@alia-codea/cli 1.0.0 → 2.0.0

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

package/src/index.ts

@@ -8,15 +8,14 @@ import { login } from './commands/auth.js';
 import { listSessions, resumeSession } from './commands/sessions.js';
 import chalk from 'chalk';
 
-const VERSION = '1.0.0';
+const VERSION = '2.0.0';
 
 const program = new Command();
 
-// ASCII art banner
 const banner = `
 ${chalk.cyan('   ____          _            ')}
 ${chalk.cyan('  / ___|___   __| | ___  __ _ ')}
-${chalk.cyan(' | |   / _ \\ / _\` |/ _ \\/ _\` |')}
+${chalk.cyan(' | |   / _ \\ / _` |/ _ \\/ _` |')}
 ${chalk.cyan(' | |__| (_) | (_| |  __/ (_| |')}
 ${chalk.cyan('  \\____\\___/ \\__,_|\\___|\\__,_|')}
 ${chalk.gray('  AI Coding Assistant by Alia')}
@@ -26,23 +25,30 @@ program
   .name('codea')
   .description('Codea CLI - AI coding assistant for your terminal')
   .version(VERSION)
-  .hook('preAction', () => {
-    // Check for API key before running commands (except login)
+  .hook('preAction', async () => {
     const command = program.args[0];
-    if (command !== 'login' && command !== 'help' && !config.get('apiKey')) {
-      console.log(chalk.yellow('\nNo API key found. Please run `codea login` first.\n'));
-      process.exit(1);
+    if (command === 'login' || command === 'help') return;
+
+    if (!config.get('apiKey')) {
+      console.log(banner);
+      console.log(chalk.yellow('No API key found. Let\'s get you logged in.\n'));
+      const success = await login();
+      if (!success) {
+        process.exit(1);
+      }
+      console.log();
     }
   });
 
-// Default command - start REPL
+// Default command - start REPL with Ink TUI
 program
   .command('chat', { isDefault: true })
   .description('Start an interactive chat session')
   .option('-m, --model <model>', 'Model to use (codea, codea-pro, codea-thinking)', 'alia-v1-codea')
+  .option('-a, --approval-mode <mode>', 'Approval mode: suggest, auto-edit, full-auto', 'suggest')
   .option('--no-context', 'Disable automatic codebase context')
+  .option('--no-instructions', 'Disable CODEA.md project instructions')
   .action(async (options) => {
-    console.log(banner);
     await startRepl(options);
   });
 
@@ -52,12 +58,26 @@ program
   .alias('r')
   .description('Run a single prompt and exit')
   .option('-m, --model <model>', 'Model to use', 'alia-v1-codea')
-  .option('-y, --yes', 'Auto-approve all file changes')
+  .option('-y, --yes', 'Auto-approve all actions (full-auto mode)')
+  .option('-a, --approval-mode <mode>', 'Approval mode: suggest, auto-edit, full-auto', 'suggest')
+  .option('-q, --quiet', 'Suppress UI, output only response text')
+  .option('--json', 'Output structured JSON')
   .option('--no-context', 'Disable automatic codebase context')
   .action(async (prompt, options) => {
     await runPrompt(prompt, options);
   });
 
+// Exec command - shorthand for run --json --quiet --yes
+program
+  .command('exec <prompt>')
+  .alias('x')
+  .description('Execute a prompt in full-auto mode with JSON output')
+  .option('-m, --model <model>', 'Model to use', 'alia-v1-codea')
+  .option('--no-context', 'Disable automatic codebase context')
+  .action(async (prompt, options) => {
+    await runPrompt(prompt, { ...options, yes: true, quiet: false, json: true });
+  });
+
 // Login/configure
 program
   .command('login')

package/src/tools/executor.ts

@@ -2,8 +2,8 @@ import * as fs from 'fs/promises';
 import * as path from 'path';
 import { exec } from 'child_process';
 import { promisify } from 'util';
-import { glob } from 'fs/promises';
 import chalk from 'chalk';
+import { applyPatch } from './patch.js';
 
 const execAsync = promisify(exec);
 
@@ -21,10 +21,12 @@ export async function executeTool(name: string, args: Record<string, any>): Prom
         return await writeFile(args.path, args.content);
       case 'edit_file':
         return await editFile(args.path, args.old_text, args.new_text);
+      case 'apply_patch':
+        return await applyPatchTool(args.patch);
       case 'list_files':
         return await listFiles(args.path, args.recursive);
       case 'search_files':
-        return await searchFiles(args.pattern, args.path, args.file_pattern);
+        return await searchFiles(args.pattern, args.path, args.file_pattern, args.context_lines, args.max_results);
       case 'run_command':
         return await runCommand(args.command, args.cwd);
       default:
@@ -55,14 +57,46 @@ async function editFile(filePath: string, oldText: string, newText: string): Pro
   const absolutePath = path.resolve(process.cwd(), filePath);
   const content = await fs.readFile(absolutePath, 'utf-8');
 
-  if (!content.includes(oldText)) {
-    return { success: false, result: `Text not found in file: "${oldText.slice(0, 50)}..."` };
+  // Try exact match first
+  if (content.includes(oldText)) {
+    const newContent = content.replace(oldText, newText);
+    await fs.writeFile(absolutePath, newContent, 'utf-8');
+    return { success: true, result: `File edited: ${filePath}` };
   }
 
-  const newContent = content.replace(oldText, newText);
-  await fs.writeFile(absolutePath, newContent, 'utf-8');
+  // Try whitespace-normalized match
+  const normalizedOld = oldText.replace(/\s+/g, ' ').trim();
+  const lines = content.split('\n');
+  let matchStart = -1;
+  let matchEnd = -1;
 
-  return { success: true, result: `File edited: ${filePath}` };
+  for (let i = 0; i < lines.length; i++) {
+    for (let j = i; j < lines.length; j++) {
+      const block = lines.slice(i, j + 1).join('\n');
+      if (block.replace(/\s+/g, ' ').trim() === normalizedOld) {
+        matchStart = i;
+        matchEnd = j;
+        break;
+      }
+    }
+    if (matchStart >= 0) break;
+  }
+
+  if (matchStart >= 0) {
+    const newLines = [...lines.slice(0, matchStart), ...newText.split('\n'), ...lines.slice(matchEnd + 1)];
+    await fs.writeFile(absolutePath, newLines.join('\n'), 'utf-8');
+    return { success: true, result: `File edited (fuzzy match): ${filePath}` };
+  }
+
+  return { success: false, result: `Text not found in file: "${oldText.slice(0, 50)}..."` };
+}
+
+async function applyPatchTool(patchText: string): Promise<ToolResult> {
+  const result = await applyPatch(patchText, process.cwd());
+  const summary = result.results
+    .map((r) => `${r.success ? '✓' : '✗'} ${r.file}: ${r.message}`)
+    .join('\n');
+  return { success: result.success, result: summary };
 }
 
 async function listFiles(dirPath: string = '.', recursive: boolean = false): Promise<ToolResult> {
@@ -98,10 +132,71 @@ async function listFiles(dirPath: string = '.', recursive: boolean = false): Pro
   }
 }
 
-async function searchFiles(pattern: string, dirPath: string = '.', filePattern?: string): Promise<ToolResult> {
+async function searchFiles(
+  pattern: string,
+  dirPath: string = '.',
+  filePattern?: string,
+  contextLines: number = 2,
+  maxResults: number = 50
+): Promise<ToolResult> {
   const absolutePath = path.resolve(process.cwd(), dirPath);
+
+  // Try ripgrep first
+  try {
+    const rgArgs = [
+      '--json',
+      '-C', String(contextLines),
+      '-m', String(maxResults),
+      '--no-heading',
+    ];
+
+    if (filePattern) {
+      rgArgs.push('-g', filePattern);
+    }
+
+    rgArgs.push('--', pattern, absolutePath);
+
+    const { stdout } = await execAsync(`rg ${rgArgs.map(a => `'${a}'`).join(' ')}`, {
+      maxBuffer: 2 * 1024 * 1024,
+      timeout: 30000,
+    });
+
+    // Parse rg --json output
+    const results: string[] = [];
+    const lines = stdout.trim().split('\n');
+
+    for (const line of lines) {
+      try {
+        const data = JSON.parse(line);
+        if (data.type === 'match') {
+          const relPath = path.relative(absolutePath, data.data.path.text);
+          const lineNum = data.data.line_number;
+          const text = data.data.lines.text.trimEnd();
+          results.push(`${relPath}:${lineNum}: ${text}`);
+        } else if (data.type === 'context') {
+          const relPath = path.relative(absolutePath, data.data.path.text);
+          const lineNum = data.data.line_number;
+          const text = data.data.lines.text.trimEnd();
+          results.push(`${relPath}:${lineNum}  ${text}`);
+        }
+      } catch {
+        // Skip malformed JSON lines
+      }
+    }
+
+    if (results.length === 0) {
+      return { success: true, result: 'No matches found.' };
+    }
+
+    return { success: true, result: results.join('\n') };
+  } catch {
+    // ripgrep not available or failed, use built-in
+  }
+
+  // Built-in fallback
   const regex = new RegExp(pattern, 'gi');
-  const results: string[] = [];
+  const results: Array<{ file: string; line: number; text: string; isMatch: boolean }> = [];
+  const fileMatchCounts = new Map<string, number>();
 
   async function searchDir(dir: string) {
     const entries = await fs.readdir(dir, { withFileTypes: true });
@@ -109,7 +204,6 @@ async function searchFiles(pattern: string, dirPath: string = '.', filePattern?:
     for (const entry of entries) {
       const fullPath = path.join(dir, entry.name);
 
-      // Skip common ignored directories
       if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'dist') {
         continue;
       }
@@ -117,7 +211,6 @@ async function searchFiles(pattern: string, dirPath: string = '.', filePattern?:
       if (entry.isDirectory()) {
         await searchDir(fullPath);
       } else {
-        // Check file pattern
         if (filePattern) {
           const ext = path.extname(entry.name);
           const patternExt = filePattern.replace('*', '');
@@ -128,14 +221,38 @@ async function searchFiles(pattern: string, dirPath: string = '.', filePattern?:
 
         try {
           const content = await fs.readFile(fullPath, 'utf-8');
+
+          // Skip binary files
+          if (content.includes('\0')) continue;
+
           const lines = content.split('\n');
+          const matchIndices: number[] = [];
 
           lines.forEach((line, index) => {
+            regex.lastIndex = 0;
             if (regex.test(line)) {
-              const relativePath = path.relative(absolutePath, fullPath);
-              results.push(`${relativePath}:${index + 1}: ${line.trim()}`);
+              matchIndices.push(index);
             }
           });
+
+          if (matchIndices.length > 0) {
+            const relativePath = path.relative(absolutePath, fullPath);
+            fileMatchCounts.set(relativePath, matchIndices.length);
+
+            for (const idx of matchIndices) {
+              const start = Math.max(0, idx - contextLines);
+              const end = Math.min(lines.length - 1, idx + contextLines);
+
+              for (let i = start; i <= end; i++) {
+                results.push({
+                  file: relativePath,
+                  line: i + 1,
+                  text: lines[i].trimEnd(),
+                  isMatch: i === idx,
+                });
+              }
+            }
+          }
         } catch {
           // Skip unreadable files
         }
@@ -149,7 +266,15 @@ async function searchFiles(pattern: string, dirPath: string = '.', filePattern?:
     return { success: true, result: 'No matches found.' };
   }
 
-  return { success: true, result: results.slice(0, 100).join('\n') + (results.length > 100 ? `\n... and ${results.length - 100} more` : '') };
+  const formatted = results
+    .slice(0, maxResults * (1 + contextLines * 2))
+    .map((r) => `${r.file}:${r.line}${r.isMatch ? ':' : ' '} ${r.text}`)
+    .join('\n');
+
+  const totalMatches = Array.from(fileMatchCounts.values()).reduce((a, b) => a + b, 0);
+  const footer = `\n(${totalMatches} matches in ${fileMatchCounts.size} files)`;
+
+  return { success: true, result: formatted + footer };
 }
 
 async function runCommand(command: string, cwd?: string): Promise<ToolResult> {
@@ -177,6 +302,7 @@ export function formatToolCall(name: string, args: Record<string, any>): string
     read_file: 'Reading file',
     write_file: 'Writing file',
     edit_file: 'Editing file',
+    apply_patch: 'Applying patch',
     list_files: 'Listing files',
     search_files: 'Searching files',
     run_command: 'Running command'