sdlc-agent-4-enterprise-server 1.0.0

package/src/engine/tools/drawio-tool.ts

@@ -0,0 +1,167 @@
+/**
+ * drawio_auto_layout MCP tool — REVIEW mode: detect issues, report for AI to fix.
+ * Does NOT modify the file. Returns detailed issue list.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { parseDrawio, DiagramGraph, DiagramNode } from './drawio-parser.js';
+
+export const DRAWIO_TOOL_DEFINITION = {
+  name: 'drawio_auto_layout',
+  description: 'Auto-layout draw.io diagrams using graph algorithms. Reads .drawio file, computes optimal node positions, writes back. Preserves all styles/labels.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      file_path: { type: 'string', description: 'Path to .drawio file (absolute or relative to workspace)' },
+      algorithm: { type: 'string', description: 'Layout algorithm: layered|force|mrtree|radial (default: layered)' },
+      spacing: { type: 'number', description: 'Node spacing in pixels (default: 80)' },
+      direction: { type: 'string', description: 'Layout direction: DOWN|RIGHT|LEFT|UP (default: DOWN)' },
+      export_png: { type: 'boolean', description: 'Also export PNG after layout (default: false)' },
+      force: { type: 'boolean', description: 'Force re-layout even if diagram has no overlaps (default: false)' },
+    },
+    required: ['file_path'],
+  },
+};
+
+export function handleDrawioLayout(args: Record<string, unknown>, workspace: string): string {
+  const rawPath = args.file_path as string | undefined;
+  if (!rawPath) return error('file_path is required');
+
+  const filePath = path.isAbsolute(rawPath) ? rawPath : path.resolve(workspace, rawPath);
+  if (!fs.existsSync(filePath)) return error(`File not found: ${filePath}`);
+  if (!filePath.endsWith('.drawio')) return error(`Not a .drawio file`);
+
+  try {
+    const { graph } = parseDrawio(filePath);
+    const nodeCount = graph.nodes.length + graph.containers.length;
+    if (nodeCount === 0) return error('No nodes found in diagram');
+
+    const issues = detectAllIssues(graph);
+    if (issues.length === 0) {
+      return JSON.stringify({
+        status: 'already_good',
+        message: 'Diagram looks good — no overlapping nodes or edge crossings detected.',
+        nodes: nodeCount, edges: graph.edges.length, issues: [],
+      });
+    }
+    return JSON.stringify({
+      status: 'needs_fix',
+      message: `Found ${issues.length} issues. Fix the drawio XML and call this tool again to verify.`,
+      nodes: nodeCount, edges: graph.edges.length, issues,
+    });
+  } catch (e: any) {
+    return error(`Analysis failed: ${e.message ?? e}`);
+  }
+}
+
+function detectAllIssues(graph: DiagramGraph): object[] {
+  return [
+    ...detectNodeOverlaps(graph),
+    ...detectEdgeCrossings(graph),
+    ...detectDiagonalEdges(graph),
+  ];
+}
+
+function detectNodeOverlaps(graph: DiagramGraph): object[] {
+  const issues: object[] = [];
+  const nodes = graph.nodes;
+  for (let i = 0; i < nodes.length; i++) {
+    for (let j = i + 1; j < nodes.length; j++) {
+      if (nodes[i].parentId !== nodes[j].parentId) continue;
+      const overlap = overlapRatio(nodes[i], nodes[j]);
+      if (overlap > 0.50) {
+        issues.push({
+          type: 'node_overlap', severity: 'high',
+          node_a: nodes[i].id, node_b: nodes[j].id,
+          overlap_pct: Math.round(overlap * 100),
+          fix_hint: `Move '${nodes[j].id}' away from '${nodes[i].id}'.`,
+        });
+      }
+    }
+  }
+  return issues;
+}
+
+function detectEdgeCrossings(graph: DiagramGraph): object[] {
+  const issues: object[] = [];
+  const allNodes = [...graph.nodes, ...graph.containers];
+  const nodeMap = new Map(allNodes.map(n => [n.id, n]));
+  for (const edge of graph.edges) {
+    const src = nodeMap.get(edge.sourceId);
+    const tgt = nodeMap.get(edge.targetId);
+    if (!src || !tgt) continue;
+    const sx = src.x + src.width / 2, sy = src.y + src.height / 2;
+    const tx = tgt.x + tgt.width / 2, ty = tgt.y + tgt.height / 2;
+    for (const node of graph.nodes) {
+      if (node.id === edge.sourceId || node.id === edge.targetId) continue;
+      if (lineCrossesRect(sx, sy, tx, ty, node)) {
+        issues.push({
+          type: 'edge_crossing', severity: 'medium',
+          edge_id: edge.id, edge_source: edge.sourceId, edge_target: edge.targetId,
+          crosses_node: node.id,
+          fix_hint: `Edge '${edge.id}' (${edge.sourceId}→${edge.targetId}) crosses '${node.id}'. Rearrange nodes.`,
+        });
+        break;
+      }
+    }
+  }
+  return issues;
+}
+
+function detectDiagonalEdges(graph: DiagramGraph): object[] {
+  const issues: object[] = [];
+  const nodeMap = new Map([...graph.nodes, ...graph.containers].map(n => [n.id, n]));
+  const tolerance = 20;
+  for (const edge of graph.edges) {
+    const src = nodeMap.get(edge.sourceId);
+    const tgt = nodeMap.get(edge.targetId);
+    if (!src || !tgt) continue;
+    const dx = Math.abs((src.x + src.width / 2) - (tgt.x + tgt.width / 2));
+    const dy = Math.abs((src.y + src.height / 2) - (tgt.y + tgt.height / 2));
+    if (dx > tolerance && dy > tolerance) {
+      const fix = dx < dy
+        ? `Align horizontally: set '${edge.targetId}' x=${Math.round(src.x)} (same column)`
+        : `Align vertically: set '${edge.targetId}' y=${Math.round(src.y)} (same row)`;
+      issues.push({
+        type: 'diagonal_edge', severity: 'low',
+        edge_id: edge.id, edge_source: edge.sourceId, edge_target: edge.targetId,
+        fix_hint: fix,
+      });
+    }
+  }
+  return issues;
+}
+
+function overlapRatio(a: DiagramNode, b: DiagramNode): number {
+  const ox = Math.max(0, Math.min(a.x + a.width, b.x + b.width) - Math.max(a.x, b.x));
+  const oy = Math.max(0, Math.min(a.y + a.height, b.y + b.height) - Math.max(a.y, b.y));
+  const area = ox * oy;
+  if (area <= 0) return 0;
+  const smaller = Math.min(a.width * a.height, b.width * b.height);
+  return smaller > 0 ? area / smaller : 0;
+}
+
+function lineCrossesRect(x1: number, y1: number, x2: number, y2: number, node: DiagramNode): boolean {
+  const m = 5;
+  const l = node.x - m, r = node.x + node.width + m;
+  const t = node.y - m, b = node.y + node.height + m;
+  if (Math.max(x1, x2) < l || Math.min(x1, x2) > r) return false;
+  if (Math.max(y1, y2) < t || Math.min(y1, y2) > b) return false;
+  const c1 = outCode(x1, y1, l, t, r, b);
+  const c2 = outCode(x2, y2, l, t, r, b);
+  if (c1 & c2) return false;
+  if (c1 === 0 || c2 === 0) return false;
+  return true;
+}
+
+function outCode(x: number, y: number, l: number, t: number, r: number, b: number): number {
+  let c = 0;
+  if (x < l) c |= 1; if (x > r) c |= 2;
+  if (y < t) c |= 4; if (y > b) c |= 8;
+  return c;
+}
+
+function error(msg: string): string {
+  return JSON.stringify({ error: msg });
+}

package/src/engine/tools/drawio-writer.ts

@@ -0,0 +1,133 @@
+/**
+ * Writes updated node positions back to draw.io XML — regex-based rewrite.
+ */
+
+import * as fs from 'fs';
+import { DiagramGraph, DiagramNode } from './drawio-parser.js';
+import { routeEdges, Waypoint } from './drawio-router.js';
+
+/** Write layout results back to the XML file. */
+export function writeLayout(rawXml: string, graph: DiagramGraph, filePath: string): void {
+  let xml = rawXml;
+  const allNodes = [...graph.nodes, ...graph.containers];
+  xml = applyPositions(xml, allNodes);
+  xml = applyEdgeAnchors(xml, graph);
+  xml = applyEdgeRouting(xml, graph);
+  fs.writeFileSync(filePath, xml, 'utf-8');
+}
+
+function applyPositions(xml: string, nodes: DiagramNode[]): string {
+  for (const node of nodes) {
+    // Match mxCell with this id, then update its mxGeometry
+    const cellRegex = new RegExp(
+      `(<mxCell[^>]*\\bid="${escapeRegex(node.id)}"[^>]*>\\s*<mxGeometry)([^/]*?)(/?>)`, 's'
+    );
+    xml = xml.replace(cellRegex, (_match, prefix, attrs, suffix) => {
+      attrs = setAttr(attrs, 'x', fmt(node.x));
+      attrs = setAttr(attrs, 'y', fmt(node.y));
+      attrs = setAttr(attrs, 'width', fmt(node.width));
+      attrs = setAttr(attrs, 'height', fmt(node.height));
+      return `${prefix}${attrs}${suffix}`;
+    });
+    // Also handle self-closing mxCell with child mxGeometry on same line
+    const altRegex = new RegExp(
+      `(id="${escapeRegex(node.id)}"[^>]*>\\s*<mxGeometry\\s)([^>]*?)(/>)`, 's'
+    );
+    xml = xml.replace(altRegex, (_match, prefix, attrs, suffix) => {
+      attrs = setAttr(attrs, 'x', fmt(node.x));
+      attrs = setAttr(attrs, 'y', fmt(node.y));
+      attrs = setAttr(attrs, 'width', fmt(node.width));
+      attrs = setAttr(attrs, 'height', fmt(node.height));
+      return `${prefix}${attrs}${suffix}`;
+    });
+  }
+  return xml;
+}
+
+function applyEdgeAnchors(xml: string, graph: DiagramGraph): string {
+  const nodeMap = new Map([...graph.nodes, ...graph.containers].map(n => [n.id, n]));
+  for (const edge of graph.edges) {
+    const src = nodeMap.get(edge.sourceId);
+    const tgt = nodeMap.get(edge.targetId);
+    if (!src || !tgt) continue;
+    const [exitX, exitY] = computeExit(src, tgt);
+    const [entryX, entryY] = computeEntry(src, tgt);
+    const cellRegex = new RegExp(`(<mxCell[^>]*\\bid="${escapeRegex(edge.id)}"[^>]*style=")([^"]*)(")`, 's');
+    xml = xml.replace(cellRegex, (_m, pre, style, post) => {
+      style = setStyleProp(style, 'exitX', fmt(exitX));
+      style = setStyleProp(style, 'exitY', fmt(exitY));
+      style = setStyleProp(style, 'entryX', fmt(entryX));
+      style = setStyleProp(style, 'entryY', fmt(entryY));
+      return `${pre}${style}${post}`;
+    });
+  }
+  return xml;
+}
+
+function applyEdgeRouting(xml: string, graph: DiagramGraph): string {
+  const routes = routeEdges(graph);
+  if (routes.size === 0) return xml;
+  for (const [edgeId, waypoints] of routes) {
+    // Set orthogonal style
+    const styleRegex = new RegExp(`(<mxCell[^>]*\\bid="${escapeRegex(edgeId)}"[^>]*style=")([^"]*)(")`, 's');
+    xml = xml.replace(styleRegex, (_m, pre, style, post) => {
+      style = setStyleProp(style, 'edgeStyle', 'orthogonalEdgeStyle');
+      style = setStyleProp(style, 'rounded', '1');
+      return `${pre}${style}${post}`;
+    });
+    // Add waypoints Array inside mxGeometry
+    const geomRegex = new RegExp(
+      `(id="${escapeRegex(edgeId)}"[^>]*>[\\s\\S]*?<mxGeometry[^>]*)(/>|>)`, 's'
+    );
+    const pointsXml = buildPointsXml(waypoints);
+    xml = xml.replace(geomRegex, (_m, prefix, close) => {
+      if (close === '/>') return `${prefix}>${pointsXml}</mxGeometry>`;
+      return `${prefix}>${pointsXml}`;
+    });
+  }
+  return xml;
+}
+
+function buildPointsXml(waypoints: Waypoint[]): string {
+  const points = waypoints.map(wp => `<mxPoint x="${fmt(wp.x)}" y="${fmt(wp.y)}" />`).join('');
+  return `<Array as="points">${points}</Array>`;
+}
+
+function computeExit(src: DiagramNode, tgt: DiagramNode): [number, number] {
+  const dx = (tgt.x + tgt.width / 2) - (src.x + src.width / 2);
+  const dy = (tgt.y + tgt.height / 2) - (src.y + src.height / 2);
+  return pickSide(dx, dy);
+}
+
+function computeEntry(src: DiagramNode, tgt: DiagramNode): [number, number] {
+  const dx = (src.x + src.width / 2) - (tgt.x + tgt.width / 2);
+  const dy = (src.y + src.height / 2) - (tgt.y + tgt.height / 2);
+  return pickSide(dx, dy);
+}
+
+function pickSide(dx: number, dy: number): [number, number] {
+  if (Math.abs(dx) > Math.abs(dy)) return dx > 0 ? [1, 0.5] : [0, 0.5];
+  return dy > 0 ? [0.5, 1] : [0.5, 0];
+}
+
+function setStyleProp(style: string, key: string, value: string): string {
+  const regex = new RegExp(`${key}=[^;]*`);
+  if (regex.test(style)) return style.replace(regex, `${key}=${value}`);
+  const sep = style.endsWith(';') ? '' : ';';
+  return `${style}${sep}${key}=${value};`;
+}
+
+function setAttr(attrs: string, key: string, value: string): string {
+  const regex = new RegExp(`${key}="[^"]*"`);
+  if (regex.test(attrs)) return attrs.replace(regex, `${key}="${value}"`);
+  return ` ${key}="${value}"${attrs}`;
+}
+
+function fmt(val: number): string {
+  const rounded = Math.round(val);
+  return rounded === val ? String(rounded) : val.toFixed(1);
+}
+
+function escapeRegex(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/src/engine/tools/impact-tools.ts

@@ -0,0 +1,97 @@
+/**
+ * KSA-156: MCP Tool Registration for code_impact.
+ */
+
+import Database from 'better-sqlite3';
+import { GraphRepository } from '../database/graph-repository.js';
+import { SymbolResolver } from '../graph/symbol-resolver.js';
+import { CallGraphService } from '../graph/call-graph-service.js';
+import { FileResolver } from '../graph/file-resolver.js';
+import { DependencyGraphService } from '../graph/dependency-graph-service.js';
+import { TestDetector } from '../graph/test-detector.js';
+import { ImpactAnalysisService, ImpactResult, ImpactAction, Severity } from '../graph/impact-analysis-service.js';
+
+export const IMPACT_TOOL_DEFINITIONS = [
+  {
+    name: 'code_impact',
+    description: 'Predict blast radius of modifying, deleting, or renaming a symbol. Shows affected callers, dependents, tests, and provides recommendations.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        symbol: { type: 'string', description: 'Symbol name to analyze impact for' },
+        action: { type: 'string', enum: ['modify', 'delete', 'rename'], description: 'Type of change (default: modify)' },
+        depth: { type: 'number', description: 'Analysis depth 1-5 (default: 3)' },
+        include_tests: { type: 'boolean', description: 'Include affected test files (default: true)' },
+        severity_threshold: { type: 'string', enum: ['critical', 'high', 'medium', 'low'], description: 'Minimum severity to include (default: low)' },
+      },
+      required: ['symbol'],
+    },
+  },
+];
+
+export function handleCodeImpact(args: Record<string, unknown>, db: Database.Database, workspace: string): string {
+  const symbol = args.symbol as string;
+  if (!symbol) return JSON.stringify({ error: 'Parameter "symbol" is required' });
+
+  const action = (args.action as ImpactAction) ?? 'modify';
+  const depth = (args.depth as number) ?? 3;
+  const includeTests = (args.include_tests as boolean) ?? true;
+  const severityThreshold = (args.severity_threshold as Severity) ?? 'low';
+
+  const graphRepo = new GraphRepository(db);
+  const resolver = new SymbolResolver(db);
+  const callGraph = new CallGraphService(graphRepo, resolver);
+  const fileResolver = new FileResolver(db, workspace);
+  const depGraph = new DependencyGraphService(db, fileResolver);
+  const testDetector = new TestDetector(db);
+
+  const service = new ImpactAnalysisService(db, callGraph, depGraph, resolver, testDetector);
+  const result = service.analyzeImpact(symbol, action, depth, includeTests, severityThreshold);
+
+  return formatImpactResult(result);
+}
+
+function formatImpactResult(result: ImpactResult): string {
+  const lines: string[] = [];
+
+  lines.push(`Impact Analysis: "${result.symbol}" (${result.action})\n`);
+  lines.push(`Blast Radius:`);
+  lines.push(`  Critical: ${result.blastRadius.summary.critical}`);
+  lines.push(`  High: ${result.blastRadius.summary.high}`);
+  lines.push(`  Medium: ${result.blastRadius.summary.medium}`);
+  lines.push(`  Low: ${result.blastRadius.summary.low}`);
+  lines.push(`  Total affected: ${result.blastRadius.totalAffected} (${result.blastRadius.affectedFiles} files)`);
+  lines.push(`  Affected tests: ${result.blastRadius.affectedTests}\n`);
+
+  if (result.impacts.length > 0) {
+    lines.push(`Impacts:`);
+    for (const impact of result.impacts.slice(0, 30)) {
+      const icon = impact.severity === 'critical' ? '!!' : impact.severity === 'high' ? '!' : '-';
+      lines.push(`  ${icon} [${impact.severity}] ${impact.symbol}`);
+      lines.push(`    ${impact.file}:${impact.line} - ${impact.reason}`);
+    }
+    if (result.impacts.length > 30) {
+      lines.push(`  ... and ${result.impacts.length - 30} more`);
+    }
+    lines.push('');
+  }
+
+  if (result.affectedTests.length > 0) {
+    lines.push(`Affected Tests:`);
+    for (const test of result.affectedTests.slice(0, 10)) {
+      lines.push(`  - ${test.file} (${test.reason})`);
+    }
+    lines.push('');
+  }
+
+  if (result.recommendations.length > 0) {
+    lines.push(`Recommendations:`);
+    for (const rec of result.recommendations) {
+      lines.push(`  * ${rec}`);
+    }
+    lines.push('');
+  }
+
+  lines.push(`--- ${result.metadata.queryTimeMs}ms | depth ${result.metadata.depthSearched}${result.metadata.truncated ? ' | TRUNCATED' : ''}`);
+  return lines.join('\n');
+}

package/src/engine/tools/register-tools.ts

@@ -0,0 +1,230 @@
+/**
+ * Tool registration and dispatch for Code Intelligence and Graph Analysis.
+ */
+import { DatabaseManager } from '../db/database-manager.js';
+import { IndexingEngine } from '../indexer/indexing-engine.js';
+import { QueryLayer } from '../query/query-layer.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+import { handleDrawioLayout, DRAWIO_TOOL_DEFINITION } from './drawio-tool.js';
+import { handleDrawioExportPng, DRAWIO_EXPORT_PNG_DEFINITION, isExportPngAvailable } from './drawio-export-png.js';
+import { CALL_GRAPH_TOOL_DEFINITIONS, handleCodeCallers, handleCodeCallees } from './call-graph-tools.js';
+import { DEPENDENCY_TOOL_DEFINITIONS, handleCodeDependencies } from './dependency-tools.js';
+import { IMPACT_TOOL_DEFINITIONS, handleCodeImpact } from './impact-tools.js';
+import { TRAVERSE_TOOL_DEFINITIONS, handleCodeTraverse } from './code-traverse.js';
+
+import { COMPLEXITY_TOOL_DEFINITION, handleComplexityTool } from '../analyzers/complexity/ComplexityTool.js';
+import { ENTRY_POINT_TOOL_DEFINITION, handleEntryPointTool } from '../analyzers/entry-points/EntryPointTool.js';
+import { GRAPH_ANALYSIS_TOOL_DEFINITIONS, handleGraphAnalysisTool } from '../analyzers/graph-analysis/GraphAnalysisTools.js';
+import { AI_CONTEXT_TOOL_DEFINITIONS, handleGetAIContext, handleGetEditContext, handleGetCuratedContext } from './ai-context-tools.js';
+import { SIMILARITY_TOOL_DEFINITIONS, handleSimilarityTool } from '../analyzers/similarity/SimilarityTools.js';
+
+export const CODE_INTEL_TOOL_DEFINITIONS = [
+  {
+    name: 'code_search',
+    description: 'Full-text search across indexed code symbols (functions, classes, interfaces). Uses SQLite FTS5 with porter stemming.',
+    inputSchema: { type: 'object', properties: { query: { type: 'string', description: 'Search query' }, limit: { type: 'number', description: 'Max results (default 20)' } }, required: ['query'] },
+  },
+  {
+    name: 'code_symbols',
+    description: 'Find code symbols by name prefix or list symbols in a file.',
+    inputSchema: { type: 'object', properties: { name: { type: 'string' }, file: { type: 'string' }, kind: { type: 'string' }, limit: { type: 'number' } } },
+  },
+  {
+    name: 'code_context',
+    description: 'Get source code context around a symbol or line range.',
+    inputSchema: { type: 'object', properties: { file: { type: 'string' }, symbol: { type: 'string' }, startLine: { type: 'number' }, endLine: { type: 'number' }, contextLines: { type: 'number' } }, required: ['file'] },
+  },
+  {
+    name: 'code_modules',
+    description: 'List all discovered code modules with file counts and languages.',
+    inputSchema: { type: 'object', properties: { name: { type: 'string' } } },
+  },
+  {
+    name: 'code_index_status',
+    description: 'Get current indexing status: file count, symbol count, languages, last indexed time.',
+    inputSchema: { type: 'object', properties: { reindex: { type: 'boolean' } } },
+  },
+  {
+    name: 'stream_write_file',
+    description: 'Write content directly to a file on disk. Modes: write (overwrite), append, create (fail if exists).',
+    inputSchema: { type: 'object', properties: { file_path: { type: 'string' }, content: { type: 'string' }, mode: { type: 'string' }, encoding: { type: 'string' } }, required: ['file_path'] },
+  },
+  {
+    name: 'code_kb_export',
+    description: 'Export code intelligence data as Knowledge Base payloads for ingestion.',
+    inputSchema: { type: 'object', properties: { module: { type: 'string' }, format: { type: 'string' } } },
+  },
+  DRAWIO_TOOL_DEFINITION,
+  ...CALL_GRAPH_TOOL_DEFINITIONS,
+  ...DEPENDENCY_TOOL_DEFINITIONS,
+  ...IMPACT_TOOL_DEFINITIONS,
+  ...TRAVERSE_TOOL_DEFINITIONS,
+  COMPLEXITY_TOOL_DEFINITION,
+  ENTRY_POINT_TOOL_DEFINITION,
+  ...GRAPH_ANALYSIS_TOOL_DEFINITIONS,
+  ...AI_CONTEXT_TOOL_DEFINITIONS,
+  ...SIMILARITY_TOOL_DEFINITIONS,
+];
+
+export async function dispatchCodeIntelTool(
+  name: string,
+  args: Record<string, unknown>,
+  dbManager: DatabaseManager,
+  indexer: IndexingEngine,
+  workspace: string
+): Promise<string> {
+  const queryLayer = new QueryLayer(dbManager);
+  switch (name) {
+    case 'code_search': return handleCodeSearch(args, queryLayer);
+    case 'code_symbols': return handleCodeSymbols(args, queryLayer);
+    case 'code_context': return handleCodeContext(args, queryLayer, workspace);
+    case 'code_modules': return handleCodeModules(args, queryLayer);
+    case 'code_index_status': return handleCodeIndexStatus(args, queryLayer, indexer);
+    case 'stream_write_file': return handleStreamWriteFile(args, workspace);
+    case 'code_kb_export': return handleCodeKbExport(args, queryLayer, workspace);
+    case 'drawio_auto_layout': return handleDrawioLayout(args, workspace);
+    case 'drawio_export_png': return handleDrawioExportPng(args, workspace, null as any);
+    case 'code_callers': return handleCodeCallers(args, dbManager.getDb());
+    case 'code_callees': return handleCodeCallees(args, dbManager.getDb());
+    case 'code_dependencies': return handleCodeDependencies(args, dbManager.getDb(), workspace);
+    case 'code_impact': return handleCodeImpact(args, dbManager.getDb(), workspace);
+    case 'code_traverse': return handleCodeTraverse(args, dbManager.getDb(), workspace);
+    case 'complexity_analysis': return handleComplexityTool(args, dbManager.getDb());
+    case 'find_entry_points': return handleEntryPointTool(args, dbManager.getDb());
+    case 'find_circular_deps':
+    case 'find_related_tests':
+    case 'find_hot_paths':
+    case 'find_dead_imports':
+    case 'module_summary': {
+      const result = handleGraphAnalysisTool(name, args, dbManager.getDb());
+      return result ?? `Unknown tool: ${name}`;
+    }
+    case 'get_ai_context': return handleGetAIContext(args, dbManager.getDb(), workspace);
+    case 'get_edit_context': return handleGetEditContext(args, dbManager.getDb(), workspace);
+    case 'get_curated_context': return handleGetCuratedContext(args, dbManager.getDb(), workspace, dbManager);
+    case 'find_duplicates':
+    case 'find_dead_code':
+    case 'git_search':
+    case 'git_index': {
+      const simResult = handleSimilarityTool(name, args, dbManager.getDb(), workspace);
+      return simResult ?? `Unknown tool: ${name}`;
+    }
+    default:
+      return `Unknown tool: ${name}`;
+  }
+}
+
+// Handlers for the 7 core code tools
+function handleCodeSearch(args: Record<string, unknown>, ql: QueryLayer): string {
+  const query = (args.query as string) ?? '';
+  const limit = (args.limit as number) ?? 20;
+  const results = ql.searchCode(query, limit);
+  if (results.length === 0) return `No results found for "${query}"`;
+  const lines = [`Found ${results.length} results for "${query}":\n`];
+  for (const r of results) {
+    lines.push(`[${r.kind}] ${r.name}`);
+    lines.push(`  File: ${r.filePath}:${r.startLine}`);
+    if (r.signature) lines.push(`  Sig: ${r.signature.slice(0, 120)}`);
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+
+function handleCodeSymbols(args: Record<string, unknown>, ql: QueryLayer): string {
+  const name = args.name as string | undefined;
+  const file = args.file as string | undefined;
+  const kind = args.kind as string | undefined;
+  const limit = (args.limit as number) ?? 50;
+  if (file) {
+    const symbols = ql.getFileSymbols(file);
+    if (symbols.length === 0) return `No symbols found in ${file}`;
+    const lines = [`Symbols in ${file} (${symbols.length}):\n`];
+    for (const s of symbols) { lines.push(`  L${s.startLine} [${s.kind}] ${s.name}`); }
+    return lines.join('\n');
+  }
+  if (name) {
+    const symbols = ql.findSymbols(name, kind, limit);
+    if (symbols.length === 0) return `No symbols matching "${name}"`;
+    const lines = [`Found ${symbols.length} symbols matching "${name}":\n`];
+    for (const s of symbols) { lines.push(`[${s.kind}] ${s.name} - ${s.filePath}:${s.startLine}`); }
+    return lines.join('\n');
+  }
+  return 'Provide either "name" or "file" parameter';
+}
+
+function handleCodeContext(args: Record<string, unknown>, ql: QueryLayer, workspace: string): string {
+  const file = args.file as string;
+  if (!file) return 'Parameter "file" is required';
+  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');
+  const contextLines = (args.contextLines as number) ?? 5;
+  const symbol = args.symbol as string | undefined;
+  if (symbol) {
+    const symbols = ql.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);
+  }
+  const startLine = args.startLine as number | undefined;
+  const endLine = args.endLine as number | undefined;
+  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 handleCodeModules(args: Record<string, unknown>, ql: QueryLayer): string {
+  const name = args.name as string | undefined;
+  const modules = ql.listModulesWithPatterns(name ?? null);
+  if (modules.length === 0) return 'No modules indexed yet.';
+  const lines = [`Modules (${modules.length}):\n`];
+  for (const m of modules) {
+    lines.push(`📦 ${m.name}`);
+    lines.push(`   Path: ${m.rootPath}`);
+    if (m.language) lines.push(`   Lang: ${m.language}`);
+    lines.push(`   Files: ${m.fileCount} | Symbols: ${m.symbolCount}`);
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+
+async function handleCodeIndexStatus(args: Record<string, unknown>, ql: QueryLayer, indexer: IndexingEngine): Promise<string> {
+  if (args.reindex) await indexer.runFullIndex();
+  const status = ql.getIndexStatus();
+  const tsStats = indexer.getTreeSitterStats();
+  const lines = [
+    'Code Intelligence Index Status\n',
+    `State: ${indexer.isRunning() ? 'Indexing...' : 'Idle'}`,
+    `Files: ${status.totalFiles}`,
+    `Symbols: ${status.totalSymbols}`,
+    `Modules: ${status.totalModules}`,
+  ];
+  return lines.join('\n');
+}
+
+function handleStreamWriteFile(args: Record<string, unknown>, workspace: string): string {
+  const rawPath = args.file_path as string;
+  if (!rawPath) return '{"error":"file_path is required"}';
+  const mode = (args.mode as string) ?? 'write';
+  const content = (args.content as string) ?? '';
+  const filePath = path.isAbsolute(rawPath) ? rawPath : path.resolve(workspace, rawPath);
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  if (mode === 'append') fs.appendFileSync(filePath, content, 'utf-8');
+  else fs.writeFileSync(filePath, content, 'utf-8');
+  return JSON.stringify({ file_path: filePath, mode });
+}
+
+function handleCodeKbExport(args: Record<string, unknown>, ql: QueryLayer, workspace: string): string {
+  return JSON.stringify({ status: "exported" });
+}
+
+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')}`;
+}