This tool is read-only: it reads only .py files and README.md files within
the repository boundary. File creation, editing, deletion, and shell execution
are not available through this server.

Returns a dict with:
- path (str): normalized manifest-relative path
- content (str): file text, possibly truncated
- truncated (bool): true when the file exceeded max_chars
- notice (str | null): truncation message with the current limit and maximum,
  or null when content was not truncated

Raises AccessError when the path escapes the repository root, points to a
non-existent file, or refers to a disallowed file type (not .py or README.md).

Call get_algorithm_summary first to confirm relevance before fetching full
source. Call search_algorithms or get_manifest to discover valid paths.

For paths in the manifest, returns all metadata fields:
- path, title, category, concepts, visual_use, good_for, complexity, dependencies
- readme_excerpt: first ~6 non-empty lines of the nearest README.md (up to 1200
  chars) when a README.md exists in the same directory

For paths not in the manifest, returns a minimal summary derived from the file
path (title inferred from directory name, category from the first path segment)
plus readme_excerpt when available.

This tool never returns source code — call get_algorithm for that. Use this
tool to assess relevance before committing to a full source fetch. It is
cheaper in context than get_algorithm for files you may not end up using.

The manifest contains an 'entries' array. Each entry includes:
- path (str): manifest-relative path to the source file (e.g. 'physics/wave/wave.py')
- title (str): human-readable algorithm name
- category (str): domain (physics, steering_behaviors, genetic_algorithms,
  neuro_evolution, fractals, cellular_automata, mathematical, tiling_patterns,
  research, simulation, shader)
- concepts (list[str]): key algorithmic concepts demonstrated
- visual_use (str): one-line description of the visual output
- good_for (list[str]): suggested use-cases and aesthetic tags
- complexity (str): 'low', 'medium', or 'high'
- dependencies (list[str]): required Python packages beyond py5

This tool is read-only and returns cached data for the current session.
Prefer search_algorithms for filtered discovery. Use get_manifest when you
need the full entry list or want to enumerate all available categories.

Returns a dict with:
- intent (str): the original intent string
- combinations (list): ranked list of layered recipes
- tip (str): guidance for following up on returned paths

Each combination includes:
- name (str): recipe name
- description (str): recipe description
- moods (list[str]): associated creative moods
- layers (list): each layer has role (str), query (str), and suggestions
  (list of manifest entries resolved by search_algorithms)

Layer roles describe compositional function (e.g. background, agents, texture,
overlay). Suggestions are live manifest entries — use get_algorithm_summary or
get_algorithm on any suggested path for full details.

Use this tool to plan layered generative artworks from a text description.
It combines curated recipes with dynamic algorithm lookup per layer.

Returns a list of manifest entries sorted by relevance score. Each entry includes
path, title, category, concepts, visual_use, good_for, complexity, and dependencies.
Returns an empty list when no entries match — this is not an error.

This tool returns manifest metadata only; it never reads source files.
Synonym expansion is applied automatically so queries like 'flow' also match
'fluid' and 'stream'. Combining query with category narrows results to a
specific domain.

Recommended workflow: call this tool for discovery, then get_algorithm_summary
for short context on candidates, then get_algorithm only for paths you intend
to use.

Returns a dict with:
- mood (str): the normalized mood used for the query
- style (str | null): the style refinement if provided
- profile_summary (dict): the mood's associated categories and key concepts
- results (list): ranked manifest entries matching the mood

Each mood maps to a curated set of algorithm categories, concepts, and good_for
tags. The style parameter re-ranks results by matching its tokens against all
metadata fields. When the mood is unrecognized, returns an error dict containing
'error', 'available_moods', and a 'tip'.

Prefer search_algorithms for free-text queries without a clear aesthetic direction.
Use this tool when you have a specific visual mood in mind (e.g. 'cosmic',
'minimal', 'chaotic').

Available moods: ethereal, chaotic, geometric, organic, cosmic, minimal,
generative, retro, crystalline, topological, networked, geological.