@cryer/star-cli 0.3.3 → 0.3.5

package/dist/{loop-TQ7GFTTE.js → loop-H5RYTO2O.js}

@@ -2,10 +2,10 @@
 import {
   AgentLoop,
   PLAN_MODE_PROMPT
-} from "./chunk-3L6QKJM4.js";
+} from "./chunk-OIDB2E5J.js";
 import "./chunk-B6P4VUBE.js";
 export {
   AgentLoop,
   PLAN_MODE_PROMPT
 };
-//# sourceMappingURL=loop-TQ7GFTTE.js.map
+//# sourceMappingURL=loop-H5RYTO2O.js.map

package/dist/main.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import {
   AgentLoop,
+  ConfigSchema,
   MAX_IMAGE_DIMENSION,
   SKIP_DIRS,
   TodoStore,
@@ -13,6 +14,7 @@ import {
   collectCommitContext,
   collectWorkingDiff,
   compactMessages,
+  contextWindowTokens,
   createDefaultRegistry,
   createIgnorePredicate,
   defaultAgentTasks,
@@ -20,6 +22,7 @@ import {
   diffTreeNames,
   discoverSkills,
   estimateTokens,
+  formatAgentTaskUpdate,
   formatTaskFinished,
   formatTaskList,
   formatTaskStarted,
@@ -41,7 +44,7 @@ import {
   resolveSnapshotContent,
   rewindToSnapshot,
   summarizeMessages
-} from "./chunk-3L6QKJM4.js";
+} from "./chunk-OIDB2E5J.js";
 import {
   envFilePath,
   globalConfigPath,
@@ -598,113 +601,6 @@ async function savePermissionMode(mode) {
   await writeFileAtomic(filePath, upsertTopLevelKeyText(content, "permissionMode", mode));
 }
 
-// src/config/schema.ts
-import { z } from "zod";
-var ProviderConfigSchema = z.object({
-  name: z.string(),
-  // openai-responses talks to the Responses API (/responses) instead of chat
-  // completions — the wire format codex uses, and the native API of
-  // reasoning-model relays that otherwise hide reasoning behind empty chat
-  // completions. streamChat sends strictSchemas:false + store:false with it.
-  protocol: z.enum(["openai-compatible", "anthropic", "openai-responses"]).default("openai-compatible"),
-  baseURL: z.string(),
-  apiKeyEnv: z.string().optional(),
-  apiKey: z.string().optional(),
-  headers: z.record(z.string()).optional()
-});
-var ModelConfigSchema = z.object({
-  name: z.string(),
-  provider: z.string(),
-  model: z.string(),
-  maxTokens: z.number().int().positive().optional(),
-  // Per-model context window; overrides the top-level contextMaxTokens for
-  // compaction and the status bar when set.
-  contextMaxTokens: z.number().int().positive().optional(),
-  // Cost estimation needs BOTH prices (USD per 1M tokens); with only one set
-  // the model is treated as unpriced.
-  promptPrice: z.number().nonnegative().optional(),
-  completionPrice: z.number().nonnegative().optional(),
-  // Optional price (USD per 1M tokens) for cache-read prompt tokens. When
-  // unset, OpenAI-style cached tokens bill at promptPrice and Anthropic-style
-  // cache reads are not billed — set this for accurate cache pricing.
-  cacheReadPrice: z.number().nonnegative().optional()
-});
-var PermissionsConfigSchema = z.object({
-  allow: z.array(z.string()).default([]),
-  deny: z.array(z.string()).default([])
-});
-var HookConfigSchema = z.object({
-  event: z.enum(["PreToolUse", "PostToolUse", "Stop"]),
-  matcher: z.string().refine(
-    (pattern) => {
-      try {
-        new RegExp(pattern);
-        return true;
-      } catch {
-        return false;
-      }
-    },
-    { message: "invalid regular expression" }
-  ).optional(),
-  command: z.string().min(1),
-  timeoutSec: z.number().positive().default(30)
-});
-var ConfigSchema = z.object({
-  defaultModel: z.string().default(""),
-  permissionMode: z.enum(["auto", "ask", "readonly", "yolo", "plan"]).default("ask"),
-  providers: z.array(ProviderConfigSchema).default([]),
-  models: z.array(ModelConfigSchema).default([]),
-  maxSteps: z.number().int().positive().default(50),
-  contextMaxTokens: z.number().int().positive().default(1e5),
-  // Seconds without any stream part before a stalled response is ended
-  // gracefully (some relays never send the terminal chunks). Applies once
-  // streaming has started; the first part gets a longer, fixed allowance.
-  streamIdleTimeoutSec: z.number().positive().default(20),
-  // Seconds to wait for the very first stream part before giving up; slow
-  // thinking-model relays can buffer for minutes before sending anything.
-  streamFirstChunkTimeoutSec: z.number().positive().default(300),
-  // Extra attempts per model request when a stream fails transiently
-  // (network error, 429/5xx, idle watchdog cutoff) or comes back empty, so a
-  // relay hiccup does not silently end a half-finished turn. 0 disables.
-  // The wait between attempts honors Retry-After headers and otherwise backs
-  // off exponentially with jitter (llm/retry.ts); retries after a
-  // timeout/empty failure also scale both stream timeouts up (attempt number
-  // ×, capped at 3x) since the relay is likely overloaded.
-  streamMaxRetries: z.number().int().min(0).default(3),
-  // How many consecutive unproductive replies may be nudged before the turn
-  // is handed back: a text-only reply that announces pending work ("我将…",
-  // "I will…") or answers a nudge with more words, or an empty reply that
-  // survived the stream retry budget (steered with a nudge — a changed
-  // request — since identical resends already failed). Tool calls reset the
-  // count, so a productive task keeps going; exhaustion surfaces a notice
-  // instead of stopping silently. Never fires in plan mode. 0 disables.
-  maxAutoContinues: z.number().int().min(0).default(2),
-  contextCompaction: z.enum(["summary", "truncate"]).default("summary"),
-  // Optional per-session dollar budget; when set, the REPL stops the session
-  // once the estimated cost for the session reaches this amount.
-  sessionBudgetUsd: z.number().positive().optional(),
-  // Terminal bell (REPL only): ring when a turn takes longer than
-  // notifyBellThresholdSec, and when a background task finishes.
-  // STAR_NO_NOTIFY=1 disables without touching the config.
-  notifyBell: z.boolean().default(true),
-  notifyBellThresholdSec: z.number().positive().default(10),
-  permissions: PermissionsConfigSchema.default({ allow: [], deny: [] }),
-  hooks: z.array(HookConfigSchema).default([]),
-  // Consecutive identical tool calls (same tool + same arguments) allowed
-  // before the loop refuses to execute the repeat and tells the model to
-  // change approach — a guard against agents stuck retrying a failing call
-  // (opencode's doom_loop). 0 disables.
-  doomLoopThreshold: z.number().int().min(0).default(3),
-  // Track the whole working tree with an internal git repo (outside the
-  // user's .git) at every turn boundary, so /undo and /redo can restore
-  // changes made by ANY tool (bash included), not just write_file/edit_file.
-  // Falls back silently to per-file snapshots when git is unavailable.
-  gitSnapshots: z.boolean().default(true)
-});
-function contextWindowTokens(config, modelName) {
-  return config.models.find((m) => m.name === modelName)?.contextMaxTokens ?? config.contextMaxTokens;
-}
-
 // src/llm/provider.ts
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { createOpenAI } from "@ai-sdk/openai";
@@ -931,6 +827,12 @@ function debugWarn(message) {
   if (process.env.STAR_DEBUG === "1") process.stderr.write(`[star-cli] ${message}
 `);
 }
+var META_WRITE_MAX_ATTEMPTS = 5;
+var META_WRITE_RETRY_DELAY_MS = 25;
+function isTransientFsError(error) {
+  const code = error.code;
+  return code === "EPERM" || code === "EACCES" || code === "EBUSY";
+}
 var FALLBACK_META = /* @__PURE__ */ Symbol("star.fallbackMeta");
 function isFallbackMeta(meta) {
   return meta[FALLBACK_META] === true;
@@ -1005,17 +907,33 @@ var SessionStore = class _SessionStore {
   // 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 fs3.writeFile(tmp, JSON.stringify(meta, null, 2));
-        await fs3.rename(tmp, this.metaPath());
-      } catch (error) {
-        await fs3.unlink(tmp).catch(() => {
-        });
-        throw error;
+      for (let attempt = 0; attempt < META_WRITE_MAX_ATTEMPTS; attempt++) {
+        try {
+          await fs3.writeFile(tmp, JSON.stringify(meta, null, 2));
+          await fs3.rename(tmp, this.metaPath());
+          return;
+        } catch (error) {
+          if (isTransientFsError(error) && attempt + 1 < META_WRITE_MAX_ATTEMPTS) {
+            await new Promise(
+              (resolve) => setTimeout(resolve, META_WRITE_RETRY_DELAY_MS * (attempt + 1))
+            );
+            continue;
+          }
+          await fs3.unlink(tmp).catch(() => {
+          });
+          debugWarn(
+            `session ${this.id}: meta write failed (${error.code ?? String(error)}), skipping`
+          );
+          return;
+        }
       }
     });
     this.metaWriteQueue = run.catch(() => {
@@ -1688,10 +1606,10 @@ async function compactSession(opts) {
     };
   }
   const beforeTokens = estimateTokens(messages);
-  const compacted = compactMessages(messages, config.contextMaxTokens);
+  const compacted = compactMessages(messages, config.contextMaxTokens, { force: true });
   if (!compacted.compacted) {
     return {
-      message: `Nothing to compact: ~${beforeTokens} estimated tokens, below the limit of ${config.contextMaxTokens}.`,
+      message: `Nothing to compact: history is too short to drop a whole turn (~${beforeTokens} estimated tokens).`,
       compacted: false
     };
   }
@@ -5003,11 +4921,7 @@ function Repl({
     };
     const onAgentUpdate = (task) => {
       setBgLabels(runningTaskLabels());
-      const label = task.description ? `: ${toTerminalSafe(task.description)}` : "";
-      pushMessage(
-        "system",
-        task.status === "running" ? `Background subagent ${task.id} started${label}` : `Background subagent ${task.id} ${task.status}${label}`
-      );
+      pushMessage("system", toTerminalSafe(formatAgentTaskUpdate(task)));
       if (task.status !== "running") {
         notifyBell({
           enabled: configRef.current.notifyBell,
@@ -5638,18 +5552,26 @@ ${estimateCost(usageRef.current, modelNameRef.current, modelConfig)}`;
         } catch {
           summaryModel = null;
         }
-        const result = await compactSession({
-          backend: backendRef.current,
-          sessionStore: sessionStoreRef.current,
-          config,
-          model: summaryModel
-        });
-        if (result.compacted && result.messages) {
-          const display = buildDisplayMessages(result.messages);
-          nextIdRef.current = display.length;
-          applyMessages(display);
+        tickerStopRef.current = startTicker((tick) => setSpinnerTick(tick));
+        setActivity("compacting context\u2026");
+        try {
+          const result = await compactSession({
+            backend: backendRef.current,
+            sessionStore: sessionStoreRef.current,
+            config,
+            model: summaryModel
+          });
+          if (result.compacted && result.messages) {
+            const display = buildDisplayMessages(result.messages);
+            nextIdRef.current = display.length;
+            applyMessages(display);
+          }
+          return result.message;
+        } finally {
+          tickerStopRef.current?.();
+          tickerStopRef.current = null;
+          setActivity(null);
         }
-        return result.message;
       },
       exportSession: (arg) => exportSession({
         backend: backendRef.current,
@@ -5819,8 +5741,9 @@ ${plan.affected.length} file change(s) will be reverted, ${messageCount} message
         `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}`,
+        `maxSteps: ${config.maxSteps === 0 ? "unlimited" : config.maxSteps}`,
         `contextMaxTokens: ${config.contextMaxTokens}`,
+        `compactThresholdTokens: ${config.compactThresholdTokens ?? "(context window)"}`,
         `streamIdleTimeoutSec: ${config.streamIdleTimeoutSec}`,
         `streamFirstChunkTimeoutSec: ${config.streamFirstChunkTimeoutSec}`,
         `streamMaxRetries: ${config.streamMaxRetries}`,
@@ -6099,6 +6022,7 @@ var PROJECT_ALLOWED_KEYS = /* @__PURE__ */ new Set([
   "models",
   "maxSteps",
   "contextMaxTokens",
+  "compactThresholdTokens",
   "streamIdleTimeoutSec",
   "streamFirstChunkTimeoutSec",
   "streamMaxRetries",