@glrs-dev/cli 2.4.0 → 2.6.0

package/dist/commands/loop.js

@@ -1,12 +1,18 @@
 import {
   runDebrief,
   shouldRunDebrief
-} from "../chunk-5ZVUFNCP.js";
+} from "../chunk-S6N5E2GG.js";
+import {
+  ADAPTER_NAMES,
+  DEFAULT_ADAPTER,
+  createAdapter,
+  resolveConfig
+} from "../chunk-J3FXSHMA.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";
+import { command, option, positional, string as stringType, optional, number as numberType, flag, oneOf } from "cmd-ts";
+import { runRalphLoop, MAX_ITERATIONS, TIMEOUT_MS, applyCLIOverrides } 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.",
@@ -43,9 +49,15 @@ var loopCmd = command({
     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.)"
+    }),
+    adapter: option({
+      long: "adapter",
+      short: "a",
+      type: optional(oneOf(ADAPTER_NAMES)),
+      description: `Agent adapter to use (default: ${DEFAULT_ADAPTER}). Available: ${ADAPTER_NAMES.join(", ")}`
     })
   },
-  handler: async ({ prompt, maxIterations, timeout, stallTimeout, noDebrief, notify, debriefOnly }) => {
+  handler: async ({ prompt, maxIterations, timeout, stallTimeout, noDebrief, notify, debriefOnly, adapter: adapterName }) => {
     const cwd = process.cwd();
     let loopStarted = false;
     const earlyExit = (signal) => {
@@ -66,17 +78,24 @@ ${signal} received before loop start \u2014 exiting
       process.exit(1);
     }
     const willDebrief = shouldRunDebrief({ noDebrief, env: process.env });
-    const { OpenCodeAdapter } = await import("@glrs-dev/adapter-opencode");
-    const adapter = new OpenCodeAdapter();
+    const resolvedConfig = resolveConfig(cwd);
+    const config = applyCLIOverrides(resolvedConfig, {
+      adapter: adapterName,
+      stallTimeout,
+      notify
+    });
+    const finalAdapterName = config.adapter ?? DEFAULT_ADAPTER;
+    const adapter = await createAdapter(finalAdapterName, config);
     const result = await runRalphLoop({
       prompt,
       cwd,
       maxIterations: maxIterations ?? void 0,
       timeoutMs: timeout ?? void 0,
-      stallMs: stallTimeout ?? void 0,
-      notifyUrl: notify ?? void 0,
+      stallMs: config.stall_timeout ?? void 0,
+      notifyUrl: config.notify_url ?? void 0,
       keepAlive: willDebrief,
-      adapter
+      adapter,
+      config
     });
     loopStarted = true;
     process.removeListener("SIGINT", earlySigint);
@@ -96,7 +115,8 @@ ${icon} ${result.message}
             agentHandle: loopHandle,
             loopResult: result,
             prompt,
-            cwd
+            cwd,
+            config
           });
         } catch {
           process.stderr.write("\x1B[33m\u26A0 Debrief failed (non-fatal)\x1B[0m\n");
@@ -105,14 +125,15 @@ ${icon} ${result.message}
           });
         }
       } else {
-        const debriefAdapter = new OpenCodeAdapter();
+        const debriefAdapter = await createAdapter(config.adapter ?? DEFAULT_ADAPTER, config);
         const debriefHandle = await debriefAdapter.start({ cwd });
         try {
           await runDebrief({
             agentHandle: { adapter: debriefAdapter, handle: debriefHandle },
             loopResult: result,
             prompt,
-            cwd
+            cwd,
+            config
           });
         } catch {
           process.stderr.write("\x1B[33m\u26A0 Debrief agent failed to start (non-fatal)\x1B[0m\n");

package/dist/index.d.ts

@@ -24,7 +24,7 @@ interface ResolvedBin {
 }
 declare function resolveSubcommand(sub: Subcommand): ResolvedBin;
 declare const SUBCOMMANDS: Subcommand[];
-declare const HELP_TEXT = "glrs \u2014 unified CLI for the @glrs-dev ecosystem\n\nUSAGE\n  glrs <subcommand> [args...]\n\nSUBCOMMANDS\n  oc         OpenCode agent harness (install, pilot, etc.)\n  wt         Worktree management (create, list, switch, delete, cleanup)\n  dashboard  Live TUI dashboard for all running autopilot sessions\n\nRun 'glrs <subcommand> --help' for per-command help.\n\nEXAMPLES\n  glrs oc install\n  glrs wt new\n  glrs wt list\n  glrs wt switch\n  glrs dashboard\n\nREQUIREMENTS\n  Bun >= 1.2.0 on PATH (install: https://bun.sh)\n\nDOCS  https://glrs.dev\nISSUES https://github.com/iceglober/glrs/issues\n";
+declare const HELP_TEXT = "glrs \u2014 unified CLI for the @glrs-dev ecosystem\n\nUSAGE\n  glrs <subcommand> [args...]\n\nSUBCOMMANDS\n  oc         OpenCode agent harness (install, pilot, etc.)\n  wt         Worktree management (create, list, switch, delete, cleanup)\n  autopilot  Run the autopilot orchestrator (scope \u2192 plan \u2192 execute)\n  loop       Run the Ralph loop with a raw prompt\n  dashboard  Live TUI dashboard for all running autopilot sessions\n\nRun 'glrs <subcommand> --help' for per-command help.\n\nEXAMPLES\n  glrs oc install\n  glrs wt new\n  glrs wt list\n  glrs wt switch\n  glrs autopilot --plan docs/plans/my-plan/\n  glrs loop \"implement the auth middleware\"\n  glrs dashboard\n\nREQUIREMENTS\n  Bun >= 1.2.0 on PATH (install: https://bun.sh)\n\nDOCS  https://glrs.dev\nISSUES https://github.com/iceglober/glrs/issues\n";
 declare const WORKTREE_HELP_TEXT = "glrs wt \u2014 worktree management\n\nUSAGE\n  glrs wt <command> [args...]\n\nCOMMANDS\n  new              Create a new worktree (auto-named from origin/default)\n  list, ls         List all worktrees across repos\n  switch, sw       Interactively select and switch to a worktree\n  delete, rm       Remove worktrees (interactive or by name)\n  cleanup          Delete merged/stale worktrees\n\nEXAMPLES\n  glrs wt new                    # Create worktree in current repo\n  glrs wt new myrepo             # Create worktree for named repo\n  glrs wt list                   # Show all worktrees\n  glrs wt list -i                # Interactive picker\n  glrs wt switch                 # Interactive switcher\n  glrs wt delete my-branch       # Delete specific worktree\n  glrs wt cleanup                # Clean up merged worktrees\n\nWorktrees are stored in ~/.glrs/worktrees/<repo>/<name>/\n";
 
 export { HELP_TEXT, type ResolvedBin, SUBCOMMANDS, type Subcommand, WORKTREE_HELP_TEXT, resolveSubcommand };

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   SUBCOMMANDS,
   WORKTREE_HELP_TEXT,
   resolveSubcommand
-} from "./chunk-HQUCVJ4G.js";
+} from "./chunk-FBXSGZAA.js";
 import "./chunk-3RG5ZIWI.js";
 export {
   HELP_TEXT,

package/dist/node_modules/@glrs-dev/adapter-opencode/dist/index.d.ts

@@ -0,0 +1,270 @@
+import { execFile } from 'node:child_process';
+import { OpencodeClient } from '@opencode-ai/sdk';
+import { AgentAdapter, AgentHandle, AdapterSessionResult } from '@glrs-dev/autopilot';
+
+/**
+ * OpenCode server lifecycle helpers.
+ *
+ * General-purpose utilities for starting an OpenCode server, creating
+ * sessions, sending messages, and waiting for idle. Used by the Ralph
+ * autopilot loop and any future feature that needs to drive OpenCode
+ * programmatically.
+ *
+ * Extracted from src/pilot/server.ts so these helpers are not coupled
+ * to the pilot subsystem.
+ */
+
+declare const execFileP: typeof execFile.__promisify__;
+type StartedServer = {
+    url: string;
+    client: OpencodeClient;
+    shutdown: () => Promise<void>;
+};
+type SessionResult = {
+    kind: "idle";
+} | {
+    kind: "stall";
+    stallMs: number;
+} | {
+    kind: "abort";
+} | {
+    kind: "error";
+    message: string;
+} | {
+    kind: "question_rejected";
+    title: string;
+};
+declare const DEFAULT_STARTUP_TIMEOUT_MS = 30000;
+/**
+ * Start an OpenCode server for the given working directory.
+ * Returns the server URL, a bound client, and a shutdown function.
+ *
+ * Uses createOpencode() which spawns the server process and creates
+ * a connected client. The server inherits process.cwd() as its project
+ * directory.
+ *
+ * When `agentOverrides` is provided, sets GLRS_AGENT_OVERRIDES in the
+ * server environment before startup, and restores the prior value on
+ * shutdown to keep the parent process clean.
+ */
+declare function startServer(opts: {
+    cwd: string;
+    port?: number;
+    timeoutMs?: number;
+    agentOverrides?: Record<string, {
+        model?: string;
+        prompt?: string;
+    }>;
+}): Promise<StartedServer>;
+/**
+ * Verify the server is responsive by listing sessions.
+ * Fails fast with a diagnostic if the server isn't working.
+ */
+declare function selfTest(client: OpencodeClient): Promise<void>;
+/**
+ * Create a new OpenCode session for the given directory.
+ *
+ * Note: the SDK's `session.create` body takes only `parentID` and `title`
+ * — agent selection is a per-message concern in OpenCode's model and lives
+ * on `session.prompt`'s body, not on session creation. The working
+ * directory is passed via the `query.directory` param.
+ *
+ * Returns the session ID.
+ */
+declare function createSession(client: OpencodeClient, opts: {
+    cwd: string;
+    agentName?: string;
+}): Promise<string>;
+/**
+ * Send a message to a session and wait for the agent to go idle.
+ *
+ * Uses `session.prompt` (the correct SDK method for sending a message).
+ * `session.chat` does not exist on the SDK — an earlier version of this
+ * module used that name and silently failed at runtime.
+ *
+ * The optional `onToolCall` callback fires once per tool invocation that
+ * reaches the `completed` state. Used by the autopilot loop to emit
+ * debug-level log events for each tool call.
+ *
+ * The optional `onTextDelta` callback fires for each assistant text
+ * chunk the agent streams. Used by the autopilot loop's stream-liveness
+ * indicator — between tool calls, the agent may stream text for minutes
+ * while reasoning, and without this signal the user can't distinguish
+ * "still working" from "hung."
+ *
+ * When `autoRejectPermissions: true`, any `permission.updated` event
+ * fired for this session is immediately answered with `response: "reject"`.
+ * Used by autopilot to prevent the `question` tool (or any tool-approval
+ * prompt) from deadlocking the session — no human is available to answer.
+ * The `onPermissionRejected` callback (if provided) fires each time a
+ * permission is auto-rejected so the caller can log it.
+ *
+ * Returns the result kind.
+ */
+declare function sendAndWait(client: OpencodeClient, opts: {
+    sessionId: string;
+    message: string;
+    agentName?: string;
+    stallMs?: number;
+    abortSignal?: AbortSignal;
+    onToolCall?: (toolName: string, firstArg?: string) => void;
+    onTextDelta?: (charCount: number) => void;
+    /** Fires on `message.updated` events with cost/token data. Used for
+     *  real-time cost visibility during long iterations. */
+    onCostUpdate?: (cost: number, tokens: {
+        input: number;
+        output: number;
+    }) => void;
+    autoRejectPermissions?: boolean;
+    /** Server URL for raw HTTP calls (question-reject endpoint). */
+    serverUrl?: string;
+    onPermissionRejected?: (permission: {
+        id: string;
+        type: string;
+        title: string;
+    }) => void;
+}): Promise<SessionResult>;
+/**
+ * Wait for a session to go idle (agent done), stall, abort, or error.
+ *
+ * `client.event.subscribe()` is async and returns `{ stream }` (a
+ * `ServerSentEventsResult`). The stream is an AsyncGenerator of events.
+ *
+ * When `onToolCall` is provided, fires once per tool invocation that
+ * reaches the `completed` state. Filters out pending/running transitions
+ * to avoid double-counting.
+ *
+ * When `onTextDelta` is provided, fires for each non-empty delta string
+ * the server emits (charCount = delta.length). Used by autopilot to
+ * signal liveness during long reasoning streams between tool calls.
+ *
+ * When `autoRejectPermissions: true`, any `permission.updated` event
+ * for this session is answered with `response: "reject"` via
+ * `POST /session/{id}/permissions/{permissionID}`. This prevents the
+ * `question` tool (and any tool-approval prompts) from deadlocking the
+ * session when no human is present to answer. `onPermissionRejected`
+ * fires synchronously with the permission payload so callers can log.
+ */
+declare function waitForIdle(client: OpencodeClient, opts: {
+    sessionId: string;
+    stallMs?: number;
+    abortSignal?: AbortSignal;
+    onToolCall?: (toolName: string, firstArg?: string) => void;
+    onTextDelta?: (charCount: number) => void;
+    /** Fires on `message.updated` events with cost/token data. Used for
+     *  real-time cost visibility during long iterations. */
+    onCostUpdate?: (cost: number, tokens: {
+        input: number;
+        output: number;
+    }) => void;
+    autoRejectPermissions?: boolean;
+    /** Server URL for raw HTTP calls (question-reject endpoint). */
+    serverUrl?: string;
+    onPermissionRejected?: (permission: {
+        id: string;
+        type: string;
+        title: string;
+    }) => void;
+}): Promise<SessionResult>;
+/**
+ * Get the cumulative cost of a session in USD.
+ *
+ * Cost is tracked per-message on the server (AssistantMessage.cost),
+ * not aggregated on the Session object. We sum across all assistant
+ * messages to get a session total.
+ */
+declare function getSessionCost(client: OpencodeClient, sessionId: string): Promise<number>;
+/**
+ * Get cumulative cost + token totals for a session.
+ *
+ * Sums cost, input tokens, and output tokens across all assistant
+ * messages. Returns zeros on any error (non-fatal).
+ */
+declare function getSessionStats(client: OpencodeClient, sessionId: string): Promise<{
+    cost: number;
+    tokensIn: number;
+    tokensOut: number;
+}>;
+/**
+ * Fetch the last assistant message text from a session.
+ *
+ * Calls `client.session.messages()`, filters to assistant-role messages,
+ * takes the last one, and concatenates all text parts.
+ *
+ * Returns an empty string if there are no assistant messages or if the
+ * API call fails.
+ */
+declare function getLastAssistantMessage(client: OpencodeClient, sessionId: string): Promise<string>;
+
+/**
+ * Extract actionable error details from OpenCode server logs.
+ *
+ * When the SSE `session.error` event carries only a generic "session error"
+ * message, the real error (credential failure, model not found, etc.) is
+ * only in the OpenCode server's own log at ~/.local/share/opencode/log/.
+ *
+ * This module reads the most recent log file and extracts the last
+ * session.processor error line — which contains the actual provider error.
+ */
+/**
+ * Read the most recent OpenCode server log and extract the last
+ * session.processor error message. Returns null if no log found
+ * or no error extracted.
+ *
+ * This is best-effort — the log directory may not exist, the log
+ * format may change, or the error may not be present. Callers
+ * should fall back to the generic message when this returns null.
+ */
+declare function extractServerError(): string | null;
+/**
+ * Enhance a generic "session error" message with details from the
+ * OpenCode server log. If the log contains a more specific error,
+ * returns that. Otherwise returns the original message unchanged.
+ */
+declare function enhanceSessionError(genericMessage: string): string;
+
+/**
+ * OpenCodeAdapter — implements AgentAdapter using the OpenCode SDK.
+ *
+ * Wraps the low-level opencode-server.ts functions into the AgentAdapter
+ * interface so the autopilot loop engine can drive OpenCode without
+ * importing the SDK directly.
+ */
+
+/**
+ * OpenCode implementation of AgentAdapter.
+ * Creates and manages OpenCode server instances.
+ */
+declare class OpenCodeAdapter implements AgentAdapter {
+    readonly name = "opencode";
+    start(opts: {
+        cwd: string;
+        agents?: Record<string, unknown>;
+    }): Promise<AgentHandle>;
+    createSession(handle: AgentHandle, opts: {
+        agentName?: string;
+    }): Promise<string>;
+    sendAndWait(handle: AgentHandle, opts: {
+        sessionId: string;
+        message: string;
+        stallMs?: number;
+        abortSignal?: AbortSignal;
+        onToolCall?: (name: string, arg?: string) => void;
+        onTextDelta?: (chars: number) => void;
+        onCostUpdate?: (cost: number, tokens: {
+            input: number;
+            output: number;
+        }) => void;
+    }): Promise<AdapterSessionResult>;
+    getLastResponse(handle: AgentHandle, sessionId: string): Promise<string>;
+    getSessionCost(handle: AgentHandle, sessionId: string): Promise<number>;
+    getSessionStats(handle: AgentHandle, sessionId: string): Promise<{
+        cost: number;
+        tokensIn: number;
+        tokensOut: number;
+    }>;
+    shutdown(handle: AgentHandle): Promise<void>;
+    enhanceError(message: string): Promise<string>;
+}
+
+export { DEFAULT_STARTUP_TIMEOUT_MS, OpenCodeAdapter, type SessionResult as OpenCodeSessionResult, type StartedServer, createSession, enhanceSessionError, execFileP, extractServerError, getLastAssistantMessage, getSessionCost, getSessionStats, selfTest, sendAndWait, startServer, waitForIdle };