neuronlayer 0.1.0

package/src/core/change-intelligence/change-tracker.ts

@@ -0,0 +1,334 @@
+import { execSync } from 'child_process';
+import { randomUUID } from 'crypto';
+import type Database from 'better-sqlite3';
+import type { Change, ChangeQueryResult, ChangeQueryOptions } from '../../types/documentation.js';
+
+export class ChangeTracker {
+  private projectPath: string;
+  private db: Database.Database;
+
+  constructor(projectPath: string, db: Database.Database) {
+    this.projectPath = projectPath;
+    this.db = db;
+    this.ensureTable();
+  }
+
+  private ensureTable(): void {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS change_history (
+        id TEXT PRIMARY KEY,
+        file TEXT NOT NULL,
+        diff TEXT,
+        timestamp INTEGER NOT NULL,
+        author TEXT,
+        commit_hash TEXT,
+        commit_message TEXT,
+        lines_added INTEGER DEFAULT 0,
+        lines_removed INTEGER DEFAULT 0,
+        change_type TEXT DEFAULT 'modify'
+      );
+      CREATE INDEX IF NOT EXISTS idx_change_timestamp ON change_history(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_change_file ON change_history(file);
+      CREATE INDEX IF NOT EXISTS idx_change_commit ON change_history(commit_hash);
+    `);
+  }
+
+  // Sync changes from git history
+  syncFromGit(limit: number = 100): number {
+    try {
+      // Get recent commits
+      const logOutput = execSync(
+        `git log --oneline -${limit} --format="%H|%an|%ad|%s" --date=unix`,
+        { cwd: this.projectPath, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 }
+      ).trim();
+
+      if (!logOutput) return 0;
+
+      const commits = logOutput.split('\n').filter(Boolean);
+      let synced = 0;
+
+      for (const commitLine of commits) {
+        const [hash, author, dateStr, ...messageParts] = commitLine.split('|');
+        const message = messageParts.join('|');
+        const timestamp = parseInt(dateStr, 10);
+
+        // Check if already synced
+        const existing = this.db.prepare(
+          'SELECT id FROM change_history WHERE commit_hash = ?'
+        ).get(hash);
+
+        if (existing) continue;
+
+        // Get files changed in this commit
+        try {
+          const filesOutput = execSync(
+            `git show --numstat --format="" ${hash}`,
+            { cwd: this.projectPath, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 }
+          ).trim();
+
+          if (!filesOutput) continue;
+
+          const files = filesOutput.split('\n').filter(Boolean);
+
+          for (const fileLine of files) {
+            const [added, removed, filePath] = fileLine.split('\t');
+            if (!filePath) continue;
+
+            // Get diff for this file (cross-platform, no pipe to head)
+            let diff = '';
+            try {
+              const fullDiff = execSync(
+                `git show ${hash} -- "${filePath}"`,
+                { cwd: this.projectPath, encoding: 'utf-8', maxBuffer: 1024 * 1024 }
+              );
+              // Limit to first 100 lines and 2000 chars
+              diff = fullDiff.split('\n').slice(0, 100).join('\n').slice(0, 2000);
+            } catch {
+              // Ignore diff errors
+            }
+
+            const linesAdded = added === '-' ? 0 : parseInt(added, 10) || 0;
+            const linesRemoved = removed === '-' ? 0 : parseInt(removed, 10) || 0;
+            const changeType = this.inferChangeType(linesAdded, linesRemoved, filePath);
+
+            this.db.prepare(`
+              INSERT INTO change_history (id, file, diff, timestamp, author, commit_hash, commit_message, lines_added, lines_removed, change_type)
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            `).run(
+              randomUUID(),
+              filePath,
+              diff,
+              timestamp,
+              author,
+              hash,
+              message,
+              linesAdded,
+              linesRemoved,
+              changeType
+            );
+
+            synced++;
+          }
+        } catch {
+          // Skip commits that fail
+        }
+      }
+
+      return synced;
+    } catch (error) {
+      console.error('Error syncing git history:', error);
+      return 0;
+    }
+  }
+
+  private inferChangeType(added: number, removed: number, _filePath: string): Change['type'] {
+    if (removed === 0 && added > 0) return 'add';
+    if (added === 0 && removed > 0) return 'delete';
+    return 'modify';
+  }
+
+  // Query changes
+  queryChanges(options: ChangeQueryOptions = {}): ChangeQueryResult {
+    const since = this.parseSince(options.since || 'this week');
+    const until = options.until || new Date();
+
+    let query = `
+      SELECT id, file, diff, timestamp, author, commit_hash, commit_message, lines_added, lines_removed, change_type
+      FROM change_history
+      WHERE timestamp >= ? AND timestamp <= ?
+    `;
+    const params: (string | number)[] = [
+      Math.floor(since.getTime() / 1000),
+      Math.floor(until.getTime() / 1000)
+    ];
+
+    if (options.file) {
+      query += ' AND file LIKE ?';
+      params.push(`%${options.file}%`);
+    }
+
+    if (options.author) {
+      query += ' AND author LIKE ?';
+      params.push(`%${options.author}%`);
+    }
+
+    if (options.type) {
+      query += ' AND change_type = ?';
+      params.push(options.type);
+    }
+
+    query += ' ORDER BY timestamp DESC';
+
+    if (options.limit) {
+      query += ` LIMIT ${options.limit}`;
+    }
+
+    const rows = this.db.prepare(query).all(...params) as Array<{
+      id: string;
+      file: string;
+      diff: string | null;
+      timestamp: number;
+      author: string;
+      commit_hash: string;
+      commit_message: string;
+      lines_added: number;
+      lines_removed: number;
+      change_type: string;
+    }>;
+
+    const changes: Change[] = rows.map(row => ({
+      id: row.id,
+      file: row.file,
+      diff: row.diff || '',
+      timestamp: new Date(row.timestamp * 1000),
+      author: row.author,
+      commitHash: row.commit_hash,
+      commitMessage: row.commit_message,
+      linesAdded: row.lines_added,
+      linesRemoved: row.lines_removed,
+      type: row.change_type as Change['type']
+    }));
+
+    // Calculate aggregates
+    const byAuthor: Record<string, number> = {};
+    const byType: Record<string, number> = {};
+    let totalLinesAdded = 0;
+    let totalLinesRemoved = 0;
+    const uniqueFiles = new Set<string>();
+
+    for (const change of changes) {
+      byAuthor[change.author] = (byAuthor[change.author] || 0) + 1;
+      byType[change.type] = (byType[change.type] || 0) + 1;
+      totalLinesAdded += change.linesAdded;
+      totalLinesRemoved += change.linesRemoved;
+      uniqueFiles.add(change.file);
+    }
+
+    return {
+      period: this.formatPeriod(since, until),
+      since,
+      until,
+      changes,
+      totalFiles: uniqueFiles.size,
+      totalLinesAdded,
+      totalLinesRemoved,
+      byAuthor,
+      byType
+    };
+  }
+
+  // Get changes for a specific file
+  getFileChanges(filePath: string, limit: number = 20): Change[] {
+    const rows = this.db.prepare(`
+      SELECT id, file, diff, timestamp, author, commit_hash, commit_message, lines_added, lines_removed, change_type
+      FROM change_history
+      WHERE file LIKE ?
+      ORDER BY timestamp DESC
+      LIMIT ?
+    `).all(`%${filePath}%`, limit) as Array<{
+      id: string;
+      file: string;
+      diff: string | null;
+      timestamp: number;
+      author: string;
+      commit_hash: string;
+      commit_message: string;
+      lines_added: number;
+      lines_removed: number;
+      change_type: string;
+    }>;
+
+    return rows.map(row => ({
+      id: row.id,
+      file: row.file,
+      diff: row.diff || '',
+      timestamp: new Date(row.timestamp * 1000),
+      author: row.author,
+      commitHash: row.commit_hash,
+      commitMessage: row.commit_message,
+      linesAdded: row.lines_added,
+      linesRemoved: row.lines_removed,
+      type: row.change_type as Change['type']
+    }));
+  }
+
+  // Get recent changes
+  getRecentChanges(hours: number = 24): Change[] {
+    const since = new Date(Date.now() - hours * 60 * 60 * 1000);
+    return this.queryChanges({ since }).changes;
+  }
+
+  private parseSince(since: string | Date): Date {
+    if (since instanceof Date) return since;
+
+    const now = new Date();
+    const lower = since.toLowerCase();
+
+    if (lower === 'today') {
+      return new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    }
+    if (lower === 'yesterday') {
+      return new Date(now.getTime() - 24 * 60 * 60 * 1000);
+    }
+    if (lower === 'this week') {
+      const dayOfWeek = now.getDay();
+      return new Date(now.getTime() - dayOfWeek * 24 * 60 * 60 * 1000);
+    }
+    if (lower === 'this month') {
+      return new Date(now.getFullYear(), now.getMonth(), 1);
+    }
+    if (lower === 'last week') {
+      return new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+    }
+
+    // Try to parse as date
+    const parsed = new Date(since);
+    return isNaN(parsed.getTime()) ? new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000) : parsed;
+  }
+
+  private formatPeriod(since: Date, until: Date): string {
+    const options: Intl.DateTimeFormatOptions = { month: 'short', day: 'numeric' };
+    const sinceStr = since.toLocaleDateString('en-US', options);
+    const untilStr = until.toLocaleDateString('en-US', options);
+
+    if (sinceStr === untilStr) {
+      return sinceStr;
+    }
+    return `${sinceStr} - ${untilStr}`;
+  }
+
+  // Search changes by keyword
+  searchChanges(keyword: string, limit: number = 20): Change[] {
+    const rows = this.db.prepare(`
+      SELECT id, file, diff, timestamp, author, commit_hash, commit_message, lines_added, lines_removed, change_type
+      FROM change_history
+      WHERE file LIKE ? OR diff LIKE ? OR commit_message LIKE ?
+      ORDER BY timestamp DESC
+      LIMIT ?
+    `).all(`%${keyword}%`, `%${keyword}%`, `%${keyword}%`, limit) as Array<{
+      id: string;
+      file: string;
+      diff: string | null;
+      timestamp: number;
+      author: string;
+      commit_hash: string;
+      commit_message: string;
+      lines_added: number;
+      lines_removed: number;
+      change_type: string;
+    }>;
+
+    return rows.map(row => ({
+      id: row.id,
+      file: row.file,
+      diff: row.diff || '',
+      timestamp: new Date(row.timestamp * 1000),
+      author: row.author,
+      commitHash: row.commit_hash,
+      commitMessage: row.commit_message,
+      linesAdded: row.lines_added,
+      linesRemoved: row.lines_removed,
+      type: row.change_type as Change['type']
+    }));
+  }
+}

package/src/core/change-intelligence/fix-suggester.ts

@@ -0,0 +1,340 @@
+import type Database from 'better-sqlite3';
+import type { FixSuggestion, PastBug, Change } from '../../types/documentation.js';
+import type { BugCorrelator } from './bug-correlator.js';
+import type { ChangeTracker } from './change-tracker.js';
+
+// Common fix patterns
+const FIX_PATTERNS = [
+  {
+    errorPattern: /cannot read (?:property |properties of )['"]?(\w+)['"]? of (?:undefined|null)/i,
+    suggestions: [
+      {
+        fix: 'Add optional chaining (?.) before accessing the property',
+        diff: '+ obj?.property instead of obj.property',
+        confidence: 85
+      },
+      {
+        fix: 'Add null/undefined check before accessing',
+        diff: '+ if (obj && obj.property) { ... }',
+        confidence: 80
+      }
+    ]
+  },
+  {
+    errorPattern: /(\w+) is not defined/i,
+    suggestions: [
+      {
+        fix: 'Add missing import statement',
+        diff: '+ import { $1 } from "module"',
+        confidence: 75
+      },
+      {
+        fix: 'Declare the variable before use',
+        diff: '+ const $1 = ...',
+        confidence: 70
+      }
+    ]
+  },
+  {
+    errorPattern: /(\w+) is not a function/i,
+    suggestions: [
+      {
+        fix: 'Check if the method exists on the object',
+        diff: '+ if (typeof obj.method === "function") { obj.method() }',
+        confidence: 70
+      },
+      {
+        fix: 'Verify the import is correct',
+        diff: 'Check that the function is exported from the source module',
+        confidence: 65
+      }
+    ]
+  },
+  {
+    errorPattern: /unexpected token/i,
+    suggestions: [
+      {
+        fix: 'Check for JSON.parse on invalid JSON',
+        diff: '+ try { JSON.parse(data) } catch { ... }',
+        confidence: 70
+      },
+      {
+        fix: 'Validate data before parsing',
+        diff: '+ if (typeof data === "string" && data.startsWith("{")) { ... }',
+        confidence: 65
+      }
+    ]
+  },
+  {
+    errorPattern: /timeout|timed out/i,
+    suggestions: [
+      {
+        fix: 'Increase timeout value',
+        diff: '+ timeout: 30000 // Increase from default',
+        confidence: 60
+      },
+      {
+        fix: 'Add retry logic',
+        diff: '+ for (let i = 0; i < 3; i++) { try { ... } catch { await delay(1000) } }',
+        confidence: 55
+      }
+    ]
+  },
+  {
+    errorPattern: /ECONNREFUSED|connection refused/i,
+    suggestions: [
+      {
+        fix: 'Verify the service is running',
+        diff: 'Check that the database/API server is started',
+        confidence: 80
+      },
+      {
+        fix: 'Check port and host configuration',
+        diff: 'Verify PORT and HOST environment variables',
+        confidence: 75
+      }
+    ]
+  },
+  {
+    errorPattern: /out of memory|heap/i,
+    suggestions: [
+      {
+        fix: 'Process data in chunks',
+        diff: '+ for (const chunk of chunks(data, 1000)) { process(chunk) }',
+        confidence: 70
+      },
+      {
+        fix: 'Increase Node.js memory limit',
+        diff: '+ node --max-old-space-size=4096 app.js',
+        confidence: 60
+      }
+    ]
+  },
+  {
+    errorPattern: /module not found|cannot find module/i,
+    suggestions: [
+      {
+        fix: 'Install missing package',
+        diff: '+ npm install <package-name>',
+        confidence: 85
+      },
+      {
+        fix: 'Check import path is correct',
+        diff: 'Verify relative path (./module vs ../module)',
+        confidence: 75
+      }
+    ]
+  },
+  {
+    errorPattern: /type.*is not assignable/i,
+    suggestions: [
+      {
+        fix: 'Add type assertion',
+        diff: '+ value as ExpectedType',
+        confidence: 60
+      },
+      {
+        fix: 'Fix the type definition',
+        diff: 'Update interface/type to match actual data',
+        confidence: 70
+      }
+    ]
+  },
+  {
+    errorPattern: /async|await|promise/i,
+    suggestions: [
+      {
+        fix: 'Add await keyword',
+        diff: '+ const result = await asyncFunction()',
+        confidence: 75
+      },
+      {
+        fix: 'Handle promise rejection',
+        diff: '+ .catch(err => console.error(err))',
+        confidence: 70
+      }
+    ]
+  }
+];
+
+export class FixSuggester {
+  private db: Database.Database;
+  private bugCorrelator: BugCorrelator;
+  private changeTracker: ChangeTracker;
+
+  constructor(
+    db: Database.Database,
+    bugCorrelator: BugCorrelator,
+    changeTracker: ChangeTracker
+  ) {
+    this.db = db;
+    this.bugCorrelator = bugCorrelator;
+    this.changeTracker = changeTracker;
+  }
+
+  suggestFix(error: string, context?: string): FixSuggestion[] {
+    const suggestions: FixSuggestion[] = [];
+
+    // 1. Check for similar bugs with fixes
+    const pastBugs = this.bugCorrelator.findSimilarBugs(error, 5);
+    for (const bug of pastBugs) {
+      if (bug.fix || bug.fixDiff) {
+        suggestions.push({
+          confidence: bug.similarity,
+          fix: bug.fix || 'Apply similar fix',
+          reason: `Fixed similar issue on ${bug.date.toLocaleDateString()}`,
+          diff: bug.fixDiff,
+          pastFix: {
+            date: bug.date,
+            file: bug.file || 'unknown',
+            bugId: bug.id
+          },
+          source: 'history'
+        });
+      }
+    }
+
+    // 2. Check for pattern-based suggestions
+    for (const { errorPattern, suggestions: patternSuggestions } of FIX_PATTERNS) {
+      const match = error.match(errorPattern);
+      if (match) {
+        for (const suggestion of patternSuggestions) {
+          // Replace $1 with captured group if present
+          let fix = suggestion.fix;
+          let diff = suggestion.diff;
+          if (match[1]) {
+            fix = fix.replace('$1', match[1]);
+            diff = diff.replace('$1', match[1]);
+          }
+
+          suggestions.push({
+            confidence: suggestion.confidence,
+            fix,
+            reason: 'Common fix for this error type',
+            diff,
+            source: 'pattern'
+          });
+        }
+        break; // Only use first matching pattern
+      }
+    }
+
+    // 3. Check if recent changes can be reverted
+    if (suggestions.length < 3) {
+      const revertSuggestion = this.checkRevertOption(error);
+      if (revertSuggestion) {
+        suggestions.push(revertSuggestion);
+      }
+    }
+
+    // 4. Add general suggestions based on context
+    if (context) {
+      const contextSuggestion = this.getContextBasedSuggestion(error, context);
+      if (contextSuggestion) {
+        suggestions.push(contextSuggestion);
+      }
+    }
+
+    // Sort by confidence
+    suggestions.sort((a, b) => b.confidence - a.confidence);
+
+    // Return top 5
+    return suggestions.slice(0, 5);
+  }
+
+  private checkRevertOption(error: string): FixSuggestion | null {
+    // Check if a recent change might have caused this
+    const keywords = error.split(/\s+/)
+      .filter(w => w.length > 3)
+      .slice(0, 5);
+
+    const recentChanges = this.changeTracker.getRecentChanges(24);
+
+    for (const change of recentChanges) {
+      const changeText = `${change.file} ${change.diff}`.toLowerCase();
+      const matchCount = keywords.filter(k => changeText.includes(k.toLowerCase())).length;
+
+      if (matchCount >= 2 && change.linesRemoved > 0) {
+        return {
+          confidence: 50,
+          fix: `Consider reverting recent change in ${change.file}`,
+          reason: `This file was modified ${Math.round((Date.now() - change.timestamp.getTime()) / (1000 * 60 * 60))}h ago and may have introduced the issue`,
+          diff: `git revert ${change.commitHash}`,
+          pastFix: {
+            date: change.timestamp,
+            file: change.file
+          },
+          source: 'history'
+        };
+      }
+    }
+
+    return null;
+  }
+
+  private getContextBasedSuggestion(error: string, context: string): FixSuggestion | null {
+    const contextLower = context.toLowerCase();
+    const errorLower = error.toLowerCase();
+
+    // Database-related
+    if (contextLower.includes('database') || contextLower.includes('query')) {
+      if (errorLower.includes('timeout')) {
+        return {
+          confidence: 55,
+          fix: 'Add database index or optimize query',
+          reason: 'Database timeouts often indicate missing indexes',
+          diff: 'CREATE INDEX idx_column ON table(column)',
+          source: 'general'
+        };
+      }
+    }
+
+    // API-related
+    if (contextLower.includes('api') || contextLower.includes('fetch')) {
+      if (errorLower.includes('undefined') || errorLower.includes('null')) {
+        return {
+          confidence: 55,
+          fix: 'Add response validation before accessing data',
+          reason: 'API responses should be validated before use',
+          diff: 'if (response?.data) { ... }',
+          source: 'general'
+        };
+      }
+    }
+
+    // React/Component-related
+    if (contextLower.includes('component') || contextLower.includes('react')) {
+      if (errorLower.includes('undefined') || errorLower.includes('null')) {
+        return {
+          confidence: 55,
+          fix: 'Add null check or default value for props',
+          reason: 'Component props may be undefined initially',
+          diff: 'const value = props.value ?? defaultValue',
+          source: 'general'
+        };
+      }
+    }
+
+    return null;
+  }
+
+  // Get fix statistics
+  getFixStats(): {
+    totalFixes: number;
+    successRate: number;
+    avgConfidence: number;
+    topPatterns: Array<{ pattern: string; count: number }>;
+  } {
+    // This would ideally track actual fix success over time
+    // For now, return pattern-based stats
+    return {
+      totalFixes: FIX_PATTERNS.length * 2, // Each pattern has ~2 suggestions
+      successRate: 75, // Estimated
+      avgConfidence: 70,
+      topPatterns: FIX_PATTERNS.slice(0, 5).map((p, i) => ({
+        pattern: p.errorPattern.source.slice(0, 30),
+        count: 10 - i // Placeholder counts
+      }))
+    };
+  }
+}

package/src/core/change-intelligence/index.ts

@@ -0,0 +1,5 @@
+// Change Intelligence Module - Phase 9
+export { ChangeIntelligence } from './change-intelligence.js';
+export { ChangeTracker } from './change-tracker.js';
+export { BugCorrelator } from './bug-correlator.js';
+export { FixSuggester } from './fix-suggester.js';