neuronlayer 0.1.9 → 0.2.0

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

@@ -1,251 +0,0 @@
-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

@@ -1,289 +0,0 @@
-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

@@ -1,5 +0,0 @@
-// 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';