@glrs-dev/cli 2.2.0 → 2.4.0

package/dist/commands/debrief.d.ts

@@ -0,0 +1,57 @@
+import { AgentAdapter, AgentHandle, LoopResult } from '@glrs-dev/autopilot';
+
+/**
+ * Autopilot post-run debrief module.
+ *
+ * After the Ralph loop exits (any exit reason), runDebrief spawns a
+ * @debriefer session, sends a structured context blob, waits for the
+ * response, and prints the structured summary to stdout.
+ *
+ * On any failure, prints a warning and returns gracefully — the loop
+ * result is the source of truth for exit code.
+ */
+
+interface DebriefOptions {
+    /** The agent adapter + handle (owned by the CLI). */
+    agentHandle: {
+        adapter: AgentAdapter;
+        handle: AgentHandle;
+    };
+    /** The result from runRalphLoop. */
+    loopResult: LoopResult & {
+        sessionId?: string;
+        cumulativeCostUsd?: number;
+    };
+    /** The original prompt passed to the loop. */
+    prompt: string;
+    /** Working directory (used for git diff stat). */
+    cwd: string;
+    /**
+     * Injectable dependencies for testing.
+     * @internal
+     */
+    _deps?: {
+        execGitDiffStat?: (cwd: string) => Promise<string>;
+    };
+}
+interface ShouldRunDebriefOptions {
+    noDebrief: boolean;
+    env: Record<string, string | undefined>;
+}
+/**
+ * Returns true if the debrief should run given the CLI flag and env var.
+ *
+ * - `--no-debrief` flag → false
+ * - `GLRS_AUTOPILOT_DEBRIEF=off` (case-insensitive) → false
+ * - Otherwise → true
+ */
+declare function shouldRunDebrief(opts: ShouldRunDebriefOptions): boolean;
+/**
+ * Run the post-loop debrief. Spawns a @debriefer session, sends context,
+ * waits for the response, and prints it to stdout.
+ *
+ * Never throws — on any error, prints a warning to stderr and returns.
+ */
+declare function runDebrief(opts: DebriefOptions): Promise<void>;
+
+export { type DebriefOptions, type ShouldRunDebriefOptions, runDebrief, shouldRunDebrief };

package/dist/commands/debrief.js

@@ -0,0 +1,9 @@
+import {
+  runDebrief,
+  shouldRunDebrief
+} from "../chunk-5ZVUFNCP.js";
+import "../chunk-3RG5ZIWI.js";
+export {
+  runDebrief,
+  shouldRunDebrief
+};

package/dist/commands/delete.js

@@ -1,10 +1,10 @@
 import {
   del
-} from "../chunk-RZWOWTKF.js";
-import "../chunk-W37UX3U2.js";
+} from "../chunk-EKNRKZWR.js";
 import "../chunk-P7PRH4I3.js";
+import "../chunk-6Y27RQQL.js";
 import "../chunk-LMRDQ4GW.js";
-import "../chunk-SPULDN7P.js";
+import "../chunk-YY7EWHMA.js";
 import "../chunk-YBCA3IP6.js";
 import "../chunk-3RG5ZIWI.js";
 export {

package/dist/commands/go.js

@@ -1,9 +1,9 @@
 import {
   go
-} from "../chunk-E2UNZIZT.js";
+} from "../chunk-R2WXQ54P.js";
 import "../chunk-P7PRH4I3.js";
 import "../chunk-LMRDQ4GW.js";
-import "../chunk-SPULDN7P.js";
+import "../chunk-YY7EWHMA.js";
 import "../chunk-YBCA3IP6.js";
 import "../chunk-3RG5ZIWI.js";
 export {

package/dist/commands/list.js

@@ -1,10 +1,10 @@
 import {
   list
-} from "../chunk-I2KUXY3I.js";
-import "../chunk-E2UNZIZT.js";
+} from "../chunk-SMDIOB5B.js";
+import "../chunk-R2WXQ54P.js";
 import "../chunk-P7PRH4I3.js";
 import "../chunk-LMRDQ4GW.js";
-import "../chunk-SPULDN7P.js";
+import "../chunk-YY7EWHMA.js";
 import "../chunk-YBCA3IP6.js";
 import "../chunk-3RG5ZIWI.js";
 export {

package/dist/commands/loop.d.ts

@@ -0,0 +1,42 @@
+import * as cmd_ts_dist_cjs_runner_js from 'cmd-ts/dist/cjs/runner.js';
+import * as cmd_ts_dist_cjs_helpdoc_js from 'cmd-ts/dist/cjs/helpdoc.js';
+import * as cmd_ts_dist_cjs_argparser_js from 'cmd-ts/dist/cjs/argparser.js';
+
+/**
+ * `glrs oc loop` — Ralph loop CLI driver.
+ *
+ * Starts an OpenCode server, creates a session with PRIME, sends the
+ * user's prompt each iteration, and exits when the agent emits
+ * `<autopilot-done>` or a budget is exhausted.
+ *
+ * PR 3 diverged `loop` and `autopilot`: `loop` is the raw-prompt
+ * Ralph-loop runner; `autopilot` is the interactive three-phase
+ * orchestrator (scope → plan → loop). They are now separate subcommands.
+ *
+ * After the loop exits, optionally runs a @debriefer session to produce
+ * a structured post-run summary. Skip with --no-debrief or
+ * GLRS_AUTOPILOT_DEBRIEF=off.
+ */
+declare const loopCmd: Partial<cmd_ts_dist_cjs_argparser_js.Register> & {
+    parse(context: cmd_ts_dist_cjs_argparser_js.ParseContext): Promise<cmd_ts_dist_cjs_argparser_js.ParsingResult<{
+        prompt: string;
+        maxIterations: number | undefined;
+        timeout: number | undefined;
+        stallTimeout: number | undefined;
+        noDebrief: boolean;
+        notify: string | undefined;
+        debriefOnly: boolean;
+    }>>;
+} & cmd_ts_dist_cjs_helpdoc_js.PrintHelp & cmd_ts_dist_cjs_helpdoc_js.ProvidesHelp & cmd_ts_dist_cjs_helpdoc_js.Named & Partial<cmd_ts_dist_cjs_helpdoc_js.Versioned> & cmd_ts_dist_cjs_argparser_js.Register & cmd_ts_dist_cjs_runner_js.Handling<{
+    prompt: string;
+    maxIterations: number | undefined;
+    timeout: number | undefined;
+    stallTimeout: number | undefined;
+    noDebrief: boolean;
+    notify: string | undefined;
+    debriefOnly: boolean;
+}, Promise<never>> & {
+    run(context: cmd_ts_dist_cjs_argparser_js.ParseContext): Promise<cmd_ts_dist_cjs_argparser_js.ParsingResult<Promise<never>>>;
+} & Partial<cmd_ts_dist_cjs_helpdoc_js.Versioned & cmd_ts_dist_cjs_helpdoc_js.Descriptive & cmd_ts_dist_cjs_helpdoc_js.Aliased>;
+
+export { loopCmd };

package/dist/commands/loop.js

@@ -0,0 +1,133 @@
+import {
+  runDebrief,
+  shouldRunDebrief
+} from "../chunk-5ZVUFNCP.js";
+import "../chunk-3RG5ZIWI.js";
+
+// src/commands/loop.ts
+import { command, option, positional, string as stringType, optional, number as numberType, flag } from "cmd-ts";
+import { runRalphLoop, MAX_ITERATIONS, TIMEOUT_MS } from "@glrs-dev/autopilot";
+var loopCmd = command({
+  name: "loop",
+  description: "Run the Ralph loop: send a prompt to PRIME repeatedly until it emits <autopilot-done> or a budget is exhausted.",
+  args: {
+    prompt: positional({
+      type: stringType,
+      displayName: "prompt",
+      description: "The prompt to send to PRIME each iteration (e.g. a Linear issue ref or free-form task)."
+    }),
+    maxIterations: option({
+      long: "max-iterations",
+      type: optional(numberType),
+      description: `Maximum number of loop iterations (default: ${MAX_ITERATIONS}).`
+    }),
+    timeout: option({
+      long: "timeout",
+      type: optional(numberType),
+      description: `Total wall-clock timeout in milliseconds (default: ${TIMEOUT_MS} = 4 hours).`
+    }),
+    stallTimeout: option({
+      long: "stall-timeout",
+      type: optional(numberType),
+      description: "Per-iteration stall timeout in milliseconds. Overrides the tier-based default (deep=30m, mid=15m, mid-execute/autopilot-execute=10m, fast=5m)."
+    }),
+    noDebrief: flag({
+      long: "no-debrief",
+      description: "Skip the post-run debrief session."
+    }),
+    notify: option({
+      long: "notify",
+      type: optional(stringType),
+      description: "Webhook URL to POST lifecycle events to (supports plain webhooks and Slack incoming webhooks)."
+    }),
+    debriefOnly: flag({
+      long: "debrief-only",
+      description: "Run the debrief against the most recent log file without re-executing the loop. (Not yet implemented \u2014 requires log-directory discovery.)"
+    })
+  },
+  handler: async ({ prompt, maxIterations, timeout, stallTimeout, noDebrief, notify, debriefOnly }) => {
+    const cwd = process.cwd();
+    let loopStarted = false;
+    const earlyExit = (signal) => {
+      if (loopStarted) return;
+      process.stderr.write(`
+${signal} received before loop start \u2014 exiting
+`);
+      process.exit(130);
+    };
+    const earlySigint = () => earlyExit("SIGINT");
+    const earlySigterm = () => earlyExit("SIGTERM");
+    process.on("SIGINT", earlySigint);
+    process.on("SIGTERM", earlySigterm);
+    if (debriefOnly) {
+      process.stderr.write(
+        "\x1B[33m\u26A0 --debrief-only is not yet implemented.\x1B[0m\n  It requires discovering the most recent log file from the per-run log directory.\n  The log directory convention is: <cwd>/.agent/autopilot-logs/<timestamp>.log\n  To implement: read the most recent file from that directory and pass it to runDebrief.\n"
+      );
+      process.exit(1);
+    }
+    const willDebrief = shouldRunDebrief({ noDebrief, env: process.env });
+    const { OpenCodeAdapter } = await import("@glrs-dev/adapter-opencode");
+    const adapter = new OpenCodeAdapter();
+    const result = await runRalphLoop({
+      prompt,
+      cwd,
+      maxIterations: maxIterations ?? void 0,
+      timeoutMs: timeout ?? void 0,
+      stallMs: stallTimeout ?? void 0,
+      notifyUrl: notify ?? void 0,
+      keepAlive: willDebrief,
+      adapter
+    });
+    loopStarted = true;
+    process.removeListener("SIGINT", earlySigint);
+    process.removeListener("SIGTERM", earlySigterm);
+    const icon = result.exitReason === "sentinel" ? "\x1B[32m\u2713\x1B[0m" : result.exitReason === "kill-switch" ? "\x1B[33m\u2298\x1B[0m" : "\x1B[31m\u2717\x1B[0m";
+    process.stdout.write(`
+${icon} ${result.message}
+`);
+    process.stdout.write(`  Iterations: ${result.iterations}
+
+`);
+    if (willDebrief) {
+      const loopHandle = result.agentHandle;
+      if (loopHandle) {
+        try {
+          await runDebrief({
+            agentHandle: loopHandle,
+            loopResult: result,
+            prompt,
+            cwd
+          });
+        } catch {
+          process.stderr.write("\x1B[33m\u26A0 Debrief failed (non-fatal)\x1B[0m\n");
+        } finally {
+          await loopHandle.adapter.shutdown(loopHandle.handle).catch(() => {
+          });
+        }
+      } else {
+        const debriefAdapter = new OpenCodeAdapter();
+        const debriefHandle = await debriefAdapter.start({ cwd });
+        try {
+          await runDebrief({
+            agentHandle: { adapter: debriefAdapter, handle: debriefHandle },
+            loopResult: result,
+            prompt,
+            cwd
+          });
+        } catch {
+          process.stderr.write("\x1B[33m\u26A0 Debrief agent failed to start (non-fatal)\x1B[0m\n");
+        } finally {
+          await debriefAdapter.shutdown(debriefHandle).catch(() => {
+          });
+        }
+      }
+    }
+    if (result.exitReason !== "sentinel" && result.exitReason !== "kill-switch") {
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+});
+export {
+  loopCmd
+};

package/dist/commands/plan-picker.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Interactive file picker for plan files.
+ *
+ * Starts at the given root directory, shows .md files and subdirectories.
+ * The user can drill into directories or select a file. Returns the
+ * absolute path to the selected file, or null if cancelled.
+ */
+/**
+ * Browse for a plan file starting at `rootDir`.
+ * Returns the absolute path to the selected .md file or directory
+ * (if it contains main.md), or null if the user cancels.
+ */
+declare function pickPlanFile(rootDir: string): Promise<string | null>;
+
+export { pickPlanFile };

package/dist/commands/plan-picker.js

@@ -0,0 +1,76 @@
+import "../chunk-3RG5ZIWI.js";
+
+// src/commands/plan-picker.ts
+import * as fs from "fs";
+import * as path from "path";
+async function pickPlanFile(rootDir) {
+  const { select } = await import("@inquirer/prompts");
+  let currentDir = path.resolve(rootDir);
+  while (true) {
+    let entries;
+    try {
+      entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      return null;
+    }
+    const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort();
+    const files = entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => e.name).sort();
+    if (dirs.length === 0 && files.length === 0) {
+      process.stderr.write(`  No .md files found in ${currentDir}
+`);
+      return null;
+    }
+    const choices = [];
+    for (const d of dirs) {
+      const dirPath = path.join(currentDir, d);
+      const hasMain = fs.existsSync(path.join(dirPath, "main.md"));
+      if (hasMain) {
+        const phaseCount = fs.readdirSync(dirPath).filter(
+          (f) => f.endsWith(".md") && f !== "main.md" && f !== "scope.md" && f !== "scope-seed.md"
+        ).length;
+        choices.push({
+          name: `\u{1F4CB} ${d}/  (plan: main.md + ${phaseCount} phases)`,
+          value: `plan:${dirPath}`
+        });
+      } else {
+        choices.push({
+          name: `\u{1F4C1} ${d}/`,
+          value: `dir:${dirPath}`
+        });
+      }
+    }
+    for (const f of files) {
+      choices.push({
+        name: `  ${f}`,
+        value: `file:${path.join(currentDir, f)}`
+      });
+    }
+    if (currentDir !== path.resolve(rootDir)) {
+      choices.push({ name: "\u21A9 Back", value: "back" });
+    }
+    choices.push({ name: "\u2715 Cancel", value: "cancel" });
+    const relDir = path.relative(rootDir, currentDir) || ".";
+    const answer = await select({
+      message: `Select a plan (${relDir}):`,
+      choices
+    });
+    if (answer === "cancel") return null;
+    if (answer === "back") {
+      currentDir = path.dirname(currentDir);
+      continue;
+    }
+    if (answer.startsWith("plan:")) {
+      return answer.slice("plan:".length);
+    }
+    if (answer.startsWith("file:")) {
+      return answer.slice("file:".length);
+    }
+    if (answer.startsWith("dir:")) {
+      currentDir = answer.slice("dir:".length);
+      continue;
+    }
+  }
+}
+export {
+  pickPlanFile
+};

package/dist/commands/scoper.d.ts

@@ -0,0 +1,54 @@
+import { ScoperSessionOptions, ScoperSessionResult } from '@glrs-dev/autopilot';
+export { ScoperSessionOptions, ScoperSessionResult } from '@glrs-dev/autopilot';
+
+/**
+ * Scoper session runner — inquirer-driven wizard loop.
+ *
+ * Starts an opencode server + creates a persistent @scoper session.
+ * Sends the user's initial goal as the first prompt, then drives a
+ * wizard loop:
+ *
+ *   1. Wait for the agent's response (idle).
+ *   2. Parse the response:
+ *      - Question (≤200 chars, ends with '?') → prompt the user via
+ *        inquirer, send the answer back, repeat.
+ *      - SCOPE_COMPLETE sentinel → validate scope.md exists, return path.
+ *      - Parse error → retry once with a reminder; second failure throws.
+ *   3. Hard cap: after 8 user answers, send a forced-finalize message.
+ *      If the agent still doesn't emit the sentinel, throw.
+ *
+ * autoRejectPermissions: true — the question tool is disabled at the
+ * agent level, but we defend in depth.
+ */
+/**
+ * Parse a question from an agent response.
+ * A valid question is a single line, ≤200 chars, ending with '?'.
+ * Returns the question string, or null if the response is not a question.
+ */
+declare function parseQuestion(response: string): string | null;
+/**
+ * Parse a scope summary from an agent response.
+ * A valid summary starts with 'SCOPE_SUMMARY:' on the first line,
+ * followed by the summary text on subsequent lines.
+ * Returns the summary text (without the prefix), or null.
+ */
+declare function parseScopeSummary(response: string): string | null;
+/**
+ * Extract the scope.md path from the SCOPE_COMPLETE sentinel line.
+ * Returns the path string, or null if no sentinel is found.
+ *
+ * Uses the LAST occurrence if multiple sentinel lines appear (the
+ * agent may emit intermediate progress lines before the final one).
+ */
+declare function extractScopeCompletePath(output: string): string | null;
+
+/**
+ * Run the @scoper wizard loop.
+ *
+ * Starts an opencode server, creates a persistent session with @scoper,
+ * sends the initial goal prompt, then drives the wizard loop until the
+ * agent emits SCOPE_COMPLETE or the hard cap is reached.
+ */
+declare function runScoperSession(opts: ScoperSessionOptions): Promise<ScoperSessionResult>;
+
+export { extractScopeCompletePath, parseQuestion, parseScopeSummary, runScoperSession };