Indexion Documentation
Audit how much of a repo’s public API is documented, prioritize gaps, and spot doc drift before shipping or growing the codebase.
Overview
indexion-documentation is an agent skill most often used in Build (also Ship, Operate) that assesses doc coverage, surfaces undocumented APIs, and helps reconcile doc drift via indexion plan and grep commands.
Install
npx skills add https://github.com/trkbt10/indexion-skills --skill indexion-documentationWhat is this skill?
- Runs `indexion plan documentation` for coverage %, per-package breakdown, and prioritized action plans
- Exports plans as GitHub issues or JSON for tracking and scripting
- Lists undocumented pub declarations via `indexion grep --undocumented`
- Detects visibility/declaration pairs (pub/fn/struct) with KGF-style tokenization for accuracy checks
- Covers evaluation side of doc lifecycle (what exists, missing, stale)—pairs with indexion-readme for authoring
- Example output cites overall coverage as a documented/total ratio with separate Functions vs Types percentages
Adoption & trust: 509 installs on skills.sh; 1 GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
You cannot tell which public symbols lack docs or whether existing documentation still matches the code after rapid changes.
Who is it for?
Solo maintainers of Rust or multi-language repos who already use or can install indexion and want measurable API documentation coverage.
Skip if: Teams that only need a one-off README template without static analysis, or projects with no indexion CLI in the workflow.
When should I use this skill?
You need to assess documentation state, find missing docs on pub items, or produce a prioritized documentation plan with indexion.
What do I get? / Deliverables
You get a coverage report, prioritized documentation plan, and targeted lists of undocumented declarations so you can fix gaps before they confuse users or agents.
- Coverage summary and per-package documentation inventory
- Prioritized documentation plan (terminal, GitHub issue, or JSON)
- File-level list of undocumented public declarations
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Documentation coverage and drift checks sit on the canonical Build shelf because they evaluate the codebase you are actively developing. The skill maps to docs subphase: coverage plans, undocumented grep, and reconcile workflows are documentation lifecycle work, not frontend or PM-only tasks.
Where it fits
After adding new pub exports, run a coverage plan to see which structs and fns still lack doc comments.
Before tagging a release, export a documentation plan as a GitHub issue so gaps block merge consciously.
When contributors report wrong docs, use plan reconcile workflows to see what drifted from the current code graph.
How it compares
Use this skill-package workflow for codebase-grounded coverage metrics, not generic “write better docs” chat prompts alone.
Common Questions / FAQ
Who is indexion-documentation for?
Indie builders and small teams who ship libraries or services and need a repeatable way to see documentation gaps and drift across packages, not just prose polish.
When should I use indexion-documentation?
During Build when API surface changes; before Ship when you want release-ready docs; during Operate when onboarding or support tickets suggest stale references—run coverage plans and undocumented grep from the repo root.
Is indexion-documentation safe to install?
It instructs the agent to run local indexion CLI commands against your workspace; review the Security Audits panel on this Prism page before trusting third-party skill sources.
SKILL.md
READMESKILL.md - Indexion Documentation
# indexion documentation — Documentation Analysis Assess documentation state and detect drift. This skill covers the **evaluation side** of the documentation lifecycle: what exists, what's missing, what's stale. For building READMEs, see `indexion-readme`. ## "What needs documentation?" ```bash # Quick coverage overview — how much of the public API is documented? indexion plan documentation --style=coverage . ``` Reports: - Overall coverage percentage (documented / total pub items) - Per-package breakdown with README presence - Functions vs types coverage split Output example: ``` Overall Coverage: 81% (2285/2806) Functions: 89%, Types: 75% ``` For a detailed plan with prioritized action items: ```bash # Full plan with priorities and package inventory indexion plan documentation . # As a GitHub Issue for tracking indexion plan documentation --format=github-issue . # JSON for scripting indexion plan documentation --format=json . ``` For a quick per-file listing of undocumented items: ```bash # Which pub declarations lack doc comments? indexion grep --undocumented src/ ``` **How detection works:** Uses KGF tokenization to find visibility keywords (`pub`, `public`, `export`) paired with declaration keywords (`fn`, `struct`, `enum`, `type`, `trait`). Associates `///` doc comments with declarations. Language-agnostic — works for any KGF-supported language. **Caveat:** `///|` marker-only comments count as "documented" even without descriptive text. Check `doc_preview` in the output for quality, not just coverage. ## "Are my docs up to date?" Detect drift between implementation code and documentation. ```bash # Full reconcile report in markdown indexion plan reconcile --format=md . ``` This compares code symbols against documentation and reports: - **Vocabulary divergence**: source code terms missing from co-located docs - **Stale docs**: code changed after docs were last updated - **Missing docs**: code modules with no documentation coverage **Read the report:** The Vocabulary Divergence table shows distance (0-100%) between code vocabulary and documentation. 90%+ distance means the README is essentially unrelated to the current code. Check the Gap Terms column for specific missing vocabulary. **Scoped checks:** ```bash # Check only package-level docs indexion plan reconcile --scope=package-docs . # Check only tree-level docs indexion plan reconcile --scope=tree-docs . # Check specific documents indexion plan reconcile --doc='docs/**/*.md' . indexion plan reconcile --doc-spec=markdown . ``` **Timestamp strategies:** ```bash # Use git commit timestamps (more accurate for collaborative projects) indexion plan reconcile --git . # Use file mtimes only (faster, no git dependency) indexion plan reconcile --mtime-only . ``` **Cache and drift:** `plan reconcile` maintains a cache at `.indexion/cache/reconcile/`. After schema changes or indexion upgrades, the cache can become stale and cause deserialization errors. Clear it: ```bash rm -rf .indexion/cache/reconcile ``` ## "Show me the dependency structure" Generate dependency diagrams for understanding module relationships. ```bash # Mermaid diagram (default — embeddable in GitHub README) indexion doc graph src/config/ # Other formats indexion doc graph --format=dot src/ # Graphviz DOT indexion doc graph --format=d2 src/ # D2 indexion doc graph --format=text src/ # ASCII text indexion doc graph --format=json src/ # Machine-readable # Custom title and output file indexion doc graph --title="KGF Dependencies" --output=deps.mmd src/kgf/ ``` ## Analysis Workflow ```bash # 1. What's the current state? indexion plan documentation --style=coverage . # 2. What specific items lack docs? indexion grep --undocumented sr