@wrongstack/core 0.5.6 → 0.6.0

package/dist/execution/index.js

@@ -1,5 +1,8 @@
+import { execFile } from 'child_process';
+import { promisify } from 'util';
 import * as fs from 'fs/promises';
 import * as path from 'path';
+import { randomBytes } from 'crypto';
 
 // src/utils/token-estimate.ts
 var RoughTokenEstimate = (text) => Math.max(1, Math.ceil(text.length / 4));
@@ -1414,6 +1417,14 @@ var DoneConditionChecker = class {
           };
         }
         break;
+      case "directive":
+        if (this.condition.maxIterations && state.iterations >= this.condition.maxIterations) {
+          return { done: true, reason: `max iterations (${this.condition.maxIterations}) reached`, ...state };
+        }
+        if (this.condition.maxToolCalls && state.toolCalls >= this.condition.maxToolCalls) {
+          return { done: true, reason: `max tool calls (${this.condition.maxToolCalls}) reached`, ...state };
+        }
+        break;
     }
     return { done: false, iterations: state.iterations, toolCalls: state.toolCalls };
   }
@@ -1433,10 +1444,16 @@ var AutonomousRunner = class {
     const offToolExecuted = this.opts.agent.events?.on?.("tool.executed", () => {
       this.toolCalls++;
     });
+    const offIterationCompleted = this.opts.agent.events?.on?.("iteration.completed", () => {
+      if (this.opts.enableAutonomousContinue && this.opts.doneCondition.type === "directive") {
+        this.iterations++;
+      }
+    });
     try {
       return await this.runLoop();
     } finally {
       offToolExecuted?.();
+      offIterationCompleted?.();
     }
   }
   async runLoop() {
@@ -1460,12 +1477,14 @@ var AutonomousRunner = class {
       const ctrl = new AbortController();
       const timeout = setTimeout(() => ctrl.abort(), this.opts.iterationTimeoutMs ?? 3e4);
       try {
+        const isDirectiveMode = this.opts.doneCondition.type === "directive" && this.opts.enableAutonomousContinue;
         const result = await this.opts.agent.run("", {
           signal: ctrl.signal,
-          maxIterations: 1,
-          executionStrategy: "sequential"
+          maxIterations: isDirectiveMode ? this.opts.doneCondition.maxIterations ?? 100 : 1,
+          executionStrategy: "sequential",
+          autonomousContinue: isDirectiveMode ? true : void 0
         });
-        this.iterations++;
+        if (!isDirectiveMode) this.iterations++;
         if (result.status === "done") {
           this.lastOutput = result.finalText;
         }
@@ -1517,6 +1536,456 @@ var AutonomousRunner = class {
     this.stopped = true;
   }
 };
+async function atomicWrite(targetPath, content, opts = {}) {
+  const dir = path.dirname(targetPath);
+  await fs.mkdir(dir, { recursive: true });
+  const tmp = path.join(dir, `.${path.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
+  try {
+    if (typeof content === "string") {
+      await fs.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
+    } else {
+      await fs.writeFile(tmp, content, { flag: "wx" });
+    }
+    try {
+      const fh = await fs.open(tmp, "r+");
+      try {
+        await fh.sync();
+      } finally {
+        await fh.close();
+      }
+    } catch {
+    }
+    let mode;
+    try {
+      const stat2 = await fs.stat(targetPath);
+      mode = stat2.mode & 511;
+    } catch {
+      mode = opts.mode;
+    }
+    if (mode !== void 0) {
+      await fs.chmod(tmp, mode);
+    }
+    await renameWithRetry(tmp, targetPath);
+  } catch (err) {
+    try {
+      await fs.unlink(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+var TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
+async function renameWithRetry(from, to) {
+  if (process.platform !== "win32") {
+    await fs.rename(from, to);
+    return;
+  }
+  const delays = [10, 25, 60, 120, 250];
+  let lastErr;
+  for (let i = 0; i <= delays.length; i++) {
+    try {
+      await fs.rename(from, to);
+      return;
+    } catch (err) {
+      lastErr = err;
+      const code = err?.code;
+      if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
+        throw err;
+      }
+      await new Promise((resolve) => setTimeout(resolve, delays[i]));
+    }
+  }
+  throw lastErr;
+}
+
+// src/storage/goal-store.ts
+var MAX_JOURNAL_ENTRIES = 500;
+function goalFilePath(projectRoot) {
+  return path.join(projectRoot, ".wrongstack", "goal.json");
+}
+async function loadGoal(filePath) {
+  let raw;
+  try {
+    raw = await fs.readFile(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed?.version !== 1 || typeof parsed.goal !== "string" || !Array.isArray(parsed.journal)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function saveGoal(filePath, goal) {
+  await atomicWrite(filePath, JSON.stringify(goal, null, 2), { mode: 384 });
+}
+function appendJournal(goal, entry) {
+  const iteration = goal.iterations + 1;
+  const at = (/* @__PURE__ */ new Date()).toISOString();
+  const full = { ...entry, iteration, at };
+  const journal = [...goal.journal, full];
+  const trimmed = journal.length > MAX_JOURNAL_ENTRIES ? journal.slice(journal.length - MAX_JOURNAL_ENTRIES) : journal;
+  return {
+    ...goal,
+    iterations: iteration,
+    lastActivityAt: at,
+    journal: trimmed
+  };
+}
+
+// src/execution/eternal-autonomy.ts
+var execFileP = promisify(execFile);
+var EternalAutonomyEngine = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.goalPath = goalFilePath(opts.projectRoot);
+  }
+  opts;
+  state = "idle";
+  stopRequested = false;
+  consecutiveFailures = 0;
+  currentCtrl = null;
+  iterationsSinceCompact = 0;
+  goalPath;
+  /** Current engine state — readable for UIs. */
+  get currentState() {
+    return this.state;
+  }
+  /** Synchronously request stop. Resolves once the running iteration aborts. */
+  stop() {
+    this.stopRequested = true;
+    this.currentCtrl?.abort();
+    void this.persistEngineState("stopped").catch(() => {
+    });
+    this.state = "stopped";
+  }
+  /**
+   * Mark the engine as 'running' on disk + reset stop state so a new
+   * batch of `runOneIteration()` calls can proceed. Called by the REPL
+   * when the user invokes `/autonomy eternal`. Idempotent.
+   */
+  async prime() {
+    this.stopRequested = false;
+    this.state = "running";
+    await this.persistEngineState("running").catch(() => {
+    });
+  }
+  /**
+   * Main loop. Returns when stop() is called or the goal file is removed.
+   * Does NOT throw — every iteration is wrapped to keep the loop alive.
+   */
+  async run() {
+    this.state = "running";
+    await this.persistEngineState("running");
+    try {
+      while (!this.stopRequested) {
+        let iterationOk = false;
+        try {
+          iterationOk = await this.runOneIteration();
+        } catch (err) {
+          this.consecutiveFailures++;
+          this.opts.onError?.(err instanceof Error ? err : new Error(String(err)), this.consecutiveFailures);
+          await this.appendFailure("engine error", err instanceof Error ? err.message : String(err));
+        }
+        if (iterationOk) {
+          this.consecutiveFailures = 0;
+        }
+        if (this.stopRequested) break;
+        await sleep(this.opts.cycleGapMs ?? 1e3);
+      }
+    } finally {
+      this.state = "stopped";
+      await this.persistEngineState("stopped").catch(() => {
+      });
+    }
+  }
+  /**
+   * Execute a single sense-decide-execute-reflect cycle.
+   * Returns true on success, false on handled failure / no-op.
+   *
+   * Exposed publicly so the REPL can pace iterations from its main loop
+   * — running the engine and the REPL as a single sequential consumer of
+   * `agent.run()` avoids race conditions on the shared Context.
+   */
+  async runOneIteration() {
+    const goal = await loadGoal(this.goalPath);
+    if (!goal) {
+      this.stopRequested = true;
+      return false;
+    }
+    const action = await this.decide(goal);
+    if (!action) {
+      await sleep(5e3);
+      return false;
+    }
+    const ctrl = new AbortController();
+    this.currentCtrl = ctrl;
+    const timer = setTimeout(
+      () => ctrl.abort(),
+      this.opts.iterationTimeoutMs ?? 5 * 6e4
+    );
+    let status = "success";
+    let note;
+    const tc = this.opts.agent.ctx?.tokenCounter;
+    const beforeUsage = tc?.total?.();
+    const beforeCost = tc?.estimateCost?.().total;
+    try {
+      const result = await this.opts.agent.run(
+        [{ type: "text", text: action.directive }],
+        { signal: ctrl.signal }
+      );
+      if (result.status === "aborted") {
+        status = "aborted";
+        note = "stopped by user";
+      } else if (result.status === "failed") {
+        status = "failure";
+        note = result.error?.describe?.() ?? "agent run failed";
+      } else if (result.status === "max_iterations") {
+        status = "failure";
+        note = `max iterations (${result.iterations})`;
+      } else {
+        status = "success";
+        const tail = (result.finalText ?? "").slice(0, 240).replace(/\s+/g, " ").trim();
+        if (tail) note = tail;
+      }
+    } catch (err) {
+      const isAbort = err instanceof Error && (err.name === "AbortError" || err.message.includes("abort"));
+      status = isAbort ? "aborted" : "failure";
+      note = err instanceof Error ? err.message : String(err);
+    } finally {
+      clearTimeout(timer);
+      this.currentCtrl = null;
+    }
+    const afterUsage = tc?.total?.();
+    const afterCost = tc?.estimateCost?.().total;
+    const tokens = beforeUsage && afterUsage ? {
+      input: Math.max(0, afterUsage.input - beforeUsage.input),
+      output: Math.max(0, afterUsage.output - beforeUsage.output)
+    } : void 0;
+    const costUsd = typeof beforeCost === "number" && typeof afterCost === "number" ? Math.max(0, afterCost - beforeCost) : void 0;
+    await this.appendIterationEntry({
+      source: action.source,
+      task: action.task,
+      status,
+      note,
+      tokens,
+      costUsd
+    });
+    let iterationIndex = 0;
+    try {
+      const reloaded = await loadGoal(this.goalPath);
+      iterationIndex = reloaded?.iterations ?? 0;
+    } catch {
+    }
+    this.opts.onIteration?.({
+      at: (this.opts.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
+      iteration: iterationIndex,
+      source: action.source,
+      task: action.task,
+      status,
+      note,
+      tokens,
+      costUsd
+    });
+    if (status === "failure") {
+      this.consecutiveFailures++;
+      return false;
+    }
+    if (status === "aborted") {
+      if (this.stopRequested) return false;
+      this.consecutiveFailures++;
+      return false;
+    }
+    this.iterationsSinceCompact++;
+    await this.maybeCompact().catch((err) => {
+      this.opts.onError?.(
+        err instanceof Error ? err : new Error(String(err)),
+        this.consecutiveFailures
+      );
+    });
+    return true;
+  }
+  /**
+   * Run compaction when either trigger fires:
+   *   - We've done >= compactEveryNIterations since the last compact.
+   *   - Current request tokens exceed aggressiveCompactRatio * maxContext.
+   *
+   * The second check uses *aggressive* mode to free more headroom; the
+   * cadence check uses non-aggressive (cheaper).
+   */
+  async maybeCompact() {
+    const compactor = this.opts.compactor;
+    if (!compactor) return;
+    const ctx = this.opts.agent.ctx;
+    if (!ctx) return;
+    const cadence = this.opts.compactEveryNIterations ?? 25;
+    const threshold = this.opts.aggressiveCompactRatio ?? 0.85;
+    const maxCtx = this.opts.maxContextTokens;
+    let aggressive = false;
+    let shouldRun = false;
+    if (this.iterationsSinceCompact >= cadence) {
+      shouldRun = true;
+    }
+    if (maxCtx && maxCtx > 0) {
+      const used = ctx.tokenCounter?.currentRequestTokens?.();
+      if (used) {
+        const total = used.input + used.cacheRead;
+        if (total / maxCtx >= threshold) {
+          shouldRun = true;
+          aggressive = true;
+        }
+      }
+    }
+    if (!shouldRun) return;
+    const report = await compactor.compact(ctx, { aggressive });
+    this.iterationsSinceCompact = 0;
+    const saved = report.before - report.after;
+    await this.appendIterationEntry({
+      source: "manual",
+      task: `compaction (${aggressive ? "aggressive" : "cadence"})`,
+      status: "success",
+      note: `saved ~${saved} tokens (${report.before}\u2192${report.after})`
+    });
+  }
+  /**
+   * Hybrid idea source.
+   *   1. Pending todos on the agent's context.
+   *   2. Dirty git working tree → propose a "review and finish this" task.
+   *   3. Otherwise: brainstorm via the LLM against the goal.
+   *
+   * After failureBudget consecutive failures, force brainstorm so the
+   * engine doesn't loop on the same broken todo or stuck git state.
+   */
+  async decide(goal) {
+    const forceBrainstorm = this.consecutiveFailures >= (this.opts.failureBudget ?? 3);
+    if (!forceBrainstorm) {
+      const todo = this.pickPendingTodo();
+      if (todo) {
+        return {
+          source: "todo",
+          task: todo.content,
+          directive: this.buildDirective(goal, "todo", todo.content)
+        };
+      }
+      const gitTask = await this.pickGitTask();
+      if (gitTask) {
+        return {
+          source: "git",
+          task: gitTask,
+          directive: this.buildDirective(goal, "git", gitTask)
+        };
+      }
+    }
+    const brainstormed = await this.brainstormTask(goal);
+    if (!brainstormed) return null;
+    return {
+      source: "brainstorm",
+      task: brainstormed,
+      directive: this.buildDirective(goal, "brainstorm", brainstormed)
+    };
+  }
+  pickPendingTodo() {
+    const todos = this.opts.agent.ctx.todos;
+    if (!Array.isArray(todos)) return null;
+    return todos.find((t) => t.status === "pending") ?? null;
+  }
+  async pickGitTask() {
+    let out;
+    try {
+      out = await (this.opts.gitStatusReader?.() ?? this.readGitStatus());
+    } catch {
+      return null;
+    }
+    const dirty = out.trim();
+    if (!dirty) return null;
+    const lines = dirty.split("\n").slice(0, 8);
+    const preview = lines.join(", ");
+    return `Inspect the dirty working tree and either finish the in-progress work or revert it. Files: ${preview}`;
+  }
+  async readGitStatus() {
+    const { stdout } = await execFileP("git", ["status", "--porcelain"], {
+      cwd: this.opts.projectRoot,
+      timeout: 5e3
+    });
+    return stdout;
+  }
+  async brainstormTask(goal) {
+    const lastFew = goal.journal.slice(-5).map((e) => `  - [${e.status}] ${e.task}`).join("\n");
+    const directive = [
+      "You are deciding the next action in an autonomous loop pursuing a long-running goal.",
+      "",
+      `Goal: ${goal.goal}`,
+      "",
+      lastFew ? `Recent iterations:
+${lastFew}` : "No prior iterations yet.",
+      "",
+      "Output ONE concrete, immediately-actionable task that advances the goal.",
+      "Constraints:",
+      "- One sentence, imperative form, under 200 chars.",
+      "- No preamble, no explanation, no markdown \u2014 just the task line.",
+      "- If recent iterations show repeated failures on the same target, pivot.",
+      "- If the goal appears fully accomplished, output exactly: DONE"
+    ].join("\n");
+    try {
+      const ctrl = new AbortController();
+      const timer = setTimeout(() => ctrl.abort(), 6e4);
+      try {
+        const result = await this.opts.agent.run(
+          [{ type: "text", text: directive }],
+          { signal: ctrl.signal, maxIterations: 1 }
+        );
+        if (result.status !== "done") return null;
+        const text = (result.finalText ?? "").trim();
+        if (!text || text === "DONE") return null;
+        const firstLine = text.split("\n").find((l) => l.trim().length > 0)?.trim();
+        if (!firstLine) return null;
+        return firstLine.slice(0, 240);
+      } finally {
+        clearTimeout(timer);
+      }
+    } catch {
+      return null;
+    }
+  }
+  buildDirective(goal, source, task) {
+    return [
+      "[ETERNAL AUTONOMY \u2014 iteration directive]",
+      "",
+      `Goal: ${goal.goal}`,
+      `Source: ${source}`,
+      `Task: ${task}`,
+      "",
+      "Execute this task end-to-end using the tools available to you. Make the",
+      "changes, run tests if relevant, and commit / push as appropriate. Do not",
+      "ask for confirmation \u2014 YOLO mode is active. When the task is done, stop;",
+      "the loop will pick the next action."
+    ].join("\n");
+  }
+  async appendIterationEntry(entry) {
+    const current = await loadGoal(this.goalPath);
+    if (!current) {
+      return;
+    }
+    const updated = appendJournal(current, entry);
+    await saveGoal(this.goalPath, updated);
+  }
+  async appendFailure(task, note) {
+    await this.appendIterationEntry({ source: "manual", task, status: "failure", note });
+  }
+  async persistEngineState(state) {
+    const current = await loadGoal(this.goalPath);
+    if (!current) return;
+    if (current.engineState === state) return;
+    await saveGoal(this.goalPath, { ...current, engineState: state });
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
 // src/types/provider.ts
 var ProviderError = class extends WrongStackError {
@@ -1648,7 +2117,7 @@ function buildRecoveryStrategies(opts) {
       async attempt(err) {
         if (!(err instanceof ProviderError) || err.status !== 429) return null;
         const delayMs = err.body?.retryAfterMs ?? 5e3;
-        const delay = Math.max(1e3, Math.min(delayMs, 6e4));
+        const delay = Math.min(6e4, Math.max(1e3, delayMs));
         await new Promise((r) => setTimeout(r, delay));
         return { action: "retry", reason: "rate_limit_backoff" };
       }
@@ -1830,6 +2299,6 @@ function parseDescription(raw) {
   return { trigger, scope };
 }
 
-export { AutoCompactionMiddleware, AutonomousRunner, DefaultErrorHandler, DefaultRetryPolicy, DefaultSkillLoader, DoneConditionChecker, HybridCompactor, IntelligentCompactor, SelectiveCompactor, ToolExecutor };
+export { AutoCompactionMiddleware, AutonomousRunner, DefaultErrorHandler, DefaultRetryPolicy, DefaultSkillLoader, DoneConditionChecker, EternalAutonomyEngine, HybridCompactor, IntelligentCompactor, SelectiveCompactor, ToolExecutor };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map