@canonical/pragma-cli 0.34.0 → 0.36.0

package/dist/src/kernel/render/style.js

@@ -0,0 +1,105 @@
+/**
+ * Terminal-styling seam for the human (TTY) output path.
+ *
+ * The condensed/agent (`llm`) and JSON paths are byte-frozen contracts; only an
+ * interactive terminal earns color and alignment. A {@link RenderStyle} carries
+ * that decision as data so a pure renderer can consult it without reading the
+ * process itself: {@link defaultStyle} probes chalk's own TTY/env detection (the
+ * same signal the help system leans on), so piped / redirected / MCP output —
+ * where `enabled` is false — renders byte-for-byte as before, while an attended
+ * terminal renders with `enabled: true`. Passing an explicit style keeps the
+ * beautified renderers deterministically testable in both modes.
+ */
+import chalk from "chalk";
+import { stdoutIsCaptured } from "../interactivity.js";
+/** The identity styler — every function returns its input unchanged. */
+const PLAIN_STYLE = {
+    enabled: false,
+    bold: (text) => text,
+    dim: (text) => text,
+    cyan: (text) => text,
+    green: (text) => text,
+    yellow: (text) => text,
+    red: (text) => text,
+};
+/**
+ * Build a {@link RenderStyle} for a known color decision.
+ *
+ * @param enabled - True to colorize + align via chalk; false for the identity
+ *   styler (byte-identical to the pre-beautify plain output).
+ * @returns A style whose functions color, or pass through, accordingly.
+ */
+export function styleFor(enabled) {
+    if (!enabled)
+        return PLAIN_STYLE;
+    return {
+        enabled: true,
+        bold: (text) => chalk.bold(text),
+        dim: (text) => chalk.dim(text),
+        cyan: (text) => chalk.cyan(text),
+        green: (text) => chalk.green(text),
+        yellow: (text) => chalk.yellow(text),
+        red: (text) => chalk.red(text),
+    };
+}
+/**
+ * Whether the environment forbids color outright.
+ *
+ * `NO_COLOR` is honored when PRESENT AND NON-EMPTY, whatever its value — an
+ * empty assignment is explicitly not a request to disable (no-color.org). The
+ * value is never parsed: `NO_COLOR=0` still disables, which surprises people
+ * and is nonetheless what the convention says.
+ *
+ * @param env - The environment to read.
+ * @returns True when color must not be emitted.
+ */
+export function forbidsColor(env) {
+    const value = env.NO_COLOR;
+    return value !== undefined && value !== "";
+}
+// Applied to the SHARED chalk instance at module load, not inside
+// `defaultStyle()`, because three modules reach for `chalk` directly rather
+// than through `RenderStyle` — help formatting, upgrade and the colophon's
+// Markdown renderer. Gating only the style seam would leave every one of them
+// still emitting escapes. Zeroing the level once covers them by construction,
+// including any site added later.
+//
+// This used to be delegated to chalk, and the delegation was silent: the
+// vendored `supports-color` this version ships handles `FORCE_COLOR` and has no
+// `NO_COLOR` branch at all, so the flag did nothing while the code asserted it
+// worked.
+if (forbidsColor(process.env))
+    chalk.level = 0;
+/**
+ * Whether stdout may carry color: an attended terminal AND a usable chalk
+ * level (zeroed by the module-load check above under `NO_COLOR`).
+ *
+ * The third question of the interactivity vocabulary (`kernel/interactivity.ts`
+ * holds the other two, and its docblock says why this one lives here: it needs
+ * `chalk`, and that module is on the flag-parsing fast path). Both signals are
+ * required — `supports-color` enables color off a TTY in CI, which would paint
+ * escapes into a redirected stream every byte-comparison then has to strip.
+ *
+ * @returns True on a color-capable terminal.
+ * @note Impure — reads stdout's capture state and chalk's color level.
+ */
+export function canColor() {
+    return !stdoutIsCaptured() && chalk.level > 0;
+}
+/**
+ * The active style for this process's stdout.
+ *
+ * Both signals, asked as one named question ({@link canColor}): stdout must be
+ * an attended TTY, so piped / redirected / MCP output stays byte-stable even
+ * where `supports-color` fires off a TTY (CI sets `GITHUB_ACTIONS`, which chalk
+ * honors); AND chalk must report a usable color level, which the module-load
+ * check above forces to zero under `NO_COLOR`.
+ *
+ * @returns A colorizing style on a color-capable TTY, else the identity styler.
+ * @note Impure — {@link canColor} reads stdout's capture state and chalk's
+ *   color level.
+ */
+export function defaultStyle() {
+    return styleFor(canColor());
+}
+//# sourceMappingURL=style.js.map

package/dist/src/kernel/render/style.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"style.js","sourceRoot":"","sources":["../../../../src/kernel/render/style.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAoBvD,wEAAwE;AACxE,MAAM,WAAW,GAAgB;IAC/B,OAAO,EAAE,KAAK;IACd,IAAI,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI;IACpB,GAAG,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI;IACnB,IAAI,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI;IACpB,KAAK,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI;IACrB,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI;IACtB,GAAG,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI;CACpB,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,UAAU,QAAQ,CAAC,OAAgB;IACvC,IAAI,CAAC,OAAO;QAAE,OAAO,WAAW,CAAC;IACjC,OAAO;QACL,OAAO,EAAE,IAAI;QACb,IAAI,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC;QAChC,GAAG,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC;QAC9B,IAAI,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC;QAChC,KAAK,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC;QAClC,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC;QACpC,GAAG,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC;KAC/B,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,YAAY,CAAC,GAAsB;IACjD,MAAM,KAAK,GAAG,GAAG,CAAC,QAAQ,CAAC;IAC3B,OAAO,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,EAAE,CAAC;AAC7C,CAAC;AAED,kEAAkE;AAClE,4EAA4E;AAC5E,2EAA2E;AAC3E,8EAA8E;AAC9E,8EAA8E;AAC9E,kCAAkC;AAClC,EAAE;AACF,yEAAyE;AACzE,gFAAgF;AAChF,+EAA+E;AAC/E,UAAU;AACV,IAAI,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC;IAAE,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC;AAE/C;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,QAAQ;IACtB,OAAO,CAAC,gBAAgB,EAAE,IAAI,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC;AAChD,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,YAAY;IAC1B,OAAO,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC;AAC9B,CAAC"}

package/dist/src/kernel/render/turtle.js

@@ -0,0 +1,194 @@
+/**
+ * Serialize an entity's neighbourhood as Turtle — the dense form of the read.
+ *
+ * The JSON projection is faithful but expensive: one named node costs about 95
+ * bytes of wrapper to convey thirteen characters, and that overhead is paid per
+ * term. Measured on one button, structure alone was ~6.1 KB of a 15.8 KB read.
+ * Turtle spends the prefixes ONCE and then writes each term as itself.
+ *
+ * It is not merely shorter — it is the shape this data already has:
+ *
+ * - IRI versus literal is SYNTAX (`ds:Foo` against `"Foo"`), which is the whole
+ *   thing the typed-term projection had to carry a `termType` field to say.
+ * - A blank node is `[ … ]` inline, which is exactly the record the reader
+ *   assembles by hand for the JSON form.
+ * - Datatypes and language tags are native (`"x"@en`, `"2026-02-20"^^xsd:date`).
+ * - An inbound edge is just a triple written the other way round. The whole
+ *   `InboundGroup` structure exists only because JSON cannot point an arrow
+ *   backwards.
+ *
+ * Counts, samples and truncations ride as `#` comments. That is not a fallback:
+ * a comment is the one place a serialization can say something ABOUT the data
+ * without asserting it as data, and a reader — human or model — takes it the
+ * same way.
+ *
+ * Pure: it reads only the projection it is handed, so the same neighbourhood
+ * always renders the same bytes.
+ */
+/** Characters that must be escaped inside a single-line Turtle literal. */
+const ESCAPES = {
+    "\\": "\\\\",
+    '"': '\\"',
+    "\n": "\\n",
+    "\r": "\\r",
+    "\t": "\\t",
+};
+/** Whether a literal is better served by a triple-quoted long string. */
+function isMultiline(value) {
+    return value.includes("\n");
+}
+/** Escape a literal for the single-line `"…"` form. */
+function escapeShort(value) {
+    return value.replace(/[\\"\n\r\t]/g, (char) => ESCAPES[char] ?? char);
+}
+/**
+ * Escape a literal for the `"""…"""` form.
+ *
+ * Only backslashes and a trailing/tripled quote need attention there — newlines
+ * are the entire point of the form and must survive untouched, which is what
+ * keeps an embedded YAML or Markdown body readable rather than turning it into
+ * one `\n`-riddled line.
+ */
+function escapeLong(value) {
+    return (value
+        .replace(/\\/g, "\\\\")
+        .replace(/"""/g, '\\"\\"\\"')
+        // A value ENDING in a quote would run straight into the closing delimiter
+        // and produce four quotes, which no parser reads as intended. Truncation
+        // makes this reachable on ordinary prose, not just on hostile input.
+        .replace(/"$/, '\\"'));
+}
+/**
+ * Write a name that may or may not have compacted.
+ *
+ * `compactUri` returns its input UNCHANGED when no namespace matches, so a
+ * datatype or predicate outside the prefix map arrived here as a bare absolute
+ * IRI and was emitted raw — producing `"x"^^http://example.com/type`, which no
+ * parser accepts. A prefixed name goes through as-is; anything else is wrapped.
+ */
+function asName(value) {
+    return /^[A-Za-z][\w.-]*:[^/]/.test(value) && !value.includes("://")
+        ? value
+        : `<${value}>`;
+}
+/** Render one term in Turtle: a prefixed name, an `<iri>`, or a literal. */
+function renderTerm(term) {
+    if (term.termType === "NamedNode") {
+        return term.prefixed ?? `<${term.value}>`;
+    }
+    if (term.termType === "BlankNode") {
+        // A bare `[]` — the label is store-local and re-minted on every load, so
+        // writing it would publish an identifier that means nothing on the next read.
+        return "[]";
+    }
+    const body = isMultiline(term.value)
+        ? `"""${escapeLong(term.value)}"""`
+        : `"${escapeShort(term.value)}"`;
+    // Direction is RDF 1.2's `@lang--dir`; it only ever accompanies a language.
+    if (term.language) {
+        return `${body}@${term.language}${term.direction ? `--${term.direction}` : ""}`;
+    }
+    if (term.datatype)
+        return `${body}^^${asName(term.datatype)}`;
+    return body;
+}
+/**
+ * `# ds:guidelines — 5,814 chars, showing 400` — states a preview as a preview.
+ *
+ * On its OWN line ABOVE the triple, never trailing it: a Turtle comment runs to
+ * end of line, so a note placed after the object swallows the `;` or `.` that
+ * terminates the statement and silently breaks the document.
+ */
+function truncationNote(predicate, term) {
+    if (!term.truncated || term.length === undefined)
+        return undefined;
+    const total = term.length.toLocaleString("en-US");
+    return `  # ${predicate} — ${total} chars, showing ${term.value.length}`;
+}
+/** Render one inlined blank node as a Turtle `[ … ]` record. */
+function renderNested(record) {
+    const fields = Object.entries(record).map(([field, value]) => {
+        // `type` was hoisted out of the record body on the way in; `a` is Turtle's
+        // own shorthand for it, so it goes back exactly where it came from.
+        const predicate = field === "type" ? "a" : asName(field);
+        return `${predicate} ${renderTerm(value)}`;
+    });
+    return `[ ${fields.join(" ; ")} ]`;
+}
+/** The prefixes a rendering actually uses, so the header declares no more. */
+function usedPrefixes(text, prefixes) {
+    return Object.entries(prefixes)
+        .filter(([prefix]) => new RegExp(`\\b${prefix}:`).test(text))
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([prefix, namespace]) => `@prefix ${prefix}: <${namespace}> .`);
+}
+/** `# rdf:type — 330 total, sample of 5` and the triples under it. */
+function renderInbound(subject, group) {
+    const predicate = renderTerm(group.predicate);
+    const total = group.count.toLocaleString("en-US");
+    // An empty `subjects` means two different things, and conflating them told a
+    // lie: at `summary` EVERY group is empty because the level exhibits none, so
+    // claiming "none individually addressable" there libelled perfectly nameable
+    // subjects. Only a level that WOULD have shown exemplars can conclude that
+    // none exist.
+    const exhibits = group.exhibits ?? 0;
+    const note = exhibits > 0 && group.subjects.length === 0 && group.count > 0
+        ? `# ${predicate} — ${total} total, none individually addressable; use the noun's list verb`
+        : group.sampled
+            ? `# ${predicate} — ${total} total, sample of ${group.subjects.length}; use the noun's list verb for the full set`
+            : group.truncated
+                ? `# ${predicate} — ${total} total, showing ${group.subjects.length}`
+                : `# ${predicate} — ${total}`;
+    return [
+        note,
+        ...group.subjects.map((s) => `${renderTerm(s)} ${predicate} ${subject} .`),
+    ];
+}
+/**
+ * Render an entity's neighbourhood as a Turtle document.
+ *
+ * @param result - The neighbourhood projection to serialize.
+ * @param prefixes - The store's merged prefix map, for the `@prefix` header.
+ * @returns A Turtle document: header, the subject's own triples, its inlined
+ *   blank nodes, then the edges pointing at it.
+ */
+export function toTurtle(result, prefixes) {
+    const subject = result.prefixed ?? `<${result.uri}>`;
+    const body = [];
+    // The subject's own triples, one predicate per line.
+    const predicates = [];
+    for (const group of result.groups) {
+        const predicate = renderTerm(group.predicate);
+        // Blank objects are written as their inlined records instead, so they are
+        // skipped here — emitting both would assert the same edge twice.
+        const objects = group.objects.filter((o) => o.termType !== "BlankNode");
+        if (objects.length === 0)
+            continue;
+        const keyword = predicate === "rdf:type" ? "a" : predicate;
+        // Notes are folded INTO the element, above its statement, so the `;` the
+        // join appends always lands on the statement line. Pushed as siblings they
+        // would each take a separator of their own — into a comment, which runs to
+        // end of line and eats it.
+        const notes = objects
+            .map((o) => truncationNote(keyword, o))
+            .filter((n) => n !== undefined);
+        const rendered = objects.map(renderTerm).join(", ");
+        predicates.push([...notes, `  ${keyword} ${rendered}`].join("\n"));
+    }
+    for (const [via, records] of Object.entries(result.nested)) {
+        predicates.push(`  ${via}\n    ${records.map(renderNested).join(",\n    ")}`);
+    }
+    if (predicates.length > 0) {
+        body.push(`${subject}\n${predicates.join(" ;\n")} .`);
+    }
+    if (result.inbound.length > 0) {
+        body.push("", "# ── referenced by ──");
+        for (const group of result.inbound) {
+            body.push(...renderInbound(subject, group));
+        }
+    }
+    const text = body.join("\n");
+    const header = usedPrefixes(text, prefixes);
+    return [...header, "", text].join("\n").trimEnd();
+}
+//# sourceMappingURL=turtle.js.map

package/dist/src/kernel/render/turtle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"turtle.js","sourceRoot":"","sources":["../../../../src/kernel/render/turtle.ts"],"names":[],"mappings":"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"}

package/dist/src/kernel/render/vocabulary.js

@@ -0,0 +1,174 @@
+/**
+ * The rendering vocabulary — the ONE place a state and the word for it meet.
+ *
+ * `doctor` reports states, `setup` plans and applies them, and both speak to
+ * the same reader about the same machine. For as long as each surface spelled
+ * the states itself — three glyph tables, two scope-label maps, two indent
+ * constants — the type layer and the copy layer were free to disagree, and a
+ * copy pass could rename a scope in every sentence while the model underneath
+ * kept the old word. This module ends that freedom: the statuses, their
+ * glyphs, the scope names, and the shared layout markers are each defined
+ * once, here, and every renderer reads them.
+ *
+ * The SCOPES are **global** and **local project**, chosen because they are the
+ * words the user already typed: `--global` and `--local`. Reading `Local
+ * project` above a row whose fix is `pragma setup mcp --local` is the whole
+ * point — the report names the flag that repairs it. (Earlier these surfaces
+ * said MACHINE/PROJECT, and later "global band"/"project band": a third and a
+ * fourth term for the same two things, and "band" is a word nobody outside
+ * this repository has ever used for a config scope. The type layer carried
+ * "band" longest — `ScopeBand`, `PlanRow.band`, a `bands.ts` — and the render
+ * tests now guard against either spelling coming back.)
+ *
+ * The GLYPHS are one small alphabet with fixed meanings, so the same mark
+ * never says two things: `✓` is work done or verified, `✗` is a real fault,
+ * `◇` is available-but-not-set-up, `○` is inert (nothing to act on), and `·`
+ * is neutral punctuation — a sub-item bullet, or a row that never ran. Doctor
+ * and setup map their own status tiers onto that alphabet below, which is what
+ * keeps a failed setup row and a failed doctor row — the same finding seen
+ * twice — wearing the same mark.
+ *
+ * This is the RENDERING vocabulary; the graph-domain vocabulary a distribution
+ * declares (`kernel/vocabulary.ts`) is a different thing with the same good
+ * reason for existing. Like the rest of `kernel/render/`, this module is
+ * statically reachable from the `--help`/`__complete` fast paths, so it
+ * imports NOTHING — it is inert data plus two pure one-line functions.
+ */
+/** The user-facing display label for each of the two config scopes. */
+export const SCOPE_LABELS = {
+    global: "Global",
+    project: "Local project",
+};
+/**
+ * The scope phrase in running text — the lowercase form of
+ * {@link SCOPE_LABELS}, plus the word for "both". Authored here rather than
+ * lowercased at the call site so a reader grepping for either spelling lands
+ * in one file.
+ */
+export const SCOPE_PHRASES = {
+    global: "global",
+    project: "local project",
+    both: "global and local project",
+};
+// =============================================================================
+// The glyph alphabet
+// =============================================================================
+/**
+ * The five marks, by meaning. Uncolored — every glyph is tinted at render
+ * time, never baked at module load. `summon-core`'s Ink wizard renders the
+ * same `success`/`failure` marks for the same meanings; the two packages
+ * cannot share this module (the dependency runs the other way, and the
+ * fast-path covenants forbid the import), so `renderVocabularySync.test.ts`
+ * pins the two alphabets to byte equality instead.
+ */
+export const GLYPHS = {
+    /** Work done, or a state verified healthy. */
+    success: "✓",
+    /** A real fault — something set up that no longer works, or a failed row. */
+    failure: "✗",
+    /** Detected and installable, but not set up — an invitation, not a fault. */
+    available: "◇",
+    /** Inert: nothing to act on here, and nothing wrong either. */
+    inert: "○",
+    /** Neutral punctuation — a sub-item bullet, or a row that never ran. */
+    neutral: "·",
+};
+/** The arrow in front of an inline instruction (`↳ fix: …`). */
+export const FIX_ARROW = "↳";
+/** The bullet a check's indented sub-items carry. */
+export const SUB_BULLET = GLYPHS.neutral;
+/**
+ * The marker for a row that carries NO outcome — one the user deselected, so
+ * it was neither done nor skipped-for-cause. It must not be a ✓: a green check
+ * against work that never ran is the same lie the old recap told when it
+ * reported "Setup complete" over a target it had dropped.
+ */
+export const NOT_RUN_GLYPH = GLYPHS.neutral;
+// =============================================================================
+// Indents
+// =============================================================================
+/** One indent step — every list body row starts two spaces in. */
+export const INDENT = "  ";
+/**
+ * The indent that aligns a check's sub-lines under its name: the row's own
+ * {@link INDENT}, plus one glyph column, plus the two-space gap after it.
+ */
+export const SUB_INDENT = "     ";
+/**
+ * Each check status's mark. `available` gets its own glyph, distinct from ✗:
+ * an opt-in integration that is not set up is not a fault, and rendering it as
+ * one would train users to ignore the failure count. The glyph pairs with the
+ * word in the tally, so the distinction survives with color stripped.
+ */
+export const CHECK_GLYPHS = {
+    pass: GLYPHS.success,
+    fail: GLYPHS.failure,
+    available: GLYPHS.available,
+    skip: GLYPHS.inert,
+};
+/**
+ * The word in front of a check row's instruction, chosen by what the row IS.
+ *
+ * A `fail` and an `available` are things to repair or switch on, so they read
+ * `fix`. A `skip` is neither — nothing is wrong and nothing is off; the row
+ * simply has nothing to act on yet — so labelling its instruction `fix` would
+ * be the same "a skip is a fault" reading the `available` glyph exists to
+ * prevent. It reads `next`, which is what the line actually is.
+ */
+export const checkRemedyWord = (status) => status === "skip" ? "next" : "fix";
+/**
+ * Each outcome's mark. The three ways work can be complete — `done`, `noop`
+ * (already current), `removed` — all read ✓; the two ways a row can stand
+ * aside — `kept`, `skipped` — read the inert ○; only `failed` earns ✗.
+ */
+export const OUTCOME_GLYPHS = {
+    done: GLYPHS.success,
+    noop: GLYPHS.success,
+    removed: GLYPHS.success,
+    kept: GLYPHS.inert,
+    skipped: GLYPHS.inert,
+    failed: GLYPHS.failure,
+};
+/**
+ * The word in front of a row outcome's instruction — `fix` for a row that
+ * failed, `next` for one that skipped. Same rule as {@link checkRemedyWord}: a
+ * skip is not a fault, and labelling its instruction as a repair is what
+ * teaches a reader to treat skips as failures.
+ */
+export const outcomeRemedyWord = (status) => status === "failed" ? "fix" : "next";
+/**
+ * The display label for an install source, e.g. `npm (global)`, `bun link
+ * (development checkout)`, `npx (ephemeral)`, `unknown (node runtime)`. The
+ * `via` word is the manager/runner/runtime name the detector resolved —
+ * absent only for a `workspace`/`linked` install whose manager could not be
+ * told, which then reads as the bare state.
+ */
+export const installSourceLabel = (kind, via) => {
+    switch (kind) {
+        case "global":
+            return `${via} (global)`;
+        case "workspace":
+            return via ? `${via} (local project)` : "local project dependency";
+        case "linked":
+            return via
+                ? `${via} link (development checkout)`
+                : "linked (development checkout)";
+        case "ephemeral":
+            return `${via} (ephemeral)`;
+        case "unknown":
+            return `unknown (${via} runtime)`;
+    }
+};
+/**
+ * What each command-less install state says when a newer release exists —
+ * honest guidance in place of a command that would be wrong to run. The
+ * `linked` sentence is the load-bearing one: it replaces the `npm i -g` that
+ * would clobber the development link.
+ */
+export const INSTALL_UPDATE_GUIDANCE = {
+    workspace: "Installed as a project dependency — update it through the project's package.json.",
+    linked: "Linked development checkout — update it from its source tree, or unlink it before installing a release.",
+    ephemeral: "Ephemeral run — invoke it again with an explicit @latest version to pick up the newest release.",
+    unknown: "The install method cannot be determined — update it the same way it was installed.",
+};
+//# sourceMappingURL=vocabulary.js.map

package/dist/src/kernel/render/vocabulary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vocabulary.js","sourceRoot":"","sources":["../../../../src/kernel/render/vocabulary.ts"],"names":[],"mappings":"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"}

package/dist/src/kernel/render/writeStdout.js

@@ -0,0 +1,43 @@
+/**
+ * Chunked stdout writer.
+ *
+ * Bun's runtime can segfault when a single very large string is written to
+ * stdout in one call; writing in ≤4 KiB pieces avoids it. Every command's final
+ * output goes through {@link writeStdout} so large list/graph payloads stay safe.
+ * Ported from the v1 `writeChunked` guard.
+ *
+ * The text is encoded to a UTF-8 `Buffer` first and sliced on byte boundaries.
+ * Slicing the *string* by UTF-16 unit could split an astral character's
+ * surrogate pair, leaving a lone surrogate that encodes to U+FFFD and corrupts
+ * the output; splitting raw UTF-8 bytes across writes is lossless — the
+ * consumer concatenates them.
+ */
+/** Maximum bytes written per `stream.write` call. */
+const CHUNK_SIZE = 4096;
+/**
+ * Write a string to a writable stream in ≤{@link CHUNK_SIZE}-byte slices.
+ *
+ * @param stream - The destination writable stream.
+ * @param text - The full string to write.
+ * @note Impure — writes to the stream.
+ */
+export function writeChunked(stream, text) {
+    const buffer = Buffer.from(text, "utf8");
+    if (buffer.length <= CHUNK_SIZE) {
+        stream.write(buffer);
+        return;
+    }
+    for (let offset = 0; offset < buffer.length; offset += CHUNK_SIZE) {
+        stream.write(buffer.subarray(offset, offset + CHUNK_SIZE));
+    }
+}
+/**
+ * Write a string to stdout, chunked, appending no newline.
+ *
+ * @param text - The string to write.
+ * @note Impure — writes to `process.stdout`.
+ */
+export function writeStdout(text) {
+    writeChunked(process.stdout, text);
+}
+//# sourceMappingURL=writeStdout.js.map

package/dist/src/kernel/render/writeStdout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeStdout.js","sourceRoot":"","sources":["../../../../src/kernel/render/writeStdout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,qDAAqD;AACrD,MAAM,UAAU,GAAG,IAAI,CAAC;AAExB;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAC1B,MAA6B,EAC7B,IAAY;IAEZ,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IACzC,IAAI,MAAM,CAAC,MAAM,IAAI,UAAU,EAAE,CAAC;QAChC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QACrB,OAAO;IACT,CAAC;IAED,KAAK,IAAI,MAAM,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,IAAI,UAAU,EAAE,CAAC;QAClE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC;IAC7D,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,YAAY,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AACrC,CAAC"}

package/dist/src/kernel/runtime/boot.js

@@ -0,0 +1,49 @@
+/**
+ * Build the per-invocation {@link PragmaRuntime}.
+ *
+ * The runtime stays cheap and storeless to construct: `store` is a lazy handle
+ * (nothing boots until a `needsStore` verb calls `store.get()`), `query` is the
+ * facade over it, and `loadConfig` memoizes the layered-config read behind a
+ * dynamic import so the config reader (and its zod) never lands on the
+ * `--help`/`__complete` fast path. No eager I/O happens here — a storeless verb
+ * that only reads `globalFlags`/`cwd` touches neither the store nor config.
+ *
+ * The store's boot reads config through `loadConfig`, so the two memos are
+ * coupled: `store.invalidate()` (called by the MCP projector after a real
+ * mutation) also clears `configPromise` via the `onInvalidate` hook, so a
+ * re-boot re-reads config from disk instead of reusing a stale layer. On a
+ * long-lived MCP server that is what makes a `config_set` visible to the next
+ * read tool; on a one-shot CLI nothing calls `invalidate`, so it never fires.
+ */
+import { VERSION } from "../../constants.js";
+import { createQueryFacade } from "./facade.js";
+import { createLazyStore } from "./store.js";
+/**
+ * Assemble a runtime for one CLI or MCP invocation.
+ *
+ * @param globalFlags - The parsed global flags for this invocation.
+ * @param cwd - The directory to resolve project state against (defaults to the
+ *   process working directory).
+ * @returns The runtime handed to every verb `run`.
+ * @note Impure by default — reads `process.cwd()` unless `cwd` is provided; the
+ *   store/config handles it exposes do their own I/O only when used.
+ */
+export function bootRuntime(globalFlags, cwd = process.cwd()) {
+    let configPromise;
+    const loadConfig = () => {
+        configPromise ??= import("../config/readConfig.js").then((module) => module.readConfig(cwd));
+        return configPromise;
+    };
+    const store = createLazyStore({
+        cwd,
+        loadConfig,
+        // Invalidating the store must also drop the config memo its boot depends on,
+        // so a re-boot after a mutation re-reads config from disk (never stale).
+        onInvalidate: () => {
+            configPromise = undefined;
+        },
+    });
+    const query = createQueryFacade(store);
+    return { cwd, version: VERSION, globalFlags, loadConfig, store, query };
+}
+//# sourceMappingURL=boot.js.map

package/dist/src/kernel/runtime/boot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boot.js","sourceRoot":"","sources":["../../../../src/kernel/runtime/boot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAG7C;;;;;;;;;GASG;AACH,MAAM,UAAU,WAAW,CACzB,WAAwB,EACxB,MAAc,OAAO,CAAC,GAAG,EAAE;IAE3B,IAAI,aAAgD,CAAC;IACrD,MAAM,UAAU,GAAG,GAA0B,EAAE;QAC7C,aAAa,KAAK,MAAM,CAAC,yBAAyB,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAClE,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,CACvB,CAAC;QACF,OAAO,aAAa,CAAC;IACvB,CAAC,CAAC;IAEF,MAAM,KAAK,GAAG,eAAe,CAAC;QAC5B,GAAG;QACH,UAAU;QACV,6EAA6E;QAC7E,yEAAyE;QACzE,YAAY,EAAE,GAAG,EAAE;YACjB,aAAa,GAAG,SAAS,CAAC;QAC5B,CAAC;KACF,CAAC,CAAC;IACH,MAAM,KAAK,GAAG,iBAAiB,CAAC,KAAK,CAAC,CAAC;IAEvC,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;AAC1E,CAAC"}

package/dist/src/kernel/runtime/facade.js

@@ -0,0 +1,39 @@
+/**
+ * The query facade — the typed spine over the lazy store.
+ *
+ * `graphql` is the default surface: it executes a document against the pack's
+ * precompiled schema via ke-graphql's in-process `executeLocal` (no HTTP, no
+ * serialization). `sparql` is the escape hatch: a raw query against the store,
+ * auto-prefixed by ke from the pack's prefix map. Both boot the store lazily on
+ * first use through the same memoized `LazyStore.get()`. ke-graphql is
+ * dynamic-imported so this module carries no static import of the heavy
+ * runtime; the ke/graphql types are referenced inline.
+ */
+/**
+ * Build the query facade over a lazy store.
+ *
+ * @param store - The lazy store to query through.
+ * @returns The `{ graphql, sparql }` facade.
+ */
+export function createQueryFacade(store) {
+    return {
+        async graphql(document, variables) {
+            const session = await store.get();
+            const { executeLocal } = await import("@canonical/ke-graphql");
+            const result = await executeLocal({
+                schema: session.schema,
+                source: document,
+                variableValues: variables ?? undefined,
+                contextValue: session.createContext(session.store),
+            });
+            // Our packs compile without @defer/@stream, so this is always a plain
+            // ExecutionResult (never an incremental stream).
+            return result;
+        },
+        async sparql(text) {
+            const session = await store.get();
+            return session.store.query(text);
+        },
+    };
+}
+//# sourceMappingURL=facade.js.map

package/dist/src/kernel/runtime/facade.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"facade.js","sourceRoot":"","sources":["../../../../src/kernel/runtime/facade.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAgB;IAChD,OAAO;QACL,KAAK,CAAC,OAAO,CACX,QAAgB,EAChB,SAA0C;YAE1C,MAAM,OAAO,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE,CAAC;YAClC,MAAM,EAAE,YAAY,EAAE,GAAG,MAAM,MAAM,CAAC,uBAAuB,CAAC,CAAC;YAC/D,MAAM,MAAM,GAAG,MAAM,YAAY,CAAC;gBAChC,MAAM,EAAE,OAAO,CAAC,MAAM;gBACtB,MAAM,EAAE,QAAQ;gBAChB,cAAc,EAAE,SAAS,IAAI,SAAS;gBACtC,YAAY,EAAE,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC;aACnD,CAAC,CAAC;YACH,sEAAsE;YACtE,iDAAiD;YACjD,OAAO,MAA2C,CAAC;QACrD,CAAC;QAED,KAAK,CAAC,MAAM,CAAC,IAAY;YACvB,MAAM,OAAO,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE,CAAC;YAClC,OAAO,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,IAAa,CAEvC,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC"}