k0ntext 3.0.0

package/src/cli/sync.ts

@@ -0,0 +1,194 @@
+import { Command } from 'commander';
+import { DatabaseClient } from '../db/client.js';
+import ora from 'ora';
+import chalk from 'chalk';
+import crypto from 'crypto';
+import fs from 'fs/promises';
+
+export interface SyncStatus {
+  synced: boolean;
+  differences: string[];
+}
+
+export interface SyncResult {
+  count: number;
+  files: string[];
+}
+
+export const syncCommand = new Command('sync')
+  .description('Synchronize context across all AI tools')
+  .option('--check', 'Only check synchronization status')
+  .option('--from <tool>', 'Sync from specific tool')
+  .option('--to <tool>', 'Sync to specific tool')
+  .option('--force', 'Force sync even if up-to-date')
+  .action(async (options) => {
+    const spinner = ora('Checking sync status...').start();
+
+    try {
+      const db = new DatabaseClient(process.cwd());
+      const syncManager = new SyncManager(db);
+
+      if (options.check) {
+        const status = await syncManager.checkStatus();
+        if (status.synced) {
+          spinner.succeed(chalk.green('All tools are synchronized'));
+        } else {
+          spinner.warn(chalk.yellow('Tools are out of sync'));
+          console.log(chalk.dim('Differences:'), status.differences.join(', '));
+        }
+        return;
+      }
+
+      if (options.from) {
+        spinner.text = `Syncing from ${options.from}...`;
+        await syncManager.syncFrom(options.from);
+        spinner.succeed(chalk.green(`Synced from ${options.from}`));
+        return;
+      }
+
+      // Default: sync all tools
+      spinner.text = 'Syncing all tools...';
+      const result = await syncManager.syncAll({ force: options.force });
+      spinner.succeed(chalk.green(`Synced ${result.count} tools`));
+
+      if (result.files.length > 0) {
+        console.log(chalk.dim('Synced:'), result.files.join(', '));
+      }
+
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      spinner.fail(chalk.red('Sync failed'));
+      console.error(chalk.dim(errorMessage));
+      process.exit(1);
+    }
+  });
+
+export class SyncManager {
+  constructor(private db: DatabaseClient) {}
+
+  async checkStatus(): Promise<SyncStatus> {
+    const tools = await this.getToolFiles();
+    const hashes = await this.getFileHashes(tools);
+    const differences: string[] = [];
+
+    for (const [tool, hash] of Object.entries(hashes)) {
+      const stored = this.db.getSyncState(tool);
+      const storedHash = Array.isArray(stored) && stored.length > 0 ? stored[0]?.contentHash : undefined;
+      if (storedHash !== undefined && storedHash !== hash) {
+        differences.push(tool);
+      }
+    }
+
+    return {
+      synced: differences.length === 0,
+      differences
+    };
+  }
+
+  async syncFrom(tool: string): Promise<void> {
+    const configs = this.db.getToolConfigs(tool as any);
+    if (!configs || configs.length === 0) {
+      throw new Error(`Tool ${tool} not found in database`);
+    }
+
+    // Sync logic - propagate changes from this tool to others
+    const content = await this.readToolFile(tool);
+    await this.propagateToTools(tool, content);
+  }
+
+  async syncAll(options: { force?: boolean }): Promise<SyncResult> {
+    const tools = ['claude', 'copilot', 'cline', 'antigravity', 'windsurf', 'aider', 'continue', 'cursor', 'gemini'];
+    const synced = [];
+
+    for (const tool of tools) {
+      try {
+        await this.syncTool(tool, options);
+        synced.push(tool);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        // Continue with other tools even if one fails
+        console.error(chalk.dim(`Failed to sync ${tool}: ${errorMessage}`));
+      }
+    }
+
+    return { count: synced.length, files: synced };
+  }
+
+  private async getToolFiles(): Promise<string[]> {
+    return ['claude', 'copilot', 'cline', 'antigravity', 'windsurf', 'aider', 'continue', 'cursor', 'gemini'];
+  }
+
+  private async getFileHashes(tools: string[]): Promise<Record<string, string>> {
+    const hashes: Record<string, string> = {};
+    const toolPaths: Record<string, string> = {
+      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'
+    };
+
+    for (const tool of tools) {
+      try {
+        const content = await fs.readFile(toolPaths[tool], 'utf-8');
+        hashes[tool] = crypto.createHash('sha256').update(content).digest('hex');
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(
+          chalk.yellow(
+            `Warning: Failed to read tool file for "${tool}" at "${toolPaths[tool]}": ${message}`
+          )
+        );
+        hashes[tool] = '';
+      }
+    }
+
+    return hashes;
+  }
+
+  private async readToolFile(tool: string): Promise<string> {
+    const toolPaths: Record<string, string> = {
+      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'
+    };
+
+    return await fs.readFile(toolPaths[tool], 'utf-8');
+  }
+
+  private async propagateToTools(_fromTool: string, _content: string): Promise<void> {
+    // In a full implementation, this would parse the content
+    // and propagate it to all other tools
+    // For now, this is a placeholder
+    console.log(chalk.dim(`Propagating from ${_fromTool} to other tools...`));
+  }
+
+  private async syncTool(tool: string, options: { force?: boolean }): Promise<void> {
+    // Check if sync is needed
+    if (!options.force) {
+      const content = this.db.getAllItems();
+      if (content.length === 0) {
+        throw new Error(`No content in database for ${tool}`);
+      }
+    }
+
+    // Update sync state
+    this.db.updateSyncState({
+        id: `sync:${tool}`,
+        tool: tool,
+        contentHash: Date.now().toString(),
+        lastSync: new Date().toISOString(),
+        status: 'synced'
+    });
+  }
+}

package/src/config/cleanup-config.ts

@@ -0,0 +1,42 @@
+/**
+ * Cleanup configuration options
+ */
+
+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;
+}
+
+/**
+ * Default cleanup configuration
+ */
+export const DEFAULT_CLEANUP_CONFIG: CleanupConfig = {
+  dryRun: true,
+  defaultKeep: ['.github', '.vscode', '.idea', '.devcontainer'],
+  verbose: false,
+  maxDepth: 3,
+  timeout: 30000,
+  cwd: process.cwd()
+};
+
+/**
+ * Get cleanup configuration (can be extended to load from file)
+ */
+export function getCleanupConfig(): CleanupConfig {
+  return { ...DEFAULT_CLEANUP_CONFIG };
+}