@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.8

package/src/mcp/tools/code-intelligence/analyze.ts

@@ -1,745 +0,0 @@
-/**
- * Agentic QE v3 - Code Intelligence MCP Tool
- *
- * qe/code/analyze - Analyze code using knowledge graph and semantic search
- *
- * This tool wraps the REAL code-intelligence domain services:
- * - KnowledgeGraphService for indexing and dependency mapping
- * - SemanticAnalyzerService for semantic code search
- * - ImpactAnalyzerService for change impact analysis
- */
-
-import { MCPToolBase, MCPToolConfig, MCPToolContext, MCPToolSchema } from '../base';
-import { ToolResult } from '../../types';
-import { KnowledgeGraphService } from '../../../domains/code-intelligence/services/knowledge-graph';
-import { SemanticAnalyzerService } from '../../../domains/code-intelligence/services/semantic-analyzer';
-import { ImpactAnalyzerService } from '../../../domains/code-intelligence/services/impact-analyzer';
-import { MemoryBackend, VectorSearchResult } from '../../../kernel/interfaces';
-import * as fs from 'fs';
-import * as path from 'path';
-
-// ============================================================================
-// Types
-// ============================================================================
-
-export interface CodeAnalyzeParams {
-  action: 'index' | 'search' | 'impact' | 'dependencies';
-  paths?: string[];
-  query?: string;
-  changedFiles?: string[];
-  depth?: number;
-  incremental?: boolean;
-  [key: string]: unknown;
-}
-
-export interface CodeAnalyzeResult {
-  action: string;
-  indexResult?: IndexResult;
-  searchResult?: SearchResult;
-  impactResult?: ImpactResult;
-  dependencyResult?: DependencyResult;
-}
-
-export interface IndexResult {
-  filesIndexed: number;
-  nodesCreated: number;
-  edgesCreated: number;
-  duration: number;
-  errors: { file: string; error: string }[];
-}
-
-export interface SearchResult {
-  results: SearchHit[];
-  total: number;
-  searchTime: number;
-}
-
-export interface SearchHit {
-  file: string;
-  line?: number;
-  snippet: string;
-  score: number;
-  highlights: string[];
-}
-
-export interface ImpactResult {
-  directImpact: ImpactedFile[];
-  transitiveImpact: ImpactedFile[];
-  impactedTests: string[];
-  riskLevel: 'critical' | 'high' | 'medium' | 'low' | 'info';
-  recommendations: string[];
-}
-
-export interface ImpactedFile {
-  file: string;
-  reason: string;
-  distance: number;
-  riskScore: number;
-}
-
-export interface DependencyResult {
-  nodes: DependencyNode[];
-  edges: DependencyEdge[];
-  cycles: string[][];
-  metrics: {
-    totalNodes: number;
-    totalEdges: number;
-    avgDegree: number;
-    maxDepth: number;
-  };
-}
-
-export interface DependencyNode {
-  id: string;
-  path: string;
-  type: 'module' | 'class' | 'function' | 'file';
-  inDegree: number;
-  outDegree: number;
-}
-
-export interface DependencyEdge {
-  source: string;
-  target: string;
-  type: 'import' | 'call' | 'extends' | 'implements';
-}
-
-// ============================================================================
-// Tool Implementation
-// ============================================================================
-
-export class CodeAnalyzeTool extends MCPToolBase<CodeAnalyzeParams, CodeAnalyzeResult> {
-  readonly config: MCPToolConfig = {
-    name: 'qe/code/analyze',
-    description: 'Analyze code using knowledge graph and semantic search. Supports indexing, searching, impact analysis, and dependency mapping.',
-    domain: 'code-intelligence',
-    schema: CODE_ANALYZE_SCHEMA,
-    streaming: true,
-    timeout: 300000,
-  };
-
-  private knowledgeGraph: KnowledgeGraphService | null = null;
-  private semanticAnalyzer: SemanticAnalyzerService | null = null;
-  private impactAnalyzer: ImpactAnalyzerService | null = null;
-
-  /**
-   * Get or create the knowledge graph service
-   */
-  private getKnowledgeGraph(context: MCPToolContext): KnowledgeGraphService {
-    if (!this.knowledgeGraph) {
-      const memory = (context as any).memory as MemoryBackend | undefined;
-      this.knowledgeGraph = new KnowledgeGraphService(
-        memory || createMinimalMemoryBackend()
-      );
-    }
-    return this.knowledgeGraph;
-  }
-
-  /**
-   * Get or create the semantic analyzer service
-   */
-  private getSemanticAnalyzer(context: MCPToolContext): SemanticAnalyzerService {
-    if (!this.semanticAnalyzer) {
-      const memory = (context as any).memory as MemoryBackend | undefined;
-      this.semanticAnalyzer = new SemanticAnalyzerService(
-        memory || createMinimalMemoryBackend()
-      );
-    }
-    return this.semanticAnalyzer;
-  }
-
-  /**
-   * Get or create the impact analyzer service
-   */
-  private getImpactAnalyzer(context: MCPToolContext): ImpactAnalyzerService {
-    if (!this.impactAnalyzer) {
-      const memory = (context as any).memory as MemoryBackend | undefined;
-      const knowledgeGraph = this.getKnowledgeGraph(context);
-      this.impactAnalyzer = new ImpactAnalyzerService(
-        memory || createMinimalMemoryBackend(),
-        knowledgeGraph
-      );
-    }
-    return this.impactAnalyzer;
-  }
-
-  async execute(
-    params: CodeAnalyzeParams,
-    context: MCPToolContext
-  ): Promise<ToolResult<CodeAnalyzeResult>> {
-    const { action, paths = ['.'], query, changedFiles = [], depth = 3, incremental = false } = params;
-
-    try {
-      this.emitStream(context, {
-        status: 'processing',
-        message: `Executing ${action} action`,
-      });
-
-      if (this.isAborted(context)) {
-        return { success: false, error: 'Operation aborted' };
-      }
-
-      let result: CodeAnalyzeResult = { action };
-
-      switch (action) {
-        case 'index':
-          result.indexResult = await this.executeIndex(paths, incremental, context);
-          break;
-        case 'search':
-          if (!query) {
-            return { success: false, error: 'Query is required for search action' };
-          }
-          result.searchResult = await this.executeSearch(query, paths, context);
-          break;
-        case 'impact':
-          if (changedFiles.length === 0) {
-            return { success: false, error: 'changedFiles is required for impact action' };
-          }
-          result.impactResult = await this.executeImpact(changedFiles, depth, context);
-          break;
-        case 'dependencies':
-          result.dependencyResult = await this.executeDependencies(paths, depth, context);
-          break;
-        default:
-          return { success: false, error: `Unknown action: ${action}` };
-      }
-
-      this.emitStream(context, {
-        status: 'complete',
-        message: `${action} complete`,
-        progress: 100,
-      });
-
-      return { success: true, data: result };
-    } catch (error) {
-      return {
-        success: false,
-        error: `Code analysis failed: ${error instanceof Error ? error.message : String(error)}`,
-      };
-    }
-  }
-
-  /**
-   * Index files using the real KnowledgeGraphService
-   */
-  private async executeIndex(
-    paths: string[],
-    incremental: boolean,
-    context: MCPToolContext
-  ): Promise<IndexResult> {
-    this.emitStream(context, {
-      status: 'indexing',
-      message: `Indexing ${paths.length} paths (${incremental ? 'incremental' : 'full'})`,
-    });
-
-    const service = this.getKnowledgeGraph(context);
-
-    // Expand paths to actual files
-    const files = await this.expandPaths(paths);
-
-    // Use real knowledge graph indexing
-    const result = await service.index({
-      paths: files,
-      incremental,
-      includeTests: true,
-      languages: ['typescript', 'javascript'],
-    });
-
-    if (!result.success) {
-      throw new Error(result.error?.message || 'Indexing failed');
-    }
-
-    return {
-      filesIndexed: result.value.filesIndexed,
-      nodesCreated: result.value.nodesCreated,
-      edgesCreated: result.value.edgesCreated,
-      duration: result.value.duration,
-      errors: result.value.errors,
-    };
-  }
-
-  /**
-   * Search code using the real SemanticAnalyzerService
-   */
-  private async executeSearch(
-    query: string,
-    paths: string[],
-    context: MCPToolContext
-  ): Promise<SearchResult> {
-    const startTime = Date.now();
-
-    // Check if demo mode is explicitly requested
-    if (this.isDemoMode(context)) {
-      const searchTime = Date.now() - startTime;
-      this.markAsDemoData(context, 'Demo mode explicitly requested');
-      return this.getDemoSearchResult(query, searchTime);
-    }
-
-    this.emitStream(context, {
-      status: 'searching',
-      message: `Searching for: ${query}`,
-    });
-
-    const service = this.getSemanticAnalyzer(context);
-
-    // Use real semantic search
-    const result = await service.search({
-      query,
-      type: 'semantic',
-      limit: 20,
-      scope: paths.length > 0 && paths[0] !== '.' ? paths : undefined,
-    });
-
-    const searchTime = Date.now() - startTime;
-
-    // If search failed, return error
-    if (!result.success) {
-      return {
-        results: [],
-        total: 0,
-        searchTime,
-      };
-    }
-
-    // Empty results is a valid state - no matches found
-    if (result.value.results.length === 0) {
-      this.markAsRealData(); // Real data, just no matches
-      return {
-        results: [],
-        total: 0,
-        searchTime,
-      };
-    }
-
-    // Mark as real data - we have actual search results
-    this.markAsRealData();
-
-    // Convert search results to output format
-    const searchResults: SearchHit[] = result.value.results.map((r) => ({
-      file: r.file,
-      line: r.line,
-      snippet: r.snippet.substring(0, 200) + (r.snippet.length > 200 ? '...' : ''),
-      score: r.score,
-      highlights: extractHighlights(r.snippet, query),
-    }));
-
-    return {
-      results: searchResults,
-      total: result.value.total,
-      searchTime,
-    };
-  }
-
-  /**
-   * Return demo search results when no real data available.
-   * Only used when demoMode is explicitly requested or as fallback with warning.
-   */
-  private getDemoSearchResult(query: string, searchTime: number): SearchResult {
-    return {
-      results: [
-        {
-          file: 'src/services/UserService.ts',
-          line: 15,
-          snippet: `export class ${query} { constructor() { /* initialization */ } }...`,
-          score: 0.95,
-          highlights: [query, `class ${query}`, `${query}Service`],
-        },
-        {
-          file: 'src/handlers/user-handler.ts',
-          line: 42,
-          snippet: `const service = new ${query}(); await service.initialize()...`,
-          score: 0.85,
-          highlights: [`new ${query}()`, `service.${query.toLowerCase()}`],
-        },
-        {
-          file: 'tests/services/UserService.test.ts',
-          line: 8,
-          snippet: `describe('${query}', () => { it('should initialize correctly'...`,
-          score: 0.78,
-          highlights: [`describe('${query}'`, `test ${query}`],
-        },
-      ],
-      total: 3,
-      searchTime,
-    };
-  }
-
-  /**
-   * Return demo impact results when no real data available.
-   * Only used when demoMode is explicitly requested or as fallback with warning.
-   */
-  private getDemoImpactResult(changedFiles: string[]): ImpactResult {
-    const baseFile = changedFiles[0] || 'src/service.ts';
-    const baseName = baseFile.split('/').pop()?.replace('.ts', '') || 'service';
-
-    return {
-      directImpact: [
-        {
-          file: `src/handlers/${baseName}-handler.ts`,
-          reason: `Direct import from ${baseFile}`,
-          distance: 0,
-          riskScore: 0.75,
-        },
-        {
-          file: `src/controllers/${baseName}-controller.ts`,
-          reason: `Uses exported functions from ${baseFile}`,
-          distance: 0,
-          riskScore: 0.65,
-        },
-      ],
-      transitiveImpact: [
-        {
-          file: 'src/routes/api.ts',
-          reason: `Imports from ${baseName}-handler.ts`,
-          distance: 1,
-          riskScore: 0.45,
-        },
-        {
-          file: 'src/app.ts',
-          reason: 'Imports API routes',
-          distance: 2,
-          riskScore: 0.25,
-        },
-      ],
-      impactedTests: [
-        `tests/${baseName}.test.ts`,
-        `tests/${baseName}-handler.test.ts`,
-        'tests/integration/api.test.ts',
-      ],
-      riskLevel: 'medium',
-      recommendations: [
-        `Review changes in ${baseFile} for breaking changes`,
-        'Run affected test suites before merging',
-        'Consider updating dependent documentation',
-      ],
-    };
-  }
-
-  /**
-   * Analyze impact using the real ImpactAnalyzerService
-   */
-  private async executeImpact(
-    changedFiles: string[],
-    depth: number,
-    context: MCPToolContext
-  ): Promise<ImpactResult> {
-    // Check if demo mode is explicitly requested
-    if (this.isDemoMode(context)) {
-      this.markAsDemoData(context, 'Demo mode explicitly requested');
-      return this.getDemoImpactResult(changedFiles);
-    }
-
-    this.emitStream(context, {
-      status: 'analyzing',
-      message: `Analyzing impact of ${changedFiles.length} changed files`,
-    });
-
-    try {
-      const service = this.getImpactAnalyzer(context);
-
-      // Use real impact analysis
-      const result = await service.analyzeImpact({
-        changedFiles,
-        depth,
-        includeTests: true,
-      });
-
-      // If impact analysis failed, return error - don't silently fall back
-      if (!result.success) {
-        return {
-          directImpact: [],
-          transitiveImpact: [],
-          impactedTests: [],
-          riskLevel: 'low',
-          recommendations: [`Impact analysis failed: ${result.error?.message || 'Unknown error'}. Ensure the code index is built first using action: 'index'.`],
-        };
-      }
-
-      // Mark as real data - we have actual impact analysis
-      this.markAsRealData();
-
-      const impact = result.value;
-
-      // Impact already in correct format from service
-      return {
-        directImpact: impact.directImpact,
-        transitiveImpact: impact.transitiveImpact,
-        impactedTests: impact.impactedTests,
-        riskLevel: impact.riskLevel,
-        recommendations: impact.recommendations,
-      };
-    } catch (error) {
-      // On error, return error info in recommendations - don't silently fall back
-      return {
-        directImpact: [],
-        transitiveImpact: [],
-        impactedTests: [],
-        riskLevel: 'low',
-        recommendations: [`Impact analysis error: ${error instanceof Error ? error.message : 'Unknown error'}. Check that files exist and index is built.`],
-      };
-    }
-  }
-
-  /**
-   * Map dependencies using the real KnowledgeGraphService
-   */
-  private async executeDependencies(
-    paths: string[],
-    depth: number,
-    context: MCPToolContext
-  ): Promise<DependencyResult> {
-    this.emitStream(context, {
-      status: 'mapping',
-      message: `Mapping dependencies to depth ${depth}`,
-    });
-
-    const service = this.getKnowledgeGraph(context);
-
-    // Expand paths to actual files
-    const files = await this.expandPaths(paths);
-
-    // Use real dependency mapping
-    const result = await service.mapDependencies({
-      files,
-      direction: 'both',
-      depth,
-    });
-
-    if (!result.success) {
-      throw new Error(result.error?.message || 'Dependency mapping failed');
-    }
-
-    const depMap = result.value;
-
-    // Convert to output format
-    const nodes: DependencyNode[] = depMap.nodes.map((n) => ({
-      id: n.id,
-      path: n.path,
-      type: n.type as DependencyNode['type'],
-      inDegree: n.inDegree,
-      outDegree: n.outDegree,
-    }));
-
-    const edges: DependencyEdge[] = depMap.edges.map((e) => ({
-      source: e.source,
-      target: e.target,
-      type: e.type as DependencyEdge['type'],
-    }));
-
-    return {
-      nodes,
-      edges,
-      cycles: depMap.cycles,
-      metrics: {
-        totalNodes: depMap.metrics.totalNodes,
-        totalEdges: depMap.metrics.totalEdges,
-        avgDegree: depMap.metrics.avgDegree,
-        maxDepth: depMap.metrics.maxDepth,
-      },
-    };
-  }
-
-  /**
-   * Expand directory paths to file paths
-   */
-  private async expandPaths(paths: string[]): Promise<string[]> {
-    const files: string[] = [];
-
-    for (const p of paths) {
-      const absPath = path.isAbsolute(p) ? p : path.resolve(process.cwd(), p);
-
-      try {
-        const stats = await fs.promises.stat(absPath);
-
-        if (stats.isDirectory()) {
-          // Recursively find source files
-          const dirFiles = await this.findSourceFiles(absPath);
-          files.push(...dirFiles);
-        } else if (stats.isFile()) {
-          files.push(absPath);
-        }
-      } catch {
-        // Path doesn't exist, skip it
-      }
-    }
-
-    return files;
-  }
-
-  /**
-   * Find source files in a directory
-   */
-  private async findSourceFiles(dir: string): Promise<string[]> {
-    const files: string[] = [];
-    const extensions = ['.ts', '.tsx', '.js', '.jsx'];
-    const ignoreDirs = ['node_modules', '.git', 'dist', 'build', 'coverage'];
-
-    try {
-      const entries = await fs.promises.readdir(dir, { withFileTypes: true });
-
-      for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-
-        if (entry.isDirectory()) {
-          if (!ignoreDirs.includes(entry.name)) {
-            const subFiles = await this.findSourceFiles(fullPath);
-            files.push(...subFiles);
-          }
-        } else if (entry.isFile()) {
-          const ext = path.extname(entry.name);
-          if (extensions.includes(ext)) {
-            files.push(fullPath);
-          }
-        }
-      }
-    } catch {
-      // Directory read failed, skip it
-    }
-
-    return files;
-  }
-}
-
-// ============================================================================
-// Schema
-// ============================================================================
-
-const CODE_ANALYZE_SCHEMA: MCPToolSchema = {
-  type: 'object',
-  properties: {
-    action: {
-      type: 'string',
-      description: 'Analysis action to perform',
-      enum: ['index', 'search', 'impact', 'dependencies'],
-    },
-    paths: {
-      type: 'array',
-      description: 'Paths to analyze',
-      items: { type: 'string', description: 'File or directory path' },
-      default: ['.'],
-    },
-    query: {
-      type: 'string',
-      description: 'Search query (for search action)',
-    },
-    changedFiles: {
-      type: 'array',
-      description: 'Changed files to analyze (for impact action)',
-      items: { type: 'string', description: 'File path' },
-    },
-    depth: {
-      type: 'number',
-      description: 'Analysis depth',
-      minimum: 1,
-      maximum: 10,
-      default: 3,
-    },
-    incremental: {
-      type: 'boolean',
-      description: 'Incremental indexing (for index action)',
-      default: false,
-    },
-  },
-  required: ['action'],
-};
-
-// ============================================================================
-// Helper Functions
-// ============================================================================
-
-/**
- * Extract highlights from content matching query
- */
-function extractHighlights(content: string, query: string): string[] {
-  const highlights: string[] = [];
-  const queryTerms = query.toLowerCase().split(/\s+/);
-  const contentLower = content.toLowerCase();
-
-  for (const term of queryTerms) {
-    if (term.length < 2) continue;
-
-    let idx = 0;
-    while ((idx = contentLower.indexOf(term, idx)) !== -1) {
-      // Extract surrounding context
-      const start = Math.max(0, idx - 20);
-      const end = Math.min(content.length, idx + term.length + 20);
-      const highlight = content.substring(start, end);
-
-      if (!highlights.includes(highlight)) {
-        highlights.push(highlight);
-      }
-
-      idx += term.length;
-      if (highlights.length >= 3) break;
-    }
-    if (highlights.length >= 3) break;
-  }
-
-  return highlights;
-}
-
-/**
- * Create minimal memory backend for standalone operation
- */
-function createMinimalMemoryBackend(): MemoryBackend {
-  const store = new Map<string, { value: unknown; metadata?: unknown }>();
-  const vectors = new Map<string, { embedding: number[]; metadata?: unknown }>();
-
-  return {
-    async initialize(): Promise<void> {
-      // No initialization needed
-    },
-    async dispose(): Promise<void> {
-      store.clear();
-      vectors.clear();
-    },
-    async set(key: string, value: unknown, _options?: unknown): Promise<void> {
-      store.set(key, { value });
-    },
-    async get<T>(key: string): Promise<T | undefined> {
-      const entry = store.get(key);
-      return entry ? (entry.value as T) : undefined;
-    },
-    async delete(key: string): Promise<boolean> {
-      return store.delete(key);
-    },
-    async has(key: string): Promise<boolean> {
-      return store.has(key);
-    },
-    async search(pattern: string, limit?: number): Promise<string[]> {
-      const regex = new RegExp(pattern.replace(/\*/g, '.*'));
-      const matches = Array.from(store.keys()).filter((key) => regex.test(key));
-      return limit ? matches.slice(0, limit) : matches;
-    },
-    async vectorSearch(embedding: number[], k: number): Promise<VectorSearchResult[]> {
-      // Simple cosine similarity search
-      const results = Array.from(vectors.entries())
-        .map(([key, data]) => ({
-          key,
-          score: cosineSimilarity(embedding, data.embedding),
-          metadata: data.metadata,
-        }))
-        .sort((a, b) => b.score - a.score)
-        .slice(0, k);
-      return results;
-    },
-    async storeVector(key: string, embedding: number[], metadata?: unknown): Promise<void> {
-      vectors.set(key, { embedding, metadata });
-    },
-  };
-}
-
-/**
- * Calculate cosine similarity between two vectors
- */
-function cosineSimilarity(a: number[], b: number[]): number {
-  if (a.length !== b.length) return 0;
-  let dotProduct = 0;
-  let normA = 0;
-  let normB = 0;
-  for (let i = 0; i < a.length; i++) {
-    dotProduct += a[i] * b[i];
-    normA += a[i] * a[i];
-    normB += b[i] * b[i];
-  }
-  return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB) || 1);
-}