baesian 0.0.0-stage → 1.0.0

package/dist/ci.js

@@ -0,0 +1,82 @@
+import { spawnSync } from "node:child_process";
+import { asWritten } from "./schema.js";
+import { TRUST_ENV, checkSigned, projectLine } from "./trust.js";
+/** A file's JSON on one line, its fields in the file's own order: a passkey's line as the website showed it. */
+const compact = (store, rel) => JSON.stringify(JSON.parse(store.bytes(rel).toString("utf8")));
+/**
+ * The pin for a linked repo (B-pt52b), from the live layer only: the line naming its project (B-mar8x); each service key
+ * and revocation the relay sent; and each passkey key file whose `.sig` checks against those keys (`checkSigned()`), at
+ * the time it was enrolled. Or why there's none yet: the relay sends its key with the project's first file. `spare` is the
+ * service's spare keys (B-x47ek), from the service itself (`spareKeys()`), each pinned beside the keys unless the relay
+ * already sent it as one: with it pinned, CI keeps passing when the service switches to it.
+ */
+export function ciPin(store, service, project, spare = []) {
+    const files = store.trustFiles();
+    if (!files.service.length) {
+        return { problem: `this machine has no key from ${service} for project ${project} yet: the relay sends it with the project's first file. File a card, then run \`baesian ci\` again` };
+    }
+    const root = { service: files.service.map((s) => s.key), revoked: files.revoked.map((r) => r.key) };
+    const passkeys = [];
+    const signed = [];
+    const skipped = [];
+    for (const { file, key } of files.passkeys) {
+        const sig = store.storage.read(`${file}.sig`);
+        const r = sig === undefined ? { problem: "it has no signature" } : checkSigned(root, store.bytes(file), Buffer.from(sig).toString("utf8"), key.enrolled, file);
+        if ("problem" in r) {
+            skipped.push({ file, why: `${r.problem}, so the service didn't write it` });
+            continue;
+        }
+        passkeys.push({ file, handle: key.handle, account: key.account, enrolled: key.enrolled });
+        signed.push(compact(store, file));
+    }
+    const spares = spare.filter((k) => !files.service.some((s) => s.key.public_key === k.public_key));
+    const lines = [
+        projectLine(project),
+        ...files.service.map((s) => compact(store, s.file)),
+        ...spares.map((k) => JSON.stringify(asWritten("service-key", k))),
+        ...files.revoked.map((r) => compact(store, r.file)),
+        ...signed,
+    ];
+    return { service, project, site: files.service[0].key.origin, lines, spare: spares.map((k) => k.key), passkeys, skipped };
+}
+/**
+ * The GitHub Actions steps that run `baesian verify` with the pin (B-pt52b), as this repo's own workflow runs it: the full
+ * history, which verify needs for the base, every commit in the range and the commit that linked the repo (B-45xz8); the
+ * pushed commits on a push, and the merge gate on a pull request (D31). The CLI comes from npm, pinned to `version`, the
+ * release that prints the steps (B-c0e0d): a new release changes a repo's CI only in a commit, made by running
+ * `baesian ci` again with it.
+ */
+export function workflowSteps(version) {
+    return ["# In a workflow that runs on pushes to your main branch and on pull requests, as one job's steps.", ...workflowBody(version)];
+}
+/** The steps alone, for `baesian ci`, which says where they go in a sentence of its own. */
+export function workflowBody(version) {
+    const env = ["  env:", `    ${TRUST_ENV}: \${{ vars.${TRUST_ENV} }}`];
+    const baesian = `npx --yes baesian@${version}`;
+    return [
+        "# Keep agents' commits from editing it, with a ruleset or code owners on .github/: it passes the pin to verify.",
+        "- uses: actions/checkout@v7",
+        "  with:",
+        "    fetch-depth: 0 # verify needs the base, every commit since it, and the commit that linked the repo",
+        "- uses: actions/setup-node@v7",
+        "  with:",
+        "    node-version: 22",
+        `# Baesian ${version} from npm, pinned: the release that printed these steps. To move CI to another, run \`baesian ci\` with it, and commit the steps it prints.`,
+        "- name: baesian verify (pushed commits)",
+        "  if: github.event_name == 'push' && github.event.before != '0000000000000000000000000000000000000000'",
+        `  run: ${baesian} verify --base "\${{ github.event.before }}"`,
+        ...env,
+        "- name: baesian verify --merge (pull request)",
+        "  if: github.event_name == 'pull_request'",
+        `  run: ${baesian} verify --merge`,
+        ...env,
+    ];
+}
+/** Run a program with text on its standard input, as `baesian ci --github` runs `gh`. */
+export function runProgram(command, args, opts) {
+    const r = spawnSync(command, args, { cwd: opts.cwd, input: opts.input, encoding: "utf8" });
+    if (r.error)
+        return { status: null, stdout: "", stderr: r.error.message, missing: r.error.code === "ENOENT" };
+    return { status: r.status, stdout: r.stdout ?? "", stderr: r.stderr ?? "" };
+}
+//# sourceMappingURL=ci.js.map

package/dist/cite.js

@@ -0,0 +1,66 @@
+// Citations of Baesian's own decisions in what it prints (B-728jd): "(B-4rwyz)", "(D42, D144)". They're notes for
+// whoever works on Baesian, and outside this repo they point nowhere, so ordinary output leaves them out and the global
+// `--verbose` puts them back where they were. Each is marked where it's written, with `cite()` or `citeIn()`, never
+// found by matching the finished text: a citation has the same shape as the user's own card IDs. The marks are two
+// characters from Unicode's private use area, which nothing Baesian prints otherwise holds, around the citation and its
+// punctuation; `unmark()` takes them out, with the citation or without it. Every place text leaves Baesian goes through
+// it: the CLI's renderer (src/style.ts), `--json`, the MCP server, the local server's responses, and errors' messages
+// (`Told`). No imports: the relay's store imports this too.
+const OPEN = "";
+const CLOSE = "";
+const MARKED = /([^]*)/g;
+/** A citation after a phrase: ` (B-4rwyz)`, or ` (D42, D144)`. Printed only with `--verbose`. */
+export function cite(...ids) {
+    return `${OPEN} (${ids.join(", ")})${CLOSE}`;
+}
+/** A citation inside a parenthesis that says something else too: `(personal mode, B-4rwyz)`. */
+export function citeIn(...ids) {
+    return `${OPEN}, ${ids.join(", ")}${CLOSE}`;
+}
+/** Text as it's printed: without its citations, or with them (`--verbose`), and never with their marks. */
+export function unmark(text, verbose = false) {
+    return text.includes(OPEN) ? text.replace(MARKED, verbose ? "$1" : "") : text;
+}
+/** Whether a text has a citation in it. */
+export const hasCitation = (text) => text.includes(OPEN);
+/** A text in pieces: what it says, and its citations, for a renderer that styles them. */
+export function segments(text) {
+    if (!text.includes(OPEN))
+        return [{ text, cite: false }];
+    const out = [];
+    let at = 0;
+    for (const m of text.matchAll(MARKED)) {
+        if (m.index > at)
+            out.push({ text: text.slice(at, m.index), cite: false });
+        out.push({ text: m[1], cite: true });
+        at = m.index + m[0].length;
+    }
+    if (at < text.length)
+        out.push({ text: text.slice(at), cite: false });
+    return out;
+}
+/** A JSON replacer that unmarks every string, for `--json` and the MCP server's structured content. */
+export function unmarkJson(_key, value) {
+    return typeof value === "string" ? unmark(value) : value;
+}
+/** A value with its strings unmarked, for output that isn't serialised here (the MCP server's structured content). */
+export function unmarked(value) {
+    return JSON.parse(JSON.stringify(value, unmarkJson));
+}
+/**
+ * An error whose message may cite Baesian's decisions and name what to do next. `message` is its plain text, without
+ * citations, with each step as a `next:` line, so anything that prints it (the MCP server, the local server, the relay)
+ * prints what an agent reads; `marked` keeps the citations, and `steps` the next steps, for the CLI to render.
+ */
+export class Told extends Error {
+    marked;
+    steps;
+    constructor(message, steps = []) {
+        super([unmark(message), ...steps.map(nextLine)].join("\n"));
+        this.marked = message;
+        this.steps = steps;
+    }
+}
+/** A next step as plain text reads it: `next: <command>  # why`. */
+export const nextLine = (s) => `next: ${s.command}${s.why ? `  # ${s.why}` : ""}`;
+//# sourceMappingURL=cite.js.map