k0ntext 3.0.0

package/src/cli/commands/export.ts

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+
+/**
+ * Export Command
+ *
+ * Exports context database to various formats (JSON, markdown).
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs';
+import path from 'path';
+
+export const exportCommand = new Command('export')
+  .description('Export context database to file')
+  .argument('<output>', 'Output file path')
+  .option('--format <format>', 'Export format (json, markdown)', 'json')
+  .option('--type <type>', 'Filter by context type')
+  .action(async (output, options) => {
+    const spinner = ora();
+    const projectRoot = process.cwd();
+
+    try {
+      spinner.start('Exporting database...');
+
+      const { DatabaseClient } = await import('../../db/client.js');
+      const db = new DatabaseClient(projectRoot);
+
+      const items = options.type
+        ? db.getItemsByType(options.type)
+        : db.getAllItems();
+
+      db.close();
+
+      const outputPath = path.resolve(projectRoot, output);
+
+      if (options.format === 'json') {
+        const exportData = {
+          version: '1.0.0',
+          exportedAt: new Date().toISOString(),
+          itemCount: items.length,
+          items: items.map(item => ({
+            id: item.id,
+            type: item.type,
+            name: item.name,
+            content: item.content,
+            metadata: item.metadata,
+            filePath: item.filePath
+          }))
+        };
+
+        fs.writeFileSync(outputPath, JSON.stringify(exportData, null, 2));
+      } else if (options.format === 'markdown') {
+        let markdown = `# K0ntext Export\n\n`;
+        markdown += `**Exported:** ${new Date().toISOString()}\n`;
+        markdown += `**Items:** ${items.length}\n\n`;
+
+        for (const item of items) {
+          markdown += `## ${item.name} (${item.type})\n\n`;
+          markdown += `**ID:** \`${item.id}\`\n\n`;
+          if (item.filePath) {
+            markdown += `**Path:** \`${item.filePath}\`\n\n`;
+          }
+          markdown += `${item.content}\n\n---\n\n`;
+        }
+
+        fs.writeFileSync(outputPath, markdown);
+      } else {
+        spinner.fail('Invalid format');
+        console.error(chalk.red(`\nError: Format must be 'json' or 'markdown'`));
+        process.exit(1);
+      }
+
+      spinner.succeed(`Exported ${items.length} items to ${outputPath}`);
+
+    } catch (error) {
+      spinner.fail('Export failed');
+      console.error(chalk.red(`\nError: ${error instanceof Error ? error.message : error}`));
+      process.exit(1);
+    }
+  });

package/src/cli/commands/import.ts

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+
+/**
+ * Import Command
+ *
+ * Imports context data from exported files.
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs';
+import path from 'path';
+
+export const importCommand = new Command('import')
+  .description('Import context data from file')
+  .argument('<input>', 'Input file path')
+  .option('--format <format>', 'Import format (json, markdown)', 'json')
+  .option('--merge', 'Merge with existing data (default: replace)')
+  .action(async (input, options) => {
+    const spinner = ora();
+    const projectRoot = process.cwd();
+
+    try {
+      const inputPath = path.resolve(projectRoot, input);
+
+      if (!fs.existsSync(inputPath)) {
+        spinner.fail('Input file not found');
+        console.error(chalk.red(`\nError: File not found: ${inputPath}`));
+        process.exit(1);
+      }
+
+      spinner.start('Importing data...');
+
+      const { DatabaseClient } = await import('../../db/client.js');
+      const db = new DatabaseClient(projectRoot);
+
+      let importCount = 0;
+
+      if (options.format === 'json') {
+        const content = fs.readFileSync(inputPath, 'utf-8');
+        const data = JSON.parse(content);
+
+        if (!data.items || !Array.isArray(data.items)) {
+          throw new Error('Invalid import file format');
+        }
+
+        for (const item of data.items) {
+          db.upsertItem({
+            type: item.type,
+            name: item.name,
+            content: item.content,
+            metadata: item.metadata,
+            filePath: item.filePath
+          });
+          importCount++;
+        }
+      } else {
+        spinner.fail('Markdown import not yet supported');
+        console.error(chalk.yellow(`\nNote: Only JSON format is currently supported for import.`));
+        process.exit(1);
+      }
+
+      db.close();
+
+      spinner.succeed(`Imported ${importCount} items from ${input}`);
+
+    } catch (error) {
+      spinner.fail('Import failed');
+      console.error(chalk.red(`\nError: ${error instanceof Error ? error.message : error}`));
+      process.exit(1);
+    }
+  });

package/src/cli/commands/performance.ts

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+
+/**
+ * Performance Command
+ *
+ * Display performance metrics and optimization suggestions.
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+
+export const performanceCommand = new Command('performance')
+  .description('Show performance metrics and suggestions')
+  .option('--json', 'Output as JSON')
+  .action(async (options) => {
+    try {
+      const { PerformanceMonitorAgent } = await import('../../agents/performance-agent.js');
+      const agent = new PerformanceMonitorAgent(process.cwd());
+
+      if (options.json) {
+        console.log(JSON.stringify(agent.getMetrics(), null, 2));
+      } else {
+        console.log(agent.generateReport());
+
+        const suggestions = agent.suggestOptimizations();
+        if (suggestions.length > 0) {
+          console.log(chalk.bold('\nOptimization Suggestions:'));
+          for (const suggestion of suggestions) {
+            console.log(`  ${chalk.cyan('•')} ${suggestion}`);
+          }
+        }
+      }
+
+      agent.close();
+
+    } catch (error) {
+      console.error(chalk.red(`\nError: ${error instanceof Error ? error.message : error}`));
+      process.exit(1);
+    }
+  });

package/src/cli/commands/validate.ts

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+/**
+ * Validate Command
+ *
+ * Validates context files and AI tool configurations for correctness.
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import path from 'path';
+import fs from 'fs';
+
+export const validateCommand = new Command('validate')
+  .description('Validate context files and configurations')
+  .option('--fix', 'Automatically fix validation errors when possible')
+  .option('--strict', 'Treat warnings as errors')
+  .action(async (options) => {
+    const spinner = ora();
+    const projectRoot = process.cwd();
+
+    try {
+      spinner.start('Validating context files...');
+
+      const { DatabaseClient } = await import('../../db/client.js');
+      const db = new DatabaseClient(projectRoot);
+
+      // First check database health
+      const health = db.healthCheck();
+      if (!health.healthy) {
+        spinner.fail('Database health check failed');
+        console.error(chalk.red(`\nError: ${health.error}`));
+        process.exit(1);
+      }
+
+      const issues: Array<{ file: string; issue: string; severity: 'error' | 'warning' }> = [];
+
+      // Validate context items
+      const items = db.getAllItems();
+      for (const item of items) {
+        if (item.filePath) {
+          const fullPath = path.join(projectRoot, item.filePath);
+          if (!fs.existsSync(fullPath)) {
+            issues.push({
+              file: item.filePath,
+              issue: 'File referenced in database does not exist',
+              severity: 'error'
+            });
+          }
+        }
+
+        // Validate content is not empty
+        if (!item.content || item.content.trim().length === 0) {
+          issues.push({
+            file: item.name,
+            issue: 'Content is empty',
+            severity: 'warning'
+          });
+        }
+      }
+
+      db.close();
+
+      spinner.stop();
+
+      if (issues.length === 0) {
+        console.log(chalk.green('\n✓ All validations passed!'));
+        return;
+      }
+
+      const errorCount = issues.filter(i => i.severity === 'error').length;
+      const warningCount = issues.filter(i => i.severity === 'warning').length;
+
+      console.log(chalk.bold(`\nValidation Results:`));
+      console.log(`  ${chalk.red('✖')} Errors: ${errorCount}`);
+      console.log(`  ${chalk.yellow('⚠')} Warnings: ${warningCount}`);
+
+      for (const issue of issues) {
+        const icon = issue.severity === 'error' ? chalk.red('✖') : chalk.yellow('⚠');
+        console.log(`\n  ${icon} ${issue.file}`);
+        console.log(`    ${issue.issue}`);
+      }
+
+      if (options.strict && warningCount > 0) {
+        process.exit(1);
+      }
+
+      if (errorCount > 0) {
+        process.exit(1);
+      }
+
+    } catch (error) {
+      spinner.fail('Validation failed');
+      console.error(chalk.red(`\nError: ${error instanceof Error ? error.message : error}`));
+      process.exit(1);
+    }
+  });

package/src/cli/commands/watch.ts

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+
+/**
+ * Watch Command
+ *
+ * Watch for file changes and automatically update the index.
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+
+export const watchCommand = new Command('watch')
+  .description('Watch for file changes and auto-update index')
+  .option('-d, --delay <ms>', 'Debounce delay in milliseconds', '1000')
+  .action(async (options) => {
+    const spinner = ora();
+    const projectRoot = process.cwd();
+    let debounceTimer: NodeJS.Timeout | null = null;
+
+    try {
+      const { createIntelligentAnalyzer } = await import('../../analyzer/intelligent-analyzer.js');
+      const { DatabaseClient } = await import('../../db/client.js');
+
+      const analyzer = createIntelligentAnalyzer(projectRoot);
+      const db = new DatabaseClient(projectRoot);
+
+      console.log(chalk.cyan('\n👀 Watching for file changes...\n'));
+      console.log(chalk.gray('Press Ctrl+C to stop\n'));
+
+      const onChange = async (filePath: string) => {
+        // Debounce rapid changes
+        if (debounceTimer) {
+          clearTimeout(debounceTimer);
+        }
+
+        debounceTimer = setTimeout(async () => {
+          spinner.start(`Indexing: ${filePath}`);
+
+          try {
+            const relativePath = filePath.replace(projectRoot + '/', '').replace(projectRoot, '');
+            const fs = await import('fs');
+            const content = fs.readFileSync(filePath, 'utf-8');
+
+            // Determine type based on path
+            let type: 'doc' | 'code' | 'tool_config' = 'code';
+            if (filePath.includes('.claude') && !filePath.endsWith('README.md')) {
+              type = 'tool_config';
+            } else if (filePath.endsWith('README.md')) {
+              type = 'doc';
+            }
+
+            db.upsertItem({
+              type,
+              name: filePath.split('/').pop() || 'unknown',
+              content,
+              filePath: relativePath,
+              metadata: { size: content.length }
+            });
+
+            spinner.succeed(`Indexed: ${relativePath}`);
+          } catch (error) {
+            spinner.fail(`Failed to index: ${filePath}`);
+          }
+        }, parseInt(options.delay as string, 10));
+      };
+
+      const cleanup = analyzer.setupFileWatcher(onChange);
+
+      // Keep process alive
+      process.on('SIGINT', () => {
+        console.log(chalk.gray('\n\nStopping watcher...'));
+        cleanup();
+        db.close();
+        process.exit(0);
+      });
+
+    } catch (error) {
+      spinner.fail('Watch failed to start');
+      console.error(chalk.red(`\nError: ${error instanceof Error ? error.message : error}`));
+      process.exit(1);
+    }
+  });

package/src/cli/generate.ts

@@ -0,0 +1,219 @@
+import { Command } from 'commander';
+import { DatabaseClient } from '../db/client.js';
+import ora from 'ora';
+import chalk from 'chalk';
+import fs from 'fs/promises';
+import path from 'path';
+
+export const generateCommand = new Command('generate')
+  .description('Generate context files for all AI tools')
+  .option('-ai, --ai <tools>', 'Generate for specific tools (comma-separated)')
+  .option('--force', 'Force regenerate all files')
+  .option('-v, --verbose', 'Show detailed output')
+  .action(async (options) => {
+    const spinner = ora('Generating context files...').start();
+
+    try {
+      const db = new DatabaseClient(process.cwd());
+
+      // Check if database has content
+      const stats = db.getStats();
+      if (stats.items === 0) {
+        spinner.warn(chalk.yellow('No context found in database. Run `k0ntext index` first.'));
+        return;
+      }
+
+      spinner.text = `Found ${stats.items} context items`;
+
+      // Determine which tools to generate for
+      const toolsParam = options.ai ? options.ai.split(',') : ['all'];
+      const tools = toolsParam.includes('all') ?
+        ['claude', 'copilot', 'cline', 'antigravity', 'windsurf', 'aider', 'continue', 'cursor', 'gemini'] :
+        toolsParam;
+
+      spinner.text = `Generating context for ${tools.length} tools...`;
+
+      const generated = [];
+      const skipped = [];
+
+      for (const tool of tools) {
+        try {
+          const toolPath = await generateForTool(tool, db, options.force);
+          if (toolPath) {
+            generated.push(tool);
+            spinner.text = `Generated ${tool} context`;
+          } else {
+            skipped.push(tool);
+          }
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          spinner.fail(chalk.red(`Failed to generate ${tool}: ${errorMessage}`));
+          if (options.verbose) {
+            console.error(chalk.dim((error as Error).stack));
+          }
+        }
+      }
+
+      spinner.succeed(chalk.green(`Generated context for ${generated.length} tools`));
+
+      if (skipped.length > 0) {
+        console.log(chalk.dim(`Skipped: ${skipped.join(', ')}`));
+      }
+
+      if (options.verbose) {
+        console.log(chalk.dim('Generated:'), generated.join(', '));
+      }
+
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      spinner.fail(chalk.red('Generation failed'));
+      console.error(chalk.dim(errorMessage));
+      if (options.verbose) {
+        console.error(chalk.dim((error as Error).stack));
+      }
+      process.exit(1);
+    }
+  });
+
+async function generateForTool(
+  tool: string,
+  db: DatabaseClient,
+  force: boolean
+): Promise<string | null> {
+  const toolConfigs: Record<string, { path: string; template: string }> = {
+    claude: { path: 'AI_CONTEXT.md', template: 'claude' },
+    copilot: { path: '.github/copilot-instructions.md', template: 'copilot' },
+    cline: { path: '.clinerules', template: 'cline' },
+    antigravity: { path: '.agent/README.md', template: 'antigravity' },
+    windsurf: { path: '.windsurf/rules.md', template: 'windsurf' },
+    aider: { path: '.aider.conf.yml', template: 'aider' },
+    continue: { path: '.continue/config.json', template: 'continue' },
+    cursor: { path: '.cursorrules', template: 'cursor' },
+    gemini: { path: '.gemini/config.md', template: 'gemini' },
+  };
+
+  const config = toolConfigs[tool];
+  if (!config) {
+    return null;
+  }
+
+  // Check if file exists and force is not set
+  if (!force) {
+    try {
+      await fs.access(config.path);
+      return null; // File exists, skip
+    } catch {
+      // File doesn't exist, proceed
+    }
+  }
+
+  // Get context from database
+  const contextItems = db.getAllItems();
+
+  // Generate content based on tool
+  const content = generateContent(tool, contextItems);
+
+  // Ensure directory exists
+  const dir = path.dirname(config.path);
+  await fs.mkdir(dir, { recursive: true });
+
+  // Write file
+  await fs.writeFile(config.path, content, 'utf-8');
+
+  return config.path;
+}
+
+function generateContent(tool: string, contextItems: Array<any>): string {
+  // Basic content generation - in production this would use templates
+  const projectName = contextItems.find(i => i.type === 'config' && i.name === 'project')?.content?.name || 'Project';
+  const description = contextItems.find(i => i.type === 'config' && i.name === 'project')?.content?.description || '';
+
+  switch (tool) {
+    case 'claude':
+      return generateClaudeContext(projectName, description, contextItems);
+    case 'copilot':
+      return generateCopilotContext(projectName, description, contextItems);
+    case 'cline':
+      return generateClineContext(projectName, description, contextItems);
+    case 'aider':
+      return generateAiderConfig(contextItems);
+    default:
+      return `# ${tool.charAt(0).toUpperCase() + tool.slice(1)} Context\n\nProject: ${projectName}\n${description}`;
+  }
+}
+
+function generateClaudeContext(projectName: string, description: string, items: Array<{ type: string; name: string; content?: string }>): string {
+  return `# ${projectName}
+
+${description}
+
+## Project Structure
+
+${items.filter(i => i.type === 'workflow').map(i => `### ${i.name}\n${i.content?.substring(0, 200)}...`).join('\n\n')}
+
+## Key Files
+
+${items.filter(i => i.type === 'code').slice(0, 10).map(i => `- \`${i.name}\``).join('\n')}
+
+---
+*Generated by k0ntext v3.0.0*
+`;
+}
+
+function generateCopilotContext(projectName: string, description: string, items: Array<{ type: string; name: string; content?: string }>): string {
+  return `# ${projectName}
+
+${description}
+
+## Tech Stack
+- Node.js 18+
+- TypeScript
+
+## Key Patterns
+${items.filter(i => i.type === 'workflow').slice(0, 5).map(i => `- ${i.name}: ${i.content?.substring(0, 100)}...`).join('\n')}
+
+---
+*Generated by k0ntext v3.0.0*
+`;
+}
+
+function generateClineContext(projectName: string, description: string, items: Array<{ type: string; name: string; content?: string }>): string {
+  return `# ${projectName} - Cline Rules
+
+${description}
+
+## Architecture
+${items.filter(i => i.type === 'workflow').slice(0, 3).map(i => `### ${i.name}\n${i.content?.substring(0, 150)}...`).join('\n\n')}
+
+## Development Commands
+- \`npm install\` - Install dependencies
+- \`npm test\` - Run tests
+- \`npm run build\` - Build project
+
+---
+*Generated by k0ntext v3.0.0*
+`;
+}
+
+function generateAiderConfig(_items: Array<{ type: string; name: string; content?: string }>): string {
+  return `# Aider Configuration
+model: claude-3-5-sonnet-20241022
+auto-commits: false
+map-tokens: 2048
+
+# Always read these files
+read:
+  - README.md
+  - AI_CONTEXT.md
+
+# Testing
+test-cmd: npm test
+auto-test: false
+
+# Language
+language: typescript
+
+---
+*Generated by k0ntext v3.0.0*
+`;
+}