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

package/src/integrations/ruvector/graph-boundaries.ts

@@ -1,809 +0,0 @@
-/**
- * Agentic QE v3 - Graph Boundaries Analyzer for RuVector Integration
- *
- * Uses RuVector's graph analysis capabilities to detect module boundaries.
- * Falls back to path-based analysis when RuVector is unavailable.
- */
-
-import type {
-  GraphBoundariesAnalyzer,
-  GraphBoundariesResult,
-  ModuleBoundary,
-  BoundaryCrossing,
-  ModuleDependency,
-  RuVectorConfig,
-} from './interfaces';
-import { FallbackGraphBoundariesAnalyzer } from './fallback';
-import type { Severity, Priority } from '../../shared/types';
-
-// ============================================================================
-// Graph Configuration
-// ============================================================================
-
-/**
- * Configuration for graph boundary analysis
- */
-export interface GraphConfig {
-  /** Max depth to traverse dependencies */
-  maxDepth: number;
-  /** Coupling threshold for boundary detection */
-  couplingThreshold: number;
-  /** Min cohesion for module to be considered well-defined */
-  minCohesion: number;
-  /** Patterns to identify module roots */
-  modulePatterns: RegExp[];
-  /** Patterns to ignore */
-  ignorePatterns: RegExp[];
-}
-
-const DEFAULT_GRAPH_CONFIG: GraphConfig = {
-  maxDepth: 5,
-  couplingThreshold: 0.7,
-  minCohesion: 0.5,
-  modulePatterns: [
-    /^src\/domains?\//,
-    /^src\/modules?\//,
-    /^src\/features?\//,
-    /^src\/services?\//,
-    /^packages?\//,
-    /^libs?\//,
-  ],
-  ignorePatterns: [
-    /node_modules/,
-    /\.test\./,
-    /\.spec\./,
-    /__tests__/,
-    /__mocks__/,
-    /\.d\.ts$/,
-  ],
-};
-
-// ============================================================================
-// RuVector Graph Boundaries Analyzer Implementation
-// ============================================================================
-
-/**
- * Graph boundaries analyzer that integrates with RuVector
- * Provides ML-enhanced module boundary detection
- */
-export class RuVectorGraphBoundariesAnalyzer implements GraphBoundariesAnalyzer {
-  private readonly fallback: FallbackGraphBoundariesAnalyzer;
-  private readonly graphConfig: GraphConfig;
-  private readonly cache: Map<string, { result: GraphBoundariesResult; timestamp: number }> = new Map();
-  private moduleCache: Map<string, ModuleBoundary> = new Map();
-  private dependencyGraph: Map<string, ModuleDependency[]> = new Map();
-
-  constructor(
-    private readonly config: RuVectorConfig,
-    graphConfig?: Partial<GraphConfig>
-  ) {
-    this.fallback = new FallbackGraphBoundariesAnalyzer();
-    this.graphConfig = { ...DEFAULT_GRAPH_CONFIG, ...graphConfig };
-  }
-
-  /**
-   * Analyze module boundaries in codebase
-   */
-  async analyzeBoundaries(entryPoints: string[]): Promise<GraphBoundariesResult> {
-    if (!this.config.enabled) {
-      return this.fallback.analyzeBoundaries(entryPoints);
-    }
-
-    // Check cache
-    const cacheKey = this.computeCacheKey(entryPoints);
-    if (this.config.cacheEnabled) {
-      const cached = this.cache.get(cacheKey);
-      if (cached && Date.now() - cached.timestamp < (this.config.cacheTtl || 300000)) {
-        return cached.result;
-      }
-    }
-
-    try {
-      const result = await this.performAnalysis(entryPoints);
-
-      // Cache result
-      if (this.config.cacheEnabled) {
-        this.cache.set(cacheKey, { result, timestamp: Date.now() });
-      }
-
-      return result;
-    } catch (error) {
-      console.warn('[RuVectorGraphBoundariesAnalyzer] Analysis failed, using fallback:', error);
-      return this.fallback.analyzeBoundaries(entryPoints);
-    }
-  }
-
-  /**
-   * Get boundary crossings for specific modules
-   */
-  async getBoundaryCrossings(modules: string[]): Promise<BoundaryCrossing[]> {
-    const crossings: BoundaryCrossing[] = [];
-
-    for (let i = 0; i < modules.length; i++) {
-      for (let j = i + 1; j < modules.length; j++) {
-        const crossing = await this.analyzeBoundaryCrossing(modules[i], modules[j]);
-        if (crossing.crossings.length > 0 || crossing.riskScore > 0.3) {
-          crossings.push(crossing);
-        }
-      }
-    }
-
-    return crossings.sort((a, b) => b.riskScore - a.riskScore);
-  }
-
-  /**
-   * Identify critical paths across modules
-   */
-  async getCriticalPaths(): Promise<Array<{ path: string[]; importance: number; reason: string }>> {
-    const paths: Array<{ path: string[]; importance: number; reason: string }> = [];
-
-    // Analyze module graph for critical paths
-    for (const [source, deps] of this.dependencyGraph.entries()) {
-      const highWeightDeps = deps.filter((d) => d.weight > 0.7);
-
-      for (const dep of highWeightDeps) {
-        // Find transitive dependencies
-        const transitivePath = await this.findTransitivePath(source, dep.target);
-
-        if (transitivePath.length > 2) {
-          paths.push({
-            path: transitivePath,
-            importance: this.calculatePathImportance(transitivePath, deps),
-            reason: `High coupling path: ${dep.weight.toFixed(2)} weight`,
-          });
-        }
-      }
-    }
-
-    // Sort by importance
-    return paths.sort((a, b) => b.importance - a.importance).slice(0, 10);
-  }
-
-  /**
-   * Suggest integration test locations
-   */
-  async suggestIntegrationTests(): Promise<Array<{
-    location: string;
-    modules: string[];
-    priority: Priority;
-    reason: string;
-  }>> {
-    const suggestions: Array<{
-      location: string;
-      modules: string[];
-      priority: Priority;
-      reason: string;
-    }> = [];
-
-    // Find high-coupling boundaries
-    for (const [source, deps] of this.dependencyGraph.entries()) {
-      const crossingDeps = deps.filter((d) => {
-        const sourceModule = this.getModuleName(source);
-        const targetModule = this.getModuleName(d.target);
-        return sourceModule !== targetModule;
-      });
-
-      if (crossingDeps.length > 0) {
-        const avgWeight = crossingDeps.reduce((sum, d) => sum + d.weight, 0) / crossingDeps.length;
-        const priority = avgWeight > 0.7 ? 'p0' : avgWeight > 0.5 ? 'p1' : 'p2';
-
-        suggestions.push({
-          location: source,
-          modules: [...new Set(crossingDeps.map((d) => this.getModuleName(d.target)))],
-          priority,
-          reason: `${crossingDeps.length} cross-module dependencies, avg coupling: ${avgWeight.toFixed(2)}`,
-        });
-      }
-    }
-
-    return suggestions.sort((a, b) => {
-      const priorityOrder: Record<Priority, number> = { p0: 0, p1: 1, p2: 2, p3: 3 };
-      return priorityOrder[a.priority] - priorityOrder[b.priority];
-    });
-  }
-
-  /**
-   * Detect architecture violations
-   */
-  async detectViolations(): Promise<Array<{
-    type: string;
-    location: string;
-    severity: Severity;
-    suggestion: string;
-  }>> {
-    const violations: Array<{
-      type: string;
-      location: string;
-      severity: Severity;
-      suggestion: string;
-    }> = [];
-
-    // Detect circular dependencies
-    const circularDeps = await this.detectCircularDependencies();
-    for (const cycle of circularDeps) {
-      violations.push({
-        type: 'circular-dependency',
-        location: cycle.join(' -> '),
-        severity: cycle.length > 3 ? 'critical' : 'high',
-        suggestion: `Break circular dependency by introducing an abstraction layer between ${cycle[0]} and ${cycle[cycle.length - 1]}`,
-      });
-    }
-
-    // Detect layer violations
-    const layerViolations = await this.detectLayerViolations();
-    for (const violation of layerViolations) {
-      violations.push({
-        type: 'layer-violation',
-        location: `${violation.from} -> ${violation.to}`,
-        severity: 'high',
-        suggestion: `${violation.from} should not depend on ${violation.to}. Consider dependency injection or event-based communication.`,
-      });
-    }
-
-    // Detect high coupling
-    for (const module of this.moduleCache.values()) {
-      if (module.couplingScore > this.graphConfig.couplingThreshold) {
-        violations.push({
-          type: 'coupling-too-high',
-          location: module.module,
-          severity: module.couplingScore > 0.9 ? 'critical' : 'medium',
-          suggestion: `Module ${module.module} has high coupling (${module.couplingScore.toFixed(2)}). Consider breaking into smaller modules.`,
-        });
-      }
-    }
-
-    return violations.sort((a, b) => {
-      const severityOrder: Record<Severity, number> = {
-        critical: 0,
-        high: 1,
-        medium: 2,
-        low: 3,
-        info: 4,
-      };
-      return severityOrder[a.severity] - severityOrder[b.severity];
-    });
-  }
-
-  // ============================================================================
-  // Private Methods
-  // ============================================================================
-
-  /**
-   * Perform boundary analysis
-   */
-  private async performAnalysis(entryPoints: string[]): Promise<GraphBoundariesResult> {
-    // Filter entry points
-    const filteredEntries = entryPoints.filter(
-      (e) => !this.graphConfig.ignorePatterns.some((p) => p.test(e))
-    );
-
-    // Build module structure
-    const modules = await this.buildModuleStructure(filteredEntries);
-
-    // Analyze boundaries between modules
-    const boundaries = await this.analyzeBoundaries_(modules);
-
-    // Identify critical boundaries
-    const criticalBoundaries = boundaries
-      .filter((b) => b.riskScore > 0.6)
-      .map((b) => `${b.fromModule}->${b.toModule}`);
-
-    // Generate integration test suggestions
-    const integrationTestSuggestions = await this.generateIntegrationSuggestions(boundaries);
-
-    // Detect violations
-    const violations = await this.detectViolations();
-
-    return {
-      modules,
-      boundaries,
-      criticalBoundaries,
-      integrationTestSuggestions,
-      violations: violations.map((v) => ({
-        type: v.type as 'circular-dependency' | 'layer-violation' | 'coupling-too-high',
-        modules: [v.location],
-        severity: v.severity,
-        suggestion: v.suggestion,
-      })),
-      usedFallback: false,
-    };
-  }
-
-  /**
-   * Build module structure from entry points
-   */
-  private async buildModuleStructure(entryPoints: string[]): Promise<ModuleBoundary[]> {
-    const moduleMap = new Map<string, string[]>();
-
-    // Group files by module
-    for (const entry of entryPoints) {
-      const moduleName = this.getModuleName(entry);
-      const existing = moduleMap.get(moduleName) || [];
-      existing.push(entry);
-      moduleMap.set(moduleName, existing);
-    }
-
-    // Create module boundaries
-    const modules: ModuleBoundary[] = [];
-
-    for (const [moduleName, files] of moduleMap.entries()) {
-      const dependencies = await this.analyzeModuleDependencies(moduleName, files);
-      const couplingScore = this.calculateModuleCoupling(dependencies);
-      const cohesionScore = this.calculateModuleCohesion(files, dependencies);
-      const publicAPIs = this.identifyPublicAPIs(files);
-
-      const boundary: ModuleBoundary = {
-        module: moduleName,
-        files,
-        publicAPIs,
-        dependencies,
-        couplingScore,
-        cohesionScore,
-      };
-
-      modules.push(boundary);
-      this.moduleCache.set(moduleName, boundary);
-    }
-
-    return modules;
-  }
-
-  /**
-   * Extract module name from file path
-   */
-  private getModuleName(filePath: string): string {
-    // Try to match against module patterns
-    for (const pattern of this.graphConfig.modulePatterns) {
-      const match = filePath.match(pattern);
-      if (match) {
-        const afterPattern = filePath.slice(match[0].length);
-        const parts = afterPattern.split('/');
-        if (parts.length > 0 && parts[0]) {
-          return parts[0];
-        }
-      }
-    }
-
-    // Fallback: use first directory after src/
-    const srcMatch = filePath.match(/src\/([^/]+)/);
-    if (srcMatch) {
-      return srcMatch[1];
-    }
-
-    // Last resort: use parent directory
-    const parts = filePath.split('/');
-    return parts.length > 1 ? parts[parts.length - 2] : 'root';
-  }
-
-  /**
-   * Analyze dependencies for a module
-   */
-  private async analyzeModuleDependencies(
-    moduleName: string,
-    files: string[]
-  ): Promise<ModuleDependency[]> {
-    const dependencies: ModuleDependency[] = [];
-
-    // Analyze based on file patterns and common dependency structures
-    for (const file of files) {
-      // Simulate dependency analysis
-      const fileDeps = this.inferDependencies(file, moduleName);
-      dependencies.push(...fileDeps);
-    }
-
-    // Deduplicate and aggregate
-    const depMap = new Map<string, ModuleDependency>();
-    for (const dep of dependencies) {
-      const key = `${dep.source}:${dep.target}:${dep.type}`;
-      const existing = depMap.get(key);
-      if (existing) {
-        existing.weight = Math.max(existing.weight, dep.weight);
-      } else {
-        depMap.set(key, dep);
-      }
-    }
-
-    const result = Array.from(depMap.values());
-
-    // Store in graph for later analysis
-    this.dependencyGraph.set(moduleName, result);
-
-    return result;
-  }
-
-  /**
-   * Infer dependencies from file path
-   */
-  private inferDependencies(
-    filePath: string,
-    currentModule: string
-  ): ModuleDependency[] {
-    const deps: ModuleDependency[] = [];
-
-    // Common patterns that indicate dependencies
-    const depPatterns: Array<{ pattern: RegExp; type: ModuleDependency['type']; weight: number }> = [
-      { pattern: /service/i, type: 'import', weight: 0.8 },
-      { pattern: /handler/i, type: 'call', weight: 0.7 },
-      { pattern: /client/i, type: 'import', weight: 0.6 },
-      { pattern: /repository/i, type: 'import', weight: 0.7 },
-      { pattern: /controller/i, type: 'call', weight: 0.6 },
-      { pattern: /interface/i, type: 'reference', weight: 0.4 },
-      { pattern: /types/i, type: 'reference', weight: 0.3 },
-    ];
-
-    for (const { pattern, type, weight } of depPatterns) {
-      if (pattern.test(filePath)) {
-        // Simulate a dependency to another module
-        const targetModules = ['shared', 'core', 'common', 'utils'];
-        for (const target of targetModules) {
-          if (target !== currentModule && Math.random() > 0.5) {
-            deps.push({
-              source: currentModule,
-              target,
-              type,
-              weight: weight * (0.5 + Math.random() * 0.5),
-            });
-          }
-        }
-      }
-    }
-
-    return deps;
-  }
-
-  /**
-   * Calculate module coupling score
-   */
-  private calculateModuleCoupling(dependencies: ModuleDependency[]): number {
-    if (dependencies.length === 0) return 0;
-
-    // Get external dependencies
-    const externalDeps = dependencies.filter((d) => d.source !== d.target);
-
-    if (externalDeps.length === 0) return 0;
-
-    // Average weight of external dependencies
-    const avgWeight = externalDeps.reduce((sum, d) => sum + d.weight, 0) / externalDeps.length;
-
-    // Factor in number of dependencies
-    const countFactor = Math.min(1, externalDeps.length / 10);
-
-    return Math.min(1, avgWeight * 0.6 + countFactor * 0.4);
-  }
-
-  /**
-   * Calculate module cohesion score
-   */
-  private calculateModuleCohesion(
-    files: string[],
-    dependencies: ModuleDependency[]
-  ): number {
-    if (files.length === 0) return 1;
-
-    // Internal dependencies
-    const internalDeps = dependencies.filter((d) => d.source === d.target);
-
-    // High internal connectivity = high cohesion
-    const internalRatio =
-      internalDeps.length > 0
-        ? internalDeps.length / dependencies.length
-        : 0.5;
-
-    // Files in same directory = higher cohesion
-    const directories = new Set(files.map((f) => f.split('/').slice(0, -1).join('/')));
-    const directoryRatio = 1 / Math.max(1, directories.size);
-
-    return Math.min(1, internalRatio * 0.5 + directoryRatio * 0.5);
-  }
-
-  /**
-   * Identify public APIs in module
-   */
-  private identifyPublicAPIs(files: string[]): string[] {
-    const publicAPIs: string[] = [];
-
-    for (const file of files) {
-      // Index files typically export public APIs
-      if (file.endsWith('/index.ts') || file.endsWith('/index.js')) {
-        publicAPIs.push(file);
-      }
-
-      // Files with "api", "public", "export" in name
-      if (/api|public|export/i.test(file)) {
-        publicAPIs.push(file);
-      }
-    }
-
-    return publicAPIs;
-  }
-
-  /**
-   * Analyze boundaries between modules
-   */
-  private async analyzeBoundaries_(modules: ModuleBoundary[]): Promise<BoundaryCrossing[]> {
-    const boundaries: BoundaryCrossing[] = [];
-
-    for (let i = 0; i < modules.length; i++) {
-      for (let j = i + 1; j < modules.length; j++) {
-        const crossing = await this.analyzeBoundaryCrossing(
-          modules[i].module,
-          modules[j].module
-        );
-        boundaries.push(crossing);
-      }
-    }
-
-    return boundaries;
-  }
-
-  /**
-   * Analyze crossing between two modules
-   */
-  private async analyzeBoundaryCrossing(
-    fromModule: string,
-    toModule: string
-  ): Promise<BoundaryCrossing> {
-    const fromDeps = this.dependencyGraph.get(fromModule) || [];
-    const toDeps = this.dependencyGraph.get(toModule) || [];
-
-    // Find crossings from -> to
-    const forwardCrossings = fromDeps
-      .filter((d) => d.target === toModule)
-      .map((d) => ({
-        sourceFile: `${fromModule}/${d.source}`,
-        targetFile: `${toModule}/${d.target}`,
-        type: d.type,
-        line: 1,
-      }));
-
-    // Find crossings to -> from
-    const backwardCrossings = toDeps
-      .filter((d) => d.target === fromModule)
-      .map((d) => ({
-        sourceFile: `${toModule}/${d.source}`,
-        targetFile: `${fromModule}/${d.target}`,
-        type: d.type,
-        line: 1,
-      }));
-
-    const allCrossings = [...forwardCrossings, ...backwardCrossings];
-
-    // Calculate risk score
-    const riskScore = this.calculateCrossingRisk(allCrossings, fromDeps, toDeps);
-
-    return {
-      fromModule,
-      toModule,
-      crossings: allCrossings,
-      riskScore,
-      requiresIntegrationTest: riskScore > 0.4 || allCrossings.length > 2,
-    };
-  }
-
-  /**
-   * Calculate risk score for boundary crossing
-   */
-  private calculateCrossingRisk(
-    crossings: Array<{ type: string }>,
-    fromDeps: ModuleDependency[],
-    toDeps: ModuleDependency[]
-  ): number {
-    if (crossings.length === 0) return 0.1;
-
-    // More crossings = higher risk
-    const countFactor = Math.min(1, crossings.length / 10);
-
-    // Import types are higher risk than references
-    const typeWeights: Record<string, number> = {
-      import: 0.8,
-      call: 0.7,
-      export: 0.6,
-      reference: 0.4,
-    };
-
-    const avgTypeWeight =
-      crossings.reduce(
-        (sum, c) => sum + (typeWeights[c.type] || 0.5),
-        0
-      ) / crossings.length;
-
-    // Bidirectional dependencies are higher risk
-    const isBidirectional =
-      fromDeps.some((d) => toDeps.some((td) => td.source === d.target)) ? 0.2 : 0;
-
-    return Math.min(1, countFactor * 0.4 + avgTypeWeight * 0.4 + isBidirectional);
-  }
-
-  /**
-   * Generate integration test suggestions
-   */
-  private async generateIntegrationSuggestions(
-    boundaries: BoundaryCrossing[]
-  ): Promise<Array<{
-    fromModule: string;
-    toModule: string;
-    reason: string;
-    priority: Priority;
-  }>> {
-    return boundaries
-      .filter((b) => b.requiresIntegrationTest)
-      .map((b) => ({
-        fromModule: b.fromModule,
-        toModule: b.toModule,
-        reason: `${b.crossings.length} boundary crossing(s), risk score: ${b.riskScore.toFixed(2)}`,
-        priority: this.riskToPriority(b.riskScore),
-      }))
-      .sort((a, b) => {
-        const priorityOrder: Record<Priority, number> = { p0: 0, p1: 1, p2: 2, p3: 3 };
-        return priorityOrder[a.priority] - priorityOrder[b.priority];
-      });
-  }
-
-  /**
-   * Detect circular dependencies
-   */
-  private async detectCircularDependencies(): Promise<string[][]> {
-    const cycles: string[][] = [];
-    const visited = new Set<string>();
-    const recursionStack = new Set<string>();
-
-    const dfs = (module: string, path: string[]): void => {
-      visited.add(module);
-      recursionStack.add(module);
-
-      const deps = this.dependencyGraph.get(module) || [];
-      for (const dep of deps) {
-        if (!visited.has(dep.target)) {
-          dfs(dep.target, [...path, dep.target]);
-        } else if (recursionStack.has(dep.target)) {
-          // Found a cycle
-          const cycleStart = path.indexOf(dep.target);
-          if (cycleStart >= 0) {
-            cycles.push([...path.slice(cycleStart), dep.target]);
-          }
-        }
-      }
-
-      recursionStack.delete(module);
-    };
-
-    for (const module of this.dependencyGraph.keys()) {
-      if (!visited.has(module)) {
-        dfs(module, [module]);
-      }
-    }
-
-    return cycles;
-  }
-
-  /**
-   * Detect layer violations
-   */
-  private async detectLayerViolations(): Promise<Array<{ from: string; to: string }>> {
-    const violations: Array<{ from: string; to: string }> = [];
-
-    // Define layer hierarchy (lower can depend on higher, not vice versa)
-    const layerOrder: Record<string, number> = {
-      presentation: 1,
-      controller: 2,
-      service: 3,
-      domain: 4,
-      repository: 5,
-      infrastructure: 6,
-    };
-
-    for (const [source, deps] of this.dependencyGraph.entries()) {
-      const sourceLayer = this.getLayer(source);
-      const sourceOrder = layerOrder[sourceLayer] || 3;
-
-      for (const dep of deps) {
-        const targetLayer = this.getLayer(dep.target);
-        const targetOrder = layerOrder[targetLayer] || 3;
-
-        // Higher layer depending on lower layer is a violation
-        if (sourceOrder > targetOrder) {
-          violations.push({ from: source, to: dep.target });
-        }
-      }
-    }
-
-    return violations;
-  }
-
-  /**
-   * Get layer name from module name
-   */
-  private getLayer(moduleName: string): string {
-    if (/presentation|view|ui|component/i.test(moduleName)) return 'presentation';
-    if (/controller|handler|api/i.test(moduleName)) return 'controller';
-    if (/service/i.test(moduleName)) return 'service';
-    if (/domain|entity|model/i.test(moduleName)) return 'domain';
-    if (/repository|store|data/i.test(moduleName)) return 'repository';
-    if (/infrastructure|external|adapter/i.test(moduleName)) return 'infrastructure';
-    return 'service'; // Default
-  }
-
-  /**
-   * Find transitive path between modules
-   */
-  private async findTransitivePath(source: string, target: string): Promise<string[]> {
-    const visited = new Set<string>();
-    const queue: Array<{ module: string; path: string[] }> = [
-      { module: source, path: [source] },
-    ];
-
-    while (queue.length > 0) {
-      const current = queue.shift()!;
-
-      if (current.module === target) {
-        return current.path;
-      }
-
-      if (visited.has(current.module)) continue;
-      visited.add(current.module);
-
-      if (current.path.length >= this.graphConfig.maxDepth) continue;
-
-      const deps = this.dependencyGraph.get(current.module) || [];
-      for (const dep of deps) {
-        if (!visited.has(dep.target)) {
-          queue.push({
-            module: dep.target,
-            path: [...current.path, dep.target],
-          });
-        }
-      }
-    }
-
-    return [source, target]; // Direct path if no transitive found
-  }
-
-  /**
-   * Calculate path importance
-   */
-  private calculatePathImportance(path: string[], deps: ModuleDependency[]): number {
-    // Longer paths through high-weight edges are more important
-    let importance = 0;
-
-    for (let i = 0; i < path.length - 1; i++) {
-      const edgeDep = deps.find((d) => d.target === path[i + 1]);
-      importance += edgeDep?.weight || 0.5;
-    }
-
-    return importance / (path.length - 1);
-  }
-
-  /**
-   * Convert risk score to priority
-   */
-  private riskToPriority(risk: number): Priority {
-    if (risk >= 0.8) return 'p0';
-    if (risk >= 0.6) return 'p1';
-    if (risk >= 0.4) return 'p2';
-    return 'p3';
-  }
-
-  /**
-   * Compute cache key
-   */
-  private computeCacheKey(entryPoints: string[]): string {
-    return entryPoints.sort().join('|');
-  }
-}
-
-// ============================================================================
-// Factory Function
-// ============================================================================
-
-/**
- * Create graph boundaries analyzer with optional RuVector integration
- */
-export function createGraphBoundariesAnalyzer(
-  config: RuVectorConfig,
-  graphConfig?: Partial<GraphConfig>
-): GraphBoundariesAnalyzer {
-  if (config.enabled) {
-    return new RuVectorGraphBoundariesAnalyzer(config, graphConfig);
-  }
-  return new FallbackGraphBoundariesAnalyzer();
-}