@alia-codea/cli 1.0.0 → 2.0.0

package/src/commands/repl.ts

@@ -1,309 +1,21 @@
-import * as readline from 'readline';
-import chalk from 'chalk';
-import { config, createSession, saveSession } from '../utils/config.js';
-import { streamChat } from '../utils/api.js';
-import { executeTool, formatToolCall } from '../tools/executor.js';
-import {
-  printBanner,
-  printTips,
-  printPrompt,
-  printToolExecution,
-  printToolResult,
-  showThinkingStatus,
-  hideThinkingStatus,
-  printStatusBar,
-  printAssistantPrefix,
-  printError,
-  printInfo
-} from '../utils/ui.js';
-import { buildSystemMessage, getCodebaseContext } from '../utils/context.js';
-
-interface Message {
-  role: 'user' | 'assistant' | 'system' | 'tool';
-  content: string;
-  tool_calls?: any[];
-  tool_call_id?: string;
-}
+import React from 'react';
+import { render } from 'ink';
+import { App, AppOptions } from '../app.js';
+import { ApprovalMode } from '../utils/approval.js';
 
 interface ReplOptions {
   model: string;
   context: boolean;
+  approvalMode?: string;
 }
 
 export async function startRepl(options: ReplOptions): Promise<void> {
-  const session = createSession();
-  const messages: Message[] = [];
-  let isProcessing = false;
-  let contextUsed = 0;
-  const maxContext = 128000;
-
-  // Print welcome UI
-  printTips();
-
-  // Get initial codebase context
-  let codebaseContext = '';
-  if (options.context !== false) {
-    printInfo('Analyzing codebase...');
-    codebaseContext = await getCodebaseContext();
-    if (codebaseContext) {
-      printInfo(`Loaded context from ${codebaseContext.split('\n').length} files`);
-    }
-  }
-
-  // Setup readline
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    terminal: true
-  });
-
-  // Handle Ctrl+C
-  rl.on('SIGINT', () => {
-    if (isProcessing) {
-      isProcessing = false;
-      hideThinkingStatus();
-      console.log(chalk.yellow('\nCancelled.'));
-      printPrompt();
-    } else {
-      console.log(chalk.gray('\nGoodbye!'));
-      process.exit(0);
-    }
-  });
-
-  const askQuestion = (): void => {
-    printPrompt();
-    rl.question('', async (input) => {
-      const trimmed = input.trim();
-
-      if (!trimmed) {
-        askQuestion();
-        return;
-      }
-
-      // Handle slash commands
-      if (trimmed.startsWith('/')) {
-        await handleSlashCommand(trimmed, messages, session, options);
-        askQuestion();
-        return;
-      }
-
-      // Add user message
-      messages.push({ role: 'user', content: trimmed });
-      isProcessing = true;
-
-      // Build system message
-      const systemMessage = buildSystemMessage(options.model, codebaseContext);
-
-      // Process conversation with tool loop
-      await processConversation(messages, systemMessage, options.model, () => isProcessing);
-
-      isProcessing = false;
-
-      // Update session
-      session.messages = messages.map(m => ({ role: m.role, content: m.content }));
-      session.title = messages[0]?.content.slice(0, 50) || 'New conversation';
-      session.updatedAt = Date.now();
-      saveSession(session);
-
-      // Update context usage estimate
-      contextUsed = Math.min(95, Math.floor(messages.reduce((acc, m) => acc + m.content.length, 0) / maxContext * 100));
-
-      // Print status bar
-      printStatusBar(process.cwd(), getModelDisplayName(options.model), 100 - contextUsed);
-
-      askQuestion();
-    });
+  const appOptions: AppOptions = {
+    model: options.model,
+    approvalMode: (options.approvalMode as ApprovalMode) || 'suggest',
+    context: options.context,
   };
 
-  askQuestion();
-}
-
-async function processConversation(
-  messages: Message[],
-  systemMessage: string,
-  model: string,
-  isActive: () => boolean
-): Promise<void> {
-  while (isActive()) {
-    console.log();
-    printAssistantPrefix();
-
-    let fullContent = '';
-    let toolCalls: any[] | undefined;
-
-    showThinkingStatus('Thinking');
-
-    try {
-      await streamChat(messages, systemMessage, model, {
-        onContent: (content) => {
-          if (!isActive()) return;
-          hideThinkingStatus();
-          process.stdout.write(content);
-          fullContent += content;
-        },
-        onToolCall: (tc) => {
-          // Tool calls are accumulated
-        },
-        onDone: (content, tcs) => {
-          hideThinkingStatus();
-          toolCalls = tcs;
-        },
-        onError: (error) => {
-          hideThinkingStatus();
-          printError(error.message);
-        }
-      });
-    } catch (error: any) {
-      hideThinkingStatus();
-      printError(error.message);
-      break;
-    }
-
-    if (!isActive()) break;
-
-    // Handle tool calls
-    if (toolCalls && toolCalls.length > 0) {
-      // Add assistant message with tool calls
-      messages.push({
-        role: 'assistant',
-        content: fullContent,
-        tool_calls: toolCalls
-      });
-
-      if (fullContent) {
-        console.log(); // New line after content
-      }
-
-      // Execute each tool
-      for (const tc of toolCalls) {
-        if (!isActive()) break;
-
-        const args = JSON.parse(tc.function.arguments);
-        printToolExecution(tc.function.name, formatToolArgs(tc.function.name, args));
-
-        showThinkingStatus(`Executing ${tc.function.name}`);
-        const result = await executeTool(tc.function.name, args);
-        hideThinkingStatus();
-
-        printToolResult(result.success, result.result);
-
-        // Add tool result
-        messages.push({
-          role: 'tool',
-          tool_call_id: tc.id,
-          content: result.result
-        });
-      }
-
-      // Continue loop for next response
-      continue;
-    } else {
-      // No tool calls, conversation turn complete
-      if (fullContent) {
-        messages.push({ role: 'assistant', content: fullContent });
-        console.log(); // New line after response
-      }
-      break;
-    }
-  }
-}
-
-async function handleSlashCommand(
-  command: string,
-  messages: Message[],
-  session: any,
-  options: ReplOptions
-): Promise<void> {
-  const [cmd, ...args] = command.slice(1).split(' ');
-
-  switch (cmd.toLowerCase()) {
-    case 'help':
-      console.log();
-      console.log(chalk.bold('Available commands:'));
-      console.log(chalk.cyan('  /help') + chalk.gray('     - Show this help'));
-      console.log(chalk.cyan('  /clear') + chalk.gray('    - Clear conversation'));
-      console.log(chalk.cyan('  /model') + chalk.gray('    - Switch model'));
-      console.log(chalk.cyan('  /context') + chalk.gray('  - Show current context'));
-      console.log(chalk.cyan('  /save') + chalk.gray('     - Save conversation'));
-      console.log(chalk.cyan('  /exit') + chalk.gray('     - Exit Codea'));
-      console.log();
-      break;
-
-    case 'clear':
-      messages.length = 0;
-      console.log(chalk.green('Conversation cleared.'));
-      break;
-
-    case 'model':
-      const modelArg = args[0];
-      if (modelArg) {
-        options.model = modelArg.startsWith('alia-') ? modelArg : `alia-v1-${modelArg}`;
-        console.log(chalk.green(`Model switched to ${options.model}`));
-      } else {
-        console.log(chalk.gray('Current model: ') + chalk.cyan(options.model));
-        try {
-          const { fetchModels } = await import('../utils/api.js');
-          const apiModels = await fetchModels();
-          if (apiModels.length > 0) {
-            console.log(chalk.gray('Available models:'));
-            for (const m of apiModels) {
-              console.log(chalk.gray('  ') + chalk.cyan(m.id) + chalk.gray(` - ${m.name}`));
-            }
-          } else {
-            console.log(chalk.gray('Available: codea, codea-pro, codea-thinking'));
-          }
-        } catch {
-          console.log(chalk.gray('Available: codea, codea-pro, codea-thinking'));
-        }
-      }
-      break;
-
-    case 'context':
-      console.log(chalk.gray(`Messages in context: ${messages.length}`));
-      console.log(chalk.gray(`Working directory: ${process.cwd()}`));
-      break;
-
-    case 'save':
-      session.messages = messages.map(m => ({ role: m.role, content: m.content }));
-      session.updatedAt = Date.now();
-      saveSession(session);
-      console.log(chalk.green('Conversation saved.'));
-      break;
-
-    case 'exit':
-    case 'quit':
-      console.log(chalk.gray('Goodbye!'));
-      process.exit(0);
-      break;
-
-    default:
-      console.log(chalk.yellow(`Unknown command: /${cmd}`));
-      console.log(chalk.gray('Type /help for available commands.'));
-  }
-}
-
-function formatToolArgs(name: string, args: Record<string, any>): string {
-  switch (name) {
-    case 'read_file':
-    case 'write_file':
-    case 'edit_file':
-      return args.path || '';
-    case 'list_files':
-      return args.path || '.';
-    case 'search_files':
-      return `"${args.pattern}" in ${args.path || '.'}`;
-    case 'run_command':
-      return args.command || '';
-    default:
-      return JSON.stringify(args).slice(0, 50);
-  }
-}
-
-function getModelDisplayName(model: string): string {
-  const names: Record<string, string> = {
-    'alia-v1-codea': 'codea',
-    'alia-v1-pro': 'codea-pro',
-    'alia-v1-thinking': 'codea-thinking'
-  };
-  return names[model] || model;
+  const { waitUntilExit } = render(React.createElement(App, { options: appOptions }));
+  await waitUntilExit();
 }

package/src/commands/run.ts

@@ -1,33 +1,28 @@
 import chalk from 'chalk';
-import { config } from '../utils/config.js';
-import { streamChat } from '../utils/api.js';
-import { executeTool, formatToolCall } from '../tools/executor.js';
-import { buildSystemMessage, getCodebaseContext } from '../utils/context.js';
-import {
-  printToolExecution,
-  printToolResult,
-  showThinkingStatus,
-  hideThinkingStatus,
-  printAssistantPrefix,
-  printError,
-  printInfo
-} from '../utils/ui.js';
-
-interface Message {
-  role: 'user' | 'assistant' | 'system' | 'tool';
-  content: string;
-  tool_calls?: any[];
-  tool_call_id?: string;
-}
+import { buildSystemMessage, getCodebaseContext, loadProjectInstructions } from '../utils/context.js';
+import { processConversation, Message, ToolExecution } from '../utils/conversation.js';
+import { ApprovalMode } from '../utils/approval.js';
+import * as readline from 'readline';
 
 interface RunOptions {
   model: string;
   yes: boolean;
   context: boolean;
+  approvalMode?: string;
+  quiet?: boolean;
+  json?: boolean;
+}
+
+interface JsonOutput {
+  model: string;
+  prompt: string;
+  response: string;
+  tool_calls: Array<{ tool: string; args: Record<string, any>; result: string; success: boolean }>;
 }
 
 export async function runPrompt(prompt: string, options: RunOptions): Promise<void> {
   const messages: Message[] = [];
+  const toolResults: JsonOutput['tool_calls'] = [];
 
   // Get codebase context
   let codebaseContext = '';
@@ -35,136 +30,118 @@ export async function runPrompt(prompt: string, options: RunOptions): Promise<vo
     codebaseContext = await getCodebaseContext();
   }
 
-  // Add user message
-  messages.push({ role: 'user', content: prompt });
-
-  // Build system message
-  const systemMessage = buildSystemMessage(options.model, codebaseContext);
-
-  // Process with tool loop
-  await processConversation(messages, systemMessage, options.model, options.yes);
-}
-
-async function processConversation(
-  messages: Message[],
-  systemMessage: string,
-  model: string,
-  autoApprove: boolean
-): Promise<void> {
-  let continueProcessing = true;
-
-  while (continueProcessing) {
-    printAssistantPrefix();
-
-    let fullContent = '';
-    let toolCalls: any[] | undefined;
-
-    showThinkingStatus('Thinking');
-
-    try {
-      await streamChat(messages, systemMessage, model, {
-        onContent: (content) => {
-          hideThinkingStatus();
-          process.stdout.write(content);
-          fullContent += content;
-        },
-        onToolCall: () => {},
-        onDone: (content, tcs) => {
-          hideThinkingStatus();
-          toolCalls = tcs;
-        },
-        onError: (error) => {
-          hideThinkingStatus();
-          printError(error.message);
-          continueProcessing = false;
-        }
-      });
-    } catch (error: any) {
-      hideThinkingStatus();
-      printError(error.message);
-      break;
-    }
-
-    // Handle tool calls
-    if (toolCalls && toolCalls.length > 0) {
-      messages.push({
-        role: 'assistant',
-        content: fullContent,
-        tool_calls: toolCalls
-      });
-
-      if (fullContent) console.log();
+  const instructions = await loadProjectInstructions();
 
-      for (const tc of toolCalls) {
-        const args = JSON.parse(tc.function.arguments);
-
-        // Check if we need approval for file writes
-        const isDestructive = ['write_file', 'edit_file', 'run_command'].includes(tc.function.name);
-
-        if (isDestructive && !autoApprove) {
-          console.log();
-          console.log(chalk.yellow('⚠ ') + chalk.bold('Approval required:'));
-          console.log(formatToolCall(tc.function.name, args));
-          console.log();
+  messages.push({ role: 'user', content: prompt });
 
-          const approved = await askApproval();
-          if (!approved) {
-            messages.push({
-              role: 'tool',
-              tool_call_id: tc.id,
-              content: 'User declined this action.'
+  const systemMessage = buildSystemMessage(options.model, codebaseContext, instructions);
+
+  const approvalMode: ApprovalMode = options.yes
+    ? 'full-auto'
+    : (options.approvalMode as ApprovalMode) || 'suggest';
+
+  let fullResponse = '';
+
+  await processConversation({
+    messages,
+    systemMessage,
+    model: options.model,
+    approvalMode,
+    isActive: () => true,
+    requestApproval: async (execution) => {
+      if (options.quiet || options.json) return false;
+      return askApproval(execution);
+    },
+    onEvent: (event) => {
+      switch (event.type) {
+        case 'thinking':
+          if (!options.quiet && !options.json) {
+            process.stdout.write(chalk.magenta('✦ '));
+          }
+          break;
+        case 'content':
+          fullResponse += event.text;
+          if (!options.quiet && !options.json) {
+            process.stdout.write(event.text);
+          }
+          break;
+        case 'tool_start':
+          if (!options.quiet && !options.json) {
+            console.log();
+            console.log(chalk.cyan('  → ') + chalk.bold(event.execution.tool) + ' ' + chalk.gray(formatArgs(event.execution)));
+          }
+          break;
+        case 'tool_done':
+          if (event.execution.result !== undefined) {
+            toolResults.push({
+              tool: event.execution.tool,
+              args: event.execution.args,
+              result: event.execution.result,
+              success: event.execution.success ?? false,
             });
-            continue;
           }
-        }
-
-        printToolExecution(tc.function.name, formatToolArgs(tc.function.name, args));
-
-        showThinkingStatus(`Executing ${tc.function.name}`);
-        const result = await executeTool(tc.function.name, args);
-        hideThinkingStatus();
-
-        printToolResult(result.success, result.result);
-
-        messages.push({
-          role: 'tool',
-          tool_call_id: tc.id,
-          content: result.result
-        });
+          if (!options.quiet && !options.json) {
+            const icon = event.execution.success ? chalk.green('  ✓') : chalk.red('  ✗');
+            const preview = (event.execution.result || '').slice(0, 100).replace(/\n/g, ' ');
+            console.log(`${icon} ${chalk.gray(preview)}`);
+          }
+          break;
+        case 'done':
+          if (!options.quiet && !options.json) {
+            console.log();
+          }
+          break;
+        case 'error':
+          if (!options.json) {
+            console.error(chalk.red('Error: ') + event.message);
+          }
+          break;
       }
+    },
+  });
 
-      continue;
-    } else {
-      if (fullContent) {
-        messages.push({ role: 'assistant', content: fullContent });
-        console.log();
-      }
-      break;
+  if (options.json) {
+    const output: JsonOutput = {
+      model: options.model,
+      prompt,
+      response: fullResponse,
+      tool_calls: toolResults,
+    };
+    console.log(JSON.stringify(output, null, 2));
+  } else if (options.quiet) {
+    if (fullResponse) {
+      console.log(fullResponse);
     }
   }
 }
 
-async function askApproval(): Promise<boolean> {
-  const readline = await import('readline');
+async function askApproval(execution: ToolExecution): Promise<boolean> {
   const rl = readline.createInterface({
     input: process.stdin,
-    output: process.stdout
+    output: process.stdout,
   });
 
+  const desc = formatArgs(execution);
+  console.log();
+  console.log(chalk.yellow('⚠ ') + chalk.bold(execution.tool) + ' ' + desc);
+
   return new Promise((resolve) => {
-    rl.question(chalk.cyan('Allow? [y/N] '), (answer) => {
+    rl.question(chalk.cyan('  Allow? [y/N] '), (answer) => {
       rl.close();
       resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
     });
   });
 }
 
-function formatToolArgs(name: string, args: Record<string, any>): string {
-  switch (name) {
+function formatArgs(execution: ToolExecution): string {
+  const { tool, args } = execution;
+  switch (tool) {
     case 'read_file':
     case 'write_file':
     case 'edit_file':
       return args.path || '';
+    case 'apply_patch':
+      return 'applying patch...';
     case 'list_files':
       return args.path || '.';
     case 'search_files':
@@ -172,6 +149,6 @@ function formatToolArgs(name: string, args: Record<string, any>): string {
     case 'run_command':
       return args.command || '';
     default:
-      return JSON.stringify(args).slice(0, 50);
+      return JSON.stringify(args).slice(0, 60);
   }
 }

package/src/commands/sessions.ts

@@ -2,13 +2,12 @@ import chalk from 'chalk';
 import * as readline from 'readline';
 import { getSessions, getSession, config } from '../utils/config.js';
 import { startRepl } from './repl.js';
-import { printBanner, printError, printInfo } from '../utils/ui.js';
 
 export async function listSessions(): Promise<void> {
   const sessions = getSessions();
 
   if (sessions.length === 0) {
-    printInfo('No saved sessions found.');
+    console.log(chalk.blue('ℹ ') + 'No saved sessions found.');
     console.log(chalk.gray('Start a new session with: ') + chalk.cyan('codea'));
     return;
   }
@@ -38,7 +37,7 @@ export async function resumeSession(sessionId?: string): Promise<void> {
   const sessions = getSessions();
 
   if (sessions.length === 0) {
-    printInfo('No saved sessions found.');
+    console.log(chalk.blue('ℹ ') + 'No saved sessions found.');
     return;
   }
 
@@ -54,7 +53,7 @@ export async function resumeSession(sessionId?: string): Promise<void> {
     }
 
     if (!selectedSession) {
-      printError(`Session not found: ${sessionId}`);
+      console.log(chalk.red('✗ Error: ') + `Session not found: ${sessionId}`);
       return;
     }
   } else {
@@ -82,7 +81,7 @@ export async function resumeSession(sessionId?: string): Promise<void> {
 
         const index = parseInt(answer) - 1;
         if (isNaN(index) || index < 0 || index >= sessions.length) {
-          printError('Invalid selection.');
+          console.log(chalk.red('✗ Error: ') + 'Invalid selection.');
           resolve();
           return;
         }
@@ -99,7 +98,7 @@ export async function resumeSession(sessionId?: string): Promise<void> {
 }
 
 async function startRestoredSession(session: any): Promise<void> {
-  printInfo(`Resuming: ${session.title}`);
+  console.log(chalk.blue('ℹ ') + `Resuming: ${session.title}`);
   console.log();
 
   // Display previous messages