k0ntext 3.3.1 → 3.6.0

package/src/cli/index.ts

@@ -16,6 +16,7 @@ import { fileURLToPath } from 'url';
 
 import { createIntelligentAnalyzer } from '../analyzer/intelligent-analyzer.js';
 import { hasOpenRouterKey } from '../embeddings/openrouter.js';
+import type { DatabaseClient } from '../db/client.js';
 import { generateCommand } from './generate.js';
 import { syncCommand } from './sync.js';
 import { cleanupCommand } from './commands/cleanup.js';
@@ -29,6 +30,11 @@ import { crossSyncCommand } from './commands/cross-sync.js';
 import { hooksCommand } from './commands/hooks.js';
 import { factCheckCommand } from './commands/fact-check.js';
 import { batchIndexCommand } from './commands/batch-index.js';
+import { versionCheckCommand } from './commands/version-check.js';
+import { restoreCommand } from './commands/restore.js';
+import { syncTemplatesCommand, templateStatusCommand } from './commands/sync-templates.js';
+import { migrateCommand } from './commands/migrate.js';
+import { embeddingsRefreshCommand } from './commands/embeddings-refresh.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -145,6 +151,8 @@ function createProgram(): Command {
     .description('Initialize AI context for a project with intelligent analysis')
     .argument('[project-name]', 'Name of the project (defaults to current directory)')
     .option('--no-intelligent', 'Skip OpenRouter-powered intelligent analysis')
+    .option('--no-version-check', 'Skip checking for outdated context files')
+    .option('--no-template-sync', 'Skip template synchronization')
     .action(async (projectName, options) => {
       showBanner();
       
@@ -204,6 +212,198 @@ function createProgram(): Command {
         await configureMcpServer(targetDir);
         spinner.succeed('MCP server configured');
 
+        // Sync templates from package
+        if (options.templateSync !== false) {
+          spinner.start('Checking template sync...');
+
+          try {
+            const { TemplateSyncEngine } = await import('../template-sync/index.js');
+            const { DatabaseClient: DBClientClass } = await import('../db/client.js');
+
+            const db = new DBClientClass(targetDir);
+            const templateRoot = path.join(__dirname, '../../templates/base');
+            const engine = new TemplateSyncEngine(db, targetDir, templateRoot);
+
+            // Check if sync is needed
+            const needsSync = await engine.needsSync();
+
+            if (needsSync) {
+              spinner.text = 'Syncing templates from package...';
+
+              const syncResult = await engine.sync({
+                dryRun: false,
+                force: false,
+                verbose: options.verbose
+              });
+
+              if (syncResult.conflicts.length === 0) {
+                spinner.succeed(chalk.green(`Templates synced (${syncResult.updated} updated, ${syncResult.created} created)`));
+              } else {
+                spinner.warn(chalk.yellow(`Templates synced with ${syncResult.conflicts.length} conflict(s)`));
+                console.log(chalk.dim(`  Run 'k0ntext sync-templates' to resolve conflicts`));
+              }
+            } else {
+              spinner.succeed('Templates already up to date');
+            }
+
+            db.close();
+          } catch (error) {
+            spinner.stop();
+            // Template sync is optional, don't fail on error
+            if (options.verbose) {
+              console.warn(chalk.dim(`Template sync skipped: ${error instanceof Error ? error.message : error}`));
+            }
+          }
+        }
+
+        // Check for database migrations
+        spinner.start('Checking database migrations...');
+
+        try {
+          const { MigrationRunner } = await import('../db/migrations/index.js');
+          const { DatabaseClient: DBClientClass } = await import('../db/client.js');
+
+          const db = await DBClientClass.create(targetDir);
+          const runner = new MigrationRunner(db, targetDir);
+
+          const migrationStatus = await runner.getStatus();
+
+          if (migrationStatus.needsMigration) {
+            spinner.stop();
+
+            console.log('');
+            console.log(chalk.yellow(`⚠ Database schema updates available: ${migrationStatus.currentVersion || 'none'} → ${migrationStatus.targetVersion}`));
+            console.log('');
+            console.log(chalk.bold('Pending migrations:'));
+            for (const migration of migrationStatus.pending) {
+              const breaks = migration.breaks ? chalk.red(' [breaking]') : '';
+              console.log(chalk.dim(`  • ${migration.version}: ${migration.description}${breaks}`));
+            }
+            console.log('');
+
+            const { confirm } = await import('@inquirer/prompts');
+            const shouldMigrate = await confirm({
+              message: 'Apply database migrations now?',
+              default: true
+            });
+
+            if (shouldMigrate) {
+              spinner.start('Applying migrations...');
+
+              const migrationResults = await runner.migrate({
+                backup: true,
+                onProgress: (current, total, migration) => {
+                  spinner.text = `Applying ${current}/${total}: ${migration.description}`;
+                }
+              });
+
+              const successful = migrationResults.filter(r => r.success).length;
+              const failed = migrationResults.filter(r => !r.success).length;
+
+              if (failed === 0) {
+                spinner.succeed(chalk.green(`Applied ${successful} migration(s)`));
+              } else {
+                spinner.warn(chalk.yellow(`Applied ${successful} migration(s), ${failed} failed`));
+                if (options.verbose) {
+                  for (const result of migrationResults) {
+                    if (!result.success) {
+                      console.log(chalk.red(`  ✗ ${result.version}: ${result.error}`));
+                    }
+                  }
+                }
+              }
+            } else {
+              spinner.start('Continuing...');
+              spinner.succeed('Database migrations skipped');
+              console.log(chalk.dim('\n  Run: k0ntext migrate up\n'));
+            }
+          } else {
+            spinner.succeed('Database schema up to date');
+          }
+
+          db.close();
+        } catch (error) {
+          spinner.warn(`Database migration check failed: ${error instanceof Error ? error.message : error}`);
+          if (options.verbose) {
+            console.warn(chalk.dim(`  ${error instanceof Error ? error.stack : error}`));
+          }
+        }
+
+        // Check for outdated context files
+        if (options.versionCheck !== false) {
+          spinner.start('Checking context file versions...');
+
+          try {
+            const { checkContextFiles, showVersionSummary, promptRegeneration } = await import('./version/index.js');
+            const { DatabaseClient: DBClientClass } = await import('../db/client.js');
+
+            let db: DatabaseClient | undefined;
+            try {
+              db = new DBClientClass(targetDir);
+            } catch {
+              // Database might not exist yet
+            }
+
+            const result = await checkContextFiles({
+              projectRoot: targetDir,
+              currentVersion: packageJson.version,
+              checkModifications: !!db
+            }, db);
+
+            spinner.stop();
+
+            if (result.outdated.length > 0) {
+              showVersionSummary(result);
+              console.log('');
+
+              const promptResult = await promptRegeneration(result.outdated);
+
+              if (promptResult.choice !== 'skip') {
+                let filesToRegenerate = result.outdated;
+
+                if (promptResult.choice === 'select' && promptResult.selectedTools) {
+                  filesToRegenerate = result.outdated.filter(f =>
+                    promptResult.selectedTools?.includes(f.tool)
+                  );
+                }
+
+                if (!promptResult.includeModified) {
+                  filesToRegenerate = filesToRegenerate.filter(f => !f.userModified);
+                }
+
+                if (filesToRegenerate.length > 0 && db) {
+                  spinner.start('Regenerating context files...');
+
+                  const { generateForTool } = await import('./generate.js');
+
+                  for (const file of filesToRegenerate) {
+                    spinner.text = `Regenerating ${file.tool} context...`;
+                    try {
+                      await generateForTool(file.tool, db, true, false, { verbose: options.verbose });
+                    } catch (error) {
+                      spinner.warn(chalk.yellow(`Failed to regenerate ${file.tool}`));
+                    }
+                  }
+
+                  spinner.succeed(chalk.green(`Regenerated ${filesToRegenerate.length} file(s)`));
+                }
+              }
+            } else {
+              spinner.stop();
+            }
+
+            if (db) {
+              db.close();
+            }
+          } catch (error) {
+            spinner.stop();
+            // Version check is optional, don't fail on error
+            if (options.verbose) {
+              console.warn(chalk.dim(`Version check skipped: ${error instanceof Error ? error.message : error}`));
+            }
+          }
+        }
+
         console.log(`\n${chalk.bold('Next Steps:')}`);
         console.log(`  ${chalk.cyan('1.')} Run ${chalk.white('k0ntext stats')} to view database statistics`);
         console.log(`  ${chalk.cyan('2.')} Run ${chalk.white('k0ntext mcp')} to start the MCP server`);
@@ -223,7 +423,7 @@ function createProgram(): Command {
   program
     .command('mcp')
     .description('Start the MCP server for AI tools to connect')
-    .option('--db <path>', 'Database file path', '.ai-context.db')
+    .option('--db <path>', 'Database file path', '.k0ntext.db')
     .action(async (options) => {
       const projectRoot = process.cwd();
       
@@ -277,6 +477,20 @@ function createProgram(): Command {
   // ==================== Fact-Check Command ====================
   program.addCommand(factCheckCommand);
 
+  // ==================== Version Check Command ====================
+  program.addCommand(versionCheckCommand);
+
+  // ==================== Restore Command ====================
+  program.addCommand(restoreCommand);
+
+  // ==================== Template Sync Commands ====================
+  program.addCommand(syncTemplatesCommand);
+  program.addCommand(templateStatusCommand);
+
+  // ==================== Migration Commands ====================
+  program.addCommand(migrateCommand);
+  program.addCommand(embeddingsRefreshCommand);
+
   // ==================== Index Command ====================
   program
     .command('index')
@@ -290,6 +504,7 @@ function createProgram(): Command {
       showBanner();
 
       const spinner = ora();
+      const verbose = options.verbose || false;
       let db: any;
       
       try {
@@ -317,6 +532,11 @@ function createProgram(): Command {
 
           // Store docs in database
           for (const doc of docs) {
+            if (verbose) {
+              spinner.stop();
+              console.log(chalk.dim(`  Indexing: ${doc.relativePath}`));
+              spinner.start();
+            }
             const content = fs.existsSync(doc.path) ? fs.readFileSync(doc.path, 'utf-8').slice(0, 50000) : '';
             const item = db.upsertItem({
               type: 'doc',
@@ -332,6 +552,11 @@ function createProgram(): Command {
 
           // Store tool configs in database
           for (const config of tools) {
+            if (verbose) {
+              spinner.stop();
+              console.log(chalk.dim(`  Indexing: ${config.relativePath}`));
+              spinner.start();
+            }
             const content = fs.existsSync(config.path) ? fs.readFileSync(config.path, 'utf-8').slice(0, 50000) : '';
             const item = db.upsertItem({
               type: 'tool_config',
@@ -348,6 +573,11 @@ function createProgram(): Command {
           // Store code in database (first N files to avoid overwhelming the db)
           const maxCodeFiles = 100;
           for (const codeFile of code.slice(0, maxCodeFiles)) {
+            if (verbose) {
+              spinner.stop();
+              console.log(chalk.dim(`  Indexing: ${codeFile.relativePath}`));
+              spinner.start();
+            }
             const content = fs.existsSync(codeFile.path) ? fs.readFileSync(codeFile.path, 'utf-8').slice(0, 20000) : '';
             const item = db.upsertItem({
               type: 'code',
@@ -369,6 +599,11 @@ function createProgram(): Command {
             discoveredCount += docs.length;
             spinner.text = `Indexing ${docs.length} docs...`;
             for (const doc of docs) {
+              if (verbose) {
+                spinner.stop();
+                console.log(chalk.dim(`  Indexing: ${doc.relativePath}`));
+                spinner.start();
+              }
               const content = fs.existsSync(doc.path) ? fs.readFileSync(doc.path, 'utf-8').slice(0, 50000) : '';
               const item = db.upsertItem({
                 type: 'doc',
@@ -388,6 +623,11 @@ function createProgram(): Command {
             const maxCodeFiles = 100;
             spinner.text = `Indexing code files...`;
             for (const codeFile of code.slice(0, maxCodeFiles)) {
+              if (verbose) {
+                spinner.stop();
+                console.log(chalk.dim(`  Indexing: ${codeFile.relativePath}`));
+                spinner.start();
+              }
               const content = fs.existsSync(codeFile.path) ? fs.readFileSync(codeFile.path, 'utf-8').slice(0, 20000) : '';
               const item = db.upsertItem({
                 type: 'code',
@@ -409,6 +649,11 @@ function createProgram(): Command {
             discoveredCount += tools.length;
             spinner.text = `Indexing ${tools.length} tool configs...`;
             for (const config of tools) {
+              if (verbose) {
+                spinner.stop();
+                console.log(chalk.dim(`  Indexing: ${config.relativePath}`));
+                spinner.start();
+              }
               const content = fs.existsSync(config.path) ? fs.readFileSync(config.path, 'utf-8').slice(0, 50000) : '';
               const item = db.upsertItem({
                 type: 'tool_config',

package/src/cli/repl/index.ts

@@ -39,6 +39,7 @@ export class REPLShell {
   private readline: readline.Interface;
   private isActive: boolean = false;
   private noTUI: boolean;
+  private readlineClosed: boolean = false;
 
   // Enhanced panels
   private searchPanel: AdvancedSearchPanel;
@@ -84,12 +85,12 @@ export class REPLShell {
    */
   private setupEventHandlers(): void {
     this.readline.on('line', async (input) => {
-      if (!this.isActive) return;
+      if (!this.isActive || this.readlineClosed) return;
 
       const trimmed = input.trim();
 
       if (!trimmed) {
-        this.readline.prompt();
+        if (!this.readlineClosed) this.readline.prompt();
         return;
       }
 
@@ -121,16 +122,17 @@ export class REPLShell {
         console.log(K0NTEXT_THEME.warning('\n⚠ Invalid command. Type "help" for available commands.'));
       }
 
-      this.readline.prompt();
+      if (!this.readlineClosed) this.readline.prompt();
     });
 
     this.readline.on('SIGINT', async () => {
       console.log('');
       console.log(K0NTEXT_THEME.warning('\n⚠ Use "exit" to quit the REPL.'));
-      this.readline.prompt();
+      if (!this.readlineClosed) this.readline.prompt();
     });
 
     this.readline.on('close', async () => {
+      this.readlineClosed = true;
       await this.stop();
     });
   }
@@ -519,11 +521,19 @@ export class REPLShell {
    * Stop the REPL
    */
   async stop(): Promise<void> {
+    if (!this.isActive) return; // Already stopping
     this.isActive = false;
     this.session.end();
+    this.readlineClosed = true;
+
+    // Only print goodbye if not in piped mode
+    const isPiped = !process.stdin.isTTY;
     this.readline.close();
-    console.log('');
-    console.log(K0NTEXT_THEME.success('✓ Session saved. Goodbye!'));
+
+    if (!isPiped) {
+      console.log('');
+      console.log(K0NTEXT_THEME.success('✓ Session saved. Goodbye!'));
+    }
   }
 
   /**

package/src/cli/utils/backup-manager.ts

@@ -0,0 +1,275 @@
+/**
+ * Backup Manager
+ *
+ * Manages backups of generated context files before overwriting.
+ * Supports both file-copy and git-stash based backup strategies.
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { execSync } from 'child_process';
+import type { DatabaseClient } from '../../db/client.js';
+
+/**
+ * Backup result
+ */
+export interface BackupResult {
+  /** Whether backup was successful */
+  success: boolean;
+  /** Path to backup file */
+  backupPath?: string;
+  /** Backup method used */
+  method: 'file-copy' | 'git-stash' | 'none';
+  /** Error message if failed */
+  error?: string;
+}
+
+/**
+ * Backup manager options
+ */
+export interface BackupManagerOptions {
+  /** Base directory for backups (default: .k0ntext/backups) */
+  backupDir?: string;
+  /** Use git stash if available (default: true) */
+  useGitStash?: boolean;
+}
+
+/**
+ * Backup manager
+ *
+ * Creates and manages backups of generated files.
+ */
+export class BackupManager {
+  private db: DatabaseClient;
+  private projectRoot: string;
+  private backupDir: string;
+  private useGitStash: boolean;
+
+  constructor(db: DatabaseClient, projectRoot: string, options: BackupManagerOptions = {}) {
+    this.db = db;
+    this.projectRoot = projectRoot;
+    this.backupDir = options.backupDir || path.join(projectRoot, '.k0ntext', 'backups');
+    this.useGitStash = options.useGitStash !== false;
+  }
+
+  /**
+   * Create a backup of a file before overwriting
+   *
+   * @param filePath - Path to file to backup (can be relative or absolute)
+   * @param tool - Tool name for organization
+   * @returns Backup result
+   */
+  async createBackup(filePath: string, tool: string): Promise<BackupResult> {
+    const fullPath = path.isAbsolute(filePath) ? filePath : path.join(this.projectRoot, filePath);
+
+    try {
+      // Check if file exists
+      try {
+        await fs.access(fullPath);
+      } catch {
+        // File doesn't exist, no backup needed
+        return { success: true, method: 'none' };
+      }
+
+      // Try git stash first if enabled
+      if (this.useGitStash && await this.isGitRepository()) {
+        const stashResult = await this.backupWithGitStash(fullPath, tool);
+        if (stashResult.success) {
+          return stashResult;
+        }
+        // Fall back to file copy if git stash fails
+      }
+
+      // Fall back to file copy
+      return await this.backupWithFileCopy(fullPath, tool);
+    } catch (error) {
+      return {
+        success: false,
+        method: 'none',
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+
+  /**
+   * Restore a file from backup
+   *
+   * @param backupPath - Path to backup file
+   * @param targetPath - Path to restore to (can be relative or absolute)
+   * @returns True if restore was successful
+   */
+  async restoreFromBackup(backupPath: string, targetPath: string): Promise<boolean> {
+    const fullTargetPath = path.isAbsolute(targetPath) ? targetPath : path.join(this.projectRoot, targetPath);
+
+    try {
+      // Ensure target directory exists
+      await fs.mkdir(path.dirname(fullTargetPath), { recursive: true });
+
+      // Copy backup to target
+      await fs.copyFile(backupPath, fullTargetPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * List all backups for a tool
+   *
+   * @param tool - Tool name
+   * @returns Array of backup paths
+   */
+  async listBackups(tool: string): Promise<string[]> {
+    const toolBackupDir = path.join(this.backupDir, tool);
+
+    try {
+      await fs.access(toolBackupDir);
+    } catch {
+      return [];
+    }
+
+    const entries = await fs.readdir(toolBackupDir, { withFileTypes: true });
+    return entries
+      .filter(e => e.isFile())
+      .map(e => path.join(toolBackupDir, e.name));
+  }
+
+  /**
+   * Backup using file copy strategy
+   *
+   * @param fullPath - Full path to file
+   * @param tool - Tool name
+   * @returns Backup result
+   */
+  private async backupWithFileCopy(fullPath: string, tool: string): Promise<BackupResult> {
+    try {
+      // Create backup directory
+      const toolBackupDir = path.join(this.backupDir, tool);
+      await fs.mkdir(toolBackupDir, { recursive: true });
+
+      // Generate backup filename with timestamp
+      const fileName = path.basename(fullPath);
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const backupFileName = `${fileName}.${timestamp}.bak`;
+      const backupPath = path.join(toolBackupDir, backupFileName);
+
+      // Copy file
+      await fs.copyFile(fullPath, backupPath);
+
+      // Update database with backup path
+      const relativePath = path.relative(this.projectRoot, fullPath);
+      const record = this.db.getGeneratedFileInfo(tool, relativePath);
+      if (record) {
+        this.db.upsertGeneratedFile({
+          tool,
+          filePath: relativePath,
+          contentHash: record.contentHash,
+          backupPath
+        });
+      }
+
+      return {
+        success: true,
+        backupPath,
+        method: 'file-copy'
+      };
+    } catch (error) {
+      return {
+        success: false,
+        method: 'none',
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+
+  /**
+   * Backup using git stash strategy
+   *
+   * @param fullPath - Full path to file
+   * @param tool - Tool name
+   * @returns Backup result
+   */
+  private async backupWithGitStash(fullPath: string, tool: string): Promise<BackupResult> {
+    try {
+      const relativePath = path.relative(this.projectRoot, fullPath);
+
+      // Create a stash with a descriptive message
+      const stashMessage = `k0ntext-backup-${tool}-${Date.now()}`;
+      const stashCommand = `git stash push -m "${stashMessage}" -- "${relativePath}"`;
+
+      execSync(stashCommand, { cwd: this.projectRoot, stdio: 'pipe' });
+
+      // Get the stash hash for reference
+      const listCommand = 'git stash list --grep="^k0ntext-backup" -n 1';
+      const stashList = execSync(listCommand, { cwd: this.projectRoot, encoding: 'utf-8' });
+      const stashRef = stashList.split(':')[0].trim();
+
+      // Update database with stash reference
+      const record = this.db.getGeneratedFileInfo(tool, relativePath);
+      if (record) {
+        this.db.upsertGeneratedFile({
+          tool,
+          filePath: relativePath,
+          contentHash: record.contentHash,
+          backupPath: `git-stash:${stashRef}`
+        });
+      }
+
+      return {
+        success: true,
+        backupPath: `git-stash:${stashRef}`,
+        method: 'git-stash'
+      };
+    } catch {
+      return {
+        success: false,
+        method: 'none',
+        error: 'Git stash failed'
+      };
+    }
+  }
+
+  /**
+   * Check if current directory is a git repository
+   *
+   * @returns True if git repository
+   */
+  private async isGitRepository(): Promise<boolean> {
+    try {
+      const gitDir = path.join(this.projectRoot, '.git');
+      await fs.access(gitDir);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Clean up old backups
+   *
+   * @param tool - Tool name (optional, if not provided cleans all)
+   * @param keepLast - Number of recent backups to keep (default: 5)
+   */
+  async cleanupOldBackups(tool?: string, keepLast = 5): Promise<void> {
+    const tools = tool ? [tool] : ['claude', 'copilot', 'cline', 'antigravity', 'windsurf', 'aider', 'continue', 'cursor', 'gemini'];
+
+    for (const toolName of tools) {
+      const backups = await this.listBackups(toolName);
+
+      if (backups.length > keepLast) {
+        // Sort by name (which includes timestamp)
+        backups.sort();
+
+        // Delete oldest backups
+        const toDelete = backups.slice(0, backups.length - keepLast);
+        for (const backupPath of toDelete) {
+          try {
+            await fs.unlink(backupPath);
+          } catch {
+            // Ignore errors during cleanup
+          }
+        }
+      }
+    }
+  }
+}