feat(web): replace language param with path in symbol tools, make repo mandatory

- find_symbol_definitions and find_symbol_references now accept `path`
  (the file where the symbol was encountered) instead of `language`
- Language is derived internally via detectLanguageFromFilename
- `repo` is now required in both tool schemas
- Also fixes ambiguous extension overrides in languageDetection.ts

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: brendan-kellam

packages/web/src/features/tools/findSymbolDefinitions.ts

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import { isServiceError } from "@/lib/utils";
+import { findSearchBasedSymbolDefinitions } from "@/features/codeNav/api";
+import { addLineNumbers } from "@/features/chat/utils";
+import { ToolDefinition } from "./types";
+import { FindSymbolFile } from "./findSymbolReferences";
+import { logger } from "./logger";
+import description from "./findSymbolDefinitions.txt";
+import { detectLanguageFromFilename } from "@/lib/languageDetection";
+
+const findSymbolDefinitionsShape = {
+    symbol: z.string().describe("The symbol to find definitions of"),
+    path: z.string().describe("The file path where the symbol was encountered."),
+    repo: z.string().describe("The repository to scope the search to"),
+};
+
+export type FindSymbolDefinitionsMetadata = {
+    files: FindSymbolFile[];
+};
+
+export const findSymbolDefinitionsDefinition: ToolDefinition<
+    'find_symbol_definitions',
+    typeof findSymbolDefinitionsShape,
+    FindSymbolDefinitionsMetadata
+> = {
+    name: 'find_symbol_definitions',
+    title: 'Find symbol definitions',
+    isReadOnly: true,
+    isIdempotent: true,
+    description,
+    inputSchema: z.object(findSymbolDefinitionsShape),
+    execute: async ({ symbol, path, repo }, _context) => {
+        logger.debug('find_symbol_definitions', { symbol, path, repo });
+        const revision = "HEAD";
+        const language = detectLanguageFromFilename(path);
+
+        const response = await findSearchBasedSymbolDefinitions({
+            symbolName: symbol,
+            language,
+            revisionName: revision,
+            repoName: repo,
+        });
+
+        if (isServiceError(response)) {
+            throw new Error(response.message);
+        }
+
+        const metadata: FindSymbolDefinitionsMetadata = {
+            files: response.files.map((file) => ({
+                fileName: file.fileName,
+                repo: file.repository,
+                language: file.language,
+                matches: file.matches.map(({ lineContent, range }) => {
+                    return addLineNumbers(lineContent, range.start.lineNumber);
+                }),
+                revision,
+            })),
+        };
+
+        return {
+            output: JSON.stringify(metadata),
+            metadata,
+        };
+    },
+};

packages/web/src/features/tools/findSymbolReferences.ts

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { isServiceError } from "@/lib/utils";
+import { findSearchBasedSymbolReferences } from "@/features/codeNav/api";
+import { addLineNumbers } from "@/features/chat/utils";
+import { ToolDefinition } from "./types";
+import { logger } from "./logger";
+import description from "./findSymbolReferences.txt";
+import { detectLanguageFromFilename } from "@/lib/languageDetection";
+
+const findSymbolReferencesShape = {
+    symbol: z.string().describe("The symbol to find references to"),
+    path: z.string().describe("The file path where the symbol was encountered."),
+    repo: z.string().describe("The repository to scope the search to"),
+};
+
+export type FindSymbolFile = {
+    fileName: string;
+    repo: string;
+    language: string;
+    matches: string[];
+    revision: string;
+};
+
+export type FindSymbolReferencesMetadata = {
+    files: FindSymbolFile[];
+};
+
+export const findSymbolReferencesDefinition: ToolDefinition<
+    'find_symbol_references',
+    typeof findSymbolReferencesShape,
+    FindSymbolReferencesMetadata
+> = {
+    name: 'find_symbol_references',
+    title: 'Find symbol references',
+    isReadOnly: true,
+    isIdempotent: true,
+    description,
+    inputSchema: z.object(findSymbolReferencesShape),
+    execute: async ({ symbol, path, repo }, _context) => {
+        logger.debug('find_symbol_references', { symbol, path, repo });
+        const revision = "HEAD";
+        const language = detectLanguageFromFilename(path);
+
+        const response = await findSearchBasedSymbolReferences({
+            symbolName: symbol,
+            language,
+            revisionName: revision,
+            repoName: repo,
+        });
+
+        if (isServiceError(response)) {
+            throw new Error(response.message);
+        }
+
+        const metadata: FindSymbolReferencesMetadata = {
+            files: response.files.map((file) => ({
+                fileName: file.fileName,
+                repo: file.repository,
+                language: file.language,
+                matches: file.matches.map(({ lineContent, range }) => {
+                    return addLineNumbers(lineContent, range.start.lineNumber);
+                }),
+                revision,
+            })),
+        };
+
+        return {
+            output: JSON.stringify(metadata),
+            metadata,
+        };
+    },
+};

packages/web/src/lib/languageDetection.ts

@@ -1,6 +1,23 @@
 import * as linguistLanguages from 'linguist-languages';
 import path from 'path';
 
+// Override map for extensions that are ambiguous in linguist-languages.
+// These are extensions where linguist maps to multiple languages, but one
+// is overwhelmingly more common in practice.
+const ambiguousExtensionOverrides: Record<string, string> = {
+    '.cs': 'C#',        // Not Smalltalk
+    '.fs': 'F#',        // Not Forth, GLSL, or Filterscript
+    '.html': 'HTML',    // Not Ecmarkup
+    '.json': 'JSON',    // Not OASv2-json, OASv3-json
+    '.md': 'Markdown',  // Not GCC Machine Description
+    '.rs': 'Rust',      // Not RenderScript (deprecated)
+    '.tsx': 'TSX',      // Not XML
+    '.ts': 'TypeScript', // Not XML
+    '.txt': 'Text',     // Not Adblock Filter List, Vim Help File
+    '.yaml': 'YAML',    // Not MiniYAML, OASv2-yaml, OASv3-yaml
+    '.yml': 'YAML',
+};
+
 const extensionToLanguage = new Map<string, string>();
 
 for (const [languageName, languageData] of Object.entries(linguistLanguages)) {
@@ -31,6 +48,12 @@ export const detectLanguageFromFilename = (filename: string): string => {
 
     // Check for extension match
     const ext = path.extname(filename).toLowerCase();
+
+    // Check override map first for ambiguous extensions
+    if (ext && ext in ambiguousExtensionOverrides) {
+        return ambiguousExtensionOverrides[ext];
+    }
+
     if (ext && extensionToLanguage.has(ext)) {
         return extensionToLanguage.get(ext)!;
     }