@open-tomato/rafa 0.45.0 → 0.46.0

package/dist/errors/rafa-codes.d.ts

@@ -0,0 +1,36 @@
+/**
+ * rafa's own cause codes (#949): the list every project starts from,
+ * and the tagged view `rafa bug codes` prints.
+ *
+ * The list has three parts. The first two give a code in the new form to
+ * every value of the four per-module unions that existed before it:
+ * `ROUTE_REFUSALS` and `DISPATCH_ERROR_CODES` (`src/cli/`), and
+ * `SKILL_ISSUE_CODES` with `FailureStringCode` (`src/schema/`). Those
+ * unions keep their own spellings, since `--output=json` readers see
+ * them in `error.code`; each entry here carries the old spelling in
+ * `legacy`. Nothing derives the unions from this list. The test beside
+ * this file holds the two together instead: a union value with no entry,
+ * or a `legacy` naming no union value, turns it red.
+ *
+ * The third part seeds the causes behind the largest duplicate clusters
+ * the bug audit found, and one common case per shared family. The list
+ * grows from fixes: a bug filed as `<family>:new-context` gets its code
+ * added here by the change that fixes it.
+ *
+ * A project's own codes come from `errors.codes`
+ * (`src/config-schema-errors.ts`), and {@link listedCodes} puts the two
+ * side by side.
+ */
+import type { ErrorCodeEntry } from './codes.js';
+/** Where a listed code comes from. */
+export type CodeSource = 'rafa' | 'project';
+/** A code as `rafa bug codes` lists it. */
+export interface ListedCode extends ErrorCodeEntry {
+    readonly source: CodeSource;
+}
+/** One line per family rafa's list uses. */
+export declare const FAMILY_DESCRIPTIONS: Readonly<Record<string, string>>;
+/** rafa's own codes; see the module note. */
+export declare const RAFA_CODES: readonly ErrorCodeEntry[];
+/** rafa's codes, then `projectCodes`, each tagged with where it comes from. */
+export declare function listedCodes(projectCodes: readonly ErrorCodeEntry[]): readonly ListedCode[];

package/dist/index-2a7nb3an.js

@@ -0,0 +1,125 @@
+// @bun
+// packages/rafa/src/core/output/text.ts
+var DEBUG_VERBOSITY = 2;
+function formatPayload(payload) {
+  return typeof payload === "string" ? payload : JSON.stringify(payload);
+}
+function resultLine(event) {
+  if (event.ok) {
+    return event.data === undefined ? "result: ok" : `result: ok ${formatPayload(event.data)}`;
+  }
+  const code = event.error?.code ?? "unknown";
+  const message = event.error?.message ?? "";
+  return message === "" ? `result: error ${code}` : `result: error ${code}: ${message}`;
+}
+function createTextOutput({ verbosity, stream }) {
+  const writeLine = (line) => {
+    stream.write(`${line}
+`);
+  };
+  const debug = (message) => {
+    if (verbosity >= DEBUG_VERBOSITY)
+      writeLine(`debug: ${message}`);
+  };
+  const info = (message) => {
+    writeLine(message);
+  };
+  const warn = (message) => {
+    writeLine(`warn: ${message}`);
+  };
+  const error = (message) => {
+    writeLine(`error: ${message}`);
+  };
+  const result = (payload) => {
+    writeLine(`result: ${formatPayload(payload)}`);
+  };
+  const writeLog = (event) => {
+    switch (event.level) {
+      case "debug": {
+        debug(event.message);
+        return;
+      }
+      case "info": {
+        info(event.message);
+        return;
+      }
+      case "warn": {
+        warn(event.message);
+        return;
+      }
+      case "error": {
+        error(event.message);
+        return;
+      }
+    }
+  };
+  const emit = (event) => {
+    switch (event.type) {
+      case "start": {
+        writeLine(`start: ${event.command}`);
+        return;
+      }
+      case "step": {
+        writeLine(`step: ${event.name}`);
+        return;
+      }
+      case "log": {
+        writeLog(event);
+        return;
+      }
+      case "result": {
+        writeLine(resultLine(event));
+        return;
+      }
+      case "event": {
+        return;
+      }
+    }
+  };
+  return Object.freeze({ info, warn, error, debug, emit, result });
+}
+
+// packages/rafa/src/core/output/active.ts
+import { AsyncLocalStorage } from "async_hooks";
+var scopes = new AsyncLocalStorage;
+var DEFAULT_OUTPUT = createTextOutput({ verbosity: 0, stream: process.stdout });
+var active = DEFAULT_OUTPUT;
+var activeMode = "text";
+function activeOutput() {
+  return scopes.getStore()?.output ?? active;
+}
+function activeOutputMode() {
+  return scopes.getStore()?.mode ?? activeMode;
+}
+
+// packages/rafa/src/core/plan/plan-stamp.ts
+var STUB_PATTERN = "[A-Za-z0-9._-]+";
+var STAMP_PATTERN = new RegExp(`<!--\\s*ralph:plan=(${STUB_PATTERN})\\s*-->`);
+function isStampableStub(stub) {
+  return new RegExp(`^${STUB_PATTERN}$`).test(stub);
+}
+function planStampLine(stub) {
+  if (!isStampableStub(stub)) {
+    throw new Error(`rafa plan stamp: unusable stub ${JSON.stringify(stub)}`);
+  }
+  return `<!-- ralph:plan=${stub} -->`;
+}
+function planStubFromPrompt(content) {
+  if (typeof content !== "string" || content.length === 0)
+    return null;
+  const match = STAMP_PATTERN.exec(content);
+  const stub = match?.[1];
+  return stub !== undefined && isStampableStub(stub) ? stub : null;
+}
+function stampPrompt(stub, prompt) {
+  return `${prompt}
+${planStampLine(stub)}`;
+}
+function planStubFromPath(planPath) {
+  const base = planPath.split("/").pop() ?? planPath;
+  const match = /^PLAN(?:_TRACKER)?-(.+)\.md$/.exec(base);
+  const stub = match?.[1];
+  return stub !== undefined && isStampableStub(stub) ? stub : null;
+}
+
+export { createTextOutput, activeOutput, activeOutputMode, isStampableStub, planStubFromPrompt, stampPrompt, planStubFromPath };