@alia-codea/cli 1.1.0 → 2.0.0

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

package/src/components/ApprovalPrompt.tsx

@@ -0,0 +1,60 @@
+import React from 'react';
+import { Box, Text, useInput } from 'ink';
+import { ToolExecution } from '../utils/conversation.js';
+
+interface ApprovalPromptProps {
+  execution: ToolExecution;
+  onResolve: (approved: boolean) => void;
+}
+
+function formatArgs(tool: string, args: Record<string, any>): string {
+  switch (tool) {
+    case 'write_file':
+      return `Write to ${args.path}`;
+    case 'edit_file':
+      return `Edit ${args.path}`;
+    case 'apply_patch':
+      return `Apply patch`;
+    case 'run_command':
+      return `Run: ${args.command}`;
+    default:
+      return `${tool}: ${JSON.stringify(args).slice(0, 80)}`;
+  }
+}
+
+export function ApprovalPrompt({ execution, onResolve }: ApprovalPromptProps) {
+  useInput((input, key) => {
+    if (input === 'y' || input === 'Y') {
+      onResolve(true);
+    } else if (input === 'n' || input === 'N' || key.escape) {
+      onResolve(false);
+    }
+  });
+
+  const description = formatArgs(execution.tool, execution.args);
+
+  return (
+    <Box flexDirection="column" paddingLeft={2} paddingY={0}>
+      <Box gap={1}>
+        <Text color="yellow">{'⚠'}</Text>
+        <Text bold>{description}</Text>
+      </Box>
+      {execution.tool === 'run_command' && execution.args.command && (
+        <Box paddingLeft={2}>
+          <Text color="gray">$ {execution.args.command}</Text>
+        </Box>
+      )}
+      {execution.tool === 'write_file' && execution.args.content && (
+        <Box paddingLeft={2}>
+          <Text color="gray">{execution.args.content.split('\n').length} lines</Text>
+        </Box>
+      )}
+      <Box paddingLeft={2} gap={1}>
+        <Text color="green">[y]</Text>
+        <Text>approve</Text>
+        <Text color="red">[n]</Text>
+        <Text>deny</Text>
+      </Box>
+    </Box>
+  );
+}

package/src/components/Header.tsx

@@ -0,0 +1,39 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import { ApprovalMode } from '../utils/approval.js';
+
+interface HeaderProps {
+  cwd: string;
+  model: string;
+  approvalMode: ApprovalMode;
+  contextPercent: number;
+}
+
+function shortenPath(p: string): string {
+  const home = process.env.HOME || '';
+  if (home && p.startsWith(home)) {
+    return '~' + p.slice(home.length);
+  }
+  return p;
+}
+
+const MODE_COLORS: Record<ApprovalMode, string> = {
+  'suggest': 'yellow',
+  'auto-edit': 'cyan',
+  'full-auto': 'green',
+};
+
+export function Header({ cwd, model, approvalMode, contextPercent }: HeaderProps) {
+  return (
+    <Box borderStyle="single" borderColor="gray" paddingX={1} justifyContent="space-between">
+      <Text color="cyan">{shortenPath(cwd)}</Text>
+      <Box gap={1}>
+        <Text color="magenta">{model}</Text>
+        <Text color="gray">|</Text>
+        <Text color={MODE_COLORS[approvalMode]}>{approvalMode}</Text>
+        <Text color="gray">|</Text>
+        <Text color={contextPercent < 20 ? 'red' : 'gray'}>{contextPercent}% left</Text>
+      </Box>
+    </Box>
+  );
+}

package/src/components/InputBar.tsx

@@ -0,0 +1,36 @@
+import React, { useState } from 'react';
+import { Box, Text } from 'ink';
+import TextInput from 'ink-text-input';
+import { ThinkingIndicator } from './ThinkingIndicator.js';
+
+interface InputBarProps {
+  onSubmit: (value: string) => void;
+  isProcessing: boolean;
+  thinkingLabel?: string;
+}
+
+export function InputBar({ onSubmit, isProcessing, thinkingLabel }: InputBarProps) {
+  const [value, setValue] = useState('');
+
+  const handleSubmit = (text: string) => {
+    const trimmed = text.trim();
+    if (!trimmed) return;
+    setValue('');
+    onSubmit(trimmed);
+  };
+
+  if (isProcessing) {
+    return (
+      <Box paddingX={1}>
+        <ThinkingIndicator label={thinkingLabel || 'Thinking'} />
+      </Box>
+    );
+  }
+
+  return (
+    <Box paddingX={1}>
+      <Text color="cyan">{'❯ '}</Text>
+      <TextInput value={value} onChange={setValue} onSubmit={handleSubmit} />
+    </Box>
+  );
+}

package/src/components/MessageList.tsx

@@ -0,0 +1,81 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import { Marked } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+import { ToolCallCard } from './ToolCallCard.js';
+import { ToolExecution } from '../utils/conversation.js';
+
+export interface DisplayMessage {
+  id: string;
+  type: 'user' | 'assistant' | 'tool' | 'info';
+  content: string;
+  toolExecution?: ToolExecution;
+  streaming?: boolean;
+}
+
+interface MessageListProps {
+  messages: DisplayMessage[];
+}
+
+const marked = new Marked(markedTerminal() as any);
+
+function renderMarkdown(text: string): string {
+  try {
+    const rendered = marked.parse(text);
+    if (typeof rendered === 'string') {
+      return rendered.trimEnd();
+    }
+    return text;
+  } catch {
+    return text;
+  }
+}
+
+function MessageBlock({ message }: { message: DisplayMessage }) {
+  switch (message.type) {
+    case 'user':
+      return (
+        <Box paddingLeft={1} paddingY={0}>
+          <Text color="cyan">{'❯ '}</Text>
+          <Text>{message.content}</Text>
+        </Box>
+      );
+
+    case 'assistant':
+      return (
+        <Box flexDirection="column" paddingLeft={1}>
+          <Box>
+            <Text color="magenta">{'✦ '}</Text>
+            <Text>{message.streaming ? message.content : renderMarkdown(message.content)}</Text>
+          </Box>
+        </Box>
+      );
+
+    case 'tool':
+      if (message.toolExecution) {
+        return <ToolCallCard execution={message.toolExecution} />;
+      }
+      return null;
+
+    case 'info':
+      return (
+        <Box paddingLeft={1}>
+          <Text color="blue">{'ℹ '}</Text>
+          <Text color="gray">{message.content}</Text>
+        </Box>
+      );
+
+    default:
+      return null;
+  }
+}
+
+export function MessageList({ messages }: MessageListProps) {
+  return (
+    <Box flexDirection="column" flexGrow={1} gap={0}>
+      {messages.map((msg) => (
+        <MessageBlock key={msg.id} message={msg} />
+      ))}
+    </Box>
+  );
+}

package/src/components/ThinkingIndicator.tsx

@@ -0,0 +1,28 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+
+interface ThinkingIndicatorProps {
+  label?: string;
+}
+
+export function ThinkingIndicator({ label = 'Thinking' }: ThinkingIndicatorProps) {
+  const [elapsed, setElapsed] = useState(0);
+
+  useEffect(() => {
+    const interval = setInterval(() => {
+      setElapsed((e) => e + 1);
+    }, 1000);
+    return () => clearInterval(interval);
+  }, []);
+
+  return (
+    <Box gap={1}>
+      <Text color="cyan">
+        <Spinner type="dots" />
+      </Text>
+      <Text bold>{label}</Text>
+      <Text color="gray">({elapsed}s)</Text>
+    </Box>
+  );
+}

package/src/components/ToolCallCard.tsx

@@ -0,0 +1,68 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import { ToolExecution } from '../utils/conversation.js';
+
+interface ToolCallCardProps {
+  execution: ToolExecution;
+}
+
+function formatArgs(tool: string, args: Record<string, any>): string {
+  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':
+      return `"${args.pattern}" in ${args.path || '.'}`;
+    case 'run_command':
+      return args.command || '';
+    default:
+      return JSON.stringify(args).slice(0, 60);
+  }
+}
+
+export function ToolCallCard({ execution }: ToolCallCardProps) {
+  const { tool, args, result, success, approved } = execution;
+  const argStr = formatArgs(tool, args);
+  const isDone = result !== undefined;
+
+  if (approved === false) {
+    return (
+      <Box flexDirection="column" paddingLeft={2}>
+        <Box gap={1}>
+          <Text color="red">{'✗'}</Text>
+          <Text bold color="gray" strikethrough>{tool}</Text>
+          <Text color="gray">{argStr}</Text>
+        </Box>
+        <Box paddingLeft={2}>
+          <Text color="yellow" dimColor>Declined by user</Text>
+        </Box>
+      </Box>
+    );
+  }
+
+  return (
+    <Box flexDirection="column" paddingLeft={2}>
+      <Box gap={1}>
+        {isDone ? (
+          <Text color={success ? 'green' : 'red'}>{success ? '✓' : '✗'}</Text>
+        ) : (
+          <Text color="cyan">{'→'}</Text>
+        )}
+        <Text bold>{tool}</Text>
+        <Text color="gray">{argStr}</Text>
+      </Box>
+      {isDone && result && (
+        <Box paddingLeft={2}>
+          <Text color="gray" wrap="truncate-end">
+            {result.slice(0, 120).replace(/\n/g, ' ')}{result.length > 120 ? '...' : ''}
+          </Text>
+        </Box>
+      )}
+    </Box>
+  );
+}