neuronlayer 0.1.0

package/src/server/gateways/memory-review.ts

@@ -0,0 +1,410 @@
+/**
+ * Memory Review Gateway
+ *
+ * Routes to: validate_pattern, check_conflicts, suggest_existing, check_tests,
+ * get_confidence, find_similar_bugs, suggest_test_update, get_related_tests,
+ * get_test_coverage
+ */
+
+import type { MemoryLayerEngine } from '../../core/engine.js';
+import type { MemoryReviewInput, MemoryReviewResponse } from './types.js';
+import { detectReviewAction, getReviewChecks, isErrorMessage } from './router.js';
+import {
+  aggregateReviewResults,
+  calculateRiskScore,
+  getVerdict,
+  type PatternValidationResult,
+  type ConflictCheckResult,
+  type ConfidenceCheckResult,
+  type TestCheckResult,
+  type ExistingFunctionResult,
+} from './aggregator.js';
+
+/**
+ * Handle a memory_review gateway call
+ */
+export async function handleMemoryReview(
+  engine: MemoryLayerEngine,
+  input: MemoryReviewInput
+): Promise<MemoryReviewResponse> {
+  const action = detectReviewAction(input);
+  const sourcesUsed: string[] = [];
+
+  // Handle specific actions
+  if (action !== 'full') {
+    switch (action) {
+      case 'pattern':
+        return handlePatternOnly(engine, input, sourcesUsed);
+
+      case 'conflicts':
+        return handleConflictsOnly(engine, input, sourcesUsed);
+
+      case 'tests':
+        return handleTestsOnly(engine, input, sourcesUsed);
+
+      case 'confidence':
+        return handleConfidenceOnly(engine, input, sourcesUsed);
+
+      case 'bugs':
+        return handleBugsOnly(engine, input, sourcesUsed);
+
+      case 'coverage':
+        return handleCoverageOnly(engine, input, sourcesUsed);
+    }
+  }
+
+  // Full review - run applicable checks in parallel
+  return handleFullReview(engine, input, sourcesUsed);
+}
+
+/**
+ * Full comprehensive review
+ * Enhanced with Ghost Mode conflict detection
+ */
+async function handleFullReview(
+  engine: MemoryLayerEngine,
+  input: MemoryReviewInput,
+  sourcesUsed: string[]
+): Promise<MemoryReviewResponse> {
+  const checks = getReviewChecks(input);
+
+  // Notify ghost mode of file access for silent tracking
+  if (input.file) {
+    engine.notifyFileAccess(input.file).catch(() => {});
+  }
+
+  // Build parallel operations
+  const operations: Promise<unknown>[] = [];
+  const operationKeys: string[] = [];
+
+  if (checks.runPatterns) {
+    sourcesUsed.push('validate_pattern');
+    operations.push(Promise.resolve(engine.validatePattern(input.code)));
+    operationKeys.push('pattern');
+  }
+
+  if (checks.runConflicts) {
+    sourcesUsed.push('check_conflicts');
+    operations.push(engine.checkCodeConflicts(input.code));
+    operationKeys.push('conflicts');
+  }
+
+  // Always run ghost mode conflict check for proactive intelligence
+  sourcesUsed.push('ghost_conflicts');
+  operations.push(Promise.resolve(engine.checkGhostConflicts(input.code, input.file)));
+  operationKeys.push('ghost');
+
+  if (checks.runConfidence) {
+    sourcesUsed.push('get_confidence');
+    operations.push(engine.getConfidence(input.code, input.intent));
+    operationKeys.push('confidence');
+  }
+
+  if (checks.runExisting && input.intent) {
+    sourcesUsed.push('suggest_existing');
+    operations.push(Promise.resolve(engine.suggestExisting(input.intent, 5)));
+    operationKeys.push('existing');
+  }
+
+  if (checks.runTests && input.file) {
+    sourcesUsed.push('check_tests');
+    operations.push(Promise.resolve(engine.checkTests(input.code, input.file)));
+    operationKeys.push('tests');
+  }
+
+  if (checks.runBugs && input.error) {
+    sourcesUsed.push('find_similar_bugs');
+    operations.push(Promise.resolve(engine.findSimilarBugs(input.error, 5)));
+    operationKeys.push('bugs');
+  }
+
+  // Run all checks in parallel
+  const results = await Promise.all(operations);
+
+  // Map results to their keys
+  const resultMap: Record<string, unknown> = {};
+  operationKeys.forEach((key, index) => {
+    resultMap[key] = results[index];
+  });
+
+  // Extract typed results
+  const patternResult = resultMap.pattern as PatternValidationResult | undefined;
+  const conflictsResult = resultMap.conflicts as ConflictCheckResult | undefined;
+  const confidenceResult = resultMap.confidence as ConfidenceCheckResult | undefined;
+  const existingResult = resultMap.existing as ExistingFunctionResult[] | undefined;
+  const testsResult = resultMap.tests as TestCheckResult | undefined;
+  const bugsResult = resultMap.bugs as Array<{
+    error: string;
+    similarity: number;
+    fix: string;
+    file?: string;
+  }> | undefined;
+  const ghostResult = resultMap.ghost as Array<{
+    decision: { id: string; title: string };
+    warning: string;
+    severity: 'low' | 'medium' | 'high';
+    matchedTerms: string[];
+  }> | undefined;
+
+  // Calculate risk score and aggregate
+  const response = aggregateReviewResults(
+    patternResult || null,
+    conflictsResult ? {
+      hasConflicts: conflictsResult.hasConflicts,
+      conflicts: conflictsResult.conflicts,
+    } : null,
+    confidenceResult || null,
+    existingResult || null,
+    testsResult || null,
+    sourcesUsed
+  );
+
+  // Add ghost mode conflict warnings (proactive intelligence)
+  if (ghostResult && ghostResult.length > 0) {
+    // Merge ghost conflicts into the conflicts response
+    const ghostConflicts = ghostResult.map(g => ({
+      decision_id: g.decision.id,
+      decision_title: g.decision.title,
+      conflict_description: g.warning,
+      severity: g.severity,
+    }));
+
+    if (response.conflicts) {
+      // Add ghost conflicts that aren't already in the regular conflicts
+      const existingIds = new Set(response.conflicts.conflicts.map(c => c.decision_id));
+      const newConflicts = ghostConflicts.filter(c => !existingIds.has(c.decision_id));
+      response.conflicts.conflicts.push(...newConflicts);
+      response.conflicts.has_conflicts = response.conflicts.conflicts.length > 0;
+    } else if (ghostConflicts.length > 0) {
+      response.conflicts = {
+        has_conflicts: true,
+        conflicts: ghostConflicts,
+      };
+
+      // Increase risk score for ghost conflicts
+      const highSeverity = ghostConflicts.filter(c => c.severity === 'high').length;
+      const mediumSeverity = ghostConflicts.filter(c => c.severity === 'medium').length;
+      response.risk_score = Math.min(100, response.risk_score + highSeverity * 20 + mediumSeverity * 10);
+
+      // Update verdict if needed
+      if (response.risk_score >= 70) {
+        response.verdict = 'reject';
+      } else if (response.risk_score >= 30) {
+        response.verdict = 'warning';
+      }
+    }
+  }
+
+  // Add similar bugs if found
+  if (bugsResult && bugsResult.length > 0) {
+    response.similar_bugs = bugsResult.map(b => ({
+      error: b.error.slice(0, 100),
+      similarity: b.similarity,
+      fix: b.fix,
+      file: b.file,
+    }));
+  }
+
+  return response;
+}
+
+/**
+ * Pattern validation only
+ */
+async function handlePatternOnly(
+  engine: MemoryLayerEngine,
+  input: MemoryReviewInput,
+  sourcesUsed: string[]
+): Promise<MemoryReviewResponse> {
+  sourcesUsed.push('validate_pattern');
+
+  const result = engine.validatePattern(input.code);
+
+  const riskScore = calculateRiskScore(result, null, null, null);
+
+  return {
+    verdict: getVerdict(riskScore),
+    risk_score: riskScore,
+    sources_used: sourcesUsed,
+    patterns: {
+      valid: result.valid,
+      score: result.score,
+      matched_pattern: result.matchedPattern,
+      violations: result.violations,
+    },
+  };
+}
+
+/**
+ * Conflict check only
+ */
+async function handleConflictsOnly(
+  engine: MemoryLayerEngine,
+  input: MemoryReviewInput,
+  sourcesUsed: string[]
+): Promise<MemoryReviewResponse> {
+  sourcesUsed.push('check_conflicts');
+
+  const result = await engine.checkCodeConflicts(input.code);
+
+  const riskScore = calculateRiskScore(null, {
+    hasConflicts: result.hasConflicts,
+    conflicts: result.conflicts,
+  }, null, null);
+
+  return {
+    verdict: getVerdict(riskScore),
+    risk_score: riskScore,
+    sources_used: sourcesUsed,
+    conflicts: {
+      has_conflicts: result.hasConflicts,
+      conflicts: result.conflicts.map(c => ({
+        decision_id: c.decisionId,
+        decision_title: c.decisionTitle,
+        conflict_description: c.conflictDescription,
+        severity: c.severity,
+      })),
+    },
+  };
+}
+
+/**
+ * Test check only
+ */
+async function handleTestsOnly(
+  engine: MemoryLayerEngine,
+  input: MemoryReviewInput,
+  sourcesUsed: string[]
+): Promise<MemoryReviewResponse> {
+  if (!input.file) {
+    return {
+      verdict: 'warning',
+      risk_score: 50,
+      sources_used: sourcesUsed,
+    };
+  }
+
+  sourcesUsed.push('check_tests');
+
+  const result = engine.checkTests(input.code, input.file);
+
+  const riskScore = calculateRiskScore(null, null, result, null);
+
+  return {
+    verdict: getVerdict(riskScore),
+    risk_score: riskScore,
+    sources_used: sourcesUsed,
+    test_impact: {
+      safe: result.safe,
+      coverage_percent: result.coveragePercent,
+      would_fail: result.wouldFail.map(f => ({
+        test_name: f.test.name,
+        test_file: f.test.file,
+        reason: f.reason,
+        suggested_fix: f.suggestedFix,
+      })),
+      suggested_updates: result.suggestedTestUpdates.map(u => ({
+        file: u.file,
+        test_name: u.testName,
+        before: u.before,
+        after: u.after,
+        reason: u.reason,
+      })),
+    },
+  };
+}
+
+/**
+ * Confidence check only
+ */
+async function handleConfidenceOnly(
+  engine: MemoryLayerEngine,
+  input: MemoryReviewInput,
+  sourcesUsed: string[]
+): Promise<MemoryReviewResponse> {
+  sourcesUsed.push('get_confidence');
+
+  const result = await engine.getConfidence(input.code, input.intent);
+
+  const riskScore = calculateRiskScore(null, null, null, result);
+
+  return {
+    verdict: getVerdict(riskScore),
+    risk_score: riskScore,
+    sources_used: sourcesUsed,
+    confidence: {
+      level: result.confidence,
+      score: result.score,
+      reasoning: result.reasoning,
+    },
+  };
+}
+
+/**
+ * Bug search only
+ */
+async function handleBugsOnly(
+  engine: MemoryLayerEngine,
+  input: MemoryReviewInput,
+  sourcesUsed: string[]
+): Promise<MemoryReviewResponse> {
+  if (!input.error) {
+    return {
+      verdict: 'approve',
+      risk_score: 0,
+      sources_used: sourcesUsed,
+    };
+  }
+
+  sourcesUsed.push('find_similar_bugs');
+
+  const bugs = engine.findSimilarBugs(input.error, 5);
+
+  return {
+    verdict: bugs.length > 0 ? 'warning' : 'approve',
+    risk_score: bugs.length > 0 ? 30 : 0,
+    sources_used: sourcesUsed,
+    similar_bugs: bugs.map(b => ({
+      error: b.error.slice(0, 100),
+      similarity: b.similarity,
+      fix: b.fix,
+      file: b.file,
+    })),
+  };
+}
+
+/**
+ * Coverage check only
+ */
+async function handleCoverageOnly(
+  engine: MemoryLayerEngine,
+  input: MemoryReviewInput,
+  sourcesUsed: string[]
+): Promise<MemoryReviewResponse> {
+  if (!input.file) {
+    return {
+      verdict: 'warning',
+      risk_score: 50,
+      sources_used: sourcesUsed,
+    };
+  }
+
+  sourcesUsed.push('get_test_coverage');
+
+  const coverage = engine.getTestCoverage(input.file);
+
+  // Risk based on coverage percentage
+  const riskScore = Math.max(0, 100 - coverage.coveragePercent);
+
+  return {
+    verdict: getVerdict(riskScore),
+    risk_score: riskScore,
+    sources_used: sourcesUsed,
+    coverage: {
+      file: coverage.file,
+      total_tests: coverage.totalTests,
+      coverage_percent: coverage.coveragePercent,
+      uncovered_functions: coverage.uncoveredFunctions,
+    },
+  };
+}