@vpxa/aikit 0.1.59 → 0.1.61

package/README.md

@@ -4,10 +4,16 @@ Local-first AI developer toolkit — knowledge base, code analysis, context mana
 
 ## Features
 
-- **67 MCP tools** for AI agents to search, analyze, and manipulate codebases
+- **82 MCP tools** for AI agents to search, analyze, and manipulate codebases
 - **47 CLI commands** for shell-based interaction
 - **Local-first** — ONNX embeddings, LanceDB vector store, no cloud dependencies
 - **Three interfaces**: MCP (for agent IDEs), CLI (for terminal agents), and programmatic API
+- **Tool profiles** — `full`, `safe`, `research`, `minimal`, `discovery` presets to control which tools are exposed
+- **Meta-tool discovery** — `list_tools`, `describe_tool`, `search_tools` for token-efficient tool exploration
+- **Pluggable flows** — `aikit:basic` and `aikit:advanced` built-in, plus custom team flows with 10 flow management tools
+- **Session digest** — auto-capture session activity for handoff between agents or sessions
+- **Middleware pipeline** — extensible plugin hooks for tool execution customization
+- **Pluggable memory** — adapter interface for curated knowledge storage backends
 
 ## What This Is
 
@@ -22,8 +28,14 @@ This is an **MCP (Model Context Protocol) server** that gives AI agents:
 7. **Knowledge graph** — auto-populated SQLite graph of modules, symbols, and import relationships with traversal, neighbor queries, and change impact tracking
 8. **Graph auto-population** — during indexing, a lightweight regex extractor builds the knowledge graph automatically from TS/JS source files (functions, classes, interfaces, types, imports)
 9. **Optimized reindex** — full reindex skips redundant hash checks, batches graph writes (flush every 50 files), and skips per-file graph deletes when bulk-cleared
+10. **Tool profiles** — five built-in profiles (`full`, `safe`, `research`, `minimal`, `discovery`) that control which subset of 82 tools are exposed, reducing token overhead for focused tasks
+11. **Meta-tools** — `list_tools`, `describe_tool`, and `search_tools` for incremental tool discovery without loading full descriptions (~200 tokens vs ~3000)
+12. **Pluggable flow system** — built-in `basic` and `advanced` development flows plus custom flow support with 10 flow management tools (`flow_list`, `flow_start`, `flow_step`, etc.)
+13. **Session digest** — auto-capture session decisions, files touched, and checkpoint state for seamless agent handoffs
+14. **Middleware pipeline** — plugin hook system for extending tool execution with pre/post processing, logging, or custom validation
+15. **Pluggable memory providers** — adapter interface for curated knowledge storage, supporting filesystem (default) and custom backends
 
-The AI Kit auto-indexes configured source directories on startup, stores embeddings in a local LanceDB vector store, and exposes everything through 67 MCP tools, 45 CLI commands, and 2 resources.
+The AI Kit auto-indexes configured source directories on startup, stores embeddings in a local LanceDB vector store, and exposes everything through 82 MCP tools, 47 CLI commands, and 2 resources.
 
 ---
 
@@ -131,6 +143,7 @@ Tools supporting `workspaces` param: `search`, `find`, `symbol`.
 | `aikit_stash` | `aikit stash` | Named key-value store |
 | `aikit_checkpoint` | `aikit checkpoint` | Session checkpoint save/restore |
 | `aikit_parse_output` | `aikit parse-output` | Parse build tool output (tsc, vitest, biome) |
+| `aikit_session_digest` | `aikit session-digest` | Auto-capture session activity, decisions, and state for handoff |
 
 ### FORGE & Context Compression
 | Tool | CLI | Description |
@@ -216,6 +229,28 @@ Tools supporting `workspaces` param: `search`, `find`, `symbol`.
 | `aikit_graph` | `aikit graph` | Query and manage the knowledge graph (8 actions: find_nodes, find_edges, neighbors, traverse, stats, add, delete, clear) |
 | `aikit_onboard` | `aikit onboard` | First-time codebase onboarding — runs all analysis tools in one command, auto-persists results |
 | `aikit_replay` | `aikit replay` | View or clear the audit trail of tool invocations (action: list/clear) |
+| `aikit_config` | `aikit config` | View and modify runtime configuration |
+
+### Meta-Tools
+| Tool | CLI | Description |
+|------|-----|-------------|
+| `aikit_list_tools` | `aikit list-tools` | List all currently active tools with categories |
+| `aikit_describe_tool` | `aikit describe-tool` | Get detailed metadata for a specific tool |
+| `aikit_search_tools` | `aikit search-tools` | Search tools by keyword or capability |
+
+### Flow Management
+| Tool | CLI | Description |
+|------|-----|-------------|
+| `aikit_flow_list` | `aikit flow list` | List installed flows and active flow |
+| `aikit_flow_info` | `aikit flow info` | Get detailed flow info including steps |
+| `aikit_flow_start` | `aikit flow start` | Start a named flow |
+| `aikit_flow_step` | `aikit flow step` | Advance: next, skip, or redo current step |
+| `aikit_flow_status` | `aikit flow status` | Check current execution state |
+| `aikit_flow_read_instruction` | `aikit flow read-instruction` | Read the instruction content for the current step |
+| `aikit_flow_reset` | `aikit flow reset` | Clear flow state to start over |
+| `aikit_flow_add` | `aikit flow add` | Install a custom flow |
+| `aikit_flow_remove` | `aikit flow remove` | Remove an installed flow |
+| `aikit_flow_update` | `aikit flow update` | Update flow definition or steps |
 
 ### TUI Dashboard
 
@@ -348,7 +383,7 @@ aikit init [--user|--workspace] [--force] [--guide]
 │   ├── chunker/      — tree-sitter + regex code chunking
 │   ├── indexer/      — incremental file indexer
 │   ├── analyzers/    — blast-radius, deps, symbols, patterns, diagrams
-│   ├── tools/        — 55 tool modules (67 MCP tools)
+│   ├── tools/        — 59 tool modules (82 MCP tools)
 │   ├── server/       — MCP protocol server
 │   └── cli/          — command-line interface
 ├── bin/aikit.mjs     — CLI entry point

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vpxa/aikit",
-  "version": "0.1.59",
+  "version": "0.1.61",
   "type": "module",
   "description": "Local-first AI developer toolkit — knowledge base, code analysis, context management, and developer tools for LLM agents",
   "license": "MIT",
@@ -28,6 +28,7 @@
     "packages/chunker/wasm/*.wasm",
     "packages/chunker/src/queries/**/*.scm",
     "scaffold/",
+    "!scaffold/__tests__/",
     "README.md",
     "LICENSE"
   ],

package/packages/aikit-client/dist/index.d.ts

@@ -1,5 +1,147 @@
-import { IKBClient, KBGraphData, KBKnowledgeEntry, KBSearchResult, KBStatus } from "./types.js";
-import { DirectClientDeps, DirectKBClient } from "./direct-client.js";
-import { McpKBClient } from "./mcp-client.js";
-import { ParsedContent, extractStructured, extractText, parseToolResult, tryParseJson } from "./parsers.js";
+import { IEmbedder } from "../../embeddings/dist/index.js";
+import { IGraphStore, IKnowledgeStore } from "../../store/dist/index.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+
+//#region packages/aikit-client/src/types.d.ts
+/**
+ * IKBClient — Unified data access interface for AI Kit consumers.
+ *
+ * Implemented by:
+ * - DirectKBClient (in-process, used by TUI)
+ * - McpKBClient (over MCP transport, used by Dashboard)
+ */
+interface KBStatus {
+  totalRecords: number;
+  totalFiles: number;
+  lastIndexedAt: string | null;
+  onboarded: boolean;
+}
+interface KBSearchResult {
+  sourcePath: string;
+  contentType: string;
+  score: number;
+  content: string;
+  headingPath?: string;
+  startLine?: number;
+  endLine?: number;
+}
+interface KBKnowledgeEntry {
+  path: string;
+  title: string;
+  category: string;
+  tags: string[];
+  content: string;
+}
+interface KBGraphData {
+  nodes: Array<{
+    id: string;
+    name: string;
+    type: string;
+    sourcePath?: string;
+  }>;
+  edges: Array<{
+    fromId: string;
+    toId: string;
+    type: string;
+  }>;
+}
+interface IKBClient {
+  /** Get AI Kit status. */
+  getStatus(): Promise<KBStatus>;
+  /** Search AI Kit. */
+  search(query: string, options?: {
+    limit?: number;
+    mode?: 'hybrid' | 'semantic' | 'keyword';
+  }): Promise<KBSearchResult[]>;
+  /** List curated knowledge entries. */
+  listKnowledge(): Promise<KBKnowledgeEntry[]>;
+  /** Read a specific curated entry. */
+  readKnowledge(path: string): Promise<KBKnowledgeEntry | null>;
+  /** Get knowledge graph data. */
+  getGraph(query?: string): Promise<KBGraphData>;
+  /** Get file tree of indexed sources. */
+  getFileTree(): Promise<string[]>;
+}
+//#endregion
+//#region packages/aikit-client/src/direct-client.d.ts
+interface CuratedEntry {
+  path: string;
+  title: string;
+  category: string;
+  tags: string[];
+  content: string;
+}
+interface DirectClientDeps {
+  store: IKnowledgeStore;
+  embedder: IEmbedder;
+  graphStore?: IGraphStore;
+  /** Function to list curated entries */
+  listCurated?: () => Promise<CuratedEntry[]>;
+  /** Function to read a single curated entry */
+  readCurated?: (path: string) => Promise<CuratedEntry | null>;
+}
+declare class DirectKBClient implements IKBClient {
+  private readonly deps;
+  constructor(deps: DirectClientDeps);
+  getStatus(): Promise<KBStatus>;
+  search(query: string, options?: {
+    limit?: number;
+    mode?: 'hybrid' | 'semantic' | 'keyword';
+  }): Promise<KBSearchResult[]>;
+  listKnowledge(): Promise<KBKnowledgeEntry[]>;
+  readKnowledge(path: string): Promise<KBKnowledgeEntry | null>;
+  getGraph(query?: string): Promise<KBGraphData>;
+  getFileTree(): Promise<string[]>;
+  private getEdgesForNodes;
+}
+//#endregion
+//#region packages/aikit-client/src/mcp-client.d.ts
+declare class McpKBClient implements IKBClient {
+  private readonly client;
+  constructor(client: Client);
+  getStatus(): Promise<KBStatus>;
+  search(query: string, options?: {
+    limit?: number;
+    mode?: 'hybrid' | 'semantic' | 'keyword';
+  }): Promise<KBSearchResult[]>;
+  listKnowledge(): Promise<KBKnowledgeEntry[]>;
+  readKnowledge(path: string): Promise<KBKnowledgeEntry | null>;
+  getGraph(query?: string): Promise<KBGraphData>;
+  getFileTree(): Promise<string[]>;
+}
+//#endregion
+//#region packages/aikit-client/src/parsers.d.ts
+/**
+ * Content parsers for MCP tool responses.
+ * Used by McpKBClient to parse structuredContent from tool calls.
+ */
+interface ParsedContent<T = unknown> {
+  text: string;
+  structured?: T;
+}
+/**
+ * Extract text content from an MCP tool result.
+ */
+declare function extractText(result: {
+  content?: unknown;
+} | null | undefined): string;
+/**
+ * Extract structured content from an MCP tool result.
+ */
+declare function extractStructured<T>(result: {
+  structuredContent?: unknown;
+} | null | undefined): T | undefined;
+/**
+ * Parse a tool result, returning both text and structured content.
+ */
+declare function parseToolResult<T = unknown>(result: {
+  content?: unknown;
+  structuredContent?: unknown;
+} | null | undefined): ParsedContent<T>;
+/**
+ * Try to parse JSON from a text tool result.
+ * Returns undefined if parsing fails.
+ */
+declare function tryParseJson<T = unknown>(text: string): T | undefined;
+//#endregion
 export { type DirectClientDeps, DirectKBClient, type IKBClient, type KBGraphData, type KBKnowledgeEntry, type KBSearchResult, type KBStatus, McpKBClient, type ParsedContent, extractStructured, extractText, parseToolResult, tryParseJson };

package/packages/aikit-client/dist/index.js

@@ -1 +1,5 @@
-import{DirectKBClient as e}from"./direct-client.js";import{extractStructured as t,extractText as n,parseToolResult as r,tryParseJson as i}from"./parsers.js";import{McpKBClient as a}from"./mcp-client.js";export{e as DirectKBClient,a as McpKBClient,t as extractStructured,n as extractText,r as parseToolResult,i as tryParseJson};
+const e=1e3;var t=class{constructor(e){this.deps=e}async getStatus(){let e=await this.deps.store.getStats();return{totalRecords:e.totalRecords,totalFiles:e.totalFiles,lastIndexedAt:e.lastIndexedAt??null,onboarded:e.totalRecords>0}}async search(e,t){let n=t?.limit??10,i=t?.mode??`hybrid`;if(i===`keyword`)return(await this.deps.store.ftsSearch(e,{limit:n})).map(r);let a=await this.deps.embedder.embedQuery(e);if(i===`semantic`)return(await this.deps.store.search(a,{limit:n})).map(r);let[o,s]=await Promise.all([this.deps.store.search(a,{limit:n*2}),this.deps.store.ftsSearch(e,{limit:n*2}).catch(()=>[])]),c=new Map;for(let e of[...o,...s]){let t=c.get(e.record.id);(!t||e.score>t.score)&&c.set(e.record.id,e)}return[...c.values()].sort((e,t)=>t.score-e.score).slice(0,n).map(r)}async listKnowledge(){return this.deps.listCurated?(await this.deps.listCurated()).map(n):[]}async readKnowledge(e){if(!this.deps.readCurated)return null;let t=await this.deps.readCurated(e);return t?n(t):null}async getGraph(t){if(!this.deps.graphStore)return{nodes:[],edges:[]};let n=await this.deps.graphStore.findNodes(t?{namePattern:t,limit:500}:{limit:500});if(n.length===0)return{nodes:[],edges:[]};let r=t?await this.getEdgesForNodes(n):await this.deps.graphStore.findEdges({limit:e});return{nodes:n.map(e=>({id:e.id,name:e.name,type:e.type,...e.sourcePath?{sourcePath:e.sourcePath}:{}})),edges:i(r).map(e=>({fromId:e.fromId,toId:e.toId,type:e.type}))}}async getFileTree(){return this.deps.store.listSourcePaths()}async getEdgesForNodes(t){let n=this.deps.graphStore;if(!n)return[];let r=t.flatMap(t=>[n.findEdges({fromId:t.id,limit:e}),n.findEdges({toId:t.id,limit:e})]);return(await Promise.all(r)).flat()}};function n(e){return{path:e.path,title:e.title,category:e.category,tags:e.tags,content:e.content}}function r(e){return{sourcePath:e.record.sourcePath,contentType:e.record.contentType,score:e.score,content:e.record.content,headingPath:e.record.headingPath,startLine:e.record.startLine,endLine:e.record.endLine}}function i(e){let t=new Map;for(let n of e)t.set(n.id,n);return[...t.values()]}function a(e){return!Array.isArray(e?.content)||e.content.length===0?``:e.content.filter(e=>typeof e==`object`&&!!e).filter(e=>e.type===`text`&&typeof e.text==`string`).map(e=>e.text).join(`
+`)}function o(e){return e?.structuredContent}function s(e){return{text:a(e),structured:o(e)}}function c(e){try{return JSON.parse(e)}catch{return}}var l=class{constructor(e){this.client=e}async getStatus(){let e=await this.client.callTool({name:`status`,arguments:{}}),t=d(e);if(t)return{totalRecords:g(t.totalRecords),totalFiles:g(t.totalFiles),lastIndexedAt:v(t.lastIndexedAt),onboarded:!!t.onboarded};let n=u(e);return{totalRecords:f(n,/Records:\s*(\d+)/i),totalFiles:f(n,/Files:\s*(\d+)/i),lastIndexedAt:null,onboarded:!/not onboarded/i.test(n)}}async search(e,t){let n=await this.client.callTool({name:`search`,arguments:{query:e,limit:t?.limit??10,search_mode:t?.mode??`hybrid`}}),r=d(n);return r?.results?r.results.map(e=>({sourcePath:y(e.sourcePath??e.path),contentType:y(e.contentType,`unknown`),score:g(e.score),content:y(e.content??e.snippet),headingPath:b(e.headingPath),startLine:_(e.startLine),endLine:_(e.endLine)})):p(u(n))}async listKnowledge(){let e=d(await this.client.callTool({name:`list`,arguments:{}}));return e?.entries?e.entries.map(e=>({path:y(e.path),title:y(e.title),category:y(e.category),tags:x(e.tags),content:y(e.content)})):[]}async readKnowledge(e){try{let t=u(await this.client.callTool({name:`read`,arguments:{path:e}}));return!t||/not found/i.test(t)?null:{path:e,title:e.split(`/`).pop()??e,category:e.split(`/`).at(-2)??`uncategorized`,tags:[],content:t}}catch{return null}}async getGraph(e){let t=m(u(await this.client.callTool({name:`graph`,arguments:{action:`find_nodes`,...e?{name_pattern:e}:{},limit:500}})));return t.length===0?{nodes:[],edges:[]}:{nodes:t,edges:h(u(await this.client.callTool({name:`graph`,arguments:{action:`find_edges`,limit:1e3}})))}}async getFileTree(){let e=await this.client.callTool({name:`find`,arguments:{glob:`**/*`,limit:1e4}}),t=d(e);return t?.results?t.results.map(e=>typeof e==`string`?e:e.path??``).filter(e=>e.length>0):u(e).split(`
+`).map(e=>e.trim()).filter(e=>e.length>0)}};function u(e){return a(e)}function d(e){return o(e)}function f(e,t){let n=t.exec(e);return n?Number.parseInt(n[1],10):0}function p(e){let t=[],n=e.split(/\n(?=\d+\.\s|\*\*)/);for(let e of n){let n=/(?:\*\*|`)([^*`]+?)(?:\*\*|`)/.exec(e),r=/score:\s*([\d.]+)/i.exec(e);n&&t.push({sourcePath:n[1].trim(),contentType:`unknown`,score:r?Number.parseFloat(r[1]):0,content:e.replace(/^.*\n/,``).trim().slice(0,200)})}return t}function m(e){let t=[];for(let n of e.split(`
+`)){let e=/\*\*(.+?)\*\*\s*\(([^,)]+)(?:,\s*id:\s*`?([\w-]+)`?)?/.exec(n);e&&t.push({id:e[3]??`node-${t.length}`,name:e[1],type:e[2]})}return t}function h(e){let t=[];for(let n of e.split(`
+`)){let e=/`?([\w-]+)`?\s*[—-]+\[(\w+)\][→>]\s*`?([\w-]+)`?/.exec(n);e&&t.push({fromId:e[1],toId:e[3],type:e[2]})}return t}function g(e){return typeof e==`number`?e:0}function _(e){return typeof e==`number`?e:void 0}function v(e){return typeof e==`string`?e:null}function y(e,t=``){return typeof e==`string`?e:t}function b(e){return typeof e==`string`?e:void 0}function x(e){return Array.isArray(e)?e.filter(e=>typeof e==`string`):[]}export{t as DirectKBClient,l as McpKBClient,o as extractStructured,a as extractText,s as parseToolResult,c as tryParseJson};

package/packages/analyzers/dist/index.d.ts

@@ -1,12 +1,310 @@
-import { AnalysisResult, AnalyzerOptions, DependencyAnalyzerOptions, DiagramOptions, EntryPoint, ExistingKnowledge, ExtractionBaselines, IAnalyzer, ImportInfo, PatternMatch, ProjectStats, StructureAnalyzerOptions, SymbolAnalyzerOptions, SymbolInfo, TreeNode } from "./types.js";
-import { BlastRadiusAnalyzer, BlastRadiusOptions } from "./blast-radius-analyzer.js";
-import { DependencyAnalyzer } from "./dependency-analyzer.js";
-import { DiagramGenerator } from "./diagram-generator.js";
-import { EntryPointAnalyzer } from "./entry-point-analyzer.js";
-import { PatternAnalyzer } from "./pattern-analyzer.js";
-import { StructureAnalyzer } from "./structure-analyzer.js";
-import { SymbolAnalyzer } from "./symbol-analyzer.js";
-import { Analyzers, KnowledgeProducer } from "./knowledge-producer.js";
-import { extractTsCallGraph } from "./ts-call-graph.js";
-import { extractRegexCallGraph } from "./regex-call-graph.js";
+//#region packages/analyzers/src/types.d.ts
+/**
+ * Analyzer interfaces and result types.
+ */
+interface AnalysisResult {
+  /** Formatted output (Markdown, JSON, or Mermaid) */
+  output: string;
+  /** Structured data for programmatic access */
+  data: Record<string, unknown>;
+  /** Analysis metadata */
+  meta: {
+    analyzedAt: string;
+    scope: string;
+    fileCount: number;
+    durationMs: number;
+  };
+}
+interface AnalyzerOptions {
+  format?: 'json' | 'markdown' | 'mermaid';
+  [key: string]: unknown;
+}
+interface IAnalyzer<TOpts extends AnalyzerOptions = AnalyzerOptions> {
+  readonly name: string;
+  analyze(rootPath: string, options?: TOpts): Promise<AnalysisResult>;
+}
+interface StructureAnalyzerOptions extends AnalyzerOptions {
+  format?: 'json' | 'markdown';
+  maxDepth?: number;
+  /** When true, only include source code and config files (no docs, images, fonts, etc.) */
+  sourceOnly?: boolean;
+  /** Token budget for dynamic tree pruning (Level 1=full, 2=collapsed leaves, 3=top-level). */
+  maxTokens?: number;
+}
+interface DependencyAnalyzerOptions extends AnalyzerOptions {
+  format?: 'json' | 'markdown' | 'mermaid';
+  maxNodes?: number;
+}
+interface SymbolAnalyzerOptions extends AnalyzerOptions {
+  filter?: string;
+  format?: 'json' | 'markdown';
+}
+interface DiagramOptions extends AnalyzerOptions {
+  diagramType?: 'architecture' | 'dependencies';
+  scope?: string;
+}
+interface TreeNode {
+  name: string;
+  type: 'file' | 'directory';
+  purpose?: string;
+  language?: string;
+  size?: number;
+  children?: TreeNode[];
+}
+interface ProjectStats {
+  totalFiles: number;
+  totalSize: number;
+  languages: Record<string, number>;
+}
+interface ImportInfo {
+  source: string;
+  specifiers: string[];
+  filePath: string;
+  isExternal: boolean;
+  /** Confidence level based on import resolution method */
+  confidence: 'high' | 'medium' | 'low';
+}
+interface SymbolInfo {
+  name: string;
+  kind: 'function' | 'class' | 'interface' | 'type' | 'const' | 'enum' | 'variable' | 'method';
+  exported: boolean;
+  filePath: string;
+  line: number;
+  /** Full signature for functions/methods (parameter list + return type) */
+  signature?: string;
+  /** Return type annotation (e.g. "Promise<void>", "string") */
+  returnType?: string;
+  /** First line of JSDoc/docstring */
+  jsdoc?: string;
+  /** Decorator names (e.g. ["@Controller('/api')", "@Injectable"]) */
+  decorators?: string[];
+  /** Condensed body for interfaces/types (e.g. "{ id: string; name: string }") */
+  typeBody?: string;
+}
+interface PatternMatch {
+  pattern: string;
+  description: string;
+  locations: string[];
+  confidence: 'high' | 'medium' | 'low';
+}
+interface EntryPoint {
+  name: string;
+  type: 'lambda-handler' | 'main' | 'bin' | 'server' | 'cli' | 'test' | 'cdk-construct';
+  filePath: string;
+  trigger?: string;
+}
+interface ExtractionBaselines {
+  structure?: AnalysisResult;
+  dependencies?: AnalysisResult;
+  symbols?: AnalysisResult;
+  patterns?: AnalysisResult;
+  entryPoints?: AnalysisResult;
+  diagrams?: AnalysisResult[];
+}
+interface ExistingKnowledge {
+  categories: string[];
+  lastProduced: Record<string, string>;
+  documentCount: number;
+}
+//#endregion
+//#region packages/analyzers/src/blast-radius-analyzer.d.ts
+interface BlastRadiusOptions {
+  /** Changed file paths (relative to root) */
+  files: string[];
+  /** Maximum depth of transitive dependency traversal (default: 5) */
+  maxDepth?: number;
+  /** Output format */
+  format?: 'json' | 'markdown';
+}
+declare class BlastRadiusAnalyzer {
+  readonly name = "blast-radius";
+  private depAnalyzer;
+  analyze(rootPath: string, options: BlastRadiusOptions): Promise<AnalysisResult>;
+  private formatMarkdown;
+}
+//#endregion
+//#region packages/analyzers/src/dependency-analyzer.d.ts
+declare class DependencyAnalyzer implements IAnalyzer<DependencyAnalyzerOptions> {
+  readonly name = "dependencies";
+  /** Map of workspace package names to their relative entry point paths */
+  private workspacePackages;
+  analyze(rootPath: string, options?: DependencyAnalyzerOptions): Promise<AnalysisResult>;
+  private collectFiles;
+  private extractImportsRegex;
+  private groupExternalDeps;
+  private groupInternalDeps;
+  /**
+   * Build reverse graph: for each source file, who imports it?
+   */
+  buildReverseGraph(imports: ImportInfo[], _rootPath: string): Record<string, string[]>;
+  /**
+   * Build test coverage map: for each source file, which test files exercise it?
+   */
+  buildTestCoverage(imports: ImportInfo[], _rootPath: string): Record<string, string[]>;
+  /** Resolve a relative import path to a normalized file path (best-effort). */
+  private resolveImportPath;
+  /**
+   * Build a map of workspace package names → relative entry point paths.
+   * Scans for package.json files in common workspace dirs.
+   */
+  private buildWorkspaceMap;
+  private formatMarkdown;
+  private formatMermaid;
+}
+//#endregion
+//#region packages/analyzers/src/diagram-generator.d.ts
+/**
+ * Generates Mermaid diagrams by combining output from other analyzers.
+ */
+declare class DiagramGenerator implements IAnalyzer<DiagramOptions> {
+  readonly name = "diagrams";
+  private readonly structureAnalyzer;
+  private readonly dependencyAnalyzer;
+  analyze(rootPath: string, options?: DiagramOptions): Promise<AnalysisResult>;
+  private generateArchitectureDiagram;
+  private generateDependencyDiagram;
+}
+//#endregion
+//#region packages/analyzers/src/entry-point-analyzer.d.ts
+declare class EntryPointAnalyzer implements IAnalyzer<AnalyzerOptions> {
+  readonly name = "entry-points";
+  analyze(rootPath: string, _options?: AnalyzerOptions): Promise<AnalysisResult>;
+  private fromPackageJson;
+  /** Parse package.json `exports` field into entry points. */
+  private parseExportsField;
+  /** Resolve export value through condition maps (import > default > first string). */
+  private resolveExportValue;
+  /**
+   * Find all workspace package directories in a monorepo.
+   * Supports pnpm-workspace.yaml and package.json#workspaces.
+   */
+  private findWorkspacePackages;
+  /** Simple YAML parser for pnpm-workspace.yaml — extracts packages list. */
+  private parsePnpmWorkspaceYaml;
+  /**
+   * Expand a workspace glob like "packages/*" into actual directories
+   * that contain package.json files.
+   */
+  private expandWorkspaceGlob;
+  private fromHandlerExports;
+  /** Check if a file is a test suite. */
+  private isTestFile;
+  /** Extract a meaningful name from the file path for non-JS entry points */
+  private inferNameFromFile;
+  /**
+   * Derive a contextual name from the directory path for generic handler/main files.
+   * E.g., "services/channels/email/delivery/src/handler.ts" → "email-delivery"
+   */
+  private deriveContextualName;
+  private inferEntryType;
+  private detectTrigger;
+  private collectFiles;
+  private formatMarkdown;
+}
+//#endregion
+//#region packages/analyzers/src/pattern-analyzer.d.ts
+declare class PatternAnalyzer implements IAnalyzer<AnalyzerOptions> {
+  readonly name = "patterns";
+  analyze(rootPath: string, _options?: AnalyzerOptions): Promise<AnalysisResult>;
+  private collectDirectories;
+  private collectCodeFiles;
+  private detectDirectoryPatterns;
+  private detectCodePatterns;
+  private detectConfigPatterns;
+  private formatMarkdown;
+}
+//#endregion
+//#region packages/analyzers/src/structure-analyzer.d.ts
+declare class StructureAnalyzer implements IAnalyzer<StructureAnalyzerOptions> {
+  readonly name = "structure";
+  analyze(rootPath: string, options?: StructureAnalyzerOptions): Promise<AnalysisResult>;
+  private buildTree;
+  private computeStats;
+  private formatMarkdownWithBudget;
+  private formatMarkdown;
+  private renderTree;
+  private renderTreeLevel3;
+  private estimateTokens;
+  private isLeafDir;
+  private leafDirSummary;
+  private countFiles;
+}
+//#endregion
+//#region packages/analyzers/src/symbol-analyzer.d.ts
+declare class SymbolAnalyzer implements IAnalyzer<SymbolAnalyzerOptions> {
+  readonly name = "symbols";
+  analyze(rootPath: string, options?: SymbolAnalyzerOptions): Promise<AnalysisResult>;
+  private collectFiles;
+  private extractSymbolsRegex;
+  private groupByKind;
+  private formatMarkdown;
+  private formatCallGraph;
+}
+//#endregion
+//#region packages/analyzers/src/knowledge-producer.d.ts
+interface Analyzers {
+  structure: StructureAnalyzer;
+  dependencies: DependencyAnalyzer;
+  symbols: SymbolAnalyzer;
+  patterns: PatternAnalyzer;
+  entryPoints: EntryPointAnalyzer;
+  diagrams: DiagramGenerator;
+}
+/**
+ * Orchestrates Tier 1 deterministic extraction and prepares
+ * synthesis instructions for the LLM to produce knowledge.
+ */
+declare class KnowledgeProducer {
+  private readonly analyzers;
+  constructor(analyzers: Analyzers);
+  /**
+   * Run Tier 1 deterministic extraction for specified aspects.
+   */
+  runExtraction(scope: string, aspects: string[]): Promise<ExtractionBaselines>;
+  /**
+   * Build synthesis instructions from baselines for the LLM.
+   */
+  buildSynthesisInstructions(baselines: ExtractionBaselines, _aspects: string[]): string;
+  /**
+   * Build cross-references between baselines (symbols ↔ entry-points ↔ patterns).
+   * Helps the LLM see connections across independently generated sections.
+   */
+  private buildCrossReferences;
+}
+//#endregion
+//#region packages/analyzers/src/ts-call-graph.d.ts
+/**
+ * TypeScript Compiler API-based call graph extractor.
+ *
+ * Uses ts.createProgram to build a real type-checked program, then walks
+ * the AST to find function call sites and resolve them to their declaration files.
+ * Produces module-level call edges: which modules call functions in which other modules.
+ */
+interface ModuleCallEdge {
+  /** Caller module (relative path) */
+  from: string;
+  /** Callee module (relative path) */
+  to: string;
+  /** Function/symbol names called across this edge */
+  symbols: string[];
+}
+interface CallGraphResult {
+  edges: ModuleCallEdge[];
+  fileCount: number;
+  edgeCount: number;
+  durationMs: number;
+}
+/**
+ * Extract module-level call graph from a TypeScript/JavaScript project.
+ * Returns null if TypeScript compiler is unavailable or no TS files found.
+ */
+declare function extractTsCallGraph(rootPath: string): Promise<CallGraphResult | null>;
+//#endregion
+//#region packages/analyzers/src/regex-call-graph.d.ts
+/**
+ * Extract regex-based call graph for any supported language.
+ * Returns null if no source files found.
+ */
+declare function extractRegexCallGraph(rootPath: string): Promise<CallGraphResult | null>;
+//#endregion
 export { type AnalysisResult, type AnalyzerOptions, type Analyzers, BlastRadiusAnalyzer, type BlastRadiusOptions, DependencyAnalyzer, type DependencyAnalyzerOptions, DiagramGenerator, type DiagramOptions, type EntryPoint, EntryPointAnalyzer, type ExistingKnowledge, type ExtractionBaselines, type IAnalyzer, type ImportInfo, KnowledgeProducer, PatternAnalyzer, type PatternMatch, type ProjectStats, StructureAnalyzer, type StructureAnalyzerOptions, SymbolAnalyzer, type SymbolAnalyzerOptions, type SymbolInfo, type TreeNode, extractRegexCallGraph, extractTsCallGraph };