@open-tomato/rafa 0.35.0 → 0.36.0

package/dist/index-3mzw3kzh.js

@@ -0,0 +1,129 @@
+// @bun
+import {
+  describeValue
+} from "./index-fzhd3d4y.js";
+
+// src/cli/spends.ts
+var SPENDS_GLYPH = "\uD83E\uDE99";
+var SPENDS_WHEN = ["always", "with", "unless", "through"];
+var FLAGGED = ["with", "unless"];
+var FLAG_SPELLING = /^--[^\s-]\S*$/;
+function flagProblem(when, flag) {
+  if (FLAGGED.includes(when)) {
+    return typeof flag === "string" && FLAG_SPELLING.test(flag) ? null : `spends.flag is ${describeValue(flag)}, expected a flag as typed, starting with --`;
+  }
+  return flag === undefined ? null : `spends.flag is ${describeValue(flag)}, expected absent when spends.when is "${when}"`;
+}
+function spendsProblem(value) {
+  if (value === undefined)
+    return null;
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return `spends is ${describeValue(value)}, expected absent or a mapping`;
+  }
+  const { when, what, flag } = value;
+  if (!SPENDS_WHEN.includes(when)) {
+    return `spends.when is ${describeValue(when)}, expected one of ${SPENDS_WHEN.join(", ")}`;
+  }
+  if (typeof what !== "string") {
+    return `spends.what is ${describeValue(what)}, expected a string`;
+  }
+  return flagProblem(when, flag);
+}
+
+// src/cli/command.ts
+var COMMAND_OUTPUTS = ["text", "json", "events", "tui"];
+var MAX_EXIT_CODE = 255;
+
+class CommandExit extends Error {
+  exitCode;
+  constructor(exitCode, message = "") {
+    super(message);
+    if (!Number.isInteger(exitCode) || exitCode < 0 || exitCode > MAX_EXIT_CODE) {
+      throw new TypeError(`CommandExit: exit code is ${describeValue(exitCode)}, expected a whole number from 0 to ${MAX_EXIT_CODE}`);
+    }
+    this.name = "CommandExit";
+    this.exitCode = exitCode;
+  }
+}
+function isListOf(value, check) {
+  return Array.isArray(value) && value.every(check);
+}
+function hasStrings(value, keys) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const record = value;
+  return keys.every((key) => typeof record[key] === "string");
+}
+function isRoutingWord(value) {
+  return typeof value === "string" && /^[^\s/-][^\s/]*$/.test(value);
+}
+function isFlag(item) {
+  if (!hasStrings(item, ["name"]))
+    return false;
+  const { deprecated } = item;
+  return deprecated === undefined || hasStrings(deprecated, ["use"]);
+}
+function fieldProblem(fields) {
+  const checks = [
+    ["subject", isRoutingWord(fields.subject), "a word with no space, no slash and no leading dash"],
+    ["action", isRoutingWord(fields.action), "a word with no space, no slash and no leading dash"],
+    ["name", typeof fields.name === "string", "a string"],
+    ["summary", typeof fields.summary === "string", "a string"],
+    ["description", typeof fields.description === "string", "a string"],
+    ["args", isListOf(fields.args, (item) => hasStrings(item, ["name"])), "a list of named arguments"],
+    ["flags", isListOf(fields.flags, isFlag), "a list of named flags, each deprecation naming its use"],
+    ["examples", isListOf(fields.examples, (item) => hasStrings(item, ["cmd", "note"])), "a list of examples"],
+    [
+      "outputs",
+      isListOf(fields.outputs, (item) => COMMAND_OUTPUTS.includes(item)),
+      `a list of ${COMMAND_OUTPUTS.join(", ")}`
+    ],
+    [
+      "aliases",
+      fields.aliases === undefined || isListOf(fields.aliases, (item) => typeof item === "string"),
+      "absent or a list of strings"
+    ],
+    [
+      "lastingAliases",
+      fields.lastingAliases === undefined || isListOf(fields.lastingAliases, (item) => typeof item === "string"),
+      "absent or a list of strings"
+    ],
+    [
+      "deprecated",
+      fields.deprecated === undefined || hasStrings(fields.deprecated, ["since", "use"]),
+      "absent or a mapping of since and use"
+    ],
+    ["hidden", fields.hidden === undefined || typeof fields.hidden === "boolean", "absent or a boolean"],
+    [
+      "needsProject",
+      fields.needsProject === undefined || typeof fields.needsProject === "boolean",
+      "absent or a boolean"
+    ],
+    ["exec", fields.exec === undefined || fields.exec === true, "absent or true"],
+    ["run", typeof fields.run === "function", "a function"]
+  ];
+  const failed = checks.find(([, passes]) => !passes);
+  if (failed === undefined)
+    return null;
+  const [key, , expected] = failed;
+  return `${key} is ${describeValue(fields[key])}, expected ${expected}`;
+}
+function commandProblem(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return `a command is ${describeValue(value)}, expected a mapping`;
+  }
+  const fields = value;
+  const problem = fieldProblem(fields) ?? spendsProblem(fields.spends);
+  if (problem === null)
+    return null;
+  const named = isRoutingWord(fields.subject) && isRoutingWord(fields.action) ? `command "${commandSpelling(fields)}"` : "a command";
+  return `${named}: ${problem}`;
+}
+function isTopLevel(command) {
+  return command.subject === command.action;
+}
+function commandSpelling(command) {
+  return isTopLevel(command) ? command.subject : `${command.subject} ${command.action}`;
+}
+
+export { SPENDS_GLYPH, CommandExit, isRoutingWord, commandProblem, isTopLevel, commandSpelling };

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

@@ -1,11 +1,13 @@
 // @bun
 import {
-  parseTaskDeclaration,
-  messageOf,
-  isStampableStub,
   activeOutput,
-  readRafaBlocks2
-} from "./index-2tjmxwvp.js";
+  isStampableStub,
+  readRafaBlocks
+} from "./index-jfas157k.js";
+import {
+  messageOf,
+  parseTaskDeclaration
+} from "./index-fzhd3d4y.js";
 // src/preflight/prerequisites-md.ts
 import { basename, dirname, join } from "path";
 var SECTION_AUTO_RE = /\[auto\]/i;
@@ -87,7 +89,7 @@ function readItem(lines, lineIndex, inherited) {
   const probe = isProbedTag(tag) ? extractProbe(description) : null;
   return Object.freeze({ raw, description, tag, lineIndex, probe });
 }
-function parsePrerequisites2(content) {
+function parsePrerequisites(content) {
   const lines = content.split(`
 `);
   const items = [];
@@ -130,8 +132,8 @@ function namedItemOf(item) {
 function isMalformed(item) {
   return isProbedTag(item.tag) && item.probe === null;
 }
-function planPrerequisites2(content) {
-  const items = parsePrerequisites2(content);
+function planPrerequisites(content) {
+  const items = parsePrerequisites(content);
   return Object.freeze({
     required: requiredItemsTagged(items, "auto"),
     startRequired: requiredItemsTagged(items, "start"),
@@ -147,8 +149,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 mergePlanPrerequisites2(settings, content) {
-  const plan = planPrerequisites2(content ?? "");
+function mergePlanPrerequisites(settings, content) {
+  const plan = planPrerequisites(content ?? "");
   return Object.freeze({
     required: Object.freeze([...settings.prerequisitesRequired, ...plan.required]),
     startRequired: plan.startRequired,
@@ -157,7 +159,7 @@ function mergePlanPrerequisites2(settings, content) {
     malformed: plan.malformed
   });
 }
-function prerequisitesPathForPlan2(planPath) {
+function prerequisitesPathForPlan(planPath) {
   const stub = PLAN_FILE_RE.exec(basename(planPath))?.[1];
   if (stub === undefined)
     return null;
@@ -173,13 +175,13 @@ async function readIfPresent(path) {
     throw new Error(`${path}: cannot be read (${messageOf(error)})`, { cause: error });
   }
 }
-async function loadPlanPrerequisites2(planPath, settings) {
-  const path = prerequisitesPathForPlan2(planPath);
+async function loadPlanPrerequisites(planPath, settings) {
+  const path = prerequisitesPathForPlan(planPath);
   const content = path === null ? null : await readIfPresent(path);
-  return mergePlanPrerequisites2(settings, content);
+  return mergePlanPrerequisites(settings, content);
 }
 // src/preflight/run.ts
-var PROBE_TIMEOUT_MS2 = 30000;
+var PROBE_TIMEOUT_MS = 30000;
 var SHELL = "/bin/sh";
 var PASS = Object.freeze({ outcome: "pass", failure: null });
 function spawnShell(probe, options) {
@@ -221,13 +223,13 @@ function collect(stream) {
   };
   return { text: read(), stop };
 }
-async function runShellProbe2(probe, options) {
+async function runShellProbe(probe, options) {
   let proc;
   try {
     proc = spawnShell(probe, options);
   } catch (error) {
-    const stderr = `could not run ${SHELL} in ${options.cwd}: ${messageOf(error)}`;
-    return Object.freeze({ exitCode: null, stderr, timedOut: false });
+    const stderr2 = `could not run ${SHELL} in ${options.cwd}: ${messageOf(error)}`;
+    return Object.freeze({ exitCode: null, stderr: stderr2, timedOut: false });
   }
   const stderr = collect(proc.stderr);
   let timedOut = false;
@@ -346,14 +348,14 @@ function contextOf(options) {
   return {
     cwd: options.cwd,
     env: options.env ?? process.env,
-    timeoutMs: options.timeoutMs ?? PROBE_TIMEOUT_MS2,
-    runProbe: options.runProbe ?? runShellProbe2,
+    timeoutMs: options.timeoutMs ?? PROBE_TIMEOUT_MS,
+    runProbe: options.runProbe ?? runShellProbe,
     request: options.request ?? ((url, init) => fetch(url, init)),
     warn: options.warn ?? warnThroughActiveOutput,
     now: options.now ?? (() => performance.now())
   };
 }
-async function runPreflight2(items, options) {
+async function runPreflight(items, options) {
   const context = contextOf(options);
   const checks = [];
   const knownMissing = [];
@@ -450,7 +452,7 @@ function withoutBlockerComment(line) {
 }
 function closedBlockLines(trackerContent) {
   const inside = new Set;
-  for (const block of readRafaBlocks2(trackerContent)) {
+  for (const block of readRafaBlocks(trackerContent)) {
     if (!block.closed)
       continue;
     for (let line = block.span.first;line <= block.span.last; line += 1) {
@@ -560,8 +562,8 @@ function trackerPathFor(planPath) {
 }
 
 // src/plan/parse.ts
-var PLAN_BLOCK_KINDS2 = ["plan", "context", "stage-context"];
-var PLAN_HEADER_FIELDS2 = ["stub", "issue", "spec", "release"];
+var PLAN_BLOCK_KINDS = ["plan", "context", "stage-context"];
+var PLAN_HEADER_FIELDS = ["stub", "issue", "spec", "release"];
 var PLAN_RELEASE_LEVELS = ["patch", "minor", "major", "none"];
 var TASK_LINES = [
   ["unchecked", /^- \[ \] (.+)/],
@@ -570,10 +572,10 @@ var TASK_LINES = [
 ];
 var STAGE_HEADING = /^# Stage: (.+)/;
 function isPlanBlockKind(kind) {
-  return PLAN_BLOCK_KINDS2.includes(kind);
+  return PLAN_BLOCK_KINDS.includes(kind);
 }
 function isHeaderField(key) {
-  return PLAN_HEADER_FIELDS2.includes(key);
+  return PLAN_HEADER_FIELDS.includes(key);
 }
 function isReleaseLevel(value) {
   return PLAN_RELEASE_LEVELS.includes(value);
@@ -782,8 +784,8 @@ function readHeader(block) {
   }
   return readFields(document, line);
 }
-function parsePlan2(markdown) {
-  const blocks = readRafaBlocks2(markdown);
+function parsePlan(markdown) {
+  const blocks = readRafaBlocks(markdown);
   const checklist = readChecklist(markdown, blocks);
   const bound = bindBlocks(blocks, checklist.headings);
   const reading = readHeader(bound.header);
@@ -896,15 +898,15 @@ var RENDERERS = {
   stage: renderStage,
   task: renderTask
 };
-function renderInjection2(request) {
+function renderInjection(request) {
   const { mode, plan, task } = request;
   if (mode === "full")
     return { requested: mode, mode, text: plan, fallback: null };
-  const model = parsePlan2(plan);
+  const model = parsePlan(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, insertTrackerTask, trackerPathFor, PLAN_BLOCK_KINDS2, PLAN_HEADER_FIELDS2, PLAN_RELEASE_LEVELS, parsePlan2, parsePrerequisites2, planPrerequisites2, malformedPrerequisiteLines, mergePlanPrerequisites2, prerequisitesPathForPlan2, loadPlanPrerequisites2, PROBE_TIMEOUT_MS2, runShellProbe2, runPreflight2, renderInjection2 };
+export { escapeBlockerText, splitBlockerComment, findNextTask, updateTrackerLine, writeTrackerBlocker, insertTrackerTask, trackerPathFor, PLAN_BLOCK_KINDS, PLAN_HEADER_FIELDS, PLAN_RELEASE_LEVELS, parsePlan, parsePrerequisites, planPrerequisites, malformedPrerequisiteLines, mergePlanPrerequisites, prerequisitesPathForPlan, loadPlanPrerequisites, PROBE_TIMEOUT_MS, runShellProbe, runPreflight, renderInjection };

package/dist/{index-hgcvjke7.js → index-d6d0942q.js}

@@ -1,11 +1,11 @@
 // @bun
 import {
-  GAP2,
-  SOURCE_STEP2,
-  CONFIDENCE_MIN2,
-  CONFIDENCE_MAX2,
-  triggerKey2
-} from "./index-21jcfatr.js";
+  CONFIDENCE_MAX,
+  CONFIDENCE_MIN,
+  GAP,
+  SOURCE_STEP,
+  triggerKey
+} from "./index-wp8c28fd.js";
 
 // src/learning/bless.ts
 import { createHash } from "crypto";
@@ -32,19 +32,19 @@ function blessedRecords(held, minConfidence) {
 function versionOf(instincts) {
   return createHash("sha256").update(JSON.stringify(instincts)).digest("hex");
 }
-function bless2(held, options) {
+function bless(held, options) {
   const instincts = blessedRecords(held, options.minConfidence);
   return { version: versionOf(instincts), instincts };
 }
-function promotable2(held, options) {
+function promotable(held, options) {
   return blessedRecords(held, options.minConfidence).filter((each) => each.usage_count >= options.after);
 }
 // src/learning/merge.ts
 var HUNDREDTHS2 = 100;
-var GAP_H = Math.round(GAP2 * HUNDREDTHS2);
-var STEP_H = Math.round(SOURCE_STEP2 * HUNDREDTHS2);
-var MIN_H = Math.round(CONFIDENCE_MIN2 * HUNDREDTHS2);
-var MAX_H = Math.round(CONFIDENCE_MAX2 * HUNDREDTHS2);
+var GAP_H = Math.round(GAP * HUNDREDTHS2);
+var STEP_H = Math.round(SOURCE_STEP * HUNDREDTHS2);
+var MIN_H = Math.round(CONFIDENCE_MIN * HUNDREDTHS2);
+var MAX_H = Math.round(CONFIDENCE_MAX * HUNDREDTHS2);
 function hundredths2(confidence) {
   return Math.round(confidence * HUNDREDTHS2);
 }
@@ -194,16 +194,16 @@ function settleTrigger(held, incoming, now) {
   }
   return settleMany(collapsed, held, now);
 }
-function merge2(held, payload, now) {
+function merge(held, payload, now) {
   const incoming = payload.instincts.map((record) => withSource(record, payload.source_id));
-  const keys = [...new Set(incoming.map((record) => triggerKey2(record.trigger)))];
+  const keys = [...new Set(incoming.map((record) => triggerKey(record.trigger)))];
   const outcomes = new Map;
   for (const key of keys) {
-    const onKey = (record) => triggerKey2(record.trigger) === key;
+    const onKey = (record) => triggerKey(record.trigger) === key;
     outcomes.set(key, settleTrigger(held.filter(onKey), incoming.filter(onKey), now));
   }
   const decisions = payload.instincts.map((record) => {
-    const outcome = outcomes.get(triggerKey2(record.trigger));
+    const outcome = outcomes.get(triggerKey(record.trigger));
     return {
       incoming: record,
       rule: outcome.rules.get(record.action_hash),
@@ -215,4 +215,4 @@ function merge2(held, payload, now) {
     discarded: keys.flatMap((key) => outcomes.get(key).discarded)
   };
 }
-export { bless2, promotable2, merge2 };
+export { bless, promotable, merge };