neuronlayer 0.1.9 → 0.2.0

package/src/core/refresh/activity-gate.ts

@@ -1,256 +0,0 @@
-/**
- * ActivityGate - Track user activity and manage idle-time maintenance tasks
- *
- * This component enables intelligent refresh by:
- * 1. Tracking when the user was last active
- * 2. Detecting idle periods
- * 3. Executing maintenance tasks during idle time
- * 4. Ensuring only one idle task runs at a time
- */
-
-export interface IdleTask {
-  name: string;
-  callback: () => void | Promise<void>;
-  minIdleMs: number; // Minimum idle time before this task can run
-  lastRun: number;
-  intervalMs: number; // Minimum time between runs
-}
-
-export class ActivityGate {
-  private lastActivity: number = Date.now();
-  private idleTasks: IdleTask[] = [];
-  private monitoringInterval: ReturnType<typeof setInterval> | null = null;
-  private isExecutingTask: boolean = false;
-  private currentTaskIndex: number = 0;
-
-  constructor() {
-    // Activity is recorded at construction time
-    this.recordActivity();
-  }
-
-  /**
-   * Record user activity (call this on API method invocations)
-   */
-  recordActivity(): void {
-    this.lastActivity = Date.now();
-  }
-
-  /**
-   * Get the timestamp of the last recorded activity
-   */
-  getLastActivity(): number {
-    return this.lastActivity;
-  }
-
-  /**
-   * Check if the user has been idle for at least the given threshold
-   */
-  isIdle(thresholdMs: number = 30_000): boolean {
-    return Date.now() - this.lastActivity > thresholdMs;
-  }
-
-  /**
-   * Get the duration of the current idle period in milliseconds
-   */
-  getIdleDuration(): number {
-    return Date.now() - this.lastActivity;
-  }
-
-  /**
-   * Register an idle-time task
-   * Tasks are executed during idle periods, one at a time
-   */
-  registerIdleTask(
-    name: string,
-    callback: () => void | Promise<void>,
-    options: {
-      minIdleMs?: number;
-      intervalMs?: number;
-    } = {}
-  ): void {
-    const { minIdleMs = 30_000, intervalMs = 300_000 } = options;
-
-    // Remove existing task with same name
-    this.idleTasks = this.idleTasks.filter(t => t.name !== name);
-
-    this.idleTasks.push({
-      name,
-      callback,
-      minIdleMs,
-      lastRun: 0,
-      intervalMs
-    });
-  }
-
-  /**
-   * Unregister an idle-time task
-   */
-  unregisterIdleTask(name: string): boolean {
-    const initialLength = this.idleTasks.length;
-    this.idleTasks = this.idleTasks.filter(t => t.name !== name);
-    return this.idleTasks.length < initialLength;
-  }
-
-  /**
-   * Get all registered idle tasks
-   */
-  getIdleTasks(): readonly IdleTask[] {
-    return this.idleTasks;
-  }
-
-  /**
-   * Start monitoring for idle periods
-   * Will check every checkIntervalMs and execute tasks when idle
-   */
-  startIdleMonitoring(checkIntervalMs: number = 10_000): void {
-    if (this.monitoringInterval) {
-      return; // Already monitoring
-    }
-
-    this.monitoringInterval = setInterval(() => {
-      this.executeNextIdleTaskIfReady();
-    }, checkIntervalMs);
-  }
-
-  /**
-   * Stop idle monitoring
-   */
-  stopIdleMonitoring(): void {
-    if (this.monitoringInterval) {
-      clearInterval(this.monitoringInterval);
-      this.monitoringInterval = null;
-    }
-  }
-
-  /**
-   * Execute the next idle task if conditions are met
-   * - User must be idle
-   * - No other task is currently executing
-   * - Task's minimum idle time must be met
-   * - Task's minimum interval since last run must be met
-   */
-  private async executeNextIdleTaskIfReady(): Promise<void> {
-    if (this.isExecutingTask) {
-      return; // Already executing a task
-    }
-
-    if (this.idleTasks.length === 0) {
-      return; // No tasks registered
-    }
-
-    const now = Date.now();
-    const idleDuration = this.getIdleDuration();
-
-    // Find the next task that's ready to run
-    for (let i = 0; i < this.idleTasks.length; i++) {
-      const taskIndex = (this.currentTaskIndex + i) % this.idleTasks.length;
-      const task = this.idleTasks[taskIndex];
-
-      // Safety check (TypeScript strictness)
-      if (!task) continue;
-
-      // Check if task is ready
-      if (idleDuration < task.minIdleMs) {
-        continue; // Not idle long enough
-      }
-
-      if (now - task.lastRun < task.intervalMs) {
-        continue; // Too soon since last run
-      }
-
-      // Execute this task
-      this.currentTaskIndex = (taskIndex + 1) % this.idleTasks.length;
-      await this.executeTask(task);
-      return; // Only execute one task per check
-    }
-  }
-
-  /**
-   * Execute a specific task
-   */
-  private async executeTask(task: IdleTask): Promise<void> {
-    this.isExecutingTask = true;
-
-    try {
-      await Promise.resolve(task.callback());
-      task.lastRun = Date.now();
-    } catch (error) {
-      console.error(`Idle task '${task.name}' failed:`, error);
-      // Still update lastRun to prevent rapid retries
-      task.lastRun = Date.now();
-    } finally {
-      this.isExecutingTask = false;
-    }
-  }
-
-  /**
-   * Manually trigger execution of all ready idle tasks
-   * Useful for testing or manual refresh
-   */
-  async executeReadyTasks(): Promise<string[]> {
-    const executed: string[] = [];
-    const now = Date.now();
-    const idleDuration = this.getIdleDuration();
-
-    for (const task of this.idleTasks) {
-      if (idleDuration >= task.minIdleMs && now - task.lastRun >= task.intervalMs) {
-        await this.executeTask(task);
-        executed.push(task.name);
-      }
-    }
-
-    return executed;
-  }
-
-  /**
-   * Force immediate execution of a specific task by name
-   * Ignores idle and interval requirements
-   */
-  async forceExecuteTask(name: string): Promise<boolean> {
-    const task = this.idleTasks.find(t => t.name === name);
-    if (!task) {
-      return false;
-    }
-
-    await this.executeTask(task);
-    return true;
-  }
-
-  /**
-   * Get status of all idle tasks
-   */
-  getStatus(): {
-    isIdle: boolean;
-    idleDuration: number;
-    isExecutingTask: boolean;
-    tasks: Array<{
-      name: string;
-      lastRun: number;
-      timeSinceRun: number;
-      readyToRun: boolean;
-    }>;
-  } {
-    const now = Date.now();
-    const idleDuration = this.getIdleDuration();
-
-    return {
-      isIdle: this.isIdle(),
-      idleDuration,
-      isExecutingTask: this.isExecutingTask,
-      tasks: this.idleTasks.map(task => ({
-        name: task.name,
-        lastRun: task.lastRun,
-        timeSinceRun: now - task.lastRun,
-        readyToRun: idleDuration >= task.minIdleMs && now - task.lastRun >= task.intervalMs
-      }))
-    };
-  }
-
-  /**
-   * Shutdown the activity gate
-   */
-  shutdown(): void {
-    this.stopIdleMonitoring();
-    this.idleTasks = [];
-  }
-}

package/src/core/refresh/git-staleness-checker.ts

@@ -1,108 +0,0 @@
-import { execSync } from 'child_process';
-
-/**
- * GitStalenessChecker - Cheap HEAD caching and change detection
- *
- * Instead of running expensive `git log` operations, we cache the HEAD commit
- * and only run full syncs when HEAD has changed. This reduces polling overhead
- * from ~100ms+ to ~5ms per check.
- */
-export class GitStalenessChecker {
-  private cachedHead: string | null = null;
-  private lastCheckTime: number = 0;
-  private projectPath: string;
-
-  constructor(projectPath: string) {
-    this.projectPath = projectPath;
-  }
-
-  /**
-   * Get the current HEAD commit hash
-   * This is a cheap operation (~5ms)
-   */
-  getCurrentHead(): string | null {
-    try {
-      const head = execSync('git rev-parse HEAD', {
-        cwd: this.projectPath,
-        encoding: 'utf-8',
-        timeout: 5000,
-        stdio: ['pipe', 'pipe', 'pipe']
-      }).trim();
-      return head;
-    } catch {
-      return null;
-    }
-  }
-
-  /**
-   * Check if there are new commits since the last check
-   * Returns true if HEAD has changed (meaning we need to sync)
-   */
-  hasNewCommits(): boolean {
-    const current = this.getCurrentHead();
-    this.lastCheckTime = Date.now();
-
-    if (current === null) {
-      return false; // Not a git repo or git command failed
-    }
-
-    if (this.cachedHead === null) {
-      // First check - cache the current HEAD
-      this.cachedHead = current;
-      return false; // No need to sync on first check (assume we synced on init)
-    }
-
-    if (current !== this.cachedHead) {
-      // HEAD has changed - update cache and signal sync needed
-      this.cachedHead = current;
-      return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * Force update the cached HEAD (call after successful sync)
-   */
-  updateCachedHead(): void {
-    this.cachedHead = this.getCurrentHead();
-    this.lastCheckTime = Date.now();
-  }
-
-  /**
-   * Get the cached HEAD without checking git
-   */
-  getCachedHead(): string | null {
-    return this.cachedHead;
-  }
-
-  /**
-   * Get the time of the last check
-   */
-  getLastCheckTime(): number {
-    return this.lastCheckTime;
-  }
-
-  /**
-   * Get time since last check in milliseconds
-   */
-  getTimeSinceLastCheck(): number {
-    return Date.now() - this.lastCheckTime;
-  }
-
-  /**
-   * Check if enough time has passed since last check
-   * Default threshold is 30 seconds
-   */
-  shouldCheck(thresholdMs: number = 30_000): boolean {
-    return this.getTimeSinceLastCheck() > thresholdMs;
-  }
-
-  /**
-   * Reset the checker state (useful for testing)
-   */
-  reset(): void {
-    this.cachedHead = null;
-    this.lastCheckTime = 0;
-  }
-}

package/src/core/refresh/index.ts

@@ -1,27 +0,0 @@
-/**
- * Intelligent Refresh System for NeuronLayer
- *
- * This module provides a tiered refresh architecture:
- *
- * TIER 1: REAL-TIME (via file watcher)
- * - File changes → Chokidar watcher → immediate invalidation
- * - User queries → immediate tracking
- * - File access → immediate hot cache update
- *
- * TIER 2: ON-DEMAND WITH CHEAP PRE-CHECK
- * - Git sync → check HEAD first (5ms), only sync if changed
- * - Summaries → check lastModified before regenerating
- * - Bug diagnosis → sync git first if HEAD changed
- *
- * TIER 3: IDLE-TIME MAINTENANCE
- * - When user idle > 30s AND git changed → sync git
- * - When idle > 5min since last update → update importance scores
- * - One task at a time, non-blocking
- *
- * TIER 4: SESSION-BASED
- * - Engine init → full git sync
- * - Shutdown → persist state
- */
-
-export { GitStalenessChecker } from './git-staleness-checker.js';
-export { ActivityGate, type IdleTask } from './activity-gate.js';

package/src/core/summarizer.ts

@@ -1,290 +0,0 @@
-import type Database from 'better-sqlite3';
-import type { CodeSymbol } from '../types/index.js';
-import { estimateTokens } from '../utils/tokens.js';
-
-interface FileSummary {
-  fileId: number;
-  summary: string;
-  tokens: number;
-  generatedAt: number;
-}
-
-export class FileSummarizer {
-  private db: Database.Database;
-
-  constructor(db: Database.Database) {
-    this.db = db;
-  }
-
-  // Generate a compressed summary of a file
-  generateSummary(
-    filePath: string,
-    content: string,
-    symbols: CodeSymbol[],
-    imports: Array<{ importedFrom: string; importedSymbols: string[] }>,
-    exports: Array<{ exportedName: string }>
-  ): string {
-    const lines: string[] = [];
-
-    // File name and type
-    const fileName = filePath.split(/[/\\]/).pop() || filePath;
-    const extension = fileName.split('.').pop() || '';
-    lines.push(`**${fileName}** (${this.getFileType(extension)})`);
-
-    // Purpose (inferred from file name and content)
-    const purpose = this.inferPurpose(fileName, content, symbols);
-    if (purpose) {
-      lines.push(`Purpose: ${purpose}`);
-    }
-
-    // Exports summary
-    if (exports.length > 0) {
-      const exportNames = exports.map(e => e.exportedName).slice(0, 10);
-      lines.push(`Exports: ${exportNames.join(', ')}${exports.length > 10 ? ` (+${exports.length - 10} more)` : ''}`);
-    }
-
-    // Key symbols
-    const functions = symbols.filter(s => s.kind === 'function' && s.exported);
-    const classes = symbols.filter(s => s.kind === 'class');
-    const interfaces = symbols.filter(s => s.kind === 'interface');
-
-    if (classes.length > 0) {
-      lines.push(`Classes: ${classes.map(c => c.name).join(', ')}`);
-    }
-
-    if (interfaces.length > 0) {
-      lines.push(`Interfaces: ${interfaces.map(i => i.name).slice(0, 5).join(', ')}`);
-    }
-
-    if (functions.length > 0) {
-      const funcNames = functions.map(f => f.signature || f.name).slice(0, 5);
-      lines.push(`Functions: ${funcNames.join(', ')}${functions.length > 5 ? ` (+${functions.length - 5} more)` : ''}`);
-    }
-
-    // Dependencies
-    if (imports.length > 0) {
-      const deps = imports
-        .filter(i => !i.importedFrom.startsWith('.'))
-        .map(i => i.importedFrom.split('/')[0])
-        .filter((v, i, a) => a.indexOf(v) === i)
-        .slice(0, 5);
-
-      if (deps.length > 0) {
-        lines.push(`Uses: ${deps.join(', ')}`);
-      }
-    }
-
-    // Local imports (internal dependencies)
-    const localImports = imports
-      .filter(i => i.importedFrom.startsWith('.'))
-      .map(i => i.importedFrom.replace(/^\.\//, '').replace(/\.[^.]+$/, ''))
-      .slice(0, 5);
-
-    if (localImports.length > 0) {
-      lines.push(`Imports from: ${localImports.join(', ')}`);
-    }
-
-    // Key patterns detected
-    const patterns = this.detectPatterns(content);
-    if (patterns.length > 0) {
-      lines.push(`Patterns: ${patterns.join(', ')}`);
-    }
-
-    return lines.join('\n');
-  }
-
-  private getFileType(extension: string): string {
-    const types: Record<string, string> = {
-      'ts': 'TypeScript',
-      'tsx': 'React Component',
-      'js': 'JavaScript',
-      'jsx': 'React Component',
-      'py': 'Python',
-      'go': 'Go',
-      'rs': 'Rust',
-      'java': 'Java',
-      'rb': 'Ruby',
-      'vue': 'Vue Component',
-      'svelte': 'Svelte Component',
-    };
-    return types[extension] || extension.toUpperCase();
-  }
-
-  private inferPurpose(fileName: string, content: string, symbols: CodeSymbol[]): string {
-    const lowerName = fileName.toLowerCase();
-    const lowerContent = content.toLowerCase();
-
-    // Common file patterns
-    if (lowerName.includes('middleware')) return 'Request middleware/interceptor';
-    if (lowerName.includes('route') || lowerName.includes('router')) return 'API route definitions';
-    if (lowerName.includes('controller')) return 'Request handler/controller';
-    if (lowerName.includes('service')) return 'Business logic service';
-    if (lowerName.includes('model')) return 'Data model definitions';
-    if (lowerName.includes('schema')) return 'Schema/validation definitions';
-    if (lowerName.includes('util') || lowerName.includes('helper')) return 'Utility functions';
-    if (lowerName.includes('config')) return 'Configuration';
-    if (lowerName.includes('constant')) return 'Constants/enums';
-    if (lowerName.includes('type') || lowerName.includes('interface')) return 'Type definitions';
-    if (lowerName.includes('test') || lowerName.includes('spec')) return 'Tests';
-    if (lowerName.includes('hook')) return 'React hooks';
-    if (lowerName.includes('context')) return 'React context provider';
-    if (lowerName.includes('store')) return 'State management';
-    if (lowerName.includes('api')) return 'API client/definitions';
-    if (lowerName.includes('auth')) return 'Authentication';
-    if (lowerName.includes('db') || lowerName.includes('database')) return 'Database operations';
-
-    // Content-based inference
-    if (lowerContent.includes('express') && lowerContent.includes('router')) return 'Express router';
-    if (lowerContent.includes('mongoose') || lowerContent.includes('prisma')) return 'Database model';
-    if (lowerContent.includes('usestate') || lowerContent.includes('useeffect')) return 'React component';
-    if (lowerContent.includes('describe(') && lowerContent.includes('it(')) return 'Test suite';
-
-    // Symbol-based inference
-    const hasClasses = symbols.some(s => s.kind === 'class');
-    const hasInterfaces = symbols.some(s => s.kind === 'interface');
-    const hasFunctions = symbols.some(s => s.kind === 'function');
-
-    if (hasInterfaces && !hasClasses && !hasFunctions) return 'Type definitions';
-    if (hasClasses && symbols.filter(s => s.kind === 'class').length === 1) {
-      const className = symbols.find(s => s.kind === 'class')?.name;
-      return `${className} implementation`;
-    }
-
-    return '';
-  }
-
-  private detectPatterns(content: string): string[] {
-    const patterns: string[] = [];
-    const lower = content.toLowerCase();
-
-    // Architectural patterns
-    if (lower.includes('singleton') || /private\s+static\s+instance/i.test(content)) {
-      patterns.push('Singleton');
-    }
-    if (lower.includes('factory') || /create\w+\s*\(/i.test(content)) {
-      patterns.push('Factory');
-    }
-    if (lower.includes('observer') || lower.includes('subscriber') || lower.includes('eventemitter')) {
-      patterns.push('Observer');
-    }
-    if (/async\s+\*|yield\s+/i.test(content)) {
-      patterns.push('Generator');
-    }
-    if (lower.includes('decorator') || /@\w+\s*\(/i.test(content)) {
-      patterns.push('Decorator');
-    }
-
-    // Code patterns
-    if (lower.includes('try') && lower.includes('catch')) {
-      patterns.push('Error handling');
-    }
-    if (lower.includes('async') && lower.includes('await')) {
-      patterns.push('Async/await');
-    }
-    if (/\.then\s*\(/i.test(content)) {
-      patterns.push('Promise chain');
-    }
-    if (lower.includes('middleware')) {
-      patterns.push('Middleware');
-    }
-
-    return patterns.slice(0, 4);
-  }
-
-  // Store summary in database
-  storeSummary(fileId: number, summary: string): void {
-    const tokens = estimateTokens(summary);
-
-    const stmt = this.db.prepare(`
-      INSERT INTO file_summaries (file_id, summary, summary_tokens, generated_at)
-      VALUES (?, ?, ?, unixepoch())
-      ON CONFLICT(file_id) DO UPDATE SET
-        summary = excluded.summary,
-        summary_tokens = excluded.summary_tokens,
-        generated_at = unixepoch()
-    `);
-    stmt.run(fileId, summary, tokens);
-  }
-
-  // Get summary from database
-  getSummary(fileId: number): FileSummary | null {
-    const stmt = this.db.prepare(`
-      SELECT file_id as fileId, summary, summary_tokens as tokens, generated_at as generatedAt
-      FROM file_summaries
-      WHERE file_id = ?
-    `);
-    return stmt.get(fileId) as FileSummary | null;
-  }
-
-  // Get summaries for multiple files
-  getSummaries(fileIds: number[]): Map<number, string> {
-    const result = new Map<number, string>();
-
-    if (fileIds.length === 0) return result;
-
-    const placeholders = fileIds.map(() => '?').join(',');
-    const stmt = this.db.prepare(`
-      SELECT file_id, summary
-      FROM file_summaries
-      WHERE file_id IN (${placeholders})
-    `);
-    const rows = stmt.all(...fileIds) as Array<{ file_id: number; summary: string }>;
-
-    for (const row of rows) {
-      result.set(row.file_id, row.summary);
-    }
-
-    return result;
-  }
-
-  // Check if summary needs regeneration
-  needsRegeneration(fileId: number, fileLastModified: number): boolean {
-    const summary = this.getSummary(fileId);
-    if (!summary) return true;
-
-    // Regenerate if file was modified after summary was generated
-    return fileLastModified > summary.generatedAt;
-  }
-
-  // Invalidate summary when file changes (event-driven)
-  invalidateSummary(fileId: number): boolean {
-    try {
-      const result = this.db.prepare('DELETE FROM file_summaries WHERE file_id = ?').run(fileId);
-      return result.changes > 0;
-    } catch {
-      return false;
-    }
-  }
-
-  // Invalidate summary by file path
-  invalidateSummaryByPath(filePath: string): boolean {
-    try {
-      const file = this.db.prepare('SELECT id FROM files WHERE path = ?').get(filePath) as { id: number } | undefined;
-      if (file) {
-        return this.invalidateSummary(file.id);
-      }
-      return false;
-    } catch {
-      return false;
-    }
-  }
-
-  // Get compression ratio stats
-  getCompressionStats(): { totalFiles: number; avgCompression: number; totalTokensSaved: number } {
-    const stmt = this.db.prepare(`
-      SELECT
-        COUNT(*) as total_files,
-        AVG(f.size_bytes / 4.0 / NULLIF(fs.summary_tokens, 0)) as avg_compression,
-        SUM(f.size_bytes / 4.0 - fs.summary_tokens) as tokens_saved
-      FROM file_summaries fs
-      JOIN files f ON fs.file_id = f.id
-    `);
-    const result = stmt.get() as { total_files: number; avg_compression: number; tokens_saved: number };
-
-    return {
-      totalFiles: result.total_files || 0,
-      avgCompression: result.avg_compression || 1,
-      totalTokensSaved: result.tokens_saved || 0
-    };
-  }
-}