@glrs-dev/cli 2.3.0 → 2.4.1

package/dist/commands/autopilot.js

@@ -0,0 +1,395 @@
+import "../chunk-3RG5ZIWI.js";
+
+// src/commands/autopilot.ts
+import { command, flag, option, optional, string as stringType, number as numberType } from "cmd-ts";
+import * as path from "path";
+import * as fs from "fs";
+import { formatElapsed, formatCost as formatCost2, EventStreamReader, deriveState } from "@glrs-dev/autopilot";
+import { SessionRunner } from "@glrs-dev/autopilot";
+
+// src/cli-renderer.ts
+function formatDuration(ms) {
+  if (ms < 6e4) return `${Math.round(ms / 1e3)}s`;
+  const min = Math.floor(ms / 6e4);
+  const sec = Math.round(ms / 1e3 % 60);
+  return `${min}m ${sec}s`;
+}
+function formatCost(usd) {
+  return `$${usd.toFixed(2)}`;
+}
+function createCliRenderer(emitter) {
+  const handler = (event) => {
+    switch (event.type) {
+      // Lifecycle — session:start and session:done are handled by the caller
+      case "session:start":
+      case "session:done":
+        break;
+      // Enrichment
+      case "enrich:start":
+        break;
+      case "enrich:file:start":
+        break;
+      case "enrich:file:done":
+        process.stderr.write(
+          `  \u2713 ${event.file}${event.specFile ? ` \u2192 ${event.specFile}` : ""} generated
+`
+        );
+        break;
+      case "enrich:file:skip":
+        process.stderr.write(`  ${event.file} \u2014 ${event.reason}
+`);
+        break;
+      case "enrich:file:error":
+        process.stderr.write(`  \u2717 ${event.file}: ${event.error}
+`);
+        break;
+      case "enrich:done":
+        break;
+      // Execution — phase
+      case "phase:start":
+        if (event.current === 0) {
+          process.stderr.write(`
+\x1B[2m${event.phase}\x1B[0m
+`);
+        } else {
+          process.stderr.write(
+            `
+\x1B[1m\u2192 Phase ${event.current}/${event.total}: ${event.phase}\x1B[0m
+`
+          );
+        }
+        break;
+      case "phase:done":
+        if (event.iterations === 0 && event.completed) {
+          process.stderr.write(
+            `  \x1B[2m\u2713 ${event.phase} \u2014 skipped (already done)\x1B[0m
+`
+          );
+        } else if (event.completed) {
+          process.stderr.write(
+            `  \u2713 Phase ${event.phase} complete (${event.iterations} iteration(s), ${formatCost(event.costUsd)})
+`
+          );
+        } else {
+          process.stderr.write(
+            `  \u2717 Phase ${event.phase} did not complete (${event.iterations} iteration(s))
+`
+          );
+        }
+        break;
+      // Execution — iteration
+      case "iteration:start": {
+        const laneTag = event.laneId ? `[${event.laneId}] ` : "";
+        process.stderr.write(`
+${laneTag}Iteration ${event.iteration}/${event.maxIterations} `);
+        break;
+      }
+      case "iteration:done": {
+        const laneTag = event.laneId ? `[${event.laneId}] ` : "";
+        const dur = formatDuration(event.durationMs);
+        const costPart = event.costUsd && event.costUsd > 0 ? ` \xB7 ${formatCost(event.costUsd)}` : "";
+        const cumulPart = event.cumulativeCostUsd && event.cumulativeCostUsd > 0 ? ` (total: ${formatCost(event.cumulativeCostUsd)})` : "";
+        const filesPart = event.filesChanged ? ` \xB7 ${event.filesChanged} file(s) changed` : "";
+        const progressPart = event.madeProgress === false ? " \xB7 \x1B[33mno progress\x1B[0m" : "";
+        process.stderr.write(
+          `
+  ${laneTag}\u2713 Iteration ${event.iteration} done (${dur}${costPart}${cumulPart}${filesPart}${progressPart})
+`
+        );
+        if (event.commitSubject) {
+          process.stderr.write(`  commit: ${event.commitSubject}
+`);
+        }
+        break;
+      }
+      case "tool:call": {
+        const laneTag = event.laneId ? `[${event.laneId}] ` : "";
+        const argPart = event.firstArg ? ` ${event.firstArg}` : "";
+        if (process.stderr.isTTY) {
+          process.stderr.write(`\r\x1B[K  ${laneTag}\u2699 ${event.toolName}${argPart}`);
+        } else {
+          process.stderr.write(`  ${laneTag}\u2699 ${event.toolName}${argPart}
+`);
+        }
+        break;
+      }
+      case "cost:update":
+        if (process.stderr.isTTY && event.cumulativeCostUsd > 0) {
+          process.stderr.write(`\r\x1B[K  \u{1F4B0} ${formatCost(event.cumulativeCostUsd)}`);
+        }
+        break;
+      // Errors
+      case "error":
+        process.stderr.write(`
+\x1B[31m\u2717 Error: ${event.message}\x1B[0m
+`);
+        break;
+      case "credential:expired":
+        process.stderr.write(
+          `
+\x1B[31m\u2717 Credentials expired (${event.provider}).\x1B[0m
+  Run \`gs-assume\` and then \`glrs oc autopilot --resume\`.
+`
+        );
+        break;
+      // Verify
+      case "verify:start":
+        process.stderr.write(
+          `  Running ${event.itemCount} verify command(s) for ${event.phase}...
+`
+        );
+        break;
+      case "verify:result":
+        if (event.passed) {
+          process.stderr.write(`  \u2713 ${event.itemId}: ${event.command}
+`);
+        } else {
+          process.stderr.write(`  \u2717 ${event.itemId}: ${event.command}
+`);
+          if (event.stderr) {
+            process.stderr.write(`    ${event.stderr.split("\n").join("\n    ")}
+`);
+          }
+        }
+        break;
+      case "verify:done":
+        if (event.failed === 0) {
+          process.stderr.write(
+            `  \u2713 All ${event.passed} verify command(s) passed
+`
+          );
+        } else {
+          process.stderr.write(
+            `  \u2717 ${event.failed} verify command(s) failed (${event.passed} passed)
+`
+          );
+        }
+        break;
+      case "thinking":
+        if (process.stderr.isTTY) {
+          const dur = event.elapsedSec < 60 ? `${event.elapsedSec}s` : `${Math.floor(event.elapsedSec / 60)}m${(event.elapsedSec % 60).toString().padStart(2, "0")}s`;
+          process.stderr.write(`\r\x1B[K  \u{1F4AD} thinking\u2026 ${dur} \xB7 ${event.chars} chars`);
+        }
+        break;
+    }
+  };
+  emitter.on("event", handler);
+  return {
+    unsubscribe: () => {
+      emitter.off("event", handler);
+    }
+  };
+}
+
+// src/commands/autopilot.ts
+var autopilotInteractiveCmd = command({
+  name: "autopilot",
+  description: "Run the autopilot. Use -p <path> to provide a plan, or omit to pick one interactively. Use -f for fast-model execution. Use --status to check the current run status.",
+  args: {
+    plan: option({
+      long: "plan",
+      short: "p",
+      type: optional(stringType),
+      description: "Path to an existing plan file or directory. If omitted, opens an interactive file picker."
+    }),
+    fast: flag({
+      long: "fast",
+      short: "f",
+      description: "Use the fast executor model (mid-execute tier). Enriches the plan first so cheaper models can execute reliably."
+    }),
+    resume: flag({
+      long: "resume",
+      description: "Resume from .agent/autopilot-checkpoint.json: skip phases listed in completedPhases (when the checkpoint's planPath matches --plan)."
+    }),
+    maxIterationsPerPhase: option({
+      long: "max-iterations-per-phase",
+      type: optional(numberType),
+      description: "Per-phase iteration budget. Override the tier default (deep=5, mid-execute/autopilot-execute=10, fast=10). A phase that hits this budget without completing is treated as a soft failure: a checkpoint is written, a warning is logged, and the run continues to the next phase."
+    }),
+    parallel: option({
+      long: "parallel",
+      type: optional(numberType),
+      description: "Number of parallel lanes for phase execution (default: 1 = sequential). When >1, phases that touch disjoint files run concurrently in per-lane git worktrees, merged back on completion. Conflicting phases (sharing any file) still run sequentially. The orchestrator falls back to the sequential path when no parallelism is possible (every phase shares a file)."
+    }),
+    ship: flag({
+      long: "ship",
+      description: 'After all phases complete and verify passes, push the current branch and open a PR via `gh pr create`. Without this flag, the autopilot stops at "all phases complete, run `/ship` to finalize." The PR title is the plan\'s H1; the PR body is main.md verbatim. Refuses to push from main/master/detached HEAD.'
+    }),
+    status: flag({
+      long: "status",
+      description: "Read and pretty-print the current autopilot status from .agent/autopilot-status.json. Exits 0 if found, 1 if not running."
+    })
+  },
+  handler: async ({ plan, fast, resume, maxIterationsPerPhase, parallel, ship, status }) => {
+    const cwd = process.cwd();
+    if (status) {
+      const eventFilePath = path.join(cwd, ".agent", "autopilot-events.jsonl");
+      const legacyStatusFilePath = path.join(cwd, ".agent", "autopilot-status.json");
+      if (fs.existsSync(eventFilePath)) {
+        try {
+          const reader = new EventStreamReader(eventFilePath);
+          const events = reader.readAll();
+          const handle = deriveState(events);
+          if (!handle) {
+            process.stderr.write("Event stream found but contains no session:start event.\n");
+            process.exit(1);
+          }
+          const elapsedMs = Date.now() - new Date(handle.startedAt).getTime();
+          const elapsed = formatElapsed(elapsedMs);
+          const cost = formatCost2(handle.cost, false);
+          process.stdout.write("\n\x1B[1mAutopilot Status\x1B[0m\n\n");
+          process.stdout.write(`  Plan:       ${handle.planPath}
+`);
+          process.stdout.write(`  Status:     ${handle.status}
+`);
+          process.stdout.write(`  Elapsed:    ${elapsed}
+`);
+          process.stdout.write(`  Iterations: ${handle.totalIterations} completed
+`);
+          process.stdout.write(`  Cost:       ${cost}
+`);
+          if (handle.currentPhase) {
+            process.stdout.write(`  Phase:      ${handle.currentPhase.phase} (${handle.currentPhase.current}/${handle.currentPhase.total})
+`);
+          }
+          if (handle.currentIteration) {
+            process.stdout.write(`  Iteration:  ${handle.currentIteration.iteration}/${handle.currentIteration.max}
+`);
+          }
+          if (handle.enrichProgress) {
+            process.stdout.write(`  Enriching:  ${handle.enrichProgress.done}/${handle.enrichProgress.total} files
+`);
+          }
+          if (handle.verifyProgress) {
+            process.stdout.write(`  Verifying:  ${handle.verifyProgress.passed}/${handle.verifyProgress.total} passed
+`);
+          }
+          if (handle.exitReason) {
+            process.stdout.write(`  Exit:       ${handle.exitReason}
+`);
+          }
+          if (handle.error) {
+            process.stdout.write(`  \x1B[31m\u26A0 Error: ${handle.error}\x1B[0m
+`);
+          }
+          process.stdout.write(`  Updated:    ${handle.lastEventAt}
+`);
+          process.stdout.write("\n");
+          process.exit(0);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          process.stderr.write(`Failed to read event stream: ${msg}
+`);
+          process.exit(1);
+        }
+      }
+      if (fs.existsSync(legacyStatusFilePath)) {
+        try {
+          const raw = fs.readFileSync(legacyStatusFilePath, "utf8");
+          const state = JSON.parse(raw);
+          const elapsed = state.elapsedMs !== void 0 ? formatElapsed(state.elapsedMs) : formatElapsed(Date.now() - state.startedAt);
+          const cost = formatCost2(state.cumulativeCostUsd, state.costIsEstimated);
+          process.stdout.write("\n\x1B[1mAutopilot Status\x1B[0m (legacy)\n\n");
+          process.stdout.write(`  Elapsed:    ${elapsed}
+`);
+          process.stdout.write(`  Iterations: ${state.iterationsCompleted} completed
+`);
+          process.stdout.write(`  Cost:       ${cost}
+`);
+          if (state.phaseCount !== void 0) {
+            process.stdout.write(`  Phase:      ${state.phasesCompleted ?? 0}/${state.phaseCount}
+`);
+          }
+          if (state.mainCheckboxesTotal !== void 0) {
+            process.stdout.write(`  Checkboxes: ${state.mainCheckboxesCompleted ?? 0}/${state.mainCheckboxesTotal}
+`);
+          }
+          process.stdout.write(`  Progress:   ${state.lastIterationProgress ? "\u2713 made progress" : "\u25CB no progress"}
+`);
+          if (state.lastIterationErrored) {
+            process.stdout.write(`  \x1B[31m\u26A0 Last iteration errored\x1B[0m
+`);
+          }
+          if (state.writtenAt) {
+            process.stdout.write(`  Updated:    ${state.writtenAt}
+`);
+          }
+          process.stdout.write("\n");
+          process.exit(0);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          process.stderr.write(`Failed to read legacy status file: ${msg}
+`);
+          process.exit(1);
+        }
+      }
+      process.stderr.write("No autopilot status found. Is autopilot running?\n");
+      process.stderr.write(`  Checked: ${eventFilePath}
+`);
+      process.stderr.write(`  Checked: ${legacyStatusFilePath}
+`);
+      process.exit(1);
+    }
+    let planPath = plan;
+    if (!planPath) {
+      const { pickPlanFile } = await import("./plan-picker.js");
+      const picked = await pickPlanFile(process.cwd());
+      if (!picked) {
+        process.stderr.write("No plan selected.\n");
+        process.exit(0);
+      }
+      planPath = picked;
+    }
+    const { validatePlan } = await import("@glrs-dev/autopilot");
+    const validation = validatePlan(path.resolve(process.cwd(), planPath));
+    for (const w of validation.warnings) {
+      process.stderr.write(`  \u26A0 ${w.message}${w.file ? ` (${w.file})` : ""}
+`);
+    }
+    if (validation.errors.length > 0) {
+      process.stderr.write(
+        `
+\x1B[31m\u2717 Plan validation failed:\x1B[0m
+`
+      );
+      for (const e of validation.errors) {
+        process.stderr.write(
+          `  ${e.message}${e.file ? ` (${e.file})` : ""}
+`
+        );
+      }
+      process.exit(1);
+    }
+    if (fast && planPath) {
+      process.stderr.write("\n\x1B[1m\u2192 Enriching plan for fast execution\x1B[0m (deep model reads codebase, adds context)\n");
+      process.stderr.write("  Adding mirror refs, code pointers, and conventions...\n");
+    }
+    const runner = new SessionRunner({
+      planPath: path.resolve(process.cwd(), planPath),
+      cwd: process.cwd(),
+      fast,
+      resume,
+      maxIterationsPerPhase,
+      parallel,
+      ship
+    });
+    const renderer = createCliRenderer(runner.events);
+    const result = await runner.run();
+    renderer.unsubscribe();
+    if (fast && planPath) {
+      process.stderr.write("  \u2713 Plan enriched \u2014 executing with fast model (mid-execute tier)\n\n");
+    }
+    const costStr = result.loopResult.cumulativeCostUsd ? ` \xB7 $${result.loopResult.cumulativeCostUsd.toFixed(2)}` : "";
+    process.stdout.write(
+      `
+\x1B[1m\u2713 Autopilot complete\x1B[0m
+  Plan:   ${result.planPath}
+  Result: ${result.loopResult.exitReason} after ${result.loopResult.iterations} iteration(s)${costStr}
+
+`
+    );
+  }
+});
+export {
+  autopilotInteractiveCmd
+};

package/dist/commands/cleanup.js

@@ -1,9 +1,9 @@
 import {
   cleanup
-} from "../chunk-UXBOTMDY.js";
-import "../chunk-W37UX3U2.js";
+} from "../chunk-2P3ETOT2.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/create.js

@@ -1,10 +1,10 @@
 import {
   create
-} from "../chunk-EM4MJBOD.js";
-import "../chunk-F3AFRUT2.js";
-import "../chunk-W37UX3U2.js";
+} from "../chunk-2AZKRWC6.js";
+import "../chunk-PTIO556V.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/dashboard.d.ts

@@ -0,0 +1,3 @@
+declare function runDashboard(): Promise<void>;
+
+export { runDashboard };