nova-terminal-assistant 0.1.0

package/src/cli/startup/InkBasedRepl.ts

@@ -0,0 +1,1056 @@
+// ============================================================================
+// InkBasedRepl - Interactive REPL using Ink UI framework
+// A modern, component-based terminal UI similar to Claude Code
+// ============================================================================
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { spawn, execSync } from 'node:child_process';
+import chalk from 'chalk';
+import React from 'react';
+import { render } from 'ink';
+import type { NovaConfig } from '../core/types/config.js';
+import type { SessionId, ApprovalRequest, ApprovalResponse } from '../core/types/session.js';
+import type { McpManager, McpServerStatus } from '../core/mcp/McpManager.js';
+import type { SkillRegistry, SkillDefinition } from '../core/extensions/SkillRegistry.js';
+import type { ConfigManager } from '../core/config/ConfigManager.js';
+import type { AuthManager } from '../core/auth/AuthManager.js';
+import { AgentLoop } from '../core/session/AgentLoop.js';
+import { ModelClient } from '../core/model/ModelClient.js';
+import { SessionManager } from '../core/session/SessionManager.js';
+import { ToolRegistry } from '../core/tools/ToolRegistry.js';
+import { ApprovalManager } from '../core/security/ApprovalManager.js';
+import { buildSystemPrompt } from '../core/context/defaultSystemPrompt.js';
+import { ThinkingBlockRenderer } from '../ui/components/ThinkingBlockRenderer.js';
+import { selectModelInteractive, selectSkillInteractive } from '../ui/SimpleSelector2.js';
+
+// Import Ink components
+import { 
+  NovaInkApp, 
+  Spinner, 
+  StatusBar, 
+  InputBox, 
+  MessageList, 
+  ToolCallPanel, 
+  ThinkingBlock,
+  ProgressBar,
+  ConfirmDialog,
+  SelectList,
+  Toast,
+  Colors,
+} from '../ui/components/index.js';
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface ReplOptions {
+  modelClient: ModelClient;
+  sessionManager: SessionManager;
+  toolRegistry: ToolRegistry;
+  approvalManager: ApprovalManager;
+  authManager: AuthManager;
+  config: NovaConfig;
+  configManager: ConfigManager;
+  cwd: string;
+  contextCompressor?: any;
+  mcpManager?: McpManager;
+  skillRegistry?: SkillRegistry;
+  restoreSessionId?: SessionId;
+  /** --json: output in JSON format for machine parsing */
+  json?: boolean;
+  /** --no-input: non-interactive mode, never prompt for input */
+  noInput?: boolean;
+  /** --limit: maximum number of items to display */
+  limit?: number;
+}
+
+type InteractionMode = 'auto' | 'plan' | 'ask';
+
+interface Message {
+  id: string;
+  role: 'user' | 'assistant' | 'tool';
+  content: string;
+  timestamp: Date;
+  isThinking?: boolean;
+}
+
+interface ToolCall {
+  id: string;
+  name: string;
+  status: 'pending' | 'running' | 'success' | 'error';
+  duration?: number;
+  input?: string;
+}
+
+interface AppState {
+  model: string;
+  mode: InteractionMode;
+  contextUsage: number;
+  sessionId: string;
+  messages: Message[];
+  activeTools: ToolCall[];
+  processing: boolean;
+  thinkingContent: string;
+  showThinking: boolean;
+  mcpConnected: number;
+  mcpTotal: number;
+}
+
+// ============================================================================
+// Box drawing characters
+// ============================================================================
+
+const BOX = {
+  tl: '╭', tr: '╮', bl: '╰', br: '╯',
+  h: '─', v: '│', ht: '├', htr: '┤',
+  hThick: '━', vThick: '┃',
+  arrow: '›', bullet: '•', check: '✓', crossX: '✗', dot: '·',
+  diamond: '◆', star: '★',
+  spinner: ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'],
+};
+
+const MODE_LABELS = {
+  auto: { label: 'AUTO', color: chalk.green.bold, description: 'Full autonomous' },
+  plan: { label: 'PLAN', color: chalk.yellow.bold, description: 'Plan first' },
+  ask:  { label: 'ASK',  color: chalk.cyan.bold, description: 'Answer only' },
+};
+
+// ============================================================================
+// InkBasedRepl Class
+// ============================================================================
+
+export class InkBasedRepl {
+  private modelClient: ModelClient;
+  private sessionManager: SessionManager;
+  private toolRegistry: ToolRegistry;
+  private approvalManager: ApprovalManager;
+  private authManager: AuthManager;
+  private config: NovaConfig;
+  private configManager: ConfigManager;
+  private cwd: string;
+  private contextCompressor?: any;
+  private mcpManager?: McpManager;
+  private skillRegistry?: SkillRegistry;
+  private sessionId: SessionId | null = null;
+  private restoreSessionId?: SessionId;
+
+  private currentLoop: AgentLoop | null = null;
+  private state: AppState;
+  private _pendingSkillInject: SkillDefinition | null = null;
+  
+  // Thinking renderer for non-Ink fallback
+  private thinkingRenderer: ThinkingBlockRenderer;
+  
+  // UI state
+  private showHelp = false;
+  private showModelSelector = false;
+  private processing = false;
+  private currentText: string = '';
+  private pendingToolCalls: Map<string, { name: string; startTime: number }> = new Map();
+  
+  // Store initial config for recreating ModelClient
+  private initialConfig: NovaConfig;
+  
+  // Agent-first options
+  private json: boolean;
+  private noInput: boolean;
+  private limit: number;
+
+  constructor(options: ReplOptions) {
+    this.modelClient = options.modelClient;
+    this.sessionManager = options.sessionManager;
+    this.toolRegistry = options.toolRegistry;
+    this.approvalManager = options.approvalManager;
+    this.authManager = options.authManager;
+    this.config = options.config;
+    this.initialConfig = JSON.parse(JSON.stringify(options.config)); // Deep copy
+    this.configManager = options.configManager;
+    this.cwd = options.cwd;
+    this.contextCompressor = options.contextCompressor;
+    this.mcpManager = options.mcpManager;
+    this.skillRegistry = options.skillRegistry;
+    this.restoreSessionId = options.restoreSessionId;
+    
+    // Agent-first options
+    this.json = options.json ?? false;
+    this.noInput = options.noInput ?? false;
+    this.limit = options.limit ?? 20; // Default limit for bounded output
+
+    this.thinkingRenderer = new ThinkingBlockRenderer({
+      expanded: false,
+      maxPreviewLines: 4,
+      maxLineLength: 80,
+      showStreamingPreview: false,
+    });
+
+    // Initialize state
+    this.state = {
+      model: this.modelClient.getModel(),
+      mode: (this.config.core.defaultApprovalMode === 'yolo' ? 'auto' : 
+             this.config.core.defaultApprovalMode === 'plan' ? 'plan' : 'ask') as InteractionMode,
+      contextUsage: 0,
+      sessionId: 'new',
+      messages: [],
+      activeTools: [],
+      processing: false,
+      thinkingContent: '',
+      showThinking: true,
+      mcpConnected: 0,
+      mcpTotal: 0,
+    };
+  }
+
+  // ========================================================================
+  // Lifecycle
+  // ========================================================================
+
+  async start(): Promise<void> {
+    // Restore or create session
+    if (this.restoreSessionId) {
+      const existing = this.sessionManager.get(this.restoreSessionId);
+      this.sessionId = existing ? this.restoreSessionId : this.createInitialSession();
+    } else {
+      this.sessionId = this.createInitialSession();
+    }
+
+    // Set approval handler
+    this.approvalManager.setHandler(this.handleApproval.bind(this));
+
+    // Print initial banner (simplified)
+    this.printBanner();
+
+    // Start interactive loop
+    await this.runInputLoop();
+  }
+
+  private createInitialSession(): SessionId {
+    const session = this.sessionManager.create({
+      workingDirectory: this.cwd,
+      model: this.modelClient.getModel(),
+      maxTokens: this.config.core.maxTokens,
+      temperature: this.config.core.temperature,
+      approvalMode: this.getEffectiveApprovalMode() as any,
+      streaming: true,
+      maxTurns: this.config.core.maxTurns,
+    });
+    return session.id;
+  }
+
+  // ========================================================================
+  // Agent-First: JSON Output Helpers
+  // ========================================================================
+
+  /**
+   * Output structured JSON data when --json flag is set
+   * This enables machine-parseable output for Agent consumers
+   */
+  private outputJSON(data: any): void {
+    if (this.json) {
+      console.log(JSON.stringify(data, null, 2));
+    }
+  }
+
+  /**
+   * Output structured error in JSON format
+   */
+  private outputErrorJSON(code: string, message: string, suggestion?: string, example?: string): void {
+    if (this.json) {
+      console.log(JSON.stringify({
+        error: {
+          code,
+          message,
+          suggestion,
+          example
+        }
+      }, null, 2));
+    }
+  }
+
+  /**
+   * Check if we should suppress interactive elements
+   */
+  private shouldSuppressInteractive(): boolean {
+    return this.noInput || this.json;
+  }
+
+  /**
+   * Apply limit to array results for bounded output
+   */
+  private applyLimit<T>(items: T[]): { items: T[]; total: number; showing: string; hint?: string } {
+    const total = items.length;
+    const limited = items.slice(0, this.limit);
+    const showing = `Showing ${limited.length} of ${total}`;
+    const hint = total > this.limit ? `Use --limit ${total} to see all items` : undefined;
+    
+    return { items: limited, total, showing, hint };
+  }
+
+  // ========================================================================
+  // Banner & UI
+  // ========================================================================
+
+  private printBanner(): void {
+    const w = 70;
+    const hr = chalk.hex('#7C3AED').dim(BOX.h.repeat(w));
+    const hrThick = chalk.hex('#7C3AED')(BOX.hThick.repeat(w));
+    const vl = chalk.hex('#7C3AED').dim(BOX.v);
+
+    const modelShort = this.modelClient.getModel().split('/').pop() || this.modelClient.getModel();
+    const modeInfo = MODE_LABELS[this.state.mode];
+
+    console.log('');
+    console.log(chalk.hex('#7C3AED')(BOX.tl) + hrThick + chalk.hex('#7C3AED')(BOX.tr));
+    
+    // Logo
+    console.log(vl + chalk.hex('#7C3AED').bold('  NOVA ') + 
+                chalk.hex('#A78BFA')('CLI') + 
+                chalk.dim(' · AI-powered terminal assistant') + ' '.repeat(24) + vl);
+    
+    console.log(chalk.hex('#7C3AED')(BOX.ht) + hr + chalk.hex('#7C3AED')(BOX.htr));
+
+    // Status line
+    console.log(vl + '  Model: ' + chalk.white(modelShort) + ' '.repeat(Math.max(0, 52 - modelShort.length)) + vl);
+    console.log(vl + '  Mode:  ' + modeInfo.color(modeInfo.label) + ' '.repeat(52) + vl);
+    console.log(vl + '  Dir:   ' + chalk.gray(this.cwd.slice(-50)) + ' '.repeat(Math.max(0, 52 - Math.min(50, this.cwd.length))) + vl);
+
+    console.log(chalk.hex('#7C3AED')(BOX.bl) + hrThick + chalk.hex('#7C3AED')(BOX.br));
+    console.log('');
+  }
+
+  private printPrompt(): void {
+    const modeInfo = MODE_LABELS[this.state.mode];
+    const modelShort = this.modelClient.getModel().split('/').pop() || this.modelClient.getModel();
+    
+    const modeBadge = modeInfo.color(`[${modeInfo.label}]`);
+    const ctxStr = this.state.contextUsage > 0 ? 
+      chalk.dim(` (${this.state.contextUsage}% ctx)`) : '';
+    
+    process.stdout.write(`\n${modeBadge} ${chalk.gray(modelShort)}${ctxStr} ${chalk.hex('#7C3AED')('›')} `);
+  }
+
+  // ========================================================================
+  // Input Loop
+  // ========================================================================
+
+  private async runInputLoop(): Promise<void> {
+    const readline = await import('node:readline');
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      historySize: 200,
+      removeHistoryDuplicates: true,
+    });
+
+    // Guard flag: when true, rl 'close' is a false alarm from raw-mode pause/resume
+    let closeGuard = false;
+
+    // Handle Ctrl+C
+    process.on('SIGINT', () => {
+      if (this.currentLoop?.isActive()) {
+        this.currentLoop.cancel();
+        this.processing = false;
+        process.stdout.write('\n');
+        this.printPrompt();
+      } else {
+        console.log(chalk.dim('\n  Use /quit or Ctrl+D to exit'));
+        this.printPrompt();
+      }
+    });
+
+    rl.on('close', () => {
+      // Ignore close events triggered by raw-mode pause/resume during
+      // interactive selectors (SimpleSelector2, etc.)
+      if (closeGuard) {
+        closeGuard = false;
+        process.stdin.resume();
+        return;
+      }
+      if (this.sessionId) this.sessionManager.persist(this.sessionId);
+      console.log(chalk.dim('\nGoodbye!'));
+      process.exit(0);
+    });
+
+    // Main loop
+    while (true) {
+      this.printPrompt();
+      
+      const input = await new Promise<string>((resolve) => {
+        rl.question('', resolve);
+      });
+
+      if (!input.trim()) continue;
+
+      // Set guard before dispatching — commands may enter/leave raw mode
+      closeGuard = true;
+      this.processing = true;
+      await this.dispatchInput(input.trim());
+      this.processing = false;
+      closeGuard = false;
+    }
+  }
+
+  private async dispatchInput(input: string): Promise<void> {
+    // Handle commands
+    if (input.startsWith('/')) {
+      await this.handleCommand(input);
+      return;
+    }
+
+    // Handle shell commands
+    if (input.startsWith('!')) {
+      await this.handleShellCommand(input.slice(1).trim());
+      return;
+    }
+
+    // Process normal input
+    await this.processInput(input);
+  }
+
+  // ========================================================================
+  // Command Handlers
+  // ========================================================================
+
+  private async handleCommand(cmd: string): Promise<void> {
+    const parts = cmd.slice(1).split(/\s+/);
+    const command = (parts[0] || '').toLowerCase();
+    const arg = parts.slice(1).join(' ');
+
+    switch (command) {
+      case 'quit':
+      case 'exit':
+      case 'q':
+        if (this.sessionId) this.sessionManager.persist(this.sessionId);
+        console.log(chalk.dim('Goodbye!'));
+        process.exit(0);
+
+      case 'help':
+      case 'h':
+      case '?':
+        this.printHelp();
+        break;
+
+      case 'clear':
+        if (this.sessionId) this.sessionManager.persist(this.sessionId);
+        this.sessionId = this.createInitialSession();
+        this.state.messages = [];
+        this.state.contextUsage = 0;
+        console.log(chalk.dim('  Conversation cleared.'));
+        break;
+
+      case 'mode':
+        if (arg && ['auto', 'plan', 'ask'].includes(arg)) {
+          this.state.mode = arg as InteractionMode;
+          console.log(chalk.dim(`  Mode: ${arg}`));
+        } else {
+          // Cycle mode
+          const modes: InteractionMode[] = ['auto', 'plan', 'ask'];
+          const idx = modes.indexOf(this.state.mode);
+          this.state.mode = modes[(idx + 1) % 3] as InteractionMode;
+          console.log(chalk.dim(`  Mode: ${this.state.mode}`));
+        }
+        break;
+
+      case 'model':
+        await this.handleModelCommand(arg);
+        break;
+
+      case 'ollama':
+        await this.handleOllamaCommand(arg);
+        break;
+
+      case 'status':
+        this.printStatus();
+        break;
+
+      case 'mcp':
+        await this.handleMcpCommand(arg);
+        break;
+
+      case 'skills':
+        await this.handleSkillsCommand(arg);
+        break;
+
+      case 'thinking':
+        this.state.showThinking = !this.state.showThinking;
+        console.log(chalk.dim(`  Thinking: ${this.state.showThinking ? 'ON' : 'OFF'}`));
+        break;
+
+      default:
+        console.log(chalk.yellow(`  Unknown command: /${command}`));
+    }
+  }
+
+  private printHelp(): void {
+    console.log('');
+    console.log(chalk.hex('#7C3AED').bold('  Commands:'));
+    console.log(chalk.gray('  /help, /h        Show this help'));
+    console.log(chalk.gray('  /quit, /q        Exit Nova CLI'));
+    console.log(chalk.gray('  /clear           Clear conversation'));
+    console.log(chalk.gray('  /mode            Cycle mode (AUTO → PLAN → ASK)'));
+    console.log(chalk.gray('  /model           Switch model'));
+    console.log(chalk.gray('  /ollama          Ollama status'));
+    console.log(chalk.gray('  /status          Session status'));
+    console.log(chalk.gray('  /mcp             MCP servers'));
+    console.log(chalk.gray('  /skills          Available skills'));
+    console.log(chalk.gray('  /thinking        Toggle thinking display'));
+    console.log('');
+    console.log(chalk.gray('  @file            Inject file content'));
+    console.log(chalk.gray('  !command         Run shell command'));
+    console.log('');
+  }
+
+  private async handleModelCommand(arg: string): Promise<void> {
+    if (!arg) {
+      // Interactive model selection — only show configured providers
+      const config = this.configManager.getConfig();
+      const models: Array<{provider: string, model: string, description?: string}> = [];
+
+      // Collect models only from configured/available providers
+      for (const [provider, providerConfig] of Object.entries(config.models.providers)) {
+        const hasCreds = this.authManager.hasCredentials(provider);
+        const isOllama = providerConfig.type === 'ollama';
+        const isOllamaCloud = providerConfig.type === 'ollama-cloud';
+
+        // Skip providers that are not configured
+        if (!hasCreds && !isOllama && !isOllamaCloud) continue;
+
+        // For Ollama, verify it's actually running
+        if (isOllama && !hasCreds) {
+          try {
+            const baseUrl = process.env.OLLAMA_HOST || 'http://localhost:11434';
+            const resp = await fetch(`${baseUrl}/api/tags`, { signal: AbortSignal.timeout(2000) });
+            if (!resp.ok) continue; // Ollama not running
+          } catch {
+            continue; // Ollama not running
+          }
+        }
+
+        for (const [modelId, modelConfig] of Object.entries(providerConfig.models)) {
+          const features: string[] = [];
+          if (modelConfig.supportsVision) features.push('vision');
+          if (modelConfig.supportsTools) features.push('tools');
+          if (modelConfig.supportsThinking) features.push('thinking');
+
+          const description = features.length > 0 ? `[${features.join(', ')}]` : '';
+          models.push({
+            provider,
+            model: modelId,
+            description,
+          });
+        }
+      }
+
+      if (models.length === 0) {
+        console.log(chalk.yellow('  No models available. Configure a provider first.'));
+        console.log(chalk.gray('  Use: nova auth set <provider>'));
+        return;
+      }
+
+      // Show interactive selector (returns "provider/model" format)
+      const selectedModel = await selectModelInteractive(models);
+
+      if (selectedModel && selectedModel !== 'separator' && !selectedModel.startsWith('provider:')) {
+        const success = await this.switchModel(selectedModel);
+        if (success) {
+          console.log(chalk.green(`  ✓ Switched to: ${selectedModel}`));
+        }
+        // If failed, switchModel already printed an error message
+      } else if (selectedModel && selectedModel.startsWith('provider:')) {
+        console.log(chalk.dim('  Please select a specific model, not a provider header'));
+      } else {
+        console.log(chalk.dim('  Model selection cancelled'));
+      }
+    } else {
+      // Direct model switch
+      const success = await this.switchModel(arg);
+      if (success) {
+        console.log(chalk.green(`  ✓ Switched to: ${arg}`));
+      }
+    }
+  }
+
+  private async handleOllamaCommand(arg: string): Promise<void> {
+    const creds = this.authManager.getCredentials('ollama');
+    const baseUrl = creds?.baseUrl || process.env.OLLAMA_HOST || 'http://localhost:11434';
+    
+    console.log(chalk.hex('#7C3AED')('\n  Ollama Status:'));
+    console.log(chalk.gray(`  Host: ${baseUrl}`));
+    
+    try {
+      const response = await fetch(`${baseUrl}/api/tags`);
+      if (response.ok) {
+        const data = await response.json() as { models: Array<{ name: string; size: number }> };
+        console.log(chalk.green('  Status: Running'));
+        console.log(chalk.gray(`  Models: ${data.models?.length || 0} installed`));
+        if (data.models?.length > 0) {
+          data.models.slice(0, 5).forEach((m: any) => {
+            console.log(chalk.gray(`    - ${m.name}`));
+          });
+        }
+      } else {
+        console.log(chalk.yellow('  Status: Not responding'));
+      }
+    } catch {
+      console.log(chalk.red('  Status: Not running'));
+      console.log(chalk.gray('  Start with: ollama serve'));
+    }
+    console.log('');
+  }
+
+  /**
+   * Switch to a different model, potentially across providers.
+   * Accepts "provider/model" or bare "model" format.
+   * Persists selection to global config.
+   */
+  private async switchModel(modelId: string): Promise<boolean> {
+    try {
+      // Parse provider/model format (e.g., "ollama/gemma3:4b")
+      let providerName: string;
+      let actualModelId: string;
+
+      if (modelId.includes('/')) {
+        const idx = modelId.indexOf('/');
+        providerName = modelId.substring(0, idx);
+        actualModelId = modelId.substring(idx + 1);
+      } else {
+        // Bare model name — look up in config to find provider
+        const modelConfig = this.configManager.getModelConfig(modelId);
+        if (!modelConfig) {
+          // Might be an Ollama model
+          if (this.authManager.hasCredentials('ollama') || process.env.OLLAMA_HOST) {
+            providerName = 'ollama';
+            actualModelId = modelId;
+          } else {
+            console.log(chalk.red(`  ✗ Model "${modelId}" not found in config`));
+            return false;
+          }
+        } else {
+          const config = this.configManager.getConfig();
+          for (const [name, p] of Object.entries(config.models.providers)) {
+            if (p === modelConfig.provider || p.models === modelConfig.provider.models) {
+              providerName = name;
+              break;
+            }
+          }
+          actualModelId = modelId;
+          if (!providerName) {
+            console.log(chalk.red(`  ✗ Cannot determine provider for "${modelId}"`));
+            return false;
+          }
+        }
+      }
+
+      // Get provider config
+      const config = this.configManager.getConfig();
+      const providerConfig = config.models.providers[providerName];
+      if (!providerConfig) {
+        console.log(chalk.red(`  ✗ Unknown provider: "${providerName}"`));
+        return false;
+      }
+
+      const providerType = providerConfig.type;
+      const creds = this.authManager.getCredentials(providerName);
+
+      // For non-Ollama providers, require API key
+      const isOllamaType = providerType === 'ollama' || providerName === 'ollama' || providerName === 'ollama-cloud';
+      if (!isOllamaType && !creds?.apiKey) {
+        console.log(chalk.yellow(`  ⚠ No API key found for "${providerName}"`));
+        console.log(chalk.gray(`  Set it with: nova auth set ${providerName}`));
+        return false;
+      }
+
+      // Create new ModelClient with correct provider
+      this.modelClient = new ModelClient({
+        provider: providerType as any,
+        apiKey: creds?.apiKey,
+        baseUrl: creds?.baseUrl || providerConfig.baseUrl,
+        model: actualModelId,
+        maxTokens: this.config.core.maxTokens,
+        temperature: this.config.core.temperature,
+        organizationId: creds?.organizationId,
+        codingPlanPlatform: providerConfig.codingPlanPlatform as any,
+      });
+
+      // Update state
+      this.state.model = `${providerName}/${actualModelId}`;
+
+      // Persist to global config
+      config.core.defaultModel = `${providerName}/${actualModelId}`;
+      await this.configManager.save(config);
+
+      return true;
+    } catch (err) {
+      console.log(chalk.red(`  ✗ Error switching model: ${(err as Error).message}`));
+      return false;
+    }
+  }
+
+  private printStatus(): void {
+    console.log(chalk.hex('#7C3AED')('\n  Session Status:'));
+    console.log(chalk.gray(`  Session: ${this.sessionId?.slice(0, 8) || 'none'}`));
+    console.log(chalk.gray(`  Model:   ${this.state.model}`));
+    console.log(chalk.gray(`  Mode:    ${this.state.mode}`));
+    console.log(chalk.gray(`  Context: ${this.state.contextUsage}%`));
+    console.log(chalk.gray(`  Messages: ${this.state.messages.length}`));
+    console.log('');
+  }
+
+  private printMcpStatus(): void {
+    if (!this.mcpManager) {
+      console.log(chalk.gray('  MCP not initialized'));
+      return;
+    }
+    
+    const statuses = this.mcpManager.listServers();
+    if (statuses.length === 0) {
+      console.log(chalk.gray('  No MCP servers configured'));
+      return;
+    }
+
+    console.log(chalk.hex('#7C3AED')('\n  MCP Servers:'));
+    for (const s of statuses) {
+      const icon = s.connected ? chalk.green('✓') : chalk.red('✗');
+      console.log(chalk.gray(`  ${icon} ${s.name}: ${s.connected ? 'connected' : 'disconnected'}`));
+    }
+    console.log('');
+  }
+
+  private async handleMcpCommand(arg: string): Promise<void> {
+    if (!this.mcpManager) {
+      console.log(chalk.gray('  MCP not initialized'));
+      return;
+    }
+    
+    const statuses = this.mcpManager.listServers();
+    
+    if (statuses.length === 0) {
+      console.log(chalk.gray('  No MCP servers configured'));
+      console.log(chalk.dim('  Add servers to ~/.nova/config.yaml under "mcp:"'));
+      return;
+    }
+
+    if (!arg) {
+      // Show status (non-interactive for now)
+      this.printMcpStatus();
+    } else {
+      // Specific server action requested
+      console.log(chalk.green(`  MCP server: ${arg}`));
+      console.log(chalk.dim('  Note: MCP server management not yet implemented in interactive mode'));
+    }
+  }
+
+  private printSkillsStatus(): void {
+    if (!this.skillRegistry) {
+      console.log(chalk.gray('  Skills not initialized'));
+      return;
+    }
+
+    // We'd need async for this, but for now just show a message
+    console.log(chalk.hex('#7C3AED')('\n  Skills:'));
+    console.log(chalk.gray('  Use /skills <name> to inject a skill'));
+    console.log('');
+  }
+
+  private async handleSkillsCommand(arg: string): Promise<void> {
+    if (!this.skillRegistry) {
+      console.log(chalk.gray('  Skills not initialized'));
+      return;
+    }
+
+    if (!arg) {
+      // Interactive skill selection
+      try {
+        const skills = await this.skillRegistry.list();
+        if (skills.length === 0) {
+          console.log(chalk.dim('  No skills installed. Use "nova skills install" to install skills.'));
+          return;
+        }
+
+        const skillItems = skills.map(skill => ({
+          name: skill.metadata.name,
+          description: skill.metadata.description,
+        }));
+
+        const selectedSkill = await selectSkillInteractive(skillItems);
+        
+        if (selectedSkill) {
+          console.log(chalk.green(`  ✓ Selected skill: ${selectedSkill}`));
+          console.log(chalk.dim('  Note: Skill injection not yet implemented in interactive mode'));
+        } else {
+          console.log(chalk.dim('  Skill selection cancelled'));
+        }
+      } catch (error) {
+        console.log(chalk.red(`  Error loading skills: ${(error as Error).message}`));
+      }
+    } else {
+      // Specific skill requested
+      console.log(chalk.green(`  ✓ Selected skill: ${arg}`));
+      console.log(chalk.dim('  Note: Skill injection not yet implemented in interactive mode'));
+    }
+  }
+
+  // ========================================================================
+  // Shell Command Handler
+  // ========================================================================
+
+  private async handleShellCommand(cmd: string): Promise<void> {
+    if (!cmd) {
+      console.log(chalk.gray('  Usage: !<command>'));
+      return;
+    }
+
+    console.log(chalk.gray(`  $ ${cmd}`));
+    const startTime = Date.now();
+
+    try {
+      const isWin = process.platform === 'win32';
+      const shell = isWin ? 'powershell.exe' : '/bin/sh';
+      const shellArgs = isWin ? ['-Command', cmd] : ['-c', cmd];
+
+      await new Promise<void>((resolve, reject) => {
+        const child = spawn(shell, shellArgs, {
+          cwd: this.cwd,
+          stdio: ['inherit', 'pipe', 'pipe'],
+        });
+
+        child.stdout?.on('data', (chunk: Buffer) => process.stdout.write(chunk.toString()));
+        child.stderr?.on('data', (chunk: Buffer) => process.stderr.write(chunk.toString()));
+
+        child.on('close', (code) => {
+          const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+          if (code === 0) {
+            console.log(chalk.green(`  ✓ exit 0`) + chalk.dim(` (${duration}s)`));
+          } else {
+            console.log(chalk.red(`  ✗ exit ${code}`) + chalk.dim(` (${duration}s)`));
+          }
+          resolve();
+        });
+
+        child.on('error', reject);
+      });
+    } catch (err) {
+      console.log(chalk.red(`  Error: ${(err as Error).message}`));
+    }
+  }
+
+  // ========================================================================
+  // Input Processing
+  // ========================================================================
+
+  private async processInput(input: string): Promise<void> {
+    if (!this.sessionId) return;
+
+    // Expand @file references
+    const expandedInput = await this.expandAtReferences(input);
+
+    // Show user message
+    console.log('');
+    console.log(chalk.dim('  • ') + chalk.white(input));
+    console.log(chalk.dim('  ' + BOX.h.repeat(20)));
+
+    // Add to messages
+    this.state.messages.push({
+      id: Date.now().toString(),
+      role: 'user',
+      content: input,
+      timestamp: new Date(),
+    });
+
+    // Get mode prefix
+    const modePrefix = this.getModePrefix();
+    const fullInput = modePrefix ? `${modePrefix}\n\n${expandedInput}` : expandedInput;
+
+    // Build system prompt
+    const systemPrompt = buildSystemPrompt({
+      workingDirectory: this.cwd,
+      model: this.modelClient.getModel(),
+      approvalMode: this.getEffectiveApprovalMode(),
+    });
+
+    // Create agent loop
+    this.currentLoop = new AgentLoop({
+      modelClient: this.modelClient,
+      sessionManager: this.sessionManager,
+      toolRegistry: this.toolRegistry,
+      systemPrompt,
+      contextCompressor: this.contextCompressor,
+      maxContextTokens: (this.config.core.maxTokens || 16384) * 8,
+
+      onTextDelta: (text: string) => {
+        this.currentText += text;
+        process.stdout.write(text);
+      },
+
+      onToolStart: (name: string, toolCallId: string) => {
+        this.pendingToolCalls.set(toolCallId, { name, startTime: Date.now() });
+        console.log(chalk.cyan(`\n  ⚡ ${name}`));
+      },
+
+      onToolComplete: (name: string, toolCallId: string, result: any) => {
+        const info = this.pendingToolCalls.get(toolCallId);
+        if (info) {
+          const duration = Date.now() - info.startTime;
+          const icon = result.isError ? chalk.red('✗') : chalk.green('✓');
+          console.log(` ${icon} ${chalk.dim(`(${duration}ms)`)}`);
+          this.pendingToolCalls.delete(toolCallId);
+        }
+      },
+
+      onThinkingStart: () => {
+        if (this.state.showThinking) {
+          this.thinkingRenderer.start();
+        }
+      },
+
+      onThinkingDelta: (delta: string) => {
+        if (this.state.showThinking) {
+          this.thinkingRenderer.append(delta);
+        }
+      },
+
+      onThinkingEnd: () => {
+        if (this.state.showThinking) {
+          this.thinkingRenderer.complete();
+        }
+      },
+
+      onApprovalRequired: this.handleApproval.bind(this),
+
+      onTurnStart: (turn: number) => {
+        if (turn > 1) {
+          console.log(chalk.dim(`\n  ─── turn ${turn} ───`));
+        }
+      },
+
+      onTurnEnd: () => {
+        // Nothing
+      },
+
+      onContextCompress: (orig: number, result: number, action: string) => {
+        console.log(chalk.dim(`\n  → context: ${orig} → ${result} tokens (${action})`));
+      },
+    });
+
+    try {
+      const result = await this.currentLoop.runStream(this.sessionId, fullInput);
+      
+      // Add assistant message
+      this.state.messages.push({
+        id: (Date.now() + 1).toString(),
+        role: 'assistant',
+        content: this.currentText,
+        timestamp: new Date(),
+      });
+
+      // Update context usage
+      const totalTokens = result.totalInputTokens + result.totalOutputTokens;
+      this.state.contextUsage = Math.min(100, Math.round((totalTokens / 128000) * 100));
+
+      // Show summary
+      console.log('');
+      console.log(chalk.dim(`  ✓ ${result.turnsCompleted} turns · ${totalTokens.toLocaleString()} tokens`));
+
+      // Persist session
+      this.sessionManager.persist(this.sessionId);
+
+    } catch (err) {
+      if ((err as any).name !== 'CancelledError') {
+        console.log(chalk.red(`\n  Error: ${(err as Error).message}`));
+      }
+    } finally {
+      this.currentLoop = null;
+      this.currentText = '';
+    }
+  }
+
+  // ========================================================================
+  // @ File Reference Expansion
+  // ========================================================================
+
+  private async expandAtReferences(input: string): Promise<string> {
+    const atPattern = /@([\w./\-\\]+)/g;
+    const matches = [...input.matchAll(atPattern)];
+    if (matches.length === 0) return input;
+
+    const injections: string[] = [];
+
+    for (const match of matches) {
+      const refPath = match[1];
+      if (!refPath) continue;
+      
+      const absPath = path.isAbsolute(refPath) 
+        ? refPath 
+        : path.resolve(this.cwd, refPath);
+
+      try {
+        if (!fs.existsSync(absPath)) {
+          injections.push(`[@${refPath}: not found]`);
+          continue;
+        }
+
+        const stat = fs.statSync(absPath);
+        if (stat.isDirectory()) {
+          const files = fs.readdirSync(absPath).slice(0, 20);
+          injections.push(`\n\`\`\`\n# Directory: ${refPath}\n${files.join('\n')}\n\`\`\`\n`);
+        } else {
+          const content = fs.readFileSync(absPath, 'utf-8');
+          const ext = path.extname(refPath).slice(1) || 'txt';
+          injections.push(`\n\`\`\`${ext}\n# ${refPath}\n${content}\n\`\`\`\n`);
+        }
+        console.log(chalk.dim(`  @ ${refPath}`));
+      } catch (err) {
+        injections.push(`[@${refPath}: error]`);
+      }
+    }
+
+    return input + '\n' + injections.join('\n');
+  }
+
+  // ========================================================================
+  // Approval Handler
+  // ========================================================================
+
+  private async handleApproval(request: ApprovalRequest): Promise<ApprovalResponse> {
+    const mode = this.getEffectiveApprovalMode();
+
+    if (mode === 'yolo' || mode === 'accepting_edits') {
+      return { requestId: request.id, approved: true };
+    }
+
+    console.log('');
+    console.log(chalk.yellow.bold('  ⚠ Approval Required'));
+    console.log(chalk.gray(`  Tool: ${request.toolName}`));
+    console.log(chalk.gray(`  Risk: ${request.risk}`));
+    console.log('');
+
+    // For now, auto-approve in non-interactive mode
+    // In a full implementation, this would use a ConfirmDialog
+    return { requestId: request.id, approved: true };
+  }
+
+  // ========================================================================
+  // Helpers
+  // ========================================================================
+
+  private getModePrefix(): string {
+    switch (this.state.mode) {
+      case 'plan':
+        return '[PLAN MODE] First analyze and create a step-by-step plan. Wait for confirmation before executing.';
+      case 'ask':
+        return '[ASK MODE] Only answer questions. Do NOT modify files or execute commands.';
+      default:
+        return '';
+    }
+  }
+
+  private getEffectiveApprovalMode(): string {
+    switch (this.state.mode) {
+      case 'auto': return 'yolo';
+      case 'plan': return 'plan';
+      case 'ask': return 'plan';
+      default: return 'default';
+    }
+  }
+}