omgbase 0.1.0

package/dist/src/cmd/outline.js

@@ -0,0 +1,87 @@
+import { parseArgs } from "node:util";
+import { findDoc, docsOutline } from "@omgbase/core";
+import { CliUsageError, EngineErrorLike, truncationFooter, EXIT_OK, renderHelp } from "../output.js";
+import { remoteCall } from "./_remote.js";
+// `omg outline <doc|path>` (alias ol) — the wire format (06 §6). Human output
+// prints the outline text with full block ids inline; --json emits the
+// OutlineResult verbatim.
+async function runOutline(cli, args) {
+    const { values, positionals } = parseArgs({
+        args,
+        allowPositionals: true,
+        options: {
+            depth: { type: "string" },
+            section: { type: "string" },
+            skeleton: { type: "boolean" },
+            help: { type: "boolean" },
+        },
+    });
+    if (values.help) {
+        return renderHelp(cli, {
+            name: "outline",
+            summary: "A document's outline with block ids inline (frozen wire format) — the orientation view",
+            usage: "outline <doc|path> [--depth <n>] [--section <locator>] [--skeleton]",
+            options: [
+                ["--depth <n>", "limit heading depth"],
+                ["--section <locator>", "outline only the section at a locator"],
+                ["--skeleton", "structure only, no text"],
+            ],
+        });
+    }
+    const ref = positionals[0];
+    if (!ref)
+        throw new CliUsageError("outline requires a <doc|path>");
+    let result;
+    let header;
+    if (cli.flags.server) {
+        // Remote: the docs_outline tool resolves the ref + returns the same
+        // OutlineResult. The header shows the ref you passed (no local path lookup).
+        result = await remoteCall(cli, "docs_outline", {
+            doc: ref,
+            ...(values.depth ? { depth: Number(values.depth) } : {}),
+            ...(values.skeleton ? { resolution: "skeleton" } : {}),
+        });
+        header = ref;
+    }
+    else {
+        const ws = cli.workspace();
+        const repo = cli.repo(ws);
+        const info = ref.startsWith("d_") ? findDoc(ws.store, { docId: ref }) : findDoc(ws.store, { repoId: repo.repoId, path: ref });
+        if (!info)
+            throw new EngineErrorLike("doc_missing", `no document ${ref}`);
+        const opts = {};
+        if (values.depth)
+            opts.depth = Number(values.depth);
+        if (values.skeleton)
+            opts.resolution = "skeleton";
+        result = docsOutline(ws.store, info.docId, opts);
+        header = info.path;
+    }
+    if (cli.flags.mode !== "human") {
+        cli.io.out(JSON.stringify(result));
+        return EXIT_OK;
+    }
+    const { render, style, io } = cli;
+    io.out(render.wordmark(header));
+    io.out(render.rule(40));
+    // Colorize the inline block ids + § marks.
+    for (const line of result.text.split("\n")) {
+        io.out(colorizeOutline(line, style));
+    }
+    if (result.truncated)
+        truncationFooter(io, style, "budget");
+    return EXIT_OK;
+}
+function colorizeOutline(line, style) {
+    // leading block id (b_…) → id style; trailing ` §` → accent.
+    return line
+        .replace(/\bb_[0-9a-z]+\b/, (m) => style.id(m))
+        .replace(/§/g, style.accent("§"));
+}
+export const cmdOutline = {
+    name: "outline",
+    aliases: ["ol"],
+    summary: "Document outline (frozen wire format)",
+    run: (cli, a) => runOutline(cli, a),
+};
+//# sourceMappingURL=outline.js.map

package/dist/src/cmd/retarget.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "../commands.js";
+export declare const cmdRetarget: Command;

package/dist/src/cmd/retarget.js

@@ -0,0 +1,91 @@
+import { parseArgs } from "node:util";
+import { linksRetarget } from "@omgbase/core";
+import { CliUsageError, EXIT_OK, renderHelp } from "../output.js";
+import { runOps } from "./_mutate.js";
+import { remoteCall } from "./_remote.js";
+// `omg retarget <from> <to> [--scope glob] [--apply]` (11 §5.6) — plan-by-default.
+// Without --apply it runs the dry-run and prints the per-block diffs (the 06 §4
+// "always dry-run first" contract, encoded as the default). --apply commits.
+async function runRetarget(cli, args) {
+    const { values, positionals } = parseArgs({
+        args,
+        allowPositionals: true,
+        options: { scope: { type: "string" }, apply: { type: "boolean" }, actor: { type: "string" }, help: { type: "boolean" } },
+    });
+    if (values.help) {
+        return renderHelp(cli, {
+            name: "retarget",
+            summary: "Rewrite every link that points at <from> to point at <to> — plan-by-default, --apply commits",
+            usage: "retarget <from> <to> [--scope <glob>] [--apply] [--actor <s>] [--dry-run]",
+            options: [
+                ["--scope <glob>", "only rewrite links in documents matching the path glob"],
+                ["--apply", "commit the rewrite (default: print the plan only)"],
+                ["--actor <s>", "commit actor (default human:$USER)"],
+            ],
+        });
+    }
+    const from = positionals[0];
+    const to = positionals[1];
+    if (!from || !to)
+        throw new CliUsageError("retarget requires <from> and <to> targets");
+    // Remote: links_retarget resolves + (optionally) applies server-side.
+    if (cli.flags.server) {
+        const r = await remoteCall(cli, "links_retarget", {
+            from_target: from, to_target: to, dry_run: !values.apply, ...(values.scope ? { path_glob: values.scope } : {}),
+        });
+        if (values.apply) {
+            if (cli.flags.mode !== "human")
+                cli.io.out(JSON.stringify(r));
+            else
+                cli.io.err(cli.style.dim(`  ${cli.style.ok(cli.render.g.ok)} retargeted ${r.hits.length} block(s)`));
+            return EXIT_OK;
+        }
+        return renderPlan(cli, from, to, r.hits);
+    }
+    const ws = cli.workspace();
+    const repo = cli.repo(ws);
+    const { ops, hits } = linksRetarget(ws.store, repo.repoId, from, to, values.scope ? { pathGlob: values.scope } : {});
+    // --apply → commit via the shared helper (honors --dry-run too, if combined).
+    if (values.apply) {
+        return runOps(cli, ws, repo, ops, values.actor ? { actor: values.actor } : {});
+    }
+    return renderPlan(cli, from, to, hits);
+}
+// Plan (default): show what WOULD change, commit nothing.
+function renderPlan(cli, from, to, hits) {
+    if (cli.flags.mode === "json") {
+        cli.io.out(JSON.stringify({ from, to, hits }));
+        return EXIT_OK;
+    }
+    const { style, io } = cli;
+    if (hits.length === 0) {
+        io.err(style.dim(`  no blocks reference ${from}`));
+        return EXIT_OK;
+    }
+    io.err(style.dim(`  plan — ${hits.length} block(s) would change; re-run with --apply to commit`));
+    for (const h of hits) {
+        io.out(style.id(h.block));
+        for (const line of lineDiff(h.oldRaw, h.newRaw)) {
+            io.out(line.startsWith("+") ? style.ok(line) : line.startsWith("-") ? style.err(line) : style.dim(line));
+        }
+        io.out("");
+    }
+    return EXIT_OK;
+}
+function lineDiff(before, after) {
+    const a = before.split("\n");
+    const b = after.split("\n");
+    const out = [];
+    const max = Math.max(a.length, b.length);
+    for (let i = 0; i < max; i++) {
+        if (a[i] === b[i])
+            continue;
+        if (a[i] !== undefined)
+            out.push(`- ${a[i]}`);
+        if (b[i] !== undefined)
+            out.push(`+ ${b[i]}`);
+    }
+    return out;
+}
+export const cmdRetarget = { name: "retarget", summary: "Rewrite a link target (plan-by-default)", run: (c, a) => runRetarget(c, a) };
+//# sourceMappingURL=retarget.js.map

package/dist/src/cmd/run.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "../commands.js";
+export declare const cmdRun: Command;

package/dist/src/cmd/run.js

@@ -0,0 +1,135 @@
+import { parseArgs } from "node:util";
+import { resolveRef, findDoc, loadDocBlocks, blockRaw, oqxRun, oqxRunAsync, collectSemanticPhrases } from "@omgbase/core";
+import { CliUsageError, EngineErrorLike, truncationFooter, EXIT_OK, renderHelp } from "../output.js";
+import { loadEmbedding } from "./_embed.js";
+// `omg run <locator|path>` (11 §5.3) — evaluate the first ```omg fence in a doc
+// (or the fence at a block locator) and print its results. The fence body is an
+// OQX source string (the same language `omg query` runs). Strictly read-and-print:
+// fences stay INERT in the corpus (ADR-011 §8) — nothing is projected or written.
+function firstOmgFence(roots) {
+    for (const n of roots) {
+        if (n.type === "code_fence" && n.attrs.lang === "omg")
+            return n;
+        const inner = firstOmgFence(n.children);
+        if (inner)
+            return inner;
+    }
+    return null;
+}
+// Strip the ``` fences from a code-fence block's raw, returning the body.
+function fenceBody(raw) {
+    const lines = raw.split("\n");
+    if (lines[0]?.trimStart().startsWith("```"))
+        lines.shift();
+    while (lines.length && lines[lines.length - 1].trim() === "")
+        lines.pop();
+    if (lines[lines.length - 1]?.trimStart().startsWith("```"))
+        lines.pop();
+    return lines.join("\n");
+}
+async function runRun(cli, args) {
+    const { values, positionals } = parseArgs({ args, allowPositionals: true, options: { help: { type: "boolean" } } });
+    if (values.help) {
+        return renderHelp(cli, {
+            name: "run",
+            summary: "Evaluate the ```omg fence (an OQX query) at a locator — or the first fence in a document — and print its results",
+            usage: "run <locator|path> [--ids|--json|--jsonl]",
+            options: [["<locator|path>", "a fence block's locator, or a document whose first ```omg fence is run"]],
+            notes: ["Strictly read-and-print: fences stay inert in the corpus; nothing is projected or written."],
+        });
+    }
+    const ref = positionals[0];
+    if (!ref)
+        throw new CliUsageError("run requires a <locator|path>");
+    const ws = cli.workspace();
+    const repo = cli.repo(ws);
+    // A block ref runs that fence; a doc/path ref runs the doc's first omg fence.
+    const resolved = resolveRef(ws.store, repo.repoId, ref);
+    if (!resolved)
+        throw new EngineErrorLike("doc_missing", `no node ${ref}`);
+    let fenceRaw = null;
+    if (resolved.kind === "block") {
+        const roots = loadDocBlocks(ws.store, resolved.docId);
+        const find = (nodes) => {
+            for (const n of nodes) {
+                if (n.blockId === resolved.blockId)
+                    return n;
+                const inner = find(n.children);
+                if (inner)
+                    return inner;
+            }
+            return null;
+        };
+        const node = find(roots);
+        if (!node || node.type !== "code_fence")
+            throw new EngineErrorLike("opaque_block", `block ${ref} is not an omg fence`);
+        fenceRaw = blockRaw(ws.store, node.rawHashHex);
+    }
+    else {
+        const info = findDoc(ws.store, { docId: resolved.docId });
+        void info;
+        const fence = firstOmgFence(loadDocBlocks(ws.store, resolved.docId));
+        if (!fence)
+            throw new EngineErrorLike("target_missing", `no \`\`\`omg fence in ${ref}`);
+        fenceRaw = blockRaw(ws.store, fence.rawHashHex);
+    }
+    const source = fenceBody(fenceRaw).trim();
+    if (!source)
+        throw new EngineErrorLike("target_missing", `the omg fence in ${ref} is empty`);
+    // Same execution path as `omg query`: load the embedder only when the fence uses
+    // semantic(...); everything else runs on the sync core.
+    const phrases = collectSemanticPhrases(source);
+    let result;
+    if (phrases.length > 0) {
+        const loaded = await loadEmbedding(ws, repo.repoId);
+        if (!loaded) {
+            throw new EngineErrorLike("semantic_unavailable", "semantic(...) needs an embedding provider", {
+                hint: "omg config set embedding.provider <command|url>",
+            });
+        }
+        try {
+            const embed = async (t) => ({ model: loaded.provider.model, vec: await loaded.worker.embedQuery(t) });
+            result = await oqxRunAsync(ws.store, repo.repoId, source, {}, embed);
+        }
+        finally {
+            await loaded.close();
+        }
+    }
+    else {
+        result = oqxRun(ws.store, repo.repoId, source);
+    }
+    if (cli.flags.mode === "json") {
+        cli.io.out(JSON.stringify(result));
+        return EXIT_OK;
+    }
+    if (result.consumer === "count" || result.consumer === "exists" || result.consumer === "none") {
+        cli.io.out(result.consumer === "count" ? String(result.count) : result.consumer === "exists" ? String(result.exists) : String(result.none));
+        return EXIT_OK;
+    }
+    if (result.values) {
+        for (const v of result.values)
+            cli.io.out(typeof v === "string" ? v : JSON.stringify(v));
+        if (result.truncated)
+            truncationFooter(cli.io, cli.style, result.cursor ?? "");
+        return EXIT_OK;
+    }
+    if (cli.flags.mode === "ids") {
+        for (const h of result.hits)
+            cli.io.out(h.id);
+        return EXIT_OK;
+    }
+    const { style, io } = cli;
+    if (result.hits.length === 0) {
+        io.err(style.dim("  no hits"));
+        return EXIT_OK;
+    }
+    for (const h of result.hits) {
+        const preview = typeof h.text === "string" ? String(h.text).split("\n")[0] : "";
+        io.out(`${style.id(h.id)}  ${style.accent(h.path)}  ${preview}`.trimEnd());
+    }
+    if (result.truncated)
+        truncationFooter(io, style, result.cursor ?? "");
+    return EXIT_OK;
+}
+export const cmdRun = { name: "run", summary: "Evaluate an ```omg fence (OQX, inert, read-only)", run: (c, a) => runRun(c, a) };
+//# sourceMappingURL=run.js.map

package/dist/src/cmd/shell.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "../commands.js";
+export declare const cmdShell: Command;

package/dist/src/cmd/shell.js

@@ -0,0 +1,159 @@
+import { parseArgs } from "node:util";
+import { createInterface } from "node:readline";
+import { EXIT_OK, renderHelp } from "../output.js";
+import { ShellSession } from "../shell/session.js";
+// `omg shell` (11 shell) — a persistent in-process session. One open
+// Workspace/store is reused across every command (no per-invocation startup
+// cost), and typed command results become ephemeral bindings (@1/@_/@name). Two
+// drive modes share one ShellSession runtime: an interactive readline REPL on a
+// TTY, and a script runner when stdin is piped (one line per command) — the
+// latter is also what a Markdown CLI-session test would feed.
+async function runShell(cli, args) {
+    const { values } = parseArgs({
+        args,
+        allowPositionals: true,
+        options: { help: { type: "boolean" }, prompt: { type: "string" } },
+    });
+    if (values.help) {
+        return renderHelp(cli, {
+            name: "shell",
+            summary: "A persistent session: one open workspace across commands, and results become typed bindings (@1/@_/@name)",
+            usage: "shell [--prompt <str>] [--server <cmd|url>]",
+            options: [
+                ["--prompt <str>", "emit <str> before reading each piped line so a driver (e.g. recital) can sync on it; also $OMG_SHELL_PROMPT (--prompt wins)"],
+                ["--server <cmd|url>", "run every line against a remote engine over MCP"],
+            ],
+            notes: ["Interactive on a TTY (type `?` for binding help, `exit` to leave); a script runner when stdin is piped (one command per line)."],
+        });
+    }
+    // An explicit prompt string, if any: --prompt wins, else $OMG_SHELL_PROMPT.
+    // In piped mode this switches on the prompt-emitting line runner; on a TTY it
+    // overrides the interactive prompt. (An empty env value is treated as unset.)
+    const promptOpt = values.prompt ?? (process.env.OMG_SHELL_PROMPT || undefined);
+    // Local mode: resolve the workspace once and hold it open for the session's
+    // lifetime. Remote mode (`--server`): no local store — every line routes over
+    // MCP through the shared connection, so we hold no workspace.
+    const ws = cli.flags.server ? undefined : cli.workspace();
+    const session = new ShellSession({
+        ...(ws ? { workspace: ws } : {}),
+        cwd: cli.cwd,
+        io: cli.io,
+        noColor: cli.style.tier === "plain",
+        ...(cli.flags.server ? { server: cli.flags.server } : {}),
+        ...(cli.flags.headers ? { headers: cli.flags.headers } : {}),
+    });
+    const interactive = cli.io.stdoutTTY && Boolean(process.stdin.isTTY);
+    if (!interactive) {
+        // Piped mode. With a prompt configured, act like the interactive REPL for a
+        // machine driver: emit the prompt (no trailing newline) before each line so
+        // a tool like recital can treat its reappearance as the end-of-command
+        // signal. Without one, keep the batch script runner (read all, run all).
+        if (promptOpt !== undefined)
+            return await runPromptedScript(cli, session, promptOpt);
+        const script = await readAll();
+        let code = EXIT_OK;
+        for (const line of script.split(/\r?\n/)) {
+            const c = await session.exec(line);
+            if (c !== EXIT_OK)
+                code = c;
+            if (session.exited)
+                break;
+        }
+        return code;
+    }
+    // Interactive REPL. A configured prompt overrides the default prompt string.
+    const prompt = promptOpt ?? (cli.style.tier === "plain" ? "omg> " : cli.style.accent("omg") + cli.style.dim("> "));
+    const rl = createInterface({ input: process.stdin, output: process.stdout, prompt });
+    cli.io.err(cli.style.dim("  omg shell — type `?` for session-binding help, `exit` to leave"));
+    rl.prompt();
+    return await new Promise((resolve) => {
+        rl.on("line", (line) => {
+            // Pause while a command runs so the next prompt appears after its output.
+            rl.pause();
+            session
+                .exec(line)
+                .catch((err) => cli.io.err(cli.style.err(String(err?.message ?? err))))
+                .finally(() => {
+                if (session.exited) {
+                    rl.close();
+                }
+                else {
+                    rl.resume();
+                    rl.prompt();
+                }
+            });
+        });
+        rl.on("close", () => {
+            cli.io.err("");
+            resolve(EXIT_OK);
+        });
+    });
+}
+/**
+ * Piped session that emits `promptStr` before each line, so a machine driver
+ * (e.g. recital's prompt mode) can sync on the prompt reappearing. The prompt is
+ * written straight to stdout with no trailing newline; command output flows
+ * through the normal IO in between. Ends on stdin EOF or an `exit` command.
+ */
+function runPromptedScript(cli, session, promptStr) {
+    const rl = createInterface({ input: process.stdin });
+    const queue = [];
+    let processing = false;
+    let inputClosed = false;
+    let code = EXIT_OK;
+    return new Promise((resolve) => {
+        // Serialize command execution: `readline` can emit several buffered `line`
+        // events before any pause takes hold, so run one command fully — output and
+        // the next prompt — before starting the next, whatever pace lines arrive at.
+        const pump = async () => {
+            if (processing)
+                return;
+            processing = true;
+            while (queue.length > 0) {
+                const line = queue.shift();
+                try {
+                    const c = await session.exec(line);
+                    if (c !== EXIT_OK)
+                        code = c;
+                }
+                catch (err) {
+                    cli.io.err(cli.style.err(String(err?.message ?? err)));
+                }
+                if (session.exited) {
+                    rl.close();
+                    resolve(code);
+                    return;
+                }
+                process.stdout.write(promptStr);
+            }
+            processing = false;
+            if (inputClosed)
+                resolve(code);
+        };
+        process.stdout.write(promptStr);
+        rl.on("line", (line) => {
+            queue.push(line);
+            void pump();
+        });
+        rl.on("close", () => {
+            inputClosed = true;
+            if (!processing && queue.length === 0)
+                resolve(code);
+        });
+    });
+}
+function readAll() {
+    return new Promise((resolve) => {
+        let buf = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (c) => (buf += c));
+        process.stdin.on("end", () => resolve(buf));
+        process.stdin.on("error", () => resolve(buf));
+    });
+}
+export const cmdShell = {
+    name: "shell",
+    summary: "Persistent session with typed bindings (@1/@_/@name)",
+    run: (cli, a) => runShell(cli, a),
+};
+//# sourceMappingURL=shell.js.map

package/dist/src/cmd/show.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "../commands.js";
+export declare const cmdShow: Command;

package/dist/src/cmd/show.js

@@ -0,0 +1,107 @@
+import { parseArgs } from "node:util";
+import { resolveRef, nodesGet, findDoc, docLinks, historyNode, docPropertiesMerged } from "@omgbase/core";
+import { CliUsageError, EngineErrorLike, EXIT_OK, renderHelp } from "../output.js";
+import { expandBlockArgs } from "./_mutate.js";
+function showOne(cli, ref, include) {
+    const ws = cli.workspace();
+    const repo = cli.repo(ws);
+    const resolved = resolveRef(ws.store, repo.repoId, ref);
+    if (!resolved)
+        throw new EngineErrorLike("doc_missing", `no node ${ref}`);
+    if (resolved.kind === "document") {
+        const info = findDoc(ws.store, { docId: resolved.docId });
+        const links = docLinks(ws.store, resolved.docId, { direction: "both" });
+        const properties = docPropertiesMerged(ws.store.db, resolved.docId);
+        const payload = { kind: "document", id: info.docId, path: info.path, properties, edges: links };
+        return { payload, render: () => renderDocCard(cli, info.path, properties, links) };
+    }
+    const node = nodesGet(ws.store, resolved.docId, resolved.blockId, { resolution: "full" });
+    if (!node)
+        throw new EngineErrorLike("block_missing", `no block ${ref}`);
+    const history = include.includes("history") ? historyNode(ws.store, resolved.blockId, { limit: 5 }) : undefined;
+    return { payload: { ...node, ...(history ? { history } : {}) }, render: () => renderBlockCard(cli, node, history) };
+}
+function runShow(cli, args) {
+    const { values, positionals } = parseArgs({
+        args,
+        allowPositionals: true,
+        options: { include: { type: "string" }, help: { type: "boolean" } },
+    });
+    if (values.help) {
+        return renderHelp(cli, {
+            name: "show",
+            summary: "Metadata card for a node: attrs, placement, open edges, last change (`cat` is the bytes)",
+            usage: "show <node…|-> [--include history]",
+            options: [
+                ["<node…>", "one or more refs: a doc/block id, a path, or a locator"],
+                ["-", `read refs from stdin, one per line (\`${cli.prog} q … --ids | ${cli.prog} show -\`)`],
+                ["--include <list>", "comma-separated extras; `history` adds the block's last 5 changes"],
+            ],
+        });
+    }
+    const refs = expandBlockArgs(positionals);
+    if (refs.length === 0)
+        throw new CliUsageError("show requires a <node> (or - to read refs from stdin)");
+    const include = (values.include ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+    const cards = refs.map((ref) => showOne(cli, ref, include));
+    // One ref keeps the single-entity shape (→ @_, frame intact); several become a list.
+    const single = cards.length === 1 ? cards[0] : null;
+    cli.capture?.(single ? single.payload : cards.map((c) => c.payload));
+    if (cli.flags.mode === "json") {
+        cli.io.out(JSON.stringify(single ? single.payload : cards.map((c) => c.payload)));
+        return EXIT_OK;
+    }
+    if (cli.flags.mode !== "human") {
+        for (const c of cards)
+            cli.io.out(JSON.stringify(c.payload));
+        return EXIT_OK;
+    }
+    for (const c of cards)
+        c.render();
+    return EXIT_OK;
+}
+function renderDocCard(cli, path, fm, links) {
+    const { render, style, io } = cli;
+    io.out(render.wordmark(path));
+    io.out(render.rule(40));
+    const keys = Object.keys(fm);
+    if (keys.length > 0) {
+        io.out(`  ${style.dim("properties")}`);
+        for (const k of keys)
+            io.out(`    ${style.accent(k)} ${style.dim("=")} ${fmt(fm[k])}`);
+    }
+    if (links.out.length > 0) {
+        io.out(`  ${style.dim("out edges")}`);
+        for (const e of links.out)
+            io.out(`    ${style.accent(e.predicate)} ${style.dim(render.g.arrow)} ${style.id(e.node)} ${style.dim(`×${e.count}`)}`);
+    }
+    if (links.in.length > 0) {
+        io.out(`  ${style.dim("backlinks")}`);
+        for (const e of links.in)
+            io.out(`    ${style.id(e.node)} ${style.dim(render.g.arrow)} ${style.accent(e.predicate)} ${style.dim(`×${e.count}`)}`);
+    }
+}
+function renderBlockCard(cli, node, history) {
+    const { render, style, io } = cli;
+    io.out(`  ${render.typeGlyph(node.type)} ${style.bold(node.type)}  ${style.id(node.id)}`);
+    io.out(render.rule(40));
+    if (node.placement)
+        io.out(`  ${style.dim("placement")}  parent=${style.id(node.placement.parent ?? "—")} ordinal=${node.placement.ordinal} depth=${node.placement.depth}`);
+    if (node.attrs && Object.keys(node.attrs).length > 0) {
+        io.out(`  ${style.dim("attrs")}`);
+        for (const [k, v] of Object.entries(node.attrs))
+            io.out(`    ${style.accent(k)} ${style.dim("=")} ${fmt(v)}`);
+    }
+    if (node.text)
+        io.out(`  ${style.dim("text")}  ${node.text}`);
+    if (history && history.length > 0) {
+        io.out(`  ${style.dim("history")}`);
+        for (const h of history)
+            io.out(`    ${style.dim(`#${h.seq}`)} ${style.accent(h.kind)} ${style.dim(h.origin)} ${style.dim(h.ts)}`);
+    }
+}
+function fmt(v) {
+    return typeof v === "string" ? v : JSON.stringify(v);
+}
+export const cmdShow = { name: "show", summary: "Metadata card for a node", run: (cli, a) => runShow(cli, a) };
+//# sourceMappingURL=show.js.map

package/dist/src/cmd/source.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "../commands.js";
+export declare const cmdSource: Command;