sdlc-agent-4-enterprise-server 1.0.0

package/src/engine/tools/code-index-status.ts

@@ -0,0 +1,85 @@
+/**
+ * code_index_status tool — Show indexing statistics and health.
+ * KSA-191: Enhanced with SFDX stats section when Salesforce project detected.
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { QueryLayer } from '../query/query-layer.js';
+import { IndexingEngine } from '../indexer/indexing-engine.js';
+
+export function registerCodeIndexStatus(
+  server: McpServer, queryLayer: QueryLayer, indexer: IndexingEngine
+): void {
+  server.tool(
+    'code_index_status',
+    'Get current indexing status: file count, symbol count, languages, last indexed time, indexer state, and SFDX stats (if Salesforce project detected).',
+    {
+      reindex: z.boolean().optional().default(false).describe('Trigger a full re-index'),
+    },
+    async ({ reindex }) => {
+      if (reindex) {
+        await indexer.runFullIndex();
+      }
+      const status = queryLayer.getIndexStatus();
+      const sfdxStats = indexer.getSfdxStats();
+      const tsStats = indexer.getTreeSitterStats();
+      const text = formatStatus(status, indexer.isRunning(), sfdxStats, tsStats);
+      return { content: [{ type: 'text', text }] };
+    }
+  );
+}
+
+function formatStatus(
+  status: any,
+  isRunning: boolean,
+  sfdxStats: ReturnType<IndexingEngine['getSfdxStats']>,
+  tsStats: ReturnType<IndexingEngine['getTreeSitterStats']>
+): string {
+  const lines = [
+    '\u{1F4CA} Code Intelligence Index Status\n',
+    `State: ${isRunning ? '\u{1F504} Indexing...' : '\u{2705} Idle'}`,
+    `Files: ${status.totalFiles}`,
+    `Symbols: ${status.totalSymbols}`,
+    `Modules: ${status.totalModules}`,
+    `Last indexed: ${status.lastIndexed ?? 'Never'}`,
+    '',
+    'Languages:',
+  ];
+
+  for (const [lang, count] of Object.entries(status.languages)) {
+    lines.push(`  ${lang}: ${count} files`);
+  }
+
+  // KSA-191: SFDX stats section
+  if (sfdxStats) {
+    lines.push('');
+    lines.push('\u{26A1} Salesforce (SFDX):');
+    lines.push(`  Detected: ${sfdxStats.detected}`);
+    lines.push(`  Package directories: ${sfdxStats.packageDirectories.join(', ')}`);
+    lines.push(`  Apex classes: ${sfdxStats.stats.apex_classes}`);
+    lines.push(`  Apex triggers: ${sfdxStats.stats.apex_triggers}`);
+    lines.push(`  Flows: ${sfdxStats.stats.flows}`);
+    lines.push(`  Objects: ${sfdxStats.stats.objects}`);
+    lines.push(`  LWC components: ${sfdxStats.stats.lwc_components}`);
+    if (sfdxStats.lastIndexed) {
+      lines.push(`  Last indexed: ${sfdxStats.lastIndexed}`);
+    }
+
+    const relEntries = Object.entries(sfdxStats.relationships);
+    if (relEntries.length > 0) {
+      lines.push('  Relationships:');
+      for (const [kind, count] of relEntries) {
+        lines.push(`    ${kind}: ${count}`);
+      }
+    }
+  }
+
+  // KSA-209: Unavailable grammars warning
+  if (tsStats.unavailableGrammars.length > 0) {
+    lines.push('');
+    lines.push(`\u{26A0}\u{FE0F} Unavailable grammars (WASM missing \u{2014} using regex fallback): ${tsStats.unavailableGrammars.join(', ')}`);
+  }
+
+  return lines.join('\n');
+}

package/src/engine/tools/code-kb-export.ts

@@ -0,0 +1,84 @@
+/**
+ * code_kb_export tool — Export code intelligence data as KB payloads.
+ * Returns structured data ready for kb_ingest consumption.
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { ModuleInfo, QueryLayer } from '../query/query-layer.js';
+
+export function registerCodeKbExport(server: McpServer, queryLayer: QueryLayer, workspace: string): void {
+  server.tool(
+    'code_kb_export',
+    'Export code intelligence data as Knowledge Base payloads for ingestion. Returns structured data ready for kb_ingest.',
+    {
+      module: z.string().optional().describe('Filter by module name (optional, exports all if omitted)'),
+      format: z.string().optional().describe('Output format: json (default) or text'),
+    },
+    async ({ module, format }) => {
+      const modules = queryLayer.listModulesWithPatterns(module ?? null);
+      const projectName = extractProjectName(workspace);
+      const outputFormat = format ?? 'json';
+      const text = outputFormat === 'text'
+        ? formatAsText(modules, projectName)
+        : formatAsJson(modules, projectName);
+      return { content: [{ type: 'text', text }] };
+    }
+  );
+}
+
+function extractProjectName(workspace: string): string {
+  const parts = workspace.replace(/\\/g, '/').split('/');
+  return parts[parts.length - 1] || 'unknown';
+}
+
+interface KbPayload {
+  title: string;
+  content: string;
+  tags: string;
+  project: string;
+}
+
+function buildPayload(m: ModuleInfo, projectName: string): KbPayload {
+  const contentLines = [
+    `Module: ${m.name}`,
+    `Language: ${m.language ?? 'unknown'}`,
+    `Purpose: ${m.purpose ?? 'unknown'}`,
+    `Files: ${m.fileCount}`,
+    `Symbols: ${m.symbolCount}`,
+    '',
+    'Patterns:',
+    `  DI Style: ${m.diStyle ?? 'unknown'}`,
+    `  Error Handling: ${m.errorHandling ?? 'unknown'}`,
+    `  Naming: ${m.namingConvention ?? 'unknown'}`,
+    `  Logging: ${m.loggingFramework ?? 'unknown'}`,
+    `  Testing: ${m.testingFramework ?? 'unknown'}`,
+  ];
+  const tags = ['code-index', m.name, m.language ?? 'unknown'].join(', ');
+  return {
+    title: `Code Index — ${m.name}`,
+    content: contentLines.join('\n'),
+    tags,
+    project: projectName,
+  };
+}
+
+function formatAsJson(modules: ModuleInfo[], projectName: string): string {
+  if (modules.length === 0) return '[]';
+  const payloads = modules.map(m => buildPayload(m, projectName));
+  return JSON.stringify(payloads, null, 2);
+}
+
+function formatAsText(modules: ModuleInfo[], projectName: string): string {
+  if (modules.length === 0) return 'No modules indexed yet. Run indexing first.';
+  const payloads = modules.map(m => buildPayload(m, projectName));
+  const lines: string[] = [];
+  for (const p of payloads) {
+    lines.push(`--- ${p.title} ---`);
+    lines.push(p.content);
+    lines.push(`Tags: ${p.tags}`);
+    lines.push(`Project: ${p.project}`);
+    lines.push('');
+  }
+  return lines.join('\n');
+}

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

@@ -0,0 +1,53 @@
+/**
+ * code_modules tool — List discovered modules with file/symbol counts.
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { QueryLayer } from '../query/query-layer.js';
+
+export function registerCodeModules(server: McpServer, queryLayer: QueryLayer): void {
+  server.tool(
+    'code_modules',
+    'List all discovered code modules in the workspace with file counts, languages, and descriptions.',
+    {
+      name: z.string().optional().describe('Filter by module name (prefix match)'),
+    },
+    async ({ name }) => {
+      const modules = queryLayer.listModules();
+      const filtered = name
+        ? modules.filter(m => m.name.toLowerCase().startsWith(name.toLowerCase()))
+        : modules;
+      const text = formatModules(filtered);
+      return { content: [{ type: 'text', text }] };
+    }
+  );
+}
+
+function formatModules(modules: any[]): string {
+  if (modules.length === 0) return 'No modules indexed yet. Run indexing first.';
+
+  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}`);
+    const patterns = formatPatterns(m);
+    if (patterns) lines.push(`   Patterns: ${patterns}`);
+    if (m.purpose) lines.push(`   Purpose: ${m.purpose}`);
+    if (m.description) lines.push(`   ${m.description}`);
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+
+function formatPatterns(m: any): string {
+  const parts: string[] = [];
+  if (m.diStyle) parts.push(`DI=${m.diStyle}`);
+  if (m.errorHandling) parts.push(`Errors=${m.errorHandling}`);
+  if (m.namingConvention) parts.push(`Naming=${m.namingConvention}`);
+  if (m.loggingFramework) parts.push(`Logging=${m.loggingFramework}`);
+  if (m.testingFramework) parts.push(`Testing=${m.testingFramework}`);
+  return parts.join(' | ');
+}

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

@@ -0,0 +1,39 @@
+/**
+ * code_search tool — Full-text search across indexed codebase using FTS5.
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { QueryLayer } from '../query/query-layer.js';
+
+export function registerCodeSearch(server: McpServer, queryLayer: QueryLayer): void {
+  server.tool(
+    'code_search',
+    'Full-text search across indexed code symbols (functions, classes, interfaces). Uses SQLite FTS5 with porter stemming.',
+    {
+      query: z.string().describe('Search query (supports FTS5 syntax: AND, OR, NOT, prefix*)'),
+      limit: z.number().optional().default(20).describe('Max results (default 20)'),
+    },
+    async ({ query, limit }) => {
+      const results = queryLayer.searchCode(query, limit);
+      const text = formatSearchResults(results, query);
+      return { content: [{ type: 'text', text }] };
+    }
+  );
+}
+
+function formatSearchResults(results: any[], query: string): string {
+  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)}`);
+    if (r.docComment) lines.push(`  Doc: ${r.docComment.slice(0, 100)}`);
+    lines.push('');
+  }
+  return lines.join('\n');
+}

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

@@ -0,0 +1,53 @@
+/**
+ * code_symbols tool — Lookup symbols by name, kind, or file path.
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { QueryLayer } from '../query/query-layer.js';
+
+export function registerCodeSymbols(server: McpServer, queryLayer: QueryLayer): void {
+  server.tool(
+    'code_symbols',
+    'Find code symbols by name prefix or list symbols in a file. Filter by kind (function, class, interface, etc).',
+    {
+      name: z.string().optional().describe('Symbol name or prefix to search'),
+      file: z.string().optional().describe('File path to list symbols from'),
+      kind: z.string().optional().describe('Filter by kind: function, class, interface, enum, type, method'),
+      limit: z.number().optional().default(50).describe('Max results'),
+    },
+    async ({ name, file, kind, limit }) => {
+      let text: string;
+      if (file) {
+        const symbols = queryLayer.getFileSymbols(file);
+        text = formatFileSymbols(file, symbols);
+      } else if (name) {
+        const symbols = queryLayer.findSymbols(name, kind, limit);
+        text = formatSymbolList(symbols, name);
+      } else {
+        text = 'Provide either "name" or "file" parameter';
+      }
+      return { content: [{ type: 'text', text }] };
+    }
+  );
+}
+
+function formatFileSymbols(file: string, symbols: any[]): string {
+  if (symbols.length === 0) return `No symbols found in ${file}`;
+  const lines = [`Symbols in ${file} (${symbols.length}):\n`];
+  for (const s of symbols) {
+    const vis = s.visibility ? `[${s.visibility}] ` : '';
+    lines.push(`  L${s.startLine} ${vis}${s.kind} ${s.name}`);
+  }
+  return lines.join('\n');
+}
+
+function formatSymbolList(symbols: any[], query: string): string {
+  if (symbols.length === 0) return `No symbols matching "${query}"`;
+  const lines = [`Found ${symbols.length} symbols matching "${query}":\n`];
+  for (const s of symbols) {
+    lines.push(`[${s.kind}] ${s.name} — ${s.filePath}:${s.startLine}`);
+    if (s.signature) lines.push(`  ${s.signature.slice(0, 120)}`);
+  }
+  return lines.join('\n');
+}

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

@@ -0,0 +1,75 @@
+/**
+ * KSA-157: MCP Tool Registration for code_traverse.
+ */
+
+import Database from 'better-sqlite3';
+import { SymbolResolver } from '../graph/symbol-resolver.js';
+import { GraphTraverser, TraverseConfig } from '../graph/traverser.js';
+
+export const TRAVERSE_TOOL_DEFINITIONS = [
+  {
+    name: 'code_traverse',
+    description: 'Generic graph traversal with custom edge/node type filters. Traverse the code relationship graph from any symbol with fine-grained control.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        start: { type: 'string', description: 'Start symbol (e.g. "MyClass", "MyClass.method", "file.ts:func")' },
+        edge_types: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Filter by edge types: calls, imports, inherits, implements, uses, decorates (default: all)',
+        },
+        node_types: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Filter by node types: function, class, interface, method, variable (default: all)',
+        },
+        direction: { type: 'string', enum: ['outgoing', 'incoming', 'both'], description: 'Traversal direction (default: outgoing)' },
+        max_depth: { type: 'number', description: 'Maximum traversal depth 1-10 (default: 3)' },
+        max_results: { type: 'number', description: 'Maximum results (default: 50)' },
+        include_source: { type: 'boolean', description: 'Include source code snippets (default: false)' },
+        source_lines: { type: 'number', description: 'Lines of source to include (default: 5)' },
+      },
+      required: ['start'],
+    },
+  },
+];
+
+export function handleCodeTraverse(args: Record<string, unknown>, db: Database.Database, workspace: string): string {
+  const start = args.start as string;
+  if (!start) return JSON.stringify({ error: 'Parameter "start" is required' });
+
+  const edgeTypes = (args.edge_types as string[]) ?? [];
+  const nodeTypes = (args.node_types as string[]) ?? [];
+  const direction = (args.direction as 'outgoing' | 'incoming' | 'both') ?? 'outgoing';
+  const maxDepth = Math.min(Math.max((args.max_depth as number) ?? 3, 1), 10);
+  const maxResults = Math.min((args.max_results as number) ?? 50, 200);
+  const includeSource = (args.include_source as boolean) ?? false;
+  const sourceLines = (args.source_lines as number) ?? 5;
+
+  const resolver = new SymbolResolver(db);
+  const traverser = new GraphTraverser(db, resolver, workspace);
+
+  // Resolve start node
+  const startNode = traverser.resolveNode(start);
+  if (!startNode) {
+    const suggestions = resolver.suggest(start);
+    if (suggestions.length > 0) {
+      return `Symbol "${start}" not found. Did you mean: ${suggestions.join(', ')}?`;
+    }
+    return `Symbol "${start}" not found in index.`;
+  }
+
+  const config: TraverseConfig = { edgeTypes, nodeTypes, direction, maxDepth, maxResults };
+
+  const startTime = Date.now();
+  const results = traverser.traverse(startNode, config);
+  const executionTimeMs = Date.now() - startTime;
+
+  if (results.length === 0) {
+    return `No connected nodes found from "${start}" with the given filters (direction: ${direction}, edge_types: ${edgeTypes.length > 0 ? edgeTypes.join(',') : 'all'}, node_types: ${nodeTypes.length > 0 ? nodeTypes.join(',') : 'all'})`;
+  }
+
+  const response = traverser.formatResponse(startNode, results, includeSource, sourceLines, executionTimeMs);
+  return JSON.stringify(response, null, 2);
+}

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

@@ -0,0 +1,54 @@
+/**
+ * KSA-155: MCP Tool Registration for code_dependencies.
+ */
+
+import Database from 'better-sqlite3';
+import { FileResolver } from '../graph/file-resolver.js';
+import { DependencyGraphService } from '../graph/dependency-graph-service.js';
+import { formatDependencyResult } from '../graph/dependency-formatters.js';
+
+export const DEPENDENCY_TOOL_DEFINITIONS = [
+  {
+    name: 'code_dependencies',
+    description: 'Analyze file/module import dependencies with direction and depth control. Shows what a file imports (outgoing) or what imports it (incoming).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        file: { type: 'string', description: 'File path to analyze (relative or absolute)' },
+        direction: { type: 'string', enum: ['incoming', 'outgoing', 'both'], description: 'Direction of dependency analysis (default: outgoing)' },
+        depth: { type: 'number', description: 'Traversal depth 1-5 (default: 1)' },
+        include_external: { type: 'boolean', description: 'Include external/stdlib dependencies (default: false)' },
+        format: { type: 'string', enum: ['tree', 'flat', 'graph'], description: 'Output format (default: tree)' },
+        limit: { type: 'number', description: 'Max results (default: 50)' },
+      },
+      required: ['file'],
+    },
+  },
+];
+
+export function handleCodeDependencies(args: Record<string, unknown>, db: Database.Database, workspace: string): string {
+  const file = args.file as string;
+  if (!file) return JSON.stringify({ error: 'Parameter "file" is required' });
+
+  const direction = (args.direction as 'incoming' | 'outgoing' | 'both') ?? 'outgoing';
+  const depth = (args.depth as number) ?? 1;
+  const includeExternal = (args.include_external as boolean) ?? false;
+  const format = (args.format as string) ?? 'tree';
+  const limit = (args.limit as number) ?? 50;
+
+  const fileResolver = new FileResolver(db, workspace);
+  const service = new DependencyGraphService(db, fileResolver);
+
+  const result = service.query(file, direction, depth, includeExternal, limit);
+
+  if (result.results.length === 0 && result.root === file) {
+    return `File "${file}" not found in index. Make sure the file has been indexed.`;
+  }
+
+  if (result.results.length === 0) {
+    return `No ${direction} dependencies found for "${result.root}"`;
+  }
+
+  const formatted = formatDependencyResult(result, format);
+  return JSON.stringify(formatted, null, 2);
+}