@cryer/star-cli 0.3.6 → 0.3.7

package/dist/chunk-4X25DNTF.js

@@ -0,0 +1,1441 @@
+#!/usr/bin/env node
+import {
+  SKIP_DIRS,
+  createIgnorePredicate,
+  downsampleImageIfNeeded,
+  envFilePath,
+  isSensitivePath,
+  pruneTreeReposExcept,
+  removeTreeRepo,
+  sessionsDir,
+  wrapFetchWithActivity
+} from "./chunk-OOOW7FC4.js";
+
+// src/cli/cost.ts
+function formatDollars(cost) {
+  let s = cost.toFixed(4).replace(/0+$/, "");
+  if (s.endsWith(".")) {
+    s += "00";
+  } else if (s.split(".")[1]?.length === 1) {
+    s += "0";
+  }
+  return s;
+}
+function formatTokens(n) {
+  if (!Number.isFinite(n)) return String(n);
+  if (n < 1e3) return String(n);
+  if (n < 1e6) return `${(n / 1e3).toFixed(2)}K`;
+  return `${(n / 1e6).toFixed(2)}M`;
+}
+function computeCostUsd(usage, model) {
+  if (model?.promptPrice === void 0 || model.completionPrice === void 0) {
+    return null;
+  }
+  const cached = Math.min(Math.max(usage.cachedPromptTokens ?? 0, 0), usage.promptTokens);
+  const promptUsd = (usage.promptTokens - cached) * model.promptPrice + cached * (model.cacheReadPrice ?? model.promptPrice) + (usage.cacheReadInputTokens ?? 0) * (model.cacheReadPrice ?? 0);
+  return (promptUsd + usage.completionTokens * model.completionPrice) / 1e6;
+}
+function estimateCost(usage, modelName, model) {
+  const cost = computeCostUsd(usage, model);
+  if (cost === null) {
+    if (model !== void 0) {
+      const missing = [
+        model.promptPrice === void 0 ? "promptPrice" : null,
+        model.completionPrice === void 0 ? "completionPrice" : null
+      ].filter((f) => f !== null);
+      if (missing.length === 1) {
+        return `Estimated cost: unknown (${model.name} is missing ${missing[0]} \u2014 both prices are needed)`;
+      }
+    }
+    return `Estimated cost: unknown (no price configured for ${modelName})`;
+  }
+  const cachePrice = model?.cacheReadPrice !== void 0 ? `, $${model.cacheReadPrice}/M cache read` : "";
+  return `Estimated cost: $${formatDollars(cost)} (${model?.name} @ $${model?.promptPrice}/M prompt, $${model?.completionPrice}/M completion${cachePrice})`;
+}
+
+// src/cli/terminal-text.ts
+var UNSAFE_CHARS = /[\x00-\x09\x0b-\x1f\x7f]/;
+var CONTROL_CHARS = /[\x00-\x08\x0b-\x1f\x7f]/g;
+var TABS = /\t/g;
+function toTerminalSafe(text) {
+  if (!UNSAFE_CHARS.test(text)) return text;
+  return text.replace(TABS, "  ").replace(CONTROL_CHARS, "");
+}
+
+// src/cli/markdown.ts
+var ESC = "\x1B[";
+var RESET = `${ESC}0m`;
+function styled(open, text, base) {
+  const reopen = base ? `${ESC}${base}m` : "";
+  return `${ESC}${open}m${text}${RESET}${reopen}`;
+}
+var bold = (t, b) => styled("1", t, b);
+var dim = (t, b) => styled("2", t, b);
+var italic = (t, b) => styled("3", t, b);
+var underline = (t, b) => styled("4", t, b);
+var strike = (t, b) => styled("9", t, b);
+var yellow = (t, b) => styled("33", t, b);
+var cyanBold = (t, b) => styled("1;36", t, b);
+function cellWidth(text) {
+  let width = 0;
+  for (const ch of text) {
+    const cp = ch.codePointAt(0) ?? 0;
+    if (cp >= 768 && cp <= 879 || cp === 8205 || cp >= 65024 && cp <= 65039) {
+      continue;
+    }
+    if (cp >= 4352 && cp <= 4447 || cp >= 11904 && cp <= 40959 || cp >= 40960 && cp <= 42191 || cp >= 44032 && cp <= 55203 || cp >= 63744 && cp <= 64255 || cp >= 65072 && cp <= 65103 || cp >= 65280 && cp <= 65376 || cp >= 65504 && cp <= 65510 || cp >= 126976 && cp <= 129791 || cp >= 131072 && cp <= 262141) {
+      width += 2;
+    } else {
+      width += 1;
+    }
+  }
+  return width;
+}
+var IMAGE_RE = /!\[([^\]]*)\]\(([^)\s]+)\)/g;
+var LINK_RE = /\[([^\]]+)\]\(([^)\s]+)\)/g;
+var BOLD_RE = /\*\*([^*\n]+)\*\*|__([^_\n]+)__/g;
+var STRIKE_RE = /~~([^~\n]+)~~/g;
+var STAR_ITALIC_RE = /\*([^*\n]+)\*/g;
+var UNDERSCORE_ITALIC_RE = /(^|[^\w])_([^_\n]+)_(?=[^\w]|$)/g;
+function renderInline(text, base = "") {
+  return text.split(/`([^`\n]+)`/).map((segment, index) => {
+    if (index % 2 === 1) return yellow(segment, base);
+    return segment.replace(IMAGE_RE, (_m, alt) => dim(`[image: ${alt}]`, base)).replace(
+      LINK_RE,
+      (_m, label, url) => `${underline(label, base)}${dim(` (${url})`, base)}`
+    ).replace(BOLD_RE, (_m, star, under) => bold(star ?? under, base)).replace(STRIKE_RE, (_m, t) => strike(t, base)).replace(STAR_ITALIC_RE, (_m, t) => italic(t, base)).replace(UNDERSCORE_ITALIC_RE, (_m, pre, t) => pre + italic(t, base));
+  }).join("");
+}
+var HEADING_RE = /^#{1,6}\s+(.*)$/;
+var HR_RE = /^\s{0,3}(?:-{3,}|\*{3,}|_{3,})\s*$/;
+var QUOTE_RE = /^\s{0,3}>\s?(.*)$/;
+var FENCE_RE = /^\s{0,3}(```+|~~~+)/;
+var TABLE_SEPARATOR_CELL_RE = /^:?-{3,}:?$/;
+function isTableSeparator(line) {
+  const cells = splitTableRow(line);
+  return cells !== null && cells.length > 0 && cells.every((cell) => TABLE_SEPARATOR_CELL_RE.test(cell.trim()));
+}
+function splitTableRow(line) {
+  const trimmed = line.trim();
+  if (!trimmed.includes("|")) return null;
+  const stripped = trimmed.replace(/^\|/, "").replace(/\|$/, "");
+  return stripped.split("|").map((cell) => cell.trim());
+}
+var MIN_COLUMN_WIDTH = 4;
+function wrapCell(text, width) {
+  const lines = [];
+  let current = "";
+  let currentWidth = 0;
+  for (const ch of text) {
+    const w = cellWidth(ch);
+    if (currentWidth > 0 && currentWidth + w > width) {
+      const lastSpace = current.lastIndexOf(" ");
+      if (lastSpace > 0 && ch !== " ") {
+        lines.push(current.slice(0, lastSpace));
+        current = current.slice(lastSpace + 1) + ch;
+      } else {
+        lines.push(current);
+        current = ch === " " ? "" : ch;
+      }
+      currentWidth = cellWidth(current);
+    } else {
+      current += ch;
+      currentWidth += w;
+    }
+  }
+  if (current.length > 0 || lines.length === 0) lines.push(current);
+  return lines;
+}
+function renderTable(lines, base, maxWidth) {
+  const rows = [];
+  for (const line of lines) {
+    const cells = splitTableRow(line);
+    if (cells) rows.push(cells);
+  }
+  if (rows.length < 2) return lines;
+  const columnCount = Math.max(...rows.map((row) => row.length));
+  const widths = Array.from(
+    { length: columnCount },
+    (_, column) => Math.max(1, ...rows.map((row) => cellWidth(row[column] ?? "")))
+  );
+  const totalWidth = () => 2 + widths.reduce((sum, width) => sum + width, 0) + 3 * (columnCount - 1);
+  while (totalWidth() > maxWidth) {
+    const widest = widths.indexOf(Math.max(...widths));
+    if (widths[widest] === void 0 || widths[widest] <= MIN_COLUMN_WIDTH) break;
+    widths[widest] -= 1;
+  }
+  const joiner = ` ${dim("\u2502", base)} `;
+  const formatRow = (row, style) => {
+    const wrapped = widths.map((width, column) => wrapCell(row[column] ?? "", width));
+    const height = Math.max(...wrapped.map((cell) => cell.length));
+    const out = [];
+    for (let line = 0; line < height; line++) {
+      out.push(
+        `  ${widths.map((width, column) => {
+          const raw = wrapped[column]?.[line] ?? "";
+          return style(raw) + " ".repeat(Math.max(0, width - cellWidth(raw)));
+        }).join(joiner).trimEnd()}`
+      );
+    }
+    return out;
+  };
+  const separator = dim(`  ${widths.map((width) => "\u2500".repeat(width)).join("\u2500\u253C\u2500")}`, base);
+  const [header, , ...body] = rows;
+  return [
+    ...formatRow(header, (cell) => bold(cell, base)),
+    separator,
+    ...body.flatMap((row, index) => {
+      const lines2 = formatRow(row, (cell) => renderInline(cell, base));
+      return index < body.length - 1 ? [...lines2, separator] : lines2;
+    })
+  ];
+}
+function committableLineCount(lines) {
+  let inFence = false;
+  let safe = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (FENCE_RE.test(line)) inFence = !inFence;
+    const isPipe = line.includes("|");
+    const nextIsPipe = i + 1 >= lines.length || (lines[i + 1] ?? "").includes("|");
+    if (!inFence && !(isPipe && nextIsPipe)) safe = i + 1;
+  }
+  return safe;
+}
+function renderMarkdown(text, base = "", maxWidth = 80) {
+  const lines = text.split("\n");
+  const out = [];
+  let inFence = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (inFence) {
+      if (FENCE_RE.test(line)) {
+        inFence = false;
+      } else {
+        out.push(`${dim("  \u258E", base)}${line}`);
+      }
+      continue;
+    }
+    const fence = FENCE_RE.exec(line);
+    if (fence) {
+      inFence = true;
+      const lang = line.trim().slice(fence[1]?.length ?? 0).trim();
+      if (lang) out.push(dim(`  \u258E ${lang}`, base));
+      continue;
+    }
+    const heading = HEADING_RE.exec(line);
+    if (heading) {
+      out.push(cyanBold(heading[1] ?? "", base));
+      continue;
+    }
+    if (HR_RE.test(line)) {
+      out.push(dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500", base));
+      continue;
+    }
+    const quote = QUOTE_RE.exec(line);
+    if (quote) {
+      out.push(`${dim("  \u258E", base)}${italic(renderInline(quote[1] ?? "", base), base)}`);
+      continue;
+    }
+    const headerCells = splitTableRow(line);
+    if (headerCells && i + 1 < lines.length && isTableSeparator(lines[i + 1] ?? "")) {
+      const block = [line];
+      let j = i + 1;
+      while (j < lines.length && splitTableRow(lines[j] ?? "") !== null) {
+        block.push(lines[j] ?? "");
+        j += 1;
+      }
+      out.push(...renderTable(block, base, maxWidth));
+      i = j - 1;
+      continue;
+    }
+    out.push(renderInline(line, base));
+  }
+  return out.join("\n");
+}
+
+// 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 formatByteCount(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+function formatElapsedSeconds(seconds) {
+  const total = Math.max(0, Math.floor(seconds));
+  if (total < 60) return `${total}s`;
+  const minutes = Math.floor(total / 60);
+  const secs = total % 60;
+  if (minutes < 60) return `${minutes}m${secs}s`;
+  return `${Math.floor(minutes / 60)}h${minutes % 60}m${secs}s`;
+}
+function splitCommittableLines(text, minCompleteLines) {
+  const lastNewline = text.lastIndexOf("\n");
+  if (lastNewline < 0) return null;
+  const complete = text.slice(0, lastNewline);
+  const lines = complete.split("\n");
+  const count = committableLineCount(lines);
+  if (count < minCompleteLines) return null;
+  const committed = lines.slice(0, count).join("\n");
+  return { committed, rest: text.slice(committed.length + 1) };
+}
+function formatStreamError(error) {
+  if (error.message.includes("Unexpected end of JSON input")) {
+    return `${error.message} (response stream was truncated \u2014 try again)`;
+  }
+  return error.message;
+}
+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: toTerminalSafe(text) });
+      } else {
+        collapsed++;
+      }
+    } else if (message.role === "tool") {
+      collapsed++;
+    }
+  }
+  if (collapsed > 0) {
+    display.push({
+      id: display.length,
+      role: "system",
+      text: `Restored ${collapsed} history message(s) not shown here.`
+    });
+  }
+  return display;
+}
+
+// src/cli/mentions.ts
+import { readFile, readdir, stat } from "fs/promises";
+import path from "path";
+var MAX_MENTION_BYTES = 100 * 1024;
+var MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+var MAX_DIR_MENTION_ENTRIES = 200;
+var MAX_DIR_MENTION_DEPTH = 10;
+var MAX_DIR_MENTION_TOTAL = 5e3;
+var IMAGE_MIME_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp"
+};
+function imageMimeType(filePath) {
+  return IMAGE_MIME_TYPES[path.extname(filePath).toLowerCase()] ?? null;
+}
+async function readImageInput(filePath, cwd) {
+  const mimeType = imageMimeType(filePath);
+  if (!mimeType) return null;
+  const abs = path.resolve(cwd, filePath);
+  const st = await stat(abs).catch(() => null);
+  if (!st || !st.isFile() || st.size > MAX_IMAGE_BYTES) return null;
+  const buf = await readFile(abs).catch(() => null);
+  if (!buf) return null;
+  const result = await downsampleImageIfNeeded({
+    path: filePath,
+    mimeType,
+    data: buf.toString("base64")
+  });
+  return result.image;
+}
+var MENTION_RE = /(?<=^|\s)@([A-Za-z]:[\\/][A-Za-z0-9._\-/\\\u2e80-\u9fff\uac00-\ud7af\uf900-\ufaff\uff00-\uffef]*|[A-Za-z0-9._\-/\\\u2e80-\u9fff\uac00-\ud7af\uf900-\ufaff\uff00-\uffef]+)/g;
+function parseMentions(text) {
+  const mentions = [];
+  const seen = /* @__PURE__ */ new Set();
+  const ranges = [];
+  for (const match of text.matchAll(MENTION_RE)) {
+    const mention = match[1];
+    const full = match[0];
+    if (mention === void 0 || full === void 0) continue;
+    ranges.push([match.index, match.index + full.length]);
+    if (!seen.has(mention)) {
+      seen.add(mention);
+      mentions.push(mention);
+    }
+  }
+  if (ranges.length === 0) {
+    return { cleanText: text, mentions };
+  }
+  let clean = "";
+  let last = 0;
+  for (const [start, end] of ranges) {
+    clean += text.slice(last, start);
+    last = end;
+  }
+  clean += text.slice(last);
+  const cleanText = clean.replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+  return { cleanText, mentions };
+}
+function isBinaryContent(buf) {
+  const probe = buf.subarray(0, 8e3);
+  return probe.includes(0);
+}
+async function listDirEntries(dir, prefix, depth, state, ignore) {
+  if (state.capped) return;
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => null);
+  if (!entries) return;
+  const visible = entries.filter((entry) => entry.isDirectory() || entry.isFile()).filter((entry) => !(entry.isDirectory() && SKIP_DIRS.has(entry.name))).filter((entry) => !isSensitivePath(entry.name)).filter((entry) => !ignore?.(path.join(dir, entry.name), entry.isDirectory())).sort((a, b) => {
+    const dirDiff = Number(b.isDirectory()) - Number(a.isDirectory());
+    return dirDiff !== 0 ? dirDiff : a.name.localeCompare(b.name);
+  });
+  for (let i = 0; i < visible.length; i++) {
+    if (state.total >= MAX_DIR_MENTION_TOTAL) {
+      state.capped = true;
+      return;
+    }
+    const entry = visible[i];
+    if (!entry) continue;
+    state.total += 1;
+    const last = i === visible.length - 1;
+    const isDir = entry.isDirectory();
+    if (state.shown < MAX_DIR_MENTION_ENTRIES) {
+      state.shown += 1;
+      state.lines.push(`${prefix}${last ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 "}${entry.name}${isDir ? "/" : ""}`);
+      if (isDir && depth < MAX_DIR_MENTION_DEPTH) {
+        await listDirEntries(
+          path.join(dir, entry.name),
+          `${prefix}${last ? "    " : "\u2502   "}`,
+          depth + 1,
+          state,
+          ignore
+        );
+      }
+    } else if (isDir && depth < MAX_DIR_MENTION_DEPTH) {
+      await listDirEntries(path.join(dir, entry.name), prefix, depth + 1, state, ignore);
+    }
+  }
+}
+async function directoryBlock(abs, mention, ignore) {
+  const display = `${mention.replace(/\\/g, "/").replace(/\/+$/, "")}/`;
+  const state = { lines: [`${display}`], shown: 0, total: 0, capped: false };
+  const probe = await readdir(abs).catch(() => null);
+  if (!probe) return null;
+  await listDirEntries(abs, "", 1, state, ignore);
+  if (state.capped) {
+    state.lines.push("... (truncated, many more entries)");
+  } else if (state.total > state.shown) {
+    state.lines.push(
+      `... (truncated, ${state.total - state.shown} more entries \u2014 use glob/grep tools or mention a subdirectory to see more)`
+    );
+  }
+  return `--- @${display} (directory) ---
+${state.lines.join("\n")}
+--- end ---`;
+}
+async function resolveMentions(text, cwd) {
+  const { cleanText, mentions } = parseMentions(text);
+  if (mentions.length === 0) {
+    return { input: text, attached: [], skipped: [], images: [] };
+  }
+  const blocks = [];
+  const attached = [];
+  const skipped = [];
+  const images = [];
+  let ignore;
+  for (const mention of mentions) {
+    const abs = path.resolve(cwd, mention);
+    if (isSensitivePath(abs)) {
+      skipped.push({ path: mention, reason: "sensitive file" });
+      continue;
+    }
+    const mimeType = imageMimeType(mention);
+    if (mimeType) {
+      const st2 = await stat(abs).catch(() => null);
+      if (!st2 || !st2.isFile()) {
+        skipped.push({ path: mention, reason: st2 ? "is a directory" : "file not found" });
+        continue;
+      }
+      if (st2.size > MAX_IMAGE_BYTES) {
+        skipped.push({ path: mention, reason: "image too large" });
+        continue;
+      }
+      const buf2 = await readFile(abs).catch(() => null);
+      if (!buf2) {
+        skipped.push({ path: mention, reason: "unreadable" });
+        continue;
+      }
+      const result = await downsampleImageIfNeeded({
+        path: mention,
+        mimeType,
+        data: buf2.toString("base64")
+      });
+      attached.push(mention);
+      images.push(result.image);
+      continue;
+    }
+    const st = await stat(abs).catch(() => null);
+    if (!st) {
+      skipped.push({ path: mention, reason: "file not found" });
+      continue;
+    }
+    if (st.isDirectory()) {
+      if (ignore === void 0) {
+        ignore = createIgnorePredicate(cwd) ?? null;
+      }
+      const block = await directoryBlock(abs, mention, ignore ?? void 0);
+      if (!block) {
+        skipped.push({ path: mention, reason: "unreadable" });
+        continue;
+      }
+      attached.push(mention);
+      blocks.push(block);
+      continue;
+    }
+    if (st.size > MAX_MENTION_BYTES) {
+      skipped.push({ path: mention, reason: `exceeds ${MAX_MENTION_BYTES / 1024}KB limit` });
+      continue;
+    }
+    const buf = await readFile(abs).catch(() => null);
+    if (!buf) {
+      skipped.push({ path: mention, reason: "unreadable" });
+      continue;
+    }
+    if (isBinaryContent(buf)) {
+      skipped.push({ path: mention, reason: "binary file" });
+      continue;
+    }
+    attached.push(mention);
+    blocks.push(`--- @${mention} ---
+${buf.toString("utf8")}
+--- end ---`);
+  }
+  const input = [cleanText, ...blocks].filter((s) => s.length > 0).join("\n\n") || text;
+  return { input, attached, skipped, images };
+}
+
+// src/cli/system-prompt.ts
+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.
+For any task with two or more steps, start by creating a todo list with todo_write and keep it updated as you progress; only mark an item completed after you have verified its result.
+The working directory is the user's project root; never touch files outside it without explicit instruction.
+For conversion, batch-processing, or other scriptable tasks, write a script file into the working directory and run it instead of pasting long inline code into the shell; once the script's output is verified, delete the script unless the user asked to keep it.
+When a tool call or command fails, read the error output, work out the cause, and try again with a corrected or alternative approach \u2014 never repeat an identical failing call without changing something.
+Never consider the task finished until you have verified the result yourself: run the tests, the build, or a check command that proves the output is correct, and if verification fails or reveals gaps, keep fixing until it passes.
+Do not end your turn while the task is still incomplete; keep going until it is done or you are genuinely blocked, and if you are blocked, state exactly what is missing.
+Never end a reply by announcing what you will do next \u2014 either do it now with tool calls, or do not mention it. Narrating future actions is not progress.`;
+
+// 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
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+
+// src/llm/sse-normalize.ts
+function splitJsonPrefix(text) {
+  if (!text.startsWith("{")) return null;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === "{") depth += 1;
+    else if (ch === "}") {
+      depth -= 1;
+      if (depth === 0) return [text.slice(0, i + 1), text.slice(i + 1).trimStart()];
+    }
+  }
+  return null;
+}
+var SseNormalizeTransform = class extends TransformStream {
+  constructor() {
+    let buffer = "";
+    let pending = null;
+    const flushPending = (controller) => {
+      if (pending === null) return;
+      controller.enqueue(`data: ${pending}
+
+`);
+      pending = null;
+    };
+    const emitPayload = (payload, controller) => {
+      let rest = payload;
+      for (; ; ) {
+        const split = splitJsonPrefix(rest);
+        if (!split) {
+          pending = rest;
+          return;
+        }
+        const [json, tail] = split;
+        if (tail === "") {
+          pending = json;
+          return;
+        }
+        controller.enqueue(`data: ${json}
+
+`);
+        if (tail.startsWith("data:")) {
+          rest = tail.slice(5).replace(/^ /, "");
+          continue;
+        }
+        if (tail.startsWith("{")) {
+          rest = tail;
+          continue;
+        }
+        controller.enqueue(`${tail}
+`);
+        return;
+      }
+    };
+    const handleLine = (raw, controller) => {
+      const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+      if (line === "") {
+        flushPending(controller);
+        return;
+      }
+      if (line.startsWith("data:")) {
+        flushPending(controller);
+        emitPayload(line.slice(5).replace(/^ /, ""), controller);
+        return;
+      }
+      if (line.startsWith("{") && pending !== null) {
+        flushPending(controller);
+        emitPayload(line, controller);
+        return;
+      }
+      flushPending(controller);
+      controller.enqueue(`${line}
+`);
+    };
+    super({
+      transform(chunk, controller) {
+        buffer += chunk;
+        let index = buffer.indexOf("\n");
+        while (index !== -1) {
+          handleLine(buffer.slice(0, index), controller);
+          buffer = buffer.slice(index + 1);
+          index = buffer.indexOf("\n");
+        }
+      },
+      flush(controller) {
+        if (buffer.length > 0) handleLine(buffer, controller);
+        flushPending(controller);
+      }
+    });
+  }
+};
+function createSseNormalizingFetch(baseFetch = fetch) {
+  return async (input, init) => {
+    const response = await baseFetch(input, init);
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!response.body || !contentType.includes("text/event-stream")) {
+      return response;
+    }
+    const body = response.body.pipeThrough(new TextDecoderStream()).pipeThrough(new SseNormalizeTransform()).pipeThrough(new TextEncoderStream());
+    const headers = new Headers(response.headers);
+    headers.delete("content-length");
+    headers.delete("content-encoding");
+    return new Response(body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  };
+}
+
+// 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);
+  const trackedFetch = wrapFetchWithActivity();
+  switch (provider.protocol) {
+    case "anthropic":
+      return createAnthropic({
+        baseURL: provider.baseURL,
+        apiKey,
+        headers: provider.headers,
+        fetch: trackedFetch
+      })(modelConfig.model);
+    case "openai-compatible":
+      return createOpenAICompatible({
+        name: provider.name,
+        baseURL: provider.baseURL,
+        apiKey,
+        headers: provider.headers,
+        fetch: trackedFetch
+      })(modelConfig.model, {}, { includeUsage: true });
+    case "openai-responses":
+      return createOpenAI({
+        baseURL: provider.baseURL,
+        apiKey,
+        headers: provider.headers,
+        // Relays fronting the Responses API sometimes batch several JSON
+        // events into one SSE data payload, which the SDK's parser cannot
+        // read; normalize the wire format back to one event per data line.
+        fetch: createSseNormalizingFetch(trackedFetch)
+      }).responses(modelConfig.model);
+  }
+}
+function reasoningEffortMetadata(config, modelName) {
+  const modelConfig = resolveModelConfig(config, modelName);
+  if (!modelConfig.reasoningEffort) return void 0;
+  const provider = config.providers.find((p) => p.name === modelConfig.provider);
+  if (!provider || provider.protocol === "anthropic") return void 0;
+  const key = provider.protocol === "openai-responses" ? "openai" : provider.name;
+  return { [key]: { reasoningEffort: modelConfig.reasoningEffort } };
+}
+
+// src/session/checkpoints.ts
+import fs from "fs/promises";
+import path2 from "path";
+function checkpointsDir(sessionDir) {
+  return path2.join(sessionDir, "checkpoints");
+}
+function indexPath(sessionDir) {
+  return path2.join(checkpointsDir(sessionDir), "index.json");
+}
+var indexWriteQueues = /* @__PURE__ */ new Map();
+function enqueueIndexWrite(sessionDir, op) {
+  const queued = indexWriteQueues.get(sessionDir) ?? Promise.resolve();
+  const run = queued.then(op);
+  indexWriteQueues.set(
+    sessionDir,
+    run.then(
+      () => {
+      },
+      () => {
+      }
+    )
+  );
+  return run;
+}
+function checkpointContentPath(sessionDir, id) {
+  return path2.join(checkpointsDir(sessionDir), `${id}.snapshot`);
+}
+async function listCheckpointRecords(sessionDir) {
+  let raw;
+  try {
+    raw = await fs.readFile(indexPath(sessionDir), "utf8");
+  } catch {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+async function appendCheckpointRecord(sessionDir, record, content) {
+  await enqueueIndexWrite(sessionDir, async () => {
+    await fs.mkdir(checkpointsDir(sessionDir), { recursive: true, mode: 448 });
+    if (record.existed && content !== null) {
+      await fs.writeFile(checkpointContentPath(sessionDir, record.id), content, "utf8");
+    }
+    const records = await listCheckpointRecords(sessionDir);
+    records.push(record);
+    await fs.writeFile(indexPath(sessionDir), JSON.stringify(records, null, 2));
+  });
+}
+async function removeCheckpointRecords(sessionDir, ids) {
+  if (ids.length === 0) return;
+  await enqueueIndexWrite(sessionDir, async () => {
+    const drop = new Set(ids);
+    const records = await listCheckpointRecords(sessionDir);
+    const kept = records.filter((record) => !drop.has(record.id));
+    if (kept.length === records.length) return;
+    await fs.mkdir(checkpointsDir(sessionDir), { recursive: true, mode: 448 });
+    await fs.writeFile(indexPath(sessionDir), JSON.stringify(kept, null, 2));
+    for (const id of ids) {
+      await fs.rm(checkpointContentPath(sessionDir, id), { force: true });
+    }
+  });
+}
+async function loadSessionSnapshots(sessionDir) {
+  const records = await listCheckpointRecords(sessionDir);
+  return records.map((record) => ({
+    ...record,
+    content: null,
+    contentFile: record.existed && !record.contentTooLarge ? checkpointContentPath(sessionDir, record.id) : void 0
+  }));
+}
+
+// src/session/store.ts
+import fs2 from "fs/promises";
+import path3 from "path";
+import { StringDecoder } from "string_decoder";
+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 debugWarn(message) {
+  if (process.env.STAR_DEBUG === "1") process.stderr.write(`[star-cli] ${message}
+`);
+}
+function warn(message) {
+  process.stderr.write(`[star-cli] ${message}
+`);
+}
+var FS_WRITE_MAX_ATTEMPTS = 5;
+var FS_WRITE_RETRY_DELAY_MS = 25;
+function isTransientFsError(error) {
+  const code = error.code;
+  return code === "EPERM" || code === "EACCES" || code === "EBUSY";
+}
+async function withTransientFsRetry(operation) {
+  let lastError;
+  for (let attempt = 0; attempt < FS_WRITE_MAX_ATTEMPTS; attempt++) {
+    try {
+      await operation();
+      return;
+    } catch (error) {
+      lastError = error;
+      if (isTransientFsError(error) && attempt + 1 < FS_WRITE_MAX_ATTEMPTS) {
+        await new Promise(
+          (resolve) => setTimeout(resolve, FS_WRITE_RETRY_DELAY_MS * (attempt + 1))
+        );
+      } else {
+        break;
+      }
+    }
+  }
+  throw lastError;
+}
+var FALLBACK_META = /* @__PURE__ */ Symbol("star.fallbackMeta");
+function isFallbackMeta(meta) {
+  return meta[FALLBACK_META] === true;
+}
+var META_FLUSH_INTERVAL_MS = 2e3;
+var MESSAGES_READ_CHUNK_BYTES = 64 * 1024;
+function dayKey(date) {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+var SessionStore = class _SessionStore {
+  id;
+  dir;
+  pendingMeta = null;
+  initialized = false;
+  cachedMeta = null;
+  metaTmpSeq = 0;
+  messagesTmpSeq = 0;
+  metaWriteQueue = Promise.resolve();
+  metaLastFlushAt = 0;
+  metaFlushTimer = null;
+  metaDirty = 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);
+    let raw;
+    try {
+      raw = await fs2.readFile(store.metaPath(), "utf8");
+    } catch {
+      return null;
+    }
+    try {
+      const meta = JSON.parse(raw);
+      if (meta.id !== id) return null;
+    } catch {
+      debugWarn(`session ${id}: corrupt meta.json, using defaults`);
+    }
+    await store.sweepTmpFiles();
+    store.initialized = true;
+    return store;
+  }
+  static async list(cwd) {
+    let entries;
+    try {
+      entries = await fs2.readdir(sessionsDir());
+    } catch {
+      return [];
+    }
+    const metas = await Promise.all(
+      entries.map(async (entry) => {
+        try {
+          const raw = await fs2.readFile(path3.join(sessionsDir(), entry, "meta.json"), "utf8");
+          const meta = JSON.parse(raw);
+          if (meta.id === entry && (cwd === void 0 || meta.cwd === cwd)) return meta;
+        } catch {
+        }
+        return null;
+      })
+    );
+    return metas.filter((meta) => meta !== null).sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+  // Meta writes are serialized per instance and land atomically (tmp file +
+  // rename) over a cached in-memory meta: the fire-and-forget title/usage
+  // writers race the loop's own appends, and a truncated read once turned
+  // fallbackMeta's empty defaults into a persisted wipe of model/cwd/usage.
+  // A branded fallback meta is never written back for the same reason.
+  // A write that still fails after retries is dropped rather than thrown:
+  // meta.json is bookkeeping the cached meta rebuilds on the next write,
+  // while the conversation itself lives in messages.jsonl — killing the
+  // agent turn over a stale updatedAt would be the wrong trade.
+  writeMeta(meta) {
+    if (isFallbackMeta(meta)) return Promise.resolve();
+    const tmp = `${this.metaPath()}.tmp-${process.pid}-${this.metaTmpSeq++}`;
+    const run = this.metaWriteQueue.then(async () => {
+      try {
+        await withTransientFsRetry(async () => {
+          await fs2.writeFile(tmp, JSON.stringify(meta, null, 2));
+          await fs2.rename(tmp, this.metaPath());
+        });
+      } catch (error) {
+        await fs2.unlink(tmp).catch(() => {
+        });
+        debugWarn(
+          `session ${this.id}: meta write failed (${error.code ?? String(error)}), skipping`
+        );
+      }
+    });
+    this.metaWriteQueue = run.catch(() => {
+    });
+    return run;
+  }
+  // Debounced flush for append-driven updatedAt bumps. The trailing timer is
+  // unref'd so a pending flush never keeps the process alive; close() flushes
+  // synchronously on a clean exit, and a hard exit simply drops the trailing
+  // bump — meta is bookkeeping.
+  markMetaDirty() {
+    this.metaDirty = true;
+    if (this.metaFlushTimer) return;
+    const delay = Math.max(0, META_FLUSH_INTERVAL_MS - (Date.now() - this.metaLastFlushAt));
+    if (delay === 0) {
+      void this.flushMetaIfDirty();
+      return;
+    }
+    this.metaFlushTimer = setTimeout(() => {
+      this.metaFlushTimer = null;
+      void this.flushMetaIfDirty();
+    }, delay);
+    this.metaFlushTimer.unref();
+  }
+  async flushMetaIfDirty() {
+    if (!this.metaDirty) return;
+    await this.flushMetaNow();
+  }
+  // Immediate flush for substantive meta changes; cancels a pending debounced
+  // flush, which the write makes redundant either way (it serializes the live
+  // cached meta).
+  async flushMetaNow() {
+    if (this.metaFlushTimer) {
+      clearTimeout(this.metaFlushTimer);
+      this.metaFlushTimer = null;
+    }
+    this.metaDirty = false;
+    this.metaLastFlushAt = Date.now();
+    if (this.cachedMeta) await this.writeMeta(this.cachedMeta);
+  }
+  // Flushes a pending debounced meta write and waits for in-flight writes to
+  // settle; call when the store is dropped so a clean exit keeps the trailing
+  // updatedAt bump.
+  async close() {
+    await this.flushMetaIfDirty();
+    await this.metaWriteQueue;
+  }
+  async ensureInitialized() {
+    if (this.initialized) return;
+    const pending = this.pendingMeta;
+    if (!pending) {
+      this.initialized = true;
+      return;
+    }
+    await fs2.mkdir(this.dir, { recursive: true, mode: 448 });
+    await this.sweepTmpFiles();
+    const meta = {
+      id: this.id,
+      title: "",
+      model: pending.model,
+      cwd: pending.cwd,
+      createdAt: pending.createdAt,
+      updatedAt: pending.createdAt
+    };
+    await this.writeMeta(meta);
+    this.cachedMeta = meta;
+    this.metaLastFlushAt = Date.now();
+    this.initialized = true;
+  }
+  // Removes tmp orphans left behind by crashed atomic writes (both meta.json
+  // and messages.jsonl write tmp file + rename); best-effort, the directory
+  // may not even exist yet.
+  async sweepTmpFiles() {
+    let entries;
+    try {
+      entries = await fs2.readdir(this.dir);
+    } catch {
+      return;
+    }
+    await Promise.all(
+      entries.filter(
+        (entry) => entry.startsWith("meta.json.tmp-") || entry.startsWith("messages.jsonl.tmp-")
+      ).map((entry) => fs2.unlink(path3.join(this.dir, entry)).catch(() => {
+      }))
+    );
+  }
+  async append(message) {
+    await this.ensureInitialized();
+    try {
+      await withTransientFsRetry(
+        () => fs2.appendFile(this.messagesPath(), `${JSON.stringify(message)}
+`)
+      );
+    } catch (error) {
+      warn(
+        `session ${this.id}: message append failed (${error.code ?? String(error)}), message kept in memory only`
+      );
+    }
+    const meta = await this.meta();
+    meta.updatedAt = Date.now();
+    this.markMetaDirty();
+  }
+  async replaceMessages(messages) {
+    await this.ensureInitialized();
+    const content = messages.map((message) => JSON.stringify(message)).join("\n");
+    const tmp = `${this.messagesPath()}.tmp-${process.pid}-${this.messagesTmpSeq++}`;
+    try {
+      await withTransientFsRetry(async () => {
+        await fs2.writeFile(tmp, content ? `${content}
+` : "");
+        await fs2.rename(tmp, this.messagesPath());
+      });
+    } catch (error) {
+      await fs2.unlink(tmp).catch(() => {
+      });
+      warn(
+        `session ${this.id}: history rewrite failed (${error.code ?? String(error)}), kept the previous messages.jsonl`
+      );
+    }
+    const meta = await this.meta();
+    meta.updatedAt = Date.now();
+    await this.flushMetaNow();
+  }
+  async messages() {
+    let handle = null;
+    try {
+      handle = await fs2.open(this.messagesPath(), "r");
+      const messages = [];
+      const decoder = new StringDecoder("utf8");
+      const buffer = Buffer.alloc(MESSAGES_READ_CHUNK_BYTES);
+      let tail = "";
+      const pushLine = (line) => {
+        const trimmed = line.trim();
+        if (!trimmed) return;
+        try {
+          messages.push(JSON.parse(trimmed));
+        } catch {
+          debugWarn(`session ${this.id}: skipping corrupt messages.jsonl line`);
+        }
+      };
+      while (true) {
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, null);
+        if (bytesRead === 0) break;
+        const chunk = tail + decoder.write(buffer.subarray(0, bytesRead));
+        const lines = chunk.split("\n");
+        tail = lines.pop() ?? "";
+        for (const line of lines) pushLine(line);
+      }
+      pushLine(tail + decoder.end());
+      return messages;
+    } catch {
+      return [];
+    } finally {
+      await handle?.close().catch(() => {
+      });
+    }
+  }
+  fallbackMeta() {
+    const now = Date.now();
+    const meta = {
+      id: this.id,
+      title: "",
+      model: "",
+      cwd: "",
+      createdAt: now,
+      updatedAt: now
+    };
+    Object.defineProperty(meta, FALLBACK_META, { value: true, enumerable: false });
+    return meta;
+  }
+  async meta() {
+    await this.ensureInitialized();
+    if (this.cachedMeta) return this.cachedMeta;
+    try {
+      const raw = await fs2.readFile(this.metaPath(), "utf8");
+      this.cachedMeta = JSON.parse(raw);
+      return this.cachedMeta;
+    } catch {
+      debugWarn(`session ${this.id}: unreadable meta.json, using defaults`);
+      return this.fallbackMeta();
+    }
+  }
+  async setTitle(title) {
+    await this.ensureInitialized();
+    const meta = await this.meta();
+    meta.title = title;
+    meta.updatedAt = Date.now();
+    await this.flushMetaNow();
+  }
+  // /model swaps the live loop mid-session; keep the recorded model in sync
+  // or the session list and /usage attribute the whole session to whichever
+  // model happened to be active at creation.
+  async setModel(model) {
+    await this.ensureInitialized();
+    const meta = await this.meta();
+    meta.model = model;
+    meta.updatedAt = Date.now();
+    await this.flushMetaNow();
+  }
+  async appendCheckpoint(record, content) {
+    await this.ensureInitialized();
+    await appendCheckpointRecord(this.dir, record, content);
+  }
+  async listCheckpoints() {
+    return listCheckpointRecords(this.dir);
+  }
+  async removeCheckpoints(ids) {
+    await removeCheckpointRecords(this.dir, ids);
+  }
+  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;
+    if (delta.cachedPromptTokens) {
+      usage.cachedPromptTokens = (usage.cachedPromptTokens ?? 0) + delta.cachedPromptTokens;
+    }
+    if (delta.cacheReadInputTokens) {
+      usage.cacheReadInputTokens = (usage.cacheReadInputTokens ?? 0) + delta.cacheReadInputTokens;
+    }
+    meta.usage = usage;
+    const day = dayKey(/* @__PURE__ */ new Date());
+    const byDay = meta.usageByDay ?? {};
+    const bucket = byDay[day] ?? { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+    bucket.promptTokens += delta.promptTokens;
+    bucket.completionTokens += delta.completionTokens;
+    bucket.totalTokens += delta.totalTokens;
+    byDay[day] = bucket;
+    meta.usageByDay = byDay;
+    await this.flushMetaNow();
+  }
+};
+
+// src/session/clear.ts
+import fs3 from "fs/promises";
+import path4 from "path";
+async function clearSessions(cwd, excludeId) {
+  if (cwd !== void 0) {
+    const metas = await SessionStore.list(cwd);
+    let removed2 = 0;
+    for (const meta of metas) {
+      if (meta.id === excludeId) continue;
+      await fs3.rm(path4.join(sessionsDir(), meta.id), { recursive: true, force: true });
+      removed2 += 1;
+    }
+    if ((await SessionStore.list(cwd)).length === 0) {
+      await removeTreeRepo(cwd);
+    }
+    return removed2;
+  }
+  let entries;
+  try {
+    entries = await fs3.readdir(sessionsDir());
+  } catch {
+    return 0;
+  }
+  let removed = 0;
+  for (const entry of entries) {
+    if (entry === excludeId) continue;
+    await fs3.rm(path4.join(sessionsDir(), entry), { recursive: true, force: true });
+    removed += 1;
+  }
+  const survivors = await SessionStore.list();
+  await pruneTreeReposExcept(survivors.map((meta) => meta.cwd));
+  return removed;
+}
+
+// src/session/list.ts
+import fs4 from "fs/promises";
+import path5 from "path";
+var COUNT_CHUNK_BYTES = 64 * 1024;
+async function countMessages(id) {
+  let handle = null;
+  try {
+    handle = await fs4.open(path5.join(sessionsDir(), id, "messages.jsonl"), "r");
+    const buffer = Buffer.alloc(COUNT_CHUNK_BYTES);
+    let count = 0;
+    let lineHasContent = false;
+    while (true) {
+      const { bytesRead } = await handle.read(buffer, 0, COUNT_CHUNK_BYTES, null);
+      if (bytesRead === 0) break;
+      for (const byte of buffer.subarray(0, bytesRead)) {
+        if (byte === 10) {
+          if (lineHasContent) count += 1;
+          lineHasContent = false;
+        } else if (byte !== 13 && byte !== 32 && byte !== 9) {
+          lineHasContent = true;
+        }
+      }
+    }
+    if (lineHasContent) count += 1;
+    return count;
+  } catch {
+    return 0;
+  } finally {
+    await handle?.close().catch(() => {
+    });
+  }
+}
+async function listSessionEntries(cwd) {
+  const metas = await SessionStore.list(cwd);
+  return Promise.all(
+    metas.map(async (meta) => ({ meta, messageCount: await countMessages(meta.id) }))
+  );
+}
+async function findLatestSession(cwd) {
+  const [latest] = await SessionStore.list(cwd);
+  return latest ?? null;
+}
+async function sessionPreview(id, maxBytes = 4096) {
+  let handle = null;
+  try {
+    handle = await fs4.open(path5.join(sessionsDir(), id, "messages.jsonl"), "r");
+    const buffer = Buffer.alloc(maxBytes);
+    const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0);
+    const head = buffer.toString("utf8", 0, bytesRead);
+    for (const line of head.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const message = JSON.parse(trimmed);
+        if (message.role !== "user") continue;
+        const text = typeof message.content === "string" ? message.content : message.content.filter((part) => part.type === "text").map((part) => part.type === "text" ? part.text : "").join(" ");
+        const collapsed = text.replace(/\s+/g, " ").trim();
+        if (collapsed) return collapsed;
+      } catch {
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    await handle?.close().catch(() => {
+    });
+  }
+}
+function shortSessionId(id) {
+  const dash = id.lastIndexOf("-");
+  return dash === -1 ? id : id.slice(dash + 1);
+}
+async function resolveSessionId(query) {
+  const metas = await SessionStore.list();
+  const exact = metas.find((meta) => meta.id === query);
+  if (exact) return exact.id;
+  const matches = metas.filter(
+    (meta) => shortSessionId(meta.id) === query || meta.id.startsWith(query)
+  );
+  return matches.length === 1 ? matches[0]?.id ?? null : null;
+}
+function relativeTime(timestamp) {
+  const diff = Date.now() - timestamp;
+  const minutes = Math.floor(diff / 6e4);
+  if (minutes < 1) return "just now";
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  if (days < 30) return `${days}d ago`;
+  const months = Math.floor(days / 30);
+  if (months < 12) return `${months}mo ago`;
+  return `${Math.floor(months / 12)}y ago`;
+}
+function formatSessionEntries(entries, options = {}) {
+  return entries.map(({ meta, messageCount }) => {
+    const title = meta.title || "(untitled)";
+    const base = `${shortSessionId(meta.id)}  ${title}  ${messageCount} messages  updated ${relativeTime(meta.updatedAt)}`;
+    return options.showCwd ? `${base}  [${meta.cwd}]` : base;
+  }).join("\n");
+}
+
+// src/version.ts
+import fs5 from "fs";
+import path6 from "path";
+import { fileURLToPath } from "url";
+function readPackageVersion() {
+  try {
+    const pkgPath = path6.join(path6.dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+    const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf8"));
+    if (typeof pkg === "object" && pkg !== null) {
+      const version = pkg.version;
+      if (typeof version === "string") return version;
+    }
+  } catch {
+  }
+  return "0.0.0";
+}
+var VERSION = readPackageVersion();
+
+// src/config/env.ts
+import fs6 from "fs";
+var ENV_KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function parseEnvContent(content) {
+  const vars = {};
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const key = line.slice(0, eq).trim();
+    if (!ENV_KEY_PATTERN.test(key)) continue;
+    let value = line.slice(eq + 1).trim();
+    if (value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    vars[key] = value;
+  }
+  return vars;
+}
+function loadEnvFile(filePath = envFilePath()) {
+  let content;
+  try {
+    content = fs6.readFileSync(filePath, "utf8");
+  } catch {
+    return;
+  }
+  for (const [key, value] of Object.entries(parseEnvContent(content))) {
+    if (process.env[key] === void 0) {
+      process.env[key] = value;
+    }
+  }
+}
+function upsertEnvContent(content, key, value) {
+  const entry = `${key}=${value.replace(/[\r\n]/g, "")}`;
+  const pattern = new RegExp(`^\\s*${key}\\s*=`);
+  const lines = content.split("\n");
+  while (lines.length > 0 && (lines[lines.length - 1] ?? "").trim() === "") lines.pop();
+  for (let i = 0; i < lines.length; i++) {
+    if (pattern.test(lines[i] ?? "")) {
+      lines[i] = entry;
+      return `${lines.join("\n")}
+`;
+    }
+  }
+  lines.push(entry);
+  return `${lines.join("\n")}
+`;
+}
+
+export {
+  formatDollars,
+  formatTokens,
+  computeCostUsd,
+  estimateCost,
+  renderMarkdown,
+  toTerminalSafe,
+  summarizeArgs,
+  previewLines,
+  formatByteCount,
+  formatElapsedSeconds,
+  splitCommittableLines,
+  formatStreamError,
+  coreMessageText,
+  buildDisplayMessages,
+  MAX_IMAGE_BYTES,
+  imageMimeType,
+  readImageInput,
+  resolveMentions,
+  SYSTEM_PROMPT,
+  loadEnvFile,
+  upsertEnvContent,
+  listModels,
+  resolveModelConfig,
+  createModel,
+  reasoningEffortMetadata,
+  loadSessionSnapshots,
+  SessionStore,
+  clearSessions,
+  listSessionEntries,
+  findLatestSession,
+  sessionPreview,
+  shortSessionId,
+  resolveSessionId,
+  relativeTime,
+  formatSessionEntries,
+  VERSION
+};
+//# sourceMappingURL=chunk-4X25DNTF.js.map