@optave/codegraph 3.9.6 → 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/infrastructure/config.ts

@@ -147,6 +147,7 @@ export const DEFAULTS = {
       implementations: 50,
       interfaces: 50,
     },
+    disabledTools: [] as string[],
   },
 } satisfies CodegraphConfig;
 

package/src/mcp/server.ts

@@ -98,17 +98,15 @@ async function resolveDbPath(
   return dbPath;
 }
 
-function validateMultiRepoAccess(multiRepo: boolean, name: string, args: { repo?: string }): void {
+function validateMultiRepoAccess(multiRepo: boolean, args: { repo?: string }): void {
   if (!multiRepo && args.repo) {
     throw new ConfigError(
       'Multi-repo access is disabled. Restart with `codegraph mcp --multi-repo` to access other repositories.',
     );
   }
-  if (!multiRepo && name === 'list_repos') {
-    throw new ConfigError(
-      'Multi-repo access is disabled. Restart with `codegraph mcp --multi-repo` to list repositories.',
-    );
-  }
+  // Note: the `list_repos` tool is excluded from `enabledToolNames` when
+  // `multiRepo` is false (see `buildToolList`), so any call to it is rejected
+  // earlier in `createCallToolHandler` with an "Unknown tool" error.
 }
 
 /**
@@ -163,11 +161,17 @@ function createCallToolHandler(
   customDbPath: string | undefined,
   allowedRepos: string[] | undefined,
   getQueries: () => Promise<unknown>,
+  enabledToolNames: Set<string>,
 ) {
   return async (request: any) => {
     const { name, arguments: args } = request.params;
     try {
-      validateMultiRepoAccess(multiRepo, name, args);
+      if (!enabledToolNames.has(name)) {
+        return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+      }
+
+      validateMultiRepoAccess(multiRepo, args);
+
       const dbPath = await resolveDbPath(customDbPath, args, allowedRepos);
 
       const toolEntry = TOOL_HANDLERS.get(name);
@@ -209,6 +213,9 @@ export async function startMCPServer(
   // Apply config-based MCP page-size overrides
   const config = options.config || loadConfig();
   initMcpDefaults(config.mcp?.defaults ? { ...config.mcp.defaults } : undefined);
+  const disabledTools = [...(config.mcp?.disabledTools ?? [])];
+  const enabledTools = buildToolList(multiRepo, disabledTools);
+  const enabledToolNames = new Set(enabledTools.map((tool) => tool.name));
 
   const { Server, StdioServerTransport, ListToolsRequestSchema, CallToolRequestSchema } =
     await loadMCPSdk();
@@ -225,12 +232,12 @@ export async function startMCPServer(
   );
 
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: buildToolList(multiRepo),
+    tools: enabledTools,
   }));
 
   server.setRequestHandler(
     CallToolRequestSchema,
-    createCallToolHandler(multiRepo, customDbPath, allowedRepos, getQueries),
+    createCallToolHandler(multiRepo, customDbPath, allowedRepos, getQueries, enabledToolNames),
   );
 
   const transport = new (StdioServerTransport as any)();

package/src/mcp/tool-registry.ts

@@ -29,6 +29,17 @@ const PAGINATION_PROPS: Record<string, unknown> = {
   offset: { type: 'number', description: 'Skip this many results (pagination, default: 0)' },
 };
 
+function normalizeToolName(name: string): string {
+  return name
+    .trim()
+    .toLowerCase()
+    .replace(/^codegraph\d+_/, '');
+}
+
+function buildDisabledToolSet(disabledTools?: string[]): Set<string> {
+  return new Set((disabledTools || []).map((name) => normalizeToolName(name)).filter(Boolean));
+}
+
 const BASE_TOOLS: ToolSchema[] = [
   {
     name: 'query',
@@ -311,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'],
@@ -849,18 +865,25 @@ const LIST_REPOS_TOOL: ToolSchema = {
 /**
  * Build the tool list based on multi-repo mode.
  */
-export function buildToolList(multiRepo: boolean): ToolSchema[] {
-  if (!multiRepo) return BASE_TOOLS;
-  return [
-    ...BASE_TOOLS.map((tool) => ({
+export function buildToolList(multiRepo: boolean, disabledTools?: string[]): ToolSchema[] {
+  const disabled = buildDisabledToolSet(disabledTools);
+  const includeTool = (tool: ToolSchema): boolean => !disabled.has(normalizeToolName(tool.name));
+  const baseTools = BASE_TOOLS.filter(includeTool);
+
+  if (!multiRepo) return baseTools;
+
+  const tools: ToolSchema[] = [
+    ...baseTools.map((tool) => ({
       ...tool,
       inputSchema: {
         ...tool.inputSchema,
         properties: { ...tool.inputSchema.properties, ...REPO_PROP },
       },
     })),
-    LIST_REPOS_TOOL,
   ];
+
+  if (includeTool(LIST_REPOS_TOOL)) tools.push(LIST_REPOS_TOOL);
+  return tools;
 }
 
 // Backward-compatible export: full multi-repo tool list