@alia-codea/cli 1.0.0

package/dist/index.js

@@ -0,0 +1,878 @@
+#!/usr/bin/env node
+import {
+  config,
+  createSession,
+  getSession,
+  getSessions,
+  saveSession,
+  streamChat
+} from "./chunk-SVPL4GNV.js";
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/repl.ts
+import * as readline2 from "readline";
+import chalk3 from "chalk";
+
+// src/tools/executor.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+import chalk from "chalk";
+var execAsync = promisify(exec);
+async function executeTool(name, args) {
+  try {
+    switch (name) {
+      case "read_file":
+        return await readFile2(args.path);
+      case "write_file":
+        return await writeFile2(args.path, args.content);
+      case "edit_file":
+        return await editFile(args.path, args.old_text, args.new_text);
+      case "list_files":
+        return await listFiles(args.path, args.recursive);
+      case "search_files":
+        return await searchFiles(args.pattern, args.path, args.file_pattern);
+      case "run_command":
+        return await runCommand(args.command, args.cwd);
+      default:
+        return { success: false, result: `Unknown tool: ${name}` };
+    }
+  } catch (error) {
+    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");
+  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");
+  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 newContent = content.replace(oldText, newText);
+  await fs.writeFile(absolutePath, newContent, "utf-8");
+  return { success: true, result: `File edited: ${filePath}` };
+}
+async function listFiles(dirPath = ".", recursive = false) {
+  const absolutePath = path.resolve(process.cwd(), dirPath);
+  if (recursive) {
+    const files = [];
+    async function walk(dir) {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        const relativePath = path.relative(absolutePath, fullPath);
+        if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") {
+          continue;
+        }
+        if (entry.isDirectory()) {
+          files.push(relativePath + "/");
+          await walk(fullPath);
+        } else {
+          files.push(relativePath);
+        }
+      }
+    }
+    await walk(absolutePath);
+    return { success: true, result: files.join("\n") };
+  } else {
+    const entries = await fs.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);
+  const regex = new RegExp(pattern, "gi");
+  const results = [];
+  async function searchDir(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        await searchDir(fullPath);
+      } else {
+        if (filePattern) {
+          const ext = path.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 lines = content.split("\n");
+          lines.forEach((line, index) => {
+            if (regex.test(line)) {
+              const relativePath = path.relative(absolutePath, fullPath);
+              results.push(`${relativePath}:${index + 1}: ${line.trim()}`);
+            }
+          });
+        } catch {
+        }
+      }
+    }
+  }
+  await searchDir(absolutePath);
+  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` : "") };
+}
+async function runCommand(command, cwd) {
+  const workingDir = cwd ? path.resolve(process.cwd(), cwd) : process.cwd();
+  try {
+    const { stdout, stderr } = await execAsync(command, {
+      cwd: workingDir,
+      maxBuffer: 1024 * 1024,
+      timeout: 6e4
+    });
+    const output = stdout + (stderr ? `
+Stderr:
+${stderr}` : "");
+    return { success: true, result: output || "Command completed successfully." };
+  } catch (error) {
+    return {
+      success: false,
+      result: error.stdout + (error.stderr ? `
+Stderr:
+${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 "));
+}
+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);
+  }
+  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/context.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
+function buildSystemMessage(model, codebaseContext) {
+  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
+- Be concise and direct. Avoid unnecessary explanations unless asked.
+- Write clean, idiomatic, well-structured code following best practices.
+- Consider edge cases, error handling, and security implications.
+- Match the existing code style and conventions of the project.
+
+## Tools Available
+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.
+- **list_files**: Explore directory structure. Use to understand project layout.
+- **search_files**: Find text/patterns across the codebase. Great for finding usages, definitions, etc.
+- **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.
+
+## 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 (codebaseContext) {
+    systemMessage += `
+
+## Current Codebase Context
+${codebaseContext}`;
+  }
+  return systemMessage;
+}
+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 pkg = JSON.parse(pkgContent);
+    contextParts.push(`Project: ${pkg.name || "Unknown"} (${pkg.description || "No description"})`);
+    if (pkg.dependencies) {
+      const deps = Object.keys(pkg.dependencies).slice(0, 10);
+      contextParts.push(`Dependencies: ${deps.join(", ")}${Object.keys(pkg.dependencies).length > 10 ? "..." : ""}`);
+    }
+  } catch {
+  }
+  try {
+    const { stdout: branch } = await execAsync2("git branch --show-current", { cwd });
+    contextParts.push(`Git branch: ${branch.trim()}`);
+    const { stdout: status } = await execAsync2("git status --porcelain", { cwd });
+    const changedFiles = status.trim().split("\n").filter(Boolean).length;
+    if (changedFiles > 0) {
+      contextParts.push(`Uncommitted changes: ${changedFiles} files`);
+    }
+  } catch {
+  }
+  try {
+    const files = await getRelevantFiles(cwd);
+    if (files.length > 0) {
+      contextParts.push(`
+Key files:
+${files.map((f) => `- ${f}`).join("\n")}`);
+    }
+  } catch {
+  }
+  return contextParts.join("\n");
+}
+async function getRelevantFiles(dir, maxFiles = 20) {
+  const relevantFiles = [];
+  const relevantExtensions = [".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".java", ".md"];
+  const ignoreDirs = ["node_modules", ".git", "dist", "build", "__pycache__", ".next", "coverage"];
+  async function walk(currentDir, depth = 0) {
+    if (depth > 3 || relevantFiles.length >= maxFiles) return;
+    try {
+      const entries = await fs2.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);
+        if (entry.isDirectory()) {
+          await walk(fullPath, depth + 1);
+        } else {
+          const ext = path2.extname(entry.name);
+          if (relevantExtensions.includes(ext) || entry.name === "README.md" || entry.name === "package.json") {
+            relevantFiles.push(relativePath);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  await walk(dir);
+  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();
+}
+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);
+        }
+      });
+    } 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
+        });
+      }
+      continue;
+    } else {
+      if (fullContent) {
+        messages.push({ role: "assistant", content: fullContent });
+        console.log();
+      }
+      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}`));
+      } 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}`));
+            }
+          } else {
+            console.log(chalk3.gray("Available: codea, codea-pro, codea-thinking"));
+          }
+        } catch {
+          console.log(chalk3.gray("Available: codea, codea-pro, codea-thinking"));
+        }
+      }
+      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);
+  }
+}
+function getModelDisplayName(model) {
+  const names = {
+    "alia-v1-codea": "codea",
+    "alia-v1-pro": "codea-pro",
+    "alia-v1-thinking": "codea-thinking"
+  };
+  return names[model] || model;
+}
+
+// src/commands/run.ts
+import chalk4 from "chalk";
+async function runPrompt(prompt, options) {
+  const messages = [];
+  let codebaseContext = "";
+  if (options.context !== false) {
+    codebaseContext = await getCodebaseContext();
+  }
+  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."
+            });
+            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();
+      }
+      break;
+    }
+  }
+}
+async function askApproval() {
+  const readline5 = await import("readline");
+  const rl = readline5.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2) => {
+    rl.question(chalk4.cyan("Allow? [y/N] "), (answer) => {
+      rl.close();
+      resolve2(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+function formatToolArgs2(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);
+  }
+}
+
+// src/commands/auth.ts
+import * as readline3 from "readline";
+import chalk5 from "chalk";
+async function login() {
+  console.log();
+  console.log(chalk5.bold("Codea CLI Login"));
+  console.log(chalk5.gray("Enter your Alia API key to get started."));
+  console.log(chalk5.gray("Get your API key at: ") + chalk5.cyan("https://alia.onl/settings/api"));
+  console.log();
+  const rl = readline3.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2) => {
+    rl.question(chalk5.cyan("API Key: "), async (apiKey) => {
+      rl.close();
+      const trimmedKey = apiKey.trim();
+      if (!trimmedKey) {
+        printError("No API key provided.");
+        resolve2();
+        return;
+      }
+      printInfo("Validating API key...");
+      try {
+        const baseUrl = config.get("apiBaseUrl") || "https://api.alia.onl";
+        const response = await fetch(`${baseUrl}/codea/me`, {
+          headers: {
+            "Authorization": `Bearer ${trimmedKey}`
+          }
+        });
+        if (response.ok) {
+          const data = await response.json();
+          config.set("apiKey", trimmedKey);
+          console.log();
+          printSuccess(`Logged in successfully!`);
+          if (data.name) {
+            console.log(chalk5.gray(`Welcome, ${data.name}!`));
+          }
+          console.log();
+          console.log(chalk5.gray("Run ") + chalk5.cyan("codea") + chalk5.gray(" to start coding."));
+        } else {
+          printError("Invalid API key. Please check and try again.");
+        }
+      } catch (error) {
+        printError(`Could not validate API key: ${error.message}`);
+      }
+      resolve2();
+    });
+  });
+}
+
+// src/commands/sessions.ts
+import chalk6 from "chalk";
+import * as readline4 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"));
+    return;
+  }
+  console.log();
+  console.log(chalk6.bold("Recent Sessions"));
+  console.log(chalk6.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})`)
+    );
+  });
+  console.log();
+  console.log(chalk6.gray("Resume a session with: ") + chalk6.cyan("codea resume <number>"));
+}
+async function resumeSession(sessionId) {
+  const sessions = getSessions();
+  if (sessions.length === 0) {
+    printInfo("No saved sessions found.");
+    return;
+  }
+  let selectedSession;
+  if (sessionId) {
+    const index = parseInt(sessionId) - 1;
+    if (!isNaN(index) && index >= 0 && index < sessions.length) {
+      selectedSession = sessions[index];
+    } else {
+      selectedSession = getSession(sessionId);
+    }
+    if (!selectedSession) {
+      printError(`Session not found: ${sessionId}`);
+      return;
+    }
+  } else {
+    console.log();
+    console.log(chalk6.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();
+    const rl = readline4.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    return new Promise((resolve2) => {
+      rl.question(chalk6.cyan("Enter number: "), (answer) => {
+        rl.close();
+        const index = parseInt(answer) - 1;
+        if (isNaN(index) || index < 0 || index >= sessions.length) {
+          printError("Invalid selection.");
+          resolve2();
+          return;
+        }
+        selectedSession = sessions[index];
+        startRestoredSession(selectedSession).then(resolve2);
+      });
+    });
+  }
+  if (selectedSession) {
+    await startRestoredSession(selectedSession);
+  }
+}
+async function startRestoredSession(session) {
+  printInfo(`Resuming: ${session.title}`);
+  console.log();
+  for (const msg of session.messages || []) {
+    if (msg.role === "user") {
+      console.log(chalk6.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();
+  }
+  console.log(chalk6.gray("\u2500".repeat(60)));
+  console.log(chalk6.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";
+var program = new Command();
+var banner = `
+${chalk7.cyan("   ____          _            ")}
+${chalk7.cyan("  / ___|___   __| | ___  __ _ ")}
+${chalk7.cyan(" | |   / _ \\ / _` |/ _ \\/ _` |")}
+${chalk7.cyan(" | |__| (_) | (_| |  __/ (_| |")}
+${chalk7.cyan("  \\____\\___/ \\__,_|\\___|\\__,_|")}
+${chalk7.gray("  AI Coding Assistant by Alia")}
+`;
+program.name("codea").description("Codea CLI - AI coding assistant for your terminal").version(VERSION).hook("preAction", () => {
+  const command = program.args[0];
+  if (command !== "login" && command !== "help" && !config.get("apiKey")) {
+    console.log(chalk7.yellow("\nNo API key found. Please run `codea login` first.\n"));
+    process.exit(1);
+  }
+});
+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);
+  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) => {
+  await runPrompt(prompt, options);
+});
+program.command("login").description("Configure your Alia API key").action(async () => {
+  await login();
+});
+program.command("sessions").alias("s").description("List recent chat sessions").action(async () => {
+  await listSessions();
+});
+program.command("resume [sessionId]").description("Resume a previous chat session").action(async (sessionId) => {
+  console.log(banner);
+  await resumeSession(sessionId);
+});
+program.parse();