@glrs-dev/cli 2.2.0 → 2.3.0

package/dist/vendor/harness-opencode/dist/scoper-S77SOK7X.js

@@ -0,0 +1,326 @@
+import {
+  createSession,
+  getLastAssistantMessage,
+  sendAndWait,
+  startServer
+} from "./chunk-GCWHRUOK.js";
+
+// src/autopilot/scoper.ts
+import * as fs from "fs";
+import * as path from "path";
+var ANSI_RESET = "\x1B[0m\x1B[2K\r";
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function createSpinner() {
+  let timer = null;
+  let frame = 0;
+  return {
+    start(label = "Thinking") {
+      if (timer) return;
+      frame = 0;
+      const isTTY = process.stderr.isTTY ?? false;
+      if (!isTTY) return;
+      timer = setInterval(() => {
+        const f = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
+        process.stderr.write(`\x1B[2K\r\x1B[36m${f}\x1B[0m ${label}...`);
+        frame++;
+      }, 80);
+    },
+    stop() {
+      if (!timer) return;
+      clearInterval(timer);
+      timer = null;
+      process.stderr.write("\x1B[2K\r");
+    }
+  };
+}
+function parseQuestion(response) {
+  const match = response.match(/^([^\n]{1,199}\?)\s*$/);
+  return match ? match[1] ?? null : null;
+}
+function parseScopeSummary(response) {
+  const match = response.match(/^SCOPE_SUMMARY:\s*\n?([\s\S]+)$/);
+  return match ? match[1]?.trim() ?? null : null;
+}
+function extractScopeCompletePath(output) {
+  const lines = output.split("\n");
+  let lastMatch = null;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("SCOPE_COMPLETE:")) {
+      const rest = trimmed.slice("SCOPE_COMPLETE:".length).trim();
+      if (rest.length > 0) {
+        lastMatch = rest;
+      }
+    }
+  }
+  return lastMatch;
+}
+var DEFAULT_SCOPER_TIMEOUT_MS = 5 * 60 * 1e3;
+var MAX_QUESTIONS = 8;
+var FORCED_FINALIZE_MESSAGE = "You have asked enough questions. Present a SCOPE_SUMMARY for user approval, then write scope.md and emit SCOPE_COMPLETE.";
+var PARSE_RETRY_REMINDER = "Your last response did not follow the strict contract. Respond with EXACTLY one of: (a) a single question (\u2264200 chars, ending with '?'), (b) a scope summary starting with 'SCOPE_SUMMARY:', or (c) the sentinel 'SCOPE_COMPLETE: <absolute-path>'. Nothing else.";
+async function runScoperSession(opts) {
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_SCOPER_TIMEOUT_MS;
+  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 _existsSync = opts._deps?.existsSync ?? fs.existsSync;
+  const _promptUser = opts._deps?.promptUser ?? (async (question) => {
+    const { input } = await import("@inquirer/prompts");
+    return input({ message: question });
+  });
+  const server = await _startServer({ cwd: opts.planDir });
+  const spinner = createSpinner();
+  try {
+    const sessionId = await _createSession(server.client, {
+      cwd: opts.planDir,
+      agentName: "scoper"
+    });
+    const initialPrompt = [
+      "You are running in an inquirer-driven wizard. Follow the strict response contract:",
+      "- Every response must be EXACTLY one of:",
+      "  (a) A single question (\u2264200 chars, ending with '?')",
+      "  (b) A scope summary starting with 'SCOPE_SUMMARY:' for user approval",
+      "  (c) The sentinel 'SCOPE_COMPLETE: <absolute-path>'",
+      "- Do NOT call the question tool. Emit questions as plain assistant text.",
+      "- Start with first-principles questions (WHAT and WHY), not implementation details.",
+      "",
+      `The user wants to build: ${opts.initialGoal}`,
+      "",
+      "Begin by asking your first clarifying question about the problem being solved."
+    ].join("\n");
+    spinner.start("Scoper is thinking");
+    const firstResult = await _sendAndWait(server.client, {
+      sessionId,
+      message: initialPrompt,
+      agentName: "scoper",
+      stallMs: timeoutMs,
+      autoRejectPermissions: true
+    });
+    if (firstResult.kind === "abort") {
+      throw new Error(`Scoper session aborted (timeout after ${timeoutMs}ms).`);
+    }
+    if (firstResult.kind === "stall") {
+      throw new Error(
+        `Scoper session stalled for ${firstResult.stallMs}ms with no idle signal.`
+      );
+    }
+    if (firstResult.kind === "error") {
+      throw new Error(`Scoper session error: ${firstResult.message}`);
+    }
+    let questionsAsked = 0;
+    let parseRetryPending = false;
+    while (true) {
+      const lastMessage = await _getLastAssistantMessage(
+        server.client,
+        sessionId
+      );
+      const scopePath = extractScopeCompletePath(lastMessage);
+      if (scopePath) {
+        spinner.stop();
+        if (!_existsSync(scopePath)) {
+          throw new Error(
+            `Scoper emitted SCOPE_COMPLETE but scope.md does not exist at: ${scopePath}`
+          );
+        }
+        return { scopePath };
+      }
+      if (questionsAsked >= MAX_QUESTIONS) {
+        spinner.start("Finalizing scope");
+        const finalResult = await _sendAndWait(server.client, {
+          sessionId,
+          message: FORCED_FINALIZE_MESSAGE,
+          stallMs: timeoutMs,
+          autoRejectPermissions: true
+        });
+        if (finalResult.kind !== "idle") {
+          throw new Error(
+            `Scoper session failed during forced finalize: ${finalResult.kind}`
+          );
+        }
+        const finalMessage = await _getLastAssistantMessage(
+          server.client,
+          sessionId
+        );
+        const finalScopePath = extractScopeCompletePath(finalMessage);
+        if (finalScopePath) {
+          spinner.stop();
+          if (!_existsSync(finalScopePath)) {
+            throw new Error(
+              `Scoper emitted SCOPE_COMPLETE after forced finalize but scope.md does not exist at: ${finalScopePath}`
+            );
+          }
+          return { scopePath: finalScopePath };
+        }
+        const expectedScopePath = path.join(opts.planDir, opts.slug, "scope.md");
+        if (_existsSync(expectedScopePath)) {
+          spinner.stop();
+          process.stderr.write(
+            `
+  \u26A0 Scoper didn't emit sentinel, but scope.md exists at ${expectedScopePath}. Using it.
+
+`
+          );
+          return { scopePath: expectedScopePath };
+        }
+        spinner.stop();
+        process.stderr.write(
+          `
+  \u26A0 Scoper didn't write scope.md. Constructing from conversation.
+
+`
+        );
+        const scopeDir = path.join(opts.planDir, opts.slug);
+        if (!_existsSync(scopeDir)) {
+          fs.mkdirSync(scopeDir, { recursive: true });
+        }
+        const constructedScope = [
+          `# ${opts.initialGoal}`,
+          "",
+          "## Goal",
+          "",
+          opts.initialGoal,
+          "",
+          "## Scoper conversation summary",
+          "",
+          "The scoper agent asked 8 questions and the user provided answers,",
+          "but the agent did not produce a formal scope.md. The last agent",
+          "response is included below for the plan agent to work from.",
+          "",
+          "### Last agent response",
+          "",
+          finalMessage || "(no response captured)",
+          "",
+          "## Acceptance criteria",
+          "",
+          "- To be determined by the plan agent based on the conversation above.",
+          "",
+          "## Constraints",
+          "",
+          "- To be determined by the plan agent.",
+          "",
+          "## Out of scope",
+          "",
+          "- To be determined by the plan agent.",
+          "",
+          "## Open questions for the plan agent",
+          "",
+          "- The scoper did not complete formally. Review the conversation summary above and fill in the missing sections."
+        ].join("\n");
+        const constructedPath = path.join(scopeDir, "scope.md");
+        fs.writeFileSync(constructedPath, constructedScope);
+        return { scopePath: constructedPath };
+      }
+      const summary = parseScopeSummary(lastMessage);
+      if (summary) {
+        spinner.stop();
+        parseRetryPending = false;
+        process.stderr.write(ANSI_RESET);
+        process.stderr.write(`
+\x1B[1m\u{1F4CB} Scope summary:\x1B[0m
+
+${summary}
+
+`);
+        const approval = await _promptUser("Approve this scope? (yes / or describe what to change)");
+        if (approval.toLowerCase().startsWith("yes") || approval.toLowerCase() === "y" || approval.toLowerCase() === "approve") {
+          spinner.start("Writing scope.md");
+          const writeResult = await _sendAndWait(server.client, {
+            sessionId,
+            message: "The user approved the scope. Write scope.md now and emit SCOPE_COMPLETE.",
+            stallMs: timeoutMs,
+            autoRejectPermissions: true
+          });
+          if (writeResult.kind !== "idle") {
+            throw new Error(
+              `Scoper session failed after scope approval: ${writeResult.kind}`
+            );
+          }
+          continue;
+        } else {
+          spinner.start("Scoper is revising");
+          const reviseResult = await _sendAndWait(server.client, {
+            sessionId,
+            message: approval,
+            stallMs: timeoutMs,
+            autoRejectPermissions: true
+          });
+          if (reviseResult.kind !== "idle") {
+            throw new Error(
+              `Scoper session failed during revision: ${reviseResult.kind}`
+            );
+          }
+          continue;
+        }
+      }
+      const question = parseQuestion(lastMessage);
+      if (question) {
+        parseRetryPending = false;
+        spinner.stop();
+        process.stderr.write(ANSI_RESET);
+        questionsAsked++;
+        const userAnswer = await _promptUser(question);
+        spinner.start("Scoper is thinking");
+        const nextResult = await _sendAndWait(server.client, {
+          sessionId,
+          message: userAnswer,
+          stallMs: timeoutMs,
+          autoRejectPermissions: true
+        });
+        if (nextResult.kind === "abort") {
+          throw new Error(
+            `Scoper session aborted (timeout after ${timeoutMs}ms).`
+          );
+        }
+        if (nextResult.kind === "stall") {
+          throw new Error(
+            `Scoper session stalled for ${nextResult.stallMs}ms with no idle signal.`
+          );
+        }
+        if (nextResult.kind === "error") {
+          throw new Error(`Scoper session error: ${nextResult.message}`);
+        }
+        continue;
+      }
+      if (parseRetryPending) {
+        spinner.stop();
+        throw new Error(
+          `Scoper response did not follow the strict contract after retry. Last response: ${lastMessage.slice(0, 200)}`
+        );
+      }
+      parseRetryPending = true;
+      spinner.start("Retrying");
+      const retryResult = await _sendAndWait(server.client, {
+        sessionId,
+        message: PARSE_RETRY_REMINDER,
+        stallMs: timeoutMs,
+        autoRejectPermissions: true
+      });
+      if (retryResult.kind === "abort") {
+        throw new Error(
+          `Scoper session aborted during parse retry (timeout after ${timeoutMs}ms).`
+        );
+      }
+      if (retryResult.kind === "stall") {
+        throw new Error(
+          `Scoper session stalled during parse retry for ${retryResult.stallMs}ms.`
+        );
+      }
+      if (retryResult.kind === "error") {
+        throw new Error(
+          `Scoper session error during parse retry: ${retryResult.message}`
+        );
+      }
+    }
+  } finally {
+    spinner.stop();
+    await server.shutdown();
+  }
+}
+export {
+  extractScopeCompletePath,
+  parseQuestion,
+  parseScopeSummary,
+  runScoperSession
+};

package/dist/vendor/harness-opencode/dist/skills/spear-protocol/SKILL.md

@@ -14,7 +14,8 @@ Before Scope, run this probe inline (no subagent) — sessions typically start i
 1. `pwd` — confirm working directory.
 2. `git status --short` — see uncommitted work.
 3. `git log --oneline -5` — recent history.
-4. `PLAN_DIR="$(bunx @glrs-dev/harness-plugin-opencode plan-dir 2>/dev/null)" && ls "$PLAN_DIR" 2>/dev/null | tail -5` — plans for this repo.
+4. Resolve the plan dir and list recent plans:
+   `PLAN_BASE="${GLORIOUS_PLAN_DIR:-$HOME/.glorious/opencode}" && GIT_COMMON="$(git rev-parse --git-common-dir 2>/dev/null)" && [ -n "$GIT_COMMON" ] && [[ "$GIT_COMMON" != /* ]] && GIT_COMMON="$PWD/$GIT_COMMON"; REPO_FOLDER="$(basename "$(dirname "$GIT_COMMON")" 2>/dev/null)" && [ -n "$REPO_FOLDER" ] && [ "$REPO_FOLDER" != "." ] && ls "$PLAN_BASE/$REPO_FOLDER/plans" 2>/dev/null | tail -5` — plans for this repo.
 
 For each plan found, read it and count unchecked acceptance items. Classify as **stale** (ignore) only if `git merge-base --is-ancestor HEAD origin/main` (fallback `origin/master`) exits 0. If classification fails, treat as active.
 

package/dist/vendor/harness-opencode/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glrs-dev/harness-plugin-opencode",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glrs-dev/cli",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Unified CLI for the @glrs-dev ecosystem — OpenCode agent harness dispatch + worktree management.",
   "license": "MIT",
   "repository": {
@@ -47,6 +47,8 @@
     "@opencode-ai/sdk": "^1.14",
     "cmd-ts": "^0.15.0",
     "picomatch": "^4.0.4",
+    "pino": "^10.3.1",
+    "pino-pretty": "^13.1.3",
     "ulid": "^3.0.2",
     "yaml": "^2.8.3",
     "zod": "4.1.8"

package/dist/vendor/harness-opencode/dist/bin/plan-check.sh

@@ -1,255 +0,0 @@
-#!/usr/bin/env bash
-# plan-check.sh — parse a plan file's plan-state fence and report on it.
-#
-# Modes:
-#   plan-check.sh <path>        Prints a summary line then one line per item:
-#                               `total=N done=M pending=K invalid=I`
-#                               `STATUS ID VERIFY`  (one per item)
-#
-#   plan-check.sh --run <path>  Prints the verify command of each PENDING
-#                               item on stdout, one per line, raw. The
-#                               caller is responsible for executing them.
-#                               This script NEVER executes verify commands
-#                               itself — that would bypass the caller's
-#                               bash-permission scope.
-#
-#   plan-check.sh --check <path>
-#                               Structural validation only. Exits 1 if any
-#                               fence item is missing a required field.
-#
-# Fence format, inside `## Acceptance criteria`:
-#
-#   ```plan-state
-#   - [ ] id: a1
-#     intent: Prose description of business intent (one line).
-#     tests:
-#       - path/to/test.sh::"some test name"
-#       - path/to/other.ts::"another test"
-#     verify: bash path/to/test.sh
-#
-#   - [x] id: a2
-#     ...
-#   ```
-#
-# Backward compat: a plan without a ```plan-state fence emits the line
-# `legacy` and exits 0 — callers treat it as "old format, fall back".
-#
-# Portability: POSIX bash + awk + grep only. No sed -i.
-
-set -eu
-
-MODE=""
-PLAN_PATH=""
-
-case "${1:-}" in
-  --run)   MODE=run;    PLAN_PATH="${2:-}" ;;
-  --check) MODE=check;  PLAN_PATH="${2:-}" ;;
-  -h|--help|"")
-    sed -n '2,34p' "$0"
-    exit 0
-    ;;
-  *)       MODE=summary; PLAN_PATH="${1:-}" ;;
-esac
-
-if [[ -z "${PLAN_PATH:-}" ]]; then
-  echo "plan-check.sh: missing plan path" >&2
-  exit 2
-fi
-
-if [[ ! -f "$PLAN_PATH" ]]; then
-  echo "plan-check.sh: file not found: $PLAN_PATH" >&2
-  exit 2
-fi
-
-# Extract the plan-state fence body into a temp file. awk state machine:
-# enter `## Acceptance criteria`, enter ``` plan-state, exit on next ```.
-FENCE_BODY="$(awk '
-  /^## Acceptance criteria/ { in_ac = 1; next }
-  /^## / && in_ac && !in_fence { in_ac = 0 }
-  in_ac && /^```plan-state[[:space:]]*$/ { in_fence = 1; next }
-  in_fence && /^```[[:space:]]*$/ { in_fence = 0; next }
-  in_fence { print }
-' "$PLAN_PATH")"
-
-if [[ -z "$FENCE_BODY" ]]; then
-  # No fence found — legacy plan. Report and exit cleanly.
-  if [[ "$MODE" == "summary" ]]; then
-    echo "legacy (no plan-state fence)"
-  fi
-  # --run on a legacy plan emits nothing (no commands to run).
-  # --check on a legacy plan succeeds (we're accepting legacy plans).
-  exit 0
-fi
-
-# Parse items. awk state machine:
-# - A line `- [ ] id: ID` or `- [x] id: ID` starts a new item.
-# - While inside an item, indented keys `intent:`, `tests:`, `verify:` set
-#   fields. Under `tests:`, subsequent `  - ...` lines extend the list
-#   until the next key or the next item.
-# - Items are separated by one or more blank lines OR by the next `- [`.
-#
-# We emit a tab-delimited record per item:
-#   STATUS<TAB>ID<TAB>INTENT<TAB>TESTS<TAB>VERIFY
-# TESTS is a `|`-delimited list. Missing fields are the empty string.
-PARSED="$(echo "$FENCE_BODY" | awk '
-  function flush() {
-    if (cur_id != "") {
-      # Trim trailing/leading whitespace on each field
-      gsub(/^[[:space:]]+|[[:space:]]+$/, "", cur_intent)
-      gsub(/^[[:space:]]+|[[:space:]]+$/, "", cur_verify)
-      gsub(/^\||\|$/, "", cur_tests)
-      printf "%s\t%s\t%s\t%s\t%s\n", cur_status, cur_id, cur_intent, cur_tests, cur_verify
-    }
-    cur_status = ""; cur_id = ""; cur_intent = ""; cur_tests = ""; cur_verify = ""
-    in_tests = 0
-  }
-
-  /^-[[:space:]]+\[[[:space:]xX[:space:]]\][[:space:]]+id:/ {
-    flush()
-    status = $0
-    sub(/^-[[:space:]]+\[[[:space:]]*/, "", status)
-    sub(/\].*$/, "", status)
-    # status is either empty/space (" ") -> pending, or "x"/"X" -> done
-    if (status ~ /[xX]/) cur_status = "done"; else cur_status = "pending"
-    # Capture id
-    id_part = $0
-    sub(/^.*id:[[:space:]]*/, "", id_part)
-    cur_id = id_part
-    next
-  }
-
-  /^[[:space:]]*intent:/ {
-    field = $0
-    sub(/^[[:space:]]*intent:[[:space:]]*/, "", field)
-    cur_intent = field
-    in_tests = 0
-    next
-  }
-
-  /^[[:space:]]*intent\b/ {
-    # already handled
-    next
-  }
-
-  /^[[:space:]]*tests:/ {
-    in_tests = 1
-    next
-  }
-
-  /^[[:space:]]*verify:/ {
-    field = $0
-    sub(/^[[:space:]]*verify:[[:space:]]*/, "", field)
-    cur_verify = field
-    in_tests = 0
-    next
-  }
-
-  # Continuation lines inside tests: list
-  in_tests && /^[[:space:]]+-[[:space:]]/ {
-    line = $0
-    sub(/^[[:space:]]+-[[:space:]]+/, "", line)
-    if (cur_tests == "") cur_tests = line
-    else cur_tests = cur_tests "|" line
-    next
-  }
-
-  # Continuation line for intent (indented without `-`, after intent is set
-  # and before another key). Append with a space separator.
-  !in_tests && /^[[:space:]]{4,}[^-[:space:]]/ && cur_id != "" && cur_intent != "" && cur_verify == "" {
-    line = $0
-    sub(/^[[:space:]]+/, "", line)
-    cur_intent = cur_intent " " line
-    next
-  }
-
-  END { flush() }
-' 2>&1)"
-
-# If PARSED contains awk errors, surface them as invalid.
-if echo "$PARSED" | grep -q '^awk:'; then
-  echo "plan-check.sh: parser error" >&2
-  echo "$PARSED" >&2
-  exit 3
-fi
-
-# Count totals.
-total=0
-done_count=0
-pending_count=0
-invalid_count=0
-invalid_reasons=()
-
-while IFS=$'\t' read -r status id intent tests verify; do
-  [[ -z "$status" ]] && continue
-  total=$((total + 1))
-  if [[ -z "$id" ]]; then
-    invalid_count=$((invalid_count + 1))
-    invalid_reasons+=("missing id")
-    continue
-  fi
-  if [[ -z "$intent" ]]; then
-    invalid_count=$((invalid_count + 1))
-    invalid_reasons+=("$id: missing intent")
-    continue
-  fi
-  if [[ -z "$tests" ]]; then
-    invalid_count=$((invalid_count + 1))
-    invalid_reasons+=("$id: missing tests")
-    continue
-  fi
-  if [[ -z "$verify" ]]; then
-    invalid_count=$((invalid_count + 1))
-    invalid_reasons+=("$id: missing verify")
-    continue
-  fi
-  if [[ "$status" == "done" ]]; then
-    done_count=$((done_count + 1))
-  else
-    pending_count=$((pending_count + 1))
-  fi
-done <<< "$PARSED"
-
-case "$MODE" in
-  summary)
-    printf 'total=%d done=%d pending=%d invalid=%d\n' \
-      "$total" "$done_count" "$pending_count" "$invalid_count"
-    while IFS=$'\t' read -r status id intent tests verify; do
-      [[ -z "$status" ]] && continue
-      # For the summary-per-item line, prefer displaying the verify
-      # command (truncated) so the reader sees what gates each item.
-      v="${verify:0:60}"
-      if [[ -n "$verify" && ${#verify} -gt 60 ]]; then v="${v}…"; fi
-      printf '%s %s %s\n' "$status" "$id" "$v"
-    done <<< "$PARSED"
-    if [[ "$invalid_count" -gt 0 ]]; then
-      echo "invalid:"
-      for r in "${invalid_reasons[@]}"; do
-        echo "  $r"
-      done
-    fi
-    ;;
-
-  run)
-    # Emit verify command per PENDING item, one per line. Skip done items,
-    # skip invalid items. Caller executes via their own bash permission.
-    while IFS=$'\t' read -r status id intent tests verify; do
-      [[ -z "$status" ]] && continue
-      [[ "$status" == "done" ]] && continue
-      [[ -z "$verify" ]] && continue
-      [[ -z "$intent" || -z "$tests" ]] && continue
-      echo "$verify"
-    done <<< "$PARSED"
-    ;;
-
-  check)
-    # Structural validation. Exit 1 if anything invalid.
-    if [[ "$invalid_count" -gt 0 ]]; then
-      echo "plan-check: $invalid_count invalid item(s):" >&2
-      for r in "${invalid_reasons[@]}"; do
-        echo "  $r" >&2
-      done
-      exit 1
-    fi
-    printf 'ok: %d item(s) pass structural validation\n' "$total"
-    ;;
-esac