@alia-codea/cli 1.1.0 → 2.0.0

package/dist/index.js

@@ -1,40 +1,610 @@
 #!/usr/bin/env node
-import {
-  config,
-  createSession,
-  getSession,
-  getSessions,
-  saveSession,
-  streamChat
-} from "./chunk-SVPL4GNV.js";
 
 // src/index.ts
 import { Command } from "commander";
 
+// src/utils/config.ts
+import Conf from "conf";
+var config = new Conf({
+  projectName: "alia-codea-cli",
+  defaults: {
+    apiKey: "",
+    apiBaseUrl: "https://api.alia.onl",
+    defaultModel: "alia-v1-codea",
+    sessions: [],
+    currentSessionId: null
+  }
+});
+function saveSession(session) {
+  const sessions = config.get("sessions") || [];
+  const existingIndex = sessions.findIndex((s) => s.id === session.id);
+  if (existingIndex >= 0) {
+    sessions[existingIndex] = session;
+  } else {
+    sessions.unshift(session);
+  }
+  if (sessions.length > 50) {
+    sessions.splice(50);
+  }
+  config.set("sessions", sessions);
+}
+function getSession(id) {
+  const sessions = config.get("sessions") || [];
+  return sessions.find((s) => s.id === id);
+}
+function getSessions() {
+  return config.get("sessions") || [];
+}
+function createSession() {
+  const session = {
+    id: Date.now().toString(),
+    title: "New conversation",
+    messages: [],
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    cwd: process.cwd()
+  };
+  saveSession(session);
+  config.set("currentSessionId", session.id);
+  return session;
+}
+
 // src/commands/repl.ts
-import * as readline2 from "readline";
-import chalk3 from "chalk";
+import React4 from "react";
+import { render } from "ink";
+
+// src/app.tsx
+import { useState as useState3, useCallback, useRef, useEffect as useEffect2 } from "react";
+import { Box as Box7, useApp, useInput as useInput2 } from "ink";
+
+// src/components/Header.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function shortenPath(p) {
+  const home = process.env.HOME || "";
+  if (home && p.startsWith(home)) {
+    return "~" + p.slice(home.length);
+  }
+  return p;
+}
+var MODE_COLORS = {
+  "suggest": "yellow",
+  "auto-edit": "cyan",
+  "full-auto": "green"
+};
+function Header({ cwd, model, approvalMode, contextPercent }) {
+  return /* @__PURE__ */ jsxs(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, justifyContent: "space-between", children: [
+    /* @__PURE__ */ jsx(Text, { color: "cyan", children: shortenPath(cwd) }),
+    /* @__PURE__ */ jsxs(Box, { gap: 1, children: [
+      /* @__PURE__ */ jsx(Text, { color: "magenta", children: model }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "|" }),
+      /* @__PURE__ */ jsx(Text, { color: MODE_COLORS[approvalMode], children: approvalMode }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "|" }),
+      /* @__PURE__ */ jsxs(Text, { color: contextPercent < 20 ? "red" : "gray", children: [
+        contextPercent,
+        "% left"
+      ] })
+    ] })
+  ] });
+}
+
+// src/components/MessageList.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { Marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+
+// src/components/ToolCallCard.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function formatArgs(tool, args) {
+  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);
+  }
+}
+function ToolCallCard({ execution }) {
+  const { tool, args, result, success, approved } = execution;
+  const argStr = formatArgs(tool, args);
+  const isDone = result !== void 0;
+  if (approved === false) {
+    return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", paddingLeft: 2, children: [
+      /* @__PURE__ */ jsxs2(Box2, { gap: 1, children: [
+        /* @__PURE__ */ jsx2(Text2, { color: "red", children: "\u2717" }),
+        /* @__PURE__ */ jsx2(Text2, { bold: true, color: "gray", strikethrough: true, children: tool }),
+        /* @__PURE__ */ jsx2(Text2, { color: "gray", children: argStr })
+      ] }),
+      /* @__PURE__ */ jsx2(Box2, { paddingLeft: 2, children: /* @__PURE__ */ jsx2(Text2, { color: "yellow", dimColor: true, children: "Declined by user" }) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", paddingLeft: 2, children: [
+    /* @__PURE__ */ jsxs2(Box2, { gap: 1, children: [
+      isDone ? /* @__PURE__ */ jsx2(Text2, { color: success ? "green" : "red", children: success ? "\u2713" : "\u2717" }) : /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "\u2192" }),
+      /* @__PURE__ */ jsx2(Text2, { bold: true, children: tool }),
+      /* @__PURE__ */ jsx2(Text2, { color: "gray", children: argStr })
+    ] }),
+    isDone && result && /* @__PURE__ */ jsx2(Box2, { paddingLeft: 2, children: /* @__PURE__ */ jsxs2(Text2, { color: "gray", wrap: "truncate-end", children: [
+      result.slice(0, 120).replace(/\n/g, " "),
+      result.length > 120 ? "..." : ""
+    ] }) })
+  ] });
+}
+
+// src/components/MessageList.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var marked = new Marked(markedTerminal());
+function renderMarkdown(text) {
+  try {
+    const rendered = marked.parse(text);
+    if (typeof rendered === "string") {
+      return rendered.trimEnd();
+    }
+    return text;
+  } catch {
+    return text;
+  }
+}
+function MessageBlock({ message }) {
+  switch (message.type) {
+    case "user":
+      return /* @__PURE__ */ jsxs3(Box3, { paddingLeft: 1, paddingY: 0, children: [
+        /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: "\u276F " }),
+        /* @__PURE__ */ jsx3(Text3, { children: message.content })
+      ] });
+    case "assistant":
+      return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", paddingLeft: 1, children: /* @__PURE__ */ jsxs3(Box3, { children: [
+        /* @__PURE__ */ jsx3(Text3, { color: "magenta", children: "\u2726 " }),
+        /* @__PURE__ */ jsx3(Text3, { children: message.streaming ? message.content : renderMarkdown(message.content) })
+      ] }) });
+    case "tool":
+      if (message.toolExecution) {
+        return /* @__PURE__ */ jsx3(ToolCallCard, { execution: message.toolExecution });
+      }
+      return null;
+    case "info":
+      return /* @__PURE__ */ jsxs3(Box3, { paddingLeft: 1, children: [
+        /* @__PURE__ */ jsx3(Text3, { color: "blue", children: "\u2139 " }),
+        /* @__PURE__ */ jsx3(Text3, { color: "gray", children: message.content })
+      ] });
+    default:
+      return null;
+  }
+}
+function MessageList({ messages }) {
+  return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", flexGrow: 1, gap: 0, children: messages.map((msg) => /* @__PURE__ */ jsx3(MessageBlock, { message: msg }, msg.id)) });
+}
+
+// src/components/InputBar.tsx
+import { useState as useState2 } from "react";
+import { Box as Box5, Text as Text5 } from "ink";
+import TextInput from "ink-text-input";
+
+// src/components/ThinkingIndicator.tsx
+import { useState, useEffect } from "react";
+import { Box as Box4, Text as Text4 } from "ink";
+import Spinner from "ink-spinner";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function ThinkingIndicator({ label = "Thinking" }) {
+  const [elapsed, setElapsed] = useState(0);
+  useEffect(() => {
+    const interval = setInterval(() => {
+      setElapsed((e) => e + 1);
+    }, 1e3);
+    return () => clearInterval(interval);
+  }, []);
+  return /* @__PURE__ */ jsxs4(Box4, { gap: 1, children: [
+    /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: /* @__PURE__ */ jsx4(Spinner, { type: "dots" }) }),
+    /* @__PURE__ */ jsx4(Text4, { bold: true, children: label }),
+    /* @__PURE__ */ jsxs4(Text4, { color: "gray", children: [
+      "(",
+      elapsed,
+      "s)"
+    ] })
+  ] });
+}
+
+// src/components/InputBar.tsx
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function InputBar({ onSubmit, isProcessing, thinkingLabel }) {
+  const [value, setValue] = useState2("");
+  const handleSubmit = (text) => {
+    const trimmed = text.trim();
+    if (!trimmed) return;
+    setValue("");
+    onSubmit(trimmed);
+  };
+  if (isProcessing) {
+    return /* @__PURE__ */ jsx5(Box5, { paddingX: 1, children: /* @__PURE__ */ jsx5(ThinkingIndicator, { label: thinkingLabel || "Thinking" }) });
+  }
+  return /* @__PURE__ */ jsxs5(Box5, { paddingX: 1, children: [
+    /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: "\u276F " }),
+    /* @__PURE__ */ jsx5(TextInput, { value, onChange: setValue, onSubmit: handleSubmit })
+  ] });
+}
+
+// src/components/ApprovalPrompt.tsx
+import { Box as Box6, Text as Text6, useInput } from "ink";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function formatArgs2(tool, args) {
+  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)}`;
+  }
+}
+function ApprovalPrompt({ execution, onResolve }) {
+  useInput((input, key) => {
+    if (input === "y" || input === "Y") {
+      onResolve(true);
+    } else if (input === "n" || input === "N" || key.escape) {
+      onResolve(false);
+    }
+  });
+  const description = formatArgs2(execution.tool, execution.args);
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", paddingLeft: 2, paddingY: 0, children: [
+    /* @__PURE__ */ jsxs6(Box6, { gap: 1, children: [
+      /* @__PURE__ */ jsx6(Text6, { color: "yellow", children: "\u26A0" }),
+      /* @__PURE__ */ jsx6(Text6, { bold: true, children: description })
+    ] }),
+    execution.tool === "run_command" && execution.args.command && /* @__PURE__ */ jsx6(Box6, { paddingLeft: 2, children: /* @__PURE__ */ jsxs6(Text6, { color: "gray", children: [
+      "$ ",
+      execution.args.command
+    ] }) }),
+    execution.tool === "write_file" && execution.args.content && /* @__PURE__ */ jsx6(Box6, { paddingLeft: 2, children: /* @__PURE__ */ jsxs6(Text6, { color: "gray", children: [
+      execution.args.content.split("\n").length,
+      " lines"
+    ] }) }),
+    /* @__PURE__ */ jsxs6(Box6, { paddingLeft: 2, gap: 1, children: [
+      /* @__PURE__ */ jsx6(Text6, { color: "green", children: "[y]" }),
+      /* @__PURE__ */ jsx6(Text6, { children: "approve" }),
+      /* @__PURE__ */ jsx6(Text6, { color: "red", children: "[n]" }),
+      /* @__PURE__ */ jsx6(Text6, { children: "deny" })
+    ] })
+  ] });
+}
+
+// src/utils/api.ts
+import OpenAI from "openai";
+var fileTools = [
+  {
+    type: "function",
+    function: {
+      name: "read_file",
+      description: "Read the contents of a file",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "The file path to read" }
+        },
+        required: ["path"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "write_file",
+      description: "Write content to a file (creates or overwrites)",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "The file path to write to" },
+          content: { type: "string", description: "The content to write" }
+        },
+        required: ["path", "content"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "edit_file",
+      description: "Make targeted edits to a file by replacing specific text. For small single-location changes.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "The file path to edit" },
+          old_text: { type: "string", description: "The text to find and replace" },
+          new_text: { type: "string", description: "The replacement text" }
+        },
+        required: ["path", "old_text", "new_text"]
+      }
+    }
+  },
+  {
+    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 (\xB120 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: {
+      name: "list_files",
+      description: "List files in a directory",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "The directory path (default: current directory)" },
+          recursive: { type: "boolean", description: "Whether to list recursively" }
+        }
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "search_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")' },
+          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"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "run_command",
+      description: "Execute a shell command",
+      parameters: {
+        type: "object",
+        properties: {
+          command: { type: "string", description: "The command to execute" },
+          cwd: { type: "string", description: "Working directory (default: current)" }
+        },
+        required: ["command"]
+      }
+    }
+  }
+];
+async function streamChat(messages, systemMessage, model, callbacks) {
+  const apiKey = config.get("apiKey");
+  const baseUrl = config.get("apiBaseUrl") || "https://api.alia.onl";
+  const openai = new OpenAI({
+    apiKey,
+    baseURL: `${baseUrl}/v1`
+  });
+  const allMessages = [
+    { role: "system", content: systemMessage },
+    ...messages.map((m) => {
+      if (m.role === "tool") {
+        return { role: "tool", tool_call_id: m.tool_call_id, content: m.content };
+      } else if (m.tool_calls) {
+        return { role: "assistant", content: m.content || "", tool_calls: m.tool_calls };
+      }
+      return { role: m.role, content: m.content };
+    })
+  ];
+  try {
+    const stream = await openai.chat.completions.create({
+      model,
+      messages: allMessages,
+      tools: fileTools,
+      stream: true
+    });
+    let fullContent = "";
+    const toolCalls = [];
+    const toolCallsMap = /* @__PURE__ */ new Map();
+    for await (const chunk of stream) {
+      const delta = chunk.choices?.[0]?.delta;
+      if (!delta) continue;
+      if (delta.content) {
+        fullContent += delta.content;
+        callbacks.onContent(delta.content);
+      }
+      if (delta.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          const index = tc.index ?? 0;
+          if (!toolCallsMap.has(index)) {
+            const newToolCall = {
+              id: tc.id || "",
+              type: "function",
+              function: {
+                name: tc.function?.name || "",
+                arguments: tc.function?.arguments || ""
+              }
+            };
+            toolCallsMap.set(index, newToolCall);
+            toolCalls.push(newToolCall);
+          } else {
+            const existingToolCall = toolCallsMap.get(index);
+            if (tc.function?.name) {
+              existingToolCall.function.name = tc.function.name;
+            }
+            if (tc.function?.arguments) {
+              existingToolCall.function.arguments += tc.function.arguments;
+            }
+          }
+        }
+      }
+    }
+    callbacks.onDone(fullContent, toolCalls.length > 0 ? toolCalls : void 0);
+  } catch (error) {
+    callbacks.onError(error);
+  }
+}
 
 // src/tools/executor.ts
-import * as fs from "fs/promises";
-import * as path from "path";
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
 import { exec } from "child_process";
 import { promisify } from "util";
 import chalk from "chalk";
+
+// src/tools/patch.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+function parsePatch(patchText) {
+  const files = [];
+  const lines = patchText.split("\n");
+  let currentFile = null;
+  let currentHunk = null;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("--- ")) {
+      const nextLine = lines[i + 1];
+      if (nextLine && nextLine.startsWith("+++ ")) {
+        let filePath = nextLine.slice(4).trim();
+        if (filePath.startsWith("b/")) {
+          filePath = filePath.slice(2);
+        }
+        currentFile = { filePath, hunks: [] };
+        files.push(currentFile);
+        i++;
+        continue;
+      }
+    }
+    const hunkMatch = line.match(/^@@ -(\d+)(?:,\d+)? \+\d+(?:,\d+)? @@/);
+    if (hunkMatch && currentFile) {
+      currentHunk = {
+        oldStart: parseInt(hunkMatch[1], 10),
+        oldLines: [],
+        newLines: []
+      };
+      currentFile.hunks.push(currentHunk);
+      continue;
+    }
+    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(" ")) {
+        currentHunk.oldLines.push(line.slice(1));
+        currentHunk.newLines.push(line.slice(1));
+      }
+    }
+  }
+  return files;
+}
+function findHunkPosition(fileLines, hunkOldLines, expectedStart, drift = 20) {
+  const start = expectedStart - 1;
+  if (matchesAt(fileLines, hunkOldLines, start)) {
+    return start;
+  }
+  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, hunkOldLines, position) {
+  if (position < 0 || position + hunkOldLines.length > fileLines.length) {
+    return false;
+  }
+  for (let i = 0; i < hunkOldLines.length; i++) {
+    const fileLine = fileLines[position + i].trimEnd();
+    const hunkLine = hunkOldLines[i].trimEnd();
+    if (fileLine !== hunkLine) {
+      return false;
+    }
+  }
+  return true;
+}
+async function applyPatch(patchText, basePath) {
+  const filePatches = parsePatch(patchText);
+  const results = [];
+  let allSuccess = true;
+  for (const filePatch of filePatches) {
+    const absolutePath = path.resolve(basePath, filePatch.filePath);
+    try {
+      let content;
+      try {
+        content = await fs.readFile(absolutePath, "utf-8");
+      } catch {
+        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");
+      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}`
+          );
+        }
+        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) {
+      allSuccess = false;
+      results.push({ file: filePatch.filePath, success: false, message: error.message });
+    }
+  }
+  return { success: allSuccess, results };
+}
+
+// src/tools/executor.ts
 var execAsync = promisify(exec);
 async function executeTool(name, args) {
   try {
     switch (name) {
       case "read_file":
-        return await readFile2(args.path);
+        return await readFile3(args.path);
       case "write_file":
-        return await writeFile2(args.path, args.content);
+        return await writeFile3(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:
@@ -44,36 +614,61 @@ async function executeTool(name, args) {
     return { success: false, result: error.message };
   }
 }
-async function readFile2(filePath) {
-  const absolutePath = path.resolve(process.cwd(), filePath);
-  const content = await fs.readFile(absolutePath, "utf-8");
+async function readFile3(filePath) {
+  const absolutePath = path2.resolve(process.cwd(), filePath);
+  const content = await fs2.readFile(absolutePath, "utf-8");
   return { success: true, result: content };
 }
-async function writeFile2(filePath, content) {
-  const absolutePath = path.resolve(process.cwd(), filePath);
-  await fs.mkdir(path.dirname(absolutePath), { recursive: true });
-  await fs.writeFile(absolutePath, content, "utf-8");
+async function writeFile3(filePath, content) {
+  const absolutePath = path2.resolve(process.cwd(), filePath);
+  await fs2.mkdir(path2.dirname(absolutePath), { recursive: true });
+  await fs2.writeFile(absolutePath, content, "utf-8");
   return { success: true, result: `File written: ${filePath}` };
 }
 async function editFile(filePath, oldText, newText) {
-  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)}..."` };
+  const absolutePath = path2.resolve(process.cwd(), filePath);
+  const content = await fs2.readFile(absolutePath, "utf-8");
+  if (content.includes(oldText)) {
+    const newContent = content.replace(oldText, newText);
+    await fs2.writeFile(absolutePath, newContent, "utf-8");
+    return { success: true, result: `File edited: ${filePath}` };
+  }
+  const normalizedOld = oldText.replace(/\s+/g, " ").trim();
+  const lines = content.split("\n");
+  let matchStart = -1;
+  let matchEnd = -1;
+  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;
   }
-  const newContent = content.replace(oldText, newText);
-  await fs.writeFile(absolutePath, newContent, "utf-8");
-  return { success: true, result: `File edited: ${filePath}` };
+  if (matchStart >= 0) {
+    const newLines = [...lines.slice(0, matchStart), ...newText.split("\n"), ...lines.slice(matchEnd + 1)];
+    await fs2.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) {
+  const result = await applyPatch(patchText, process.cwd());
+  const summary = result.results.map((r) => `${r.success ? "\u2713" : "\u2717"} ${r.file}: ${r.message}`).join("\n");
+  return { success: result.success, result: summary };
 }
 async function listFiles(dirPath = ".", recursive = false) {
-  const absolutePath = path.resolve(process.cwd(), dirPath);
+  const absolutePath = path2.resolve(process.cwd(), dirPath);
   if (recursive) {
     const files = [];
     async function walk(dir) {
-      const entries = await fs.readdir(dir, { withFileTypes: true });
+      const entries = await fs2.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-        const relativePath = path.relative(absolutePath, fullPath);
+        const fullPath = path2.join(dir, entry.name);
+        const relativePath = path2.relative(absolutePath, fullPath);
         if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") {
           continue;
         }
@@ -88,19 +683,62 @@ async function listFiles(dirPath = ".", recursive = false) {
     await walk(absolutePath);
     return { success: true, result: files.join("\n") };
   } else {
-    const entries = await fs.readdir(absolutePath, { withFileTypes: true });
+    const entries = await fs2.readdir(absolutePath, { withFileTypes: true });
     const files = entries.map((e) => e.name + (e.isDirectory() ? "/" : ""));
     return { success: true, result: files.join("\n") };
   }
 }
-async function searchFiles(pattern, dirPath = ".", filePattern) {
-  const absolutePath = path.resolve(process.cwd(), dirPath);
+async function searchFiles(pattern, dirPath = ".", filePattern, contextLines = 2, maxResults = 50) {
+  const absolutePath = path2.resolve(process.cwd(), dirPath);
+  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: 3e4
+    });
+    const results2 = [];
+    const lines = stdout.trim().split("\n");
+    for (const line of lines) {
+      try {
+        const data = JSON.parse(line);
+        if (data.type === "match") {
+          const relPath = path2.relative(absolutePath, data.data.path.text);
+          const lineNum = data.data.line_number;
+          const text = data.data.lines.text.trimEnd();
+          results2.push(`${relPath}:${lineNum}: ${text}`);
+        } else if (data.type === "context") {
+          const relPath = path2.relative(absolutePath, data.data.path.text);
+          const lineNum = data.data.line_number;
+          const text = data.data.lines.text.trimEnd();
+          results2.push(`${relPath}:${lineNum}  ${text}`);
+        }
+      } catch {
+      }
+    }
+    if (results2.length === 0) {
+      return { success: true, result: "No matches found." };
+    }
+    return { success: true, result: results2.join("\n") };
+  } catch {
+  }
   const regex = new RegExp(pattern, "gi");
   const results = [];
+  const fileMatchCounts = /* @__PURE__ */ new Map();
   async function searchDir(dir) {
-    const entries = await fs.readdir(dir, { withFileTypes: true });
+    const entries = await fs2.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
+      const fullPath = path2.join(dir, entry.name);
       if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") {
         continue;
       }
@@ -108,21 +746,39 @@ async function searchFiles(pattern, dirPath = ".", filePattern) {
         await searchDir(fullPath);
       } else {
         if (filePattern) {
-          const ext = path.extname(entry.name);
+          const ext = path2.extname(entry.name);
           const patternExt = filePattern.replace("*", "");
           if (ext !== patternExt && !entry.name.match(filePattern.replace("*", ".*"))) {
             continue;
           }
         }
         try {
-          const content = await fs.readFile(fullPath, "utf-8");
+          const content = await fs2.readFile(fullPath, "utf-8");
+          if (content.includes("\0")) continue;
           const lines = content.split("\n");
+          const matchIndices = [];
           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 = path2.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 {
         }
       }
@@ -132,11 +788,14 @@ async function searchFiles(pattern, dirPath = ".", filePattern) {
   if (results.length === 0) {
     return { success: true, result: "No matches found." };
   }
-  return { success: true, result: results.slice(0, 100).join("\n") + (results.length > 100 ? `
-... 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 = `
+(${totalMatches} matches in ${fileMatchCounts.size} files)`;
+  return { success: true, result: formatted + footer };
 }
 async function runCommand(command, cwd) {
-  const workingDir = cwd ? path.resolve(process.cwd(), cwd) : process.cwd();
+  const workingDir = cwd ? path2.resolve(process.cwd(), cwd) : process.cwd();
   try {
     const { stdout, stderr } = await execAsync(command, {
       cwd: workingDir,
@@ -156,113 +815,123 @@ ${error.stderr}` : "") || error.message
     };
   }
 }
-function formatToolCall(name, args) {
-  const labels = {
-    read_file: "Reading file",
-    write_file: "Writing file",
-    edit_file: "Editing file",
-    list_files: "Listing files",
-    search_files: "Searching files",
-    run_command: "Running command"
-  };
-  const label = labels[name] || name;
-  const argStr = Object.entries(args).map(([k, v]) => `${k}: ${typeof v === "string" ? v.slice(0, 50) : v}`).join(", ");
-  return `${chalk.cyan("\u2192")} ${chalk.bold(label)}: ${chalk.gray(argStr)}`;
-}
 
-// src/utils/ui.ts
-import chalk2 from "chalk";
-import * as readline from "readline";
-function printTips() {
-  console.log(chalk2.white("Tips for getting started:"));
-  console.log(chalk2.gray("1. Ask questions, edit files, or run commands."));
-  console.log(chalk2.gray("2. Be specific for the best results."));
-  console.log(chalk2.gray("3. ") + chalk2.cyan("/help") + chalk2.gray(" for more information."));
-  console.log();
-}
-function printPrompt() {
-  process.stdout.write(chalk2.cyan("\u276F "));
+// src/utils/approval.ts
+var TOOL_CATEGORIES = {
+  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"
+};
+function categorize(toolName) {
+  return TOOL_CATEGORIES[toolName] || "shell";
 }
-function printToolExecution(tool, description) {
-  const boxWidth = Math.min(process.stdout.columns || 80, 80);
-  const content = `${chalk2.bold(tool)} ${description}`;
-  const paddedContent = ` \u2190 ${content} `.padEnd(boxWidth - 4);
-  console.log();
-  console.log(chalk2.gray("\u250C" + "\u2500".repeat(boxWidth - 2) + "\u2510"));
-  console.log(chalk2.gray("\u2502") + paddedContent + chalk2.gray("\u2502"));
-  console.log(chalk2.gray("\u2514" + "\u2500".repeat(boxWidth - 2) + "\u2518"));
-}
-function printToolResult(success, result) {
-  const status = success ? chalk2.green("\u2713") : chalk2.red("\u2717");
-  const preview = result.slice(0, 100).replace(/\n/g, " ");
-  console.log(`  ${status} ${chalk2.gray(preview)}${result.length > 100 ? "..." : ""}`);
-  console.log();
-}
-var statusInterval = null;
-var startTime = 0;
-function showThinkingStatus(message) {
-  startTime = Date.now();
-  const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-  let frameIndex = 0;
-  statusInterval = setInterval(() => {
-    const elapsed = Math.floor((Date.now() - startTime) / 1e3);
-    const frame = frames[frameIndex % frames.length];
-    frameIndex++;
-    readline.clearLine(process.stdout, 0);
-    readline.cursorTo(process.stdout, 0);
-    process.stdout.write(
-      chalk2.cyan(frame) + " " + chalk2.bold(message) + chalk2.gray(` (esc to cancel, ${elapsed}s)`)
-    );
-  }, 80);
-}
-function hideThinkingStatus() {
-  if (statusInterval) {
-    clearInterval(statusInterval);
-    statusInterval = null;
-    readline.clearLine(process.stdout, 0);
-    readline.cursorTo(process.stdout, 0);
-  }
-}
-function printStatusBar(cwd, model, contextPercent) {
-  const width = process.stdout.columns || 80;
-  const cwdPart = chalk2.cyan(shortenPath(cwd));
-  const modelPart = chalk2.magenta(`${model} (${contextPercent}% context left)`);
-  const padding = width - stripAnsi(cwdPart).length - stripAnsi(modelPart).length - 4;
-  const spacer = " ".repeat(Math.max(padding, 2));
-  console.log();
-  console.log(chalk2.gray("\u2500".repeat(width)));
-  console.log(`${cwdPart}${spacer}${modelPart}`);
-}
-function shortenPath(p) {
-  const home = process.env.HOME || "";
-  if (p.startsWith(home)) {
-    return "~" + p.slice(home.length);
+function needsApproval(toolName, mode) {
+  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;
   }
-  return p;
-}
-function stripAnsi(str) {
-  return str.replace(/\x1b\[[0-9;]*m/g, "");
-}
-function printAssistantPrefix() {
-  process.stdout.write(chalk2.magenta("\u2726 "));
 }
-function printError(message) {
-  console.log(chalk2.red("\u2717 Error: ") + message);
-}
-function printSuccess(message) {
-  console.log(chalk2.green("\u2713 ") + message);
-}
-function printInfo(message) {
-  console.log(chalk2.blue("\u2139 ") + message);
+
+// src/utils/conversation.ts
+async function processConversation(opts) {
+  const { messages, systemMessage, model, approvalMode, onEvent, requestApproval, isActive } = opts;
+  while (isActive()) {
+    let fullContent = "";
+    let toolCalls;
+    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) {
+      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 = {
+          id: tc.id,
+          tool: tc.function.name,
+          args
+        };
+        onEvent({ type: "tool_start", execution });
+        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;
+    }
+  }
 }
 
 // src/utils/context.ts
-import * as fs2 from "fs/promises";
-import * as path2 from "path";
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
 var execAsync2 = promisify2(exec2);
-function buildSystemMessage(model, codebaseContext) {
+function buildSystemMessage(model, codebaseContext, projectInstructions) {
   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
@@ -276,22 +945,30 @@ 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.
 - For code explanations, be thorough but focused.
 - For code changes, be precise and action-oriented.
 - If unsure about requirements, ask clarifying questions.`;
+  if (projectInstructions) {
+    systemMessage += `
+
+## Project Instructions (from CODEA.md)
+${projectInstructions}`;
+  }
   if (codebaseContext) {
     systemMessage += `
 
@@ -300,12 +977,57 @@ ${codebaseContext}`;
   }
   return systemMessage;
 }
+async function loadProjectInstructions() {
+  const parts = [];
+  const home = process.env.HOME || "";
+  if (home) {
+    const globalPath = path3.join(home, ".codea", "CODEA.md");
+    try {
+      const content = await fs3.readFile(globalPath, "utf-8");
+      if (content.trim()) {
+        parts.push(`# Global Instructions (~/.codea/CODEA.md)
+${content.trim()}`);
+      }
+    } catch {
+    }
+  }
+  let gitRoot = "";
+  try {
+    const { stdout } = await execAsync2("git rev-parse --show-toplevel", { cwd: process.cwd() });
+    gitRoot = stdout.trim();
+  } catch {
+  }
+  if (gitRoot) {
+    const projectPath = path3.join(gitRoot, "CODEA.md");
+    try {
+      const content = await fs3.readFile(projectPath, "utf-8");
+      if (content.trim()) {
+        parts.push(`# Project Instructions (CODEA.md)
+${content.trim()}`);
+      }
+    } catch {
+    }
+  }
+  const cwd = process.cwd();
+  if (cwd !== gitRoot) {
+    const dirPath = path3.join(cwd, "CODEA.md");
+    try {
+      const content = await fs3.readFile(dirPath, "utf-8");
+      if (content.trim()) {
+        parts.push(`# Directory Instructions (./CODEA.md)
+${content.trim()}`);
+      }
+    } catch {
+    }
+  }
+  return parts.join("\n\n---\n\n");
+}
 async function getCodebaseContext() {
   const cwd = process.cwd();
   const contextParts = [];
   try {
-    const pkgPath = path2.join(cwd, "package.json");
-    const pkgContent = await fs2.readFile(pkgPath, "utf-8");
+    const pkgPath = path3.join(cwd, "package.json");
+    const pkgContent = await fs3.readFile(pkgPath, "utf-8");
     const pkg = JSON.parse(pkgContent);
     contextParts.push(`Project: ${pkg.name || "Unknown"} (${pkg.description || "No description"})`);
     if (pkg.dependencies) {
@@ -342,16 +1064,16 @@ async function getRelevantFiles(dir, maxFiles = 20) {
   async function walk(currentDir, depth = 0) {
     if (depth > 3 || relevantFiles.length >= maxFiles) return;
     try {
-      const entries = await fs2.readdir(currentDir, { withFileTypes: true });
+      const entries = await fs3.readdir(currentDir, { withFileTypes: true });
       for (const entry of entries) {
         if (relevantFiles.length >= maxFiles) break;
         if (ignoreDirs.includes(entry.name)) continue;
-        const fullPath = path2.join(currentDir, entry.name);
-        const relativePath = path2.relative(dir, fullPath);
+        const fullPath = path3.join(currentDir, entry.name);
+        const relativePath = path3.relative(dir, fullPath);
         if (entry.isDirectory()) {
           await walk(fullPath, depth + 1);
         } else {
-          const ext = path2.extname(entry.name);
+          const ext = path3.extname(entry.name);
           if (relevantExtensions.includes(ext) || entry.name === "README.md" || entry.name === "package.json") {
             relevantFiles.push(relativePath);
           }
@@ -364,326 +1086,369 @@ async function getRelevantFiles(dir, maxFiles = 20) {
   return relevantFiles;
 }
 
-// src/commands/repl.ts
-async function startRepl(options) {
-  const session = createSession();
-  const messages = [];
-  let isProcessing = false;
-  let contextUsed = 0;
-  const maxContext = 128e3;
-  printTips();
-  let codebaseContext = "";
-  if (options.context !== false) {
-    printInfo("Analyzing codebase...");
-    codebaseContext = await getCodebaseContext();
-    if (codebaseContext) {
-      printInfo(`Loaded context from ${codebaseContext.split("\n").length} files`);
-    }
-  }
-  const rl = readline2.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    terminal: true
-  });
-  rl.on("SIGINT", () => {
-    if (isProcessing) {
-      isProcessing = false;
-      hideThinkingStatus();
-      console.log(chalk3.yellow("\nCancelled."));
-      printPrompt();
-    } else {
-      console.log(chalk3.gray("\nGoodbye!"));
-      process.exit(0);
-    }
-  });
-  const askQuestion = () => {
-    printPrompt();
-    rl.question("", async (input) => {
-      const trimmed = input.trim();
-      if (!trimmed) {
-        askQuestion();
-        return;
-      }
-      if (trimmed.startsWith("/")) {
-        await handleSlashCommand(trimmed, messages, session, options);
-        askQuestion();
-        return;
-      }
-      messages.push({ role: "user", content: trimmed });
-      isProcessing = true;
-      const systemMessage = buildSystemMessage(options.model, codebaseContext);
-      await processConversation(messages, systemMessage, options.model, () => isProcessing);
-      isProcessing = false;
-      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);
-      contextUsed = Math.min(95, Math.floor(messages.reduce((acc, m) => acc + m.content.length, 0) / maxContext * 100));
-      printStatusBar(process.cwd(), getModelDisplayName(options.model), 100 - contextUsed);
-      askQuestion();
-    });
-  };
-  askQuestion();
+// src/app.tsx
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var msgCounter = 0;
+function nextId() {
+  return `msg-${++msgCounter}`;
 }
-async function processConversation(messages, systemMessage, model, isActive) {
-  while (isActive()) {
-    console.log();
-    printAssistantPrefix();
-    let fullContent = "";
-    let toolCalls;
-    showThinkingStatus("Thinking");
-    try {
-      await streamChat(messages, systemMessage, model, {
-        onContent: (content) => {
-          if (!isActive()) return;
-          hideThinkingStatus();
-          process.stdout.write(content);
-          fullContent += content;
-        },
-        onToolCall: (tc) => {
-        },
-        onDone: (content, tcs) => {
-          hideThinkingStatus();
-          toolCalls = tcs;
-        },
-        onError: (error) => {
-          hideThinkingStatus();
-          printError(error.message);
+function App({ options }) {
+  const { exit } = useApp();
+  const [displayMessages, setDisplayMessages] = useState3([]);
+  const [isProcessing, setIsProcessing] = useState3(false);
+  const [thinkingLabel, setThinkingLabel] = useState3("Thinking");
+  const [approvalMode, setApprovalMode] = useState3(options.approvalMode);
+  const [contextPercent, setContextPercent] = useState3(100);
+  const [pendingApproval, setPendingApproval] = useState3(null);
+  const [ready, setReady] = useState3(false);
+  const [codebaseContext, setCodebaseContext] = useState3("");
+  const [instructions, setInstructions] = useState3("");
+  const messagesRef = useRef([]);
+  const sessionRef = useRef(createSession());
+  const activeRef = useRef(true);
+  const streamingIdRef = useRef(null);
+  useEffect2(() => {
+    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` }
+          ]);
         }
-      });
-    } catch (error) {
-      hideThinkingStatus();
-      printError(error.message);
-      break;
-    }
-    if (!isActive()) break;
-    if (toolCalls && toolCalls.length > 0) {
-      messages.push({
-        role: "assistant",
-        content: fullContent,
-        tool_calls: toolCalls
-      });
-      if (fullContent) {
-        console.log();
       }
-      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);
-        messages.push({
-          role: "tool",
-          tool_call_id: tc.id,
-          content: result.result
-        });
+      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)` }
+        ]);
       }
-      continue;
-    } else {
-      if (fullContent) {
-        messages.push({ role: "assistant", content: fullContent });
-        console.log();
+      if (!cancelled) {
+        setCodebaseContext(ctx);
+        setInstructions(instr);
+        setReady(true);
       }
-      break;
-    }
-  }
-}
-async function handleSlashCommand(command, messages, session, options) {
-  const [cmd, ...args] = command.slice(1).split(" ");
-  switch (cmd.toLowerCase()) {
-    case "help":
-      console.log();
-      console.log(chalk3.bold("Available commands:"));
-      console.log(chalk3.cyan("  /help") + chalk3.gray("     - Show this help"));
-      console.log(chalk3.cyan("  /clear") + chalk3.gray("    - Clear conversation"));
-      console.log(chalk3.cyan("  /model") + chalk3.gray("    - Switch model"));
-      console.log(chalk3.cyan("  /context") + chalk3.gray("  - Show current context"));
-      console.log(chalk3.cyan("  /save") + chalk3.gray("     - Save conversation"));
-      console.log(chalk3.cyan("  /exit") + chalk3.gray("     - Exit Codea"));
-      console.log();
-      break;
-    case "clear":
-      messages.length = 0;
-      console.log(chalk3.green("Conversation cleared."));
-      break;
-    case "model":
-      const modelArg = args[0];
-      if (modelArg) {
-        options.model = modelArg.startsWith("alia-") ? modelArg : `alia-v1-${modelArg}`;
-        console.log(chalk3.green(`Model switched to ${options.model}`));
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  useInput2((_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 {
-        console.log(chalk3.gray("Current model: ") + chalk3.cyan(options.model));
-        try {
-          const { fetchModels } = await import("./api-X2G5QROW.js");
-          const apiModels = await fetchModels();
-          if (apiModels.length > 0) {
-            console.log(chalk3.gray("Available models:"));
-            for (const m of apiModels) {
-              console.log(chalk3.gray("  ") + chalk3.cyan(m.id) + chalk3.gray(` - ${m.name}`));
-            }
+        exit();
+      }
+    }
+  });
+  const addMessage = useCallback((msg) => {
+    setDisplayMessages((prev) => [...prev, msg]);
+  }, []);
+  const updateLastAssistant = useCallback((text) => {
+    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) => {
+    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]);
+            addMessage({ id: nextId(), type: "info", content: `Approval mode: ${args[0]}` });
           } else {
-            console.log(chalk3.gray("Available: codea, codea-pro, codea-thinking"));
+            addMessage({ id: nextId(), type: "info", content: `Current mode: ${approvalMode}. Options: suggest, auto-edit, full-auto` });
           }
-        } catch {
-          console.log(chalk3.gray("Available: codea, codea-pro, codea-thinking"));
+          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;
+      }
+    }
+    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((resolve3) => {
+          setPendingApproval({ execution, resolve: resolve3 });
+        });
+      },
+      onEvent: (event) => {
+        switch (event.type) {
+          case "thinking":
+            setThinkingLabel("Thinking");
+            streamingIdRef.current = nextId();
+            setDisplayMessages((prev) => [
+              ...prev,
+              { id: streamingIdRef.current, type: "assistant", content: "", streaming: true }
+            ]);
+            break;
+          case "content":
+            updateLastAssistant(event.text);
+            break;
+          case "tool_start":
+            finalizeAssistant();
+            setThinkingLabel(`Running ${event.execution.tool}`);
+            addMessage({
+              id: nextId(),
+              type: "tool",
+              content: "",
+              toolExecution: { ...event.execution }
+            });
+            break;
+          case "tool_done":
+            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;
         }
       }
-      break;
-    case "context":
-      console.log(chalk3.gray(`Messages in context: ${messages.length}`));
-      console.log(chalk3.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(chalk3.green("Conversation saved."));
-      break;
-    case "exit":
-    case "quit":
-      console.log(chalk3.gray("Goodbye!"));
-      process.exit(0);
-      break;
-    default:
-      console.log(chalk3.yellow(`Unknown command: /${cmd}`));
-      console.log(chalk3.gray("Type /help for available commands."));
-  }
-}
-function formatToolArgs(name, args) {
-  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);
-  }
+    });
+    setIsProcessing(false);
+    setPendingApproval(null);
+    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);
+    const totalChars = messagesRef.current.reduce((acc, m) => acc + m.content.length, 0);
+    const maxContext = 128e3;
+    setContextPercent(Math.max(5, 100 - Math.floor(totalChars / maxContext * 100)));
+  }, [approvalMode, codebaseContext, instructions, options]);
+  const handleApprovalResolve = useCallback((approved) => {
+    if (pendingApproval) {
+      pendingApproval.resolve(approved);
+      setPendingApproval(null);
+    }
+  }, [pendingApproval]);
+  const modelDisplay = options.model.replace("alia-v1-", "");
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx7(
+      Header,
+      {
+        cwd: process.cwd(),
+        model: modelDisplay,
+        approvalMode,
+        contextPercent
+      }
+    ),
+    /* @__PURE__ */ jsx7(MessageList, { messages: displayMessages }),
+    pendingApproval ? /* @__PURE__ */ jsx7(
+      ApprovalPrompt,
+      {
+        execution: pendingApproval.execution,
+        onResolve: handleApprovalResolve
+      }
+    ) : /* @__PURE__ */ jsx7(
+      InputBar,
+      {
+        onSubmit: handleSubmit,
+        isProcessing,
+        thinkingLabel
+      }
+    )
+  ] });
 }
-function getModelDisplayName(model) {
-  const names = {
-    "alia-v1-codea": "codea",
-    "alia-v1-pro": "codea-pro",
-    "alia-v1-thinking": "codea-thinking"
+
+// src/commands/repl.ts
+async function startRepl(options) {
+  const appOptions = {
+    model: options.model,
+    approvalMode: options.approvalMode || "suggest",
+    context: options.context
   };
-  return names[model] || model;
+  const { waitUntilExit } = render(React4.createElement(App, { options: appOptions }));
+  await waitUntilExit();
 }
 
 // src/commands/run.ts
-import chalk4 from "chalk";
+import chalk2 from "chalk";
+import * as readline from "readline";
 async function runPrompt(prompt, options) {
   const messages = [];
+  const toolResults = [];
   let codebaseContext = "";
   if (options.context !== false) {
     codebaseContext = await getCodebaseContext();
   }
+  const instructions = await loadProjectInstructions();
   messages.push({ role: "user", content: prompt });
-  const systemMessage = buildSystemMessage(options.model, codebaseContext);
-  await processConversation2(messages, systemMessage, options.model, options.yes);
-}
-async function processConversation2(messages, systemMessage, model, autoApprove) {
-  let continueProcessing = true;
-  while (continueProcessing) {
-    printAssistantPrefix();
-    let fullContent = "";
-    let toolCalls;
-    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) {
-      hideThinkingStatus();
-      printError(error.message);
-      break;
-    }
-    if (toolCalls && toolCalls.length > 0) {
-      messages.push({
-        role: "assistant",
-        content: fullContent,
-        tool_calls: toolCalls
-      });
-      if (fullContent) console.log();
-      for (const tc of toolCalls) {
-        const args = JSON.parse(tc.function.arguments);
-        const isDestructive = ["write_file", "edit_file", "run_command"].includes(tc.function.name);
-        if (isDestructive && !autoApprove) {
-          console.log();
-          console.log(chalk4.yellow("\u26A0 ") + chalk4.bold("Approval required:"));
-          console.log(formatToolCall(tc.function.name, args));
-          console.log();
-          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 = options.yes ? "full-auto" : options.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(chalk2.magenta("\u2726 "));
+          }
+          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(chalk2.cyan("  \u2192 ") + chalk2.bold(event.execution.tool) + " " + chalk2.gray(formatArgs3(event.execution)));
+          }
+          break;
+        case "tool_done":
+          if (event.execution.result !== void 0) {
+            toolResults.push({
+              tool: event.execution.tool,
+              args: event.execution.args,
+              result: event.execution.result,
+              success: event.execution.success ?? false
             });
-            continue;
           }
-        }
-        printToolExecution(tc.function.name, formatToolArgs2(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
-        });
-      }
-      continue;
-    } else {
-      if (fullContent) {
-        messages.push({ role: "assistant", content: fullContent });
-        console.log();
+          if (!options.quiet && !options.json) {
+            const icon = event.execution.success ? chalk2.green("  \u2713") : chalk2.red("  \u2717");
+            const preview = (event.execution.result || "").slice(0, 100).replace(/\n/g, " ");
+            console.log(`${icon} ${chalk2.gray(preview)}`);
+          }
+          break;
+        case "done":
+          if (!options.quiet && !options.json) {
+            console.log();
+          }
+          break;
+        case "error":
+          if (!options.json) {
+            console.error(chalk2.red("Error: ") + event.message);
+          }
+          break;
       }
-      break;
+    }
+  });
+  if (options.json) {
+    const output = {
+      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() {
-  const readline5 = await import("readline");
-  const rl = readline5.createInterface({
+async function askApproval(execution) {
+  const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve2) => {
-    rl.question(chalk4.cyan("Allow? [y/N] "), (answer) => {
+  const desc = formatArgs3(execution);
+  console.log();
+  console.log(chalk2.yellow("\u26A0 ") + chalk2.bold(execution.tool) + " " + desc);
+  return new Promise((resolve3) => {
+    rl.question(chalk2.cyan("  Allow? [y/N] "), (answer) => {
       rl.close();
-      resolve2(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+      resolve3(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
     });
   });
 }
-function formatToolArgs2(name, args) {
-  switch (name) {
+function formatArgs3(execution) {
+  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":
@@ -691,16 +1456,25 @@ function formatToolArgs2(name, args) {
     case "run_command":
       return args.command || "";
     default:
-      return JSON.stringify(args).slice(0, 50);
+      return JSON.stringify(args).slice(0, 60);
   }
 }
 
 // src/commands/auth.ts
-import * as readline3 from "readline";
+import * as readline2 from "readline";
 import * as crypto from "crypto";
 import * as http from "http";
 import { exec as exec3 } from "child_process";
-import chalk5 from "chalk";
+import chalk3 from "chalk";
+function printSuccess(message) {
+  console.log(chalk3.green("\u2713 ") + message);
+}
+function printError(message) {
+  console.log(chalk3.red("\u2717 Error: ") + message);
+}
+function printInfo(message) {
+  console.log(chalk3.blue("\u2139 ") + message);
+}
 function openBrowser(url) {
   const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? 'start ""' : "xdg-open";
   exec3(`${cmd} "${url}"`);
@@ -708,7 +1482,7 @@ function openBrowser(url) {
 async function loginWithBrowser() {
   const codeVerifier = crypto.randomBytes(32).toString("base64url");
   const codeChallenge = crypto.createHash("sha256").update(codeVerifier).digest("base64url");
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const server = http.createServer(async (req, res) => {
       const url = new URL(req.url, `http://localhost`);
       if (url.pathname !== "/callback") {
@@ -724,7 +1498,7 @@ async function loginWithBrowser() {
           '<html><body style="font-family:system-ui;text-align:center;padding:60px"><h2>Authorization cancelled</h2><p>You can close this window.</p></body></html>'
         );
         server.close();
-        resolve2(false);
+        resolve3(false);
         return;
       }
       try {
@@ -749,7 +1523,7 @@ async function loginWithBrowser() {
           console.log();
           printSuccess("Logged in successfully!");
           server.close();
-          resolve2(true);
+          resolve3(true);
         } else {
           throw new Error("No token received");
         }
@@ -760,7 +1534,7 @@ async function loginWithBrowser() {
         );
         printError("Failed to exchange authorization code.");
         server.close();
-        resolve2(false);
+        resolve3(false);
       }
     });
     server.listen(0, () => {
@@ -770,29 +1544,29 @@ async function loginWithBrowser() {
       printInfo("Opening browser for authorization...");
       openBrowser(authorizeUrl);
       console.log(
-        chalk5.gray("\nIf the browser doesn't open, visit:\n") + chalk5.cyan(authorizeUrl) + "\n"
+        chalk3.gray("\nIf the browser doesn't open, visit:\n") + chalk3.cyan(authorizeUrl) + "\n"
       );
-      console.log(chalk5.gray("Waiting for authorization..."));
+      console.log(chalk3.gray("Waiting for authorization..."));
     });
     setTimeout(() => {
       server.close();
       printError("Authorization timed out.");
-      resolve2(false);
+      resolve3(false);
     }, 5 * 60 * 1e3);
   });
 }
 async function loginWithApiKey() {
-  const rl = readline3.createInterface({
+  const rl = readline2.createInterface({
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve2) => {
-    rl.question(chalk5.cyan("API Key: "), async (apiKey) => {
+  return new Promise((resolve3) => {
+    rl.question(chalk3.cyan("API Key: "), async (apiKey) => {
       rl.close();
       const trimmedKey = apiKey.trim();
       if (!trimmedKey) {
         printError("No API key provided.");
-        resolve2(false);
+        resolve3(false);
         return;
       }
       printInfo("Validating API key...");
@@ -807,63 +1581,63 @@ async function loginWithApiKey() {
           console.log();
           printSuccess("Logged in successfully!");
           if (data.name) {
-            console.log(chalk5.gray(`Welcome, ${data.name}!`));
+            console.log(chalk3.gray(`Welcome, ${data.name}!`));
           }
-          resolve2(true);
+          resolve3(true);
         } else {
           printError("Invalid API key. Please check and try again.");
-          resolve2(false);
+          resolve3(false);
         }
       } catch (error) {
         printError(`Could not validate API key: ${error.message}`);
-        resolve2(false);
+        resolve3(false);
       }
     });
   });
 }
 async function login() {
   console.log();
-  console.log(chalk5.bold("Codea CLI Login"));
+  console.log(chalk3.bold("Codea CLI Login"));
   console.log();
   const success = await loginWithBrowser();
   if (success) return true;
   console.log();
   console.log(
-    chalk5.gray("Alternatively, paste your API key from: ") + chalk5.cyan("https://alia.onl/settings/api")
+    chalk3.gray("Alternatively, paste your API key from: ") + chalk3.cyan("https://alia.onl/settings/api")
   );
   console.log();
   return loginWithApiKey();
 }
 
 // src/commands/sessions.ts
-import chalk6 from "chalk";
-import * as readline4 from "readline";
+import chalk4 from "chalk";
+import * as readline3 from "readline";
 async function listSessions() {
   const sessions = getSessions();
   if (sessions.length === 0) {
-    printInfo("No saved sessions found.");
-    console.log(chalk6.gray("Start a new session with: ") + chalk6.cyan("codea"));
+    console.log(chalk4.blue("\u2139 ") + "No saved sessions found.");
+    console.log(chalk4.gray("Start a new session with: ") + chalk4.cyan("codea"));
     return;
   }
   console.log();
-  console.log(chalk6.bold("Recent Sessions"));
-  console.log(chalk6.gray("\u2500".repeat(60)));
+  console.log(chalk4.bold("Recent Sessions"));
+  console.log(chalk4.gray("\u2500".repeat(60)));
   sessions.slice(0, 10).forEach((session, index) => {
     const date = new Date(session.updatedAt).toLocaleDateString();
     const time = new Date(session.updatedAt).toLocaleTimeString();
     const messageCount = session.messages?.length || 0;
     const title = session.title.slice(0, 40) + (session.title.length > 40 ? "..." : "");
     console.log(
-      chalk6.cyan(`${index + 1}.`) + " " + chalk6.white(title) + " " + chalk6.gray(`(${messageCount} msgs, ${date} ${time})`)
+      chalk4.cyan(`${index + 1}.`) + " " + chalk4.white(title) + " " + chalk4.gray(`(${messageCount} msgs, ${date} ${time})`)
     );
   });
   console.log();
-  console.log(chalk6.gray("Resume a session with: ") + chalk6.cyan("codea resume <number>"));
+  console.log(chalk4.gray("Resume a session with: ") + chalk4.cyan("codea resume <number>"));
 }
 async function resumeSession(sessionId) {
   const sessions = getSessions();
   if (sessions.length === 0) {
-    printInfo("No saved sessions found.");
+    console.log(chalk4.blue("\u2139 ") + "No saved sessions found.");
     return;
   }
   let selectedSession;
@@ -875,34 +1649,34 @@ async function resumeSession(sessionId) {
       selectedSession = getSession(sessionId);
     }
     if (!selectedSession) {
-      printError(`Session not found: ${sessionId}`);
+      console.log(chalk4.red("\u2717 Error: ") + `Session not found: ${sessionId}`);
       return;
     }
   } else {
     console.log();
-    console.log(chalk6.bold("Select a session to resume:"));
+    console.log(chalk4.bold("Select a session to resume:"));
     console.log();
     sessions.slice(0, 10).forEach((session, index) => {
       const date = new Date(session.updatedAt).toLocaleDateString();
       const title = session.title.slice(0, 50) + (session.title.length > 50 ? "..." : "");
-      console.log(chalk6.cyan(`  ${index + 1}.`) + " " + title + " " + chalk6.gray(`(${date})`));
+      console.log(chalk4.cyan(`  ${index + 1}.`) + " " + title + " " + chalk4.gray(`(${date})`));
     });
     console.log();
-    const rl = readline4.createInterface({
+    const rl = readline3.createInterface({
       input: process.stdin,
       output: process.stdout
     });
-    return new Promise((resolve2) => {
-      rl.question(chalk6.cyan("Enter number: "), (answer) => {
+    return new Promise((resolve3) => {
+      rl.question(chalk4.cyan("Enter number: "), (answer) => {
         rl.close();
         const index = parseInt(answer) - 1;
         if (isNaN(index) || index < 0 || index >= sessions.length) {
-          printError("Invalid selection.");
-          resolve2();
+          console.log(chalk4.red("\u2717 Error: ") + "Invalid selection.");
+          resolve3();
           return;
         }
         selectedSession = sessions[index];
-        startRestoredSession(selectedSession).then(resolve2);
+        startRestoredSession(selectedSession).then(resolve3);
       });
     });
   }
@@ -911,41 +1685,41 @@ async function resumeSession(sessionId) {
   }
 }
 async function startRestoredSession(session) {
-  printInfo(`Resuming: ${session.title}`);
+  console.log(chalk4.blue("\u2139 ") + `Resuming: ${session.title}`);
   console.log();
   for (const msg of session.messages || []) {
     if (msg.role === "user") {
-      console.log(chalk6.cyan("\u276F ") + msg.content);
+      console.log(chalk4.cyan("\u276F ") + msg.content);
     } else if (msg.role === "assistant") {
-      console.log(chalk6.magenta("\u2726 ") + msg.content.slice(0, 200) + (msg.content.length > 200 ? "..." : ""));
+      console.log(chalk4.magenta("\u2726 ") + msg.content.slice(0, 200) + (msg.content.length > 200 ? "..." : ""));
     }
     console.log();
   }
-  console.log(chalk6.gray("\u2500".repeat(60)));
-  console.log(chalk6.gray("Session restored. Continue the conversation below."));
+  console.log(chalk4.gray("\u2500".repeat(60)));
+  console.log(chalk4.gray("Session restored. Continue the conversation below."));
   console.log();
   const model = config.get("defaultModel") || "alia-v1-codea";
   await startRepl({ model, context: true });
 }
 
 // src/index.ts
-import chalk7 from "chalk";
-var VERSION = "1.0.0";
+import chalk5 from "chalk";
+var VERSION = "2.0.0";
 var program = new Command();
 var banner = `
-${chalk7.cyan("   ____          _            ")}
-${chalk7.cyan("  / ___|___   __| | ___  __ _ ")}
-${chalk7.cyan(" | |   / _ \\ / _` |/ _ \\/ _` |")}
-${chalk7.cyan(" | |__| (_) | (_| |  __/ (_| |")}
-${chalk7.cyan("  \\____\\___/ \\__,_|\\___|\\__,_|")}
-${chalk7.gray("  AI Coding Assistant by Alia")}
+${chalk5.cyan("   ____          _            ")}
+${chalk5.cyan("  / ___|___   __| | ___  __ _ ")}
+${chalk5.cyan(" | |   / _ \\ / _` |/ _ \\/ _` |")}
+${chalk5.cyan(" | |__| (_) | (_| |  __/ (_| |")}
+${chalk5.cyan("  \\____\\___/ \\__,_|\\___|\\__,_|")}
+${chalk5.gray("  AI Coding Assistant by Alia")}
 `;
 program.name("codea").description("Codea CLI - AI coding assistant for your terminal").version(VERSION).hook("preAction", async () => {
   const command = program.args[0];
   if (command === "login" || command === "help") return;
   if (!config.get("apiKey")) {
     console.log(banner);
-    console.log(chalk7.yellow("No API key found. Let's get you logged in.\n"));
+    console.log(chalk5.yellow("No API key found. Let's get you logged in.\n"));
     const success = await login();
     if (!success) {
       process.exit(1);
@@ -953,13 +1727,15 @@ program.name("codea").description("Codea CLI - AI coding assistant for your term
     console.log();
   }
 });
-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("--no-context", "Disable automatic codebase context").action(async (options) => {
-  console.log(banner);
+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) => {
   await startRepl(options);
 });
-program.command("run <prompt>").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("--no-context", "Disable automatic codebase context").action(async (prompt, options) => {
+program.command("run <prompt>").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 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);
 });
+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 });
+});
 program.command("login").description("Configure your Alia API key").action(async () => {
   await login();
 });