vigthoria-cli 1.0.0

package/src/commands/chat.ts

@@ -0,0 +1,690 @@
+/**
+ * Interactive Chat Command for Vigthoria CLI
+ * 
+ * Now with Claude Code-like agentic capabilities!
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+import * as readline from 'readline';
+import { Marked } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+import { Config } from '../utils/config.js';
+import { Logger } from '../utils/logger.js';
+import { APIClient, ChatMessage } from '../utils/api.js';
+import { FileUtils } from '../utils/files.js';
+import { AgenticTools, ToolCall, ToolResult } from '../utils/tools.js';
+import { SessionManager, Session } from '../utils/session.js';
+
+interface ChatOptions {
+  model: string;
+  project: string;
+  agent?: boolean;
+  autoApprove?: boolean;
+  resume?: boolean;
+  stream?: boolean;
+  local?: boolean;  // Skip authentication for local testing
+}
+
+export class ChatCommand {
+  private config: Config;
+  private logger: Logger;
+  private api: APIClient;
+  private messages: ChatMessage[] = [];
+  private fileUtils: FileUtils;
+  private marked: Marked;
+  private tools: AgenticTools | null = null;
+  private agentMode: boolean = false;
+  private rl: readline.Interface | null = null;
+  private sessionManager: SessionManager;
+  private currentSession: Session | null = null;
+  private streamMode: boolean = true;
+  private localMode: boolean = false;
+
+  constructor(config: Config, logger: Logger) {
+    this.config = config;
+    this.logger = logger;
+    this.api = new APIClient(config, logger);
+    this.fileUtils = new FileUtils(process.cwd(), config.get('project').ignorePatterns);
+    this.sessionManager = new SessionManager();
+    
+    // Setup marked for terminal rendering
+    this.marked = new Marked();
+    this.marked.use(markedTerminal() as any);
+  }
+
+  async run(options: ChatOptions): Promise<void> {
+    // Check authentication (skip for local testing mode)
+    if (!options.local && !this.config.isAuthenticated()) {
+      this.logger.error('Not authenticated. Run: vigthoria login');
+      this.logger.info('Tip: Use --local flag to test with local Ollama models');
+      return;
+    }
+
+    if (!options.local && !this.config.hasValidSubscription()) {
+      this.logger.warn('Your subscription has expired. Some features may be limited.');
+    }
+
+    if (options.local) {
+      this.logger.info('Local mode: Using Ollama for AI responses');
+    }
+
+    // Setup agentic tools if enabled
+    this.agentMode = options.agent || false;
+    this.streamMode = options.stream !== false; // Default to true
+    this.localMode = options.local || false;
+    
+    if (this.agentMode) {
+      this.tools = new AgenticTools(
+        this.logger,
+        options.project,
+        this.askPermission.bind(this),
+        options.autoApprove || false
+      );
+    }
+
+    // Try to resume previous session or create new one
+    if (options.resume) {
+      this.currentSession = this.sessionManager.getLatest(options.project);
+      if (this.currentSession) {
+        this.messages = [...this.currentSession.messages];
+        this.logger.success(`Resumed session: ${this.currentSession.id}`);
+      }
+    }
+
+    if (!this.currentSession) {
+      this.currentSession = this.sessionManager.create(
+        options.project,
+        options.model,
+        this.agentMode
+      );
+    }
+
+    // Get project context
+    const projectContext = await this.fileUtils.getProjectContext();
+    
+    // Setup system message
+    const systemMessage: ChatMessage = {
+      role: 'system',
+      content: this.buildSystemPrompt(projectContext, options),
+    };
+    this.messages.push(systemMessage);
+
+    this.printWelcome(options);
+    
+    // Start REPL
+    await this.startRepl(options);
+  }
+
+  private buildSystemPrompt(
+    projectContext: { type: string; files: string[]; dependencies: Record<string, string> },
+    options: ChatOptions
+  ): string {
+    let prompt = `You are Vigthoria, a premium AI coding assistant. You help developers write, understand, and improve code.
+
+Project Context:
+- Type: ${projectContext.type}
+- Root: ${options.project}
+- Key files: ${projectContext.files.slice(0, 10).join(', ')}
+${projectContext.type === 'node' ? `- Dependencies: ${Object.keys(projectContext.dependencies).slice(0, 15).join(', ')}` : ''}
+
+Guidelines:
+- Provide complete, production-ready code
+- Use modern best practices (2024-2026 standards)
+- Include proper error handling
+- Explain your reasoning when helpful
+- Be concise but thorough
+
+Special Commands (user may use these):
+- /file <path> - Read and include a file in context
+- /edit <path> - Switch to file editing mode
+- /diff - Show pending changes
+- /apply - Apply pending changes
+- /clear - Clear conversation history
+- /model <name> - Switch AI model
+- /agent - Toggle agentic mode (Claude Code-like autonomous actions)
+- /help - Show available commands`;
+
+    // Add tool instructions if in agent mode
+    if (this.agentMode && this.tools) {
+      prompt += `\n\n${AgenticTools.getToolsForPrompt()}`;
+    }
+
+    return prompt;
+  }
+
+  private printWelcome(options: ChatOptions): void {
+    const sub = this.config.get('subscription');
+    
+    console.log();
+    this.logger.box(
+      `Model: ${chalk.cyan(options.model)}\n` +
+      `Plan: ${chalk.green(sub.plan || 'free')}\n` +
+      `Project: ${chalk.gray(options.project)}\n` +
+      `Agent Mode: ${this.agentMode ? chalk.green('ON ✓') : chalk.gray('OFF')}`,
+      'Vigthoria Chat'
+    );
+    console.log();
+    if (this.agentMode) {
+      console.log(chalk.yellow('🤖 Agent Mode: AI can read files, edit code, and run commands autonomously.'));
+    }
+    console.log(chalk.gray('Type your message or /help for commands. Press Ctrl+C to exit.'));
+    console.log();
+  }
+
+  private async startRepl(options: ChatOptions): Promise<void> {
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: chalk.cyan('you › '),
+    });
+
+    let currentModel = options.model;
+    let pendingChanges: { file: string; content: string } | null = null;
+
+    this.rl.prompt();
+
+    for await (const line of this.rl) {
+      const input = line.trim();
+      
+      if (!input) {
+        this.rl.prompt();
+        continue;
+      }
+
+      // Handle special commands
+      if (input.startsWith('/')) {
+        const [cmd, ...args] = input.slice(1).split(' ');
+        
+        switch (cmd) {
+          case 'help':
+            this.printHelp();
+            break;
+            
+          case 'clear':
+            this.messages = [this.messages[0]]; // Keep system message
+            this.logger.success('Conversation cleared');
+            break;
+            
+          case 'model':
+            if (args[0]) {
+              currentModel = args[0];
+              this.logger.success(`Model switched to: ${currentModel}`);
+            } else {
+              this.printModels();
+            }
+            break;
+          
+          case 'agent':
+            this.agentMode = !this.agentMode;
+            if (this.agentMode && !this.tools) {
+              this.tools = new AgenticTools(
+                this.logger,
+                options.project,
+                this.askPermission.bind(this),
+                options.autoApprove || false
+              );
+            }
+            // Rebuild system prompt with/without tools
+            this.messages[0] = {
+              role: 'system',
+              content: this.buildSystemPrompt(
+                await this.fileUtils.getProjectContext(),
+                { ...options, agent: this.agentMode }
+              ),
+            };
+            this.logger.success(`Agent mode: ${this.agentMode ? chalk.green('ON') : chalk.red('OFF')}`);
+            if (this.agentMode) {
+              console.log(chalk.yellow('  AI can now read files, edit code, and run commands.'));
+            }
+            break;
+            
+          case 'approve':
+            if (this.tools) {
+              options.autoApprove = !options.autoApprove;
+              this.tools = new AgenticTools(
+                this.logger,
+                options.project,
+                this.askPermission.bind(this),
+                options.autoApprove
+              );
+              this.logger.success(`Auto-approve: ${options.autoApprove ? chalk.green('ON') : chalk.red('OFF')}`);
+              if (options.autoApprove) {
+                console.log(chalk.red('  ⚠️  AI actions will be executed without confirmation!'));
+              }
+            }
+            break;
+            
+          case 'file':
+            if (args[0]) {
+              await this.addFileToContext(args[0]);
+            } else {
+              this.logger.error('Usage: /file <path>');
+            }
+            break;
+            
+          case 'edit':
+            if (args[0]) {
+              pendingChanges = await this.startEditMode(args[0], currentModel);
+            } else {
+              this.logger.error('Usage: /edit <path>');
+            }
+            break;
+            
+          case 'diff':
+            if (pendingChanges) {
+              this.showPendingDiff(pendingChanges);
+            } else {
+              this.logger.info('No pending changes');
+            }
+            break;
+            
+          case 'apply':
+            if (pendingChanges) {
+              this.applyChanges(pendingChanges);
+              pendingChanges = null;
+            } else {
+              this.logger.info('No pending changes to apply');
+            }
+            break;
+
+          case 'sessions':
+            this.listSessions();
+            break;
+
+          case 'history':
+            this.showHistory();
+            break;
+
+          case 'save':
+            if (this.currentSession) {
+              this.sessionManager.save(this.currentSession);
+              this.logger.success(`Session saved: ${this.currentSession.id}`);
+            }
+            break;
+
+          case 'new':
+            // Start new session
+            this.currentSession = this.sessionManager.create(
+              options.project,
+              currentModel,
+              this.agentMode
+            );
+            this.messages = [this.messages[0]]; // Keep only system message
+            this.logger.success(`New session: ${this.currentSession.id}`);
+            break;
+
+          case 'compact':
+            // Compact context by summarizing older messages
+            await this.compactContext(currentModel);
+            break;
+
+          case 'undo':
+            // Undo last file operation
+            if (this.tools) {
+              const undoResult = await this.tools.undo();
+              if (undoResult.success) {
+                this.logger.success(undoResult.output || 'Undo completed');
+                if (undoResult.metadata?.remainingUndos !== undefined) {
+                  console.log(chalk.gray(`  ${undoResult.metadata.remainingUndos} more undo(s) available`));
+                }
+              } else {
+                this.logger.error(undoResult.error || 'Nothing to undo');
+              }
+            } else {
+              this.logger.info('Undo is only available in agent mode. Use /agent to enable.');
+            }
+            break;
+            
+          case 'exit':
+          case 'quit':
+            // Auto-save session on exit
+            if (this.currentSession && this.messages.length > 1) {
+              this.sessionManager.save(this.currentSession);
+              console.log(chalk.gray(`Session saved: ${this.currentSession.id}`));
+            }
+            console.log(chalk.cyan('\nGoodbye! 👋\n'));
+            this.rl!.close();
+            return;
+            
+          default:
+            this.logger.warn(`Unknown command: /${cmd}`);
+        }
+        
+        this.rl!.prompt();
+        continue;
+      }
+
+      // Regular chat message
+      await this.chat(input, currentModel);
+      
+      // Save message to session
+      if (this.currentSession) {
+        this.currentSession.messages = [...this.messages];
+        this.sessionManager.save(this.currentSession);
+      }
+      
+      this.rl!.prompt();
+    }
+  }
+
+  private async chat(userInput: string, model: string): Promise<void> {
+    // Add user message (skip if empty - used for tool continuation)
+    if (userInput) {
+      this.messages.push({ role: 'user', content: userInput });
+    }
+
+    const spinner = ora({
+      text: chalk.gray('Thinking...'),
+      spinner: 'dots',
+    }).start();
+
+    try {
+      const response = await this.api.chat(this.messages, model, this.localMode);
+      
+      spinner.stop();
+      
+      // Add assistant message
+      this.messages.push({ role: 'assistant', content: response.message });
+
+      // Render markdown response
+      console.log();
+      console.log(chalk.cyan('vigthoria ›'));
+      console.log(this.marked.parse(response.message));
+      
+      // Show token usage
+      if (response.usage) {
+        console.log(chalk.gray(`[${response.usage.total_tokens} tokens]`));
+      }
+      console.log();
+
+      // In agent mode, check for and execute tool calls
+      if (this.agentMode && this.tools) {
+        const toolCalls = AgenticTools.parseToolCalls(response.message);
+        
+        if (toolCalls.length > 0) {
+          await this.executeToolCalls(toolCalls, model);
+        }
+      }
+
+    } catch (error) {
+      spinner.stop();
+      this.logger.error('Failed to get response:', (error as Error).message);
+      // Remove failed user message
+      this.messages.pop();
+    }
+  }
+
+  /**
+   * Execute tool calls from AI response (Claude Code-like)
+   */
+  private async executeToolCalls(calls: ToolCall[], model: string): Promise<void> {
+    const results: { tool: string; result: ToolResult }[] = [];
+    
+    for (const call of calls) {
+      console.log(chalk.yellow(`\n⚙ Executing: ${call.tool}`));
+      
+      const result = await this.tools!.execute(call);
+      results.push({ tool: call.tool, result });
+      
+      if (result.success) {
+        this.logger.success(`${call.tool}: Success`);
+        if (result.output) {
+          console.log(chalk.gray(this.truncateOutput(result.output)));
+        }
+      } else {
+        this.logger.error(`${call.tool}: ${result.error}`);
+      }
+    }
+    
+    // Send tool results back to AI for continuation
+    const toolResultsMessage: ChatMessage = {
+      role: 'user',
+      content: this.formatToolResults(results),
+    };
+    this.messages.push(toolResultsMessage);
+    
+    // Get AI's follow-up response
+    console.log();
+    await this.chat('', model);
+  }
+
+  /**
+   * Format tool results for AI context
+   */
+  private formatToolResults(
+    results: { tool: string; result: ToolResult }[]
+  ): string {
+    let msg = 'Tool execution results:\n\n';
+    
+    for (const { tool, result } of results) {
+      msg += `## ${tool}\n`;
+      msg += `Status: ${result.success ? 'Success' : 'Failed'}\n`;
+      if (result.output) {
+        msg += `Output:\n\`\`\`\n${this.truncateOutput(result.output)}\n\`\`\`\n`;
+      }
+      if (result.error) {
+        msg += `Error: ${result.error}\n`;
+      }
+      msg += '\n';
+    }
+    
+    msg += 'Continue with your analysis or next steps.';
+    return msg;
+  }
+
+  /**
+   * Truncate long output for context management
+   */
+  private truncateOutput(output: string, maxLines: number = 50): string {
+    const lines = output.split('\n');
+    if (lines.length <= maxLines) {
+      return output;
+    }
+    return lines.slice(0, maxLines).join('\n') + `\n... (${lines.length - maxLines} more lines)`;
+  }
+
+  /**
+   * Ask user for permission to execute dangerous action
+   */
+  private async askPermission(action: string): Promise<boolean> {
+    return new Promise((resolve) => {
+      console.log('\n' + action);
+      
+      if (!this.rl) {
+        resolve(false);
+        return;
+      }
+      
+      this.rl.question(chalk.yellow('Allow? [y/N] '), (answer) => {
+        const allowed = answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
+        resolve(allowed);
+      });
+    });
+  }
+
+  private async addFileToContext(filePath: string): Promise<void> {
+    const file = this.fileUtils.readFile(filePath);
+    
+    if (!file) {
+      this.logger.error(`File not found: ${filePath}`);
+      return;
+    }
+
+    // Add file content to messages
+    const fileMessage: ChatMessage = {
+      role: 'user',
+      content: `Here is the content of ${file.relativePath} (${file.language}, ${file.lines} lines):\n\n\`\`\`${file.language}\n${file.content}\n\`\`\``,
+    };
+    
+    this.messages.push(fileMessage);
+    this.logger.success(`Added ${file.relativePath} to context (${file.lines} lines)`);
+  }
+
+  private async startEditMode(
+    filePath: string,
+    model: string
+  ): Promise<{ file: string; content: string } | null> {
+    const file = this.fileUtils.readFile(filePath);
+    
+    if (!file) {
+      this.logger.error(`File not found: ${filePath}`);
+      return null;
+    }
+
+    console.log();
+    this.logger.section(`Editing: ${file.relativePath}`);
+    console.log(chalk.gray('What changes would you like to make?'));
+    console.log();
+
+    // This would enter a sub-REPL for editing
+    // For now, return the file info
+    return { file: file.path, content: file.content };
+  }
+
+  private showPendingDiff(changes: { file: string; content: string }): void {
+    const file = this.fileUtils.readFile(changes.file);
+    if (!file) return;
+
+    const diff = this.fileUtils.createDiff(file.content, changes.content);
+    
+    this.logger.section('Pending Changes');
+    this.logger.diff(diff.added, diff.removed);
+  }
+
+  private applyChanges(changes: { file: string; content: string }): void {
+    // Backup first
+    const backup = this.fileUtils.backupFile(changes.file);
+    if (backup) {
+      this.logger.info(`Backup created: ${backup}`);
+    }
+
+    // Apply
+    if (this.fileUtils.writeFile(changes.file, changes.content)) {
+      this.logger.success(`Changes applied to ${changes.file}`);
+    } else {
+      this.logger.error('Failed to apply changes');
+    }
+  }
+
+  private printHelp(): void {
+    console.log();
+    this.logger.section('Available Commands');
+    console.log(chalk.cyan('/file <path>') + '  - Add file to conversation context');
+    console.log(chalk.cyan('/edit <path>') + '  - Start editing a file');
+    console.log(chalk.cyan('/diff') + '         - Show pending changes');
+    console.log(chalk.cyan('/apply') + '        - Apply pending changes');
+    console.log(chalk.cyan('/model <name>') + ' - Switch AI model');
+    console.log(chalk.cyan('/agent') + '        - Toggle agentic mode (Claude Code-like)');
+    console.log(chalk.cyan('/approve') + '      - Toggle auto-approve for agent actions');
+    console.log(chalk.cyan('/undo') + '         - Undo last file operation (agent mode)');
+    console.log(chalk.cyan('/clear') + '        - Clear conversation history');
+    console.log(chalk.cyan('/compact') + '      - Compact context (summarize older messages)');
+    console.log(chalk.cyan('/sessions') + '     - List saved sessions');
+    console.log(chalk.cyan('/history') + '      - Show conversation history');
+    console.log(chalk.cyan('/save') + '         - Save current session');
+    console.log(chalk.cyan('/new') + '          - Start new session');
+    console.log(chalk.cyan('/help') + '         - Show this help');
+    console.log(chalk.cyan('/exit') + '         - Exit Vigthoria (auto-saves)');
+    console.log();
+    
+    if (this.agentMode) {
+      console.log(chalk.yellow('Agent Mode Tools:'));
+      console.log(chalk.gray('  read_file, write_file, edit_file, bash, grep, list_dir, glob, git'));
+      console.log();
+    }
+  }
+
+  private listSessions(): void {
+    const sessions = this.sessionManager.list();
+    
+    console.log();
+    this.logger.section('Saved Sessions');
+    
+    if (sessions.length === 0) {
+      console.log(chalk.gray('  No saved sessions'));
+    } else {
+      sessions.slice(0, 10).forEach(s => {
+        const current = this.currentSession?.id === s.id ? chalk.green(' (current)') : '';
+        const agent = s.agentMode ? chalk.yellow(' [agent]') : '';
+        console.log(chalk.cyan(s.id) + agent + current);
+        console.log(chalk.gray(`  ${s.project} - ${new Date(s.updatedAt).toLocaleString()}`));
+      });
+    }
+    console.log();
+  }
+
+  private showHistory(): void {
+    console.log();
+    this.logger.section('Conversation History');
+    
+    const userMessages = this.messages.filter(m => m.role !== 'system');
+    
+    if (userMessages.length === 0) {
+      console.log(chalk.gray('  No messages yet'));
+    } else {
+      userMessages.forEach((m, i) => {
+        const role = m.role === 'user' ? chalk.cyan('you') : chalk.green('vigthoria');
+        const preview = m.content.substring(0, 60).replace(/\n/g, ' ');
+        console.log(`${i + 1}. ${role}: ${chalk.gray(preview)}...`);
+      });
+    }
+    console.log();
+  }
+
+  private async compactContext(model: string): Promise<void> {
+    // If we have too many messages, summarize older ones
+    if (this.messages.length < 10) {
+      this.logger.info('Context is already compact');
+      return;
+    }
+
+    const spinner = ora({
+      text: chalk.gray('Compacting context...'),
+      spinner: 'dots',
+    }).start();
+
+    try {
+      // Keep system message and last 4 messages
+      const systemMessage = this.messages[0];
+      const recentMessages = this.messages.slice(-4);
+      const olderMessages = this.messages.slice(1, -4);
+
+      if (olderMessages.length === 0) {
+        spinner.stop();
+        this.logger.info('Nothing to compact');
+        return;
+      }
+
+      // Ask AI to summarize older conversation
+      const summaryResponse = await this.api.chat([
+        { role: 'system', content: 'Summarize this conversation in a concise way, preserving key context and decisions.' },
+        ...olderMessages,
+      ], model, this.localMode);
+
+      // Create compacted context
+      this.messages = [
+        systemMessage,
+        { role: 'system', content: `[Previous conversation summary]: ${summaryResponse.message}` },
+        ...recentMessages,
+      ];
+
+      spinner.stop();
+      this.logger.success(`Compacted ${olderMessages.length} messages into summary`);
+    } catch (error) {
+      spinner.stop();
+      this.logger.error('Failed to compact context:', (error as Error).message);
+    }
+  }
+
+  private printModels(): void {
+    const models = this.config.getAvailableModels();
+    
+    console.log();
+    this.logger.section('Available Models');
+    models.forEach(m => {
+      console.log(chalk.cyan(m.id.padEnd(20)) + chalk.gray(m.description));
+    });
+    console.log();
+  }
+}