@open-tomato/rafa 0.16.0 → 0.17.0

package/dist/{index-kph6p7rp.js → index-r7cnr44m.js}

@@ -44,6 +44,7 @@ import {
   announceRiskTotal,
   assessPlanRisk,
   blockedFaultMessage,
+  blockedLineSentence,
   boardId,
   branchClaims,
   checkbox,
@@ -86,6 +87,7 @@ import {
   ghHostOf,
   ghIssueReader,
   ghMissingMessage,
+  ghNextBoard,
   ghPreflightItems,
   ghPullRequestsIn,
   ghUnauthenticatedMessage,
@@ -139,6 +141,8 @@ import {
   readAgentDirectory,
   readAuthorTrust,
   readBlockedBy,
+  readBranch,
+  readBranchPlan,
   readChoice,
   readChoiceFlag,
   readCopyRefs,
@@ -148,7 +152,9 @@ import {
   readMergeRefusal,
   readNextState,
   readNonBlankFlag,
+  readOpenPull,
   readPlanChanges,
+  readPlans,
   readRecords,
   readRefsText,
   readRequiredFlag,
@@ -210,7 +216,7 @@ import {
   waitForChecks,
   writeFrontmatter,
   writeSession
-} from "./index-1vtd5fr7.js";
+} from "./index-4qd537z6.js";
 import {
   FINDING_KINDS,
   FINDING_SIGNALS,
@@ -218,6 +224,7 @@ import {
   findNextTask,
   isStampableStub,
   loadPlanPrerequisites,
+  malformedPrerequisiteLines,
   mergePlanPrerequisites,
   parsePlan,
   parsePrerequisites,
@@ -225,7 +232,7 @@ import {
   runPreflight,
   splitBlockerComment,
   trackerPathFor
-} from "./index-krjzghpz.js";
+} from "./index-64wec0k7.js";
 import {
   CORE_ADAPTER_REGISTRY,
   EFFORT_STORE_DIR,
@@ -243,7 +250,7 @@ import {
   spawnClaudeCaptured,
   sqliteStorePath,
   typeOfLabels
-} from "./index-q491ekzm.js";
+} from "./index-7t0qz29r.js";
 import {
   CONFIG_DEFAULTS,
   CONFIG_FILE,
@@ -252,7 +259,7 @@ import {
   configFilePath,
   parseConfigText,
   readRafaBlocks
-} from "./index-6cw1n0qy.js";
+} from "./index-ps5sac9p.js";
 import {
   createCommandRegistry,
   describeRegistry,
@@ -8355,6 +8362,17 @@ async function loadItems(plan2, config) {
     throw refusal2(["rafa doctor: the plan's prerequisites cannot be read:", `  ${messageOf(error)}`]);
   }
 }
+function refuseMalformedItems(plan2, items) {
+  if (plan2 === null || items.malformed.length === 0)
+    return;
+  const file = basename6(prerequisitesPathForPlan(plan2) ?? plan2);
+  const [head = "", ...rest] = malformedPrerequisiteLines(file, items.malformed);
+  throw refusal2([
+    `rafa doctor: ${head}`,
+    ...rest,
+    "rafa loop start would refuse here, before any probe. No run was started and nothing was stored."
+  ]);
+}
 function mergedFile(plan2) {
   const file = plan2 === null ? null : prerequisitesPathForPlan(plan2);
   return file !== null && isFile(file) ? file : null;
@@ -8388,6 +8406,7 @@ async function checkPreflight(context, project, seams) {
   const { config } = resolved;
   const { plan: plan2, lookedFor } = choosePlan(project.root, config, named);
   const items = await loadItems(plan2, config);
+  refuseMalformedItems(plan2, items);
   const automatic = readProvider(project.root, config, seams);
   const start2 = readStartTier(plan2, items);
   const tiers = {
@@ -9177,7 +9196,9 @@ var CONFIG_SETTINGS_LINES = Object.freeze([
   `#   worktreeIdleDays: ${String(CONFIG_DEFAULTS.cleanupWorktreeIdleDays)}          # days before rafa cleanup lists a worktree as idle`,
   "#   keep: []                     # glob patterns naming branches rafa cleanup never lists",
   "# dangerous:",
-  `#   acceptStaleRefs: ${String(CONFIG_DEFAULTS.dangerousAcceptStaleRefs)}       # true plans past dangling and suspect spec references on every run`
+  `#   acceptStaleRefs: ${String(CONFIG_DEFAULTS.dangerousAcceptStaleRefs)}       # true plans past dangling and suspect spec references on every run`,
+  "# status:",
+  `#   notice: ${String(CONFIG_DEFAULTS.statusNotice)}                 # false drops the one-line notice of what is new since the last command`
 ]);
 var VERSION_LINE = `version: ${String(CONFIG_DEFAULTS.version)}`;
 var PROJECT_HEADER = Object.freeze([
@@ -12758,7 +12779,7 @@ function openPrContext(context, seams = DEFAULT_PR_SEAMS) {
     readRemote: seams.readRemote
   }));
   const makeProvider = seams.pullRequests ?? ghPullRequestsIn;
-  const readBranch = seams.readBranch ?? gitBranch;
+  const readBranch2 = seams.readBranch ?? gitBranch;
   return {
     project,
     reading,
@@ -12768,7 +12789,7 @@ function openPrContext(context, seams = DEFAULT_PR_SEAMS) {
     resolveBudget: config.prResolveBudget,
     trustedAuthors: config.boardTrustedAuthors,
     roadmapIssue: config.roadmapIssue,
-    readBranch: () => readBranch(project.root)
+    readBranch: () => readBranch2(project.root)
   };
 }
 async function onProvider(doing, call) {
@@ -16543,7 +16564,7 @@ function readUntagged(root, configured, tags) {
   const released = changelogVersions(text);
   return { path: configured, released, versions: untaggedVersions(released, tags), problem: null };
 }
-function readBranch(git) {
+function readBranch2(git) {
   const result = git(["rev-parse", "--abbrev-ref", "HEAD"]);
   const branch = result.stdout.trim();
   return result.ok && branch !== "" && branch !== "HEAD" ? branch : null;
@@ -16707,7 +16728,7 @@ function readStatus(context, seams = DEFAULT_RELEASE_SEAMS) {
     versionFile: readVersionFile(project.root, config.versionFile),
     tags,
     untagged: readUntagged(project.root, config.changelog, tags.tags),
-    plan: readPending(project.root, asked, readBranch(git), planStubsUnder(project.root, config.planDir), readNotes)
+    plan: readPending(project.root, asked, readBranch2(git), planStubsUnder(project.root, config.planDir), readNotes)
   };
   return { reading, text: renderStatus2(reading) };
 }
@@ -16758,7 +16779,7 @@ var DEFAULT_RELEASE_BRANCH = "main";
 var DEFAULT_REGISTRY = "https://registry.npmjs.org";
 var RELEASE_REMOTE = "origin";
 var INDENT9 = "  ";
-function readBranch2(git) {
+function readBranch3(git) {
   const result = git(["rev-parse", "--abbrev-ref", "HEAD"]);
   if (!result.ok) {
     return { branch: null, problem: `the branch could not be read: ${gitSaid(result)}` };
@@ -16910,7 +16931,7 @@ function tagConfig(project, warn) {
 function readTagInputs(root, git, config) {
   return {
     releaseBranch: config.releaseBranch,
-    branch: readBranch2(git),
+    branch: readBranch3(git),
     version: readVersion(root, config.versionFile),
     changelog: readNewestRelease(root, config.changelog),
     tags: readTags(git)
@@ -19411,6 +19432,335 @@ function createSkillShowCommand(seams = DEFAULT_SKILL_SHOW_SEAMS) {
 }
 var show_default6 = createSkillShowCommand();
 
+// src/status/render.ts
+var STATUS_SECTION_TITLES = Object.freeze({
+  branch: "Branch",
+  loops: "Loops",
+  pull: "Pull request",
+  board: "Board",
+  housekeeping: "Housekeeping"
+});
+var INDENT10 = "  ";
+var MERGEABILITY_WORDS = Object.freeze({
+  mergeable: "mergeable",
+  conflicting: "conflicting",
+  unknown: "mergeability unknown"
+});
+var VERDICT_WORDS = Object.freeze({
+  green: "checks green",
+  red: "checks red",
+  pending: "checks pending",
+  none: "no checks"
+});
+function counted3(count, noun, plural5 = `${noun}s`) {
+  return `${String(count)} ${count === 1 ? noun : plural5}`;
+}
+function info(text) {
+  return { level: "info", text };
+}
+function branchText(reading) {
+  const plan2 = reading.plan === null ? "no plan" : `plan \`${reading.plan.stub}\` (${formatCounts(reading.plan.tasks)})`;
+  return `\`${reading.branch}\`, ${plan2}`;
+}
+function blockedTaskCount(blocked) {
+  return blocked.reduce((sum, one) => sum + one.tasks.length, 0);
+}
+function loopsText(reading) {
+  const tasks = blockedTaskCount(reading.blocked);
+  return `${String(reading.live.length)} running, ${counted3(tasks, "task")} blocked`;
+}
+function loopsBody(reading) {
+  const running = reading.live.map((record) => info(`${INDENT10}${sessionLine(record)}`));
+  const blocked = reading.blocked.flatMap((one) => one.tasks.map((task) => {
+    const blocker = task.blocker === null ? "" : ` (${task.blocker})`;
+    return info(`${INDENT10}blocked: plan \`${planLabel(one.session)}\` line ${String(task.line)}: ${task.text}${blocker}`);
+  }));
+  return [...running, ...blocked];
+}
+function pullText(reading) {
+  if (reading.pull === null)
+    return "none open";
+  const { summary, mergeable, verdict } = reading.pull;
+  return `#${String(summary.number)} ${summary.title}, ${MERGEABILITY_WORDS[mergeable]}, ${VERDICT_WORDS[verdict]}`;
+}
+function boardText(reading) {
+  const roadmap = `roadmap #${String(reading.roadmap)}`;
+  const next = reading.next === null ? `${roadmap} has no line left` : `next is #${String(reading.next.line.issue)} on ${roadmap}, ${nextStanding(reading.next)}`;
+  const blocked = reading.blockedIssues === null ? `the ${SPEC_BLOCKED_LABEL} issues were not read` : `${counted3(reading.blockedIssues, "issue")} labelled ${SPEC_BLOCKED_LABEL}`;
+  return `${next}; ${blocked}`;
+}
+function nextStanding(next) {
+  if (next.blocked !== null)
+    return blockedLineSentence(next.blocked);
+  return next.ready ? "ready" : "not ready";
+}
+function housekeepingText(reading) {
+  const { merged: merged2, stale, notPushed, worktrees } = reading.counts;
+  return `${String(merged2)} merged, ${String(stale)} stale, ${String(notPushed)} not pushed,` + ` ${counted3(worktrees, "worktree")} (${String(reading.idleWorktrees)} idle)`;
+}
+function sectionLines(key, section, text, body = () => []) {
+  const title = STATUS_SECTION_TITLES[key];
+  if (!section.read)
+    return [{ level: "warn", text: `${title}: not read: ${section.problem}` }];
+  return [info(`${title}: ${text(section)}`), ...body(section)];
+}
+function renderStatus3(sections) {
+  return [
+    ...sectionLines("branch", sections.branch, branchText),
+    ...sectionLines("loops", sections.loops, loopsText, loopsBody),
+    ...sectionLines("pull", sections.pull, pullText),
+    ...sectionLines("board", sections.board, boardText),
+    ...sectionLines("housekeeping", sections.housekeeping, housekeepingText)
+  ];
+}
+function sectionData(section) {
+  const copy = JSON.parse(JSON.stringify(section));
+  const reading = Object.fromEntries(Object.entries(copy).filter(([key]) => key !== "read"));
+  return { read: section.read, ...reading };
+}
+function statusData(sections) {
+  return {
+    branch: sectionData(sections.branch),
+    loops: sectionData(sections.loops),
+    pull: sectionData(sections.pull),
+    board: sectionData(sections.board),
+    housekeeping: sectionData(sections.housekeeping)
+  };
+}
+
+// src/status/sections.ts
+var STATUS_NETWORK_TIMEOUT_MS = 5000;
+function isIdleWorktree(row) {
+  return !row.blockers.some((blocker) => blocker.kind === "recent");
+}
+function unread2(problem2) {
+  return { read: false, problem: problem2 };
+}
+function read2(reading) {
+  return { ...reading, read: true };
+}
+function localSection(work) {
+  try {
+    const reading = work();
+    return isUnread(reading) ? reading : read2(reading);
+  } catch (error) {
+    return unread2(messageOf(error));
+  }
+}
+function isUnread(value) {
+  return typeof value === "object" && value !== null && value.read === false;
+}
+function openDeadline(ms) {
+  let endsAt = null;
+  return {
+    ms,
+    start: () => {
+      endsAt = Date.now() + ms;
+    },
+    left: () => endsAt === null ? ms : endsAt - Date.now()
+  };
+}
+function boundedRunner(open, root, deadline) {
+  return (args) => {
+    const left = deadline.left();
+    if (left <= 0) {
+      return Promise.resolve({
+        ok: false,
+        stdout: "",
+        stderr: `gh ${args.join(" ")} was not run: the ${String(deadline.ms)}ms network deadline had passed`
+      });
+    }
+    return open(root, left)(args);
+  };
+}
+async function networkSection(what, deadline, work) {
+  let timer;
+  const expired = new Promise((resolve18) => {
+    timer = setTimeout(() => {
+      resolve18(unread2(`the ${what} was not read within the ${String(deadline.ms)}ms network deadline`));
+    }, Math.max(0, deadline.left()));
+  });
+  try {
+    return await Promise.race([work().then((reading) => read2(reading)), expired]);
+  } catch (error) {
+    return unread2(messageOf(error));
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function notGhProblem(what, provider) {
+  const from = provider.source === "config" ? "as the config names it" : "as origin is no GitHub remote";
+  return `pr.provider is ${provider.provider}, ${from}, and rafa status reads the ${what} through gh alone`;
+}
+function readBranchSection(sources) {
+  let notes = [];
+  const note = (problem2) => {
+    notes = [...notes, problem2];
+  };
+  const branch = readBranch(sources, note);
+  if (branch === "") {
+    return unread2(notes.join("; ") || "the branch at the project root could not be read");
+  }
+  const plans = readPlans(sources, note);
+  return { branch, plan: readBranchPlan(branch, plans), notes };
+}
+function blockedSessions(root, records) {
+  let seen = new Set;
+  let found = [];
+  for (const session of [...records].reverse()) {
+    const checklist = readSessionChecklist(root, session);
+    if (checklist === null || seen.has(checklist.file))
+      continue;
+    seen = new Set([...seen, checklist.file]);
+    const tasks = blockedTasks(checklist);
+    if (tasks.length > 0)
+      found = [...found, { session, checklist: checklist.file, tasks }];
+  }
+  return found;
+}
+function readLoopsSection(root, sources) {
+  return localSection(() => {
+    const records = sources.runs();
+    return { live: records.filter((record) => isLive(record)), blocked: blockedSessions(root, records) };
+  });
+}
+function pullSection(sources, branch, provider, deadline) {
+  if (provider.provider !== "gh")
+    return Promise.resolve(unread2(notGhProblem("pull request", provider)));
+  if (!branch.read) {
+    return Promise.resolve(unread2(`no pull request was looked for, as the branch was not read: ${branch.problem}`));
+  }
+  return networkSection("pull request", deadline, () => readPull(sources, branch.branch));
+}
+async function readPull(sources, branch) {
+  let notes = [];
+  const pull = await readOpenPull(sources, branch, (problem2) => {
+    notes = [...notes, problem2];
+  });
+  return { pull, notes };
+}
+async function readBoard(board, blocked) {
+  const [walk, report3] = await Promise.all([board.next(), blocked]);
+  const { line } = walk;
+  const next = line === null ? null : { line, ready: await board.isReady(line.issue), blocked: await board.blocking(line.issue) };
+  const listed2 = report3.problem === null ? [] : [`the issues labelled ${SPEC_BLOCKED_LABEL} could not be read: ${report3.problem}`];
+  return {
+    roadmap: walk.roadmap,
+    next,
+    passed: walk.passed,
+    blockedIssues: report3.problem === null ? report3.readings.length : null,
+    notes: [...walk.problems, ...listed2]
+  };
+}
+async function readHousekeeping(input, cleanup, now) {
+  try {
+    const settings = doctorCleanupSettings({ root: input.root, home: input.home, config: input.config, gh: null }, now);
+    const reading = await readCleanup(cleanup, settings);
+    if (!reading.ok)
+      return unread2(reading.detail);
+    const idle = reading.worktrees.filter((row) => isIdleWorktree(row));
+    return read2({ counts: cleanupCounts(reading), idleWorktrees: idle.length, notes: reading.notes });
+  } catch (error) {
+    return unread2(messageOf(error));
+  }
+}
+async function readStatusSections(input, seams = {}) {
+  const { root, config } = input;
+  const git = (seams.openGit ?? createGitRunner)(root);
+  const openGh2 = seams.openGh ?? ((cwd, timeoutMs) => createGhRunner({ cwd, timeoutMs }));
+  const deadline = openDeadline(seams.timeoutMs ?? STATUS_NETWORK_TIMEOUT_MS);
+  const gh = boundedRunner(openGh2, root, deadline);
+  const pulls = (seams.pullRequests ?? ((runner) => createGhPullRequests({ gh: runner })))(gh);
+  const board = (seams.board ?? ghNextBoard)({ gh, git, configured: config.roadmapIssue });
+  const sources = {
+    base: config.prBase ?? DEFAULT_BASE_BRANCH,
+    plans: plansDirAt(root, config.planDir),
+    runs: () => readSessions(root, { isAlive: seams.isAlive }),
+    git,
+    pulls,
+    board
+  };
+  const branch = localSection(() => readBranchSection(sources));
+  const loops = readLoopsSection(root, sources);
+  const provider = resolvePrProvider({ configured: config.prProvider, dir: root, readRemote: seams.readRemote });
+  const isGh = provider.provider === "gh";
+  const cleanup = (seams.cleanupSeams ?? defaultCleanupSeams)(root, isGh ? pulls : null);
+  const now = (seams.now ?? (() => new Date))();
+  const blockedIssues = seams.blockedIssues ?? ((runner) => readBlockedIssues({ gh: runner }));
+  deadline.start();
+  const pull = pullSection(sources, branch, provider, deadline);
+  const boardSection = isGh ? networkSection("board", deadline, () => readBoard(board, blockedIssues(gh))) : Promise.resolve(unread2(notGhProblem("board", provider)));
+  const housekeeping = readHousekeeping(input, cleanup, now);
+  return {
+    branch,
+    loops,
+    pull: await pull,
+    board: await boardSection,
+    housekeeping: await housekeeping
+  };
+}
+
+// src/commands/status.ts
+var COMMAND_NAME6 = "rafa status";
+var STATUS_USAGE = "rafa status";
+var STATUS_ARGUMENT_EXIT = 2;
+var DEFAULT_STATUS_SEAMS = Object.freeze({});
+function projectOf15(context) {
+  if (context.project === null)
+    throw new Error("rafa status runs inside a project, and was handed none");
+  return context.project;
+}
+function expectNoWord(args) {
+  if (args.length === 0)
+    return;
+  throw new CommandExit(STATUS_ARGUMENT_EXIT, `\u274C ${COMMAND_NAME6}: expected no argument, got ${String(args.length)}: ${args.join(" ")}
+Usage: ${STATUS_USAGE}`);
+}
+async function runStatus2(context, seams) {
+  expectNoWord(context.args);
+  const project = projectOf15(context);
+  const config = resolveProjectConfig(project, COMMAND_NAME6, (message) => {
+    context.output.warn(message);
+  });
+  const read3 = seams.read ?? ((input) => readStatusSections(input));
+  const sections = await read3({ root: project.root, home: project.home, config });
+  if (context.outputMode === "json") {
+    context.output.result(statusData(sections));
+    return;
+  }
+  for (const line of renderStatus3(sections)) {
+    if (line.level === "warn")
+      context.output.warn(line.text);
+    else
+      context.output.info(line.text);
+  }
+}
+function createStatusCommand(seams = DEFAULT_STATUS_SEAMS) {
+  const command = {
+    name: "status",
+    subject: "status",
+    action: "status",
+    summary: "where the project stands: branch and plan, loops, pull request, board and housekeeping",
+    description: "Prints one line for each of five sections. Branch: the branch checked out at the project root" + " and the plan its `feat/<stub>` names, with its task counts. Loops: how many sessions are running and" + " how many tasks are blocked, with a line under it for each running loop and each blocked task. Pull" + " request: the branch's open pull request, whether it can be merged and its checks. Board: the" + " Roadmap's next issue and whether it is ready, and how many issues carry `spec:blocked`. Housekeeping:" + " what `rafa cleanup` would list, counted per group, and how many worktrees are idle. Git, the session" + " records and the plans are read first; the pull request and the board are read through `gh` under a" + " short deadline, and nothing is fetched. A section that cannot be read is one `warn` line saying why," + " and the others are printed all the same: it exits 1 only for a config that cannot be used. With" + " `--output=json` the five sections are the data of the terminal result event. Starts no session.",
+    args: [],
+    flags: [],
+    examples: [
+      {
+        cmd: "rafa status",
+        note: "Prints the five sections, one line each, with the running loops and blocked tasks under Loops."
+      },
+      {
+        cmd: "rafa status --output=json",
+        note: "Gives the five sections as data, each with `read` and its reading or the problem."
+      }
+    ],
+    outputs: ["text", "json"],
+    run: async (context) => runStatus2(context, seams)
+  };
+  return Object.freeze(command);
+}
+var status_default3 = createStatusCommand();
+
 // src/commands/usage.ts
 var usage_default = wrapPhaseZeroCommand({
   name: "usage",
@@ -19489,6 +19839,7 @@ var CORE_COMMANDS = Object.freeze([
   show_default2,
   status_default2,
   tag_default,
+  status_default3,
   next_default,
   roadmap_default,
   init_default,

package/dist/index.js

@@ -20,7 +20,7 @@ import {
   start,
   usage,
   validateManifest
-} from "./index-1vtd5fr7.js";
+} from "./index-4qd537z6.js";
 import {
   FINDING_KINDS,
   FINDING_SIGNALS,
@@ -38,7 +38,7 @@ import {
   renderInjection,
   runPreflight,
   runShellProbe
-} from "./index-krjzghpz.js";
+} from "./index-64wec0k7.js";
 import {
   CORE_ADAPTER_REGISTRY,
   EFFORT_KEY_PROJECTIONS,
@@ -47,7 +47,7 @@ import {
   openNdjsonStore,
   openSqliteStore,
   selectEffortStore
-} from "./index-q491ekzm.js";
+} from "./index-7t0qz29r.js";
 import {
   CONFIG_DEFAULTS,
   CONFIG_FILE,
@@ -58,7 +58,7 @@ import {
   parseConfigText,
   readRafaBlocks,
   resolveConfig
-} from "./index-6cw1n0qy.js";
+} from "./index-ps5sac9p.js";
 import"./index-qzhpqmfy.js";
 import"./index-p901zs2p.js";
 import {

package/dist/plan/index.js

@@ -16,12 +16,12 @@ import {
   renderInjection,
   runPreflight,
   runShellProbe
-} from "../index-krjzghpz.js";
+} from "../index-64wec0k7.js";
 import {
   RAFA_BLOCK_KINDS,
   isRafaBlockKind,
   readRafaBlocks
-} from "../index-6cw1n0qy.js";
+} from "../index-ps5sac9p.js";
 import {
   INJECT_MODES
 } from "../index-n3rw8rhr.js";

package/dist/plan-prompt.md

@@ -66,7 +66,9 @@ criteria — **do not execute the plan**.
   as a checklist in the PREREQUISITES.md format of the dev-planner
   specification below. Only genuinely non-automatable steps; do not duplicate
   what `README.md`/`AGENTS.md` already require of every contributor. Link to
-  it from the plan.
+  it from the plan. An `[auto]` item holds exactly one backticked span, and
+  that span is its command, ending the item after `: ` and run as written:
+  prove a tool with `<tool> --version`, `<tool> --help` or `which <tool>`.
 * Do not create or touch any tracker file — the loop derives it from the plan.
 
 {PLAN_FORMAT}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-tomato/rafa",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "Alpha. Runs a plan through the ralph loop: one Claude Code session per task, one commit per task, then a pull request and a CI wait.",
   "private": false,
   "publishConfig": {