@cryer/star-cli 0.1.0

package/dist/main.js

@@ -0,0 +1,2232 @@
+#!/usr/bin/env node
+
+// src/main.tsx
+import { Command } from "commander";
+
+// src/agent/loop.ts
+import { tool as aiTool } from "ai";
+
+// src/context/compaction.ts
+import { generateText } from "ai";
+
+// src/context/tokens.ts
+var CHARS_PER_TOKEN = 4;
+var MESSAGE_OVERHEAD = 4;
+function contentCharLength(message) {
+  if (message.role === "tool") {
+    let chars2 = 0;
+    for (const part of message.content) {
+      chars2 += JSON.stringify(part.result ?? null).length;
+    }
+    return chars2;
+  }
+  if (typeof message.content === "string") {
+    return message.content.length;
+  }
+  let chars = 0;
+  for (const part of message.content) {
+    if (part.type === "text" || part.type === "reasoning") {
+      chars += part.text.length;
+    } else if (part.type === "tool-call") {
+      chars += part.toolName.length + JSON.stringify(part.args ?? null).length;
+    }
+  }
+  return chars;
+}
+function estimateMessageTokens(message) {
+  return Math.ceil(contentCharLength(message) / CHARS_PER_TOKEN) + MESSAGE_OVERHEAD;
+}
+function estimateTokens(messages) {
+  return messages.reduce((total, message) => total + estimateMessageTokens(message), 0);
+}
+
+// src/context/compaction.ts
+var MIN_KEPT_MESSAGES = 4;
+function placeholderMessage(droppedCount) {
+  return {
+    role: "user",
+    content: `[context compacted: ${droppedCount} earlier messages dropped]`
+  };
+}
+var SUMMARY_SYSTEM_PROMPT = [
+  "You are summarizing an AI coding agent's conversation for context compaction.",
+  "Write a concise summary that preserves:",
+  "- the user's goals and requests",
+  "- decisions made and their rationale",
+  "- files and code touched (paths, key changes)",
+  "- tool results that matter (errors, key outputs)",
+  "- outstanding TODOs and next steps",
+  "Output only the summary, no preamble."
+].join("\n");
+function serializeMessage(message) {
+  if (typeof message.content === "string") {
+    return `${message.role}: ${message.content}`;
+  }
+  const parts = message.content.map((part) => {
+    if (part.type === "text") return part.text;
+    if (part.type === "tool-call")
+      return `[tool-call ${part.toolName}] ${JSON.stringify(part.args)}`;
+    if (part.type === "tool-result")
+      return `[tool-result ${part.toolName}] ${JSON.stringify(part.result)}`;
+    return `[${part.type}]`;
+  });
+  return `${message.role}: ${parts.join("\n")}`;
+}
+async function summarizeMessages(messages, model) {
+  const transcript = messages.map(serializeMessage).join("\n");
+  const { text } = await generateText({
+    model,
+    system: SUMMARY_SYSTEM_PROMPT,
+    prompt: `Summarize this conversation so far:
+
+${transcript}`
+  });
+  return text.trim();
+}
+function compactMessages(messages, maxTokens) {
+  if (estimateTokens(messages) <= maxTokens) {
+    return { messages, compacted: false, droppedCount: 0 };
+  }
+  const first = messages[0];
+  const hasSystem = first?.role === "system";
+  const head = hasSystem && first ? [first] : [];
+  const rest = hasSystem ? messages.slice(1) : messages.slice();
+  const turns = [];
+  for (const message of rest) {
+    const current = turns[turns.length - 1];
+    if (message.role === "user" || !current) {
+      turns.push([message]);
+    } else {
+      current.push(message);
+    }
+  }
+  let droppedCount = 0;
+  let turnIndex = 0;
+  while (turnIndex < turns.length) {
+    const turn = turns[turnIndex];
+    if (rest.length - droppedCount - turn.length < MIN_KEPT_MESSAGES) {
+      break;
+    }
+    droppedCount += turn.length;
+    turnIndex += 1;
+    const candidate = [...head, placeholderMessage(droppedCount), ...rest.slice(droppedCount)];
+    if (estimateTokens(candidate) <= maxTokens) {
+      break;
+    }
+  }
+  if (droppedCount === 0) {
+    return { messages, compacted: false, droppedCount: 0 };
+  }
+  return {
+    messages: [...head, placeholderMessage(droppedCount), ...rest.slice(droppedCount)],
+    compacted: true,
+    droppedCount
+  };
+}
+
+// src/permissions/gate.ts
+import path from "path";
+var FILE_TOOLS = /* @__PURE__ */ new Set(["write_file", "edit_file", "read_file"]);
+var DANGEROUS_COMMAND_PATTERNS = [
+  /rm\s+-rf\s+\/(?:\s|$|;|&)/i,
+  /rm\s+-rf\s+~(?:\s|\/|$|;|&)/i,
+  /:\(\)\s*\{\s*:\|:&\s*\}\s*;:/,
+  /\bmkfs\b/i,
+  /dd\s+[^|;]*\bif=/i,
+  />\s*\/dev\/sd[a-z]/i,
+  /\bshutdown\b/i,
+  /\breboot\b/i,
+  /\bpoweroff\b/i
+];
+function getStringArg(args, key) {
+  if (typeof args === "object" && args !== null) {
+    const value = args[key];
+    if (typeof value === "string") {
+      return value;
+    }
+  }
+  return void 0;
+}
+function normalizeAbsolute(p, cwd) {
+  const abs = path.isAbsolute(p) ? path.normalize(p) : path.resolve(cwd, p);
+  return abs.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+}
+function isOutsideCwd(p, cwd) {
+  const abs = normalizeAbsolute(p, cwd);
+  const base = normalizeAbsolute(cwd, cwd);
+  return abs !== base && !abs.startsWith(`${base}/`);
+}
+function isSensitivePath(p) {
+  const base = p.replace(/\\/g, "/").split("/").pop()?.toLowerCase() ?? "";
+  if (base === ".env.example" || base === ".env.sample" || base === ".env.template") {
+    return false;
+  }
+  return base === ".env" || base.startsWith(".env.") || base === "id_rsa" || base.endsWith(".pem");
+}
+function checkPermission(mode, req, ctx) {
+  const command = getStringArg(req.args, "command");
+  const filePath = getStringArg(req.args, "path");
+  if (req.toolName === "bash" && command !== void 0 && DANGEROUS_COMMAND_PATTERNS.some((pattern) => pattern.test(command))) {
+    return "deny";
+  }
+  if (FILE_TOOLS.has(req.toolName) && filePath !== void 0) {
+    if ((req.toolName === "write_file" || req.toolName === "edit_file") && isSensitivePath(filePath)) {
+      return "deny";
+    }
+    if (isOutsideCwd(filePath, ctx.cwd)) {
+      if (mode === "ask" && req.level === "read") {
+        return "ask";
+      }
+      return "deny";
+    }
+  }
+  if (mode === "auto") {
+    return "allow";
+  }
+  if (mode === "readonly") {
+    return req.level === "read" ? "allow" : "deny";
+  }
+  return req.level === "read" ? "allow" : "ask";
+}
+
+// src/agent/loop.ts
+var AgentLoop = class {
+  messages = [];
+  opts;
+  confirmHandler;
+  constructor(opts) {
+    this.opts = opts;
+    if (opts.system) {
+      this.messages.push({ role: "system", content: opts.system });
+    }
+  }
+  getMessages() {
+    return this.messages;
+  }
+  async loadMessages(messages) {
+    this.messages = messages;
+  }
+  async persist(message) {
+    await this.opts.sessionStore?.append(message);
+  }
+  async *stream(input, signal) {
+    const userMessage = { role: "user", content: input };
+    this.messages.push(userMessage);
+    await this.persist(userMessage);
+    const { config, registry, cwd } = this.opts;
+    const aiTools = this.buildAiTools();
+    for (let step = 0; step < config.maxSteps; step++) {
+      const compacted = compactMessages([...this.messages], config.contextMaxTokens);
+      if (compacted.compacted) {
+        this.messages = await this.applyCompactionSummary(compacted);
+      }
+      let text = "";
+      const toolCalls = [];
+      let failed = false;
+      try {
+        for await (const event of this.streamOnce(aiTools, signal)) {
+          if (event.type === "text-delta") {
+            text += event.text;
+            yield event;
+          } else if (event.type === "tool-call") {
+            toolCalls.push({ id: event.id, name: event.name, args: event.args });
+            yield event;
+          } else if (event.type === "error") {
+            failed = true;
+            yield event;
+          } else {
+            yield event;
+          }
+        }
+      } catch (error) {
+        yield { type: "error", error: error instanceof Error ? error : new Error(String(error)) };
+        return;
+      }
+      if (failed) return;
+      const assistantMessage = {
+        role: "assistant",
+        content: [
+          ...text ? [{ type: "text", text }] : [],
+          ...toolCalls.map((call) => ({
+            type: "tool-call",
+            toolCallId: call.id,
+            toolName: call.name,
+            args: call.args
+          }))
+        ]
+      };
+      this.messages.push(assistantMessage);
+      await this.persist(assistantMessage);
+      if (toolCalls.length === 0) return;
+      for (const call of toolCalls) {
+        const result = await this.executeTool(call, signal);
+        const toolMessage = {
+          role: "tool",
+          content: [
+            {
+              type: "tool-result",
+              toolCallId: call.id,
+              toolName: call.name,
+              result: result.content
+            }
+          ]
+        };
+        this.messages.push(toolMessage);
+        await this.persist(toolMessage);
+        yield {
+          type: "tool-result",
+          id: call.id,
+          name: call.name,
+          content: result.content,
+          isError: result.isError
+        };
+      }
+    }
+    yield {
+      type: "error",
+      error: new Error(`Max steps (${config.maxSteps}) reached, stopping.`)
+    };
+  }
+  async applyCompactionSummary(compacted) {
+    const { config, model } = this.opts;
+    if (config.contextCompaction !== "summary" || !model) {
+      return compacted.messages;
+    }
+    const headCount = compacted.messages[0]?.role === "system" ? 1 : 0;
+    const dropped = this.messages.slice(headCount, headCount + compacted.droppedCount);
+    try {
+      const summary = await summarizeMessages(dropped, model);
+      const messages = compacted.messages.slice();
+      messages[headCount] = {
+        role: "user",
+        content: `[earlier conversation summarized]
+${summary}`
+      };
+      return messages;
+    } catch {
+      return compacted.messages;
+    }
+  }
+  async *streamOnce(aiTools, signal) {
+    const { streamChat } = await import("./stream-FJQZGETE.js");
+    yield* streamChat({
+      model: this.opts.model,
+      messages: this.messages,
+      tools: aiTools,
+      abortSignal: signal
+    });
+  }
+  buildAiTools() {
+    const tools = {};
+    for (const t of this.opts.registry.list()) {
+      tools[t.name] = aiTool({
+        description: t.description,
+        parameters: t.parameters
+      });
+    }
+    return tools;
+  }
+  async executeTool(call, signal) {
+    const { registry, config, cwd } = this.opts;
+    const tool = registry.get(call.name);
+    if (!tool) {
+      return { content: `Unknown tool: ${call.name}`, isError: true };
+    }
+    const decision = checkPermission(
+      config.permissionMode,
+      { toolName: call.name, args: call.args, level: tool.permission },
+      { cwd }
+    );
+    if (decision === "deny") {
+      return { content: `Permission denied for tool "${call.name}".`, isError: true };
+    }
+    if (decision === "ask") {
+      const approved = this.confirmHandler ? await this.confirmHandler({
+        toolName: call.name,
+        args: call.args,
+        level: tool.permission
+      }) : false;
+      if (!approved) {
+        return { content: `User rejected tool "${call.name}".`, isError: true };
+      }
+    }
+    const parsed = tool.parameters.safeParse(call.args);
+    if (!parsed.success) {
+      return { content: `Invalid arguments: ${parsed.error.message}`, isError: true };
+    }
+    try {
+      return await tool.execute(parsed.data, { cwd, abortSignal: signal });
+    } catch (error) {
+      if (signal.aborted) {
+        return { content: "Tool execution aborted.", isError: true };
+      }
+      return {
+        content: `Tool error: ${error instanceof Error ? error.message : String(error)}`,
+        isError: true
+      };
+    }
+  }
+};
+
+// src/cli/repl.tsx
+import { Box as Box7, render, useApp, useInput as useInput3 } from "ink";
+import { useCallback, useEffect, useMemo, useRef as useRef2, useState as useState2 } from "react";
+
+// src/llm/provider.ts
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+
+// src/llm/registry.ts
+function listModels(config) {
+  return config.models;
+}
+function resolveModelConfig(config, modelName) {
+  const name = modelName ?? config.defaultModel;
+  const model = config.models.find((m) => m.name === name);
+  if (!model) {
+    const available = config.models.map((m) => m.name).join(", ") || "(none)";
+    throw new Error(`Model "${name}" not found. Available models: ${available}`);
+  }
+  return model;
+}
+
+// src/llm/provider.ts
+function resolveApiKey(provider) {
+  const fromEnv = provider.apiKeyEnv ? process.env[provider.apiKeyEnv] : void 0;
+  const apiKey = fromEnv ?? provider.apiKey;
+  if (!apiKey) {
+    const hint = provider.apiKeyEnv ? `set ${provider.apiKeyEnv} or configure apiKey` : "configure apiKey";
+    throw new Error(`Missing API key for provider "${provider.name}": ${hint}`);
+  }
+  return apiKey;
+}
+function createModel(config, modelName) {
+  const modelConfig = resolveModelConfig(config, modelName);
+  const provider = config.providers.find((p) => p.name === modelConfig.provider);
+  if (!provider) {
+    const available = config.providers.map((p) => p.name).join(", ") || "(none)";
+    throw new Error(
+      `Provider "${modelConfig.provider}" for model "${modelConfig.name}" not found. Available providers: ${available}`
+    );
+  }
+  const apiKey = resolveApiKey(provider);
+  switch (provider.protocol) {
+    case "anthropic":
+      return createAnthropic({
+        baseURL: provider.baseURL,
+        apiKey,
+        headers: provider.headers
+      })(modelConfig.model);
+    case "openai-compatible":
+      return createOpenAICompatible({
+        name: provider.name,
+        baseURL: provider.baseURL,
+        apiKey,
+        headers: provider.headers
+      })(modelConfig.model);
+    case "openai-responses":
+      return createOpenAI({
+        baseURL: provider.baseURL,
+        apiKey,
+        headers: provider.headers
+      }).responses(modelConfig.model);
+  }
+}
+
+// src/session/store.ts
+import fs from "fs/promises";
+import path3 from "path";
+
+// src/config/paths.ts
+import os from "os";
+import path2 from "path";
+function starHome() {
+  return process.env.STAR_HOME ?? path2.join(os.homedir(), ".star-cli");
+}
+function globalConfigPath() {
+  return path2.join(starHome(), "config.toml");
+}
+function sessionsDir() {
+  return path2.join(starHome(), "sessions");
+}
+function projectConfigPath(cwd) {
+  return path2.join(cwd, ".star", "config.toml");
+}
+
+// src/session/store.ts
+function generateId(now) {
+  const pad = (n) => String(n).padStart(2, "0");
+  const stamp = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+  const suffix = Math.random().toString(16).slice(2, 8).padEnd(6, "0");
+  return `${stamp}-${suffix}`;
+}
+function messageText(message) {
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter((part) => part.type === "text").map((part) => "text" in part ? part.text : "").join(" ");
+  }
+  return "";
+}
+var SessionStore = class _SessionStore {
+  id;
+  dir;
+  pendingMeta = null;
+  initialized = false;
+  constructor(id) {
+    this.id = id;
+    this.dir = path3.join(sessionsDir(), id);
+  }
+  metaPath() {
+    return path3.join(this.dir, "meta.json");
+  }
+  messagesPath() {
+    return path3.join(this.dir, "messages.jsonl");
+  }
+  static async create(cwd, model) {
+    const store = new _SessionStore(generateId(/* @__PURE__ */ new Date()));
+    store.pendingMeta = { cwd, model, createdAt: Date.now() };
+    return store;
+  }
+  static async open(id) {
+    const store = new _SessionStore(id);
+    try {
+      const raw = await fs.readFile(store.metaPath(), "utf8");
+      const meta = JSON.parse(raw);
+      if (meta.id !== id) return null;
+      store.initialized = true;
+      return store;
+    } catch {
+      return null;
+    }
+  }
+  static async list(cwd) {
+    let entries;
+    try {
+      entries = await fs.readdir(sessionsDir());
+    } catch {
+      return [];
+    }
+    const metas = [];
+    for (const entry of entries) {
+      try {
+        const raw = await fs.readFile(path3.join(sessionsDir(), entry, "meta.json"), "utf8");
+        const meta = JSON.parse(raw);
+        if (meta.id === entry && (cwd === void 0 || meta.cwd === cwd)) metas.push(meta);
+      } catch {
+      }
+    }
+    return metas.sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+  async ensureInitialized() {
+    if (this.initialized) return;
+    const pending = this.pendingMeta;
+    if (!pending) {
+      this.initialized = true;
+      return;
+    }
+    await fs.mkdir(this.dir, { recursive: true });
+    const meta = {
+      id: this.id,
+      title: "",
+      model: pending.model,
+      cwd: pending.cwd,
+      createdAt: pending.createdAt,
+      updatedAt: pending.createdAt
+    };
+    await fs.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
+    this.initialized = true;
+  }
+  async append(message) {
+    await this.ensureInitialized();
+    await fs.appendFile(this.messagesPath(), `${JSON.stringify(message)}
+`);
+    const meta = await this.meta();
+    meta.updatedAt = Date.now();
+    if (!meta.title && message.role === "user") {
+      meta.title = messageText(message).slice(0, 60);
+    }
+    await fs.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
+  }
+  async messages() {
+    let raw;
+    try {
+      raw = await fs.readFile(this.messagesPath(), "utf8");
+    } catch {
+      return [];
+    }
+    const messages = [];
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        messages.push(JSON.parse(trimmed));
+      } catch {
+      }
+    }
+    return messages;
+  }
+  async meta() {
+    await this.ensureInitialized();
+    const raw = await fs.readFile(this.metaPath(), "utf8");
+    return JSON.parse(raw);
+  }
+  async setTitle(title) {
+    await this.ensureInitialized();
+    const meta = await this.meta();
+    meta.title = title;
+    meta.updatedAt = Date.now();
+    await fs.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
+  }
+  async addUsage(delta) {
+    await this.ensureInitialized();
+    const meta = await this.meta();
+    const usage = meta.usage ?? {
+      requests: 0,
+      promptTokens: 0,
+      completionTokens: 0,
+      totalTokens: 0
+    };
+    usage.requests += 1;
+    usage.promptTokens += delta.promptTokens;
+    usage.completionTokens += delta.completionTokens;
+    usage.totalTokens += delta.totalTokens;
+    meta.usage = usage;
+    await fs.writeFile(this.metaPath(), JSON.stringify(meta, null, 2));
+  }
+};
+
+// src/session/resume.ts
+async function resumeSession(id) {
+  const store = await SessionStore.open(id);
+  if (!store) return null;
+  const [meta, messages] = await Promise.all([store.meta(), store.messages()]);
+  return { meta, messages };
+}
+function relativeTime(timestamp) {
+  const diff = Date.now() - timestamp;
+  const minutes = Math.floor(diff / 6e4);
+  if (minutes < 1) return "\u521A\u521A";
+  if (minutes < 60) return `${minutes} \u5206\u949F\u524D`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours} \u5C0F\u65F6\u524D`;
+  const days = Math.floor(hours / 24);
+  if (days < 30) return `${days} \u5929\u524D`;
+  const months = Math.floor(days / 30);
+  if (months < 12) return `${months} \u4E2A\u6708\u524D`;
+  return `${Math.floor(months / 12)} \u5E74\u524D`;
+}
+function formatSessionList(metas) {
+  return metas.map((meta) => {
+    const title = meta.title || "(\u65E0\u6807\u9898)";
+    return `${meta.id}  ${title}  (\u66F4\u65B0\u4E8E ${relativeTime(meta.updatedAt)})`;
+  }).join("\n");
+}
+
+// src/tools/bash.ts
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import path4 from "path";
+import { z } from "zod";
+var MAX_OUTPUT = 3e4;
+var DEFAULT_TIMEOUT = 120;
+var MAX_TIMEOUT = 600;
+function findOnPath(exe, exclude) {
+  for (const dir of (process.env.PATH ?? "").split(path4.delimiter)) {
+    if (!dir || exclude?.(dir)) {
+      continue;
+    }
+    const full = path4.join(dir, exe);
+    if (existsSync(full)) {
+      return full;
+    }
+  }
+  return null;
+}
+function resolveShell() {
+  if (process.platform !== "win32") {
+    return { shell: "sh", wrap: (c) => ["-c", c], label: "sh" };
+  }
+  const isWslStub = (dir) => /\\(system32|windowsapps)\\?$/i.test(dir.trim());
+  const fromPath = findOnPath("bash.exe", isWslStub);
+  if (fromPath) {
+    return { shell: fromPath, wrap: (c) => ["-c", c], label: "bash" };
+  }
+  const gitExe = findOnPath("git.exe");
+  if (gitExe) {
+    const sibling = path4.join(path4.dirname(path4.dirname(gitExe)), "bin", "bash.exe");
+    if (existsSync(sibling)) {
+      return { shell: sibling, wrap: (c) => ["-c", c], label: "bash" };
+    }
+  }
+  for (const candidate of [
+    "C:\\Program Files\\Git\\bin\\bash.exe",
+    "C:\\Program Files (x86)\\Git\\bin\\bash.exe",
+    "D:\\Git\\bin\\bash.exe"
+  ]) {
+    if (existsSync(candidate)) {
+      return { shell: candidate, wrap: (c) => ["-c", c], label: "bash" };
+    }
+  }
+  const comspec = process.env.ComSpec ?? "cmd.exe";
+  return { shell: comspec, wrap: (c) => ["/d", "/s", "/c", c], label: "cmd" };
+}
+var schema = z.object({
+  command: z.string().describe("Shell command to execute"),
+  timeout: z.number().positive().max(MAX_TIMEOUT).optional().describe("Timeout in seconds (default 120, max 600)"),
+  description: z.string().optional().describe("Short description of what the command does")
+});
+function killTree(child) {
+  if (process.platform === "win32" && child.pid) {
+    spawn("taskkill", ["/pid", String(child.pid), "/t", "/f"], {
+      windowsHide: true,
+      stdio: "ignore"
+    }).unref();
+    return;
+  }
+  child.kill("SIGKILL");
+}
+function truncateMiddle(s) {
+  if (s.length <= MAX_OUTPUT) {
+    return s;
+  }
+  const half = Math.floor(MAX_OUTPUT / 2);
+  const head = s.slice(0, half);
+  const tail = s.slice(-half);
+  return `${head}
+... [${s.length - MAX_OUTPUT} characters truncated] ...
+${tail}`;
+}
+var bashTool = {
+  name: "bash",
+  description: "Execute a shell command (Git Bash on Windows when available, otherwise cmd; sh elsewhere). Stdout and stderr are merged. Output is truncated to 30000 characters.",
+  permission: "exec",
+  parameters: schema,
+  execute(args, ctx) {
+    const timeoutSeconds = Math.min(args.timeout ?? DEFAULT_TIMEOUT, MAX_TIMEOUT);
+    const spec = resolveShell();
+    return new Promise((resolve) => {
+      const child = spawn(spec.shell, spec.wrap(args.command), {
+        cwd: ctx.cwd,
+        windowsHide: true
+      });
+      let output = "";
+      let settled = false;
+      const finish = (result) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        clearTimeout(timer);
+        ctx.abortSignal?.removeEventListener("abort", onAbort);
+        resolve(result);
+      };
+      const onAbort = () => {
+        killTree(child);
+        finish({ content: `${truncateMiddle(output)}
+Command aborted`, isError: true });
+      };
+      const timer = setTimeout(() => {
+        killTree(child);
+        finish({
+          content: `${truncateMiddle(output)}
+Command timed out after ${timeoutSeconds}s`,
+          isError: true
+        });
+      }, timeoutSeconds * 1e3);
+      child.stdout.on("data", (d) => {
+        output += d.toString("utf8");
+      });
+      child.stderr.on("data", (d) => {
+        output += d.toString("utf8");
+      });
+      child.on("error", (err) => {
+        finish({ content: `Failed to start shell '${spec.label}': ${err.message}`, isError: true });
+      });
+      ctx.abortSignal?.addEventListener("abort", onAbort);
+      child.on("close", (code) => {
+        const trimmed = output.replace(/\s+$/, "");
+        if (code === 0) {
+          finish({ content: truncateMiddle(trimmed) || "(no output)" });
+          return;
+        }
+        const body = truncateMiddle(trimmed);
+        finish({
+          content: `${body}${body ? "\n" : ""}Exit code: ${code ?? "unknown"}`,
+          isError: true
+        });
+      });
+    });
+  }
+};
+
+// src/tools/fs/edit.ts
+import { readFile, writeFile } from "fs/promises";
+import path5 from "path";
+import { z as z2 } from "zod";
+var schema2 = z2.object({
+  path: z2.string().describe("File path, absolute or relative to the working directory"),
+  old_string: z2.string().min(1).describe("Exact text to replace"),
+  new_string: z2.string().describe("Replacement text"),
+  replace_all: z2.boolean().optional().describe("Replace every occurrence instead of requiring a unique match")
+});
+var editFileTool = {
+  name: "edit_file",
+  description: "Replace an exact string in a file. Fails if old_string is not found or matches multiple locations unless replace_all is set.",
+  permission: "write",
+  parameters: schema2,
+  async execute(args, ctx) {
+    const filePath = path5.resolve(ctx.cwd, args.path);
+    let content;
+    try {
+      content = await readFile(filePath, "utf8");
+    } catch (err) {
+      return { content: `Failed to read ${args.path}: ${err.message}`, isError: true };
+    }
+    let count = 0;
+    let idx = content.indexOf(args.old_string);
+    while (idx !== -1) {
+      count += 1;
+      idx = content.indexOf(args.old_string, idx + args.old_string.length);
+    }
+    if (count === 0) {
+      return { content: `old_string not found in ${args.path}`, isError: true };
+    }
+    if (count > 1 && !args.replace_all) {
+      return {
+        content: `old_string matches ${count} locations in ${args.path}; provide more surrounding context or set replace_all`,
+        isError: true
+      };
+    }
+    const updated = args.replace_all ? content.split(args.old_string).join(args.new_string) : content.replace(args.old_string, args.new_string);
+    await writeFile(filePath, updated, "utf8");
+    return { content: `Edited ${args.path}: ${count} replacement${count > 1 ? "s" : ""}` };
+  }
+};
+
+// src/tools/fs/glob.ts
+import path7 from "path";
+import { z as z3 } from "zod";
+
+// src/tools/fs/util.ts
+import { readdir, stat } from "fs/promises";
+import path6 from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist"]);
+async function walkFiles(root, skipDirs = SKIP_DIRS) {
+  const out = [];
+  async function walk(dir, relBase) {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => null);
+    if (!entries) {
+      return;
+    }
+    for (const entry of entries) {
+      const abs = path6.join(dir, entry.name);
+      const rel = relBase ? `${relBase}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        if (!skipDirs.has(entry.name)) {
+          await walk(abs, rel);
+        }
+      } else if (entry.isFile()) {
+        try {
+          const st = await stat(abs);
+          out.push({ abs, rel, mtimeMs: st.mtimeMs });
+        } catch {
+        }
+      }
+    }
+  }
+  await walk(root, "");
+  return out;
+}
+var REGEX_SPECIALS = /[.+^${}()|[\]\\]/g;
+function globToRegExp(pattern) {
+  let re = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const c = pattern.charAt(i);
+    if (c === "*") {
+      if (pattern.charAt(i + 1) === "*") {
+        i += 2;
+        if (pattern.charAt(i) === "/") {
+          i += 1;
+          re += "(?:[^/]+/)*";
+        } else {
+          re += ".*";
+        }
+      } else {
+        re += "[^/]*";
+        i += 1;
+      }
+    } else if (c === "?") {
+      re += "[^/]";
+      i += 1;
+    } else {
+      re += c.replace(REGEX_SPECIALS, "\\$&");
+      i += 1;
+    }
+  }
+  return new RegExp(`^${re}$`);
+}
+function matchesGlob(pattern, relPath) {
+  const normalized = pattern.replace(/\\/g, "/");
+  if (!normalized.includes("/")) {
+    const base = relPath.split("/").pop() ?? relPath;
+    return globToRegExp(normalized).test(base);
+  }
+  return globToRegExp(normalized).test(relPath);
+}
+function isSensitivePath2(filePath) {
+  const base = path6.basename(filePath);
+  if (base === ".env.example" || base === ".env.sample" || base === ".env.template") {
+    return false;
+  }
+  if (base === ".env" || base.startsWith(".env.")) {
+    return true;
+  }
+  if (base === "id_rsa" || base.endsWith(".pem")) {
+    return true;
+  }
+  return false;
+}
+
+// src/tools/fs/glob.ts
+var MAX_RESULTS = 100;
+var schema3 = z3.object({
+  pattern: z3.string().describe(
+    "Glob pattern, e.g. 'src/**/*.ts'. Supports **, * and ?. A bare pattern like '*.ts' matches basenames recursively."
+  ),
+  path: z3.string().optional().describe("Directory to search, defaults to the working directory")
+});
+var globTool = {
+  name: "glob",
+  description: "Find files by glob pattern. Skips node_modules, .git and dist. Returns paths sorted by modification time, newest first, up to 100 results.",
+  permission: "read",
+  parameters: schema3,
+  async execute(args, ctx) {
+    const root = path7.resolve(ctx.cwd, args.path ?? ".");
+    const files = await walkFiles(root);
+    const matched = files.filter((f) => matchesGlob(args.pattern, f.rel)).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, MAX_RESULTS);
+    if (matched.length === 0) {
+      return { content: `No files matched pattern: ${args.pattern}` };
+    }
+    return { content: matched.map((f) => f.rel).join("\n") };
+  }
+};
+
+// src/tools/fs/grep.ts
+import { readFile as readFile2, stat as stat2 } from "fs/promises";
+import path8 from "path";
+import { z as z4 } from "zod";
+var MAX_MATCHES = 250;
+var schema4 = z4.object({
+  pattern: z4.string().describe("Regular expression to search for"),
+  path: z4.string().optional().describe("File or directory to search, defaults to the working directory"),
+  glob: z4.string().optional().describe("Glob pattern to filter which files are searched, e.g. '*.ts'"),
+  ignoreCase: z4.boolean().optional().describe("Case-insensitive matching")
+});
+var grepTool = {
+  name: "grep",
+  description: "Search file contents with a regular expression. Outputs 'file:line:content', up to 250 matches. Skips binary files, node_modules and .git.",
+  permission: "read",
+  parameters: schema4,
+  async execute(args, ctx) {
+    let re;
+    try {
+      re = new RegExp(args.pattern, args.ignoreCase ? "i" : "");
+    } catch (err) {
+      return { content: `Invalid regular expression: ${err.message}`, isError: true };
+    }
+    const root = path8.resolve(ctx.cwd, args.path ?? ".");
+    let files;
+    try {
+      const st = await stat2(root);
+      if (st.isFile()) {
+        files = [{ abs: root, rel: path8.basename(root), mtimeMs: st.mtimeMs }];
+      } else {
+        files = await walkFiles(root);
+      }
+    } catch {
+      return { content: `Path not found: ${args.path ?? "."}`, isError: true };
+    }
+    if (args.glob) {
+      const glob = args.glob;
+      files = files.filter((f) => matchesGlob(glob, f.rel));
+    }
+    const out = [];
+    let truncated = false;
+    outer: for (const file of files) {
+      let buf;
+      try {
+        buf = await readFile2(file.abs);
+      } catch {
+        continue;
+      }
+      if (buf.includes(0)) {
+        continue;
+      }
+      const lines = buf.toString("utf8").split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        if (re.test(line)) {
+          out.push(`${file.rel}:${i + 1}:${line}`);
+          if (out.length >= MAX_MATCHES) {
+            truncated = true;
+            break outer;
+          }
+        }
+      }
+    }
+    if (out.length === 0) {
+      return { content: `No matches for pattern: ${args.pattern}` };
+    }
+    if (truncated) {
+      out.push(`... (truncated: more than ${MAX_MATCHES} matches)`);
+    }
+    return { content: out.join("\n") };
+  }
+};
+
+// src/tools/fs/read.ts
+import { readFile as readFile3, stat as stat3 } from "fs/promises";
+import path9 from "path";
+import { z as z5 } from "zod";
+var DEFAULT_LIMIT = 2e3;
+var MAX_CHARS = 100 * 1024;
+var schema5 = z5.object({
+  path: z5.string().describe("File path, absolute or relative to the working directory"),
+  offset: z5.number().int().positive().optional().describe("1-based line number to start reading from"),
+  limit: z5.number().int().positive().optional().describe("Maximum number of lines to read (default 2000)")
+});
+var readFileTool = {
+  name: "read_file",
+  description: "Read a text file and return its contents with line numbers. Output is truncated to 2000 lines or 100KB by default.",
+  permission: "read",
+  parameters: schema5,
+  async execute(args, ctx) {
+    const filePath = path9.resolve(ctx.cwd, args.path);
+    if (isSensitivePath2(filePath)) {
+      return { content: `Refused to read sensitive file: ${args.path}`, isError: true };
+    }
+    const st = await stat3(filePath).catch(() => null);
+    if (!st) {
+      return { content: `File not found: ${args.path}`, isError: true };
+    }
+    if (st.isDirectory()) {
+      return { content: `Path is a directory, not a file: ${args.path}`, isError: true };
+    }
+    const raw = await readFile3(filePath, "utf8");
+    const lines = raw.split("\n");
+    const start = args.offset ?? 1;
+    const limit = args.limit ?? DEFAULT_LIMIT;
+    const end = Math.min(lines.length, start - 1 + limit);
+    const out = [];
+    let size = 0;
+    let truncatedBySize = false;
+    for (let i = start - 1; i < end; i++) {
+      const line = lines[i];
+      if (line === void 0) {
+        break;
+      }
+      const numbered = `${i + 1}	${line}`;
+      if (size + numbered.length > MAX_CHARS) {
+        truncatedBySize = true;
+        break;
+      }
+      out.push(numbered);
+      size += numbered.length;
+    }
+    const lastShown = start - 1 + out.length;
+    if (truncatedBySize) {
+      out.push(
+        `... (truncated: output exceeds 100KB, showing lines ${start}-${lastShown} of ${lines.length})`
+      );
+    } else if (end < lines.length) {
+      out.push(`... (truncated: showing lines ${start}-${end} of ${lines.length})`);
+    }
+    return { content: out.join("\n") };
+  }
+};
+
+// src/tools/fs/write.ts
+import { mkdir, writeFile as writeFile2 } from "fs/promises";
+import path10 from "path";
+import { z as z6 } from "zod";
+var schema6 = z6.object({
+  path: z6.string().describe("File path, absolute or relative to the working directory"),
+  content: z6.string().describe("Full content to write to the file")
+});
+var writeFileTool = {
+  name: "write_file",
+  description: "Write content to a file, creating parent directories as needed. Overwrites existing files.",
+  permission: "write",
+  parameters: schema6,
+  async execute(args, ctx) {
+    const filePath = path10.resolve(ctx.cwd, args.path);
+    try {
+      await mkdir(path10.dirname(filePath), { recursive: true });
+      await writeFile2(filePath, args.content, "utf8");
+    } catch (err) {
+      return { content: `Failed to write ${args.path}: ${err.message}`, isError: true };
+    }
+    return { content: `Wrote ${Buffer.byteLength(args.content, "utf8")} bytes to ${args.path}` };
+  }
+};
+
+// src/tools/todo.ts
+import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
+import path11 from "path";
+import { z as z7 } from "zod";
+var todoItemSchema = z7.object({
+  id: z7.number().int(),
+  title: z7.string(),
+  status: z7.enum(["pending", "in_progress", "done"])
+});
+var writeSchema = z7.object({
+  todos: z7.array(todoItemSchema).describe("The full todo list, replacing the current one")
+});
+var readSchema = z7.object({});
+function fileFor(cwd) {
+  return path11.join(cwd, ".star", "todos.json");
+}
+var TodoStore = class {
+  items = /* @__PURE__ */ new Map();
+  list() {
+    return [...this.items.values()];
+  }
+  replace(items) {
+    this.items.clear();
+    for (const item of items) {
+      this.items.set(item.id, item);
+    }
+  }
+  async load(cwd) {
+    let raw;
+    try {
+      raw = await readFile4(fileFor(cwd), "utf8");
+    } catch {
+      return;
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) {
+        this.replace(parsed.filter((it) => todoItemSchema.safeParse(it).success));
+      }
+    } catch {
+    }
+  }
+  async save(cwd) {
+    await mkdir2(path11.join(cwd, ".star"), { recursive: true });
+    await writeFile3(fileFor(cwd), `${JSON.stringify(this.list(), null, 2)}
+`);
+  }
+};
+var SYMBOLS = {
+  pending: "[ ]",
+  in_progress: "[~]",
+  done: "[x]"
+};
+function formatTodos(items) {
+  if (items.length === 0) {
+    return "No todos.";
+  }
+  const lines = items.map((it) => `${SYMBOLS[it.status]} ${it.id}. ${it.title}`);
+  const width = Math.max(...lines.map((l) => l.length));
+  return lines.map((line, i) => {
+    const status = items[i]?.status;
+    return status === "pending" ? line : `${line.padEnd(width + 4)}(${status})`;
+  }).join("\n");
+}
+var defaultStore = new TodoStore();
+function createTodoTools(store = defaultStore) {
+  const todoWrite = {
+    name: "todo_write",
+    description: "Replace the current todo list with the given items. Each item has an id, title, and status (pending, in_progress, done).",
+    permission: "read",
+    parameters: writeSchema,
+    async execute(args, ctx) {
+      const parsed = writeSchema.safeParse(args);
+      if (!parsed.success) {
+        return { content: `Invalid todos: ${parsed.error.message}`, isError: true };
+      }
+      await store.load(ctx.cwd);
+      store.replace(parsed.data.todos);
+      await store.save(ctx.cwd);
+      return { content: formatTodos(store.list()) };
+    }
+  };
+  const todoRead = {
+    name: "todo_read",
+    description: "Read the current todo list.",
+    permission: "read",
+    parameters: readSchema,
+    async execute(_args, ctx) {
+      await store.load(ctx.cwd);
+      return { content: formatTodos(store.list()) };
+    }
+  };
+  return [todoWrite, todoRead];
+}
+
+// src/tools/web/fetch.ts
+import { z as z8 } from "zod";
+var DEFAULT_MAX_CHARS = 2e4;
+var MAX_BYTES = 2 * 1024 * 1024;
+var TIMEOUT_MS = 3e4;
+var schema7 = z8.object({
+  url: z8.string().describe("The http(s) URL to fetch"),
+  maxChars: z8.number().int().positive().optional().describe("Maximum characters of text to return (default 20000)")
+});
+function decodeEntities(s) {
+  return s.replace(/&#(\d+);/g, (_, n) => String.fromCodePoint(Number(n))).replace(/&#x([0-9a-fA-F]+);/gi, (_, n) => String.fromCodePoint(Number.parseInt(n, 16))).replace(/&(quot|lt|gt|nbsp);/g, (m) => {
+    switch (m) {
+      case "&quot;":
+        return '"';
+      case "&lt;":
+        return "<";
+      case "&gt;":
+        return ">";
+      case "&nbsp;":
+        return " ";
+      default:
+        return m;
+    }
+  }).replace(/&amp;/g, "&");
+}
+function htmlToText(html) {
+  const noBlocks = html.replace(/<(script|style|noscript|template)\b[^>]*>[\s\S]*?<\/\1>/gi, " ");
+  const withBreaks = noBlocks.replace(
+    /<br\s*\/?>|<\/(p|div|li|tr|h[1-6]|section|article|header|footer|blockquote|pre)>/gi,
+    "\n"
+  );
+  const stripped = decodeEntities(withBreaks.replace(/<[^>]+>/g, " "));
+  return stripped.split("\n").map((line) => line.replace(/\s+/g, " ").trim()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+async function readBody(res, maxChars) {
+  if (!res.body) {
+    return "";
+  }
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let bytes = 0;
+  let text = "";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      bytes += value.byteLength;
+      text += decoder.decode(value, { stream: true });
+      if (bytes >= MAX_BYTES || text.length >= maxChars * 2) {
+        break;
+      }
+    }
+    text += decoder.decode();
+  } finally {
+    reader.cancel().catch(() => {
+    });
+  }
+  return text;
+}
+function truncate(s, maxChars) {
+  if (s.length <= maxChars) {
+    return s;
+  }
+  return `${s.slice(0, maxChars)}
+[truncated, showing first ${maxChars} of ${s.length} chars]`;
+}
+var webFetchTool = {
+  name: "web_fetch",
+  description: "Fetch a URL over http(s) and return its contents as readable text. HTML pages are converted to plain text (tags, scripts and styles removed). Output is truncated to maxChars (default 20000).",
+  permission: "read",
+  parameters: schema7,
+  async execute(args, ctx) {
+    let url;
+    try {
+      url = new URL(args.url);
+    } catch {
+      return { content: `ERROR: invalid URL: ${args.url}`, isError: true };
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      return {
+        content: `ERROR: only http(s) URLs are supported, got: ${url.protocol}`,
+        isError: true
+      };
+    }
+    const maxChars = args.maxChars ?? DEFAULT_MAX_CHARS;
+    const timeoutSignal = AbortSignal.timeout(TIMEOUT_MS);
+    const signal = ctx.abortSignal ? AbortSignal.any([timeoutSignal, ctx.abortSignal]) : timeoutSignal;
+    let res;
+    try {
+      res = await fetch(url, { signal, redirect: "follow" });
+    } catch (err) {
+      if (ctx.abortSignal?.aborted) {
+        return { content: "ERROR: request aborted", isError: true };
+      }
+      if (timeoutSignal.aborted) {
+        return { content: `ERROR: request timed out after ${TIMEOUT_MS / 1e3}s`, isError: true };
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `ERROR: failed to fetch ${args.url}: ${message}`, isError: true };
+    }
+    if (!res.ok) {
+      await res.body?.cancel().catch(() => {
+      });
+      return {
+        content: `ERROR: HTTP ${res.status} ${res.statusText} for ${args.url}`,
+        isError: true
+      };
+    }
+    const [rawType = ""] = (res.headers.get("content-type") ?? "text/plain").split(";");
+    const contentType = rawType.trim().toLowerCase();
+    const isHtml = contentType === "text/html" || contentType === "application/xhtml+xml";
+    const isText = contentType.startsWith("text/") || contentType === "application/json" || contentType === "application/xml" || contentType.endsWith("+json") || contentType.endsWith("+xml");
+    if (!isHtml && !isText) {
+      await res.body?.cancel().catch(() => {
+      });
+      return {
+        content: `ERROR: unsupported content type: ${contentType} (${args.url})`,
+        isError: true
+      };
+    }
+    let body;
+    try {
+      body = await readBody(res, maxChars);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `ERROR: failed to read response body: ${message}`, isError: true };
+    }
+    const text = isHtml ? htmlToText(body) : body;
+    return { content: truncate(text, maxChars) };
+  }
+};
+
+// src/tools/registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  constructor() {
+    for (const tool of [
+      readFileTool,
+      writeFileTool,
+      editFileTool,
+      globTool,
+      grepTool,
+      bashTool,
+      webFetchTool,
+      ...createTodoTools()
+    ]) {
+      this.register(tool);
+    }
+  }
+  register(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  list() {
+    return [...this.tools.values()];
+  }
+  names() {
+    return [...this.tools.keys()];
+  }
+};
+
+// src/tools/index.ts
+function createDefaultRegistry() {
+  const registry = new ToolRegistry();
+  for (const tool of createTodoTools()) {
+    registry.register(tool);
+  }
+  return registry;
+}
+
+// src/cli/commands/builtin.ts
+function registerBuiltinCommands(registry) {
+  registry.register({
+    name: "help",
+    description: "List available commands",
+    usage: "/help",
+    run(_args, ctx) {
+      const lines = registry.list().map((cmd) => {
+        const usage = cmd.usage ?? `/${cmd.name}`;
+        return `${usage} - ${cmd.description}`;
+      });
+      ctx.addSystemMessage(`Available commands:
+${lines.join("\n")}`);
+    }
+  });
+  registry.register({
+    name: "clear",
+    description: "Clear message history",
+    usage: "/clear",
+    run(_args, ctx) {
+      ctx.clearMessages();
+    }
+  });
+  registry.register({
+    name: "exit",
+    description: "Exit the application",
+    usage: "/exit",
+    run(_args, ctx) {
+      ctx.exit();
+    }
+  });
+  registry.register({
+    name: "q",
+    description: "Exit the application (alias of /exit)",
+    usage: "/q",
+    run(_args, ctx) {
+      ctx.exit();
+    }
+  });
+  registry.register({
+    name: "model",
+    description: "List available models or switch the current model",
+    usage: "/model [name]",
+    async run(args, ctx) {
+      if (!args) {
+        ctx.addSystemMessage(ctx.listModels());
+      } else {
+        ctx.addSystemMessage(await ctx.switchModel(args));
+      }
+    }
+  });
+  registry.register({
+    name: "resume",
+    description: "List sessions or resume a session by id",
+    usage: "/resume [sessionId]",
+    async run(args, ctx) {
+      if (!args) {
+        ctx.addSystemMessage(await ctx.listSessions());
+      } else {
+        ctx.addSystemMessage(await ctx.resumeSession(args));
+      }
+    }
+  });
+  registry.register({
+    name: "todo",
+    description: "Show the current todo list",
+    usage: "/todo",
+    async run(_args, ctx) {
+      ctx.addSystemMessage(await ctx.showTodos());
+    }
+  });
+  registry.register({
+    name: "cost",
+    description: "Show API token usage for this session",
+    usage: "/cost",
+    run(_args, ctx) {
+      ctx.addSystemMessage(ctx.showUsage());
+    }
+  });
+  registry.register({
+    name: "config",
+    description: "Show the current configuration",
+    usage: "/config",
+    run(_args, ctx) {
+      ctx.addSystemMessage(ctx.describeConfig());
+    }
+  });
+}
+
+// src/cli/commands/registry.ts
+var CommandRegistry = class {
+  commands = /* @__PURE__ */ new Map();
+  register(command) {
+    this.commands.set(command.name, command);
+  }
+  list() {
+    return [...this.commands.values()].sort((a, b) => a.name.localeCompare(b.name));
+  }
+  get(name) {
+    return this.commands.get(name);
+  }
+  complete(prefix) {
+    const stripped = prefix.startsWith("/") ? prefix.slice(1) : prefix;
+    return this.list().filter((cmd) => cmd.name.startsWith(stripped));
+  }
+};
+function parseSlashCommand(input) {
+  if (!input.startsWith("/")) return null;
+  const body = input.slice(1).trim();
+  if (body.length === 0) return null;
+  const spaceIndex = body.search(/\s/);
+  if (spaceIndex === -1) return { name: body, args: "" };
+  return {
+    name: body.slice(0, spaceIndex),
+    args: body.slice(spaceIndex).trim()
+  };
+}
+
+// src/cli/components/InputBox.tsx
+import { Box, Text, useInput } from "ink";
+import { useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function InputBox({ isStreaming, disabled, onSubmit, onInterrupt, onExit }) {
+  const [value, setValue] = useState("");
+  const [cursor, setCursor] = useState(0);
+  const [history, setHistory] = useState([]);
+  const historyIndexRef = useRef(null);
+  const draftRef = useRef("");
+  const edit = (next, nextCursor) => {
+    setValue(next);
+    setCursor(Math.max(0, Math.min(nextCursor, next.length)));
+  };
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") {
+      if (isStreaming || disabled) {
+        onInterrupt();
+      } else {
+        edit("", 0);
+        historyIndexRef.current = null;
+      }
+      return;
+    }
+    if (key.ctrl && input === "d") {
+      onExit();
+      return;
+    }
+    if (isStreaming || disabled) return;
+    if (key.return) {
+      const text = value.trim();
+      if (text.length > 0) {
+        setHistory((prev) => [...prev, text]);
+        onSubmit(text);
+      }
+      edit("", 0);
+      historyIndexRef.current = null;
+      draftRef.current = "";
+      return;
+    }
+    if (key.upArrow) {
+      if (history.length === 0) return;
+      if (historyIndexRef.current === null) {
+        draftRef.current = value;
+        historyIndexRef.current = history.length - 1;
+      } else if (historyIndexRef.current > 0) {
+        historyIndexRef.current -= 1;
+      }
+      const entry = history[historyIndexRef.current] ?? "";
+      edit(entry, entry.length);
+      return;
+    }
+    if (key.downArrow) {
+      if (historyIndexRef.current === null) return;
+      if (historyIndexRef.current < history.length - 1) {
+        historyIndexRef.current += 1;
+        const entry = history[historyIndexRef.current] ?? "";
+        edit(entry, entry.length);
+      } else {
+        historyIndexRef.current = null;
+        edit(draftRef.current, draftRef.current.length);
+      }
+      return;
+    }
+    if (key.leftArrow) {
+      setCursor((prev) => Math.max(0, prev - 1));
+      return;
+    }
+    if (key.rightArrow) {
+      setCursor((prev) => Math.min(value.length, prev + 1));
+      return;
+    }
+    if (key.ctrl && input === "a") {
+      setCursor(0);
+      return;
+    }
+    if (key.ctrl && input === "e") {
+      setCursor(value.length);
+      return;
+    }
+    if (key.ctrl && input === "u") {
+      edit(value.slice(cursor), 0);
+      return;
+    }
+    if (key.ctrl && input === "k") {
+      edit(value.slice(0, cursor), cursor);
+      return;
+    }
+    if (key.ctrl && input === "w") {
+      const trimmed = value.slice(0, cursor).replace(/\s+$/, "");
+      const wordStart = trimmed.search(/\S+$/);
+      const next = value.slice(0, wordStart === -1 ? 0 : wordStart) + value.slice(cursor);
+      edit(next, wordStart === -1 ? 0 : wordStart);
+      return;
+    }
+    if (key.backspace || key.delete) {
+      if (cursor === 0) return;
+      edit(value.slice(0, cursor - 1) + value.slice(cursor), cursor - 1);
+      return;
+    }
+    if (input && !key.ctrl && !key.meta) {
+      edit(value.slice(0, cursor) + input + value.slice(cursor), cursor + input.length);
+    }
+  });
+  const before = value.slice(0, cursor);
+  const at = value[cursor] ?? " ";
+  const after = value.slice(cursor + 1);
+  return /* @__PURE__ */ jsxs(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, children: [
+    /* @__PURE__ */ jsx(Text, { color: "cyan", children: "> " }),
+    /* @__PURE__ */ jsx(Text, { children: before }),
+    /* @__PURE__ */ jsx(Text, { inverse: true, children: at }),
+    /* @__PURE__ */ jsx(Text, { children: after })
+  ] });
+}
+
+// src/cli/components/MessageList.tsx
+import { Box as Box2, Static, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var roleStyles = {
+  user: { label: "you", color: "cyan" },
+  assistant: { label: "star", color: "green" },
+  system: { label: "system", color: "yellow" },
+  tool: { label: "tool", color: "magenta" }
+};
+function MessageList({ messages }) {
+  return /* @__PURE__ */ jsx2(Static, { items: messages, children: (message) => {
+    const style = roleStyles[message.role];
+    return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx2(Text2, { bold: true, color: style.color, children: style.label }),
+      /* @__PURE__ */ jsx2(Text2, { color: style.color, children: message.text })
+    ] }, message.id);
+  } });
+}
+
+// src/cli/components/PermissionPrompt.tsx
+import { Box as Box3, Text as Text3, useInput as useInput2 } from "ink";
+
+// src/cli/format.ts
+function summarizeArgs(args, maxLength = 120) {
+  let json;
+  try {
+    json = JSON.stringify(args) ?? String(args);
+  } catch {
+    json = String(args);
+  }
+  return json.length > maxLength ? `${json.slice(0, maxLength)}...` : json;
+}
+function previewLines(text, maxLines = 10) {
+  const lines = text.split("\n");
+  if (lines.length <= maxLines) return { text, truncated: false };
+  return { text: lines.slice(0, maxLines).join("\n"), truncated: true };
+}
+function coreMessageText(message) {
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter((part) => part.type === "text").map((part) => "text" in part ? part.text : "").join(" ");
+  }
+  return "";
+}
+function buildDisplayMessages(messages) {
+  const display = [];
+  let collapsed = 0;
+  for (const message of messages) {
+    if (message.role === "user" || message.role === "assistant") {
+      const text = coreMessageText(message);
+      if (text) {
+        display.push({ id: display.length, role: message.role, text });
+      } else {
+        collapsed++;
+      }
+    } else if (message.role === "tool") {
+      collapsed++;
+    }
+  }
+  if (collapsed > 0) {
+    display.push({
+      id: display.length,
+      role: "system",
+      text: `\u5DF2\u6062\u590D ${collapsed} \u6761\u5386\u53F2\u6D88\u606F`
+    });
+  }
+  return display;
+}
+
+// src/cli/components/PermissionPrompt.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function PermissionPrompt({ request, onDecision }) {
+  useInput2((input) => {
+    const ch = input.toLowerCase();
+    if (ch === "y") onDecision("yes");
+    else if (ch === "n") onDecision("no");
+    else if (ch === "a") onDecision("always");
+  });
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs3(Text3, { bold: true, color: "yellow", children: [
+      "Permission required: ",
+      request.toolName,
+      " (",
+      request.level,
+      ")"
+    ] }),
+    /* @__PURE__ */ jsx3(Text3, { children: summarizeArgs(request.args) }),
+    /* @__PURE__ */ jsx3(Text3, { children: "[y] allow [n] deny [a] always" })
+  ] });
+}
+
+// src/cli/components/StatusBar.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsxs as jsxs4 } from "react/jsx-runtime";
+function StatusBar({ model, permissionMode, tokens }) {
+  return /* @__PURE__ */ jsxs4(Box4, { justifyContent: "space-between", children: [
+    /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+      "model: ",
+      model
+    ] }),
+    /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+      tokens,
+      " tokens"
+    ] }),
+    /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+      "mode: ",
+      permissionMode
+    ] })
+  ] });
+}
+
+// src/cli/components/StreamingMessage.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx4, jsxs as jsxs5 } from "react/jsx-runtime";
+function StreamingMessage({ text }) {
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx4(Text5, { bold: true, color: "green", children: "star" }),
+    /* @__PURE__ */ jsx4(Text5, { color: "green", children: text })
+  ] });
+}
+
+// src/cli/components/ToolCallCard.tsx
+import { Box as Box6, Text as Text6 } from "ink";
+import { jsx as jsx5, jsxs as jsxs6 } from "react/jsx-runtime";
+function ToolCallCard({ card }) {
+  const color = card.isError ? "red" : "magenta";
+  const preview = card.result !== void 0 ? previewLines(card.result, 10) : null;
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs6(Text6, { bold: true, color, children: [
+      "tool: ",
+      card.name,
+      card.isError ? " (error)" : ""
+    ] }),
+    /* @__PURE__ */ jsx5(Text6, { dimColor: true, children: card.argsSummary }),
+    preview && /* @__PURE__ */ jsxs6(Text6, { color, children: [
+      preview.text,
+      preview.truncated ? "\n... (truncated)" : ""
+    ] })
+  ] });
+}
+function formatToolCard(card) {
+  const header = `${card.name} ${card.argsSummary}${card.isError ? " [error]" : ""}`;
+  if (card.result === void 0) return header;
+  const preview = previewLines(card.result, 10);
+  return `${header}
+${preview.text}${preview.truncated ? "\n... (truncated)" : ""}`;
+}
+
+// src/cli/repl.tsx
+import { jsx as jsx6, jsxs as jsxs7 } from "react/jsx-runtime";
+var FLUSH_INTERVAL_MS = 30;
+function emptyUsage() {
+  return { requests: 0, promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+}
+function formatUsage(usage) {
+  return `API usage this session: ${usage.requests} requests, ${usage.promptTokens} prompt + ${usage.completionTokens} completion = ${usage.totalTokens} tokens`;
+}
+function Repl({
+  backend,
+  model,
+  permissionMode,
+  config,
+  cwd,
+  sessionStore,
+  initialMessages,
+  initialUsage
+}) {
+  const { exit } = useApp();
+  const [initialDisplay] = useState2(() => buildDisplayMessages(initialMessages ?? []));
+  const [messages, setMessages] = useState2(initialDisplay);
+  const [epoch, setEpoch] = useState2(0);
+  const [streamingText, setStreamingText] = useState2(null);
+  const [isStreaming, setIsStreaming] = useState2(false);
+  const [usageVersion, setUsageVersion] = useState2(0);
+  const [modelName, setModelName] = useState2(model);
+  const [pending, setPending] = useState2(null);
+  const [cardsVersion, setCardsVersion] = useState2(0);
+  const backendRef = useRef2(backend);
+  const nextIdRef = useRef2(initialDisplay.length);
+  const abortRef = useRef2(null);
+  const streamedRef = useRef2("");
+  const flushTimerRef = useRef2(null);
+  const toolCardsRef = useRef2(/* @__PURE__ */ new Map());
+  const pendingRef = useRef2(null);
+  const alwaysAllowedRef = useRef2(/* @__PURE__ */ new Set());
+  const modelNameRef = useRef2(model);
+  const usageRef = useRef2(initialUsage ? { ...initialUsage } : emptyUsage());
+  const pushMessage = useCallback((role, text) => {
+    setMessages((prev) => [...prev, { id: nextIdRef.current++, role, text }]);
+  }, []);
+  const setPendingPermission = useCallback((p) => {
+    pendingRef.current = p;
+    setPending(p);
+  }, []);
+  const attachConfirmHandler = useCallback(
+    (target) => {
+      target.confirmHandler = (req) => {
+        if (alwaysAllowedRef.current.has(req.toolName)) {
+          return Promise.resolve(true);
+        }
+        return new Promise((resolve) => {
+          setPendingPermission({ request: req, resolve });
+        });
+      };
+    },
+    [setPendingPermission]
+  );
+  useEffect(() => {
+    attachConfirmHandler(backendRef.current);
+    return () => {
+      if (flushTimerRef.current !== null) clearInterval(flushTimerRef.current);
+      abortRef.current?.abort();
+      pendingRef.current?.resolve(false);
+    };
+  }, [attachConfirmHandler]);
+  const interrupt = useCallback(() => {
+    abortRef.current?.abort();
+    const p = pendingRef.current;
+    if (p) {
+      setPendingPermission(null);
+      p.resolve(false);
+    }
+  }, [setPendingPermission]);
+  useInput3((_input, key) => {
+    if (key.escape) interrupt();
+  });
+  const handleDecision = useCallback(
+    (decision) => {
+      const p = pendingRef.current;
+      if (!p) return;
+      if (decision === "always") {
+        alwaysAllowedRef.current.add(p.request.toolName);
+      }
+      setPendingPermission(null);
+      p.resolve(decision !== "no");
+    },
+    [setPendingPermission]
+  );
+  const switchModel = useCallback(
+    async (name) => {
+      try {
+        const newModel = createModel(config, name);
+        const loop = new AgentLoop({
+          model: newModel,
+          registry: createDefaultRegistry(),
+          config,
+          cwd,
+          sessionStore
+        });
+        const prev = backendRef.current;
+        if (prev instanceof AgentLoop) {
+          await loop.loadMessages([...prev.getMessages()]);
+        }
+        attachConfirmHandler(loop);
+        backendRef.current = loop;
+        modelNameRef.current = name;
+        setModelName(name);
+        return `Switched to model "${name}".`;
+      } catch (error) {
+        return `Failed to switch model: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    [config, cwd, sessionStore, attachConfirmHandler]
+  );
+  const resume = useCallback(async (id) => {
+    const current = backendRef.current;
+    if (!(current instanceof AgentLoop)) {
+      return "Current backend does not support resuming sessions.";
+    }
+    const resumed = await resumeSession(id);
+    if (!resumed) {
+      return `Session not found: ${id}`;
+    }
+    await current.loadMessages(resumed.messages);
+    const display = buildDisplayMessages(resumed.messages);
+    nextIdRef.current = display.length;
+    setMessages(display);
+    setEpoch((e) => e + 1);
+    usageRef.current = resumed.meta.usage ? { ...resumed.meta.usage } : emptyUsage();
+    setUsageVersion((v) => v + 1);
+    return `Resumed session ${id} (${resumed.messages.length} messages).`;
+  }, []);
+  const registry = useMemo(() => {
+    const ctx = {
+      addSystemMessage: (text) => pushMessage("system", text),
+      clearMessages: () => {
+        setMessages([]);
+        setEpoch((e) => e + 1);
+      },
+      exit: () => exit(),
+      listModels: () => {
+        const models = listModels(config);
+        if (models.length === 0) return "No models configured.";
+        const lines = models.map(
+          (m) => `${m.name === modelNameRef.current ? "*" : " "} ${m.name} (${m.provider}/${m.model})`
+        );
+        return `Models (* = current):
+${lines.join("\n")}`;
+      },
+      switchModel,
+      listSessions: async () => {
+        const metas = await SessionStore.list(cwd);
+        return metas.length === 0 ? "No sessions found for this directory." : formatSessionList(metas);
+      },
+      resumeSession: resume,
+      showTodos: async () => {
+        const store = new TodoStore();
+        await store.load(cwd);
+        return formatTodos(store.list());
+      },
+      showUsage: () => formatUsage(usageRef.current),
+      describeConfig: () => [
+        `defaultModel: ${config.defaultModel || "(none)"}`,
+        `permissionMode: ${config.permissionMode}`,
+        `providers (${config.providers.length}): ${config.providers.map((p) => p.name).join(", ") || "(none)"}`,
+        `models (${config.models.length}): ${config.models.map((m) => m.name).join(", ") || "(none)"}`,
+        `maxSteps: ${config.maxSteps}`,
+        `contextMaxTokens: ${config.contextMaxTokens}`
+      ].join("\n")
+    };
+    const reg = new CommandRegistry();
+    registerBuiltinCommands(reg);
+    return Object.assign(reg, { ctx });
+  }, [pushMessage, exit, config, cwd, switchModel, resume]);
+  const runStream = useCallback(
+    async (input) => {
+      pushMessage("user", input);
+      const controller = new AbortController();
+      abortRef.current = controller;
+      streamedRef.current = "";
+      setStreamingText("");
+      setIsStreaming(true);
+      flushTimerRef.current = setInterval(() => {
+        setStreamingText(streamedRef.current);
+      }, FLUSH_INTERVAL_MS);
+      try {
+        for await (const event of backendRef.current.stream(input, controller.signal)) {
+          if (event.type === "text-delta") {
+            streamedRef.current += event.text;
+          } else if (event.type === "tool-call") {
+            toolCardsRef.current.set(event.id, {
+              id: event.id,
+              name: event.name,
+              argsSummary: summarizeArgs(event.args)
+            });
+            setCardsVersion((v) => v + 1);
+          } else if (event.type === "tool-result") {
+            const card = toolCardsRef.current.get(event.id);
+            if (card) {
+              card.result = event.content;
+              card.isError = event.isError ?? false;
+              setCardsVersion((v) => v + 1);
+            }
+          } else if (event.type === "finish") {
+            if (event.usage) {
+              const usage = usageRef.current;
+              usage.requests += 1;
+              usage.promptTokens += event.usage.promptTokens;
+              usage.completionTokens += event.usage.completionTokens;
+              usage.totalTokens += event.usage.totalTokens;
+              setUsageVersion((v) => v + 1);
+              sessionStore?.addUsage(event.usage).catch(() => {
+              });
+            }
+          } else if (event.type === "error") {
+            pushMessage("system", `Error: ${event.error.message}`);
+          }
+        }
+      } catch (error) {
+        if (!(error instanceof DOMException && error.name === "AbortError")) {
+          pushMessage("system", `Error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      } finally {
+        if (flushTimerRef.current !== null) {
+          clearInterval(flushTimerRef.current);
+          flushTimerRef.current = null;
+        }
+        abortRef.current = null;
+        setIsStreaming(false);
+        const finalText = streamedRef.current;
+        streamedRef.current = "";
+        setStreamingText(null);
+        if (finalText.length > 0) {
+          pushMessage(
+            "assistant",
+            controller.signal.aborted ? `${finalText} [interrupted]` : finalText
+          );
+        }
+        for (const card of toolCardsRef.current.values()) {
+          pushMessage("tool", formatToolCard(card));
+        }
+        toolCardsRef.current.clear();
+        setCardsVersion((v) => v + 1);
+        const p = pendingRef.current;
+        if (p) {
+          setPendingPermission(null);
+          p.resolve(false);
+        }
+      }
+    },
+    [pushMessage, setPendingPermission, sessionStore]
+  );
+  const handleSubmit = useCallback(
+    (text) => {
+      if (text.startsWith("/")) {
+        const parsed = parseSlashCommand(text);
+        if (!parsed) return;
+        const command = registry.get(parsed.name);
+        if (!command) {
+          pushMessage("system", `Unknown command: /${parsed.name} (try /help)`);
+          return;
+        }
+        void command.run(parsed.args, registry.ctx);
+        return;
+      }
+      void runStream(text);
+    },
+    [registry, pushMessage, runStream]
+  );
+  const cards = [...toolCardsRef.current.values()];
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx6(MessageList, { messages }, epoch),
+    cards.length > 0 && /* @__PURE__ */ jsx6(Box7, { flexDirection: "column", children: cards.map((card) => /* @__PURE__ */ jsx6(ToolCallCard, { card }, card.id)) }, cardsVersion),
+    streamingText !== null && /* @__PURE__ */ jsx6(StreamingMessage, { text: streamingText }),
+    pending && /* @__PURE__ */ jsx6(PermissionPrompt, { request: pending.request, onDecision: handleDecision }),
+    /* @__PURE__ */ jsx6(
+      InputBox,
+      {
+        isStreaming,
+        disabled: pending !== null,
+        onSubmit: handleSubmit,
+        onInterrupt: interrupt,
+        onExit: exit
+      }
+    ),
+    /* @__PURE__ */ jsx6(
+      StatusBar,
+      {
+        model: modelName,
+        permissionMode,
+        tokens: usageRef.current.totalTokens
+      },
+      usageVersion
+    )
+  ] });
+}
+function renderRepl(backend, opts) {
+  return render(
+    /* @__PURE__ */ jsx6(
+      Repl,
+      {
+        backend,
+        model: opts.model,
+        permissionMode: opts.permissionMode,
+        config: opts.config,
+        cwd: opts.cwd,
+        sessionStore: opts.sessionStore,
+        initialMessages: opts.initialMessages,
+        initialUsage: opts.initialUsage
+      }
+    )
+  );
+}
+
+// src/config/loader.ts
+import fs2 from "fs";
+import { parse } from "smol-toml";
+
+// src/config/schema.ts
+import { z as z9 } from "zod";
+var ProviderConfigSchema = z9.object({
+  name: z9.string(),
+  protocol: z9.enum(["openai-compatible", "anthropic", "openai-responses"]).default("openai-compatible"),
+  baseURL: z9.string(),
+  apiKeyEnv: z9.string().optional(),
+  apiKey: z9.string().optional(),
+  headers: z9.record(z9.string()).optional()
+});
+var ModelConfigSchema = z9.object({
+  name: z9.string(),
+  provider: z9.string(),
+  model: z9.string(),
+  maxTokens: z9.number().int().positive().optional()
+});
+var ConfigSchema = z9.object({
+  defaultModel: z9.string().default(""),
+  permissionMode: z9.enum(["auto", "ask", "readonly"]).default("ask"),
+  providers: z9.array(ProviderConfigSchema).default([]),
+  models: z9.array(ModelConfigSchema).default([]),
+  maxSteps: z9.number().int().positive().default(50),
+  contextMaxTokens: z9.number().int().positive().default(1e5),
+  contextCompaction: z9.enum(["summary", "truncate"]).default("summary")
+});
+
+// src/config/loader.ts
+var PartialConfigSchema = ConfigSchema.partial();
+function parseTomlFile(content, filePath) {
+  let raw;
+  try {
+    raw = parse(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to parse TOML in ${filePath}: ${message}`);
+  }
+  const result = PartialConfigSchema.safeParse(raw);
+  if (!result.success) {
+    throw new Error(`Invalid config in ${filePath}: ${result.error.message}`);
+  }
+  return result.data;
+}
+function mergeConfig(base, override) {
+  return { ...base, ...override };
+}
+function applyOverrides(config, overrides) {
+  if (!overrides) return config;
+  const merged = { ...config };
+  if (overrides.model !== void 0) merged.defaultModel = overrides.model;
+  if (overrides.permissionMode !== void 0) merged.permissionMode = overrides.permissionMode;
+  return merged;
+}
+function readTomlFileSync(filePath) {
+  if (!fs2.existsSync(filePath)) return {};
+  const content = fs2.readFileSync(filePath, "utf8");
+  return parseTomlFile(content, filePath);
+}
+function loadConfigSync(cwd, overrides) {
+  const global = readTomlFileSync(globalConfigPath());
+  const project = readTomlFileSync(projectConfigPath(cwd));
+  const merged = applyOverrides(mergeConfig(global, project), overrides);
+  return ConfigSchema.parse(merged);
+}
+
+// src/main.tsx
+var SYSTEM_PROMPT = `You are Star CLI, an AI coding agent running in the user's terminal.
+You help with software engineering tasks: reading, writing and editing code, running shell commands, and managing todos.
+Be concise and direct. Use tools when they help accomplish the task.
+The working directory is the user's project root; never touch files outside it without explicit instruction.`;
+async function createLoop(config, modelName, cwd, sessionStore) {
+  const model = createModel(config, modelName);
+  const registry = createDefaultRegistry();
+  return new AgentLoop({
+    model,
+    registry,
+    config,
+    cwd,
+    system: SYSTEM_PROMPT,
+    sessionStore
+  });
+}
+async function printMode(loop, prompt) {
+  const controller = new AbortController();
+  process.on("SIGINT", () => controller.abort());
+  let requests = 0;
+  let promptTokens = 0;
+  let completionTokens = 0;
+  let totalTokens = 0;
+  let exitCode = 0;
+  for await (const event of loop.stream(prompt, controller.signal)) {
+    switch (event.type) {
+      case "text-delta":
+        process.stdout.write(event.text);
+        break;
+      case "tool-call":
+        process.stderr.write(`
+[tool] ${event.name} ${JSON.stringify(event.args)}
+`);
+        break;
+      case "tool-result": {
+        const preview = event.content.length > 500 ? `${event.content.slice(0, 500)}... (truncated)` : event.content;
+        process.stderr.write(`[result] ${event.isError ? "ERROR: " : ""}${preview}
+`);
+        break;
+      }
+      case "finish":
+        if (event.usage) {
+          requests += 1;
+          promptTokens += event.usage.promptTokens;
+          completionTokens += event.usage.completionTokens;
+          totalTokens += event.usage.totalTokens;
+        }
+        break;
+      case "error":
+        process.stderr.write(`
+[error] ${event.error.message}
+`);
+        exitCode = 1;
+        break;
+    }
+    if (exitCode !== 0) break;
+  }
+  if (requests > 0) {
+    process.stderr.write(
+      `[usage] ${requests} requests, ${promptTokens} prompt + ${completionTokens} completion = ${totalTokens} tokens
+`
+    );
+  }
+  process.stdout.write("\n");
+  return exitCode;
+}
+var program = new Command();
+program.name("star").description("Star CLI \u2014 an AI agent command-line interface").version("0.1.0").option("-m, --model <model>", "model to use").option("--permission-mode <mode>", "permission mode: auto | ask | readonly").option("-p, --print <prompt>", "non-interactive print mode").option("-r, --resume <sessionId>", "resume a previous session").action(async (opts) => {
+  const cwd = process.cwd();
+  let config;
+  try {
+    config = loadConfigSync(cwd, { model: opts.model, permissionMode: opts.permissionMode });
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+  const modelName = opts.model ?? config.defaultModel;
+  if (!modelName) {
+    console.error(
+      "No model configured. Add one to ~/.star-cli/config.toml or pass --model.\nSee README.md for configuration examples."
+    );
+    process.exit(1);
+  }
+  let sessionStore = null;
+  let resumed = null;
+  if (opts.resume) {
+    resumed = await resumeSession(opts.resume);
+    if (!resumed) {
+      console.error(`Session not found: ${opts.resume}`);
+      process.exit(1);
+    }
+    sessionStore = await SessionStore.open(opts.resume);
+  } else if (!opts.print) {
+    sessionStore = await SessionStore.create(cwd, modelName);
+  }
+  let loop;
+  try {
+    loop = await createLoop(config, modelName, cwd, sessionStore);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+  if (resumed) {
+    await loop.loadMessages(resumed.messages);
+  }
+  if (opts.print) {
+    process.exitCode = await printMode(loop, opts.print);
+    return;
+  }
+  renderRepl(loop, {
+    model: modelName,
+    permissionMode: config.permissionMode,
+    config,
+    cwd,
+    sessionStore,
+    initialMessages: resumed?.messages,
+    initialUsage: resumed?.meta.usage
+  });
+});
+program.parse(process.argv);
+//# sourceMappingURL=main.js.map