neuronlayer 0.1.0

package/src/core/confidence/confidence-scorer.ts

@@ -0,0 +1,251 @@
+import type { Tier2Storage } from '../../storage/tier2.js';
+import type { EmbeddingGenerator } from '../../indexing/embeddings.js';
+import type {
+  ConfidenceResult,
+  ConfidenceLevel,
+  ConfidenceSources,
+  ConfidenceWarning,
+  CodebaseMatch,
+  DecisionMatch,
+  PatternMatch
+} from '../../types/documentation.js';
+import { SourceTracker } from './source-tracker.js';
+import { WarningDetector } from './warning-detector.js';
+import { ConflictChecker } from './conflict-checker.js';
+
+// Weights for confidence calculation
+const WEIGHTS = {
+  codebase: 0.5,    // 50% weight from codebase matches
+  decision: 0.3,    // 30% weight from decision alignment
+  pattern: 0.2      // 20% weight from pattern matching
+};
+
+// Thresholds for confidence levels
+const THRESHOLDS = {
+  high: 80,
+  medium: 50,
+  low: 20
+};
+
+export class ConfidenceScorer {
+  private sourceTracker: SourceTracker;
+  private warningDetector: WarningDetector;
+  private conflictChecker: ConflictChecker;
+
+  constructor(
+    tier2: Tier2Storage,
+    embeddingGenerator: EmbeddingGenerator
+  ) {
+    this.sourceTracker = new SourceTracker(tier2, embeddingGenerator);
+    this.warningDetector = new WarningDetector(tier2);
+    this.conflictChecker = new ConflictChecker(tier2, embeddingGenerator);
+  }
+
+  async getConfidence(code: string, context?: string): Promise<ConfidenceResult> {
+    // 1. Track sources
+    const sources = await this.sourceTracker.trackSources(code, context);
+
+    // 2. Calculate scores for each component
+    const codeScore = this.calculateCodeScore(sources.codebase);
+    const decisionScore = this.calculateDecisionScore(sources.decisions);
+    const patternScore = this.calculatePatternScore(sources.patterns);
+
+    // 3. Calculate composite score
+    const compositeScore = this.calculateCompositeScore(codeScore, decisionScore, patternScore);
+
+    // 4. Determine confidence level
+    const confidence = this.determineLevel(compositeScore);
+
+    // 5. Detect warnings
+    const warnings = await this.warningDetector.detectWarnings(code, sources);
+
+    // 6. Check for decision conflicts
+    const conflicts = await this.conflictChecker.checkConflicts(code);
+    if (conflicts.hasConflicts) {
+      for (const conflict of conflicts.conflicts) {
+        warnings.push({
+          type: 'conflicts_with_decision',
+          message: `Conflicts with decision: "${conflict.decisionTitle}"`,
+          severity: conflict.severity === 'high' ? 'critical' : 'warning',
+          suggestion: conflict.conflictDescription,
+          relatedDecision: conflict.decisionId
+        });
+      }
+    }
+
+    // 7. Generate reasoning
+    const reasoning = this.generateReasoning(confidence, sources, warnings);
+
+    return {
+      confidence,
+      score: Math.round(compositeScore),
+      reasoning,
+      sources,
+      warnings
+    };
+  }
+
+  private calculateCodeScore(matches: CodebaseMatch[]): number {
+    if (matches.length === 0) return 0;
+
+    // Weight by similarity and usage count
+    let totalWeight = 0;
+    let weightedSum = 0;
+
+    for (const match of matches) {
+      const weight = 1 + Math.log10(1 + (match.usageCount || 1));
+      weightedSum += match.similarity * weight;
+      totalWeight += weight;
+    }
+
+    return totalWeight > 0 ? weightedSum / totalWeight : 0;
+  }
+
+  private calculateDecisionScore(matches: DecisionMatch[]): number {
+    if (matches.length === 0) return 50; // Neutral if no decisions
+
+    // Average relevance of matched decisions
+    const totalRelevance = matches.reduce((sum, m) => sum + m.relevance, 0);
+    return totalRelevance / matches.length;
+  }
+
+  private calculatePatternScore(matches: PatternMatch[]): number {
+    if (matches.length === 0) return 30; // Low baseline if no patterns
+
+    // Average confidence of matched patterns
+    const totalConfidence = matches.reduce((sum, m) => sum + m.confidence, 0);
+    return totalConfidence / matches.length;
+  }
+
+  private calculateCompositeScore(codeScore: number, decisionScore: number, patternScore: number): number {
+    return (
+      codeScore * WEIGHTS.codebase +
+      decisionScore * WEIGHTS.decision +
+      patternScore * WEIGHTS.pattern
+    );
+  }
+
+  private determineLevel(score: number): ConfidenceLevel {
+    if (score >= THRESHOLDS.high) return 'high';
+    if (score >= THRESHOLDS.medium) return 'medium';
+    if (score >= THRESHOLDS.low) return 'low';
+    return 'guessing';
+  }
+
+  private generateReasoning(
+    level: ConfidenceLevel,
+    sources: ConfidenceSources,
+    warnings: ConfidenceWarning[]
+  ): string {
+    const parts: string[] = [];
+
+    // Confidence level explanation
+    switch (level) {
+      case 'high':
+        parts.push('High confidence');
+        break;
+      case 'medium':
+        parts.push('Medium confidence');
+        break;
+      case 'low':
+        parts.push('Low confidence');
+        break;
+      case 'guessing':
+        parts.push('Best guess');
+        break;
+    }
+
+    // Source attribution
+    if (sources.codebase.length > 0) {
+      const topMatch = sources.codebase[0];
+      parts.push(`found similar code in ${topMatch.file}${topMatch.function ? `:${topMatch.function}` : ''} (${topMatch.similarity}% match)`);
+    }
+
+    if (sources.decisions.length > 0) {
+      parts.push(`aligns with ${sources.decisions.length} recorded decision(s)`);
+    }
+
+    if (sources.patterns.length > 0) {
+      parts.push(`matches ${sources.patterns.length} established pattern(s)`);
+    }
+
+    if (sources.usedGeneralKnowledge) {
+      parts.push('based partly on general knowledge');
+    }
+
+    // Warnings
+    const criticalWarnings = warnings.filter(w => w.severity === 'critical');
+    if (criticalWarnings.length > 0) {
+      parts.push(`${criticalWarnings.length} critical warning(s)`);
+    }
+
+    return parts.join(', ');
+  }
+
+  async listSources(code: string, context?: string, includeSnippets: boolean = false): Promise<ConfidenceSources> {
+    const sources = await this.sourceTracker.trackSources(code, context);
+
+    if (!includeSnippets) {
+      // Remove snippets for cleaner output
+      for (const match of sources.codebase) {
+        delete match.snippet;
+      }
+    }
+
+    return sources;
+  }
+
+  async checkConflicts(code: string) {
+    return this.conflictChecker.checkConflicts(code);
+  }
+
+  // Get confidence level indicator emoji
+  static getIndicator(level: ConfidenceLevel): string {
+    switch (level) {
+      case 'high': return '\u{1F7E2}'; // Green circle
+      case 'medium': return '\u{1F7E1}'; // Yellow circle
+      case 'low': return '\u{1F7E0}'; // Orange circle
+      case 'guessing': return '\u{1F534}'; // Red circle
+    }
+  }
+
+  // Format confidence result for display
+  static formatResult(result: ConfidenceResult): string {
+    const indicator = ConfidenceScorer.getIndicator(result.confidence);
+    const lines: string[] = [];
+
+    lines.push(`${indicator} ${result.confidence.toUpperCase()} Confidence (${result.score}%)`);
+    lines.push(result.reasoning);
+
+    if (result.sources.codebase.length > 0) {
+      lines.push('');
+      lines.push('Codebase Sources:');
+      for (const match of result.sources.codebase.slice(0, 3)) {
+        lines.push(`  - ${match.file}${match.line ? `:${match.line}` : ''} (${match.similarity}% similar)`);
+      }
+    }
+
+    if (result.sources.decisions.length > 0) {
+      lines.push('');
+      lines.push('Related Decisions:');
+      for (const decision of result.sources.decisions.slice(0, 3)) {
+        lines.push(`  - "${decision.title}" (${decision.relevance}% relevant)`);
+      }
+    }
+
+    if (result.warnings.length > 0) {
+      lines.push('');
+      lines.push('Warnings:');
+      for (const warning of result.warnings) {
+        const icon = warning.severity === 'critical' ? '\u{1F534}' :
+                     warning.severity === 'warning' ? '\u{1F7E1}' : '\u{2139}\u{FE0F}';
+        lines.push(`  ${icon} ${warning.message}`);
+        if (warning.suggestion) {
+          lines.push(`     \u{2192} ${warning.suggestion}`);
+        }
+      }
+    }
+
+    return lines.join('\n');
+  }
+}

package/src/core/confidence/conflict-checker.ts

@@ -0,0 +1,289 @@
+import type { Tier2Storage } from '../../storage/tier2.js';
+import type { EmbeddingGenerator } from '../../indexing/embeddings.js';
+import type { ConflictResult } from '../../types/documentation.js';
+
+// Common conflict patterns - decisions that might conflict with code patterns
+const CONFLICT_PATTERNS = [
+  // Authentication patterns
+  {
+    decisionKeywords: ['jwt', 'json web token'],
+    conflictingCode: /session\s*=|cookie.*auth|express-session/i,
+    conflict: 'Code uses session-based auth, but decision specifies JWT'
+  },
+  {
+    decisionKeywords: ['session', 'cookie auth'],
+    conflictingCode: /jwt\.sign|jsonwebtoken/i,
+    conflict: 'Code uses JWT, but decision specifies session-based auth'
+  },
+
+  // Database patterns
+  {
+    decisionKeywords: ['parameterized queries', 'prepared statements', 'no string concatenation'],
+    conflictingCode: /\$\{.*\}.*(?:SELECT|INSERT|UPDATE|DELETE)|`.*\+.*\+.*(?:SELECT|INSERT)/i,
+    conflict: 'Code uses string concatenation for SQL, but decision requires parameterized queries'
+  },
+  {
+    decisionKeywords: ['orm', 'prisma', 'sequelize', 'typeorm'],
+    conflictingCode: /db\.query\s*\(|execute\s*\(\s*['"`]SELECT/i,
+    conflict: 'Code uses raw SQL, but decision specifies ORM usage'
+  },
+
+  // Error handling patterns
+  {
+    decisionKeywords: ['custom error classes', 'error types'],
+    conflictingCode: /throw\s+new\s+Error\s*\(/i,
+    conflict: 'Code throws generic Error, but decision specifies custom error classes'
+  },
+  {
+    decisionKeywords: ['always log errors', 'error logging'],
+    conflictingCode: /catch\s*\([^)]*\)\s*\{\s*\}/i,
+    conflict: 'Code has empty catch block, but decision requires error logging'
+  },
+
+  // API patterns
+  {
+    decisionKeywords: ['rest api', 'restful'],
+    conflictingCode: /graphql|gql`|ApolloServer/i,
+    conflict: 'Code uses GraphQL, but decision specifies REST API'
+  },
+  {
+    decisionKeywords: ['graphql'],
+    conflictingCode: /app\.(get|post|put|delete|patch)\s*\(/i,
+    conflict: 'Code uses REST endpoints, but decision specifies GraphQL'
+  },
+
+  // Testing patterns
+  {
+    decisionKeywords: ['jest', 'use jest'],
+    conflictingCode: /import.*mocha|describe.*chai|from\s+['"]vitest/i,
+    conflict: 'Code uses different testing framework, but decision specifies Jest'
+  },
+  {
+    decisionKeywords: ['vitest'],
+    conflictingCode: /import.*jest|from\s+['"]@jest/i,
+    conflict: 'Code uses Jest, but decision specifies Vitest'
+  },
+
+  // State management patterns
+  {
+    decisionKeywords: ['redux', 'use redux'],
+    conflictingCode: /useContext|createContext|zustand|mobx/i,
+    conflict: 'Code uses different state management, but decision specifies Redux'
+  },
+
+  // Styling patterns
+  {
+    decisionKeywords: ['tailwind', 'tailwindcss'],
+    conflictingCode: /styled-components|emotion|\.module\.css/i,
+    conflict: 'Code uses different styling approach, but decision specifies Tailwind'
+  },
+
+  // Async patterns
+  {
+    decisionKeywords: ['async/await', 'always use async'],
+    conflictingCode: /\.then\s*\([^)]*=>/i,
+    conflict: 'Code uses promise chains, but decision specifies async/await'
+  }
+];
+
+export class ConflictChecker {
+  private tier2: Tier2Storage;
+  private embeddingGenerator: EmbeddingGenerator;
+
+  constructor(tier2: Tier2Storage, embeddingGenerator: EmbeddingGenerator) {
+    this.tier2 = tier2;
+    this.embeddingGenerator = embeddingGenerator;
+  }
+
+  async checkConflicts(code: string): Promise<ConflictResult> {
+    const conflicts: ConflictResult['conflicts'] = [];
+
+    // Get all decisions
+    const decisions = this.tier2.getAllDecisions();
+
+    if (decisions.length === 0) {
+      return { hasConflicts: false, conflicts: [] };
+    }
+
+    // Check each decision for conflicts
+    for (const decision of decisions) {
+      const conflict = this.checkDecisionConflict(code, decision);
+      if (conflict) {
+        conflicts.push(conflict);
+      }
+    }
+
+    // Also check using semantic similarity for decisions that might conflict
+    const semanticConflicts = await this.checkSemanticConflicts(code, decisions);
+    for (const conflict of semanticConflicts) {
+      // Avoid duplicates
+      if (!conflicts.some(c => c.decisionId === conflict.decisionId)) {
+        conflicts.push(conflict);
+      }
+    }
+
+    // Sort by severity
+    conflicts.sort((a, b) => {
+      const severityOrder = { high: 0, medium: 1, low: 2 };
+      return severityOrder[a.severity] - severityOrder[b.severity];
+    });
+
+    return {
+      hasConflicts: conflicts.length > 0,
+      conflicts
+    };
+  }
+
+  private checkDecisionConflict(
+    code: string,
+    decision: { id: string; title: string; description: string; createdAt: Date }
+  ): ConflictResult['conflicts'][0] | null {
+    const decisionText = `${decision.title} ${decision.description}`.toLowerCase();
+
+    for (const pattern of CONFLICT_PATTERNS) {
+      // Check if this decision matches the pattern keywords
+      const matchesKeywords = pattern.decisionKeywords.some(keyword =>
+        decisionText.includes(keyword.toLowerCase())
+      );
+
+      if (matchesKeywords && pattern.conflictingCode.test(code)) {
+        return {
+          decisionId: decision.id,
+          decisionTitle: decision.title,
+          decisionDate: decision.createdAt,
+          conflictDescription: pattern.conflict,
+          severity: this.determineSeverity(pattern.conflict)
+        };
+      }
+    }
+
+    return null;
+  }
+
+  private async checkSemanticConflicts(
+    code: string,
+    decisions: Array<{ id: string; title: string; description: string; createdAt: Date }>
+  ): Promise<ConflictResult['conflicts']> {
+    const conflicts: ConflictResult['conflicts'] = [];
+
+    try {
+      // Extract key concepts from the code
+      const codeApproach = this.extractApproach(code);
+      if (!codeApproach) return [];
+
+      // Generate embedding for the code approach
+      const codeEmbedding = await this.embeddingGenerator.embed(codeApproach);
+
+      // Search for related decisions
+      const relatedDecisions = this.tier2.searchDecisions(codeEmbedding, 5);
+
+      for (const related of relatedDecisions) {
+        // Check if the decision contradicts the approach
+        const contradiction = this.findContradiction(codeApproach, related.description);
+        if (contradiction) {
+          // Avoid duplicates
+          if (!conflicts.some(c => c.decisionId === related.id)) {
+            conflicts.push({
+              decisionId: related.id,
+              decisionTitle: related.title,
+              decisionDate: related.createdAt,
+              conflictDescription: contradiction,
+              severity: 'medium'
+            });
+          }
+        }
+      }
+    } catch (error) {
+      console.error('Error checking semantic conflicts:', error);
+    }
+
+    return conflicts;
+  }
+
+  private extractApproach(code: string): string | null {
+    // Extract what the code is doing
+    const patterns: Array<{ regex: RegExp; approach: string }> = [
+      { regex: /async\s+function\s+(\w+)/, approach: 'async function' },
+      { regex: /class\s+(\w+)\s+extends/, approach: 'class inheritance' },
+      { regex: /interface\s+(\w+)/, approach: 'interface definition' },
+      { regex: /import\s+.*from\s+['"](\w+)/, approach: 'using library' },
+      { regex: /\.then\s*\(/, approach: 'promise chains' },
+      { regex: /await\s+/, approach: 'async/await' },
+      { regex: /db\.(query|execute)/i, approach: 'direct database queries' },
+      { regex: /prisma\.\w+/, approach: 'Prisma ORM' },
+      { regex: /jwt\.(sign|verify)/i, approach: 'JWT authentication' },
+      { regex: /session\s*\[/i, approach: 'session-based authentication' }
+    ];
+
+    for (const { regex, approach } of patterns) {
+      if (regex.test(code)) {
+        return approach;
+      }
+    }
+
+    return null;
+  }
+
+  private findContradiction(codeApproach: string, decisionDescription: string): string | null {
+    const desc = decisionDescription.toLowerCase();
+    const approach = codeApproach.toLowerCase();
+
+    // Define contradictory pairs
+    const contradictions: Array<{ approaches: string[]; keywords: string[]; message: string }> = [
+      {
+        approaches: ['promise chains'],
+        keywords: ['async/await', 'always use async'],
+        message: 'Code uses promise chains, but decision prefers async/await'
+      },
+      {
+        approaches: ['direct database queries'],
+        keywords: ['orm', 'prisma', 'typeorm'],
+        message: 'Code uses direct queries, but decision specifies ORM'
+      },
+      {
+        approaches: ['class inheritance'],
+        keywords: ['composition', 'prefer composition'],
+        message: 'Code uses inheritance, but decision prefers composition'
+      }
+    ];
+
+    for (const { approaches, keywords, message } of contradictions) {
+      if (approaches.some(a => approach.includes(a)) &&
+          keywords.some(k => desc.includes(k))) {
+        return message;
+      }
+    }
+
+    return null;
+  }
+
+  private determineSeverity(conflictDescription: string): 'low' | 'medium' | 'high' {
+    const highSeverityKeywords = ['sql', 'security', 'authentication', 'injection', 'password'];
+    const mediumSeverityKeywords = ['orm', 'framework', 'testing', 'api'];
+
+    const lower = conflictDescription.toLowerCase();
+
+    if (highSeverityKeywords.some(k => lower.includes(k))) {
+      return 'high';
+    }
+
+    if (mediumSeverityKeywords.some(k => lower.includes(k))) {
+      return 'medium';
+    }
+
+    return 'low';
+  }
+
+  // Quick check without full analysis
+  quickConflictCheck(code: string): boolean {
+    const decisions = this.tier2.getAllDecisions();
+
+    for (const decision of decisions) {
+      if (this.checkDecisionConflict(code, decision)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+}

package/src/core/confidence/index.ts

@@ -0,0 +1,5 @@
+// Confidence Scoring Module - Phase 8
+export { ConfidenceScorer } from './confidence-scorer.js';
+export { SourceTracker } from './source-tracker.js';
+export { WarningDetector } from './warning-detector.js';
+export { ConflictChecker } from './conflict-checker.js';