k0ntext 3.0.0

package/src/agents/cleanup-agent.ts

@@ -0,0 +1,96 @@
+import fs from 'fs';
+import path from 'path';
+import { DEFAULT_CLEANUP_CONFIG } from '../config/cleanup-config.js';
+
+export interface CleanupOptions {
+  dryRun?: boolean;
+  keep?: string[];
+  verbose?: boolean;
+  cwd?: string;
+}
+
+export interface CleanupConfig {
+  /** Default dry run mode (safe mode) */
+  dryRun: boolean;
+
+  /** Default folders to keep */
+  defaultKeep: string[];
+
+  /** Verbose output by default */
+  verbose: boolean;
+
+  /** Maximum folder depth to scan */
+  maxDepth: number;
+
+  /** Timeout for folder operations in milliseconds */
+  timeout: number;
+
+  /** Default working directory */
+  cwd: string;
+}
+
+export interface CleanupResult {
+  scanned: number;
+  removed: string[];
+  kept: string[];
+  errors: Array<{ folder: string; error: unknown }>;
+}
+
+export class CleanupAgent {
+  private readonly KNOWN_TOOL_FOLDERS = [
+    '.cursor', '.windsurf', '.cline', '.aider',
+    '.continue', '.copilot', '.cursorrules',
+    '.ai-context', // legacy
+    '.github', '.vscode', '.idea', '.devcontainer'
+  ];
+
+  private config: typeof DEFAULT_CLEANUP_CONFIG;
+
+  constructor(config?: Partial<typeof DEFAULT_CLEANUP_CONFIG>) {
+    this.config = { ...DEFAULT_CLEANUP_CONFIG, ...config, cwd: config?.cwd || process.cwd() };
+  }
+
+  async cleanup(options: CleanupOptions = {}): Promise<CleanupResult> {
+    const cwd = options.cwd || this.config.cwd;
+    const entries = fs.readdirSync(cwd, { withFileTypes: true });
+
+    const toolFolders = entries
+      .filter(e => e.isDirectory() && e.name.startsWith('.'))
+      .filter(e => this.KNOWN_TOOL_FOLDERS.includes(e.name))
+      .filter(e => !options.keep?.includes(e.name) && !this.config.defaultKeep.includes(e.name));
+
+    const results: CleanupResult = {
+      scanned: toolFolders.length,
+      removed: [],
+      kept: [],
+      errors: [],
+    };
+
+    for (const folder of toolFolders) {
+      try {
+        const folderPath = path.join(cwd, folder.name);
+
+        if (options.dryRun || this.config.dryRun) {
+          results.removed.push(folder.name + ' (dry-run)');
+          if (options.verbose || this.config.verbose) console.log(`Would remove: ${folder.name}`);
+        } else {
+          fs.rmSync(folderPath, { recursive: true, force: true });
+          results.removed.push(folder.name);
+          if (options.verbose || this.config.verbose) console.log(`Removed: ${folder.name}`);
+        }
+      } catch (error) {
+        results.errors.push({ folder: folder.name, error });
+      }
+    }
+
+    return results;
+  }
+
+  async analyze(options: Omit<CleanupOptions, 'dryRun'> = {}): Promise<CleanupResult> {
+    return this.cleanup({ ...options, dryRun: true, verbose: true });
+  }
+
+  getConfig(): typeof DEFAULT_CLEANUP_CONFIG {
+    return { ...this.config };
+  }
+}

package/src/agents/performance-agent.ts

@@ -0,0 +1,117 @@
+/**
+ * Performance Monitor Agent
+ *
+ * Monitors database performance, query times, and system metrics.
+ */
+
+import path from 'path';
+import fs from 'fs';
+import { DatabaseClient } from '../db/client.js';
+
+export interface PerformanceMetrics {
+  queryCount: number;
+  avgQueryTime: number;
+  slowQueries: number;
+  databaseSize: number;
+  indexUsage: number;
+  cacheHitRate: number;
+}
+
+export class PerformanceMonitorAgent {
+  private db: DatabaseClient;
+  private queryTimes: number[] = [];
+  private slowQueryThreshold = 1000; // ms
+
+  constructor(projectRoot: string) {
+    this.db = new DatabaseClient(projectRoot);
+  }
+
+  /**
+   * Track query execution time
+   */
+  trackQuery(durationMs: number): void {
+    this.queryTimes.push(durationMs);
+
+    // Keep only last 100 queries
+    if (this.queryTimes.length > 100) {
+      this.queryTimes.shift();
+    }
+  }
+
+  /**
+   * Get current performance metrics
+   */
+  getMetrics(): PerformanceMetrics {
+    const avgQueryTime = this.queryTimes.length > 0
+      ? this.queryTimes.reduce((a, b) => a + b, 0) / this.queryTimes.length
+      : 0;
+
+    const slowQueries = this.queryTimes.filter(t => t > this.slowQueryThreshold).length;
+
+    // Get database size
+    const dbPath = path.resolve(this.db.getPath());
+    let databaseSize = 0;
+    try {
+      const stats = fs.statSync(dbPath);
+      databaseSize = stats.size;
+    } catch (error) {
+      // File doesn't exist or can't be read
+      console.error(`Warning: Could not read database size for ${dbPath}:`, error instanceof Error ? error.message : error);
+    }
+
+    return {
+      queryCount: this.queryTimes.length,
+      avgQueryTime,
+      slowQueries,
+      databaseSize,
+      indexUsage: 0, // Would need PRAGMA stats
+      cacheHitRate: 0  // Would need cache tracking
+    };
+  }
+
+  /**
+   * Generate performance report
+   */
+  generateReport(): string {
+    const metrics = this.getMetrics();
+
+    let report = 'Performance Report\n';
+    report += '==================\n\n';
+    report += `Query Count: ${metrics.queryCount}\n`;
+    report += `Avg Query Time: ${metrics.avgQueryTime.toFixed(2)}ms\n`;
+    report += `Slow Queries: ${metrics.slowQueries}\n`;
+    report += `Database Size: ${(metrics.databaseSize / 1024).toFixed(2)} KB\n\n`;
+
+    if (metrics.slowQueries > 0) {
+      report += '⚠ Warning: Slow queries detected. Consider adding indexes.\n';
+    }
+
+    return report;
+  }
+
+  /**
+   * Suggest optimizations
+   */
+  suggestOptimizations(): string[] {
+    const suggestions: string[] = [];
+    const metrics = this.getMetrics();
+
+    if (metrics.avgQueryTime > 500) {
+      suggestions.push('Consider adding indexes for frequently queried columns');
+    }
+
+    if (metrics.databaseSize > 10 * 1024 * 1024) { // 10 MB
+      suggestions.push('Database is large. Consider running VACUUM to reclaim space');
+    }
+
+    if (metrics.slowQueries > 0) {
+      suggestions.push('Review slow queries and optimize with proper indexes');
+    }
+
+    return suggestions;
+  }
+
+  close(): void {
+    this.db.close();
+  }
+}

package/src/analyzer/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Analyzer Module Index
+ */
+
+export {
+  IntelligentAnalyzer,
+  createIntelligentAnalyzer,
+  type DiscoveredFile,
+  type AnalysisResult
+} from './intelligent-analyzer.js';