@optave/codegraph 3.10.0 → 3.11.1

package/src/presentation/flow.ts

@@ -16,54 +16,65 @@ interface FlowOpts {
   csv?: boolean;
 }
 
-export function flow(
-  name: string | undefined,
-  dbPath: string | undefined,
-  opts: FlowOpts = {},
-): void {
-  if (opts.list) {
-    const data = listEntryPointsData(dbPath, {
-      noTests: opts.noTests,
-      limit: opts.limit,
-      offset: opts.offset,
-    }) as any;
-    if (outputResult(data, 'entries', opts)) return;
-    if (data.count === 0) {
-      console.log('No entry points found. Run "codegraph build" first.');
-      return;
-    }
-    console.log(`\nEntry points (${data.count} total):\n`);
-    for (const [type, entries] of Object.entries(
-      data.byType as Record<
-        string,
-        Array<{ kind: string; name: string; file: string; line: number }>
-      >,
-    )) {
-      console.log(`  ${type} (${entries.length}):`);
-      for (const e of entries) {
-        console.log(`    [${kindIcon(e.kind)}] ${e.name}  ${e.file}:${e.line}`);
-      }
-      console.log();
-    }
-    return;
-  }
+interface EntryPoint {
+  kind: string;
+  name: string;
+  file: string;
+  line: number;
+}
 
-  if (!name) {
-    console.log(
-      'Please provide a function or entry-point name. Use --list to see available entry points.',
-    );
-    return;
-  }
+interface FlowNode {
+  kind: string;
+  name: string;
+  file: string;
+  line: number;
+}
 
-  const data = flowData(name, dbPath, opts) as any;
-  if (outputResult(data, 'steps', opts)) return;
+interface FlowStep {
+  depth: number;
+  nodes: FlowNode[];
+}
 
-  if (!data.entry) {
-    console.log(`No matching entry point or function found for "${name}".`);
+interface FlowCycle {
+  from: string;
+  to: string;
+  depth: number;
+}
+
+interface FlowResult {
+  entry?: { kind: string; name: string; type: string; file: string; line: number };
+  depth: number;
+  totalReached: number;
+  leaves: Array<{ name: string; file: string }>;
+  steps: FlowStep[];
+  cycles: FlowCycle[];
+  truncated?: boolean;
+}
+
+function runListEntryPoints(dbPath: string | undefined, opts: FlowOpts): void {
+  const data = listEntryPointsData(dbPath, {
+    noTests: opts.noTests,
+    limit: opts.limit,
+    offset: opts.offset,
+  }) as { count: number; byType: Record<string, EntryPoint[]> };
+  if (outputResult(data, 'entries', opts)) return;
+  if (data.count === 0) {
+    console.log('No entry points found. Run "codegraph build" first.');
     return;
   }
+  console.log(`\nEntry points (${data.count} total):\n`);
+  for (const [type, entries] of Object.entries(data.byType)) {
+    console.log(`  ${type} (${entries.length}):`);
+    for (const e of entries) {
+      console.log(`    [${kindIcon(e.kind)}] ${e.name}  ${e.file}:${e.line}`);
+    }
+    console.log();
+  }
+}
 
+function printFlowHeader(data: FlowResult): void {
   const e = data.entry;
+  if (!e) return;
   const typeTag = e.type !== 'exported' ? ` (${e.type})` : '';
   console.log(`\nFlow from: [${kindIcon(e.kind)}] ${e.name}${typeTag}  ${e.file}:${e.line}`);
   console.log(
@@ -73,27 +84,64 @@ export function flow(
     console.log(`  (truncated at depth ${data.depth})`);
   }
   console.log();
+}
+
+function isLeafNode(n: FlowNode, leaves: Array<{ name: string; file: string }>): boolean {
+  return leaves.some((l) => l.name === n.name && l.file === n.file);
+}
 
+/** Returns true when the node is a leaf (no steps); caller should skip cycle output. */
+function printFlowSteps(data: FlowResult): boolean {
   if (data.steps.length === 0) {
     console.log('  (leaf node — no callees)');
-    return;
+    return true;
   }
-
   for (const step of data.steps) {
     console.log(`  depth ${step.depth}:`);
     for (const n of step.nodes) {
-      const isLeaf = data.leaves.some(
-        (l: { name: string; file: string }) => l.name === n.name && l.file === n.file,
-      );
-      const leafTag = isLeaf ? ' [leaf]' : '';
+      const leafTag = isLeafNode(n, data.leaves) ? ' [leaf]' : '';
       console.log(`    [${kindIcon(n.kind)}] ${n.name}  ${n.file}:${n.line}${leafTag}`);
     }
   }
+  return false;
+}
+
+function printFlowCycles(cycles: FlowCycle[]): void {
+  if (cycles.length === 0) return;
+  console.log('\n  Cycles detected:');
+  for (const c of cycles) {
+    console.log(`    ${c.from} -> ${c.to} (at depth ${c.depth})`);
+  }
+}
 
-  if (data.cycles.length > 0) {
-    console.log('\n  Cycles detected:');
-    for (const c of data.cycles) {
-      console.log(`    ${c.from} -> ${c.to} (at depth ${c.depth})`);
-    }
+export function flow(
+  name: string | undefined,
+  dbPath: string | undefined,
+  opts: FlowOpts = {},
+): void {
+  if (opts.list) {
+    runListEntryPoints(dbPath, opts);
+    return;
+  }
+
+  if (!name) {
+    console.log(
+      'Please provide a function or entry-point name. Use --list to see available entry points.',
+    );
+    return;
+  }
+
+  const data = flowData(name, dbPath, opts) as unknown as FlowResult;
+  if (outputResult(data, 'steps', opts)) return;
+
+  if (!data.entry) {
+    console.log(`No matching entry point or function found for "${name}".`);
+    return;
+  }
+
+  printFlowHeader(data);
+  const isLeaf = printFlowSteps(data);
+  if (!isLeaf) {
+    printFlowCycles(data.cycles);
   }
 }

package/src/types.ts

@@ -99,6 +99,7 @@ export type LanguageId =
   | 'ocaml'
   | 'ocaml-interface'
   | 'fsharp'
+  | 'fsharp-signature'
   | 'gleam'
   | 'clojure'
   | 'julia'
@@ -576,6 +577,7 @@ export interface TreeSitterNode {
   child(index: number): TreeSitterNode | null;
   namedChild(index: number): TreeSitterNode | null;
   childForFieldName(name: string): TreeSitterNode | null;
+  fieldNameForChild(index: number): string | null;
   parent: TreeSitterNode | null;
   previousSibling: TreeSitterNode | null;
   nextSibling: TreeSitterNode | null;
@@ -1062,7 +1064,20 @@ export interface BuildGraphOpts {
   complexity?: boolean;
   cfg?: boolean;
   scope?: string[];
+  /**
+   * Glob patterns merged on top of `config.exclude` for this build only.
+   * Lets callers extend exclusion programmatically without writing a config
+   * file — used by the benchmark scripts to skip resolution-benchmark
+   * fixtures that aren't representative of real code.
+   */
+  exclude?: string[];
   skipRegistry?: boolean;
+  /**
+   * Override the graph.db location. Resolved absolute. When omitted, the
+   * pipeline writes to `<rootDir>/.codegraph/graph.db` — same default as
+   * `findDbPath` for every other DB-scoped command.
+   */
+  dbPath?: string;
 }
 
 /** Build timing result from buildGraph. */
@@ -1113,7 +1128,7 @@ export interface CodegraphConfig {
   };
 
   embeddings: {
-    model: string;
+    model: string | null;
     llmProvider: string | null;
   };