Mindmap

Source: https://github.com/aipoch/medical-research-skills

When to Use

• You need to render mindmaps in offline, air-gapped, or internal-network environments where CDN access is unavailable.
• You want a zero-dependency renderer using only native HTML/CSS/JS (no third-party visualization libraries).
• You need to parse a Plain Text mindmap format into a node tree and render it locally.
• You want to stream or incrementally update mindmap content (e.g., from LLM output) and visualize it in a browser.
• You need a single-file HTML template that can be reused across projects with minimal integration overhead.

Key Features

• Local mindmap rendering using a single HTML file: assets/local-mindmap/index.html.
• Plain Text → node structure parsing (format and rules defined in the reference document).
• Customizable parsing rules and layout parameters while keeping no external library dependencies.
• Designed for streaming-friendly workflows (generate/parse/update content progressively).

Dependencies

• Python: None (no required packages at present).
• Runtime: Any modern web browser capable of running standard HTML/CSS/JS.
• External JS/CSS libraries: None (by design).

Example Usage

The following example is a complete, runnable workflow that renders a mindmap locally using the provided single-file template.

1. Create a Plain Text mindmap file (example: mindmap.txt)

Mindmap Demo
  Goals
    Offline rendering
    Zero dependencies
  Inputs
    Plain Text nodes
    LLM streaming output
  Output
    Local HTML visualization

2. Open the renderer template

• Open assets/local-mindmap/index.html in your browser.

3. Load/insert the Plain Text content

• Follow the Plain Text format and loading instructions described in:
  • references/streaming-implementation.md

Note: If you add any Python scripts under scripts/ (e.g., to transform LLM output into the Plain Text format), invoke them consistently as:

python scripts/<task_name>.py

Implementation Details

• Rendering template: The renderer is implemented as a reusable single-file HTML template:
  • assets/local-mindmap/index.html
• Data format: The mindmap structure is represented in a Plain Text specification:
  • See references/streaming-implementation.md for the exact format, examples, and constraints.
• Parsing rules: The parser converts Plain Text into a hierarchical node tree. You may adjust:
  • indentation/marker rules (to match your input style),
  • node labeling rules (to sanitize or normalize text),
  • streaming/incremental update behavior (if applicable), while preserving the no external dependency requirement.
• Layout parameters: Layout and styling are controlled within the HTML/CSS/JS template. Tune spacing, alignment, and node styling as needed, referencing:
  • references/streaming-implementation.md
• Script/config conventions (if you extend with scripts):
  • Put configuration constants at the top of each script (avoid excessive CLI flags).
  • Keep invocation consistent: python scripts/<task_name>.py.
  • If any Python packages are introduced, list them (with versions) in the Dependencies section above.

When Not to Use

• Do not use this skill when the required source data, identifiers, files, or credentials are missing.
• Do not use this skill when the user asks for fabricated results, unsupported claims, or out-of-scope conclusions.
• Do not use this skill when a simpler direct answer is more appropriate than the documented workflow.

Required Inputs

• A clearly specified task goal aligned with the documented scope.
• All required files, identifiers, parameters, or environment variables before execution.
• Any domain constraints, formatting requirements, and expected output destination if applicable.