@alia-codea/cli 1.1.0 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alia-codea/cli",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "description": "Codea CLI - AI coding assistant for your terminal by Alia",
   "main": "dist/index.js",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "type": "module",
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean",
+    "build": "tsup src/index.ts --format esm --clean",
     "dev": "tsx src/index.ts",
     "start": "node dist/index.js",
     "lint": "eslint src",
@@ -29,19 +29,19 @@
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "conf": "^13.0.1",
-    "ink": "^5.0.1",
+    "ink": "^6.7.0",
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",
     "marked": "^15.0.4",
     "marked-terminal": "^7.2.1",
     "openai": "^6.16.0",
     "ora": "^8.1.1",
-    "react": "^18.3.1",
+    "react": "19.2.0",
     "simple-git": "^3.27.0"
   },
   "devDependencies": {
     "@types/node": "^22.10.5",
-    "@types/react": "^18.3.12",
+    "@types/react": "^19.2.0",
     "tsup": "^8.3.5",
     "tsx": "^4.19.2",
     "typescript": "^5.7.2"

package/src/app.tsx

@@ -0,0 +1,281 @@
+import React, { useState, useCallback, useRef, useEffect } from 'react';
+import { Box, Text, useApp, useInput } from 'ink';
+import { Header } from './components/Header.js';
+import { MessageList, DisplayMessage } from './components/MessageList.js';
+import { InputBar } from './components/InputBar.js';
+import { ApprovalPrompt } from './components/ApprovalPrompt.js';
+import { processConversation, Message, ToolExecution } from './utils/conversation.js';
+import { buildSystemMessage, getCodebaseContext, loadProjectInstructions } from './utils/context.js';
+import { createSession, saveSession } from './utils/config.js';
+import { ApprovalMode } from './utils/approval.js';
+
+export interface AppOptions {
+  model: string;
+  approvalMode: ApprovalMode;
+  context: boolean;
+}
+
+let msgCounter = 0;
+function nextId(): string {
+  return `msg-${++msgCounter}`;
+}
+
+export function App({ options }: { options: AppOptions }) {
+  const { exit } = useApp();
+  const [displayMessages, setDisplayMessages] = useState<DisplayMessage[]>([]);
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [thinkingLabel, setThinkingLabel] = useState('Thinking');
+  const [approvalMode, setApprovalMode] = useState<ApprovalMode>(options.approvalMode);
+  const [contextPercent, setContextPercent] = useState(100);
+  const [pendingApproval, setPendingApproval] = useState<{
+    execution: ToolExecution;
+    resolve: (approved: boolean) => void;
+  } | null>(null);
+  const [ready, setReady] = useState(false);
+  const [codebaseContext, setCodebaseContext] = useState('');
+  const [instructions, setInstructions] = useState('');
+
+  const messagesRef = useRef<Message[]>([]);
+  const sessionRef = useRef(createSession());
+  const activeRef = useRef(true);
+  const streamingIdRef = useRef<string | null>(null);
+
+  // Initialize on mount
+  useEffect(() => {
+    let cancelled = false;
+    (async () => {
+      let ctx = '';
+      let instr = '';
+      if (options.context !== false) {
+        ctx = await getCodebaseContext();
+        if (ctx && !cancelled) {
+          setDisplayMessages((prev) => [
+            ...prev,
+            { id: nextId(), type: 'info', content: `Loaded context from ${ctx.split('\n').length} lines` },
+          ]);
+        }
+      }
+      instr = await loadProjectInstructions();
+      if (instr && !cancelled) {
+        const count = instr.split('\n---\n').length;
+        setDisplayMessages((prev) => [
+          ...prev,
+          { id: nextId(), type: 'info', content: `Loaded ${count} CODEA.md instruction file(s)` },
+        ]);
+      }
+      if (!cancelled) {
+        setCodebaseContext(ctx);
+        setInstructions(instr);
+        setReady(true);
+      }
+    })();
+    return () => { cancelled = true; };
+  }, []);
+
+  // Handle Ctrl+C
+  useInput((_input, key) => {
+    if (key.ctrl && (_input === 'c' || _input === 'C')) {
+      if (isProcessing) {
+        activeRef.current = false;
+        setIsProcessing(false);
+        setPendingApproval(null);
+        setDisplayMessages((prev) => [
+          ...prev,
+          { id: nextId(), type: 'info', content: 'Cancelled.' },
+        ]);
+      } else {
+        exit();
+      }
+    }
+  });
+
+  const addMessage = useCallback((msg: DisplayMessage) => {
+    setDisplayMessages((prev) => [...prev, msg]);
+  }, []);
+
+  const updateLastAssistant = useCallback((text: string) => {
+    setDisplayMessages((prev) => {
+      const last = prev[prev.length - 1];
+      if (last && last.type === 'assistant' && last.streaming) {
+        return [...prev.slice(0, -1), { ...last, content: last.content + text }];
+      }
+      return prev;
+    });
+  }, []);
+
+  const finalizeAssistant = useCallback(() => {
+    setDisplayMessages((prev) => {
+      const last = prev[prev.length - 1];
+      if (last && last.type === 'assistant' && last.streaming) {
+        return [...prev.slice(0, -1), { ...last, streaming: false }];
+      }
+      return prev;
+    });
+  }, []);
+
+  const handleSubmit = useCallback(async (input: string) => {
+    // Handle slash commands
+    if (input.startsWith('/')) {
+      const [cmd, ...args] = input.slice(1).split(' ');
+      switch (cmd.toLowerCase()) {
+        case 'help':
+          addMessage({
+            id: nextId(),
+            type: 'info',
+            content: 'Commands: /help, /clear, /mode <suggest|auto-edit|full-auto>, /model <name>, /exit',
+          });
+          return;
+        case 'clear':
+          messagesRef.current = [];
+          setDisplayMessages([]);
+          setContextPercent(100);
+          return;
+        case 'mode':
+          if (args[0] && ['suggest', 'auto-edit', 'full-auto'].includes(args[0])) {
+            setApprovalMode(args[0] as ApprovalMode);
+            addMessage({ id: nextId(), type: 'info', content: `Approval mode: ${args[0]}` });
+          } else {
+            addMessage({ id: nextId(), type: 'info', content: `Current mode: ${approvalMode}. Options: suggest, auto-edit, full-auto` });
+          }
+          return;
+        case 'model':
+          if (args[0]) {
+            options.model = args[0].startsWith('alia-') ? args[0] : `alia-v1-${args[0]}`;
+            addMessage({ id: nextId(), type: 'info', content: `Model: ${options.model}` });
+          } else {
+            addMessage({ id: nextId(), type: 'info', content: `Current model: ${options.model}` });
+          }
+          return;
+        case 'exit':
+        case 'quit':
+          exit();
+          return;
+        default:
+          addMessage({ id: nextId(), type: 'info', content: `Unknown command: /${cmd}` });
+          return;
+      }
+    }
+
+    // Add user message
+    addMessage({ id: nextId(), type: 'user', content: input });
+    messagesRef.current.push({ role: 'user', content: input });
+
+    setIsProcessing(true);
+    activeRef.current = true;
+    streamingIdRef.current = null;
+
+    const systemMessage = buildSystemMessage(options.model, codebaseContext, instructions);
+
+    await processConversation({
+      messages: messagesRef.current,
+      systemMessage,
+      model: options.model,
+      approvalMode,
+      isActive: () => activeRef.current,
+      requestApproval: (execution) => {
+        return new Promise<boolean>((resolve) => {
+          setPendingApproval({ execution, resolve });
+        });
+      },
+      onEvent: (event) => {
+        switch (event.type) {
+          case 'thinking':
+            setThinkingLabel('Thinking');
+            // Start a new streaming assistant message
+            streamingIdRef.current = nextId();
+            setDisplayMessages((prev) => [
+              ...prev,
+              { id: streamingIdRef.current!, type: 'assistant', content: '', streaming: true },
+            ]);
+            break;
+          case 'content':
+            updateLastAssistant(event.text);
+            break;
+          case 'tool_start':
+            // Finalize any streaming text before showing tool
+            finalizeAssistant();
+            setThinkingLabel(`Running ${event.execution.tool}`);
+            addMessage({
+              id: nextId(),
+              type: 'tool',
+              content: '',
+              toolExecution: { ...event.execution },
+            });
+            break;
+          case 'tool_done':
+            // Update the tool message with result
+            setDisplayMessages((prev) => {
+              const idx = prev.findLastIndex(
+                (m) => m.type === 'tool' && m.toolExecution?.id === event.execution.id
+              );
+              if (idx >= 0) {
+                const updated = [...prev];
+                updated[idx] = {
+                  ...updated[idx],
+                  toolExecution: { ...event.execution },
+                };
+                return updated;
+              }
+              return prev;
+            });
+            break;
+          case 'done':
+            finalizeAssistant();
+            break;
+          case 'error':
+            finalizeAssistant();
+            addMessage({ id: nextId(), type: 'info', content: `Error: ${event.message}` });
+            break;
+        }
+      },
+    });
+
+    setIsProcessing(false);
+    setPendingApproval(null);
+
+    // Save session
+    const session = sessionRef.current;
+    session.messages = messagesRef.current.map((m) => ({ role: m.role, content: m.content }));
+    session.title = messagesRef.current[0]?.content.slice(0, 50) || 'New conversation';
+    session.updatedAt = Date.now();
+    saveSession(session);
+
+    // Update context estimate
+    const totalChars = messagesRef.current.reduce((acc, m) => acc + m.content.length, 0);
+    const maxContext = 128000;
+    setContextPercent(Math.max(5, 100 - Math.floor((totalChars / maxContext) * 100)));
+  }, [approvalMode, codebaseContext, instructions, options]);
+
+  const handleApprovalResolve = useCallback((approved: boolean) => {
+    if (pendingApproval) {
+      pendingApproval.resolve(approved);
+      setPendingApproval(null);
+    }
+  }, [pendingApproval]);
+
+  const modelDisplay = options.model.replace('alia-v1-', '');
+
+  return (
+    <Box flexDirection="column">
+      <Header
+        cwd={process.cwd()}
+        model={modelDisplay}
+        approvalMode={approvalMode}
+        contextPercent={contextPercent}
+      />
+      <MessageList messages={displayMessages} />
+      {pendingApproval ? (
+        <ApprovalPrompt
+          execution={pendingApproval.execution}
+          onResolve={handleApprovalResolve}
+        />
+      ) : (
+        <InputBar
+          onSubmit={handleSubmit}
+          isProcessing={isProcessing}
+          thinkingLabel={thinkingLabel}
+        />
+      )}
+    </Box>
+  );
+}

package/src/commands/auth.ts

@@ -4,7 +4,17 @@ import * as http from 'http';
 import { exec } from 'child_process';
 import chalk from 'chalk';
 import { config } from '../utils/config.js';
-import { printSuccess, printError, printInfo } from '../utils/ui.js';
+function printSuccess(message: string): void {
+  console.log(chalk.green('✓ ') + message);
+}
+
+function printError(message: string): void {
+  console.log(chalk.red('✗ Error: ') + message);
+}
+
+function printInfo(message: string): void {
+  console.log(chalk.blue('ℹ ') + message);
+}
 
 function openBrowser(url: string): void {
   const cmd =

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();
 }