@open-tomato/rafa 0.34.0 → 0.35.0

package/dist/{index-v8d7c6sw.js → index-41vzahew.js}

@@ -1,13 +1,11 @@
 // @bun
 import {
-  activeOutput,
-  isStampableStub,
-  readRafaBlocks
-} from "./index-vp0xghk2.js";
-import {
+  parseTaskDeclaration,
   messageOf,
-  parseTaskDeclaration
-} from "./index-fzhd3d4y.js";
+  isStampableStub,
+  activeOutput,
+  readRafaBlocks2
+} from "./index-2tjmxwvp.js";
 // src/preflight/prerequisites-md.ts
 import { basename, dirname, join } from "path";
 var SECTION_AUTO_RE = /\[auto\]/i;
@@ -89,7 +87,7 @@ function readItem(lines, lineIndex, inherited) {
   const probe = isProbedTag(tag) ? extractProbe(description) : null;
   return Object.freeze({ raw, description, tag, lineIndex, probe });
 }
-function parsePrerequisites(content) {
+function parsePrerequisites2(content) {
   const lines = content.split(`
 `);
   const items = [];
@@ -132,8 +130,8 @@ function namedItemOf(item) {
 function isMalformed(item) {
   return isProbedTag(item.tag) && item.probe === null;
 }
-function planPrerequisites(content) {
-  const items = parsePrerequisites(content);
+function planPrerequisites2(content) {
+  const items = parsePrerequisites2(content);
   return Object.freeze({
     required: requiredItemsTagged(items, "auto"),
     startRequired: requiredItemsTagged(items, "start"),
@@ -149,8 +147,8 @@ function malformedPrerequisiteLines(file, malformed) {
     `Write each as ${PROBE_ITEM_EXAMPLE}, its one backticked span a complete command run as written;` + " prove a tool is there with `<tool> --version`, `<tool> --help` or `which <tool>`."
   ];
 }
-function mergePlanPrerequisites(settings, content) {
-  const plan = planPrerequisites(content ?? "");
+function mergePlanPrerequisites2(settings, content) {
+  const plan = planPrerequisites2(content ?? "");
   return Object.freeze({
     required: Object.freeze([...settings.prerequisitesRequired, ...plan.required]),
     startRequired: plan.startRequired,
@@ -159,7 +157,7 @@ function mergePlanPrerequisites(settings, content) {
     malformed: plan.malformed
   });
 }
-function prerequisitesPathForPlan(planPath) {
+function prerequisitesPathForPlan2(planPath) {
   const stub = PLAN_FILE_RE.exec(basename(planPath))?.[1];
   if (stub === undefined)
     return null;
@@ -175,13 +173,13 @@ async function readIfPresent(path) {
     throw new Error(`${path}: cannot be read (${messageOf(error)})`, { cause: error });
   }
 }
-async function loadPlanPrerequisites(planPath, settings) {
-  const path = prerequisitesPathForPlan(planPath);
+async function loadPlanPrerequisites2(planPath, settings) {
+  const path = prerequisitesPathForPlan2(planPath);
   const content = path === null ? null : await readIfPresent(path);
-  return mergePlanPrerequisites(settings, content);
+  return mergePlanPrerequisites2(settings, content);
 }
 // src/preflight/run.ts
-var PROBE_TIMEOUT_MS = 30000;
+var PROBE_TIMEOUT_MS2 = 30000;
 var SHELL = "/bin/sh";
 var PASS = Object.freeze({ outcome: "pass", failure: null });
 function spawnShell(probe, options) {
@@ -223,13 +221,13 @@ function collect(stream) {
   };
   return { text: read(), stop };
 }
-async function runShellProbe(probe, options) {
+async function runShellProbe2(probe, options) {
   let proc;
   try {
     proc = spawnShell(probe, options);
   } catch (error) {
-    const stderr2 = `could not run ${SHELL} in ${options.cwd}: ${messageOf(error)}`;
-    return Object.freeze({ exitCode: null, stderr: stderr2, timedOut: false });
+    const stderr = `could not run ${SHELL} in ${options.cwd}: ${messageOf(error)}`;
+    return Object.freeze({ exitCode: null, stderr, timedOut: false });
   }
   const stderr = collect(proc.stderr);
   let timedOut = false;
@@ -348,14 +346,14 @@ function contextOf(options) {
   return {
     cwd: options.cwd,
     env: options.env ?? process.env,
-    timeoutMs: options.timeoutMs ?? PROBE_TIMEOUT_MS,
-    runProbe: options.runProbe ?? runShellProbe,
+    timeoutMs: options.timeoutMs ?? PROBE_TIMEOUT_MS2,
+    runProbe: options.runProbe ?? runShellProbe2,
     request: options.request ?? ((url, init) => fetch(url, init)),
     warn: options.warn ?? warnThroughActiveOutput,
     now: options.now ?? (() => performance.now())
   };
 }
-async function runPreflight(items, options) {
+async function runPreflight2(items, options) {
   const context = contextOf(options);
   const checks = [];
   const knownMissing = [];
@@ -452,7 +450,7 @@ function withoutBlockerComment(line) {
 }
 function closedBlockLines(trackerContent) {
   const inside = new Set;
-  for (const block of readRafaBlocks(trackerContent)) {
+  for (const block of readRafaBlocks2(trackerContent)) {
     if (!block.closed)
       continue;
     for (let line = block.span.first;line <= block.span.last; line += 1) {
@@ -519,13 +517,51 @@ function writeTrackerBlocker(trackerPath, lineNum, blocker) {
 `), "utf8");
   return true;
 }
+var ANY_TASK_PREFIX = /^- \[(?: |x|BLOCKED)\] /;
+var LINE_TERMINATOR = /[\n\r\u2028\u2029]/;
+function assertInsertable(entry) {
+  if (entry.task.trim().length === 0 || LINE_TERMINATOR.test(entry.task)) {
+    throw new Error("insertTrackerTask: the task text must be one line and not blank");
+  }
+  if (entry.declaration.trim().length === 0 || /[{}]/.test(entry.declaration) || LINE_TERMINATOR.test(entry.declaration)) {
+    throw new Error("insertTrackerTask: the declaration must be one line of entries holding no brace");
+  }
+}
+function endOfChecklist(lines, inBlock) {
+  for (let i = lines.length - 1;i >= 0; i -= 1) {
+    if (!inBlock.has(i) && ANY_TASK_PREFIX.test(lines[i]))
+      return i + 1;
+  }
+  const last = lines.length - 1;
+  return lines[last] === "" ? last : lines.length;
+}
+function insertTrackerTask(trackerPath, entry, beforeLine) {
+  assertInsertable(entry);
+  const content = fs.readFileSync(trackerPath, "utf8");
+  const lines = content.split(`
+`);
+  const inBlock = closedBlockLines(content);
+  if (beforeLine !== null) {
+    const target = lines[beforeLine];
+    if (target === undefined || inBlock.has(beforeLine) || !ANY_TASK_PREFIX.test(target)) {
+      throw new Error(`insertTrackerTask: line ${beforeLine} is no task line`);
+    }
+  }
+  const at = beforeLine ?? endOfChecklist(lines, inBlock);
+  const { cr } = splitCarriageReturn(lines[0] ?? "");
+  const line = `- [BLOCKED] ${entry.task.trim()}${BLOCKER_GAP}{${entry.declaration.trim()}}` + `${BLOCKER_GAP}${blockerComment(entry.blocker)}${cr}`;
+  const written = [...lines.slice(0, at), line, ...lines.slice(at)];
+  fs.writeFileSync(trackerPath, written.join(`
+`), "utf8");
+  return at;
+}
 function trackerPathFor(planPath) {
   return planPath.replace(/PLAN(-[^/]*)?\.md$/, (_m, stub) => `PLAN_TRACKER${stub ?? ""}.md`);
 }
 
 // src/plan/parse.ts
-var PLAN_BLOCK_KINDS = ["plan", "context", "stage-context"];
-var PLAN_HEADER_FIELDS = ["stub", "issue", "spec", "release"];
+var PLAN_BLOCK_KINDS2 = ["plan", "context", "stage-context"];
+var PLAN_HEADER_FIELDS2 = ["stub", "issue", "spec", "release"];
 var PLAN_RELEASE_LEVELS = ["patch", "minor", "major", "none"];
 var TASK_LINES = [
   ["unchecked", /^- \[ \] (.+)/],
@@ -534,10 +570,10 @@ var TASK_LINES = [
 ];
 var STAGE_HEADING = /^# Stage: (.+)/;
 function isPlanBlockKind(kind) {
-  return PLAN_BLOCK_KINDS.includes(kind);
+  return PLAN_BLOCK_KINDS2.includes(kind);
 }
 function isHeaderField(key) {
-  return PLAN_HEADER_FIELDS.includes(key);
+  return PLAN_HEADER_FIELDS2.includes(key);
 }
 function isReleaseLevel(value) {
   return PLAN_RELEASE_LEVELS.includes(value);
@@ -746,8 +782,8 @@ function readHeader(block) {
   }
   return readFields(document, line);
 }
-function parsePlan(markdown) {
-  const blocks = readRafaBlocks(markdown);
+function parsePlan2(markdown) {
+  const blocks = readRafaBlocks2(markdown);
   const checklist = readChecklist(markdown, blocks);
   const bound = bindBlocks(blocks, checklist.headings);
   const reading = readHeader(bound.header);
@@ -860,15 +896,15 @@ var RENDERERS = {
   stage: renderStage,
   task: renderTask
 };
-function renderInjection(request) {
+function renderInjection2(request) {
   const { mode, plan, task } = request;
   if (mode === "full")
     return { requested: mode, mode, text: plan, fallback: null };
-  const model = parsePlan(plan);
+  const model = parsePlan2(plan);
   const location = locate(model, task);
   if (!location.found) {
     return { requested: mode, mode: "full", text: plan, fallback: location.fallback };
   }
   return { requested: mode, mode, text: RENDERERS[mode](model, location.task), fallback: null };
 }
-export { escapeBlockerText, splitBlockerComment, findNextTask, updateTrackerLine, writeTrackerBlocker, trackerPathFor, PLAN_BLOCK_KINDS, PLAN_HEADER_FIELDS, PLAN_RELEASE_LEVELS, parsePlan, parsePrerequisites, planPrerequisites, malformedPrerequisiteLines, mergePlanPrerequisites, prerequisitesPathForPlan, loadPlanPrerequisites, PROBE_TIMEOUT_MS, runShellProbe, runPreflight, renderInjection };
+export { escapeBlockerText, splitBlockerComment, findNextTask, updateTrackerLine, writeTrackerBlocker, insertTrackerTask, trackerPathFor, PLAN_BLOCK_KINDS2, PLAN_HEADER_FIELDS2, PLAN_RELEASE_LEVELS, parsePlan2, parsePrerequisites2, planPrerequisites2, malformedPrerequisiteLines, mergePlanPrerequisites2, prerequisitesPathForPlan2, loadPlanPrerequisites2, PROBE_TIMEOUT_MS2, runShellProbe2, runPreflight2, renderInjection2 };