k0ntext 3.2.1 → 3.3.0

package/src/cli/repl/core/parser.ts

@@ -0,0 +1,373 @@
+/**
+ * REPL Command Parser
+ *
+ * Parses and executes commands in the REPL shell
+ */
+
+import { ProjectType } from './session.js';
+
+/**
+ * Parsed command
+ */
+export interface ParsedCommand {
+  raw: string;
+  name: string;
+  args: string[];
+  flags: Record<string, boolean | string>;
+}
+
+/**
+ * Command result
+ */
+export interface CommandResult {
+  success: boolean;
+  output?: string;
+  error?: string;
+  data?: unknown;
+}
+
+/**
+ * Command definition
+ */
+export interface CommandDefinition {
+  name: string;
+  aliases?: string[];
+  description: string;
+  usage: string;
+  examples: string[];
+  handler: (args: string[], flags: Record<string, boolean | string>) => Promise<CommandResult>;
+  completions?: (args: string[]) => string[];
+}
+
+/**
+ * REPL Command Parser
+ */
+export class REPLCommandParser {
+  private commands: Map<string, CommandDefinition>;
+  private aliases: Map<string, string>;
+
+  constructor() {
+    this.commands = new Map();
+    this.aliases = new Map();
+    this.registerDefaultCommands();
+  }
+
+  /**
+   * Register a command
+   */
+  registerCommand(def: CommandDefinition): void {
+    this.commands.set(def.name, def);
+
+    // Register aliases
+    if (def.aliases) {
+      for (const alias of def.aliases) {
+        this.aliases.set(alias, def.name);
+      }
+    }
+  }
+
+  /**
+   * Unregister a command
+   */
+  unregisterCommand(name: string): void {
+    const def = this.commands.get(name);
+    if (def) {
+      this.commands.delete(name);
+
+      // Remove aliases
+      if (def.aliases) {
+        for (const alias of def.aliases) {
+          this.aliases.delete(alias);
+        }
+      }
+    }
+  }
+
+  /**
+   * Parse a command string
+   */
+  parse(input: string): ParsedCommand | null {
+    const trimmed = input.trim();
+    if (!trimmed) {
+      return null;
+    }
+
+    // Split into parts, respecting quotes
+    const parts: string[] = [];
+    let current = '';
+    let inQuotes = false;
+    let quoteChar = '';
+
+    for (let i = 0; i < trimmed.length; i++) {
+      const char = trimmed[i];
+
+      if ((char === '"' || char === "'") && (i === 0 || trimmed[i - 1] !== '\\')) {
+        if (!inQuotes) {
+          inQuotes = true;
+          quoteChar = char;
+        } else if (char === quoteChar) {
+          inQuotes = false;
+          quoteChar = '';
+        }
+      } else if (char === ' ' && !inQuotes) {
+        if (current) {
+          parts.push(current);
+          current = '';
+        }
+      } else {
+        current += char;
+      }
+    }
+
+    if (current) {
+      parts.push(current);
+    }
+
+    if (parts.length === 0) {
+      return null;
+    }
+
+    // Parse flags
+    const args: string[] = [];
+    const flags: Record<string, boolean | string> = {};
+
+    for (const part of parts.slice(1)) {
+      if (part.startsWith('--')) {
+        const flagParts = part.slice(2).split('=');
+        const flagName = flagParts[0];
+        if (flagParts.length > 1) {
+          flags[flagName] = flagParts.slice(1).join('=');
+        } else {
+          flags[flagName] = true;
+        }
+      } else if (part.startsWith('-')) {
+        flags[part.slice(1)] = true;
+      } else {
+        args.push(part);
+      }
+    }
+
+    // Resolve command name (handle aliases)
+    let name = parts[0].toLowerCase();
+    if (this.aliases.has(name)) {
+      name = this.aliases.get(name)!;
+    }
+
+    return {
+      raw: trimmed,
+      name,
+      args,
+      flags
+    };
+  }
+
+  /**
+   * Execute a parsed command
+   */
+  async execute(parsed: ParsedCommand): Promise<CommandResult> {
+    const def = this.commands.get(parsed.name);
+
+    if (!def) {
+      return {
+        success: false,
+        error: `Unknown command: ${parsed.name}. Type 'help' for available commands.`
+      };
+    }
+
+    try {
+      return await def.handler(parsed.args, parsed.flags);
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+
+  /**
+   * Get command completions
+   */
+  getCompletions(input: string, cursor: number): string[] {
+    const parsed = this.parse(input);
+    if (!parsed) {
+      return Array.from(this.commands.keys());
+    }
+
+    const def = this.commands.get(parsed.name);
+    if (def && def.completions) {
+      return def.completions(parsed.args);
+    }
+
+    return [];
+  }
+
+  /**
+   * Get all command names
+   */
+  getCommandNames(): string[] {
+    return Array.from(this.commands.keys());
+  }
+
+  /**
+   * Get command definition
+   */
+  getCommand(name: string): CommandDefinition | undefined {
+    // Resolve alias
+    const resolvedName = this.aliases.get(name) || name;
+    return this.commands.get(resolvedName);
+  }
+
+  /**
+   * Get help text for a command
+   */
+  getHelp(name?: string): string {
+    if (name) {
+      const def = this.getCommand(name);
+      if (!def) {
+        return `Unknown command: ${name}`;
+      }
+
+      return `
+${def.name} - ${def.description}
+
+Usage:
+  ${def.usage}
+
+Examples:
+${def.examples.map(e => `  ${e}`).join('\n')}
+      `.trim();
+    }
+
+    // Show all commands
+    const lines = [
+      '\nAvailable Commands:',
+      ''
+    ];
+
+    const categories = this.groupCommandsByCategory();
+
+    for (const [category, commands] of Object.entries(categories)) {
+      lines.push(`  ${category}:`);
+      for (const cmd of commands) {
+        const def = this.getCommand(cmd);
+        if (def) {
+          lines.push(`    ${cmd.padEnd(15)} - ${def.description}`);
+        } else {
+          lines.push(`    ${cmd.padEnd(15)} - (no description)`);
+        }
+      }
+      lines.push('');
+    }
+
+    lines.push('  Use "help <command>" for more information on a specific command.');
+    lines.push('');
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Group commands by category
+   */
+  private groupCommandsByCategory(): Record<string, string[]> {
+    const categories: Record<string, string[]> = {
+      'Core': ['help', 'exit', 'clear', 'config'],
+      'Database': ['stats', 'index', 'search'],
+      'Initialization': ['init', 'generate'],
+      'Monitoring': ['watch', 'drift'],
+      'MCP': ['mcp', 'sync']
+    };
+
+    // Add all commands to categories
+    for (const name of this.getCommandNames()) {
+      let categorized = false;
+      for (const [_, cmds] of Object.entries(categories)) {
+        if (cmds.includes(name)) {
+          categorized = true;
+          break;
+        }
+      }
+      if (!categorized) {
+        if (!categories['Other']) {
+          categories['Other'] = [];
+        }
+        categories['Other'].push(name);
+      }
+    }
+
+    return categories;
+  }
+
+  /**
+   * Register default commands
+   */
+  private registerDefaultCommands(): void {
+    // Help command
+    this.registerCommand({
+      name: 'help',
+      aliases: ['?', 'h'],
+      description: 'Show help information',
+      usage: 'help [command]',
+      examples: [
+        'help',
+        'help index',
+        'help stats'
+      ],
+      handler: async (args) => {
+        const commandName = args[0];
+        return {
+          success: true,
+          output: this.getHelp(commandName)
+        };
+      }
+    });
+
+    // Exit command
+    this.registerCommand({
+      name: 'exit',
+      aliases: ['quit', 'q'],
+      description: 'Exit the REPL shell',
+      usage: 'exit',
+      examples: ['exit', 'quit'],
+      handler: async () => {
+        return {
+          success: true,
+          output: 'Goodbye!'
+        };
+      }
+    });
+
+    // Clear command
+    this.registerCommand({
+      name: 'clear',
+      aliases: ['cls'],
+      description: 'Clear the screen',
+      usage: 'clear',
+      examples: ['clear'],
+      handler: async () => {
+        console.clear();
+        return {
+          success: true,
+          output: ''
+        };
+      }
+    });
+
+    // Config command
+    this.registerCommand({
+      name: 'config',
+      description: 'Manage configuration',
+      usage: 'config [get|set|list] [key] [value]',
+      examples: [
+        'config list',
+        'config get projectType',
+        'config set projectType webapp'
+      ],
+      handler: async (args) => {
+        return {
+          success: true,
+          output: 'Config command - use get|set|list'
+        };
+      }
+    });
+  }
+}

package/src/cli/repl/core/session.ts

@@ -0,0 +1,269 @@
+/**
+ * REPL Session Manager
+ *
+ * Manages REPL session lifecycle, state persistence, and activity tracking
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Generate a simple UUID v4
+ */
+function generateUUID(): string {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === 'x' ? r : (r & 0x3 | 0x8);
+    return v.toString(16);
+  });
+}
+
+/**
+ * Session state
+ */
+export interface SessionState {
+  sessionId: string;
+  startTime: string;
+  lastActivity: string;
+  projectRoot: string;
+  config: SessionConfig;
+  history: CommandHistoryEntry[];
+  stats: SessionStats;
+}
+
+/**
+ * Session configuration
+ */
+export interface SessionConfig {
+  apiKey?: string;
+  projectType?: ProjectType;
+  aiTools: string[];
+  features: string[];
+  autoUpdate: boolean;
+  theme: string;
+}
+
+/**
+ * Project type
+ */
+export type ProjectType = 'monorepo' | 'webapp' | 'library' | 'api' | 'cli' | 'unknown';
+
+/**
+ * Command history entry
+ */
+export interface CommandHistoryEntry {
+  command: string;
+  timestamp: string;
+  result?: string;
+  duration?: number;
+}
+
+/**
+ * Session statistics
+ */
+export interface SessionStats {
+  commandsExecuted: number;
+  searchesPerformed: number;
+  filesIndexed: number;
+  embeddingsGenerated: number;
+  errorsEncountered: number;
+}
+
+/**
+ * REPL Session Manager
+ */
+export class REPLSessionManager {
+  private state: SessionState;
+  private statePath: string;
+  private projectRoot: string;
+
+  constructor(projectRoot: string) {
+    this.projectRoot = projectRoot;
+    const k0ntextDir = path.join(projectRoot, '.k0ntext');
+    this.statePath = path.join(k0ntextDir, 'session.json');
+
+    // Ensure .k0ntext directory exists
+    if (!fs.existsSync(k0ntextDir)) {
+      fs.mkdirSync(k0ntextDir, { recursive: true });
+    }
+
+    // Try to load existing session or create new
+    this.state = this.load() || this.createNewSession();
+  }
+
+  /**
+   * Create a new session
+   */
+  private createNewSession(): SessionState {
+    return {
+      sessionId: generateUUID(),
+      startTime: new Date().toISOString(),
+      lastActivity: new Date().toISOString(),
+      projectRoot: this.projectRoot,
+      config: {
+        aiTools: [],
+        autoUpdate: true,
+        theme: 'default',
+        features: []
+      },
+      history: [],
+      stats: {
+        commandsExecuted: 0,
+        searchesPerformed: 0,
+        filesIndexed: 0,
+        embeddingsGenerated: 0,
+        errorsEncountered: 0
+      }
+    };
+  }
+
+  /**
+   * Load session from disk
+   */
+  private load(): SessionState | null {
+    try {
+      if (fs.existsSync(this.statePath)) {
+        const content = fs.readFileSync(this.statePath, 'utf-8');
+        return JSON.parse(content) as SessionState;
+      }
+    } catch {
+      // If load fails, return null to create new session
+    }
+    return null;
+  }
+
+  /**
+   * Save session to disk
+   */
+  save(): void {
+    try {
+      this.state.lastActivity = new Date().toISOString();
+      fs.writeFileSync(this.statePath, JSON.stringify(this.state, null, 2));
+    } catch (error) {
+      console.error('Failed to save session:', error);
+    }
+  }
+
+  /**
+   * Get session state
+   */
+  getState(): SessionState {
+    return { ...this.state };
+  }
+
+  /**
+   * Update session config
+   */
+  updateConfig(config: Partial<SessionConfig>): void {
+    this.state.config = { ...this.state.config, ...config };
+    this.save();
+  }
+
+  /**
+   * Add command to history
+   */
+  addCommand(command: string, result?: string, duration?: number): void {
+    const entry: CommandHistoryEntry = {
+      command,
+      timestamp: new Date().toISOString(),
+      result,
+      duration
+    };
+
+    this.state.history.push(entry);
+
+    // Keep only last 100 commands
+    if (this.state.history.length > 100) {
+      this.state.history = this.state.history.slice(-100);
+    }
+
+    this.state.stats.commandsExecuted++;
+    this.save();
+  }
+
+  /**
+   * Get command history
+   */
+  getHistory(limit?: number): CommandHistoryEntry[] {
+    const history = this.state.history.slice().reverse();
+    return limit ? history.slice(0, limit) : history;
+  }
+
+  /**
+   * Update session stats
+   */
+  updateStats(stats: Partial<SessionStats>): void {
+    this.state.stats = { ...this.state.stats, ...stats };
+    this.save();
+  }
+
+  /**
+   * Get session stats
+   */
+  getStats(): SessionStats {
+    return { ...this.state.stats };
+  }
+
+  /**
+   * Get session duration
+   */
+  getDuration(): { ms: number; human: string } {
+    const start = new Date(this.state.startTime);
+    const now = new Date();
+    const diff = now.getTime() - start.getTime();
+
+    const seconds = Math.floor(diff / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+
+    let human = '';
+    if (days > 0) human += `${days}d `;
+    if (hours % 24 > 0) human += `${hours % 24}h `;
+    if (minutes % 60 > 0) human += `${minutes % 60}m `;
+    if (seconds % 60 > 0 || human === '') human += `${seconds % 60}s`;
+
+    return { ms: diff, human: human.trim() };
+  }
+
+  /**
+   * Check if session is initialized (has API key and project type)
+   */
+  isInitialized(): boolean {
+    return !!(
+      this.state.config.apiKey ||
+      process.env.OPENROUTER_API_KEY
+    ) && !!this.state.config.projectType;
+  }
+
+  /**
+   * Set initialization status
+   */
+  setInitialized(apiKey: string, projectType: ProjectType): void {
+    this.state.config.apiKey = apiKey;
+    this.state.config.projectType = projectType;
+    this.save();
+  }
+
+  /**
+   * Get OpenRouter API key
+   */
+  getApiKey(): string | undefined {
+    return this.state.config.apiKey || process.env.OPENROUTER_API_KEY;
+  }
+
+  /**
+   * Clear session (for reset/reinit)
+   */
+  clear(): void {
+    this.state = this.createNewSession();
+    this.save();
+  }
+
+  /**
+   * End session
+   */
+  end(): void {
+    this.save();
+  }
+}