@alia-codea/cli 1.0.0 → 2.0.0

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[] = [];

package/src/utils/conversation.ts

@@ -0,0 +1,141 @@
+import { streamChat } from './api.js';
+import { executeTool } from '../tools/executor.js';
+import { ApprovalMode, needsApproval } from './approval.js';
+
+export interface Message {
+  role: 'user' | 'assistant' | 'system' | 'tool';
+  content: string;
+  tool_calls?: ToolCall[];
+  tool_call_id?: string;
+}
+
+export interface ToolCall {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+export interface ToolExecution {
+  id: string;
+  tool: string;
+  args: Record<string, any>;
+  result?: string;
+  success?: boolean;
+  approved?: boolean;
+}
+
+export type ConversationEvent =
+  | { type: 'thinking' }
+  | { type: 'content'; text: string }
+  | { type: 'tool_start'; execution: ToolExecution }
+  | { type: 'approval_needed'; execution: ToolExecution; resolve: (approved: boolean) => void }
+  | { type: 'tool_done'; execution: ToolExecution }
+  | { type: 'done'; content: string }
+  | { type: 'error'; message: string };
+
+export interface ConversationOptions {
+  messages: Message[];
+  systemMessage: string;
+  model: string;
+  approvalMode: ApprovalMode;
+  onEvent: (event: ConversationEvent) => void;
+  requestApproval: (execution: ToolExecution) => Promise<boolean>;
+  isActive: () => boolean;
+}
+
+export async function processConversation(opts: ConversationOptions): Promise<void> {
+  const { messages, systemMessage, model, approvalMode, onEvent, requestApproval, isActive } = opts;
+
+  while (isActive()) {
+    let fullContent = '';
+    let toolCalls: ToolCall[] | undefined;
+
+    onEvent({ type: 'thinking' });
+
+    try {
+      await streamChat(messages, systemMessage, model, {
+        onContent: (content) => {
+          if (!isActive()) return;
+          fullContent += content;
+          onEvent({ type: 'content', text: content });
+        },
+        onToolCall: () => {},
+        onDone: (_content, tcs) => {
+          toolCalls = tcs;
+        },
+        onError: (error) => {
+          onEvent({ type: 'error', message: error.message });
+        },
+      });
+    } catch (error: any) {
+      onEvent({ type: 'error', message: error.message });
+      break;
+    }
+
+    if (!isActive()) break;
+
+    if (toolCalls && toolCalls.length > 0) {
+      messages.push({
+        role: 'assistant',
+        content: fullContent,
+        tool_calls: toolCalls,
+      });
+
+      for (const tc of toolCalls) {
+        if (!isActive()) break;
+
+        const args = JSON.parse(tc.function.arguments);
+        const execution: ToolExecution = {
+          id: tc.id,
+          tool: tc.function.name,
+          args,
+        };
+
+        onEvent({ type: 'tool_start', execution });
+
+        // Check approval
+        if (needsApproval(tc.function.name, approvalMode)) {
+          const approved = await requestApproval(execution);
+          if (!approved) {
+            execution.approved = false;
+            execution.success = false;
+            execution.result = 'User declined this action.';
+            messages.push({
+              role: 'tool',
+              tool_call_id: tc.id,
+              content: 'User declined this action.',
+            });
+            onEvent({ type: 'tool_done', execution });
+            continue;
+          }
+          execution.approved = true;
+        } else {
+          execution.approved = true;
+        }
+
+        const result = await executeTool(tc.function.name, args);
+        execution.result = result.result;
+        execution.success = result.success;
+
+        messages.push({
+          role: 'tool',
+          tool_call_id: tc.id,
+          content: result.result,
+        });
+
+        onEvent({ type: 'tool_done', execution });
+      }
+
+      continue;
+    } else {
+      if (fullContent) {
+        messages.push({ role: 'assistant', content: fullContent });
+      }
+      onEvent({ type: 'done', content: fullContent });
+      break;
+    }
+  }
+}

package/dist/api-X2G5QROW.js

@@ -1,10 +0,0 @@
-import {
-  fetchModels,
-  fileTools,
-  streamChat
-} from "./chunk-SVPL4GNV.js";
-export {
-  fetchModels,
-  fileTools,
-  streamChat
-};