k0ntext 3.3.1 → 3.6.0

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

@@ -0,0 +1,146 @@
+/**
+ * Database Backup Manager
+ *
+ * Manages database backups for migration safety.
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import type { DatabaseClient } from '../../db/client.js';
+
+/**
+ * Backup result
+ */
+export interface DbBackupResult {
+  /** Whether backup was successful */
+  success: boolean;
+  /** Path to backup file */
+  backupPath?: string;
+  /** Size of backup in bytes */
+  size?: number;
+  /** Error message if failed */
+  error?: string;
+}
+
+/**
+ * Database backup manager
+ *
+ * Creates and manages backups of the SQLite database for migration safety.
+ */
+export class DbBackupManager {
+  private db: DatabaseClient;
+  private projectRoot: string;
+  private readonly BACKUP_DIR = '.k0ntext/db-backups';
+  private readonly KEEP_BACKUPS = 5;
+
+  constructor(db: DatabaseClient, projectRoot: string) {
+    this.db = db;
+    this.projectRoot = projectRoot;
+  }
+
+  /**
+   * Create a backup of the database
+   *
+   * @returns Backup result
+   */
+  async createBackup(): Promise<DbBackupResult> {
+    try {
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const backupFileName = `db-${timestamp}.db`;
+      const backupPath = path.join(this.projectRoot, this.BACKUP_DIR, backupFileName);
+
+      // Ensure backup directory exists
+      await fs.mkdir(path.dirname(backupPath), { recursive: true });
+
+      // Use existing backup method from DatabaseClient
+      this.db.backup(backupPath);
+
+      // Get file size
+      const stats = await fs.stat(backupPath);
+
+      // Clean old backups (keep last 5)
+      await this.cleanupOldBackups();
+
+      return {
+        success: true,
+        backupPath,
+        size: stats.size
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+
+  /**
+   * List all database backups
+   *
+   * @returns Array of backup file names
+   */
+  async listBackups(): Promise<string[]> {
+    const backupDir = path.join(this.projectRoot, this.BACKUP_DIR);
+
+    try {
+      await fs.access(backupDir);
+    } catch {
+      return [];
+    }
+
+    const files = await fs.readdir(backupDir);
+    return files
+      .filter(f => f.endsWith('.db'))
+      .sort()
+      .reverse();
+  }
+
+  /**
+   * Restore from a backup
+   *
+   * @param backupFileName - Name of backup file to restore
+   * @returns True if restore was successful
+   */
+  async restoreFromBackup(backupFileName: string): Promise<boolean> {
+    const backupDir = path.join(this.projectRoot, this.BACKUP_DIR);
+    const backupPath = path.join(backupDir, backupFileName);
+
+    try {
+      // Verify backup exists
+      await fs.access(backupPath);
+
+      // Get database path from DatabaseClient
+      const dbPath = (this.db as any).dbPath;
+
+      // Copy backup to main database location
+      await fs.copyFile(backupPath, dbPath);
+
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Clean up old backups (keep last 5)
+   */
+  private async cleanupOldBackups(): Promise<void> {
+    const backupDir = path.join(this.projectRoot, this.BACKUP_DIR);
+
+    try {
+      const files = await fs.readdir(backupDir);
+      const backups = files
+        .filter(f => f.endsWith('.db'))
+        .sort();
+
+      // Keep last 5
+      const toDelete = backups.slice(0, backups.length - this.KEEP_BACKUPS);
+
+      for (const file of toDelete) {
+        await fs.unlink(path.join(backupDir, file));
+      }
+    } catch {
+      // Ignore cleanup errors
+    }
+  }
+}

package/src/cli/utils/file-detector.ts

@@ -0,0 +1,181 @@
+/**
+ * File Modification Detector
+ *
+ * Detects when user has modified generated context files.
+ * Uses content hashing for efficient change detection.
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import type { DatabaseClient } from '../../db/client.js';
+
+/**
+ * File modification status
+ */
+export interface FileModificationStatus {
+  /** Tool name */
+  tool: string;
+  /** Full file path */
+  filePath: string;
+  /** Whether file exists on disk */
+  exists: boolean;
+  /** Whether file was generated by k0ntext */
+  wasGenerated: boolean;
+  /** Current content hash */
+  currentHash: string | null;
+  /** Hash stored in database when generated */
+  storedHash: string | null;
+  /** Whether file has been modified since generation */
+  isModified: boolean;
+  /** Last time file was generated */
+  generatedAt?: string;
+  /** Last time file was verified */
+  lastVerifiedAt?: string;
+}
+
+/**
+ * File modification detector options
+ */
+export interface ModificationDetectorOptions {
+  /** Include files that don't exist in results */
+  includeNonExistent?: boolean;
+}
+
+/**
+ * File modification detector
+ *
+ * Checks if user has modified generated context files.
+ */
+export class FileModificationDetector {
+  private db: DatabaseClient;
+  private projectRoot: string;
+
+  constructor(db: DatabaseClient, projectRoot: string = process.cwd()) {
+    this.db = db;
+    this.projectRoot = projectRoot;
+  }
+
+  /**
+   * Convert absolute path to relative path for database lookup
+   */
+  private toRelativePath(filePath: string): string {
+    if (path.isAbsolute(filePath)) {
+      return path.relative(this.projectRoot, filePath);
+    }
+    return filePath;
+  }
+
+  /**
+   * Check a single file for modifications
+   *
+   * @param tool - Tool name
+   * @param filePath - Full path to file
+   * @returns File modification status
+   */
+  async checkFile(tool: string, filePath: string): Promise<FileModificationStatus> {
+    // Check if file exists
+    let exists = false;
+    let currentContent = '';
+    try {
+      currentContent = await fs.readFile(filePath, 'utf-8');
+      exists = true;
+    } catch {
+      // File doesn't exist
+    }
+
+    // Get current hash
+    const currentHash = exists ? this.db.hashContent(currentContent) : null;
+
+    // Get stored record - convert absolute path to relative for lookup
+    const relativePath = this.toRelativePath(filePath);
+    const stored = this.db.getGeneratedFileInfo(tool, relativePath);
+
+    const wasGenerated = stored !== null;
+    const storedHash = stored?.contentHash || null;
+    const isModified = storedHash !== null && currentHash !== null && currentHash !== storedHash;
+
+    return {
+      tool,
+      filePath,
+      exists,
+      wasGenerated,
+      currentHash,
+      storedHash,
+      isModified,
+      generatedAt: stored?.generatedAt,
+      lastVerifiedAt: stored?.lastVerifiedAt
+    };
+  }
+
+  /**
+   * Check all generated files for modifications
+   *
+   * @param options - Detector options
+   * @returns Array of file modification statuses
+   */
+  async checkAll(options: ModificationDetectorOptions = {}): Promise<FileModificationStatus[]> {
+    const results: FileModificationStatus[] = [];
+
+    // Get all tracked tools
+    const tools = ['claude', 'copilot', 'cline', 'antigravity', 'windsurf', 'aider', 'continue', 'cursor', 'gemini'];
+
+    for (const tool of tools) {
+      const generatedFiles = this.db.getGeneratedFiles(tool);
+
+      for (const file of generatedFiles) {
+        // Convert relative path to absolute for file operations
+        const absolutePath = path.isAbsolute(file.filePath)
+          ? file.filePath
+          : path.join(this.projectRoot, file.filePath);
+
+        const status = await this.checkFile(file.tool, absolutePath);
+
+        if (options.includeNonExistent || status.exists) {
+          results.push(status);
+        }
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Get only modified files
+   *
+   * @returns Array of modified file statuses
+   */
+  async getModifiedFiles(): Promise<FileModificationStatus[]> {
+    const all = await this.checkAll();
+    return all.filter(f => f.isModified);
+  }
+
+  /**
+   * Mark a file as verified (update last_verified_at)
+   *
+   * @param tool - Tool name
+   * @param filePath - Full path to file
+   */
+  markAsVerified(tool: string, filePath: string): void {
+    const relativePath = this.toRelativePath(filePath);
+    const record = this.db.getGeneratedFileInfo(tool, relativePath);
+    if (record) {
+      this.db.upsertGeneratedFile({
+        tool,
+        filePath: relativePath,
+        contentHash: record.contentHash,
+        backupPath: record.backupPath
+      });
+    }
+  }
+
+  /**
+   * Mark a file as user-modified
+   *
+   * @param tool - Tool name
+   * @param filePath - Full path to file
+   */
+  markAsModified(tool: string, filePath: string): void {
+    const relativePath = this.toRelativePath(filePath);
+    this.db.markUserModified(tool, relativePath);
+  }
+}

package/src/cli/utils/index.ts

@@ -0,0 +1,9 @@
+/**
+ * CLI Utilities Module
+ *
+ * Exports all utility functions and classes.
+ */
+
+export * from './file-detector.js';
+export * from './backup-manager.js';
+export * from './modification-prompt.js';

package/src/cli/utils/modification-prompt.ts

@@ -0,0 +1,112 @@
+/**
+ * Modification Prompt
+ *
+ * Interactive prompts for handling user-modified files.
+ */
+
+import chalk from 'chalk';
+import { confirm, select } from '@inquirer/prompts';
+import type { FileModificationStatus } from './file-detector.js';
+
+/**
+ * Modification prompt options
+ */
+export interface ModificationPromptOptions {
+  /** Modified file to prompt about */
+  file: FileModificationStatus;
+  /** Default choice */
+  defaultChoice?: 'skip' | 'backup' | 'overwrite';
+}
+
+/**
+ * Prompt result for single file
+ */
+export type PromptResult = 'skip' | 'backup' | 'overwrite' | 'cancel';
+
+/**
+ * Prompt for single file modification
+ *
+ * @param options - Prompt options
+ * @returns User's choice
+ */
+export async function promptFileModification(options: ModificationPromptOptions): Promise<PromptResult> {
+  const { file } = options;
+
+  console.log('');
+  console.log(chalk.yellow('⚠ Modified file detected:'), chalk.bold(path.basename(file.filePath)));
+  console.log(chalk.dim(`Path: ${file.filePath}`));
+  console.log(chalk.dim(`This file was generated by k0ntext but has been modified.`));
+  console.log('');
+
+  const choice = await select<PromptResult>({
+    message: 'What would you like to do?',
+    choices: [
+      {
+        name: 'Skip this file (keep current version)',
+        value: 'skip',
+        description: 'Leave the file as-is and continue'
+      },
+      {
+        name: 'Backup then overwrite',
+        value: 'backup',
+        description: 'Create a backup of current version, then regenerate'
+      },
+      {
+        name: 'Overwrite without backup',
+        value: 'overwrite',
+        description: 'Discard current changes and regenerate (no backup)'
+      },
+      {
+        name: 'Cancel generation',
+        value: 'cancel',
+        description: 'Stop the generation process'
+      }
+    ],
+    default: options.defaultChoice || 'skip'
+  });
+
+  return choice;
+}
+
+/**
+ * Show a summary of modified files
+ *
+ * @param modifications - Array of modification statuses
+ * @returns True if user wants to proceed
+ */
+export async function showSummary(modifications: FileModificationStatus[]): Promise<boolean> {
+  if (modifications.length === 0) {
+    return true;
+  }
+
+  console.log('');
+  console.log(chalk.yellow(`⚠ ${modifications.length} modified file(s) detected:`));
+  console.log('');
+
+  for (const mod of modifications) {
+    console.log(chalk.dim('  •'), mod.filePath);
+  }
+
+  console.log('');
+
+  const proceed = await confirm({
+    message: 'These files have custom modifications. Continue?',
+    default: false
+  });
+
+  return proceed;
+}
+
+/**
+ * Format modification status for display
+ *
+ * @param status - Modification status
+ * @returns Formatted string
+ */
+export function formatModificationStatus(status: FileModificationStatus): string {
+  const icon = status.isModified ? '⚠' : '✓';
+  const modified = status.isModified ? chalk.yellow('modified') : chalk.green('unmodified');
+  return `${icon} ${status.filePath} (${modified})`;
+}
+
+import path from 'path';

package/src/cli/version/checker.ts

@@ -0,0 +1,172 @@
+/**
+ * Version Checker
+ *
+ * Checks context files for outdated versions.
+ * Integrates with database for efficient caching.
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import type { DatabaseClient } from '../../db/client.js';
+import { parseVersion, hasVersionMarker } from './parser.js';
+import { needsUpdate, getUpdateType } from './comparator.js';
+import type {
+  CheckOptions,
+  FileVersionStatus,
+  VersionCheckResult,
+  OutdatedFile
+} from './types.js';
+
+/**
+ * Tool to file path mappings
+ */
+const TOOL_FILES: Record<string, string[]> = {
+  claude: ['AI_CONTEXT.md', 'CLAUDE.md', '.claude/AI_CONTEXT.md'],
+  copilot: ['.github/copilot-instructions.md'],
+  cline: ['.clinerules'],
+  antigravity: ['.agent/README.md'],
+  windsurf: ['.windsurf/rules.md'],
+  aider: ['.aider.conf.yml'],
+  continue: ['.continue/config.json'],
+  cursor: ['.cursorrules'],
+  gemini: ['.gemini/config.md']
+};
+
+/**
+ * Check a single file for version status
+ *
+ * @param filePath - Full path to the file
+ * @param tool - Tool name
+ * @param currentVersion - Current k0ntext version
+ * @param db - Database client (optional, for modification detection)
+ * @returns File version status
+ */
+export async function checkSingleFile(
+  filePath: string,
+  tool: string,
+  currentVersion: string,
+  db?: DatabaseClient
+): Promise<FileVersionStatus> {
+  // Check if file exists
+  let exists = false;
+  let content = '';
+  try {
+    content = await fs.readFile(filePath, 'utf-8');
+    exists = true;
+  } catch {
+    // File doesn't exist
+  }
+
+  // Check for version marker
+  const hasMarker = hasVersionMarker(content);
+  const fileVersion = parseVersion(content);
+
+  // Determine if outdated
+  const isOutdated = fileVersion ? needsUpdate(fileVersion, currentVersion) : false;
+  const updateType = fileVersion ? getUpdateType(fileVersion, currentVersion) : 'none';
+
+  // Check if user modified (from database)
+  let userModified = false;
+  if (db && exists) {
+    const tracked = db.getGeneratedFileInfo(tool, filePath);
+    if (tracked?.userModified) {
+      userModified = true;
+    }
+  }
+
+  return {
+    tool,
+    filePath,
+    exists,
+    fileVersion,
+    hasMarker,
+    isOutdated,
+    updateType,
+    userModified
+  };
+}
+
+/**
+ * Check all context files for version status
+ *
+ * @param options - Check options
+ * @param db - Database client (optional)
+ * @returns Version check result
+ */
+export async function checkContextFiles(
+  options: CheckOptions,
+  db?: DatabaseClient
+): Promise<VersionCheckResult> {
+  const { projectRoot, currentVersion, tools: toolsToCheck } = options;
+
+  const tools = toolsToCheck || Object.keys(TOOL_FILES);
+  const results: VersionCheckResult = {
+    currentVersion,
+    checked: 0,
+    outdated: [],
+    upToDate: [],
+    noVersion: []
+  };
+
+  for (const tool of tools) {
+    const files = TOOL_FILES[tool] || [];
+    const toolName = tool;
+
+    for (const relativePath of files) {
+      const fullPath = path.join(projectRoot, relativePath);
+
+      const status = await checkSingleFile(fullPath, toolName, currentVersion, db);
+      results.checked++;
+
+      if (!status.exists) {
+        continue; // Skip non-existent files
+      }
+
+      if (status.isOutdated) {
+        results.outdated.push({
+          tool: status.tool,
+          filePath: status.filePath,
+          fileVersion: status.fileVersion || 'unknown',
+          currentVersion,
+          updateType: status.updateType,
+          userModified: status.userModified
+        });
+      } else if (status.hasMarker) {
+        results.upToDate.push(status);
+      } else {
+        results.noVersion.push(status);
+      }
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Get all context file paths for a tool
+ *
+ * @param tool - Tool name
+ * @returns Array of file paths
+ */
+export function getToolFiles(tool: string): string[] {
+  return TOOL_FILES[tool] || [];
+}
+
+/**
+ * Check if a tool is supported
+ *
+ * @param tool - Tool name
+ * @returns True if supported
+ */
+export function isSupportedTool(tool: string): boolean {
+  return tool in TOOL_FILES;
+}
+
+/**
+ * Get all supported tools
+ *
+ * @returns Array of tool names
+ */
+export function getSupportedTools(): string[] {
+  return Object.keys(TOOL_FILES);
+}