neuronlayer 0.1.3 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neuronlayer",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Persistent memory layer for AI coding assistants - MCP server that makes AI truly understand your codebase",
   "type": "module",
   "main": "dist/index.js",
@@ -9,16 +9,9 @@
   },
   "scripts": {
     "build": "node esbuild.config.js",
-    "build:benchmark": "node esbuild.benchmark.cjs",
-    "build:all": "npm run build && npm run build:benchmark",
     "dev": "node --watch dist/index.js",
     "start": "node dist/index.js",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest",
-    "test:run": "vitest run",
-    "benchmark": "npm run build:all && node dist/benchmark/working-benchmark.js",
-    "benchmark:quick": "npm run build:all && node dist/benchmark/working-benchmark.js --quick",
-    "benchmark:full": "npm run build:all && node dist/benchmark/working-benchmark.js --iterations 50"
+    "typecheck": "tsc --noEmit"
   },
   "keywords": [
     "mcp",
@@ -28,7 +21,6 @@
     "codebase",
     "claude",
     "embeddings",
-    "agent",
     "coding-assistant",
     "llm"
   ],
@@ -54,8 +46,7 @@
     "@types/better-sqlite3": "^7.6.0",
     "@types/node": "^22.0.0",
     "esbuild": "^0.25.0",
-    "typescript": "^5.7.0",
-    "vitest": "^3.0.0"
+    "typescript": "^5.7.0"
   },
   "engines": {
     "node": ">=18.0.0"

package/src/core/change-intelligence/bug-correlator.ts

@@ -413,6 +413,106 @@ export class BugCorrelator {
     return null;
   }
 
+  /**
+   * Scan git history for fix commits and auto-record as bugs
+   * Looks for commits with "fix:", "bugfix:", "hotfix:" prefixes or "fixes #" references
+   */
+  scanForBugFixes(): number {
+    try {
+      // Get commits from change_history that look like bug fixes
+      const fixCommits = this.db.prepare(`
+        SELECT DISTINCT commit_hash, commit_message, file, diff, timestamp
+        FROM change_history
+        WHERE (
+          LOWER(commit_message) LIKE 'fix:%' OR
+          LOWER(commit_message) LIKE 'fix(%' OR
+          LOWER(commit_message) LIKE 'bugfix:%' OR
+          LOWER(commit_message) LIKE 'hotfix:%' OR
+          LOWER(commit_message) LIKE '%fixes #%' OR
+          LOWER(commit_message) LIKE '%fixed #%' OR
+          LOWER(commit_message) LIKE '%closes #%'
+        )
+        ORDER BY timestamp DESC
+        LIMIT 50
+      `).all() as Array<{
+        commit_hash: string;
+        commit_message: string;
+        file: string;
+        diff: string | null;
+        timestamp: number;
+      }>;
+
+      let recorded = 0;
+
+      for (const commit of fixCommits) {
+        // Check if we already have this bug recorded (by commit hash in related_changes)
+        const existing = this.db.prepare(`
+          SELECT id FROM bug_history
+          WHERE fixed_by = ? OR related_changes LIKE ?
+        `).get(commit.commit_hash, `%${commit.commit_hash}%`);
+
+        if (existing) continue;
+
+        // Extract the bug description from commit message
+        const errorDescription = this.extractErrorFromCommitMessage(commit.commit_message);
+
+        // Record the bug as already fixed
+        const id = randomUUID();
+
+        this.db.prepare(`
+          INSERT INTO bug_history (id, error, file, timestamp, status, fixed_by, fixed_at, fix_diff, cause)
+          VALUES (?, ?, ?, ?, 'fixed', ?, ?, ?, ?)
+        `).run(
+          id,
+          errorDescription,
+          commit.file,
+          commit.timestamp,
+          commit.commit_hash,
+          commit.timestamp,
+          commit.diff?.slice(0, 2000) || null,
+          commit.commit_message
+        );
+
+        recorded++;
+      }
+
+      return recorded;
+    } catch {
+      return 0;
+    }
+  }
+
+  /**
+   * Extract a bug/error description from a fix commit message
+   */
+  private extractErrorFromCommitMessage(message: string): string {
+    // Remove common prefixes
+    let cleaned = message
+      .replace(/^fix\s*[:\(]/i, '')
+      .replace(/^bugfix\s*[:\(]/i, '')
+      .replace(/^hotfix\s*[:\(]/i, '')
+      .replace(/\):\s*/, ': ')
+      .trim();
+
+    // Extract issue references
+    const issueMatch = cleaned.match(/(?:fixes|fixed|closes)\s*#(\d+)/i);
+    if (issueMatch) {
+      cleaned = cleaned.replace(/(?:fixes|fixed|closes)\s*#\d+/gi, '').trim();
+      if (cleaned) {
+        cleaned = `Issue #${issueMatch[1]}: ${cleaned}`;
+      } else {
+        cleaned = `Issue #${issueMatch[1]}`;
+      }
+    }
+
+    // Capitalize first letter
+    if (cleaned.length > 0) {
+      cleaned = cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
+    }
+
+    return cleaned || message;
+  }
+
   // Get bug statistics
   getBugStats(): {
     total: number;

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

@@ -19,6 +19,8 @@ export class ChangeIntelligence {
   private bugCorrelator: BugCorrelator;
   private fixSuggester: FixSuggester;
   private initialized = false;
+  private lastKnownHead: string | null = null;
+  private lastBugScanHead: string | null = null;
 
   constructor(
     projectPath: string,
@@ -40,6 +42,39 @@ export class ChangeIntelligence {
     return synced;
   }
 
+  // Sync recent git changes on-demand (event-driven alternative to polling)
+  syncFromGit(limit: number = 20): number {
+    return this.changeTracker.syncFromGit(limit);
+  }
+
+  /**
+   * Get the last known HEAD commit
+   */
+  getLastKnownHead(): string | null {
+    return this.lastKnownHead;
+  }
+
+  /**
+   * Update the last known HEAD (call this after syncing)
+   */
+  setLastKnownHead(head: string): void {
+    this.lastKnownHead = head;
+  }
+
+  /**
+   * Get the last HEAD where we scanned for bug fixes
+   */
+  getLastBugScanHead(): string | null {
+    return this.lastBugScanHead;
+  }
+
+  /**
+   * Update the last bug scan HEAD (call this after scanning)
+   */
+  setLastBugScanHead(head: string): void {
+    this.lastBugScanHead = head;
+  }
+
   // Query what changed
   whatChanged(options: ChangeQueryOptions = {}): ChangeQueryResult {
     return this.changeTracker.queryChanges(options);
@@ -85,6 +120,14 @@ export class ChangeIntelligence {
     return this.bugCorrelator.recordFix(bugId, fixDiff, cause);
   }
 
+  /**
+   * Scan git history for fix commits and auto-record as bugs
+   * Called by background intelligence loop
+   */
+  scanForBugFixes(): number {
+    return this.bugCorrelator.scanForBugFixes();
+  }
+
   // Search changes by keyword
   searchChanges(keyword: string, limit?: number): Change[] {
     return this.changeTracker.searchChanges(keyword, limit);

package/src/core/engine.ts

@@ -22,6 +22,7 @@ import { TestAwareness } from './test-awareness/index.js';
 import { GhostMode, type GhostInsight, type ConflictWarning } from './ghost-mode.js';
 import { DejaVuDetector, type DejaVuMatch } from './deja-vu.js';
 import { CodeVerifier, type VerificationResult, type VerificationCheck, type ImportVerification, type SecurityScanResult, type DependencyCheckResult } from './code-verifier.js';
+import { GitStalenessChecker, ActivityGate } from './refresh/index.js';
 import { detectLanguage, getPreview, countLines } from '../utils/files.js';
 import type { MemoryLayerConfig, AssembledContext, Decision, ProjectSummary, SearchResult, CodeSymbol, SymbolKind, ActiveFeatureContext, HotContext } from '../types/index.js';
 import type { ArchitectureDoc, ComponentDoc, DailyChangelog, ChangelogOptions, ValidationResult, ActivityResult, UndocumentedItem, ContextHealth, CompactionResult, CompactionOptions, CriticalContext, DriftResult, ConfidenceResult, ConfidenceLevel, ConfidenceSources, ConflictResult, ChangeQueryResult, ChangeQueryOptions, Diagnosis, PastBug, FixSuggestion, Change, Pattern, PatternCategory, PatternValidationResult, ExistingFunction, TestInfo, TestFramework, TestValidationResult, TestUpdate, TestCoverage } from '../types/documentation.js';
@@ -53,14 +54,12 @@ export class MemoryLayerEngine {
   private ghostMode: GhostMode;
   private dejaVu: DejaVuDetector;
   private codeVerifier: CodeVerifier;
-  private backgroundInterval: NodeJS.Timeout | null = null;
+  private gitStalenessChecker: GitStalenessChecker;
+  private activityGate: ActivityGate;
   private initialized = false;
   private initializationStatus: 'pending' | 'indexing' | 'ready' | 'error' = 'pending';
   private indexingProgress: { indexed: number; total: number } = { indexed: 0, total: 0 };
 
-  // Background intelligence settings
-  private readonly BACKGROUND_REFRESH_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
-
   constructor(config: MemoryLayerConfig) {
     this.config = config;
 
@@ -165,6 +164,10 @@ export class MemoryLayerEngine {
     // Phase 13: Initialize Code Verifier (pre-commit quality gate)
     this.codeVerifier = new CodeVerifier(config.projectPath);
 
+    // Intelligent Refresh System
+    this.gitStalenessChecker = new GitStalenessChecker(config.projectPath);
+    this.activityGate = new ActivityGate();
+
     // Register this project
     const projectInfo = this.projectManager.registerProject(config.projectPath);
     this.projectManager.setActiveProject(projectInfo.id);
@@ -197,6 +200,13 @@ export class MemoryLayerEngine {
 
       if (stats.indexed > 0) {
         console.error(`Indexing complete: ${stats.indexed} files indexed`);
+        // Log activity for indexing
+        this.livingDocs.getActivityTracker().logActivity(
+          'indexing_complete',
+          `Indexed ${stats.indexed} files`,
+          undefined,
+          { total: stats.total, indexed: stats.indexed }
+        );
       } else {
         console.error(`Index up to date (${stats.total} files)`);
       }
@@ -209,6 +219,9 @@ export class MemoryLayerEngine {
     this.indexer.on('fileIndexed', (path) => {
       // Track file in feature context
       this.featureContextManager.onFileOpened(path);
+
+      // Invalidate cached summary when file changes (event-driven, not polling)
+      this.summarizer.invalidateSummaryByPath(path);
     });
 
     this.indexer.on('error', (error) => {
@@ -247,8 +260,17 @@ export class MemoryLayerEngine {
         console.error(`Test awareness: ${testResult.testsIndexed} tests indexed (${testResult.framework})`);
       }
 
-      // Start background intelligence loop
-      this.startBackgroundIntelligence();
+      // Scan for bug fixes from git history (one-time on init, not polling)
+      this.changeIntelligence.scanForBugFixes();
+
+      // Initialize git staleness checker with current HEAD
+      this.gitStalenessChecker.updateCachedHead();
+
+      // Register idle-time maintenance tasks
+      this.registerIdleTasks();
+
+      // Start idle monitoring
+      this.activityGate.startIdleMonitoring(10_000);
 
       this.initialized = true;
       this.initializationStatus = 'ready';
@@ -271,30 +293,129 @@ export class MemoryLayerEngine {
   }
 
   /**
-   * Background Intelligence Loop - continuously learn and update without user intervention
+   * Register idle-time maintenance tasks
    */
-  private startBackgroundIntelligence(): void {
-    // Clear any existing interval
-    if (this.backgroundInterval) {
-      clearInterval(this.backgroundInterval);
-    }
-
-    // Refresh git changes every 5 minutes
-    this.backgroundInterval = setInterval(() => {
-      try {
-        // Sync recent git changes
+  private registerIdleTasks(): void {
+    // Git sync when idle and HEAD has changed
+    this.activityGate.registerIdleTask('git-sync', () => {
+      if (this.gitStalenessChecker.hasNewCommits()) {
         const synced = this.changeIntelligence.syncFromGit(20);
         if (synced > 0) {
-          console.error(`[Background] Synced ${synced} recent changes from git`);
+          this.changeIntelligence.scanForBugFixes();
+          console.error(`Idle sync: ${synced} git changes synced`);
         }
+      }
+    }, {
+      minIdleMs: 30_000,     // 30 seconds idle
+      intervalMs: 60_000     // Check at most every minute
+    });
+
+    // Importance score updates when idle for longer
+    this.activityGate.registerIdleTask('importance-update', () => {
+      this.learningEngine.updateImportanceScores();
+    }, {
+      minIdleMs: 60_000,     // 1 minute idle
+      intervalMs: 300_000    // Max once per 5 minutes
+    });
+  }
 
-        // Update importance scores for recently accessed files
-        this.learningEngine.updateImportanceScores();
-      } catch (error) {
-        // Silent fail for background tasks
-        console.error('[Background] Error in intelligence loop:', error);
+  /**
+   * Sync git changes on-demand with cheap pre-check
+   * Only syncs if HEAD has changed, otherwise returns 0
+   */
+  syncGitChanges(limit: number = 20): number {
+    // Record activity
+    this.activityGate.recordActivity();
+
+    try {
+      // Cheap pre-check: has HEAD changed?
+      if (!this.gitStalenessChecker.hasNewCommits()) {
+        return 0; // No new commits, skip expensive sync
+      }
+
+      const synced = this.changeIntelligence.syncFromGit(limit);
+      if (synced > 0) {
+        // Also scan for bug fixes when syncing
+        this.changeIntelligence.scanForBugFixes();
+      }
+      return synced;
+    } catch {
+      return 0;
+    }
+  }
+
+  /**
+   * Force sync git changes, bypassing the staleness check
+   */
+  forceSyncGitChanges(limit: number = 20): number {
+    this.activityGate.recordActivity();
+    this.gitStalenessChecker.updateCachedHead();
+
+    try {
+      const synced = this.changeIntelligence.syncFromGit(limit);
+      if (synced > 0) {
+        this.changeIntelligence.scanForBugFixes();
       }
-    }, this.BACKGROUND_REFRESH_INTERVAL_MS);
+      return synced;
+    } catch {
+      return 0;
+    }
+  }
+
+  /**
+   * Trigger a full refresh of the memory layer
+   * Syncs git changes, updates importance scores, etc.
+   */
+  triggerRefresh(): {
+    gitSynced: number;
+    importanceUpdated: boolean;
+    tasksExecuted: string[];
+  } {
+    this.activityGate.recordActivity();
+
+    // Force git sync
+    this.gitStalenessChecker.updateCachedHead();
+    const gitSynced = this.forceSyncGitChanges();
+
+    // Update importance scores
+    this.learningEngine.updateImportanceScores();
+
+    return {
+      gitSynced,
+      importanceUpdated: true,
+      tasksExecuted: ['git-sync', 'importance-update']
+    };
+  }
+
+  /**
+   * Get refresh system status
+   */
+  getRefreshStatus(): {
+    lastActivity: number;
+    isIdle: boolean;
+    idleDuration: number;
+    gitHead: string | null;
+    hasNewCommits: boolean;
+    idleTasks: Array<{
+      name: string;
+      lastRun: number;
+      readyToRun: boolean;
+    }>;
+  } {
+    const status = this.activityGate.getStatus();
+
+    return {
+      lastActivity: this.activityGate.getLastActivity(),
+      isIdle: status.isIdle,
+      idleDuration: status.idleDuration,
+      gitHead: this.gitStalenessChecker.getCachedHead(),
+      hasNewCommits: this.gitStalenessChecker.hasNewCommits(),
+      idleTasks: status.tasks.map(t => ({
+        name: t.name,
+        lastRun: t.lastRun,
+        readyToRun: t.readyToRun
+      }))
+    };
   }
 
   /**
@@ -313,6 +434,9 @@ export class MemoryLayerEngine {
   }
 
   async getContext(query: string, currentFile?: string, maxTokens?: number): Promise<AssembledContext> {
+    // Record activity for refresh system
+    this.activityGate.recordActivity();
+
     // Track the query
     this.learningEngine.trackEvent({ eventType: 'query', query });
 
@@ -339,6 +463,7 @@ export class MemoryLayerEngine {
   }
 
   async searchCodebase(query: string, limit: number = 10): Promise<SearchResult[]> {
+    this.activityGate.recordActivity();
     const embedding = await this.indexer.getEmbeddingGenerator().embed(query);
     let results = this.tier2.search(embedding, limit * 2); // Get more for re-ranking
 
@@ -354,7 +479,28 @@ export class MemoryLayerEngine {
     files?: string[],
     tags?: string[]
   ): Promise<Decision> {
-    return this.decisionTracker.recordDecision(title, description, files || [], tags || []);
+    this.activityGate.recordActivity();
+    const decision = await this.decisionTracker.recordDecision(title, description, files || [], tags || []);
+
+    // Log activity for decision recording
+    this.livingDocs.getActivityTracker().logActivity(
+      'decision_recorded',
+      `Decision: ${title}`,
+      undefined,
+      { decisionId: decision.id }
+    );
+
+    // Auto-mark decisions as critical context
+    this.contextRotPrevention.markCritical(
+      `Decision: ${title}\n${description}`,
+      {
+        type: 'decision',
+        reason: 'Architectural decision',
+        source: 'auto'
+      }
+    );
+
+    return decision;
   }
 
   getRecentDecisions(limit: number = 10): Decision[] {
@@ -370,6 +516,7 @@ export class MemoryLayerEngine {
   }
 
   async getFileContext(filePath: string): Promise<{ content: string; language: string; lines: number } | null> {
+    this.activityGate.recordActivity();
     const absolutePath = join(this.config.projectPath, filePath);
 
     if (!existsSync(absolutePath)) {
@@ -1440,14 +1587,8 @@ export class MemoryLayerEngine {
 
   shutdown(): void {
     console.error('Shutting down MemoryLayer...');
-
-    // Stop background intelligence
-    if (this.backgroundInterval) {
-      clearInterval(this.backgroundInterval);
-      this.backgroundInterval = null;
-    }
-
     this.indexer.stopWatching();
+    this.activityGate.shutdown();
     this.tier1.save();
     this.featureContextManager.shutdown();
     closeDatabase(this.db);

package/src/core/learning.ts

@@ -37,6 +37,8 @@ export class LearningEngine {
   private hotCache: Map<string, { content: string; accessCount: number; lastAccessed: number }> = new Map();
   private readonly MAX_CACHE_SIZE = 50;
   private readonly CACHE_TTL_MS = 30 * 60 * 1000; // 30 minutes
+  private lastImportanceUpdate: number = 0;
+  private readonly IMPORTANCE_UPDATE_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
 
   constructor(db: Database.Database) {
     this.db = db;
@@ -385,11 +387,40 @@ export class LearningEngine {
     return result.changes;
   }
 
+  /**
+   * Check if importance update should be skipped
+   * Returns true if we've already updated within the last 5 minutes
+   */
+  shouldSkipImportanceUpdate(): boolean {
+    const now = Date.now();
+    return now - this.lastImportanceUpdate < this.IMPORTANCE_UPDATE_INTERVAL_MS;
+  }
+
+  /**
+   * Get time since last importance update in milliseconds
+   */
+  getTimeSinceLastImportanceUpdate(): number {
+    return Date.now() - this.lastImportanceUpdate;
+  }
+
+  /**
+   * Get the last importance update timestamp
+   */
+  getLastImportanceUpdateTime(): number {
+    return this.lastImportanceUpdate;
+  }
+
   /**
    * Update importance scores for all files based on usage patterns
    * Called by background intelligence loop
+   * Gated to run at most once per 5 minutes
    */
   updateImportanceScores(): void {
+    // Gate: skip if we've already updated recently
+    if (this.shouldSkipImportanceUpdate()) {
+      return;
+    }
+
     try {
       // Get all files with access stats
       const stmt = this.db.prepare(`
@@ -428,6 +459,9 @@ export class LearningEngine {
           importance
         );
       }
+
+      // Update the timestamp to prevent running again within the interval
+      this.lastImportanceUpdate = Date.now();
     } catch (error) {
       console.error('Error updating importance scores:', error);
     }

package/src/core/living-docs/doc-engine.ts

@@ -40,6 +40,9 @@ export class LivingDocumentationEngine {
   async generateArchitectureDocs(): Promise<ArchitectureDoc> {
     const doc = await this.archGen.generate();
 
+    // Store architecture docs in documentation table
+    this.storeDocumentation('_architecture', 'architecture', JSON.stringify(doc));
+
     // Log activity
     this.activityTracker.logActivity(
       'doc_generation',
@@ -51,6 +54,13 @@ export class LivingDocumentationEngine {
     return doc;
   }
 
+  /**
+   * Get the activity tracker for external use
+   */
+  getActivityTracker(): ActivityTracker {
+    return this.activityTracker;
+  }
+
   async generateComponentDoc(filePath: string): Promise<ComponentDoc> {
     const doc = await this.compGen.generate(filePath);
 
@@ -89,6 +99,20 @@ export class LivingDocumentationEngine {
 
   private storeDocumentation(filePath: string, docType: string, content: string): void {
     try {
+      // Special handling for architecture docs (no file ID)
+      if (filePath === '_architecture') {
+        // Use file_id = 0 for special docs like architecture
+        const stmt = this.db.prepare(`
+          INSERT INTO documentation (file_id, doc_type, content, generated_at)
+          VALUES (0, ?, ?, unixepoch())
+          ON CONFLICT(file_id, doc_type) DO UPDATE SET
+            content = excluded.content,
+            generated_at = unixepoch()
+        `);
+        stmt.run(docType, content);
+        return;
+      }
+
       // Get file ID
       const fileStmt = this.db.prepare('SELECT id FROM files WHERE path = ?');
       const fileRow = fileStmt.get(filePath) as { id: number } | undefined;