@optave/codegraph 3.10.0 → 3.11.0

package/src/extractors/python.ts

@@ -122,7 +122,7 @@ function handlePyFunctionDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const parentClass = findPythonParentClass(node);
   const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
   const kind = parentClass ? 'method' : 'function';
-  const fnChildren = extractPythonParameters(node);
+  const fnChildren = extractPythonParameters(node, parentClass !== null);
   ctx.definitions.push({
     name: fullName,
     kind,
@@ -238,7 +238,7 @@ function handlePyImportFrom(node: TreeSitterNode, ctx: ExtractorOutput): void {
 
 // ── Python-specific helpers ─────────────────────────────────────────────────
 
-function extractPythonParameters(fnNode: TreeSitterNode): SubDeclaration[] {
+function extractPythonParameters(fnNode: TreeSitterNode, isMethod: boolean): SubDeclaration[] {
   const params: SubDeclaration[] = [];
   const paramsNode = fnNode.childForFieldName('parameters') || findChild(fnNode, 'parameters');
   if (!paramsNode) return params;
@@ -246,7 +246,9 @@ function extractPythonParameters(fnNode: TreeSitterNode): SubDeclaration[] {
     const child = paramsNode.child(i);
     if (!child) continue;
     const param = extractSinglePyParam(child);
-    if (param) params.push(param);
+    if (!param) continue;
+    if (isMethod && (param.name === 'self' || param.name === 'cls')) continue;
+    params.push(param);
   }
   return params;
 }

package/src/extractors/r.ts

@@ -125,11 +125,16 @@ function handleCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
     return;
   }
 
-  if (funcName === 'setGeneric' || funcName === 'setMethod') {
+  if (funcName === 'setGeneric') {
     handleSetGeneric(node, ctx);
     return;
   }
 
+  if (funcName === 'setMethod') {
+    handleSetMethod(node, ctx);
+    return;
+  }
+
   // Regular call
   if (funcNode.type === 'identifier') {
     ctx.calls.push({ name: funcName, line: node.startPosition.row + 1 });
@@ -147,7 +152,10 @@ function handleCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
 }
 
 function handleLibraryCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
-  // Find the package name in arguments
+  // Find the package name in arguments. For named arguments like
+  // `library(package = dplyr)`, prefer the field-named `value` child of the
+  // `argument` node so we extract `dplyr` (the value), not `package` (the
+  // parameter name). Keeps native (Rust) and WASM extractors in parity.
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child) continue;
@@ -174,9 +182,27 @@ function handleLibraryCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
         }
         // Argument might be wrapped
         if (arg.type === 'argument') {
-          const id = findChild(arg, 'identifier') || findChild(arg, 'string');
-          if (id) {
-            const text = id.text.replace(/^["']|["']$/g, '');
+          // Prefer the `value` field (correct for named arguments).
+          const valueNode = arg.childForFieldName('value');
+          let pick: TreeSitterNode | null = null;
+          if (valueNode && (valueNode.type === 'string' || valueNode.type === 'identifier')) {
+            pick = valueNode;
+          } else {
+            // Fallback: skip the parameter-name child if the grammar exposes
+            // it via the `name` field, then pick the first string/identifier.
+            const nameNode = arg.childForFieldName('name');
+            for (let k = 0; k < arg.childCount; k++) {
+              const inner = arg.child(k);
+              if (!inner) continue;
+              if (nameNode && inner.id === nameNode.id) continue;
+              if (inner.type === 'string' || inner.type === 'identifier') {
+                pick = inner;
+                break;
+              }
+            }
+          }
+          if (pick) {
+            const text = pick.text.replace(/^["']|["']$/g, '');
             ctx.imports.push({
               source: text,
               names: [text],
@@ -191,47 +217,55 @@ function handleLibraryCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
 }
 
 function handleSourceCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
-    if (!child || child.type !== 'arguments') continue;
-    for (let j = 0; j < child.childCount; j++) {
-      const arg = child.child(j);
-      if (!arg) continue;
-      if (arg.type === 'string') {
-        const text = arg.text.replace(/^["']|["']$/g, '');
-        ctx.imports.push({
-          source: text,
-          names: ['source'],
-          line: node.startPosition.row + 1,
-        });
-        return;
-      }
-    }
-  }
+  // source() only accepts string literals — `source(varname)` is not an import.
+  const path = firstStringArgument(node);
+  if (path === null) return;
+  ctx.imports.push({
+    source: path,
+    names: ['source'],
+    line: node.startPosition.row + 1,
+  });
 }
 
 function handleSetClass(node: TreeSitterNode, ctx: ExtractorOutput): void {
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
-    if (!child || child.type !== 'arguments') continue;
-    for (let j = 0; j < child.childCount; j++) {
-      const arg = child.child(j);
-      if (!arg) continue;
-      if (arg.type === 'string') {
-        const name = arg.text.replace(/^["']|["']$/g, '');
-        ctx.definitions.push({
-          name,
-          kind: 'class',
-          line: node.startPosition.row + 1,
-          endLine: nodeEndLine(node),
-        });
-        return;
-      }
-    }
-  }
+  const name = firstStringArgument(node);
+  if (name === null) return;
+  ctx.definitions.push({
+    name,
+    kind: 'class',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
 }
 
 function handleSetGeneric(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const name = firstStringArgument(node);
+  if (name === null) return;
+  ctx.definitions.push({
+    name,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+// setMethod("greet", "Person", function(x) ...) registers an implementation of
+// the generic `greet` — it is not a new top-level definition. Emitting a
+// definition here produced two `function` nodes with the same name (one from
+// setGeneric, one from setMethod) and broke resolution. Emit a call edge to
+// the generic instead; the method body's calls are still picked up by the
+// recursive walk of the anonymous function argument.
+function handleSetMethod(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const name = firstStringArgument(node);
+  if (name === null) return;
+  ctx.calls.push({ name, line: node.startPosition.row + 1 });
+}
+
+// tree-sitter-r wraps each positional argument in an `argument` node that
+// contains the actual `string` (or `identifier`) child, so the inner string
+// must be unwrapped — checking `child.type === 'string'` directly misses it.
+// Mirrors `first_argument_value` in the Rust extractor for parity.
+function firstStringArgument(node: TreeSitterNode): string | null {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child || child.type !== 'arguments') continue;
@@ -239,15 +273,21 @@ function handleSetGeneric(node: TreeSitterNode, ctx: ExtractorOutput): void {
       const arg = child.child(j);
       if (!arg) continue;
       if (arg.type === 'string') {
-        const name = arg.text.replace(/^["']|["']$/g, '');
-        ctx.definitions.push({
-          name,
-          kind: 'function',
-          line: node.startPosition.row + 1,
-          endLine: nodeEndLine(node),
-        });
-        return;
+        return stripQuotes(arg.text);
+      }
+      if (arg.type === 'argument') {
+        const valueNode = arg.childForFieldName('value');
+        if (valueNode && valueNode.type === 'string') return stripQuotes(valueNode.text);
+        for (let k = 0; k < arg.childCount; k++) {
+          const inner = arg.child(k);
+          if (inner && inner.type === 'string') return stripQuotes(inner.text);
+        }
       }
     }
   }
+  return null;
+}
+
+function stripQuotes(text: string): string {
+  return text.replace(/^["']|["']$/g, '');
 }

package/src/extractors/scala.ts

@@ -1,5 +1,6 @@
 import type {
   Call,
+  Definition,
   ExtractorOutput,
   SubDeclaration,
   TreeSitterNode,
@@ -59,52 +60,37 @@ function walkScalaNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
 // ── Walk-path per-node-type handlers ────────────────────────────────────────
 
 function handleScalaClassDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
-  const nameNode = node.childForFieldName('name');
-  if (!nameNode) return;
-  const name = nameNode.text;
-  const children = extractScalaBodyMembers(node, name, ctx);
-
-  ctx.definitions.push({
-    name,
-    kind: 'class',
-    line: node.startPosition.row + 1,
-    endLine: nodeEndLine(node),
-    children: children.length > 0 ? children : undefined,
-  });
-
-  extractScalaInheritance(node, name, ctx);
+  emitScalaTypeDef(node, ctx, 'class');
 }
 
 function handleScalaTraitDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
-  const nameNode = node.childForFieldName('name');
-  if (!nameNode) return;
-  const name = nameNode.text;
-  const children = extractScalaBodyMembers(node, name, ctx);
-
-  ctx.definitions.push({
-    name,
-    kind: 'interface',
-    line: node.startPosition.row + 1,
-    endLine: nodeEndLine(node),
-    children: children.length > 0 ? children : undefined,
-  });
-
-  extractScalaInheritance(node, name, ctx);
+  emitScalaTypeDef(node, ctx, 'interface');
 }
 
 function handleScalaObjectDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  emitScalaTypeDef(node, ctx, 'class');
+}
+
+function emitScalaTypeDef(
+  node: TreeSitterNode,
+  ctx: ExtractorOutput,
+  kind: 'class' | 'interface',
+): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   const name = nameNode.text;
-  const children = extractScalaBodyMembers(node, name, ctx);
+  const { children, methods } = collectScalaBodyMembers(node, name);
 
+  // Push the type def before its methods so the definition order follows
+  // source-line order (matches native, which walks depth-first).
   ctx.definitions.push({
     name,
-    kind: 'class',
+    kind,
     line: node.startPosition.row + 1,
     endLine: nodeEndLine(node),
     children: children.length > 0 ? children : undefined,
   });
+  for (const m of methods) ctx.definitions.push(m);
 
   extractScalaInheritance(node, name, ctx);
 }
@@ -224,14 +210,14 @@ function extractScalaInheritance(node: TreeSitterNode, name: string, ctx: Extrac
 
 // ── Body member extraction ──────────────────────────────────────────────────
 
-function extractScalaBodyMembers(
+function collectScalaBodyMembers(
   parentNode: TreeSitterNode,
   parentName: string,
-  ctx: ExtractorOutput,
-): SubDeclaration[] {
+): { children: SubDeclaration[]; methods: Definition[] } {
   const children: SubDeclaration[] = [];
+  const methods: Definition[] = [];
   const body = findChild(parentNode, 'template_body');
-  if (!body) return children;
+  if (!body) return { children, methods };
 
   for (let i = 0; i < body.childCount; i++) {
     const member = body.child(i);
@@ -240,12 +226,14 @@ function extractScalaBodyMembers(
     if (member.type === 'function_definition') {
       const methName = member.childForFieldName('name');
       if (methName) {
-        ctx.definitions.push({
+        const params = extractScalaParameters(member);
+        methods.push({
           name: `${parentName}.${methName.text}`,
           kind: 'method',
           line: member.startPosition.row + 1,
           endLine: member.endPosition.row + 1,
           visibility: extractModifierVisibility(member),
+          children: params.length > 0 ? params : undefined,
         });
       }
     } else if (member.type === 'val_definition' || member.type === 'var_definition') {
@@ -264,7 +252,7 @@ function extractScalaBodyMembers(
     }
   }
 
-  return children;
+  return { children, methods };
 }
 
 // ── Parameter extraction ────────────────────────────────────────────────────

package/src/extractors/solidity.ts

@@ -156,15 +156,24 @@ function extractContractMember(child: TreeSitterNode): SubDeclaration | null {
   }
 }
 
-/** Extract inheritance (extends) relationships from a contract node. */
+/**
+ * Extract inheritance (extends) relationships from a contract node.
+ *
+ * Each parent in `contract A is B, C, D { }` is its own `inheritance_specifier`
+ * sibling under the contract node (see tree-sitter-solidity grammar:
+ * `_class_heritage: "is" commaSep1($.inheritance_specifier)`), so we must walk
+ * all direct children rather than stopping at the first match.
+ */
 function extractInheritance(node: TreeSitterNode, name: string, ctx: ExtractorOutput): void {
-  const inheritance = findChild(node, 'inheritance_specifier');
-  if (!inheritance) return;
-  for (let i = 0; i < inheritance.childCount; i++) {
-    const child = inheritance.child(i);
-    if (!child) continue;
-    if (child.type === 'user_defined_type' || child.type === 'identifier') {
-      ctx.classes.push({ name, extends: child.text, line: node.startPosition.row + 1 });
+  for (let i = 0; i < node.childCount; i++) {
+    const inheritance = node.child(i);
+    if (!inheritance || inheritance.type !== 'inheritance_specifier') continue;
+    for (let j = 0; j < inheritance.childCount; j++) {
+      const child = inheritance.child(j);
+      if (!child) continue;
+      if (child.type === 'user_defined_type' || child.type === 'identifier') {
+        ctx.classes.push({ name, extends: child.text, line: node.startPosition.row + 1 });
+      }
     }
   }
 }

package/src/extractors/verilog.ts

@@ -99,27 +99,60 @@ function handlePackageDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
 }
 
 function handleClassDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
-  const nameNode = node.childForFieldName('name');
-  if (!nameNode) return;
+  // tree-sitter-verilog exposes no field names on `class_declaration`. The
+  // class name lives under a `class_identifier > simple_identifier` chain, and
+  // the superclass appears as a `class_type` child (no `superclass` field).
+  // The Rust extractor in `crates/codegraph-core/src/extractors/verilog.rs`
+  // uses the same structural lookups so both engines emit identical class
+  // definitions and `extends` relations.
+  const name = findClassName(node);
+  if (!name) return;
 
   ctx.definitions.push({
-    name: nameNode.text,
+    name,
     kind: 'class',
     line: node.startPosition.row + 1,
     endLine: nodeEndLine(node),
   });
 
-  // Superclass via extends
-  const superclass = node.childForFieldName('superclass');
+  const superclass = findClassSuperclass(node);
   if (superclass) {
     ctx.classes.push({
-      name: nameNode.text,
-      extends: superclass.text,
+      name,
+      extends: superclass,
       line: node.startPosition.row + 1,
     });
   }
 }
 
+function findClassName(node: TreeSitterNode): string | null {
+  const fieldName = node.childForFieldName('name');
+  if (fieldName) return fieldName.text;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === 'class_identifier') {
+      const simple = findChild(child, 'simple_identifier');
+      return (simple ?? child).text.trim();
+    }
+  }
+  return null;
+}
+
+function findClassSuperclass(node: TreeSitterNode): string | null {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === 'class_type') {
+      const id = findChild(child, 'class_identifier');
+      if (id) {
+        const simple = findChild(id, 'simple_identifier');
+        return (simple ?? id).text.trim();
+      }
+      return child.text.trim();
+    }
+  }
+  return null;
+}
+
 function handleFunctionDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = findFunctionOrTaskName(node, 'function_identifier');
   if (!nameNode) return;
@@ -151,8 +184,12 @@ function handleTaskDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
 }
 
 function handleModuleInstantiation(node: TreeSitterNode, ctx: ExtractorOutput): void {
-  // Module instantiations are like function calls: `ModuleName instance_name(...);`
-  const moduleType = node.childForFieldName('type') || node.child(0);
+  // Module instantiations are like function calls: `ModuleName instance_name(...);`.
+  // The module type identifier is the first *named* child; using
+  // `namedChild(0)` (instead of `child(0)`) skips anonymous tokens like a
+  // leading `#` parameter-override punctuation so we never capture that as a
+  // call name. The Rust extractor uses the same lookup for parity.
+  const moduleType = node.childForFieldName('type') ?? node.namedChild(0);
   if (!moduleType) return;
 
   ctx.calls.push({
@@ -169,7 +206,10 @@ function handlePackageImport(node: TreeSitterNode, ctx: ExtractorOutput): void {
     if (child.type === 'package_import_item') {
       const text = child.text;
       const parts = text.split('::');
-      const pkg = parts[0] ?? text;
+      // `String.split('::')` always yields at least one element — when the
+      // delimiter is absent the whole string is the sole item, so the
+      // empty-string fallback is unreachable in practice.
+      const pkg = parts[0] ?? '';
       const item = parts[1] ?? '*';
       ctx.imports.push({
         source: pkg,
@@ -182,9 +222,18 @@ function handlePackageImport(node: TreeSitterNode, ctx: ExtractorOutput): void {
 
 function handleIncludeDirective(node: TreeSitterNode, ctx: ExtractorOutput): void {
   // `include "file.vh"
+  // Mirrors the Rust `handle_include_directive` which checks all three node
+  // kinds — tree-sitter-verilog has emitted `double_quoted_string` in some
+  // grammar revisions, and missing it would silently drop the import in WASM
+  // while the native engine still records it.
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
-    if (child && (child.type === 'string_literal' || child.type === 'quoted_string')) {
+    if (
+      child &&
+      (child.type === 'string_literal' ||
+        child.type === 'quoted_string' ||
+        child.type === 'double_quoted_string')
+    ) {
       const source = child.text.replace(/^["']|["']$/g, '');
       ctx.imports.push({
         source,
@@ -266,8 +315,14 @@ function findVerilogParent(node: TreeSitterNode): string | null {
       current.type === 'package_declaration' ||
       current.type === 'class_declaration'
     ) {
-      const name = findDeclName(current) || findModuleName(current);
-      return name ? name.text : null;
+      // `class_declaration` wraps its name in `class_identifier >
+      // simple_identifier`; `findDeclName` / `findModuleName` only look at
+      // bare `simple_identifier`/`identifier` children, so they miss it.
+      // `findClassName` already handles the wrapper, so consult it last to
+      // qualify tasks/functions nested inside a SystemVerilog class.
+      const nameNode = findDeclName(current) || findModuleName(current);
+      if (nameNode) return nameNode.text;
+      return findClassName(current);
     }
     current = current.parent;
   }
@@ -292,17 +347,30 @@ function extractPorts(moduleNode: TreeSitterNode): SubDeclaration[] {
       ) {
         const nameNode =
           child.childForFieldName('name') ||
+          findChild(child, 'port_identifier') ||
           findChild(child, 'simple_identifier') ||
           findChild(child, 'identifier');
         if (nameNode) {
-          ports.push({ name: nameNode.text, kind: 'property', line: child.startPosition.row + 1 });
+          // `port_identifier` wraps a `simple_identifier`; descend to the
+          // innermost identifier for a clean, whitespace-free name.
+          const inner =
+            findChild(nameNode, 'simple_identifier') ||
+            findChild(nameNode, 'identifier') ||
+            nameNode;
+          ports.push({ name: inner.text, kind: 'property', line: child.startPosition.row + 1 });
         }
       }
 
-      // Recurse into port list containers
+      // Recurse into port list containers. `module_ansi_header` wraps the
+      // ANSI-style declarations emitted by tree-sitter-verilog (e.g.
+      // `module top(input clk, output reg q);`) — without this branch the
+      // WASM engine returns an empty children array while the native engine
+      // (which includes the same kind in its CONTAINER_KINDS list) returns
+      // the correct ports, breaking engine parity.
       if (
         child.type === 'list_of_port_declarations' ||
         child.type === 'module_header' ||
+        child.type === 'module_ansi_header' ||
         child.type === 'port_declaration_list'
       ) {
         collectFromNode(child);

package/src/mcp/tool-registry.ts

@@ -322,6 +322,11 @@ const BASE_TOOLS: ToolSchema[] = [
           description:
             'Search mode: hybrid (BM25 + semantic, default), semantic (embeddings only), keyword (BM25 only)',
         },
+        file_pattern: {
+          oneOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }],
+          description:
+            'Restrict results to files matching one or more glob or substring patterns (e.g. "db/", "src/**/*.ts", or ["db/", "src/"])',
+        },
         ...PAGINATION_PROPS,
       },
       required: ['query'],

package/src/mcp/tools/semantic-search.ts

@@ -9,6 +9,7 @@ interface SemanticSearchArgs {
   limit?: number;
   offset?: number;
   min_score?: number;
+  file_pattern?: string | string[];
 }
 
 export async function handler(args: SemanticSearchArgs, ctx: McpToolContext): Promise<unknown> {
@@ -17,6 +18,7 @@ export async function handler(args: SemanticSearchArgs, ctx: McpToolContext): Pr
     limit: Math.min(args.limit ?? MCP_DEFAULTS.semantic_search ?? 100, ctx.MCP_MAX_LIMIT),
     offset: effectiveOffset(args),
     minScore: args.min_score,
+    filePattern: args.file_pattern,
   };
 
   if (mode === 'keyword') {

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. */