sdlc-agent-4-enterprise-server 1.0.0

package/src/engine/scanner/pattern-detector.ts

@@ -0,0 +1,112 @@
+/**
+ * Pattern Detector — Identifies DI style, error handling, naming, logging, testing patterns.
+ * Ported from: .analysis/code-intelligence/scripts/nodejs/src/full-indexer.ts
+ */
+
+import type { ExtractedSymbol } from './signature-extractor.js';
+
+export interface DetectedPatterns {
+  diStyle: string;
+  errorHandling: string;
+  naming: string;
+  logging: string;
+  testing: string;
+}
+
+/** Detect all coding patterns from aggregated module data. */
+export function detectPatterns(
+  classes: ExtractedSymbol[],
+  functions: ExtractedSymbol[],
+  imports: string[]
+): DetectedPatterns {
+  return {
+    diStyle: detectDiStyle(classes, functions, imports),
+    errorHandling: detectErrorHandling(classes, imports),
+    naming: detectNaming(classes),
+    logging: detectLogging(imports),
+    testing: detectTesting(imports),
+  };
+}
+
+/** Infer module purpose from name, classes, and packages. */
+export function inferModulePurpose(
+  moduleName: string,
+  classes: ExtractedSymbol[],
+  packages: string[]
+): string {
+  const allNames = [moduleName, ...classes.map(c => c.name), ...packages]
+    .join(' ').toLowerCase();
+  const purposes: [string, string][] = [
+    ['api', 'API layer'], ['controller', 'API layer'],
+    ['service', 'Business logic'], ['business', 'Business logic'],
+    ['repository', 'Data access'], ['dao', 'Data access'],
+    ['data', 'Data access'],
+    ['config', 'Configuration'], ['configuration', 'Configuration'],
+    ['common', 'Shared utilities'], ['shared', 'Shared utilities'],
+    ['test', 'Testing'], ['spec', 'Testing'],
+    ['web', 'Web/UI layer'], ['ui', 'Web/UI layer'],
+    ['model', 'Domain model'], ['domain', 'Domain model'],
+  ];
+  for (const [keyword, purpose] of purposes) {
+    if (allNames.includes(keyword)) return purpose;
+  }
+  return 'Application module';
+}
+
+function detectDiStyle(
+  classes: ExtractedSymbol[],
+  functions: ExtractedSymbol[],
+  imports: string[]
+): string {
+  const allText = imports.join(' ');
+  if (allText.includes('@Inject') || allText.includes('@Autowired')) {
+    return 'field injection';
+  }
+  if (functions.some(f => f.name === 'constructor' || f.name === '__init__')) {
+    return 'constructor injection';
+  }
+  return 'none';
+}
+
+function detectErrorHandling(
+  classes: ExtractedSymbol[], imports: string[]
+): string {
+  const allText = [...imports, ...classes.map(c => c.name)].join(' ');
+  if (allText.includes('Result') || allText.includes('Either')) {
+    return 'Result type';
+  }
+  if (allText.includes('ExceptionHandler') || allText.includes('ControllerAdvice')) {
+    return 'exception handler';
+  }
+  if (allText.includes('Exception') || allText.includes('Error')) {
+    return 'try-catch';
+  }
+  return 'unknown';
+}
+
+function detectNaming(classes: ExtractedSymbol[]): string {
+  const suffixes = ['Controller', 'Service', 'Repository'];
+  const found = suffixes.filter(
+    suffix => classes.some(c => c.name.endsWith(suffix))
+  ).map(s => `*${s}`);
+  return found.length > 0 ? found.join(', ') : 'unknown';
+}
+
+function detectLogging(imports: string[]): string {
+  const allImports = imports.join(' ');
+  if (allImports.includes('slf4j') || allImports.includes('SLF4J')) return 'SLF4J';
+  if (allImports.includes('log4j') || allImports.includes('Log4j')) return 'Log4j';
+  if (allImports.includes('logging')) return 'logging';
+  if (allImports.includes('console')) return 'console.log';
+  return 'unknown';
+}
+
+function detectTesting(imports: string[]): string {
+  const allImports = imports.join(' ');
+  if (allImports.includes('junit') || allImports.includes('org.junit')) return 'JUnit';
+  if (allImports.includes('pytest') || allImports.includes('unittest')) return 'pytest';
+  if (allImports.includes('jest') || allImports.includes('@jest')) return 'Jest';
+  if (allImports.includes('kotest')) return 'kotest';
+  if (allImports.includes('vitest')) return 'vitest';
+  return 'unknown';
+}

package/src/engine/scanner/signature-extractor.ts

@@ -0,0 +1,173 @@
+/**
+ * Signature Extractor — Multi-language regex-based symbol extraction.
+ * Extracts functions, classes, interfaces, and other symbols from source files.
+ */
+
+export interface ExtractedSymbol {
+  name: string;
+  kind: SymbolKind;
+  signature: string;
+  startLine: number;
+  endLine: number;
+  parentSymbol: string | null;
+  visibility: string | null;
+  docComment: string | null;
+}
+
+export type SymbolKind =
+  | 'function' | 'class' | 'interface' | 'method'
+  | 'enum' | 'type' | 'constant' | 'variable'
+  | 'module' | 'namespace' | 'trait' | 'struct';
+
+interface PatternDef {
+  regex: RegExp;
+  kind: SymbolKind;
+  nameGroup: number;
+  signatureGroup?: number;
+}
+
+/** Extract symbols from source content based on language. */
+export function extractSymbols(content: string, language: string): ExtractedSymbol[] {
+  const patterns = getPatterns(language);
+  if (!patterns.length) return [];
+
+  const lines = content.split('\n');
+  const symbols: ExtractedSymbol[] = [];
+
+  for (const pattern of patterns) {
+    extractWithPattern(lines, content, pattern, symbols);
+  }
+
+  return deduplicateSymbols(symbols);
+}
+
+function extractWithPattern(
+  lines: string[], content: string, pattern: PatternDef, symbols: ExtractedSymbol[]
+): void {
+  const matches = content.matchAll(new RegExp(pattern.regex, 'gm'));
+  for (const match of matches) {
+    if (!match.index && match.index !== 0) continue;
+    const startLine = content.slice(0, match.index).split('\n').length;
+    const name = match[pattern.nameGroup];
+    if (!name || name.length > 100) continue;
+
+    symbols.push({
+      name,
+      kind: pattern.kind,
+      signature: (match[pattern.signatureGroup ?? 0] ?? match[0]).trim().slice(0, 500),
+      startLine,
+      endLine: estimateEndLine(lines, startLine),
+      parentSymbol: null,
+      visibility: extractVisibility(match[0]),
+      docComment: extractDocComment(lines, startLine - 1),
+    });
+  }
+}
+
+function estimateEndLine(lines: string[], startLine: number): number {
+  let depth = 0;
+  let foundOpen = false;
+  for (let i = startLine - 1; i < lines.length && i < startLine + 200; i++) {
+    const line = lines[i];
+    for (const ch of line) {
+      if (ch === '{') { depth++; foundOpen = true; }
+      if (ch === '}') depth--;
+    }
+    if (foundOpen && depth <= 0) return i + 1;
+  }
+  return Math.min(startLine + 1, lines.length);
+}
+
+function extractVisibility(text: string): string | null {
+  if (/\bpublic\b/.test(text)) return 'public';
+  if (/\bprivate\b/.test(text)) return 'private';
+  if (/\bprotected\b/.test(text)) return 'protected';
+  if (/\binternal\b/.test(text)) return 'internal';
+  if (/\bexport\b/.test(text)) return 'export';
+  return null;
+}
+
+function extractDocComment(lines: string[], lineIdx: number): string | null {
+  const comments: string[] = [];
+  for (let i = lineIdx - 1; i >= Math.max(0, lineIdx - 15); i--) {
+    const line = lines[i].trim();
+    if (line.startsWith('*') || line.startsWith('/**') || line.startsWith('///') || line.startsWith('#')) {
+      comments.unshift(line.replace(/^\/\*\*|\*\/|\*|\/\/\/|#\s?/g, '').trim());
+    } else if (line === '') {
+      continue;
+    } else {
+      break;
+    }
+  }
+  return comments.length > 0 ? comments.join(' ').slice(0, 500) : null;
+}
+
+function deduplicateSymbols(symbols: ExtractedSymbol[]): ExtractedSymbol[] {
+  const seen = new Set<string>();
+  return symbols.filter(s => {
+    const key = `${s.name}:${s.startLine}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function getPatterns(language: string): PatternDef[] {
+  switch (language) {
+    case 'typescript': case 'javascript': return TS_PATTERNS;
+    case 'kotlin': return KOTLIN_PATTERNS;
+    case 'python': return PYTHON_PATTERNS;
+    case 'java': return JAVA_PATTERNS;
+    case 'go': return GO_PATTERNS;
+    case 'rust': return RUST_PATTERNS;
+    default: return GENERIC_PATTERNS;
+  }
+}
+
+const TS_PATTERNS: PatternDef[] = [
+  { regex: /^(?:export\s+)?(?:async\s+)?function\s+(\w+)/m, kind: 'function', nameGroup: 1 },
+  { regex: /^(?:export\s+)?class\s+(\w+)/m, kind: 'class', nameGroup: 1 },
+  { regex: /^(?:export\s+)?interface\s+(\w+)/m, kind: 'interface', nameGroup: 1 },
+  { regex: /^(?:export\s+)?type\s+(\w+)/m, kind: 'type', nameGroup: 1 },
+  { regex: /^(?:export\s+)?enum\s+(\w+)/m, kind: 'enum', nameGroup: 1 },
+  { regex: /^(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s*)?\(/m, kind: 'function', nameGroup: 1 },
+];
+
+const KOTLIN_PATTERNS: PatternDef[] = [
+  { regex: /^\s*(?:(?:public|private|internal|protected)\s+)?(?:suspend\s+)?fun\s+(\w+)/m, kind: 'function', nameGroup: 1 },
+  { regex: /^\s*(?:(?:public|private|internal|protected)\s+)?(?:data\s+|sealed\s+|abstract\s+|open\s+)?class\s+(\w+)/m, kind: 'class', nameGroup: 1 },
+  { regex: /^\s*(?:(?:public|private|internal|protected)\s+)?interface\s+(\w+)/m, kind: 'interface', nameGroup: 1 },
+  { regex: /^\s*(?:(?:public|private|internal|protected)\s+)?object\s+(\w+)/m, kind: 'module', nameGroup: 1 },
+  { regex: /^\s*(?:(?:public|private|internal|protected)\s+)?enum\s+class\s+(\w+)/m, kind: 'enum', nameGroup: 1 },
+];
+
+const PYTHON_PATTERNS: PatternDef[] = [
+  { regex: /^(?:async\s+)?def\s+(\w+)/m, kind: 'function', nameGroup: 1 },
+  { regex: /^class\s+(\w+)/m, kind: 'class', nameGroup: 1 },
+];
+
+const JAVA_PATTERNS: PatternDef[] = [
+  { regex: /^\s*(?:(?:public|private|protected)\s+)?(?:static\s+)?(?:[\w<>\[\]]+\s+)(\w+)\s*\(/m, kind: 'function', nameGroup: 1 },
+  { regex: /^\s*(?:(?:public|private|protected)\s+)?(?:abstract\s+)?class\s+(\w+)/m, kind: 'class', nameGroup: 1 },
+  { regex: /^\s*(?:(?:public|private|protected)\s+)?interface\s+(\w+)/m, kind: 'interface', nameGroup: 1 },
+  { regex: /^\s*(?:(?:public|private|protected)\s+)?enum\s+(\w+)/m, kind: 'enum', nameGroup: 1 },
+];
+
+const GO_PATTERNS: PatternDef[] = [
+  { regex: /^func\s+(?:\(\w+\s+\*?\w+\)\s+)?(\w+)/m, kind: 'function', nameGroup: 1 },
+  { regex: /^type\s+(\w+)\s+struct/m, kind: 'struct', nameGroup: 1 },
+  { regex: /^type\s+(\w+)\s+interface/m, kind: 'interface', nameGroup: 1 },
+];
+
+const RUST_PATTERNS: PatternDef[] = [
+  { regex: /^\s*(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/m, kind: 'function', nameGroup: 1 },
+  { regex: /^\s*(?:pub\s+)?struct\s+(\w+)/m, kind: 'struct', nameGroup: 1 },
+  { regex: /^\s*(?:pub\s+)?trait\s+(\w+)/m, kind: 'trait', nameGroup: 1 },
+  { regex: /^\s*(?:pub\s+)?enum\s+(\w+)/m, kind: 'enum', nameGroup: 1 },
+  { regex: /^\s*(?:pub\s+)?mod\s+(\w+)/m, kind: 'module', nameGroup: 1 },
+];
+
+const GENERIC_PATTERNS: PatternDef[] = [
+  { regex: /^(?:function|def|func|fn|sub)\s+(\w+)/m, kind: 'function', nameGroup: 1 },
+  { regex: /^(?:class|struct|type)\s+(\w+)/m, kind: 'class', nameGroup: 1 },
+];

package/src/engine/tools/ai-context-tools.ts

@@ -0,0 +1,155 @@
+/**
+ * KSA-158/159/160: AI Context MCP tool handlers and definitions.
+ */
+
+import Database from 'better-sqlite3';
+import { SymbolResolver } from '../graph/symbol-resolver.js';
+import { CallGraphService } from '../graph/call-graph-service.js';
+import { TestDetector } from '../graph/test-detector.js';
+import { GraphTraverser } from '../graph/traverser.js';
+import { GraphRepository } from '../database/graph-repository.js';
+import { QueryLayer } from '../query/query-layer.js';
+import { AIContextService } from '../context/ai-context-service.js';
+import { EditContextService } from '../context/edit-context-service.js';
+import { CuratedContextService } from '../context/curated-context-service.js';
+import { DatabaseManager } from '../db/database-manager.js';
+
+export const AI_CONTEXT_TOOL_DEFINITIONS = [
+  {
+    name: 'get_ai_context',
+    description: 'Get intent-aware code context with token budgeting. Returns source, callers, callees, tests based on intent (explain/modify/debug/test).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        symbol: { type: 'string', description: 'Symbol name to get context for (supports Class.method, file:symbol formats)' },
+        intent: { type: 'string', description: 'Intent: explain, modify, debug, test (default: explain)', enum: ['explain', 'modify', 'debug', 'test'] },
+        token_budget: { type: 'number', description: 'Max tokens for response (default: 4000, min: 500)' },
+        caller_depth: { type: 'number', description: 'Depth for caller/callee traversal (default: 1, max: 5)' }
+      },
+      required: ['symbol']
+    }
+  },
+  {
+    name: 'get_edit_context',
+    description: 'Get everything needed before editing a symbol: source + callers + tests + git history + siblings. Optimized for code modification.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        symbol: { type: 'string', description: 'Symbol name or file:line format' },
+        include_callers: { type: 'boolean', description: 'Include caller context (default: true)' },
+        include_tests: { type: 'boolean', description: 'Include related test context (default: true)' },
+        include_git: { type: 'boolean', description: 'Include git history (default: true)' },
+        token_budget: { type: 'number', description: 'Max tokens (default: 4000)' },
+        caller_depth: { type: 'number', description: 'Caller traversal depth (default: 1)' }
+      },
+      required: ['symbol']
+    }
+  },
+  {
+    name: 'get_curated_context',
+    description: 'Natural language query across codebase: searches code symbols, knowledge base, and graph relationships. Returns ranked results within token budget.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Natural language query (e.g., "how does authentication work")' },
+        max_tokens: { type: 'number', description: 'Max tokens for response (default: 4000)' },
+        include_source: { type: 'boolean', description: 'Search code symbols (default: true)' },
+        include_memory: { type: 'boolean', description: 'Search knowledge base (default: true)' },
+        include_graph: { type: 'boolean', description: 'Expand via graph relationships (default: true)' },
+        source_weights: {
+          type: 'object',
+          description: 'Custom weights for source ranking',
+          properties: {
+            code: { type: 'number' },
+            memory: { type: 'number' },
+            graph: { type: 'number' }
+          }
+        }
+      },
+      required: ['query']
+    }
+  }
+];
+
+/** Handle get_ai_context tool call. */
+export function handleGetAIContext(args: Record<string, unknown>, db: Database.Database, workspace: string): string {
+  const resolver = new SymbolResolver(db);
+  const graphRepo = new GraphRepository(db);
+  const callGraph = new CallGraphService(graphRepo, resolver);
+  const service = new AIContextService(db, resolver, callGraph, workspace);
+
+  const params = {
+    symbol: args.symbol as string,
+    intent: (args.intent as string) || 'explain',
+    token_budget: (args.token_budget as number) || 4000,
+    caller_depth: (args.caller_depth as number) || 1
+  };
+
+  // Execute synchronously (all DB operations are sync with better-sqlite3)
+  const result = executeSync(() => service.getContext(params));
+  return JSON.stringify(result, null, 2);
+}
+
+/** Handle get_edit_context tool call. */
+export function handleGetEditContext(args: Record<string, unknown>, db: Database.Database, workspace: string): string {
+  const resolver = new SymbolResolver(db);
+  const graphRepo = new GraphRepository(db);
+  const callGraph = new CallGraphService(graphRepo, resolver);
+  const testDetector = new TestDetector(db);
+  const service = new EditContextService(db, resolver, callGraph, testDetector, workspace);
+
+  const params = {
+    symbol: args.symbol as string,
+    include_callers: (args.include_callers as boolean) ?? true,
+    include_tests: (args.include_tests as boolean) ?? true,
+    include_memories: false,
+    include_git: (args.include_git as boolean) ?? true,
+    token_budget: (args.token_budget as number) || 4000,
+    caller_depth: (args.caller_depth as number) || 1
+  };
+
+  const result = executeSync(() => service.getContext(params));
+  return JSON.stringify(result, null, 2);
+}
+
+/** Handle get_curated_context tool call. */
+export function handleGetCuratedContext(
+  args: Record<string, unknown>,
+  db: Database.Database,
+  workspace: string,
+  dbManager: DatabaseManager
+): string {
+  const resolver = new SymbolResolver(db);
+  const traverser = new GraphTraverser(db, resolver, workspace);
+  const queryLayer = new QueryLayer(dbManager);
+  const service = new CuratedContextService(db, queryLayer, traverser, resolver);
+
+  const params = {
+    query: args.query as string,
+    max_tokens: (args.max_tokens as number) || 4000,
+    include_source: (args.include_source as boolean) ?? true,
+    include_memory: (args.include_memory as boolean) ?? true,
+    include_graph: (args.include_graph as boolean) ?? true,
+    source_weights: args.source_weights as any
+  };
+
+  const result = executeSync(() => service.getContext(params));
+  return JSON.stringify(result, null, 2);
+}
+
+/**
+ * Execute an async function synchronously.
+ * Works because better-sqlite3 is synchronous — the async wrappers
+ * resolve immediately without actual I/O waiting.
+ */
+function executeSync<T>(fn: () => Promise<T>): T {
+  let result: T | undefined;
+  let error: Error | undefined;
+
+  fn().then(r => { result = r; }).catch(e => { error = e; });
+
+  // Since all operations are sync (better-sqlite3 + fs.readFileSync),
+  // the promise resolves in the same microtask
+  if (error) throw error;
+  return result as T;
+}

package/src/engine/tools/call-graph-tools.ts

@@ -0,0 +1,109 @@
+/**
+ * KSA-154: MCP Tool Registration for code_callers and code_callees.
+ */
+
+import Database from 'better-sqlite3';
+import { GraphRepository } from '../database/graph-repository.js';
+import { SymbolResolver } from '../graph/symbol-resolver.js';
+import { CallGraphService, CallGraphResponse } from '../graph/call-graph-service.js';
+
+export const CALL_GRAPH_TOOL_DEFINITIONS = [
+  {
+    name: 'code_callers',
+    description: 'Find all callers of a function/method with transitive depth control. Supports qualified names (Class.method) and file:symbol format.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        symbol: { type: 'string', description: 'Symbol name to find callers for (e.g. "processData", "MyClass.method", "src/utils:helper")' },
+        depth: { type: 'number', description: 'Transitive depth (1-5, default 1)' },
+        limit: { type: 'number', description: 'Max results (default 20)' },
+        file_filter: { type: 'string', description: 'Filter results by file path pattern (glob)' },
+        kind_filter: { type: 'string', description: 'Relationship kind filter (default: calls)' },
+      },
+      required: ['symbol'],
+    },
+  },
+  {
+    name: 'code_callees',
+    description: 'Find all functions/methods called by a given symbol with transitive depth.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        symbol: { type: 'string', description: 'Symbol name to find callees for' },
+        depth: { type: 'number', description: 'Transitive depth (1-5, default 1)' },
+        limit: { type: 'number', description: 'Max results (default 20)' },
+        file_filter: { type: 'string', description: 'Filter results by file path pattern (glob)' },
+        include_external: { type: 'boolean', description: 'Include external/unresolved callees (default true)' },
+      },
+      required: ['symbol'],
+    },
+  },
+];
+
+export function handleCodeCallers(args: Record<string, unknown>, db: Database.Database): string {
+  const symbol = args.symbol as string;
+  if (!symbol) return JSON.stringify({ error: 'Parameter "symbol" is required' });
+
+  const depth = (args.depth as number) ?? 1;
+  const limit = (args.limit as number) ?? 20;
+  const fileFilter = args.file_filter as string | undefined;
+  const kindFilter = (args.kind_filter as string) ?? 'calls';
+
+  const graphRepo = new GraphRepository(db);
+  const resolver = new SymbolResolver(db);
+  const service = new CallGraphService(graphRepo, resolver);
+
+  const result = service.findCallers(symbol, depth, limit, fileFilter, kindFilter);
+  return formatCallGraphResult(result, 'callers');
+}
+
+export function handleCodeCallees(args: Record<string, unknown>, db: Database.Database): string {
+  const symbol = args.symbol as string;
+  if (!symbol) return JSON.stringify({ error: 'Parameter "symbol" is required' });
+
+  const depth = (args.depth as number) ?? 1;
+  const limit = (args.limit as number) ?? 20;
+  const fileFilter = args.file_filter as string | undefined;
+  const includeExternal = (args.include_external as boolean) ?? true;
+
+  const graphRepo = new GraphRepository(db);
+  const resolver = new SymbolResolver(db);
+  const service = new CallGraphService(graphRepo, resolver);
+
+  const result = service.findCallees(symbol, depth, limit, fileFilter, includeExternal);
+  return formatCallGraphResult(result, 'callees');
+}
+
+function formatCallGraphResult(result: CallGraphResponse, direction: string): string {
+  if (result.results.length === 0 && result.resolvedTo.length === 0) {
+    const suggestions = (result as any).suggestions;
+    if (suggestions && suggestions.length > 0) {
+      return `Symbol "${result.symbol}" not found. Did you mean: ${suggestions.join(', ')}?`;
+    }
+    return `Symbol "${result.symbol}" not found in index.`;
+  }
+
+  if (result.results.length === 0) {
+    return `No ${direction} found for "${result.symbol}" (resolved to ${result.resolvedTo.length} definition(s))`;
+  }
+
+  const lines: string[] = [];
+  lines.push(`${direction === 'callers' ? 'Callers' : 'Callees'} of "${result.symbol}" (depth ${result.metadata.depthSearched}):\n`);
+
+  if (result.resolvedTo.length > 0) {
+    lines.push(`Resolved to:`);
+    for (const r of result.resolvedTo) {
+      lines.push(`  [${r.kind}] ${r.file}:${r.line}`);
+    }
+    lines.push('');
+  }
+
+  for (const item of result.results) {
+    const prefix = '  '.repeat(item.depthLevel);
+    lines.push(`${prefix}[${item.kind}] ${item.qualifiedName}`);
+    lines.push(`${prefix}  ${item.filePath}:${item.callSiteLine} (def: L${item.definitionLine})`);
+  }
+
+  lines.push(`\n--- ${result.metadata.totalCount} results | ${result.metadata.queryTimeMs}ms${result.metadata.truncated ? ' | TRUNCATED' : ''}`);
+  return lines.join('\n');
+}

package/src/engine/tools/code-context.ts

@@ -0,0 +1,70 @@
+/**
+ * code_context tool — Get surrounding context for a symbol or file region.
+ * Reads actual source code lines around a symbol definition.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { QueryLayer } from '../query/query-layer.js';
+
+export function registerCodeContext(
+  server: McpServer, queryLayer: QueryLayer, workspace: string
+): void {
+  server.tool(
+    'code_context',
+    'Get source code context around a symbol or line range. Returns actual code lines from the file.',
+    {
+      file: z.string().describe('Relative file path'),
+      symbol: z.string().optional().describe('Symbol name to find in file'),
+      startLine: z.number().optional().describe('Start line (1-based)'),
+      endLine: z.number().optional().describe('End line (1-based)'),
+      contextLines: z.number().optional().default(5).describe('Extra lines above/below'),
+    },
+    async ({ file, symbol, startLine, endLine, contextLines }) => {
+      const text = getContext(workspace, file, symbol, startLine, endLine, contextLines, queryLayer);
+      return { content: [{ type: 'text', text }] };
+    }
+  );
+}
+
+function getContext(
+  workspace: string, file: string, symbol: string | undefined,
+  startLine: number | undefined, endLine: number | undefined,
+  contextLines: number, queryLayer: QueryLayer
+): string {
+  const fullPath = path.resolve(workspace, file);
+  if (!fs.existsSync(fullPath)) return `File not found: ${file}`;
+
+  const content = fs.readFileSync(fullPath, 'utf-8');
+  const lines = content.split('\n');
+
+  if (symbol) {
+    return getSymbolContext(file, symbol, lines, contextLines, queryLayer);
+  }
+
+  const start = Math.max(0, (startLine ?? 1) - 1 - contextLines);
+  const end = Math.min(lines.length, (endLine ?? startLine ?? lines.length) + contextLines);
+  return formatLines(lines, start, end, file);
+}
+
+function getSymbolContext(
+  file: string, symbol: string, lines: string[],
+  contextLines: number, queryLayer: QueryLayer
+): string {
+  const symbols = queryLayer.getFileSymbols(file);
+  const match = symbols.find(s => s.name === symbol);
+  if (!match) return `Symbol "${symbol}" not found in ${file}`;
+
+  const start = Math.max(0, match.startLine - 1 - contextLines);
+  const end = Math.min(lines.length, match.endLine + contextLines);
+  return formatLines(lines, start, end, file);
+}
+
+function formatLines(lines: string[], start: number, end: number, file: string): string {
+  const numbered = lines
+    .slice(start, end)
+    .map((line, i) => `${String(start + i + 1).padStart(4)} | ${line}`);
+  return `// ${file} [${start + 1}-${end}]\n${numbered.join('\n')}`;
+}