@glrs-dev/cli 2.2.0 → 2.3.0

package/dist/vendor/harness-opencode/dist/chunk-NIFAVPNN.js

@@ -0,0 +1,544 @@
+import {
+  parsePlanState
+} from "./chunk-MJSMBY2Y.js";
+import {
+  createSession,
+  getLastAssistantMessage,
+  getSessionCost,
+  sendAndWait,
+  startServer
+} from "./chunk-GCWHRUOK.js";
+
+// src/autopilot/loop.ts
+import { execFile as execFileCb } from "child_process";
+import { promisify } from "util";
+import { readFileSync } from "fs";
+import { join as join3 } from "path";
+
+// src/lib/logger.ts
+import pino from "pino";
+import PinoPretty from "pino-pretty";
+import { existsSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+function resolveStderrLevel() {
+  const env = process.env["GLRS_LOG_LEVEL"];
+  if (env && ["fatal", "error", "warn", "info", "debug", "trace", "silent"].includes(env)) {
+    return env;
+  }
+  return "info";
+}
+function shouldPrettyPrint() {
+  if (process.env["GLRS_LOG_FORMAT"] === "json") return false;
+  if (process.env["GLRS_LOG_FORMAT"] === "pretty") return true;
+  return process.stderr.isTTY ?? false;
+}
+function resolveLogFilePath(cwd) {
+  const env = process.env["GLRS_AUTOPILOT_LOG_FILE"];
+  if (env === "off") return null;
+  if (env) return env;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  return join(cwd, ".agent", "autopilot-logs", `${timestamp}.log`);
+}
+function buildStderrStream(level) {
+  if (shouldPrettyPrint()) {
+    const pretty = PinoPretty({
+      colorize: true,
+      translateTime: "HH:MM:ss.l",
+      ignore: "pid,hostname,component",
+      messageFormat: "[{component}] {msg}",
+      destination: 2
+      // stderr
+    });
+    return { level, stream: pretty };
+  }
+  return {
+    level,
+    stream: pino.destination({ fd: 2, sync: false })
+  };
+}
+function buildFileStream(cwd) {
+  const filePath = resolveLogFilePath(cwd);
+  if (!filePath) return null;
+  const parent = dirname(filePath);
+  if (!existsSync(parent)) {
+    mkdirSync(parent, { recursive: true });
+  }
+  return {
+    path: filePath,
+    entry: {
+      level: "trace",
+      // sync: true gives deterministic flushSync semantics so the file
+      // log is safe to read immediately after flush() returns (critical
+      // for tests and for reliable postmortem after a crash). Autopilot
+      // runs are long-lived enough that sync writes aren't a bottleneck.
+      stream: pino.destination({ dest: filePath, sync: true, mkdir: true })
+    }
+  };
+}
+function createAutopilotLogger(opts) {
+  const stderrLevel = resolveStderrLevel();
+  const fileSink = buildFileStream(opts.cwd);
+  const streams = [buildStderrStream(stderrLevel)];
+  if (fileSink) streams.push(fileSink.entry);
+  const ms = pino.multistream(streams);
+  const root = pino(
+    {
+      level: "trace",
+      // router gate; individual streams apply their own levels
+      timestamp: pino.stdTimeFunctions.isoTime
+    },
+    ms
+  );
+  const flush = async () => {
+    try {
+      ms.flushSync();
+    } catch {
+    }
+  };
+  return {
+    root,
+    logFilePath: fileSink?.path ?? null,
+    flush
+  };
+}
+function childLogger(root, component) {
+  return root.child({ component });
+}
+
+// src/autopilot/status.ts
+function formatElapsed(ms) {
+  const totalSeconds = Math.floor(ms / 1e3);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) return `${hours}h ${minutes}m ${seconds}s`;
+  if (minutes > 0) return `${minutes}m ${seconds}s`;
+  return `${seconds}s`;
+}
+function formatCost(usd) {
+  if (usd === 0) return "$0.00";
+  return `$${usd.toFixed(3)}`;
+}
+function composeStatusMessage(state, now) {
+  const elapsed = formatElapsed(now - state.startedAt);
+  const cost = formatCost(state.cumulativeCostUsd);
+  const iterNote = state.iterationsCompleted === 0 ? "iteration 1 in flight" : `${state.iterationsCompleted} iteration${state.iterationsCompleted === 1 ? "" : "s"} complete`;
+  let planNote = "";
+  if (state.phaseCount !== void 0 && state.phasesCompleted !== void 0 && state.mainCheckboxesTotal !== void 0 && state.mainCheckboxesCompleted !== void 0) {
+    planNote = `, phase ${state.phasesCompleted}/${state.phaseCount}, ${state.mainCheckboxesCompleted}/${state.mainCheckboxesTotal} boxes`;
+  }
+  if (state.lastIterationErrored) {
+    return `working (${iterNote}, ${elapsed} elapsed, ${cost} used${planNote}) \u2014 last iteration errored`;
+  }
+  return `working (${iterNote}, ${elapsed} elapsed, ${cost} used${planNote})`;
+}
+function createStatusHeartbeat(opts) {
+  const now = opts._deps?.now ?? (() => Date.now());
+  const setIntervalFn = opts._deps?.setInterval ?? setInterval;
+  const clearIntervalFn = opts._deps?.clearInterval ?? clearInterval;
+  const state = {
+    startedAt: now(),
+    iterationsCompleted: 0,
+    cumulativeCostUsd: 0,
+    lastIterationProgress: false,
+    lastIterationErrored: false
+  };
+  let timerId = null;
+  const tick = () => {
+    if (opts.pollCost) {
+      opts.pollCost().then((cost) => {
+        if (cost > 0) state.cumulativeCostUsd = cost;
+      }).catch(() => {
+      });
+    }
+    const message = composeStatusMessage(state, now());
+    opts.logger.info(
+      {
+        elapsedMs: now() - state.startedAt,
+        iterationsCompleted: state.iterationsCompleted,
+        cumulativeCostUsd: state.cumulativeCostUsd,
+        lastIterationProgress: state.lastIterationProgress,
+        lastIterationErrored: state.lastIterationErrored
+      },
+      message
+    );
+  };
+  return {
+    start() {
+      if (timerId !== null) return;
+      timerId = setIntervalFn(tick, opts.intervalMs);
+    },
+    stop() {
+      if (timerId === null) return;
+      clearIntervalFn(timerId);
+      timerId = null;
+    },
+    update(patch) {
+      Object.assign(state, patch);
+    },
+    getState() {
+      return { ...state };
+    }
+  };
+}
+
+// src/autopilot/config.ts
+var MAX_ITERATIONS = 50;
+var STRUGGLE_THRESHOLD = 3;
+var TIMEOUT_MS = 4 * 60 * 60 * 1e3;
+var STALL_MS = 60 * 60 * 1e3;
+var KILL_SWITCH_PATH = ".agent/autopilot-disable";
+var SENTINEL_TAG = "<autopilot-done>";
+var STATUS_INTERVAL_MS = (() => {
+  const env = process.env["GLRS_AUTOPILOT_STATUS_INTERVAL_MS"];
+  if (!env) return 5 * 60 * 1e3;
+  const n = Number.parseInt(env, 10);
+  if (Number.isNaN(n) || n < 1e3 || n > 60 * 60 * 1e3) return 5 * 60 * 1e3;
+  return n;
+})();
+
+// src/autopilot/sentinel.ts
+function detectSentinel(text) {
+  if (!text.includes(SENTINEL_TAG)) {
+    return false;
+  }
+  const withoutFences = text.replace(/```[\s\S]*?```/g, "");
+  const withoutInline = withoutFences.replace(/`[^`\n]*`/g, "");
+  return withoutInline.includes(SENTINEL_TAG);
+}
+
+// src/autopilot/struggle.ts
+import * as fs from "fs";
+import * as path from "path";
+var StruggleDetector = class {
+  _consecutiveStalls = 0;
+  _threshold;
+  constructor(threshold) {
+    this._threshold = threshold;
+  }
+  /** Number of consecutive stall iterations recorded so far. */
+  get consecutiveStalls() {
+    return this._consecutiveStalls;
+  }
+  /**
+   * Record the result of one iteration.
+   * @param madeProgress - true if the agent made filesystem changes this iteration.
+   */
+  record(madeProgress) {
+    if (madeProgress) {
+      this._consecutiveStalls = 0;
+    } else {
+      this._consecutiveStalls++;
+    }
+  }
+  /**
+   * Returns true if the agent has stalled for `threshold` consecutive
+   * iterations without making progress.
+   */
+  isStruggling() {
+    return this._consecutiveStalls >= this._threshold;
+  }
+};
+function checkKillSwitch(cwd) {
+  const killSwitchFile = path.join(cwd, KILL_SWITCH_PATH);
+  return fs.existsSync(killSwitchFile);
+}
+
+// src/autopilot/loop.ts
+var execFile = promisify(execFileCb);
+function buildFullPrompt(userPrompt) {
+  const candidates = [
+    join3(import.meta.dir, "prompt-template.md"),
+    join3(import.meta.dir, "..", "..", "src", "autopilot", "prompt-template.md")
+  ];
+  let template = "";
+  for (const candidate of candidates) {
+    try {
+      const raw = readFileSync(candidate, "utf8");
+      template = raw.replace(/^---\n[\s\S]*?\n---\n/, "");
+      break;
+    } catch {
+    }
+  }
+  const withArgs = template.replace("$ARGUMENTS", userPrompt);
+  return withArgs || userPrompt;
+}
+async function checkProgress(cwd, baseRef) {
+  try {
+    const { stdout } = await execFile("git", ["diff", "--stat", baseRef], { cwd });
+    return stdout.trim().length > 0;
+  } catch {
+    return true;
+  }
+}
+async function getHeadSha(cwd) {
+  try {
+    const { stdout } = await execFile("git", ["rev-parse", "HEAD"], { cwd });
+    return stdout.trim();
+  } catch {
+    return "HEAD";
+  }
+}
+async function runRalphLoop(opts) {
+  const maxIterations = opts.maxIterations ?? MAX_ITERATIONS;
+  const timeoutMs = opts.timeoutMs ?? TIMEOUT_MS;
+  const stallMs = opts.stallMs ?? STALL_MS;
+  const struggleThreshold = opts.struggleThreshold ?? STRUGGLE_THRESHOLD;
+  const _startServer = opts._deps?.startServer ?? startServer;
+  const _createSession = opts._deps?.createSession ?? createSession;
+  const _sendAndWait = opts._deps?.sendAndWait ?? sendAndWait;
+  const _getLastAssistantMessage = opts._deps?.getLastAssistantMessage ?? getLastAssistantMessage;
+  const fullPrompt = buildFullPrompt(opts.prompt);
+  const struggle = new StruggleDetector(struggleThreshold);
+  const startTime = Date.now();
+  const autopilotLog = createAutopilotLogger({ cwd: opts.cwd });
+  const log = childLogger(autopilotLog.root, "autopilot.loop");
+  const toolLog = childLogger(autopilotLog.root, "autopilot.tool");
+  const streamLog = childLogger(autopilotLog.root, "autopilot.stream");
+  const statusLog = childLogger(autopilotLog.root, "autopilot.status");
+  let heartbeat = null;
+  if (autopilotLog.logFilePath) {
+    log.info({ file: autopilotLog.logFilePath }, `Logging to ${autopilotLog.logFilePath}`);
+  }
+  log.info({ cwd: opts.cwd, maxIterations, timeoutMs }, "Starting OpenCode server");
+  const server = await _startServer({ cwd: opts.cwd });
+  log.info({ url: server.url }, "Server ready");
+  const abort = new AbortController();
+  const timeoutHandle = setTimeout(() => {
+    abort.abort();
+  }, timeoutMs);
+  let sessionId;
+  try {
+    sessionId = await _createSession(server.client, {
+      cwd: opts.cwd,
+      agentName: "autopilot-prime"
+    });
+    log.info({ sessionId }, "Session created with autopilot-prime");
+    heartbeat = createStatusHeartbeat({
+      logger: statusLog,
+      intervalMs: STATUS_INTERVAL_MS,
+      pollCost: async () => getSessionCost(server.client, sessionId)
+    });
+    heartbeat.start();
+    for (let iteration = 1; iteration <= maxIterations; iteration++) {
+      if (checkKillSwitch(opts.cwd)) {
+        log.warn({ iteration: iteration - 1 }, "Kill switch active \u2014 stopping");
+        return {
+          exitReason: "kill-switch",
+          iterations: iteration - 1,
+          message: `Kill switch active (.agent/autopilot-disable exists). Stopping after ${iteration - 1} iteration(s).`,
+          sessionId
+        };
+      }
+      if (Date.now() - startTime >= timeoutMs) {
+        log.warn({ iteration: iteration - 1, timeoutMs }, "Total timeout exceeded");
+        return {
+          exitReason: "timeout",
+          iterations: iteration - 1,
+          message: `Total timeout (${timeoutMs}ms) exceeded after ${iteration - 1} iteration(s).`,
+          sessionId
+        };
+      }
+      const headBefore = await getHeadSha(opts.cwd);
+      const iterationBaseCost = heartbeat.getState().cumulativeCostUsd;
+      const iterStart = Date.now();
+      log.debug({ iteration, maxIterations }, `Iteration ${iteration}/${maxIterations} \u2014 sending prompt`);
+      let streamDeltaCount = 0;
+      let streamCharCount = 0;
+      let lastStreamLogAt = 0;
+      let lastToolOrStreamLogAt = Date.now();
+      const DEBUG_STREAM_INTERVAL_MS = 15e3;
+      const INFO_STREAM_INTERVAL_MS = 6e4;
+      const result = await _sendAndWait(server.client, {
+        sessionId,
+        message: fullPrompt,
+        stallMs,
+        abortSignal: abort.signal,
+        // Autopilot is lights-out: auto-reject every permission prompt
+        // (question tool, edit gates, bash confirmations) so the agent
+        // can't deadlock waiting on a human response.
+        autoRejectPermissions: true,
+        serverUrl: server.url,
+        onPermissionRejected: (perm) => {
+          log.warn(
+            { iteration, permissionId: perm.id, permissionType: perm.type, title: perm.title },
+            `Auto-rejected permission: ${perm.type} \u2014 "${perm.title}"`
+          );
+        },
+        onToolCall: (toolName) => {
+          toolLog.debug({ iteration, tool: toolName }, toolName);
+          lastToolOrStreamLogAt = Date.now();
+          streamDeltaCount = 0;
+          streamCharCount = 0;
+          lastStreamLogAt = Date.now();
+        },
+        onCostUpdate: (cost, tokens) => {
+          heartbeat.update({
+            cumulativeCostUsd: iterationBaseCost + cost
+          });
+        },
+        onTextDelta: (charCount) => {
+          streamDeltaCount += 1;
+          streamCharCount += charCount;
+          const now = Date.now();
+          if (now - lastStreamLogAt >= DEBUG_STREAM_INTERVAL_MS) {
+            streamLog.debug(
+              { iteration, deltas: streamDeltaCount, chars: streamCharCount },
+              `streaming (${streamDeltaCount} deltas, ${streamCharCount} chars)`
+            );
+            lastStreamLogAt = now;
+          }
+          const silenceSinceLastTool = now - lastToolOrStreamLogAt;
+          if (silenceSinceLastTool >= INFO_STREAM_INTERVAL_MS) {
+            streamLog.info(
+              {
+                iteration,
+                deltas: streamDeltaCount,
+                chars: streamCharCount,
+                silenceMs: silenceSinceLastTool
+              },
+              `still streaming (${streamDeltaCount} deltas, ${streamCharCount} chars, ${Math.round(silenceSinceLastTool / 1e3)}s since last tool)`
+            );
+            lastToolOrStreamLogAt = now;
+          }
+        }
+      });
+      const iterDurationMs = Date.now() - iterStart;
+      if (result.kind === "abort") {
+        log.warn({ iteration, iterDurationMs }, "Iteration aborted (total timeout)");
+        return {
+          exitReason: "timeout",
+          iterations: iteration,
+          message: `Aborted after ${iteration} iteration(s) (total timeout exceeded).`,
+          sessionId
+        };
+      }
+      if (result.kind === "stall") {
+        log.warn({ iteration, stallMs: result.stallMs }, "Iteration stalled");
+        return {
+          exitReason: "stall",
+          iterations: iteration,
+          message: `Iteration ${iteration} stalled for ${result.stallMs}ms with no idle signal.`,
+          sessionId
+        };
+      }
+      if (result.kind === "error") {
+        log.error({ iteration, err: result.message }, "Iteration errored");
+        heartbeat.update({
+          iterationsCompleted: iteration,
+          lastIterationErrored: true
+        });
+        return {
+          exitReason: "error",
+          iterations: iteration,
+          message: `Error in iteration ${iteration}: ${result.message}`,
+          sessionId
+        };
+      }
+      if (result.kind === "question_rejected") {
+        log.warn(
+          { iteration, questionTitle: result.title },
+          `Question rejected \u2014 re-sending prompt with reminder (iteration ${iteration})`
+        );
+        const reminderResult = await _sendAndWait(server.client, {
+          sessionId,
+          message: fullPrompt + "\n\nIMPORTANT: Your previous attempt to use the question tool was rejected. The question tool is not available in autopilot mode. You must solve this without asking the user. Pick a sensible default, document the decision in the plan's ## Open questions, and continue working.",
+          stallMs,
+          abortSignal: abort.signal,
+          autoRejectPermissions: true,
+          serverUrl: server.url,
+          onPermissionRejected: (perm) => {
+            log.warn(
+              { iteration, permissionId: perm.id, permissionType: perm.type },
+              `Auto-rejected permission on retry: ${perm.type}`
+            );
+          },
+          onToolCall: (toolName) => {
+            toolLog.debug({ iteration, tool: toolName }, toolName);
+          }
+        });
+        if (reminderResult.kind === "question_rejected") {
+          log.error(
+            { iteration },
+            "Agent invoked question tool twice in same iteration \u2014 giving up on this iteration"
+          );
+        } else if (reminderResult.kind !== "idle") {
+          log.warn(
+            { iteration, kind: reminderResult.kind },
+            `Retry after question rejection returned ${reminderResult.kind}`
+          );
+        }
+      }
+      const lastMessage = await _getLastAssistantMessage(server.client, sessionId);
+      if (detectSentinel(lastMessage)) {
+        log.info({ iteration, iterDurationMs }, "Sentinel detected \u2014 autopilot done");
+        return {
+          exitReason: "sentinel",
+          iterations: iteration,
+          message: `Agent emitted <autopilot-done> at iteration ${iteration}.`,
+          sessionId
+        };
+      }
+      const madeProgress = await checkProgress(opts.cwd, headBefore);
+      struggle.record(madeProgress);
+      const cumulativeCostUsd = await getSessionCost(server.client, sessionId);
+      const planPathMatch = opts.prompt.match(/plans\/([^/\s]+(?:\/[^/\s]+)?)/);
+      let planProgressPatch = {};
+      if (planPathMatch) {
+        try {
+          const planPath = planPathMatch[0];
+          const planState = parsePlanState(planPath);
+          if (planState.type === "multi") {
+            planProgressPatch = {
+              phaseCount: planState.phaseCount,
+              phasesCompleted: planState.phasesCompleted,
+              mainCheckboxesTotal: planState.totalItems,
+              mainCheckboxesCompleted: planState.checkedItems
+            };
+          }
+        } catch (err) {
+          log.debug({ err }, "plan-parser error \u2014 falling back to plan-blind heartbeat");
+        }
+      }
+      heartbeat.update({
+        iterationsCompleted: iteration,
+        cumulativeCostUsd,
+        lastIterationProgress: madeProgress,
+        lastIterationErrored: false,
+        ...planProgressPatch
+      });
+      log.debug(
+        { iteration, iterDurationMs, madeProgress, cumulativeCostUsd },
+        `Iteration ${iteration} idle (${(iterDurationMs / 1e3).toFixed(1)}s, ${madeProgress ? "progress" : "no progress"})`
+      );
+      if (struggle.isStruggling()) {
+        log.warn({ iteration, struggleThreshold }, "Struggle detected \u2014 stopping");
+        return {
+          exitReason: "struggle",
+          iterations: iteration,
+          message: `Agent made no filesystem progress for ${struggleThreshold} consecutive iteration(s). Stopping at iteration ${iteration}.`,
+          sessionId
+        };
+      }
+    }
+    log.warn({ maxIterations }, "Reached max iterations");
+    return {
+      exitReason: "max-iterations",
+      iterations: maxIterations,
+      message: `Reached maximum iterations (${maxIterations}). Stopping.`,
+      sessionId
+    };
+  } finally {
+    clearTimeout(timeoutHandle);
+    heartbeat?.stop();
+    log.info({}, "Shutting down server");
+    await server.shutdown();
+    await autopilotLog.flush();
+  }
+}
+
+export {
+  MAX_ITERATIONS,
+  TIMEOUT_MS,
+  runRalphLoop
+};