@aidemd-mcp/server 0.2.0

package/.claude/commands/aide/upgrade.md

@@ -0,0 +1,91 @@
+# /aide:upgrade — Interactive Methodology Upgrade
+
+> **Agent:** You are the orchestrator for this command. Do NOT delegate to a subagent.
+
+> **CRITICAL — read this before doing anything:**
+> This is a step-by-step wizard. You show ONE category at a time, ask ONE question using the `AskUserQuestion` tool with structured options, then STOP and wait.
+>
+> **Rules:**
+> - Never show all drifted categories at once and ask "which do you want?"
+> - Never offer "all" as an option
+> - Every pause point MUST use `AskUserQuestion` with defined options
+> - After every `AskUserQuestion`, STOP. Do not continue until the user responds.
+> - The tool writes files to disk itself — you do NOT use the Write tool for file categories
+
+Bring this project's AIDE methodology artifacts up to date with canonical by calling `aide_upgrade` and walking the user through each drifted category interactively.
+
+## Two-call pattern
+
+The tool uses a **two-call pattern**. The first call (no `category`) returns a lightweight summary. The second call (with `category`) writes files to disk and returns a manifest — no file content.
+
+## Wizard flow
+
+---
+
+### Step 1: Call `aide_upgrade` (summary)
+
+Call `aide_upgrade` with no arguments. The response is JSON with `framework` and `categories`. Each category has `files` (metadata only — no `canonicalContent`) and a `summary` with counts.
+
+If all categories have `differs: 0` and `missing: 0`, tell the user everything is current and stop.
+
+Otherwise, proceed to walk through drifted categories one at a time.
+
+---
+
+### Step 2–N: Walk through drifted categories one at a time
+
+For each category where `differs > 0` or `missing > 0`, present ONLY that category:
+
+- Name the category
+- List which files differ or are missing (use `~` for differs, `+` for missing)
+- Call `AskUserQuestion`:
+
+```
+question: "{Category} — {count} files need updating. Apply?"
+header: "{Category}"
+options:
+  - label: "Yes, update" / description: "Write the canonical versions to disk"
+  - label: "Skip" / description: "Keep current versions"
+```
+
+STOP. Wait for user response.
+
+**If the user selects "Yes":**
+1. Call `aide_upgrade` with `category` set to that category name
+2. The tool writes all differs/missing files to disk itself and returns a manifest
+3. Report what was updated (e.g., "Updated 2 files in .aide/docs/")
+
+Then move to the NEXT drifted category. Present it the same way with `AskUserQuestion`.
+
+**If the user selects "Skip":** Move to the next drifted category.
+
+**Categories that are all `matches`:** Skip silently — don't ask about them.
+
+---
+
+### Special category handling
+
+**pointer-stub:** The tool splices the canonical stub within marker boundaries, preserving user content outside the markers. This is handled by the tool during apply — just report the result.
+
+**mcp:** The manifest includes `prescription` data. Read the existing MCP config, show what would change, and call `AskUserQuestion`:
+
+```
+question: "MCP config — the aide server entry needs updating. Merge?"
+header: "MCP"
+options:
+  - label: "Yes, merge" / description: "Update the aide entry in .mcp.json"
+  - label: "Skip" / description: "Keep current MCP config"
+```
+
+On confirmation, read the config, merge the prescription, write with the Write tool. If `malformed`, tell the user and ask how to proceed.
+
+**ide:** Use `AskUserQuestion` with multiSelect. VS Code steps return an `instructions` field — execute it if confirmed. Zed is written by the tool directly.
+
+---
+
+### Final step: Summary
+
+Report what was done:
+- Files updated per category
+- Categories that were already current
+- Categories the user skipped

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TetsuKodai Group LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,88 @@
+# @aidemd-mcp/server
+
+MCP server that teaches any agent the AIDE (Autonomous Intel-Driven Engineering) methodology. When an agent connects, the tool descriptions themselves teach the convention — no config or documentation injection needed.
+
+## What is AIDE?
+
+AIDE specs are `.aide` files that live next to orchestrator code as progressive disclosure specs. They capture the domain context that code alone doesn't — strategy, research, implementation contracts, and anti-patterns.
+
+| File | Purpose |
+|------|---------|
+| `.aide` | Intent spec (default). Strategy, contracts, anti-patterns. |
+| `intent.aide` | Same as `.aide` — used only when `research.aide` exists in the same folder. |
+| `research.aide` | Raw research. Sources, data points, pattern synthesis. |
+| `todo.aide` | QA checklist. Issues found by audit agents. |
+
+## Installation
+
+Add to your MCP client config:
+
+```json
+{
+  "mcpServers": {
+    "aide": {
+      "command": "npx",
+      "args": ["@aidemd-mcp/server"]
+    }
+  }
+}
+```
+
+Or with a custom project root:
+
+```json
+{
+  "mcpServers": {
+    "aide": {
+      "command": "npx",
+      "args": ["@aidemd-mcp/server", "--root", "/path/to/project"]
+    }
+  }
+}
+```
+
+## Tools
+
+### `aide_discover`
+
+Scans the project for all `.aide` files and returns a progressive disclosure tree map. This is the flagship tool — it teaches the agent the entire module architecture at a glance.
+
+**Input:** optional `path` (subdirectory to scan)
+
+**Output:** Tree showing each spec's type, location, and summary.
+
+### `aide_read`
+
+Reads an `.aide` file with context awareness. Returns the file content, classified type, sibling specs in the same directory, and links found in the content (wikilinks, relative paths, URLs).
+
+**Input:** `path` (required)
+
+### `aide_scaffold`
+
+Creates new `.aide` files with automatic naming convention enforcement. Handles auto-rename logic — creating a `research.aide` will rename an existing `.aide` to `intent.aide`.
+
+**Input:** `directory` (required), `type` (required: `intent` | `research` | `both` | `todo`)
+
+### `aide_validate`
+
+Health check for `.aide` spec files. Detects orphaned specs, missing specs, naming conflicts, broken links, and orphaned research files.
+
+**Input:** optional `path` (subdirectory to validate)
+
+### `aide_init`
+
+Bootstrap the AIDE development environment into a project with one command. Detects the agent framework, writes the AIDE methodology into the agent's config file, scaffolds slash commands for every pipeline phase (`/aide-research`, `/aide-spec`, `/aide-synthesize`, `/aide-plan`, `/aide-build`, `/aide-qa`, `/aide-fix`, `/aide-refactor`), and wires this MCP server into the project's MCP config.
+
+Supports Claude Code, Cursor, Windsurf, and Copilot. Auto-detects from marker files or accepts an override.
+
+**Input:** optional `framework` (`claude` | `cursor` | `windsurf` | `copilot`), optional `path` (project root)
+
+Each step is idempotent — running on an already-initialized project reports what's present without overwriting.
+
+## Development
+
+```bash
+npm install
+npm run build
+npm test
+```

package/dist/cli/App/index.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import type { TreeNode } from "../../types/index.js";
+interface AppProps {
+    /** Project root to scan. */
+    root: string;
+    /** Initial shallow scan results already loaded before render. */
+    initialNodes: TreeNode[];
+}
+/**
+ * Top-level TUI orchestrator. Owns view state (tree vs drill-in) and delegates
+ * to TreePanel and DetailPanel. Handles all keyboard input.
+ */
+export default function App({ root, initialNodes }: AppProps): React.ReactElement;
+export {};

package/dist/cli/App/index.js

@@ -0,0 +1,282 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback, useEffect, useMemo } from "react";
+import { spawnSync } from "node:child_process";
+import { Box, Text, useInput, useApp, useStdout } from "ink";
+import { readFile } from "node:fs/promises";
+import flattenTree from "../../cli/flattenTree/index.js";
+import buildTreeData from "../../cli/buildTreeData/index.js";
+import TreePanel from "../../cli/TreePanel/index.js";
+import DetailPanel from "../../cli/DetailPanel/index.js";
+import parseFrontmatter from "../../util/parseFrontmatter/index.js";
+import parseBody from "../../util/parseBody/index.js";
+import scan from "../../util/scan/index.js";
+import findPrimaryIntent from "../../cli/findPrimaryIntent/index.js";
+/**
+ * Top-level TUI orchestrator. Owns view state (tree vs drill-in) and delegates
+ * to TreePanel and DetailPanel. Handles all keyboard input.
+ */
+export default function App({ root, initialNodes }) {
+    const { exit } = useApp();
+    const { stdout } = useStdout();
+    const columns = stdout?.columns ?? 80;
+    // --- Tree state ---
+    // Cache shallow results so toggling back from deep view restores them instantly.
+    const [shallowNodes] = useState(initialNodes);
+    const [treeNodes, setTreeNodes] = useState(initialNodes);
+    const [expandedDirs, setExpandedDirs] = useState(new Set());
+    const [cursorIndex, setCursorIndex] = useState(0);
+    const [searchFilter, setSearchFilter] = useState("");
+    const [isDeepView, setIsDeepView] = useState(false);
+    const [deepLoading, setDeepLoading] = useState(false);
+    // Derive flatNodes from treeNodes + expandedDirs — always in sync within the same render.
+    const flatNodes = useMemo(() => flattenTree(treeNodes, expandedDirs), [treeNodes, expandedDirs]);
+    // --- View mode ---
+    const [mode, setMode] = useState("tree");
+    // --- Drill-in state ---
+    const [drilledFile, setDrilledFile] = useState(null);
+    const [drillData, setDrillData] = useState(null);
+    const [drillCache] = useState(new Map());
+    // Single expanded section in drill-in mode; Tab cycles through sections.
+    const [expandedSection, setExpandedSection] = useState(null);
+    // --- Detail panel frontmatter (for currently selected file) ---
+    const [selectedFrontmatter, setSelectedFrontmatter] = useState(null);
+    const [fmCache] = useState(new Map());
+    /** Returns true if any file descendant of node matches the search filter. */
+    function hasMatchingDescendant(node, filter) {
+        if (node.kind === "file") {
+            const lower = filter.toLowerCase();
+            return (node.file.relativePath.toLowerCase().includes(lower) ||
+                (node.file.summary ?? "").toLowerCase().includes(lower));
+        }
+        return node.children.some((child) => hasMatchingDescendant(child, filter));
+    }
+    // Compute visible flat nodes from a single source of truth in App.
+    // Dir nodes are included when at least one of their file descendants matches.
+    // File nodes inside expanded dirs are included when they individually match.
+    const visibleNodes = searchFilter
+        ? flatNodes.filter((fn) => {
+            if (fn.node.kind === "dir") {
+                return hasMatchingDescendant(fn.node, searchFilter);
+            }
+            return (fn.node.file.relativePath.toLowerCase().includes(searchFilter.toLowerCase()) ||
+                (fn.node.file.summary ?? "").toLowerCase().includes(searchFilter.toLowerCase()));
+        })
+        : flatNodes;
+    // Clamp cursor within visible range.
+    const clampedCursor = Math.min(cursorIndex, Math.max(0, visibleNodes.length - 1));
+    // Current cursor node.
+    const cursorNode = visibleNodes[clampedCursor];
+    // Derive selectedFile: for dir nodes auto-load primary intent; for file nodes use directly.
+    const selectedFile = cursorNode
+        ? cursorNode.node.kind === "file"
+            ? cursorNode.node.file
+            : findPrimaryIntent(cursorNode.node)
+        : null;
+    // Computed booleans for the cursor's current position.
+    const cursorOnDir = cursorNode?.node.kind === "dir";
+    const cursorDirExpanded = cursorOnDir && cursorNode.node.kind === "dir" && expandedDirs.has(cursorNode.node.path);
+    // Load frontmatter for the detail panel whenever selectedFile changes.
+    useEffect(() => {
+        if (!selectedFile) {
+            setSelectedFrontmatter(null);
+            return;
+        }
+        if (fmCache.has(selectedFile.path)) {
+            setSelectedFrontmatter(fmCache.get(selectedFile.path) ?? null);
+            return;
+        }
+        readFile(selectedFile.path, "utf-8")
+            .then((content) => {
+            const { frontmatter } = parseFrontmatter(content);
+            fmCache.set(selectedFile.path, frontmatter);
+            setSelectedFrontmatter(frontmatter);
+        })
+            .catch(() => {
+            fmCache.set(selectedFile.path, null);
+            setSelectedFrontmatter(null);
+        });
+    }, [selectedFile?.path]);
+    /** Load and parse a file for drill-in view. */
+    const drillIntoFile = useCallback(async (file) => {
+        setDrilledFile(file);
+        setExpandedSection(null);
+        setMode("drill-in");
+        if (drillCache.has(file.path)) {
+            setDrillData(drillCache.get(file.path));
+            return;
+        }
+        try {
+            const content = await readFile(file.path, "utf-8");
+            const { frontmatter, body } = parseFrontmatter(content);
+            const sections = parseBody(body);
+            const data = { frontmatter, sections };
+            drillCache.set(file.path, data);
+            setDrillData(data);
+        }
+        catch {
+            setDrillData({ frontmatter: null, sections: [] });
+        }
+    }, [drillCache]);
+    /** Toggle deep view on/off, caching shallow results for instant restore. */
+    const toggleDeepView = useCallback(async () => {
+        if (isDeepView) {
+            // Restore cached shallow results — no re-scan needed.
+            setTreeNodes(shallowNodes);
+            setIsDeepView(false);
+            return;
+        }
+        setDeepLoading(true);
+        try {
+            const result = await scan(root, undefined, false);
+            const nodes = buildTreeData(result.files);
+            setTreeNodes(nodes);
+        }
+        catch {
+            // Silently keep current state on scan failure.
+        }
+        finally {
+            setDeepLoading(false);
+            setIsDeepView(true);
+        }
+    }, [isDeepView, root, shallowNodes]);
+    // --- Keyboard handling ---
+    useInput((input, key) => {
+        if (mode === "tree") {
+            if (key.upArrow) {
+                setCursorIndex((c) => Math.max(0, c - 1));
+                return;
+            }
+            if (key.downArrow) {
+                setCursorIndex((c) => Math.min(visibleNodes.length - 1, c + 1));
+                return;
+            }
+            if (key.return) {
+                if (!cursorNode)
+                    return;
+                if (cursorNode.node.kind === "dir") {
+                    const dirPath = cursorNode.node.path;
+                    const isExpanded = expandedDirs.has(dirPath);
+                    setExpandedDirs((prev) => {
+                        const next = new Set(prev);
+                        if (isExpanded) {
+                            next.delete(dirPath);
+                        }
+                        else {
+                            next.add(dirPath);
+                        }
+                        return next;
+                    });
+                    // When expanding, advance cursor to first child.
+                    if (!isExpanded) {
+                        setCursorIndex((c) => c + 1);
+                    }
+                    // When collapsing, cursor stays on the dir node (clampedCursor handles bounds).
+                }
+                else {
+                    // File node: drill in.
+                    drillIntoFile(cursorNode.node.file);
+                }
+                return;
+            }
+            if (key.tab) {
+                toggleDeepView();
+                return;
+            }
+            if (key.escape) {
+                // Priority 1: if cursor is on a file node inside an expanded dir, collapse parent.
+                if (cursorNode && cursorNode.node.kind === "file") {
+                    // Walk backward through visibleNodes to find the nearest preceding dir at shallower depth.
+                    const cursorDepth = cursorNode.depth;
+                    for (let i = clampedCursor - 1; i >= 0; i--) {
+                        const candidate = visibleNodes[i];
+                        if (candidate.node.kind === "dir" && candidate.depth < cursorDepth) {
+                            // Collapse this parent dir.
+                            const parentPath = candidate.node.path;
+                            setExpandedDirs((prev) => {
+                                const next = new Set(prev);
+                                next.delete(parentPath);
+                                return next;
+                            });
+                            setCursorIndex(i);
+                            return;
+                        }
+                    }
+                }
+                // Priority 2: if search filter non-empty, clear it.
+                if (searchFilter) {
+                    setSearchFilter("");
+                    setCursorIndex(0);
+                    return;
+                }
+                // Priority 3: exit.
+                exit();
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setSearchFilter((f) => f.slice(0, -1));
+                return;
+            }
+            // Printable characters: append to search filter.
+            if (input && !key.ctrl && !key.meta && input.length === 1) {
+                setSearchFilter((f) => f + input);
+                setCursorIndex(0);
+            }
+            return;
+        }
+        // Drill-in mode.
+        if (key.escape || key.backspace) {
+            setMode("tree");
+            setDrilledFile(null);
+            setDrillData(null);
+            return;
+        }
+        if (key.upArrow) {
+            const next = Math.max(0, clampedCursor - 1);
+            setCursorIndex(next);
+            const nextNode = visibleNodes[next];
+            const nextFile = nextNode
+                ? nextNode.node.kind === "file"
+                    ? nextNode.node.file
+                    : findPrimaryIntent(nextNode.node)
+                : null;
+            if (nextFile)
+                drillIntoFile(nextFile);
+            return;
+        }
+        if (key.downArrow) {
+            const next = Math.min(visibleNodes.length - 1, clampedCursor + 1);
+            setCursorIndex(next);
+            const nextNode = visibleNodes[next];
+            const nextFile = nextNode
+                ? nextNode.node.kind === "file"
+                    ? nextNode.node.file
+                    : findPrimaryIntent(nextNode.node)
+                : null;
+            if (nextFile)
+                drillIntoFile(nextFile);
+            return;
+        }
+        if (key.tab) {
+            const sectionCount = (drillData?.sections ?? []).filter((s) => s.heading !== "").length;
+            if (sectionCount === 0)
+                return;
+            setExpandedSection((prev) => {
+                if (prev === null)
+                    return 0;
+                if (prev >= sectionCount - 1)
+                    return null;
+                return prev + 1;
+            });
+            return;
+        }
+        if (input === "e" && drilledFile) {
+            const editor = process.env.VISUAL ?? process.env.EDITOR ?? "code";
+            spawnSync(editor, [drilledFile.path], { stdio: "inherit" });
+            return;
+        }
+        // Enter is a no-op in drill-in mode.
+    });
+    // --- Layout ---
+    const treeWidth = Math.floor(columns * 0.38);
+    return (_jsxs(Box, { flexDirection: "row", width: columns, children: [_jsxs(Box, { flexDirection: "column", width: treeWidth, borderStyle: "single", borderColor: "white", children: [_jsx(Text, { bold: true, children: " Intent Tree" }), deepLoading && _jsx(Text, { color: "yellow", children: "  Loading summaries..." }), _jsx(TreePanel, { visibleNodes: visibleNodes, cursorIndex: clampedCursor, searchFilter: searchFilter, isDeepView: isDeepView, expandedDirs: expandedDirs, cursorOnDir: cursorOnDir, cursorDirExpanded: cursorDirExpanded, width: treeWidth - 2 })] }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, borderStyle: "single", borderColor: "white", children: [_jsx(Text, { bold: true, children: " Detail" }), _jsx(DetailPanel, { file: selectedFile, frontmatter: mode === "drill-in" ? (drillData?.frontmatter ?? null) : selectedFrontmatter, mode: mode === "drill-in" ? "drill-in" : "preview", sections: drillData?.sections ?? [], expandedSection: expandedSection, drilledFilePath: drilledFile?.relativePath ?? null })] })] }));
+}

package/dist/cli/DetailPanel/index.d.ts

@@ -0,0 +1,24 @@
+import React from "react";
+import type { AideFile, AideFrontmatter, BodySection } from "../../types/index.js";
+interface DetailPanelProps {
+    file: AideFile | null;
+    frontmatter: AideFrontmatter | null;
+    /** Controls which rendering mode is active in the right panel. */
+    mode: "preview" | "drill-in";
+    /** Body sections from the drilled-in file. */
+    sections: BodySection[];
+    /** Index of the currently expanded section, or null when all are collapsed. */
+    expandedSection: number | null;
+    /** File path shown as the panel title during drill-in, or null in preview mode. */
+    drilledFilePath: string | null;
+}
+/**
+ * Right-panel component that handles both preview mode (tree navigation) and
+ * drill-in mode (formatted frontmatter card with expandable body sections).
+ *
+ * In preview mode: scope, truncated intent, and outcome counts.
+ * In drill-in mode: full frontmatter card (scope heading, full intent, side-by-side
+ * outcomes) plus expandable body sections cycled with Tab.
+ */
+export default function DetailPanel({ file, frontmatter, mode, sections, expandedSection, drilledFilePath, }: DetailPanelProps): React.ReactElement;
+export {};

package/dist/cli/DetailPanel/index.js

@@ -0,0 +1,57 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useStdout } from "ink";
+/** Truncate a string to maxLen chars, appending "..." if trimmed. */
+function truncate(s, maxLen) {
+    if (s.length <= maxLen)
+        return s;
+    return s.slice(0, maxLen - 3) + "...";
+}
+/** Bullet-point list of outcome strings. */
+function OutcomeList({ items, color }) {
+    return (_jsx(Box, { flexDirection: "column", children: items.map((item, i) => (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: color, children: "\u2022 " }), _jsx(Box, { flexGrow: 1, children: _jsx(Text, { wrap: "wrap", children: item }) })] }, i))) }));
+}
+/** Side-by-side (or stacked) outcomes display. */
+function OutcomesDisplay({ desired, undesired, wide, }) {
+    if (wide) {
+        return (_jsxs(Box, { flexDirection: "row", marginTop: 1, children: [_jsxs(Box, { flexDirection: "column", flexBasis: "50%", borderStyle: "single", borderColor: "green", paddingX: 1, marginRight: 1, children: [_jsx(Text, { bold: true, color: "green", children: "Desired Outcomes" }), _jsx(Box, { marginTop: 1, children: _jsx(OutcomeList, { items: desired, color: "green" }) })] }), _jsxs(Box, { flexDirection: "column", flexBasis: "50%", borderStyle: "single", borderColor: "red", paddingX: 1, children: [_jsx(Text, { bold: true, color: "red", children: "Undesired Outcomes" }), _jsx(Box, { marginTop: 1, children: _jsx(OutcomeList, { items: undesired, color: "red" }) })] })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "green", paddingX: 1, marginBottom: 1, children: [_jsx(Text, { bold: true, color: "green", children: "Desired Outcomes" }), _jsx(Box, { marginTop: 1, children: _jsx(OutcomeList, { items: desired, color: "green" }) })] }), _jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "red", paddingX: 1, children: [_jsx(Text, { bold: true, color: "red", children: "Undesired Outcomes" }), _jsx(Box, { marginTop: 1, children: _jsx(OutcomeList, { items: undesired, color: "red" }) })] })] }));
+}
+/**
+ * Right-panel component that handles both preview mode (tree navigation) and
+ * drill-in mode (formatted frontmatter card with expandable body sections).
+ *
+ * In preview mode: scope, truncated intent, and outcome counts.
+ * In drill-in mode: full frontmatter card (scope heading, full intent, side-by-side
+ * outcomes) plus expandable body sections cycled with Tab.
+ */
+export default function DetailPanel({ file, frontmatter, mode, sections, expandedSection, drilledFilePath, }) {
+    const { stdout } = useStdout();
+    const columns = stdout?.columns ?? 80;
+    const wide = columns >= 80;
+    // --- Preview mode ---
+    if (mode === "preview") {
+        if (!file) {
+            return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [_jsx(Text, { color: "gray", children: "Select a file to preview" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: "Type to search, [tab] for deep view" }) })] }));
+        }
+        if (!frontmatter) {
+            return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [_jsx(Text, { color: "red", children: "[FAILED TO PARSE]" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: file.relativePath }) })] }));
+        }
+        const scope = frontmatter.scope ?? "[FAILED TO PARSE]";
+        const intent = frontmatter.intent ? truncate(frontmatter.intent, 160) : "[FAILED TO PARSE]";
+        const desiredCount = frontmatter.outcomes?.desired.length ?? 0;
+        const undesiredCount = frontmatter.outcomes?.undesired.length ?? 0;
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [_jsxs(Text, { bold: true, children: ["scope: ", scope] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { wrap: "wrap", children: intent }) }), (desiredCount > 0 || undesiredCount > 0) && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { color: "green", children: ["\u2713 desired (", desiredCount, ")"] }), _jsxs(Text, { color: "red", children: ["\u2717 undesired (", undesiredCount, ")"] })] })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: "[\u2191\u2193] navigate  [enter] drill in  [tab] deep view" }) })] }));
+    }
+    // --- Drill-in mode ---
+    const title = drilledFilePath ?? "[unknown]";
+    const scope = frontmatter?.scope ?? "[FAILED TO PARSE]";
+    const intent = frontmatter?.intent ?? "[FAILED TO PARSE]";
+    const desired = frontmatter?.outcomes?.desired ?? [];
+    const undesired = frontmatter?.outcomes?.undesired ?? [];
+    const visibleSections = sections.filter((s) => s.heading !== "");
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, flexGrow: 1, children: [_jsx(Text, { bold: true, children: title }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { bold: true, children: "scope: " }), _jsx(Text, { children: scope })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { wrap: "wrap", children: intent }) }), (desired.length > 0 || undesired.length > 0) && (_jsx(OutcomesDisplay, { desired: desired, undesired: undesired, wide: wide })), visibleSections.length > 0 && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: visibleSections.map((section, i) => {
+                    const isExpanded = i === expandedSection;
+                    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { children: [isExpanded ? "▾" : "▸", " ", section.heading, !isExpanded && section.summary ? ` (${section.summary})` : ""] }), isExpanded && (_jsx(Box, { marginLeft: 2, marginTop: 1, children: _jsx(Text, { wrap: "wrap", children: section.content }) }))] }, i));
+                }) })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: "[esc] back  [tab] next section  [e] open in editor" }) })] }));
+}

package/dist/cli/TreePanel/index.d.ts

@@ -0,0 +1,24 @@
+import React from "react";
+import type { FlatNode } from "../../cli/flattenTree/index.js";
+interface TreePanelProps {
+    /** Pre-filtered visible nodes computed by App (single source of truth). */
+    visibleNodes: FlatNode[];
+    cursorIndex: number;
+    searchFilter: string;
+    isDeepView: boolean;
+    /** Set of dir paths that are currently expanded. */
+    expandedDirs: Set<string>;
+    /** True when the cursor is currently on a dir node. */
+    cursorOnDir: boolean;
+    /** True when the cursor is on a dir node that is currently expanded. */
+    cursorDirExpanded: boolean;
+    /** Available width in columns for the tree panel content. */
+    width: number;
+}
+/**
+ * Renders the left-panel tree of .aide files with cursor highlighting and optional summaries.
+ * Receives pre-filtered visibleNodes from App — manages no state and performs no filtering.
+ * Shows expand/collapse indicators on dir nodes and context-aware footer hints.
+ */
+export default function TreePanel({ visibleNodes, cursorIndex, searchFilter, isDeepView, expandedDirs, cursorOnDir, cursorDirExpanded, width, }: TreePanelProps): React.ReactElement;
+export {};