@alia-codea/cli 1.1.0 → 2.0.0

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')}
@@ -41,14 +40,15 @@ program
     }
   });
 
-// 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);
   });
 
@@ -58,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'

package/src/tools/patch.ts

@@ -0,0 +1,167 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+interface Hunk {
+  oldStart: number;
+  oldLines: string[];
+  newLines: string[];
+}
+
+interface FilePatch {
+  filePath: string;
+  hunks: Hunk[];
+}
+
+interface PatchResult {
+  success: boolean;
+  results: Array<{ file: string; success: boolean; message: string }>;
+}
+
+export function parsePatch(patchText: string): FilePatch[] {
+  const files: FilePatch[] = [];
+  const lines = patchText.split('\n');
+  let currentFile: FilePatch | null = null;
+  let currentHunk: Hunk | null = null;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // File header: --- a/path or --- path
+    if (line.startsWith('--- ')) {
+      // Next line should be +++ b/path
+      const nextLine = lines[i + 1];
+      if (nextLine && nextLine.startsWith('+++ ')) {
+        let filePath = nextLine.slice(4).trim();
+        // Remove b/ prefix
+        if (filePath.startsWith('b/')) {
+          filePath = filePath.slice(2);
+        }
+        currentFile = { filePath, hunks: [] };
+        files.push(currentFile);
+        i++; // skip the +++ line
+        continue;
+      }
+    }
+
+    // Hunk header: @@ -start,count +start,count @@
+    const hunkMatch = line.match(/^@@ -(\d+)(?:,\d+)? \+\d+(?:,\d+)? @@/);
+    if (hunkMatch && currentFile) {
+      currentHunk = {
+        oldStart: parseInt(hunkMatch[1], 10),
+        oldLines: [],
+        newLines: [],
+      };
+      currentFile.hunks.push(currentHunk);
+      continue;
+    }
+
+    // Hunk content
+    if (currentHunk) {
+      if (line.startsWith('-')) {
+        currentHunk.oldLines.push(line.slice(1));
+      } else if (line.startsWith('+')) {
+        currentHunk.newLines.push(line.slice(1));
+      } else if (line.startsWith(' ')) {
+        // Context line - appears in both old and new
+        currentHunk.oldLines.push(line.slice(1));
+        currentHunk.newLines.push(line.slice(1));
+      }
+    }
+  }
+
+  return files;
+}
+
+function findHunkPosition(fileLines: string[], hunkOldLines: string[], expectedStart: number, drift: number = 20): number {
+  // Try exact position first (0-indexed)
+  const start = expectedStart - 1;
+  if (matchesAt(fileLines, hunkOldLines, start)) {
+    return start;
+  }
+
+  // Fuzzy search within ±drift lines
+  for (let offset = 1; offset <= drift; offset++) {
+    if (matchesAt(fileLines, hunkOldLines, start + offset)) {
+      return start + offset;
+    }
+    if (matchesAt(fileLines, hunkOldLines, start - offset)) {
+      return start - offset;
+    }
+  }
+
+  return -1;
+}
+
+function matchesAt(fileLines: string[], hunkOldLines: string[], position: number): boolean {
+  if (position < 0 || position + hunkOldLines.length > fileLines.length) {
+    return false;
+  }
+
+  for (let i = 0; i < hunkOldLines.length; i++) {
+    // Normalize whitespace for comparison
+    const fileLine = fileLines[position + i].trimEnd();
+    const hunkLine = hunkOldLines[i].trimEnd();
+    if (fileLine !== hunkLine) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export async function applyPatch(patchText: string, basePath: string): Promise<PatchResult> {
+  const filePatches = parsePatch(patchText);
+  const results: PatchResult['results'] = [];
+  let allSuccess = true;
+
+  for (const filePatch of filePatches) {
+    const absolutePath = path.resolve(basePath, filePatch.filePath);
+
+    try {
+      let content: string;
+      try {
+        content = await fs.readFile(absolutePath, 'utf-8');
+      } catch {
+        // File doesn't exist - if all hunks are additions, create it
+        const allAdditions = filePatch.hunks.every((h) => h.oldLines.length === 0);
+        if (allAdditions) {
+          const newContent = filePatch.hunks.map((h) => h.newLines.join('\n')).join('\n');
+          await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+          await fs.writeFile(absolutePath, newContent, 'utf-8');
+          results.push({ file: filePatch.filePath, success: true, message: 'Created new file' });
+          continue;
+        }
+        throw new Error(`File not found: ${filePatch.filePath}`);
+      }
+
+      let fileLines = content.split('\n');
+
+      // Apply hunks in reverse order to preserve line numbers
+      const sortedHunks = [...filePatch.hunks].sort((a, b) => b.oldStart - a.oldStart);
+
+      for (const hunk of sortedHunks) {
+        const position = findHunkPosition(fileLines, hunk.oldLines, hunk.oldStart);
+        if (position === -1) {
+          throw new Error(
+            `Could not find match for hunk at line ${hunk.oldStart} in ${filePatch.filePath}`
+          );
+        }
+
+        // Replace old lines with new lines
+        fileLines.splice(position, hunk.oldLines.length, ...hunk.newLines);
+      }
+
+      await fs.writeFile(absolutePath, fileLines.join('\n'), 'utf-8');
+      results.push({
+        file: filePatch.filePath,
+        success: true,
+        message: `Applied ${filePatch.hunks.length} hunk(s)`,
+      });
+    } catch (error: any) {
+      allSuccess = false;
+      results.push({ file: filePatch.filePath, success: false, message: error.message });
+    }
+  }
+
+  return { success: allSuccess, results };
+}

package/src/utils/api.ts

@@ -59,7 +59,7 @@ export const fileTools = [
     type: 'function',
     function: {
       name: 'edit_file',
-      description: 'Make targeted edits to a file by replacing specific text',
+      description: 'Make targeted edits to a file by replacing specific text. For small single-location changes.',
       parameters: {
         type: 'object',
         properties: {
@@ -71,6 +71,23 @@ export const fileTools = [
       }
     }
   },
+  {
+    type: 'function',
+    function: {
+      name: 'apply_patch',
+      description: 'Apply a unified diff patch to one or more files. Preferred for multi-line or multi-file changes. Uses standard unified diff format with fuzzy line matching (±20 line drift).',
+      parameters: {
+        type: 'object',
+        properties: {
+          patch: {
+            type: 'string',
+            description: 'The unified diff patch text. Must include --- a/file and +++ b/file headers and @@ hunk headers.'
+          }
+        },
+        required: ['patch']
+      }
+    }
+  },
   {
     type: 'function',
     function: {
@@ -89,13 +106,15 @@ export const fileTools = [
     type: 'function',
     function: {
       name: 'search_files',
-      description: 'Search for text patterns across files',
+      description: 'Search for text patterns across files. Uses ripgrep when available for fast results with context lines.',
       parameters: {
         type: 'object',
         properties: {
           pattern: { type: 'string', description: 'The search pattern (regex supported)' },
           path: { type: 'string', description: 'Directory to search in (default: current)' },
-          file_pattern: { type: 'string', description: 'File glob pattern (e.g., "*.ts")' }
+          file_pattern: { type: 'string', description: 'File glob pattern (e.g., "*.ts")' },
+          context_lines: { type: 'number', description: 'Number of context lines around matches (default: 2)' },
+          max_results: { type: 'number', description: 'Maximum number of matches to return (default: 50)' }
         },
         required: ['pattern']
       }

package/src/utils/approval.ts

@@ -0,0 +1,31 @@
+export type ApprovalMode = 'suggest' | 'auto-edit' | 'full-auto';
+export type ToolCategory = 'read_only' | 'file_write' | 'shell';
+
+const TOOL_CATEGORIES: Record<string, ToolCategory> = {
+  read_file: 'read_only',
+  list_files: 'read_only',
+  search_files: 'read_only',
+  write_file: 'file_write',
+  edit_file: 'file_write',
+  apply_patch: 'file_write',
+  run_command: 'shell',
+};
+
+export function categorize(toolName: string): ToolCategory {
+  return TOOL_CATEGORIES[toolName] || 'shell';
+}
+
+export function needsApproval(toolName: string, mode: ApprovalMode): boolean {
+  const category = categorize(toolName);
+
+  switch (mode) {
+    case 'full-auto':
+      return false;
+    case 'auto-edit':
+      return category === 'shell';
+    case 'suggest':
+      return category === 'file_write' || category === 'shell';
+    default:
+      return true;
+  }
+}

package/src/utils/context.ts

@@ -5,7 +5,7 @@ import { promisify } from 'util';
 
 const execAsync = promisify(exec);
 
-export function buildSystemMessage(model: string, codebaseContext: string): string {
+export function buildSystemMessage(model: string, codebaseContext: string, projectInstructions?: string): string {
   let systemMessage = `You are Codea, an expert AI coding assistant created by Alia. You help developers write, debug, refactor, and understand code directly in their terminal.
 
 ## Core Principles
@@ -19,16 +19,18 @@ You have powerful tools to interact with the user's workspace:
 
 - **read_file**: Read file contents. Use to understand existing code before making changes.
 - **write_file**: Create new files or completely rewrite existing ones.
-- **edit_file**: Make precise, targeted changes to existing files. Preferred for small modifications.
+- **edit_file**: Make precise, targeted changes using exact text match and replace.
+- **apply_patch**: Apply unified diff patches to files. Preferred for multi-line or multi-file changes. Supports fuzzy line matching.
 - **list_files**: Explore directory structure. Use to understand project layout.
-- **search_files**: Find text/patterns across the codebase. Great for finding usages, definitions, etc.
+- **search_files**: Find text/patterns across the codebase with context lines. Uses ripgrep when available.
 - **run_command**: Execute shell commands (build, test, git, npm, etc.)
 
 ## Best Practices
 1. **Read before writing**: Always read relevant files before modifying them.
 2. **Minimal changes**: Make the smallest change necessary to accomplish the task.
 3. **Preserve style**: Match existing formatting, naming conventions, and patterns.
-4. **Explain when helpful**: For complex changes, briefly explain the approach.
+4. **Prefer apply_patch**: For multi-line edits, use apply_patch with unified diff format.
+5. **Explain when helpful**: For complex changes, briefly explain the approach.
 
 ## Response Style
 - Use markdown for formatting code blocks, lists, and emphasis.
@@ -36,6 +38,10 @@ You have powerful tools to interact with the user's workspace:
 - For code changes, be precise and action-oriented.
 - If unsure about requirements, ask clarifying questions.`;
 
+  if (projectInstructions) {
+    systemMessage += `\n\n## Project Instructions (from CODEA.md)\n${projectInstructions}`;
+  }
+
   if (codebaseContext) {
     systemMessage += `\n\n## Current Codebase Context\n${codebaseContext}`;
   }
@@ -43,6 +49,61 @@ You have powerful tools to interact with the user's workspace:
   return systemMessage;
 }
 
+export async function loadProjectInstructions(): Promise<string> {
+  const parts: string[] = [];
+
+  // 1. Global: ~/.codea/CODEA.md
+  const home = process.env.HOME || '';
+  if (home) {
+    const globalPath = path.join(home, '.codea', 'CODEA.md');
+    try {
+      const content = await fs.readFile(globalPath, 'utf-8');
+      if (content.trim()) {
+        parts.push(`# Global Instructions (~/.codea/CODEA.md)\n${content.trim()}`);
+      }
+    } catch {
+      // No global instructions
+    }
+  }
+
+  // 2. Project root: {git_root}/CODEA.md
+  let gitRoot = '';
+  try {
+    const { stdout } = await execAsync('git rev-parse --show-toplevel', { cwd: process.cwd() });
+    gitRoot = stdout.trim();
+  } catch {
+    // Not a git repo
+  }
+
+  if (gitRoot) {
+    const projectPath = path.join(gitRoot, 'CODEA.md');
+    try {
+      const content = await fs.readFile(projectPath, 'utf-8');
+      if (content.trim()) {
+        parts.push(`# Project Instructions (CODEA.md)\n${content.trim()}`);
+      }
+    } catch {
+      // No project instructions
+    }
+  }
+
+  // 3. Directory-level: {cwd}/CODEA.md (if different from git root)
+  const cwd = process.cwd();
+  if (cwd !== gitRoot) {
+    const dirPath = path.join(cwd, 'CODEA.md');
+    try {
+      const content = await fs.readFile(dirPath, 'utf-8');
+      if (content.trim()) {
+        parts.push(`# Directory Instructions (./CODEA.md)\n${content.trim()}`);
+      }
+    } catch {
+      // No directory instructions
+    }
+  }
+
+  return parts.join('\n\n---\n\n');
+}
+
 export async function getCodebaseContext(): Promise<string> {
   const cwd = process.cwd();
   const contextParts: string[] = [];