feat: agent intelligence roadmap phases 3-6 + parser ignore tests

Phases 3-6: process tracing, community detection, persistence,
impact analysis, MCP tools/prompts, UI enhancements (file tree,
search, staleness), CLI persistence (--index/--force/--status/--clean),
per-symbol PageRank/betweenness, BM25 search, symbol disambiguation.

Parser: +9 tests for gitignore filtering, .git skip, broken symlinks.

171 tests passing, 0 failures.

Author: bntvllnt

app/api/meta/route.ts

@@ -1,6 +1,13 @@
 import { NextResponse } from "next/server";
-import { getProjectName } from "@/src/server/graph-store";
+import { getProjectName, getIndexedHead } from "@/src/server/graph-store";
 
 export function GET(): NextResponse {
-  return NextResponse.json({ projectName: getProjectName() });
+  const indexedHash = getIndexedHead();
+  return NextResponse.json({
+    projectName: getProjectName(),
+    staleness: {
+      stale: false,
+      indexedHash,
+    },
+  });
 }

app/api/processes/route.ts

@@ -0,0 +1,14 @@
+import { NextResponse } from "next/server";
+import { getGraph } from "@/src/server/graph-store";
+
+export function GET(): NextResponse {
+  const graph = getGraph();
+
+  return NextResponse.json({
+    processes: graph.processes,
+    stats: {
+      totalProcesses: graph.processes.length,
+      maxDepth: graph.processes.reduce((max, p) => Math.max(max, p.depth), 0),
+    },
+  });
+}

app/api/search/route.ts

@@ -0,0 +1,36 @@
+import { NextResponse } from "next/server";
+import { getGraph } from "@/src/server/graph-store";
+import { createSearchIndex, search, getSuggestions } from "@/src/search/index";
+
+export function GET(request: Request): NextResponse {
+  const url = new URL(request.url);
+  const query = url.searchParams.get("q") ?? "";
+  const limitParam = url.searchParams.get("limit");
+  const limit = limitParam ? Math.min(Math.max(parseInt(limitParam, 10), 1), 100) : 20;
+
+  if (!query) {
+    return NextResponse.json({ error: "Missing query parameter 'q'" }, { status: 400 });
+  }
+
+  const graph = getGraph();
+  const index = createSearchIndex(graph);
+  const results = search(index, query, limit);
+
+  if (results.length === 0) {
+    const suggestions = getSuggestions(index, query);
+    return NextResponse.json({ query, results: [], suggestions });
+  }
+
+  const mapped = results.map((r) => ({
+    file: r.file,
+    score: r.score,
+    symbols: r.symbols.map((s) => ({
+      name: s.name,
+      type: s.type,
+      loc: s.loc,
+      relevance: s.score,
+    })),
+  }));
+
+  return NextResponse.json({ query, results: mapped });
+}

app/api/symbols/[name]/route.ts

@@ -0,0 +1,68 @@
+import { NextResponse } from "next/server";
+import { getGraph } from "@/src/server/graph-store";
+import { getHints } from "@/src/mcp/hints";
+
+export function GET(
+  _request: Request,
+  { params }: { params: Promise<{ name: string }> },
+): Promise<NextResponse> {
+  return params.then(({ name: symbolName }) => {
+    const graph = getGraph();
+
+    const matches = [...graph.symbolMetrics.values()].filter(
+      (m) => m.name === symbolName || m.symbolId.endsWith(`::${symbolName}`),
+    );
+
+    if (matches.length === 0) {
+      return NextResponse.json(
+        { error: `Symbol not found: ${symbolName}` },
+        { status: 404 },
+      );
+    }
+
+    const uniqueByFile = new Map<string, typeof matches[0]>();
+    for (const m of matches) {
+      if (!uniqueByFile.has(m.file)) {
+        uniqueByFile.set(m.file, m);
+      }
+    }
+    let deduped = [...uniqueByFile.values()];
+
+    if (deduped.length > 1) {
+      const nonBarrel = deduped.filter((m) => !m.file.endsWith("/index.ts") && m.file !== "index.ts");
+      if (nonBarrel.length > 0) deduped = nonBarrel;
+    }
+
+    if (deduped.length > 1) {
+      return NextResponse.json({
+        disambiguation: deduped.map((m) => ({
+          name: m.name,
+          file: m.file,
+          symbolId: m.symbolId,
+          fanIn: m.fanIn,
+          fanOut: m.fanOut,
+        })),
+      });
+    }
+
+    const sym = deduped[0];
+
+    const callers = graph.callEdges
+      .filter((e) => e.calleeSymbol === symbolName || e.target === sym.symbolId)
+      .map((e) => ({ symbol: e.callerSymbol, file: e.source.split("::")[0] }));
+
+    const callees = graph.callEdges
+      .filter((e) => e.callerSymbol === symbolName || e.source === sym.symbolId)
+      .map((e) => ({ symbol: e.calleeSymbol, file: e.target.split("::")[0] }));
+
+    return NextResponse.json({
+      name: sym.name,
+      file: sym.file,
+      fanIn: sym.fanIn,
+      fanOut: sym.fanOut,
+      callers,
+      callees,
+      nextSteps: getHints("symbol_context"),
+    });
+  });
+}

app/page.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import { useState } from "react";
 import { GraphProvider, useGraphContext } from "@/components/graph-provider";
 import { GraphCanvas } from "@/components/graph-canvas";
 import { ProjectBar } from "@/components/project-bar";
@@ -8,13 +9,16 @@ import { SearchInput } from "@/components/search-input";
 import { DetailPanel } from "@/components/detail-panel";
 import { SettingsPanel } from "@/components/settings-panel";
 import { Legend } from "@/components/legend";
+import { FileTree } from "@/components/file-tree";
+import { StaleBanner } from "@/components/stale-banner";
 
 function App(): React.ReactElement | null {
   const {
     graphData,
     forceData,
     groupData,
     projectName,
+    staleness,
     isLoading,
     error,
     config,
@@ -30,6 +34,8 @@ function App(): React.ReactElement | null {
     handleSearch,
   } = useGraphContext();
 
+  const [fileTreeOpen, setFileTreeOpen] = useState(false);
+
   if (error) {
     return (
       <div className="w-screen h-screen flex items-center justify-center">
@@ -50,9 +56,16 @@ function App(): React.ReactElement | null {
 
   return (
     <>
+      <StaleBanner staleness={staleness} />
       <ProjectBar projectName={projectName} graphData={graphData} forceData={forceData} />
       <ViewTabs current={currentView} onChange={setCurrentView} />
-      <SearchInput nodes={graphData.nodes} onSearch={handleSearch} />
+      <SearchInput onSearch={handleSearch} />
+      <FileTree
+        nodes={graphData.nodes}
+        onSelect={handleSearch}
+        isOpen={fileTreeOpen}
+        onTogglePanel={() => { setFileTreeOpen((prev) => !prev); }}
+      />
       <GraphCanvas
         nodes={graphData.nodes}
         edges={graphData.edges}