v1.12 track B.2: codecontext tool wrappers + tests

apps/server/src/services/tools/codecontext/get_codebase_overview.ts

@@ -0,0 +1,59 @@
+// v1.12 Track B.2: codecontext wrapper — get_codebase_overview.
+// Pattern mirrors services/web_search.ts: pure executor + ToolDef wrapper.
+// target_dir is supplied by callCodecontext from the resolved project root.
+
+import { z } from 'zod';
+import type { ToolDef } from '../../tools.js';
+import { callCodecontext, type CodecontextResponse } from '../../codecontext_client.js';
+
+export const GetCodebaseOverviewInput = z.object({
+  include_stats: z.boolean().optional(),
+});
+export type GetCodebaseOverviewInputT = z.infer<typeof GetCodebaseOverviewInput>;
+
+const DESCRIPTION =
+  'Returns a structured overview of the codebase: file count, symbol count, primary languages, and top-level architecture. ' +
+  'Use this before deeper investigation to orient yourself in an unfamiliar codebase. ' +
+  'Tree-sitter coverage: full for JS/Python/Java/Go/Rust/C++. TypeScript symbols are approximate (uses JS grammar). ' +
+  'PHP and SQL are not supported — fall back to view_file/grep for those.';
+
+export async function executeGetCodebaseOverview(
+  input: GetCodebaseOverviewInputT,
+  projectPath: string,
+  fetcher: typeof fetch = fetch,
+): Promise<CodecontextResponse> {
+  return callCodecontext(
+    {
+      toolName: 'get_codebase_overview',
+      args: { include_stats: input.include_stats ?? true },
+      projectPath,
+    },
+    fetcher,
+  );
+}
+
+export const getCodebaseOverview: ToolDef<GetCodebaseOverviewInputT> = {
+  name: 'get_codebase_overview',
+  description: DESCRIPTION,
+  inputSchema: GetCodebaseOverviewInput,
+  jsonSchema: {
+    type: 'function',
+    function: {
+      name: 'get_codebase_overview',
+      description: DESCRIPTION,
+      parameters: {
+        type: 'object',
+        properties: {
+          include_stats: {
+            type: 'boolean',
+            description: 'Include file count, symbol count, language stats. Defaults to true.',
+          },
+        },
+        additionalProperties: false,
+      },
+    },
+  },
+  async execute(input, projectRoot) {
+    return await executeGetCodebaseOverview(input, projectRoot);
+  },
+};

apps/server/src/services/tools/codecontext/get_dependencies.ts

@@ -0,0 +1,60 @@
+// v1.12 Track B.2: codecontext wrapper — get_dependencies.
+
+import { z } from 'zod';
+import type { ToolDef } from '../../tools.js';
+import { callCodecontext, type CodecontextResponse } from '../../codecontext_client.js';
+
+export const GetDependenciesInput = z.object({
+  file_path: z.string().optional(),
+  direction: z.enum(['incoming', 'outgoing', 'both']).optional(),
+});
+export type GetDependenciesInputT = z.infer<typeof GetDependenciesInput>;
+
+const DESCRIPTION =
+  'Returns the import/dependency graph either for a single file (when file_path is set) or for the whole project. ' +
+  'Direction "outgoing" = what this file imports; "incoming" = what imports this file; "both" = the union. ' +
+  'Tree-sitter coverage: full for JS/Python/Java/Go/Rust/C++. TypeScript dependencies are approximate. ' +
+  'PHP and SQL are not supported.';
+
+export async function executeGetDependencies(
+  input: GetDependenciesInputT,
+  projectPath: string,
+  fetcher: typeof fetch = fetch,
+): Promise<CodecontextResponse> {
+  const args: Record<string, unknown> = {
+    direction: input.direction ?? 'both',
+  };
+  if (input.file_path) args['file_path'] = input.file_path;
+  return callCodecontext({ toolName: 'get_dependencies', args, projectPath }, fetcher);
+}
+
+export const getDependencies: ToolDef<GetDependenciesInputT> = {
+  name: 'get_dependencies',
+  description: DESCRIPTION,
+  inputSchema: GetDependenciesInput,
+  jsonSchema: {
+    type: 'function',
+    function: {
+      name: 'get_dependencies',
+      description: DESCRIPTION,
+      parameters: {
+        type: 'object',
+        properties: {
+          file_path: {
+            type: 'string',
+            description: 'Narrow to a single file. Omit for a project-wide graph.',
+          },
+          direction: {
+            type: 'string',
+            enum: ['incoming', 'outgoing', 'both'],
+            description: 'Which edges to include. Defaults to "both".',
+          },
+        },
+        additionalProperties: false,
+      },
+    },
+  },
+  async execute(input, projectRoot) {
+    return await executeGetDependencies(input, projectRoot);
+  },
+};

apps/server/src/services/tools/codecontext/get_file_analysis.ts

@@ -0,0 +1,58 @@
+// v1.12 Track B.2: codecontext wrapper — get_file_analysis.
+
+import { z } from 'zod';
+import type { ToolDef } from '../../tools.js';
+import { callCodecontext, type CodecontextResponse } from '../../codecontext_client.js';
+
+export const GetFileAnalysisInput = z.object({
+  file_path: z.string().min(1),
+});
+export type GetFileAnalysisInputT = z.infer<typeof GetFileAnalysisInput>;
+
+const DESCRIPTION =
+  'Returns detailed analysis of a single file: symbols defined, imports, exports, and inferred role. ' +
+  'Use when you have a specific file in mind and need its structure without view_file-ing the whole thing. ' +
+  'Tree-sitter coverage: full for JS/Python/Java/Go/Rust/C++. TypeScript symbols are approximate. ' +
+  'PHP and SQL are not supported — fall back to view_file for those.';
+
+export async function executeGetFileAnalysis(
+  input: GetFileAnalysisInputT,
+  projectPath: string,
+  fetcher: typeof fetch = fetch,
+): Promise<CodecontextResponse> {
+  return callCodecontext(
+    {
+      toolName: 'get_file_analysis',
+      args: { file_path: input.file_path },
+      projectPath,
+    },
+    fetcher,
+  );
+}
+
+export const getFileAnalysis: ToolDef<GetFileAnalysisInputT> = {
+  name: 'get_file_analysis',
+  description: DESCRIPTION,
+  inputSchema: GetFileAnalysisInput,
+  jsonSchema: {
+    type: 'function',
+    function: {
+      name: 'get_file_analysis',
+      description: DESCRIPTION,
+      parameters: {
+        type: 'object',
+        properties: {
+          file_path: {
+            type: 'string',
+            description: 'Absolute or project-relative path to the file.',
+          },
+        },
+        required: ['file_path'],
+        additionalProperties: false,
+      },
+    },
+  },
+  async execute(input, projectRoot) {
+    return await executeGetFileAnalysis(input, projectRoot);
+  },
+};

apps/server/src/services/tools/codecontext/get_framework_analysis.ts

@@ -0,0 +1,58 @@
+// v1.12 Track B.2: codecontext wrapper — get_framework_analysis.
+
+import { z } from 'zod';
+import type { ToolDef } from '../../tools.js';
+import { callCodecontext, type CodecontextResponse } from '../../codecontext_client.js';
+
+export const GetFrameworkAnalysisInput = z.object({
+  framework: z.string().optional(),
+  include_stats: z.boolean().optional(),
+});
+export type GetFrameworkAnalysisInputT = z.infer<typeof GetFrameworkAnalysisInput>;
+
+const DESCRIPTION =
+  'Returns framework-specific structural analysis: component relationships (React), hook usage patterns, store wiring (Vue/Pinia), service registration (Angular/Nest), etc. ' +
+  'When framework is omitted, codecontext auto-detects from the project files. ' +
+  'Tree-sitter coverage: full for JS/Python/Java/Go/Rust/C++. TypeScript is approximate. ' +
+  'PHP and SQL are not supported.';
+
+export async function executeGetFrameworkAnalysis(
+  input: GetFrameworkAnalysisInputT,
+  projectPath: string,
+  fetcher: typeof fetch = fetch,
+): Promise<CodecontextResponse> {
+  const args: Record<string, unknown> = {};
+  if (input.framework) args['framework'] = input.framework;
+  if (input.include_stats !== undefined) args['include_stats'] = input.include_stats;
+  return callCodecontext({ toolName: 'get_framework_analysis', args, projectPath }, fetcher);
+}
+
+export const getFrameworkAnalysis: ToolDef<GetFrameworkAnalysisInputT> = {
+  name: 'get_framework_analysis',
+  description: DESCRIPTION,
+  inputSchema: GetFrameworkAnalysisInput,
+  jsonSchema: {
+    type: 'function',
+    function: {
+      name: 'get_framework_analysis',
+      description: DESCRIPTION,
+      parameters: {
+        type: 'object',
+        properties: {
+          framework: {
+            type: 'string',
+            description: 'Framework name. Auto-detected if omitted.',
+          },
+          include_stats: {
+            type: 'boolean',
+            description: 'Include component/hook/service counts.',
+          },
+        },
+        additionalProperties: false,
+      },
+    },
+  },
+  async execute(input, projectRoot) {
+    return await executeGetFrameworkAnalysis(input, projectRoot);
+  },
+};

apps/server/src/services/tools/codecontext/get_semantic_neighborhoods.ts

@@ -0,0 +1,73 @@
+// v1.12 Track B.2: codecontext wrapper — get_semantic_neighborhoods.
+
+import { z } from 'zod';
+import type { ToolDef } from '../../tools.js';
+import { callCodecontext, type CodecontextResponse } from '../../codecontext_client.js';
+
+export const GetSemanticNeighborhoodsInput = z.object({
+  file_path: z.string().optional(),
+  include_basic: z.boolean().optional(),
+  include_quality: z.boolean().optional(),
+  max_results: z.number().int().positive().optional(),
+});
+export type GetSemanticNeighborhoodsInputT = z.infer<typeof GetSemanticNeighborhoodsInput>;
+
+const DESCRIPTION =
+  'Returns semantic neighborhoods — clusters of related files derived from git co-change patterns and import structure. ' +
+  'Use when you want to find code that "belongs together" with a given file without enumerating imports manually. ' +
+  'Tree-sitter coverage: full for JS/Python/Java/Go/Rust/C++. TypeScript is approximate. ' +
+  'PHP and SQL are not supported.';
+
+const DEFAULT_MAX_RESULTS = 10;
+
+export async function executeGetSemanticNeighborhoods(
+  input: GetSemanticNeighborhoodsInputT,
+  projectPath: string,
+  fetcher: typeof fetch = fetch,
+): Promise<CodecontextResponse> {
+  const args: Record<string, unknown> = {
+    max_results: input.max_results ?? DEFAULT_MAX_RESULTS,
+  };
+  if (input.file_path) args['file_path'] = input.file_path;
+  if (input.include_basic !== undefined) args['include_basic'] = input.include_basic;
+  if (input.include_quality !== undefined) args['include_quality'] = input.include_quality;
+  return callCodecontext({ toolName: 'get_semantic_neighborhoods', args, projectPath }, fetcher);
+}
+
+export const getSemanticNeighborhoods: ToolDef<GetSemanticNeighborhoodsInputT> = {
+  name: 'get_semantic_neighborhoods',
+  description: DESCRIPTION,
+  inputSchema: GetSemanticNeighborhoodsInput,
+  jsonSchema: {
+    type: 'function',
+    function: {
+      name: 'get_semantic_neighborhoods',
+      description: DESCRIPTION,
+      parameters: {
+        type: 'object',
+        properties: {
+          file_path: {
+            type: 'string',
+            description: 'Anchor file for the neighborhood query. Omit for a project-wide view.',
+          },
+          include_basic: {
+            type: 'boolean',
+            description: 'Include the basic (import-based) neighborhood. Default true.',
+          },
+          include_quality: {
+            type: 'boolean',
+            description: 'Include code-quality metrics for the neighborhood. Default false.',
+          },
+          max_results: {
+            type: 'integer',
+            description: `Cap on neighborhoods returned. Defaults to ${DEFAULT_MAX_RESULTS}.`,
+          },
+        },
+        additionalProperties: false,
+      },
+    },
+  },
+  async execute(input, projectRoot) {
+    return await executeGetSemanticNeighborhoods(input, projectRoot);
+  },
+};

apps/server/src/services/tools/codecontext/get_symbol_info.ts

@@ -0,0 +1,63 @@
+// v1.12 Track B.2: codecontext wrapper — get_symbol_info.
+
+import { z } from 'zod';
+import type { ToolDef } from '../../tools.js';
+import { callCodecontext, type CodecontextResponse } from '../../codecontext_client.js';
+
+export const GetSymbolInfoInput = z.object({
+  symbol_name: z.string().min(1),
+  file_path: z.string().optional(),
+  framework_type: z.string().optional(),
+});
+export type GetSymbolInfoInputT = z.infer<typeof GetSymbolInfoInput>;
+
+const DESCRIPTION =
+  'Returns detailed information about a named symbol: definition location, kind (function/class/method/etc.), and (when known) framework-specific context (React component, Vue store, Angular service, …). ' +
+  'Tree-sitter coverage: full for JS/Python/Java/Go/Rust/C++. TypeScript symbols are approximate (uses JS grammar). ' +
+  'PHP and SQL are not supported — fall back to grep for those.';
+
+export async function executeGetSymbolInfo(
+  input: GetSymbolInfoInputT,
+  projectPath: string,
+  fetcher: typeof fetch = fetch,
+): Promise<CodecontextResponse> {
+  const args: Record<string, unknown> = { symbol_name: input.symbol_name };
+  if (input.file_path) args['file_path'] = input.file_path;
+  if (input.framework_type) args['framework_type'] = input.framework_type;
+  return callCodecontext({ toolName: 'get_symbol_info', args, projectPath }, fetcher);
+}
+
+export const getSymbolInfo: ToolDef<GetSymbolInfoInputT> = {
+  name: 'get_symbol_info',
+  description: DESCRIPTION,
+  inputSchema: GetSymbolInfoInput,
+  jsonSchema: {
+    type: 'function',
+    function: {
+      name: 'get_symbol_info',
+      description: DESCRIPTION,
+      parameters: {
+        type: 'object',
+        properties: {
+          symbol_name: {
+            type: 'string',
+            description: 'The symbol name to look up (case-sensitive).',
+          },
+          file_path: {
+            type: 'string',
+            description: 'Narrow to a specific file when the symbol name is ambiguous.',
+          },
+          framework_type: {
+            type: 'string',
+            description: 'Hint for framework-specific extraction (react|vue|svelte|django|fastapi|express|nest|…).',
+          },
+        },
+        required: ['symbol_name'],
+        additionalProperties: false,
+      },
+    },
+  },
+  async execute(input, projectRoot) {
+    return await executeGetSymbolInfo(input, projectRoot);
+  },
+};

apps/server/src/services/tools/codecontext/index.ts

@@ -0,0 +1,11 @@
+// v1.12 Track B.2: codecontext tool registry. Re-exports the 8 ToolDefs so
+// tools.ts can pull them in one line.
+
+export { getCodebaseOverview } from './get_codebase_overview.js';
+export { getFileAnalysis } from './get_file_analysis.js';
+export { getSymbolInfo } from './get_symbol_info.js';
+export { searchSymbols } from './search_symbols.js';
+export { getDependencies } from './get_dependencies.js';
+export { watchChanges } from './watch_changes.js';
+export { getSemanticNeighborhoods } from './get_semantic_neighborhoods.js';
+export { getFrameworkAnalysis } from './get_framework_analysis.js';

apps/server/src/services/tools/codecontext/search_symbols.ts

@@ -0,0 +1,77 @@
+// v1.12 Track B.2: codecontext wrapper — search_symbols.
+
+import { z } from 'zod';
+import type { ToolDef } from '../../tools.js';
+import { callCodecontext, type CodecontextResponse } from '../../codecontext_client.js';
+
+export const SearchSymbolsInput = z.object({
+  query: z.string().min(1),
+  file_type: z.string().optional(),
+  symbol_type: z.string().optional(),
+  framework_type: z.string().optional(),
+  limit: z.number().int().positive().optional(),
+});
+export type SearchSymbolsInputT = z.infer<typeof SearchSymbolsInput>;
+
+const DESCRIPTION =
+  'Search for symbols (functions, classes, methods, types) across the codebase by name fragment. ' +
+  'Filter by file_type, symbol_type, or framework_type to narrow. ' +
+  'Tree-sitter coverage: full for JS/Python/Java/Go/Rust/C++. TypeScript symbols are approximate. ' +
+  'PHP and SQL are not supported — fall back to grep for those.';
+
+const DEFAULT_LIMIT = 20;
+
+export async function executeSearchSymbols(
+  input: SearchSymbolsInputT,
+  projectPath: string,
+  fetcher: typeof fetch = fetch,
+): Promise<CodecontextResponse> {
+  const args: Record<string, unknown> = {
+    query: input.query,
+    limit: input.limit ?? DEFAULT_LIMIT,
+  };
+  if (input.file_type) args['file_type'] = input.file_type;
+  if (input.symbol_type) args['symbol_type'] = input.symbol_type;
+  if (input.framework_type) args['framework_type'] = input.framework_type;
+  return callCodecontext({ toolName: 'search_symbols', args, projectPath }, fetcher);
+}
+
+export const searchSymbols: ToolDef<SearchSymbolsInputT> = {
+  name: 'search_symbols',
+  description: DESCRIPTION,
+  inputSchema: SearchSymbolsInput,
+  jsonSchema: {
+    type: 'function',
+    function: {
+      name: 'search_symbols',
+      description: DESCRIPTION,
+      parameters: {
+        type: 'object',
+        properties: {
+          query: { type: 'string', description: 'Substring or name fragment to match.' },
+          file_type: {
+            type: 'string',
+            description: 'Filter by file extension or language (e.g. "ts", "py", "go").',
+          },
+          symbol_type: {
+            type: 'string',
+            description: 'Filter by kind: function|class|method|variable|type|interface.',
+          },
+          framework_type: {
+            type: 'string',
+            description: 'Filter by framework context (react|vue|svelte|…).',
+          },
+          limit: {
+            type: 'integer',
+            description: `Max matches to return. Defaults to ${DEFAULT_LIMIT}.`,
+          },
+        },
+        required: ['query'],
+        additionalProperties: false,
+      },
+    },
+  },
+  async execute(input, projectRoot) {
+    return await executeSearchSymbols(input, projectRoot);
+  },
+};

apps/server/src/services/tools/codecontext/watch_changes.ts

@@ -0,0 +1,57 @@
+// v1.12 Track B.2: codecontext wrapper — watch_changes.
+
+import { z } from 'zod';
+import type { ToolDef } from '../../tools.js';
+import { callCodecontext, type CodecontextResponse } from '../../codecontext_client.js';
+
+export const WatchChangesInput = z.object({
+  enable: z.boolean(),
+});
+export type WatchChangesInputT = z.infer<typeof WatchChangesInput>;
+
+const DESCRIPTION =
+  'Turn codecontext\'s file watcher on or off for this project. ' +
+  'When on, codecontext re-analyzes files in the background as they change (debounced). Default is on. ' +
+  'Disable temporarily if you\'re doing bulk edits and want to avoid analysis churn.';
+
+export async function executeWatchChanges(
+  input: WatchChangesInputT,
+  projectPath: string,
+  fetcher: typeof fetch = fetch,
+): Promise<CodecontextResponse> {
+  return callCodecontext(
+    {
+      toolName: 'watch_changes',
+      args: { enable: input.enable },
+      projectPath,
+    },
+    fetcher,
+  );
+}
+
+export const watchChanges: ToolDef<WatchChangesInputT> = {
+  name: 'watch_changes',
+  description: DESCRIPTION,
+  inputSchema: WatchChangesInput,
+  jsonSchema: {
+    type: 'function',
+    function: {
+      name: 'watch_changes',
+      description: DESCRIPTION,
+      parameters: {
+        type: 'object',
+        properties: {
+          enable: {
+            type: 'boolean',
+            description: 'true = enable the watcher; false = disable.',
+          },
+        },
+        required: ['enable'],
+        additionalProperties: false,
+      },
+    },
+  },
+  async execute(input, projectRoot) {
+    return await executeWatchChanges(input, projectRoot);
+  },
+};