k0ntext 3.2.1 → 3.3.1

package/src/cli/repl/index.ts

@@ -0,0 +1,557 @@
+/**
+ * K0ntext REPL Shell
+ *
+ * Interactive shell for managing k0ntext context
+ */
+
+import readline from 'readline';
+import { REPLSessionManager, ProjectType } from './core/session.js';
+import { REPLCommandParser } from './core/parser.js';
+import { InitWizard } from './init/wizard.js';
+import { UpdateChecker } from './update/checker.js';
+import { K0NTEXT_THEME, terminal } from './tui/theme.js';
+import { createIntelligentAnalyzer } from '../../analyzer/intelligent-analyzer.js';
+import { DatabaseClient } from '../../db/client.js';
+import { hasOpenRouterKey } from '../../embeddings/openrouter.js';
+import { AdvancedSearchPanel, EnhancedSearchResult } from './tui/panels/search.js';
+import { ConfigPanel } from './tui/panels/config.js';
+import { IndexingProgressVisualizer } from './tui/panels/indexing.js';
+import { DriftDetectionPanel } from './tui/panels/drift.js';
+
+/**
+ * REPL options
+ */
+export interface REPLOptions {
+  projectRoot: string;
+  version: string;
+  noTUI?: boolean;
+}
+
+/**
+ * K0ntext REPL Shell
+ */
+export class REPLShell {
+  private session: REPLSessionManager;
+  private parser: REPLCommandParser;
+  private updateChecker: UpdateChecker;
+  private projectRoot: string;
+  private version: string;
+  private readline: readline.Interface;
+  private isActive: boolean = false;
+  private noTUI: boolean;
+
+  // Enhanced panels
+  private searchPanel: AdvancedSearchPanel;
+  private configPanel: ConfigPanel;
+  private driftPanel: DriftDetectionPanel;
+
+  constructor(options: REPLOptions) {
+    this.projectRoot = options.projectRoot;
+    this.version = options.version;
+    this.noTUI = options.noTUI || false;
+
+    this.session = new REPLSessionManager(this.projectRoot);
+    this.parser = new REPLCommandParser();
+    this.updateChecker = new UpdateChecker(options.version);
+
+    // Initialize enhanced panels
+    this.searchPanel = new AdvancedSearchPanel();
+    this.configPanel = new ConfigPanel(this.projectRoot, { ...this.session.getState().config } as Record<string, unknown>);
+    this.driftPanel = new DriftDetectionPanel(this.projectRoot);
+
+    // Create readline interface
+    this.readline = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: this.getPrompt()
+    });
+
+    this.setupEventHandlers();
+    this.registerCommands();
+  }
+
+  /**
+   * Get the command prompt
+   */
+  private getPrompt(): string {
+    const isInit = this.session.isInitialized();
+    const symbol = isInit ? '█' : '?';
+    return K0NTEXT_THEME.primary(`k0ntext${symbol} `);
+  }
+
+  /**
+   * Setup event handlers
+   */
+  private setupEventHandlers(): void {
+    this.readline.on('line', async (input) => {
+      if (!this.isActive) return;
+
+      const trimmed = input.trim();
+
+      if (!trimmed) {
+        this.readline.prompt();
+        return;
+      }
+
+      // Handle exit commands
+      if (trimmed.toLowerCase() === 'exit' || trimmed.toLowerCase() === 'quit') {
+        await this.stop();
+        return;
+      }
+
+      // Parse and execute command
+      const parsed = this.parser.parse(trimmed);
+      if (parsed) {
+        const startTime = Date.now();
+        const result = await this.parser.execute(parsed);
+        const duration = Date.now() - startTime;
+
+        this.session.addCommand(trimmed, result.output, duration);
+
+        if (result.output) {
+          console.log('');
+          console.log(result.output);
+        }
+
+        if (result.error) {
+          console.log('');
+          console.log(K0NTEXT_THEME.error(`✖ ${result.error}`));
+        }
+      } else {
+        console.log(K0NTEXT_THEME.warning('\n⚠ Invalid command. Type "help" for available commands.'));
+      }
+
+      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();
+    });
+
+    this.readline.on('close', async () => {
+      await this.stop();
+    });
+  }
+
+  /**
+   * Register REPL-specific commands
+   */
+  private registerCommands(): void {
+    // Stats command
+    this.parser.registerCommand({
+      name: 'stats',
+      description: 'Show database and session statistics',
+      usage: 'stats',
+      examples: ['stats'],
+      handler: async () => {
+        const db = new DatabaseClient(this.projectRoot);
+        const dbStats = db.getStats();
+        const sessionStats = this.session.getStats();
+        const duration = this.session.getDuration();
+
+        const output = [
+          '',
+          K0NTEXT_THEME.header('━━━ Database Statistics ━━━'),
+          `  ${K0NTEXT_THEME.cyan('•')} Context Items:    ${dbStats.items}`,
+          `  ${K0NTEXT_THEME.cyan('•')} Relations:         ${dbStats.relations}`,
+          `  ${K0NTEXT_THEME.cyan('•')} Git Commits:       ${dbStats.commits}`,
+          `  ${K0NTEXT_THEME.cyan('•')} Embeddings:        ${dbStats.embeddings}`,
+          `  ${K0NTEXT_THEME.cyan('•')} Tool Configs:      ${dbStats.toolConfigs}`,
+          `  ${K0NTEXT_THEME.cyan('•')} Database Path:     ${dbStats.path || '.k0ntext.db'}`,
+          '',
+          K0NTEXT_THEME.header('━━━ Session Statistics ━━━'),
+          `  ${K0NTEXT_THEME.cyan('•')} Duration:          ${duration.human}`,
+          `  ${K0NTEXT_THEME.cyan('•')} Commands Run:      ${sessionStats.commandsExecuted}`,
+          `  ${K0NTEXT_THEME.cyan('•')} Searches:          ${sessionStats.searchesPerformed}`,
+          `  ${K0NTEXT_THEME.cyan('•')} Files Indexed:     ${sessionStats.filesIndexed}`,
+          `  ${K0NTEXT_THEME.cyan('•')} Embeddings:        ${sessionStats.embeddingsGenerated}`,
+          ''
+        ];
+
+        db.close();
+
+        return { success: true, output: output.join('\n') };
+      }
+    });
+
+    // Index command
+    this.parser.registerCommand({
+      name: 'index',
+      description: 'Index codebase into database',
+      usage: 'index [options]',
+      examples: ['index', 'index --code', 'index --all'],
+      handler: async (args, flags) => {
+        const analyzer = createIntelligentAnalyzer(this.projectRoot);
+        const db = new DatabaseClient(this.projectRoot);
+        const visualizer = new IndexingProgressVisualizer();
+
+        let indexedCount = 0;
+        let docsCount = 0;
+        let codeIndexedCount = 0;
+        let toolsIndexedCount = 0;
+
+        try {
+          const [docs, code, tools] = await Promise.all([
+            analyzer.discoverDocs(),
+            analyzer.discoverCode(),
+            analyzer.discoverToolConfigs()
+          ]);
+
+          docsCount = docs.length;
+          const codeCount = Math.min(code.length, 500); // Limit for now
+          const toolsCount = tools.length;
+          const totalFiles = docsCount + codeCount + toolsCount;
+
+          visualizer.start(totalFiles);
+
+          // Index docs
+          for (const doc of docs) {
+            const content = require('fs').readFileSync(doc.path, 'utf-8').slice(0, 50000);
+            db.upsertItem({
+              type: 'doc',
+              name: require('path').basename(doc.relativePath),
+              content,
+              filePath: doc.relativePath,
+              metadata: { size: doc.size }
+            });
+            indexedCount++;
+            docsCount++;
+            visualizer.update('indexing_docs', { processed: indexedCount, currentFile: doc.relativePath });
+          }
+
+          // Index code
+          for (const codeFile of code.slice(0, 500)) {
+            const content = require('fs').existsSync(codeFile.path)
+              ? require('fs').readFileSync(codeFile.path, 'utf-8').slice(0, 20000)
+              : '';
+            if (content) {
+              db.upsertItem({
+                type: 'code',
+                name: require('path').basename(codeFile.relativePath),
+                content,
+                filePath: codeFile.relativePath,
+                metadata: { size: codeFile.size }
+              });
+              indexedCount++;
+              codeIndexedCount++;
+            }
+            visualizer.update('indexing_code', { processed: indexedCount, currentFile: codeFile.relativePath });
+          }
+
+          // Index tools
+          for (const tool of tools) {
+            const content = require('fs').existsSync(tool.path)
+              ? require('fs').readFileSync(tool.path, 'utf-8').slice(0, 50000)
+              : '';
+            if (content) {
+              db.upsertItem({
+                type: 'tool_config',
+                name: `${tool.tool}:${require('path').basename(tool.relativePath)}`,
+                content,
+                filePath: tool.relativePath,
+                metadata: { tool: tool.tool, size: tool.size }
+              });
+              indexedCount++;
+              toolsIndexedCount++;
+            }
+            visualizer.update('indexing_tools', { processed: indexedCount, currentFile: tool.relativePath });
+          }
+
+          this.session.updateStats({
+            filesIndexed: this.session.getStats().filesIndexed + indexedCount
+          });
+
+          visualizer.complete({ docsIndexed: docsCount, codeIndexed: codeIndexedCount, configsIndexed: toolsIndexedCount });
+
+          db.close();
+
+          return { success: true, output: '' };
+        } catch (error) {
+          visualizer.cancel();
+          db.close();
+          return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error)
+          };
+        }
+      }
+    });
+
+    // Search command - Enhanced
+    this.parser.registerCommand({
+      name: 'search',
+      description: 'Search indexed content with advanced options',
+      usage: 'search <query> [options]',
+      examples: [
+        'search auth',
+        'search "user login"',
+        'search config --type code',
+        'search auth --sort date --limit 20'
+      ],
+      handler: async (args, flags) => {
+        const query = args.join(' ');
+        if (!query) {
+          return {
+            success: false,
+            error: 'Please provide a search query'
+          };
+        }
+
+        const db = new DatabaseClient(this.projectRoot);
+        const results = db.searchText(query);
+
+        this.session.updateStats({
+          searchesPerformed: this.session.getStats().searchesPerformed + 1
+        });
+
+        // Parse search flags
+        const filters = this.searchPanel.parseSearchFlags(args);
+
+        // Apply filters
+        let filteredResults: EnhancedSearchResult[] = results.map(r => ({ item: r, score: 0.5, highlights: [] }));
+        if (filters.type) {
+          filteredResults = this.searchPanel.filterByType(filteredResults, filters.type);
+        }
+        if (filters.sortBy) {
+          filteredResults = this.searchPanel.sortResults(filteredResults, filters.sortBy, filters.sortOrder || 'desc');
+        }
+
+        // Display results
+        const output = this.searchPanel.displayResults(filteredResults, query, filters);
+
+        db.close();
+
+        return { success: true, output };
+      }
+    });
+
+    // Init command (re-run wizard)
+    this.parser.registerCommand({
+      name: 'init',
+      description: 'Re-run initialization wizard',
+      usage: 'init',
+      examples: ['init'],
+      handler: async () => {
+        const wizard = new InitWizard(this.projectRoot);
+        const config = await wizard.run();
+
+        if (config) {
+          this.session.setInitialized(config.apiKey, config.projectType);
+          this.session.updateConfig({
+            apiKey: config.apiKey,
+            projectType: config.projectType,
+            aiTools: config.aiTools,
+            features: config.features
+          });
+
+          wizard.showSuccess(config);
+        }
+
+        return { success: true };
+      }
+    });
+
+    // Update command
+    this.parser.registerCommand({
+      name: 'update',
+      description: 'Check for k0ntext updates',
+      usage: 'update',
+      examples: ['update'],
+      handler: async () => {
+        const hasUpdate = await this.updateChecker.checkAndPrompt();
+        return {
+          success: true,
+          output: hasUpdate ? '' : K0NTEXT_THEME.success('\n✓ Already on latest version')
+        };
+      }
+    });
+
+    // Drift command
+    this.parser.registerCommand({
+      name: 'drift',
+      description: 'Check for documentation drift',
+      usage: 'drift',
+      examples: ['drift'],
+      handler: async () => {
+        const report = await this.driftPanel.analyze();
+        const output = this.driftPanel.displayReport(report);
+        return { success: true, output };
+      }
+    });
+
+    // Config command - Enhanced
+    this.parser.registerCommand({
+      name: 'config',
+      description: 'View or set configuration',
+      usage: 'config [get|set|list|edit|validate] [key] [value]',
+      examples: ['config list', 'config get projectType', 'config set projectType webapp', 'config edit', 'config validate'],
+      handler: async (args) => {
+        const action = args[0] || 'list';
+
+        if (action === 'edit') {
+          // Interactive configuration editor
+          const category = args[1]; // Optional category filter
+          await this.configPanel.interactiveConfig(category);
+          return { success: true, output: '' };
+        }
+
+        if (action === 'validate') {
+          const validation = this.configPanel.validateConfig();
+          const output = [
+            '',
+            K0NTEXT_THEME.header('━━━ Configuration Validation ━━━'),
+            ''
+          ];
+
+          if (validation.valid) {
+            output.push(K0NTEXT_THEME.success('✓ Configuration is valid'));
+          } else {
+            output.push(K0NTEXT_THEME.error('✗ Configuration errors found:'));
+            for (const error of validation.errors) {
+              output.push(`  ${K0NTEXT_THEME.error('•')} ${error}`);
+            }
+          }
+
+          if (validation.warnings.length > 0) {
+            output.push('');
+            output.push(K0NTEXT_THEME.warning('⚠ Warnings:'));
+            for (const warning of validation.warnings) {
+              output.push(`  ${K0NTEXT_THEME.warning('•')} ${warning}`);
+            }
+          }
+          output.push('');
+
+          return { success: validation.valid, output: output.join('\n') };
+        }
+
+        if (action === 'list') {
+          return { success: true, output: this.configPanel.displayConfig() };
+        }
+
+        if (action === 'get') {
+          const key = args[1];
+          if (!key) return { success: false, error: 'Please specify a key' };
+          const value = this.configPanel.getValue(key);
+          const formatted = this.configPanel.formatValue(value, {
+            name: key,
+            type: 'string',
+            description: '',
+            defaultValue: ''
+          });
+          return { success: true, output: `${key}: ${formatted}` };
+        }
+
+        if (action === 'set') {
+          const key = args[1];
+          const value = args.slice(2).join(' ');
+          if (!key || !value) return { success: false, error: 'Usage: config set <key> <value>' };
+
+          this.session.updateConfig({ [key]: value });
+          await this.configPanel.saveConfig();
+          return { success: true, output: K0NTEXT_THEME.success(`✓ Set ${key} = ${value}`) };
+        }
+
+        return { success: false, error: 'Unknown action. Use: list, get, set, edit, or validate' };
+      }
+    });
+  }
+
+  /**
+   * Start the REPL
+   */
+  async start(): Promise<void> {
+    this.isActive = true;
+
+    // Show banner
+    this.showBanner();
+
+    // Check for updates
+    if (this.session.getState().config.autoUpdate) {
+      await this.updateChecker.showNotification({ showIfCurrent: false, checkInterval: 24 * 60 * 60 * 1000 });
+    }
+
+    // Check if initialized
+    if (!this.session.isInitialized()) {
+      console.log('');
+      console.log(K0NTEXT_THEME.info('🔧 First-time setup detected. Running initialization wizard...\n'));
+
+      const wizard = new InitWizard(this.projectRoot);
+      const config = await wizard.run();
+
+      if (config) {
+        this.session.setInitialized(config.apiKey, config.projectType);
+        this.session.updateConfig({
+          apiKey: config.apiKey,
+          projectType: config.projectType,
+          aiTools: config.aiTools,
+          features: config.features
+        });
+
+        wizard.showSuccess(config);
+      } else {
+        console.log(K0NTEXT_THEME.info('\n✓ Skipping initialization. You can run "init" later.\n'));
+      }
+    }
+
+    // Show project stats if initialized
+    if (this.session.isInitialized()) {
+      const analyzer = createIntelligentAnalyzer(this.projectRoot);
+      const analysis = await analyzer.analyze();
+
+      console.log('');
+      console.log(K0NTEXT_THEME.header('━━━ Project Overview ━━━'));
+      console.log(`  ${K0NTEXT_THEME.primary('Type:')}     ${this.session.getState().config.projectType}`);
+      console.log(`  ${K0NTEXT_THEME.primary('Docs:')}    ${analysis.existingContext.files.filter(f => f.type === 'doc').length}`);
+      console.log(`  ${K0NTEXT_THEME.primary('Code:')}    ${analysis.existingContext.files.filter(f => f.type === 'code').length}`);
+      console.log(`  ${K0NTEXT_THEME.primary('Tech:')}    ${analysis.techStack.languages.slice(0, 3).join(', ')}`);
+    }
+
+    console.log('');
+    console.log(K0NTEXT_THEME.dim('Type "help" for available commands, "exit" to quit.'));
+
+    // Start readline
+    this.readline.prompt();
+  }
+
+  /**
+   * Stop the REPL
+   */
+  async stop(): Promise<void> {
+    this.isActive = false;
+    this.session.end();
+    this.readline.close();
+    console.log('');
+    console.log(K0NTEXT_THEME.success('✓ Session saved. Goodbye!'));
+  }
+
+  /**
+   * Show welcome banner
+   */
+  private showBanner(): void {
+    const { supportsColor } = K0NTEXT_THEME.detectCapabilities();
+
+    if (!supportsColor) {
+      console.log(`\n  K0ntext v${this.version}\n`);
+      return;
+    }
+
+    console.log('');
+    console.log(K0NTEXT_THEME.box(
+      `K0NTEXT v${this.version}`,
+      `${K0NTEXT_THEME.dim('Interactive shell for AI context engineering')}
+${K0NTEXT_THEME.dim('Type "help" for commands, "exit" to quit')}`,
+      'primary'
+    ));
+    console.log('');
+  }
+}
+
+/**
+ * Create and start a REPL shell
+ */
+export async function startREPL(projectRoot: string = process.cwd(), version: string, noTUI = false): Promise<void> {
+  const shell = new REPLShell({ projectRoot, version, noTUI });
+  await shell.start();
+}