@optave/codegraph 3.3.0 → 3.4.0

package/src/mcp/tools/{list-functions.js → list-functions.ts}

@@ -1,8 +1,17 @@
 import { effectiveLimit, effectiveOffset } from '../middleware.js';
+import type { McpToolContext } from '../server.js';
 
 export const name = 'list_functions';
 
-export async function handler(args, ctx) {
+interface ListFunctionsArgs {
+  file?: string;
+  pattern?: string;
+  no_tests?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+export async function handler(args: ListFunctionsArgs, ctx: McpToolContext): Promise<unknown> {
   const { listFunctionsData } = await ctx.getQueries();
   return listFunctionsData(ctx.dbPath, {
     file: args.file,

package/src/mcp/tools/list-repos.ts

@@ -0,0 +1,17 @@
+import type { McpToolContext } from '../server.js';
+
+export const name = 'list_repos';
+
+interface ListReposArgs {
+  [key: string]: unknown;
+}
+
+export async function handler(_args: ListReposArgs, ctx: McpToolContext): Promise<unknown> {
+  const { listRepos, pruneRegistry } = await import('../../infrastructure/registry.js');
+  pruneRegistry();
+  let repos = listRepos();
+  if (ctx.allowedRepos) {
+    repos = repos.filter((r: { name: string }) => (ctx.allowedRepos as string[]).includes(r.name));
+  }
+  return { repos };
+}

package/src/mcp/tools/module-map.ts

@@ -0,0 +1,13 @@
+import type { McpToolContext } from '../server.js';
+
+export const name = 'module_map';
+
+interface ModuleMapArgs {
+  limit?: number;
+  no_tests?: boolean;
+}
+
+export async function handler(args: ModuleMapArgs, ctx: McpToolContext): Promise<unknown> {
+  const { moduleMapData } = await ctx.getQueries();
+  return moduleMapData(ctx.dbPath, args.limit || 20, { noTests: args.no_tests });
+}

package/src/mcp/tools/{node-roles.js → node-roles.ts}

@@ -1,8 +1,17 @@
 import { effectiveLimit, effectiveOffset } from '../middleware.js';
+import type { McpToolContext } from '../server.js';
 
 export const name = 'node_roles';
 
-export async function handler(args, ctx) {
+interface NodeRolesArgs {
+  role?: string;
+  file?: string;
+  no_tests?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+export async function handler(args: NodeRolesArgs, ctx: McpToolContext): Promise<unknown> {
   const { rolesData } = await ctx.getQueries();
   return rolesData(ctx.dbPath, {
     role: args.role,

package/src/mcp/tools/path.ts

@@ -0,0 +1,24 @@
+import type { McpToolContext } from '../server.js';
+
+export const name = 'path';
+
+interface PathArgs {
+  from: string;
+  to: string;
+  depth?: number;
+  edge_kinds?: string[];
+  from_file?: string;
+  to_file?: string;
+  no_tests?: boolean;
+}
+
+export async function handler(args: PathArgs, ctx: McpToolContext): Promise<unknown> {
+  const { pathData } = await ctx.getQueries();
+  return pathData(args.from, args.to, ctx.dbPath, {
+    maxDepth: args.depth ?? 10,
+    edgeKinds: args.edge_kinds,
+    fromFile: args.from_file,
+    toFile: args.to_file,
+    noTests: args.no_tests,
+  });
+}

package/src/mcp/tools/{query.js → query.ts}

@@ -1,8 +1,25 @@
 import { effectiveOffset, MCP_DEFAULTS } from '../middleware.js';
+import type { McpToolContext } from '../server.js';
 
 export const name = 'query';
 
-export async function handler(args, ctx) {
+interface QueryArgs {
+  name: string;
+  mode?: string;
+  to?: string;
+  depth?: number;
+  edge_kinds?: string[];
+  reverse?: boolean;
+  from_file?: string;
+  to_file?: string;
+  file?: string;
+  kind?: string;
+  no_tests?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+export async function handler(args: QueryArgs, ctx: McpToolContext): Promise<unknown> {
   const { fnDepsData, pathData } = await ctx.getQueries();
   const qMode = args.mode || 'deps';
   if (qMode === 'path') {
@@ -24,7 +41,7 @@ export async function handler(args, ctx) {
     file: args.file,
     kind: args.kind,
     noTests: args.no_tests,
-    limit: Math.min(args.limit ?? MCP_DEFAULTS.query, ctx.MCP_MAX_LIMIT),
+    limit: Math.min(args.limit ?? MCP_DEFAULTS['query'] ?? 100, ctx.MCP_MAX_LIMIT),
     offset: effectiveOffset(args),
   });
 }

package/src/mcp/tools/{semantic-search.js → semantic-search.ts}

@@ -1,17 +1,26 @@
-import { effectiveOffset, MCP_DEFAULTS, MCP_MAX_LIMIT } from '../middleware.js';
+import { effectiveOffset, MCP_DEFAULTS } from '../middleware.js';
+import type { McpToolContext } from '../server.js';
 
 export const name = 'semantic_search';
 
-export async function handler(args, ctx) {
+interface SemanticSearchArgs {
+  query: string;
+  mode?: string;
+  limit?: number;
+  offset?: number;
+  min_score?: number;
+}
+
+export async function handler(args: SemanticSearchArgs, ctx: McpToolContext): Promise<unknown> {
   const mode = args.mode || 'hybrid';
   const searchOpts = {
-    limit: Math.min(args.limit ?? MCP_DEFAULTS.semantic_search, MCP_MAX_LIMIT),
+    limit: Math.min(args.limit ?? MCP_DEFAULTS['semantic_search'] ?? 100, ctx.MCP_MAX_LIMIT),
     offset: effectiveOffset(args),
     minScore: args.min_score,
   };
 
   if (mode === 'keyword') {
-    const { ftsSearchData } = await import('../../embeddings/index.js');
+    const { ftsSearchData } = await import('../../domain/search/index.js');
     const result = ftsSearchData(args.query, ctx.dbPath, searchOpts);
     if (result === null) {
       return {
@@ -28,7 +37,7 @@ export async function handler(args, ctx) {
   }
 
   if (mode === 'semantic') {
-    const { searchData } = await import('../../embeddings/index.js');
+    const { searchData } = await import('../../domain/search/index.js');
     const result = await searchData(args.query, ctx.dbPath, searchOpts);
     if (result === null) {
       return {
@@ -45,8 +54,8 @@ export async function handler(args, ctx) {
   }
 
   // hybrid (default) — falls back to semantic if no FTS5
-  const { hybridSearchData, searchData } = await import('../../embeddings/index.js');
-  let result = await hybridSearchData(args.query, ctx.dbPath, searchOpts);
+  const { hybridSearchData, searchData } = await import('../../domain/search/index.js');
+  let result: unknown = await hybridSearchData(args.query, ctx.dbPath, searchOpts);
   if (result === null) {
     result = await searchData(args.query, ctx.dbPath, searchOpts);
     if (result === null) {

package/src/mcp/tools/{sequence.js → sequence.ts}

@@ -1,8 +1,21 @@
 import { effectiveOffset, MCP_DEFAULTS } from '../middleware.js';
+import type { McpToolContext } from '../server.js';
 
 export const name = 'sequence';
 
-export async function handler(args, ctx) {
+interface SequenceArgs {
+  name: string;
+  depth?: number;
+  file?: string;
+  kind?: string;
+  dataflow?: boolean;
+  no_tests?: boolean;
+  limit?: number;
+  offset?: number;
+  format?: string;
+}
+
+export async function handler(args: SequenceArgs, ctx: McpToolContext): Promise<unknown> {
   const { sequenceData, sequenceToMermaid } = await import('../../features/sequence.js');
   const seqResult = sequenceData(args.name, ctx.dbPath, {
     depth: args.depth,
@@ -10,7 +23,7 @@ export async function handler(args, ctx) {
     kind: args.kind,
     dataflow: args.dataflow,
     noTests: args.no_tests,
-    limit: Math.min(args.limit ?? MCP_DEFAULTS.execution_flow, ctx.MCP_MAX_LIMIT),
+    limit: Math.min(args.limit ?? MCP_DEFAULTS['execution_flow'] ?? 100, ctx.MCP_MAX_LIMIT),
     offset: effectiveOffset(args),
   });
   return args.format === 'json' ? seqResult : { text: sequenceToMermaid(seqResult), ...seqResult };

package/src/mcp/tools/{structure.js → structure.ts}

@@ -1,8 +1,18 @@
 import { effectiveLimit, effectiveOffset } from '../middleware.js';
+import type { McpToolContext } from '../server.js';
 
 export const name = 'structure';
 
-export async function handler(args, ctx) {
+interface StructureArgs {
+  directory?: string;
+  depth?: number;
+  sort?: string;
+  full?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+export async function handler(args: StructureArgs, ctx: McpToolContext): Promise<unknown> {
   const { structureData } = await import('../../features/structure.js');
   return structureData(ctx.dbPath, {
     directory: args.directory,

package/src/mcp/tools/symbol-children.ts

@@ -0,0 +1,24 @@
+import { effectiveOffset, MCP_DEFAULTS } from '../middleware.js';
+import type { McpToolContext } from '../server.js';
+
+export const name = 'symbol_children';
+
+interface SymbolChildrenArgs {
+  name: string;
+  file?: string;
+  kind?: string;
+  no_tests?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+export async function handler(args: SymbolChildrenArgs, ctx: McpToolContext): Promise<unknown> {
+  const { childrenData } = await ctx.getQueries();
+  return childrenData(args.name, ctx.dbPath, {
+    file: args.file,
+    kind: args.kind,
+    noTests: args.no_tests,
+    limit: Math.min(args.limit ?? MCP_DEFAULTS['context'] ?? 100, ctx.MCP_MAX_LIMIT),
+    offset: effectiveOffset(args),
+  });
+}

package/src/mcp/tools/{triage.js → triage.ts}

@@ -1,21 +1,36 @@
+import type { Role } from '../../types.js';
 import { effectiveLimit, effectiveOffset, MCP_DEFAULTS, MCP_MAX_LIMIT } from '../middleware.js';
+import type { McpToolContext } from '../server.js';
 
 export const name = 'triage';
 
-export async function handler(args, ctx) {
+interface TriageArgs {
+  level?: string;
+  sort?: string;
+  min_score?: number;
+  role?: string;
+  file?: string;
+  kind?: string;
+  no_tests?: boolean;
+  weights?: Record<string, number>;
+  limit?: number;
+  offset?: number;
+}
+
+export async function handler(args: TriageArgs, ctx: McpToolContext): Promise<unknown> {
   if (args.level === 'file' || args.level === 'directory') {
     const { hotspotsData } = await import('../../features/structure.js');
-    const TRIAGE_TO_HOTSPOT = {
+    const TRIAGE_TO_HOTSPOT: Record<string, string> = {
       risk: 'fan-in',
       complexity: 'density',
       churn: 'coupling',
       mi: 'fan-in',
     };
-    const metric = TRIAGE_TO_HOTSPOT[args.sort] ?? args.sort;
+    const metric = TRIAGE_TO_HOTSPOT[args.sort as string] ?? args.sort;
     return hotspotsData(ctx.dbPath, {
       metric,
       level: args.level,
-      limit: Math.min(args.limit ?? MCP_DEFAULTS.hotspots, MCP_MAX_LIMIT),
+      limit: Math.min(args.limit ?? MCP_DEFAULTS['hotspots'] ?? 100, MCP_MAX_LIMIT),
       offset: effectiveOffset(args),
       noTests: args.no_tests,
     });
@@ -24,7 +39,7 @@ export async function handler(args, ctx) {
   return triageData(ctx.dbPath, {
     sort: args.sort,
     minScore: args.min_score,
-    role: args.role,
+    role: args.role as Role | undefined,
     file: args.file,
     kind: args.kind,
     noTests: args.no_tests,

package/src/mcp/tools/{where.js → where.ts}

@@ -1,8 +1,17 @@
 import { effectiveLimit, effectiveOffset } from '../middleware.js';
+import type { McpToolContext } from '../server.js';
 
 export const name = 'where';
 
-export async function handler(args, ctx) {
+interface WhereArgs {
+  target: string;
+  file_mode?: string;
+  no_tests?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+export async function handler(args: WhereArgs, ctx: McpToolContext): Promise<unknown> {
   const { whereData } = await ctx.getQueries();
   return whereData(args.target, ctx.dbPath, {
     file: args.file_mode,

package/src/presentation/{audit.js → audit.ts}

@@ -2,11 +2,26 @@ import { kindIcon } from '../domain/queries.js';
 import { auditData } from '../features/audit.js';
 import { outputResult } from '../infrastructure/result-formatter.js';
 
-/**
- * CLI formatter for the audit command.
- */
-export function audit(target, customDbPath, opts = {}) {
-  const data = auditData(target, customDbPath, opts);
+interface AuditOpts {
+  json?: boolean;
+  ndjson?: boolean;
+  noTests?: boolean;
+  file?: string;
+  kind?: string;
+  quick?: boolean;
+  limit?: number;
+  offset?: number;
+  depth?: number;
+  config?: unknown;
+}
+
+export function audit(
+  target: string,
+  customDbPath: string | undefined,
+  opts: AuditOpts = {},
+): void {
+  // biome-ignore lint/suspicious/noExplicitAny: audit data shape is dynamic
+  const data: any = auditData(target, customDbPath, opts as any);
 
   if (outputResult(data, null, opts)) return;
 
@@ -60,7 +75,9 @@ export function audit(target, customDbPath, opts = {}) {
     // Impact
     console.log(`\n  Impact: ${fn.impact.totalDependents} transitive dependent(s)`);
     for (const [level, nodes] of Object.entries(fn.impact.levels)) {
-      console.log(`    Level ${level}: ${nodes.map((n) => n.name).join(', ')}`);
+      console.log(
+        `    Level ${level}: ${(nodes as Array<{ name: string }>).map((n) => n.name).join(', ')}`,
+      );
     }
 
     // Call edges

package/src/presentation/batch.ts

@@ -0,0 +1,49 @@
+import { batchData, multiBatchData } from '../features/batch.js';
+
+interface BatchOpts {
+  json?: boolean;
+  ndjson?: boolean;
+  noTests?: boolean;
+  file?: string;
+  kind?: string;
+  command?: string;
+  limit?: number;
+  offset?: number;
+  [key: string]: unknown;
+}
+
+interface MultiBatchTarget {
+  command: string;
+  target: string;
+  [key: string]: unknown;
+}
+
+export function batch(
+  command: string,
+  targets: string[],
+  customDbPath: string | undefined,
+  opts: BatchOpts = {},
+): void {
+  const data = batchData(command, targets, customDbPath, opts);
+  console.log(JSON.stringify(data, null, 2));
+}
+
+export function batchQuery(
+  targets: Array<string | MultiBatchTarget>,
+  customDbPath: string | undefined,
+  opts: BatchOpts = {},
+): void {
+  const { command: defaultCommand = 'where', ...rest } = opts;
+  const isMulti =
+    targets.length > 0 &&
+    typeof targets[0] === 'object' &&
+    !!(targets[0] as MultiBatchTarget).command;
+
+  let data: unknown;
+  if (isMulti) {
+    data = multiBatchData(targets as MultiBatchTarget[], customDbPath, rest);
+  } else {
+    data = batchData(defaultCommand, targets as string[], customDbPath, rest);
+  }
+  console.log(JSON.stringify(data, null, 2));
+}

package/src/presentation/{branch-compare.js → branch-compare.ts}

@@ -4,10 +4,42 @@ import { outputResult } from '../infrastructure/result-formatter.js';
 
 // ─── Text Formatting ────────────────────────────────────────────────────
 
-function formatText(data) {
+interface BranchCompareSymbol {
+  kind: string;
+  name: string;
+  file: string;
+  line: number;
+  impact?: unknown[];
+  changes?: { lineCount: number; fanIn: number; fanOut: number };
+  base?: { lineCount: number; fanIn: number; fanOut: number; line: number };
+  target?: { lineCount: number; fanIn: number; fanOut: number };
+}
+
+interface BranchCompareSummary {
+  added: number;
+  removed: number;
+  changed: number;
+  totalImpacted: number;
+  filesAffected: number;
+}
+
+interface BranchCompareFormatData {
+  error?: string;
+  baseSha: string;
+  targetSha: string;
+  baseRef: string;
+  targetRef: string;
+  changedFiles: string[];
+  added: BranchCompareSymbol[];
+  removed: BranchCompareSymbol[];
+  changed: BranchCompareSymbol[];
+  summary: BranchCompareSummary;
+}
+
+function formatText(data: BranchCompareFormatData): string {
   if (data.error) return `Error: ${data.error}`;
 
-  const lines = [];
+  const lines: string[] = [];
   const shortBase = data.baseSha.slice(0, 7);
   const shortTarget = data.targetSha.slice(0, 7);
 
@@ -45,19 +77,19 @@ function formatText(data) {
       `  ~ Changed (${data.changed.length} symbol${data.changed.length !== 1 ? 's' : ''}):`,
     );
     for (const sym of data.changed) {
-      const parts = [];
-      if (sym.changes.lineCount !== 0) {
-        parts.push(`lines: ${sym.base.lineCount} -> ${sym.target.lineCount}`);
+      const parts: string[] = [];
+      if (sym.changes?.lineCount !== 0) {
+        parts.push(`lines: ${sym.base?.lineCount} -> ${sym.target?.lineCount}`);
       }
-      if (sym.changes.fanIn !== 0) {
-        parts.push(`fan_in: ${sym.base.fanIn} -> ${sym.target.fanIn}`);
+      if (sym.changes?.fanIn !== 0) {
+        parts.push(`fan_in: ${sym.base?.fanIn} -> ${sym.target?.fanIn}`);
       }
-      if (sym.changes.fanOut !== 0) {
-        parts.push(`fan_out: ${sym.base.fanOut} -> ${sym.target.fanOut}`);
+      if (sym.changes?.fanOut !== 0) {
+        parts.push(`fan_out: ${sym.base?.fanOut} -> ${sym.target?.fanOut}`);
       }
       const detail = parts.length > 0 ? `  (${parts.join(', ')})` : '';
       lines.push(
-        `    [${kindIcon(sym.kind)}] ${sym.name} -- ${sym.file}:${sym.base.line}${detail}`,
+        `    [${kindIcon(sym.kind)}] ${sym.name} -- ${sym.file}:${sym.base?.line}${detail}`,
       );
       if (sym.impact && sym.impact.length > 0) {
         lines.push(
@@ -82,7 +114,22 @@ function formatText(data) {
 
 // ─── CLI Display Function ───────────────────────────────────────────────
 
-export async function branchCompare(baseRef, targetRef, opts = {}) {
+interface BranchCompareCliOpts {
+  json?: boolean;
+  ndjson?: boolean;
+  format?: string;
+  repoRoot?: string;
+  noTests?: boolean;
+  dbPath?: string;
+  engine?: string;
+  depth?: number;
+}
+
+export async function branchCompare(
+  baseRef: string,
+  targetRef: string,
+  opts: BranchCompareCliOpts = {},
+): Promise<void> {
   const data = await branchCompareData(baseRef, targetRef, opts);
 
   if (opts.format === 'json') opts = { ...opts, json: true };
@@ -93,5 +140,5 @@ export async function branchCompare(baseRef, targetRef, opts = {}) {
     return;
   }
 
-  console.log(formatText(data));
+  console.log(formatText(data as unknown as BranchCompareFormatData));
 }

package/src/presentation/{brief.js → brief.ts}

@@ -1,18 +1,30 @@
 import { briefData } from '../domain/analysis/brief.js';
 import { outputResult } from './result-formatter.js';
 
-/**
- * Format a compact brief for hook context injection.
- * Single-block, token-efficient output.
- *
- * Example:
- *   src/domain/graph/builder.js [HIGH RISK]
- *   Symbols: buildGraph [core, 12 callers], collectFiles [leaf, 2 callers]
- *   Imports: src/db/index.js, src/domain/parser.js
- *   Imported by: src/cli/commands/build.js (+8 transitive)
- */
-export function brief(file, customDbPath, opts = {}) {
-  const data = briefData(file, customDbPath, opts);
+interface BriefOpts {
+  json?: boolean;
+  ndjson?: boolean;
+  noTests?: boolean;
+  config?: unknown;
+}
+
+interface BriefSymbol {
+  name: string;
+  role?: string;
+  callerCount: number;
+}
+
+interface BriefResult {
+  file: string;
+  risk: string;
+  symbols: BriefSymbol[];
+  imports: string[];
+  importedBy: string[];
+  totalImporterCount: number;
+}
+
+export function brief(file: string, customDbPath: string | undefined, opts: BriefOpts = {}): void {
+  const data = briefData(file, customDbPath as string, opts);
   if (outputResult(data, 'results', opts)) return;
 
   if (data.results.length === 0) {
@@ -20,13 +32,13 @@ export function brief(file, customDbPath, opts = {}) {
     return;
   }
 
-  for (const r of data.results) {
+  for (const r of data.results as BriefResult[]) {
     console.log(`${r.file} [${r.risk.toUpperCase()} RISK]`);
 
     // Symbols line
     if (r.symbols.length > 0) {
       const parts = r.symbols.map((s) => {
-        const tags = [];
+        const tags: string[] = [];
         if (s.role) tags.push(s.role);
         tags.push(`${s.callerCount} caller${s.callerCount !== 1 ? 's' : ''}`);
         return `${s.name} [${tags.join(', ')}]`;

package/src/presentation/{cfg.js → cfg.ts}

@@ -1,10 +1,42 @@
 import { cfgData, cfgToDOT, cfgToMermaid } from '../features/cfg.js';
 import { outputResult } from '../infrastructure/result-formatter.js';
 
-/**
- * CLI display for cfg command.
- */
-export function cfg(name, customDbPath, opts = {}) {
+interface CfgCliOpts {
+  json?: boolean;
+  ndjson?: boolean;
+  noTests?: boolean;
+  file?: string;
+  kind?: string;
+  format?: string;
+  limit?: number;
+  offset?: number;
+}
+
+interface CfgBlock {
+  index: number;
+  type: string;
+  label?: string;
+  startLine?: number;
+  endLine?: number;
+}
+
+interface CfgEdge {
+  source: number;
+  target: number;
+  kind: string;
+}
+
+interface CfgResultEntry {
+  kind: string;
+  name: string;
+  file: string;
+  line: number;
+  summary: { blockCount: number; edgeCount: number };
+  blocks: CfgBlock[];
+  edges: CfgEdge[];
+}
+
+export function cfg(name: string, customDbPath: string | undefined, opts: CfgCliOpts = {}): void {
   const data = cfgData(name, customDbPath, opts);
 
   if (outputResult(data, 'results', opts)) return;
@@ -29,7 +61,7 @@ export function cfg(name, customDbPath, opts = {}) {
   }
 
   // Text format
-  for (const r of data.results) {
+  for (const r of data.results as CfgResultEntry[]) {
     console.log(`\n${r.kind} ${r.name}  (${r.file}:${r.line})`);
     console.log('\u2500'.repeat(60));
     console.log(`  Blocks: ${r.summary.blockCount}  Edges: ${r.summary.edgeCount}`);