@alucify/cli 0.6.5 → 0.7.0

package/dist/docs/help/getting-started/installation.md

@@ -0,0 +1,65 @@
+---
+order: 5
+title: "Installation"
+description: "Install guides for each Alucify UI."
+---
+
+# Installation
+
+Pick the UI you want to install. You can install more than one; they all read from the same `.alucify/` project directory.
+
+## VS Code Extension
+
+Search **Alucify** in the VS Code Marketplace, or install via command line:
+
+```bash
+code --install-extension alucify.alucify
+```
+
+Full guide: [VS Code Extension Installation](../vscode/installation.md).
+
+## CLI (+ Web UI)
+
+```bash
+npm install -g @alucify/cli
+```
+
+Verify:
+```bash
+alucify --version
+```
+
+The CLI bundles the Web UI — once installed, `alucify ui` launches the browser dashboard.
+
+Full guide: [CLI Installation](../cli/installation.md).
+
+## Desktop App
+
+Download the installer for your OS:
+- macOS: `.dmg`
+- Windows: `.exe`
+- Linux: `.AppImage` or `.deb`
+
+Full guide: [Desktop Installation](../desktop/installation.md).
+
+## MCP Server (Claude Code Integration)
+
+The MCP server ships with the CLI. After installing the CLI, from any project directory run:
+
+```bash
+alucify enable        # full integration (hooks + MCP + CLAUDE.md)
+# or
+alucify mcp-install   # MCP server only
+```
+
+Full guide: [MCP Server Setup](../mcp-server/setup.md).
+
+## Prerequisites
+
+All UIs require:
+- Either a [Claude Code subscription](../concepts/authentication-modes.md#claude-code-subscription-default) or an [Anthropic API key](../concepts/authentication-modes.md#anthropic-api-key)
+- Supported OS (see [System Requirements](system-requirements.md))
+
+## After Install
+
+Once installed, run your [first analysis](first-analysis.md).

package/dist/docs/help/getting-started/key-concepts.md

@@ -0,0 +1,73 @@
+---
+order: 2
+title: "Key Concepts"
+description: "Core concepts in Alucify: code analysis, spec analysis, congruency, coverage, implementation status, and versions."
+---
+
+# Key Concepts
+
+Understanding these concepts will help you get the most out of Alucify.
+
+## Code Analysis
+
+Code analysis scans your codebase and builds a structured model of your project. It identifies:
+
+- **Interfaces** — Screens, UI components, API endpoints, and other interaction points
+- **Logic** — Business logic, workflows, services, and handler functions
+- **Schemas** — Data models, database schemas, and data structures
+
+This baseline gives Alucify (and your AI coding agents) a structured understanding of what's already built.
+
+## Specs (Specifications)
+
+Specs are the documents that describe what your project should do — PRDs, requirements documents, design files, API specifications, and any other project documentation. Alucify can import and analyze these to understand your project's intent.
+
+## Spec Analysis
+
+Spec analysis compares your specifications against your codebase. It looks at several dimensions:
+
+- **Congruency** — How well do your specs align with your code? Are there contradictions or mismatches between what's specified and what's built?
+- **Coverage** — Are all requirements implemented? Are there specs without corresponding code, or code without corresponding specs?
+- **Completeness** — Do your specs cover all the necessary dimensions? Are there missing requirements or gaps in your documentation?
+
+## AI Readiness
+
+AI Readiness is a composite score (0–100%) that summarizes how prepared your project is for AI coding. It factors in congruency, coverage, and completeness. A higher score means an AI coding agent is more likely to produce correct, aligned implementations.
+
+## Implementation Status
+
+Each component in your project can have an implementation status:
+
+- **Planned** — Specified but not yet started
+- **In Progress** — Currently being implemented
+- **Implemented** — Code has been written
+- **Tested** — Tests exist and pass
+- **Deprecated** — No longer active
+
+Alucify tracks these statuses as you analyze commits and make progress.
+
+## Versions
+
+Each time you run an analysis, Alucify saves a versioned snapshot (v1, v2, v3, etc.). This lets you track how your project evolves over time. You can compare versions to see what's changed.
+
+## Analysis Modes
+
+Alucify offers three analysis depth levels:
+
+- **Speed** — Fast, mechanical analysis. Usually 5–10 minutes. No AI costs.
+- **Balanced** — Moderate depth with AI-powered analysis. Usually 15–60 minutes.
+- **Quality** — Comprehensive AI analysis. Usually 45–90 minutes.
+
+See [Analysis Modes](../concepts/analysis-modes.md) for more detail.
+
+## AI Coding Risks
+
+Risks that Alucify identifies which could cause problems for AI coding agents — things like missing specs, conflicting requirements, high blast radius areas, and untested code paths.
+
+## Blast Radius
+
+The percentage of your project that could be affected by a change. A high blast radius means changes in one area ripple across many parts of the system. Understanding blast radius helps you and your AI agents make safer changes.
+
+## Grounding
+
+How well a component is anchored in your specifications. A component with strong grounding has clear spec references and well-defined requirements. Components with weak grounding may need better documentation before AI coding.

package/dist/docs/help/getting-started/supported-project-types.md

@@ -0,0 +1,65 @@
+---
+order: 4
+title: "Supported Project Types & Languages"
+description: "Languages, frameworks, and project structures that Alucify can analyze."
+---
+
+# Supported Project Types & Languages
+
+Alucify can analyze projects written in a wide range of languages and frameworks.
+
+## Supported Languages
+
+- TypeScript / JavaScript (including JSX/TSX)
+- Python
+- Java
+- Go
+- Rust
+- Ruby
+- C / C++
+- C#
+- Swift
+- Kotlin
+
+## Supported Spec Formats
+
+You can import specifications in many formats:
+
+### Documents
+- PDF (.pdf)
+- Markdown (.md)
+- Plain text (.txt)
+- ReStructuredText (.rst)
+- AsciiDoc (.adoc)
+
+### Data Formats
+- JSON (.json)
+- YAML (.yaml, .yml)
+- TOML (.toml)
+- XML (.xml)
+- CSV (.csv)
+
+### Images
+- PNG (.png)
+- JPG / JPEG (.jpg, .jpeg)
+- GIF (.gif)
+- SVG (.svg)
+- WebP (.webp)
+
+### Code Files
+Any of the supported language file types listed above can also be imported as specs — useful for API contracts, interface definitions, or reference implementations.
+
+## Project Structure
+
+Alucify works with any project structure. It scans your workspace root and analyzes all source files it finds. There's no required directory layout or configuration file needed to get started.
+
+## Frameworks
+
+Alucify recognizes and works well with popular frameworks including (but not limited to):
+
+- **Frontend** — React, Next.js, Vue, Angular, Svelte
+- **Backend** — Express, Django, Rails, Spring Boot, FastAPI
+- **Mobile** — React Native, Swift/SwiftUI, Kotlin/Jetpack Compose
+- **Full Stack** — Next.js, Remix, Nuxt
+
+The analysis automatically detects your tech stack and displays it in the Code Analysis tab.

package/dist/docs/help/getting-started/system-requirements.md

@@ -0,0 +1,61 @@
+---
+order: 3
+title: "System Requirements & Prerequisites"
+description: "What you need to run Alucify: VS Code version, Claude access, and supported platforms."
+---
+
+# System Requirements & Prerequisites
+
+## VS Code Extension
+
+- **VS Code** version 1.85.0 or later
+- **Operating System** — macOS, Windows, or Linux (any platform VS Code supports)
+- **Claude Access** — One of:
+  - An Anthropic API key (pay-per-use), or
+  - A Claude Code / Claude Max subscription
+
+## CLI
+
+- **Node.js** version 18 or later
+- **npm** (comes with Node.js)
+- **Claude Access** — Same options as above (API key or Claude Code subscription)
+
+## MCP Server
+
+- **Claude Code** installed and configured
+- An existing Alucify analysis (run `analyze-code` first)
+
+## Desktop App
+
+- **macOS** with **Apple Silicon** (M1 or later). Intel Macs are not currently supported.
+- **Claude Access** — Same options as the Extension/CLI (API key or Claude Code subscription)
+
+## Claude Access Options
+
+Alucify uses Claude to power its AI analysis. You have two options:
+
+### Anthropic API Key
+
+Pay per token using your own API key. You'll need to:
+
+1. Create an account at [console.anthropic.com](https://console.anthropic.com)
+2. Generate an API key
+3. Enter the key in Alucify's welcome screen or via the CLI
+
+Cost varies by analysis mode and project size. Speed mode (catalog) is free — it uses mechanical analysis with no AI calls.
+
+### Claude Code / Claude Max Subscription
+
+Use your existing Claude Code or Claude Max subscription. This requires:
+
+1. Claude Code CLI installed on your machine
+2. An active Claude Code or Claude Max subscription
+3. The CLI authenticated and ready to use
+
+This option uses your subscription's included usage rather than per-token billing.
+
+## Network Requirements
+
+- Internet connection required for AI-powered analysis (Balanced and Quality modes)
+- Speed mode works offline (mechanical analysis only)
+- Outdated package detection requires internet access

package/dist/docs/help/integrations/_meta.json

@@ -0,0 +1 @@
+{ "title": "Integrations", "order": 7 }

package/dist/docs/help/integrations/ci-cd.md

@@ -0,0 +1,95 @@
+---
+order: 4
+title: "CI/CD Integration"
+description: "Running Alucify in continuous integration."
+---
+
+# CI/CD Integration
+
+Alucify can run in CI to enforce quality gates, produce analysis artifacts, or keep a centralized AppGraph up to date. All commands support `--json` output for parsing in scripts.
+
+## Prerequisites
+
+- An API key (`alucify --auth apiKey --api-key $ANTHROPIC_API_KEY`) or the Claude Code CLI installed in the CI image
+- Node.js 18+ (or whatever the current Alucify runtime requires — check [System Requirements](../getting-started/system-requirements.md))
+- Git history available (run `actions/checkout@v4` with `fetch-depth: 0` on GitHub Actions)
+
+## Common Patterns
+
+### Gate PRs on Congruency Drop
+
+```yaml
+- name: Analyze code
+  run: alucify analyze-code --mode catalog
+- name: Analyze specs
+  run: alucify analyze-specs --mode catalog
+- name: Check scores
+  run: |
+    score=$(alucify status --json | jq '.congruency')
+    if [ "$score" -lt 70 ]; then
+      echo "Congruency dropped below 70"
+      exit 1
+    fi
+```
+
+### Post Risk Summary to PR
+
+```yaml
+- name: Analyze
+  run: alucify analyze-specs --mode catalog
+- name: Summary
+  run: alucify status --json > status.json
+- name: Post PR comment
+  uses: actions/github-script@v7
+  with:
+    script: |
+      const data = require('./status.json');
+      const body = `## Alucify\n- Congruency: ${data.congruency}%\n- Risks: ${data.risks.total}`;
+      github.rest.issues.createComment({
+        issue_number: context.issue.number,
+        owner: context.repo.owner,
+        repo: context.repo.repo,
+        body,
+      });
+```
+
+### Track Token Spend per Build
+
+```yaml
+- run: alucify analyze-code --mode catalog
+- run: alucify usage --json >> /tmp/usage.jsonl
+- uses: actions/upload-artifact@v4
+  with:
+    name: alucify-usage
+    path: /tmp/usage.jsonl
+```
+
+## Auth in CI
+
+Prefer API key mode in CI. It doesn't require the Claude Code CLI or an interactive session.
+
+```bash
+alucify --auth apiKey --api-key "$ANTHROPIC_API_KEY" analyze-code --mode catalog
+```
+
+Store the API key as a CI secret (`ANTHROPIC_API_KEY`), never commit it.
+
+## Cost Control
+
+- **Use catalog mode in CI** — free, fast, deterministic. Heavier modes (Fast, Full) are better run locally or scheduled.
+- **Cache `.alucify/`** between CI runs — preserves version history and enables incremental analysis.
+- **Scheduled deep analyses** — run Full mode nightly rather than per-PR; use CI for quick gates only.
+
+## Exit Codes
+
+- `0` — success
+- `1` — runtime error (bad args, missing deps)
+
+Quality gates (congruency below X, coverage below Y) aren't exit-code-driven — read them out of `alucify status --json` and fail your CI step yourself, as in the gate example above.
+
+## See Also
+
+- [CLI Automation](../cli/automation.md)
+- [`alucify analyze-code`](../cli/commands/analyze-code.md)
+- [`alucify analyze-specs`](../cli/commands/analyze-specs.md)
+- [`alucify status`](../cli/commands/status.md)

package/dist/docs/help/integrations/claude-code-hooks.md

@@ -0,0 +1,54 @@
+---
+order: 3
+title: "Claude Code Session Hooks"
+description: "The Claude Code hooks Alucify uses for context injection and intent capture."
+---
+
+# Claude Code Session Hooks
+
+Separate from git hooks (which fire on commits), Alucify also installs hooks into your Claude Code configuration. These fire at session boundaries and key events inside Claude Code.
+
+## What Gets Installed
+
+When you run [`alucify enable`](../cli/commands/enable-disable.md), entries are added to `.claude/settings.json` in your project:
+
+- **SessionStart** — inject AppGraph context when a new Claude Code session opens
+- **UserPromptSubmit** — enrich certain prompts with relevant AppGraph excerpts
+- **SubagentStart** — share context with spawned subagents
+- **SessionEnd** — stage session transcripts for [intent capture](../concepts/intent-capture.md)
+
+All hooks are marker-scoped and idempotent — safe to add to an existing `.claude/settings.json`.
+
+## What Each Hook Does
+
+### SessionStart
+Runs a one-shot command that emits an AppGraph summary into Claude's context. Output includes node counts, current scores, and open high-severity risks. Total payload is typically ~500 tokens.
+
+### UserPromptSubmit
+For certain prompts (those that appear to be planning or implementation-related), runs a pre-filter that fetches relevant AppGraph excerpts and prepends them to the prompt. Keeps Claude grounded without bloating every message.
+
+### SubagentStart
+When Claude Code spawns a subagent for a multi-step task, the subagent inherits the AppGraph context from its parent. This hook ensures the subagent starts with the same grounding.
+
+### SessionEnd
+Stages the session transcript in a pending state. A background polling process reads staged sessions and runs intent capture against them. See [Intent Capture](../concepts/intent-capture.md).
+
+## Turning Off Individual Hooks
+
+Edit `.claude/settings.json` and comment out or remove specific hook entries. You can keep some (e.g., SessionStart for context injection) while disabling others (e.g., SessionEnd for intent capture).
+
+## Lightweight Alternative
+
+If you only want the MCP tools without session hooks, use [`alucify mcp-install`](../cli/commands/mcp-install.md) instead of `enable`. That skips all Claude Code hooks.
+
+## Debugging
+
+If hooks don't appear to be firing, check:
+- `.claude/settings.json` contains the Alucify hook entries (look for `alucify:` markers)
+- Claude Code version supports the hook mechanism (requires recent CLI version)
+- Run `alucify enable` again to repair any missing entries (safe and idempotent)
+
+## See Also
+
+- [Claude Code Integration](claude-code.md) — the full integration picture
+- [Intent Capture](../concepts/intent-capture.md) — what SessionEnd feeds

package/dist/docs/help/integrations/claude-code.md

@@ -0,0 +1,123 @@
+---
+order: 1
+title: "Claude Code Integration"
+description: "What Alucify installs into your Claude Code environment, how the pieces fit together, and what each one does."
+---
+
+# Claude Code Integration
+
+When you run `alucify enable` (or toggle the integration in VS Code), Alucify installs four components that give Claude Code structured awareness of your project. Each serves a distinct purpose — together they form a feedback loop that helps Claude plan with real architecture context, implement against actual requirements, and track progress automatically.
+
+## What Gets Installed
+
+| Component | File | Purpose |
+|-----------|------|---------|
+| CLAUDE.md instructions | `CLAUDE.md` | Teaches Claude what the appgraph is and when to use it |
+| Hooks | `.claude/settings.json` | Injects context at key moments (planning, task creation, subagent start) |
+| MCP server | `.mcp.json` | Gives Claude tools to query your project's architecture on demand |
+| Git hooks | `.git/hooks/pre-commit` + `post-commit` | Analyzes commits against the appgraph for progress tracking |
+
+All installations are marker-based and idempotent — running `enable` multiple times is safe, and `disable` cleanly removes everything while preserving your analysis data.
+
+## CLAUDE.md Instructions
+
+**What it is:** A small section (~200 tokens) added to your project's `CLAUDE.md` file, delimited by `<!-- alucify:appgraph:start -->` / `<!-- alucify:appgraph:end -->` markers.
+
+**What it does:** Teaches Claude the mental model of your project's appgraph — the node type system (requirements, interfaces, schemas, logic, validations), how they connect via edges, and rules for when to query the architecture. For example: "Before planning features, call `query_context()` to find existing components" and "Call `trace_dependencies()` before cross-cutting changes to check blast radius."
+
+**Why it matters:** Without these instructions, Claude has MCP tools available but doesn't know *when* to use them. The instructions bridge that gap — they're always loaded, never go stale (they contain rules, not data), and work regardless of how large your project is.
+
+## Hooks
+
+**What they are:** Entries in `.claude/settings.json` that run automatically when Claude Code reaches specific moments in its workflow.
+
+**What they do:** Each hook injects a small, targeted piece of context:
+
+| Hook | When it fires | What it injects |
+|------|---------------|-----------------|
+| **EnterPlanMode** | When Claude enters formal planning | Unimplemented requirements with validation status, plus a step-by-step exploration workflow |
+| **ExitPlanMode** | When Claude finishes a plan, before presenting it | Validation warnings — missing dependencies, uncovered acceptance criteria, nodes referenced but not addressed |
+| **TodoWrite** | When Claude creates or updates tasks | Per-task context — related appgraph nodes, blast radius, acceptance criteria from validation nodes |
+
+**Why they matter:** Hooks deliver the right context at the right time without dumping your entire architecture into every conversation. The planning hooks ensure Claude's plans account for real dependencies and requirements. Task hooks give each implementation step the specific context it needs.
+
+**Note:** Not every Claude Code interaction uses all hooks. For simple tasks like bug fixes, only CLAUDE.md rules are active — Claude won't enter plan mode for a one-line fix, and that's the right behavior. The planning and task hooks activate naturally when Claude tackles more complex work.
+
+## MCP Server
+
+**What it is:** A lightweight server that starts as a subprocess when Claude Code connects. It reads your `.alucify/` analysis data and exposes it through tools and resources.
+
+**What it does:** Gives Claude on-demand access to your project's architecture:
+
+| Tool | What it answers |
+|------|-----------------|
+| `query_context` | "What screens exist?" "Find anything related to auth" "What's still planned?" |
+| `get_context` | Full detail on a specific node — UI structure, data model, state machines, connected nodes |
+| `trace_dependencies` | "If I change this file, what else is affected?" — blast radius analysis |
+| `get_remaining_work` | Unimplemented requirements, untested validations, orphaned nodes |
+| `get_implementation_tasks` | Per-requirement task list with gap notes and untested validations — used by `/alucify-plan` |
+| `link_context` | Link a node to its implementation file so progress tracking can find it |
+| `verify_plan` | Mechanically validate a plan's appgraph references before presenting it |
+| `find_similar_context` | "Is there already a concept called X?" — terminology grounding for artifact drafting |
+| `diff_context` | What changed between two analysis versions |
+| `get_analysis` | Congruency, coverage, or quality report summaries |
+
+**Why it matters:** The MCP server is the primary data source — it's where the actual architecture knowledge lives. The CLAUDE.md instructions teach Claude *when* to query, the hooks *nudge* Claude with summaries, but the MCP tools *provide the data*. This keeps the design scale-independent: a 50-node project and a 5,000-node project work identically because Claude queries what it needs rather than receiving everything upfront.
+
+All tools are read-only except `link_context`, which updates a node's file reference for progress tracking.
+
+## Git Hooks (Pre-Commit + Post-Commit)
+
+**What they are:** Two hooks in `.git/hooks/` that work together to analyze every commit.
+
+**How they work:**
+
+1. **Pre-commit hook** (synchronous, ≤15s timeout): Runs `alucify analyze-progress --pre-commit` to classify staged files against the appgraph using a single LLM call. On success, the analysis output (updated appgraph, version snapshot) is staged into the same commit — so everything lands in a single atomic commit with zero leftover files.
+
+2. **Post-commit hook** (async fallback): Only runs if the pre-commit analysis timed out or failed. In that case, it runs the full async analysis in the background, and the results are auto-staged into the *next* commit by the pre-commit hook.
+
+**Why they matter:** This closes the loop. The other three components help Claude *plan and write* code with architecture awareness. The git hooks track *what was actually built*, so you can see progress against your requirements without manual bookkeeping — and without requiring a second commit.
+
+## How They Work Together
+
+Here's the flow across a typical development session:
+
+```
+Session starts
+  └─ CLAUDE.md loaded → Claude knows the node types and when to query
+
+You ask Claude to plan a feature
+  └─ EnterPlanMode hook → "Here's what's unfinished: nr00045 (0/3 tested)..."
+  └─ Claude calls MCP tools → query_context, get_context, trace_dependencies
+  └─ ExitPlanMode hook → "⚠ ProjectDetail also depends on this schema"
+  └─ Claude presents plan with node IDs and dependency warnings
+
+You approve, Claude implements
+  └─ TodoWrite hook → per-task blast radius + acceptance criteria
+  └─ Claude calls link_context → links nodes to implementation files
+  └─ Claude edits files
+
+You commit
+  └─ Git hook captures changed files
+  └─ analyze-progress matches commits to nodes → statuses update
+```
+
+For simpler tasks (bug fixes, refactors), Claude skips the planning hooks entirely and works with just the baseline — CLAUDE.md rules and MCP tools available if needed.
+
+## `enable` vs `mcp-install`
+
+If you don't need the full integration — for example, you're consuming an appgraph a teammate built and just want Claude to be able to query it — you can install only the MCP server:
+
+```bash
+alucify mcp-install --with-rules
+```
+
+This gives you the MCP server and CLAUDE.md instructions but skips hooks and commit tracking. See [MCP Server Setup](../mcp-server/setup.md) for details.
+
+| | `enable` | `mcp-install --with-rules` |
+|---|---|---|
+| MCP server (query tools) | Yes | Yes |
+| CLAUDE.md instructions | Yes | Yes |
+| Hooks (session, planning, tasks) | Yes | No |
+| Git hook (commit tracking) | Yes | No |
+| Best for | Running analysis + developing | Consuming a teammate's analysis |

package/dist/docs/help/integrations/git-hooks.md

@@ -0,0 +1,64 @@
+---
+order: 2
+title: "Git Hooks"
+description: "The pre-commit and post-commit hooks Alucify installs for automatic progress tracking."
+---
+
+# Git Hooks
+
+`alucify enable` installs two git hooks that keep your AppGraph's progress tracking in sync with your commits — automatically.
+
+## Pre-Commit Hook
+
+**File:** `.git/hooks/pre-commit`
+**Runs:** `alucify analyze-progress --pre-commit` with a ≤15s timeout
+
+**What it does:**
+- Classifies staged files synchronously against the AppGraph
+- On success, writes an analysis + version snapshot to `.alucify/` and stages it alongside your commit
+- On timeout or failure, writes nothing — the post-commit hook handles it async instead
+
+**It never blocks your commit.** The hook always exits 0 regardless of analysis outcome, so a slow or broken analysis can't stop you from committing. Quality signals (new risks, coverage drops) are informational, surfaced in the UI — not blocking at the git layer.
+
+## Post-Commit Hook
+
+**File:** `.git/hooks/post-commit`
+**Runs:** `alucify analyze-progress --commit HEAD` in the background
+
+**What it does:**
+- Reads the just-landed commit
+- Updates AppGraph node statuses (planned → in_progress → implemented)
+- Writes gap notes for nodes that are partially implemented
+- Appends to the commit log in `.alucify/progress/`
+
+**It runs async.** Your commit completes immediately; the analysis runs in the background and notifies when done (if OS notifications are on).
+
+## What's Analyzed
+
+Both hooks only look at files in the AppGraph scope:
+- Source files (based on detected languages)
+- Spec files (if staged at the same time)
+
+Files outside the scope (CI configs, asset binaries, docs) are skipped.
+
+## Token Cost
+
+Both hooks consume tokens when they invoke LLM-backed classification. Actual cost scales with commit size and which analysis mode your project uses. See [Token Usage](../concepts/token-usage.md) for tracking your spend.
+
+## Skipping Hooks
+
+If you need to commit without running the hooks:
+
+```bash
+git commit --no-verify -m "..."
+```
+
+This skips both pre-commit and post-commit. Use sparingly — it bypasses all your project's other hooks too.
+
+## Uninstalling
+
+Run `alucify disable` to cleanly remove both hooks. The hook files are marker-scoped, so uninstalling preserves any custom hook code you've added alongside Alucify's.
+
+## Conflict with Existing Hooks
+
+If you already have custom pre-commit or post-commit hooks, Alucify prepends its logic with a marker block. Your existing hook content is preserved. See [Claude Code Integration](claude-code.md) for the full marker scheme.

package/dist/docs/help/mcp-server/_meta.json

@@ -0,0 +1 @@
+{ "title": "MCP Server", "order": 6 }

package/dist/docs/help/mcp-server/quickstart.md

@@ -0,0 +1,59 @@
+---
+order: 1
+title: "MCP Server Quick Start"
+description: "Get the Alucify MCP server running with Claude Code in under 5 minutes."
+---
+
+# MCP Server Quick Start
+
+The Alucify MCP server gives Claude Code direct access to your project analysis, so it can make informed decisions about architecture, impact, and requirements while coding.
+
+## 1. Analyze Your Project First
+
+You need analysis results before the MCP server has anything to serve:
+
+```bash
+alucify analyze-code
+```
+
+Optionally add and analyze specs:
+
+```bash
+alucify add-spec requirements.pdf
+alucify analyze-specs
+```
+
+## 2. Enable the Integration
+
+The easiest way to set up the MCP server:
+
+```bash
+alucify enable
+```
+
+This registers the MCP server in your `.mcp.json` file and installs Claude Code hooks.
+
+## 3. Use Claude Code
+
+Start a Claude Code session in your project. Claude Code now has access to tools that query your project analysis:
+
+- **Search** your project for components by type, name, or status
+- **Get details** on any specific component
+- **Check impact** before committing changes
+- **Find gaps** in requirement coverage
+- **Compare versions** to see how the project evolved
+
+## Example Interaction
+
+In a Claude Code session, you might ask:
+
+> "What screens exist in this project?"
+> "What's the blast radius if I modify src/models/user.ts?"
+> "What requirements haven't been implemented yet?"
+
+Claude Code will automatically use the MCP tools to answer using your project analysis.
+
+## What's Next?
+
+- [Setting Up the MCP Server](setup.md) — Alternative setup options
+- [MCP Tools Reference](tools/query.md) — All tools explained

package/dist/docs/help/mcp-server/resources/_meta.json

@@ -0,0 +1 @@
+{ "title": "Resources", "order": 4 }