omgbase 0.4.1 → 0.6.0

package/dist/build-info.json

@@ -0,0 +1,4 @@
+{
+  "commit": "b380706",
+  "built": "2026-09-28T23:04:02.290Z"
+}

package/dist/src/build.d.ts

@@ -0,0 +1,22 @@
+import { type HostInfo } from "@omgbase/core";
+/**
+ * `--version` prints THIS package's version (spec/cli §2.5), read from the
+ * nearest `package.json` named `omgbase` above the running module (the source
+ * tree and the built `dist/src/` sit at different depths). The engine's own
+ * `VERSION` is the fallback only if the package file cannot be found.
+ */
+export declare function cliVersion(): string;
+export interface BuildInfo {
+    commit: string | null;
+    built: string | null;
+}
+/**
+ * `dist/build-info.json`, written by `pnpm build` (`scripts/build-info.mjs`):
+ * `{ commit: "<short sha>" | null, built: "<RFC 3339>" }`. It sits one level
+ * above this module's directory (`dist/src/` → `dist/`), so a source-tree run
+ * (vitest over `src/`) looks for `packages/cli/build-info.json`, finds nothing,
+ * and reports nulls — the same answer a build outside a git checkout gives.
+ */
+export declare function buildInfo(): BuildInfo;
+/** The `HostInfo` this binary hands the engine's `version` tool (`omg mcp`) and verb (`omg version`). */
+export declare function hostInfo(): HostInfo;

package/dist/src/build.js

@@ -0,0 +1,58 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { VERSION } from "@omgbase/core";
+// What this binary knows about itself (spec/cli §2.5 `--version`, §6 `version`):
+// its package version and the build's git revision + time.
+/**
+ * `--version` prints THIS package's version (spec/cli §2.5), read from the
+ * nearest `package.json` named `omgbase` above the running module (the source
+ * tree and the built `dist/src/` sit at different depths). The engine's own
+ * `VERSION` is the fallback only if the package file cannot be found.
+ */
+export function cliVersion() {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (;;) {
+        const candidate = join(dir, "package.json");
+        if (existsSync(candidate)) {
+            try {
+                const pkg = JSON.parse(readFileSync(candidate, "utf8"));
+                if (pkg.name === "omgbase" && typeof pkg.version === "string")
+                    return pkg.version;
+            }
+            catch {
+                /* keep walking */
+            }
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return VERSION;
+        dir = parent;
+    }
+}
+/**
+ * `dist/build-info.json`, written by `pnpm build` (`scripts/build-info.mjs`):
+ * `{ commit: "<short sha>" | null, built: "<RFC 3339>" }`. It sits one level
+ * above this module's directory (`dist/src/` → `dist/`), so a source-tree run
+ * (vitest over `src/`) looks for `packages/cli/build-info.json`, finds nothing,
+ * and reports nulls — the same answer a build outside a git checkout gives.
+ */
+export function buildInfo() {
+    const path = new URL("../build-info.json", import.meta.url);
+    try {
+        const raw = JSON.parse(readFileSync(path, "utf8"));
+        return {
+            commit: typeof raw.commit === "string" ? raw.commit : null,
+            built: typeof raw.built === "string" ? raw.built : null,
+        };
+    }
+    catch {
+        return { commit: null, built: null };
+    }
+}
+/** The `HostInfo` this binary hands the engine's `version` tool (`omg mcp`) and verb (`omg version`). */
+export function hostInfo() {
+    const { commit, built } = buildInfo();
+    return { version: cliVersion(), commit, built, resolveFrom: import.meta.url };
+}
+//# sourceMappingURL=build.js.map

package/dist/src/cmd/docs.js

@@ -30,18 +30,39 @@ function report(cli, verb, res) {
     cli.io.out(res.docId);
     return EXIT_OK;
 }
-// `mv` does not rewrite inbound links; say so wherever the move is reported
-// (spec/cli §6 `mv`): the human confirmation carries the same `dangling` list
-// the --json result does, with the retarget that fixes them.
+// `mv` rewrites the inbound links by default (spec/mutate 1.3; `--no-retarget`
+// opts out); say what happened wherever the move is reported (spec/cli §6 `mv`):
+// the human confirmation carries the `retargeted` count and the same `dangling`
+// list the --json result does, with the fix for each kind — `retarget` for
+// authored links left as written, `meta` for a frontmatter relation (never
+// rewritten by a move).
 function reportMove(cli, from, res) {
     const code = report(cli, "moved to", res);
-    if (cli.flags.mode !== "human" || res.dangling.length === 0)
+    if (cli.flags.mode !== "human")
         return code;
     const { style, io } = cli;
+    if (!cli.flags.dryRun && res.retargeted && res.retargeted.blocks.length > 0) {
+        const b = res.retargeted.blocks.length;
+        const d = res.retargeted.docs.length;
+        io.err(style.dim(`  ${style.ok(cli.render.g.ok)} retargeted ${b} inbound link${b === 1 ? "" : "s"} in ${d} document${d === 1 ? "" : "s"}`));
+    }
+    if (res.dangling.length === 0)
+        return code;
     const where = res.dangling.map((l) => (l.block ? `${l.path} ${l.block}` : `${l.path} (frontmatter)`)).join(", ");
     const n = res.dangling.length;
     io.err(style.warn(`  ${style.warn(cli.render.g.warn)} ${n} inbound link${n === 1 ? "" : "s"} still name${n === 1 ? "s" : ""} the old path: ${where}`));
-    io.err(style.dim(`  fix: ${cli.prog} retarget /${from} /${res.path} --apply`));
+    if (res.dangling.some((l) => l.block))
+        io.err(style.dim(`  fix: ${cli.prog} retarget /${from} /${res.path} --apply`));
+    const seen = new Set();
+    for (const l of res.dangling) {
+        if (l.block || !l.field)
+            continue;
+        const key = `${l.path}\u0000${l.field}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        io.err(style.dim(`  fix: ${cli.prog} meta ${l.path} --set ${l.field}=/${res.path}`));
+    }
     return code;
 }
 // ---- new --------------------------------------------------------------------
@@ -82,27 +103,31 @@ async function runMv(cli, args) {
     const { values, positionals } = parseArgs({
         args,
         allowPositionals: true,
-        options: { actor: { type: "string" }, help: { type: "boolean" } },
+        options: { actor: { type: "string" }, "no-retarget": { type: "boolean" }, help: { type: "boolean" } },
     });
     if (values.help) {
         return renderHelp(cli, {
             name: "mv",
-            summary: "Rename/move a document to a new path; its identity and history are preserved",
-            usage: "mv <doc> <new-path> [--actor <s>] [--dry-run]",
-            options: [["--actor <s>", "commit actor (default human:$USER)"]],
+            summary: "Rename/move a document to a new path; its identity and history are preserved and inbound links follow it",
+            usage: "mv <doc> <new-path> [--no-retarget] [--actor <s>] [--dry-run]",
+            options: [
+                ["--no-retarget", "leave the inbound links as written (they dangle; fix later with retarget)"],
+                ["--actor <s>", "commit actor (default human:$USER)"],
+            ],
         });
     }
     const doc = positionals[0];
     const toPath = positionals[1];
     if (!doc || !toPath)
         throw new CliUsageError("mv requires <doc> and <new-path>");
+    const noRetarget = values["no-retarget"] === true;
     if (cli.flags.server) {
-        const res = await remoteCall(cli, "docs_move", { doc, to_path: toPath, ...dryRunArg(cli) });
+        const res = await remoteCall(cli, "docs_move", { doc, to_path: toPath, ...(noRetarget ? { retarget_inbound: false } : {}), ...dryRunArg(cli) });
         return reportMove(cli, fromPathOf(res, doc), res);
     }
     const ws = cli.workspace();
     const repo = cli.repo(ws);
-    const res = docsMove(ws.store, ctxOf(cli, ws, repo.repoId, repo.rootPath, values.actor), doc, toPath);
+    const res = docsMove(ws.store, ctxOf(cli, ws, repo.repoId, repo.rootPath, values.actor), doc, toPath, noRetarget ? { retargetInbound: false } : {});
     return reportMove(cli, fromPathOf(res, doc), res);
 }
 // ---- rm --doc (block rm lives in mutate.ts; this handles the --doc branch) --

package/dist/src/cmd/help.js

@@ -11,7 +11,7 @@ const GROUPS = [
     { title: "documents", names: ["new", "mv", "meta"] },
     { title: "session", names: ["shell"] },
     { title: "sync & serve", names: ["sync", "mcp"] },
-    { title: "admin", names: ["rebuild-index", "gc", "doctor", "config", "embed"] },
+    { title: "admin", names: ["rebuild-index", "gc", "doctor", "config", "embed", "version"] },
 ];
 async function runHelp(cli) {
     const { render, style, io, prog } = cli;

package/dist/src/cmd/mcp.js

@@ -4,6 +4,7 @@ import { EngineErrorLike, EXIT_OK, renderHelp } from "../output.js";
 import { installSpecSeams } from "../seams.js";
 import { loadEmbedding } from "./_embed.js";
 import { openRepoSource } from "./_source.js";
+import { hostInfo } from "../build.js";
 // `omg mcp [--no-watch]` (11 §5.8) — MCP server on stdio; the host owns the
 // process lifetime. Runs an in-process watcher by default so a lone session is
 // always fresh, auto-disabled when another live watch lease exists; --no-watch
@@ -166,6 +167,8 @@ async function runMcp(cli, args) {
         ...(repo.rootPath ? { rootPath: repo.rootPath } : {}),
         ...(drainer ? { onMutation: () => drainer.schedule() } : {}),
         ...(embedQuery ? { embedQuery } : {}),
+        // The `version` tool's view of this binary (spec/surface §4).
+        host: hostInfo(),
     });
     let shuttingDown = false;
     const shutdown = async () => {

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

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

package/dist/src/cmd/version.js

@@ -0,0 +1,68 @@
+import { parseArgs } from "node:util";
+import { versionInfo } from "@omgbase/core";
+import { EXIT_OK, emitMachine, renderHelp } from "../output.js";
+import { hostInfo } from "../build.js";
+import { remoteCall } from "./_remote.js";
+// `omg version` (spec/cli §6, 1.1): the surface's `version` tool, rendered.
+// Which engine and which component versions a host or a shell is talking to —
+// with `--server` it is the REMOTE engine's answer, which is exactly how you
+// tell a TypeScript `omg mcp` from a Rust `omgbase mcp`. Needs no repo; the
+// workspace is opened only for `schema` (`—` without one). `--version` (§2.5)
+// stays the one-line form.
+async function runVersion(cli, args) {
+    const { values } = parseArgs({ args, allowPositionals: true, options: { help: { type: "boolean" } } });
+    if (values.help) {
+        return renderHelp(cli, {
+            name: "version",
+            summary: "Which engine and which versions: the binary, its components, the specs it implements, the schema, MCP protocol, runtime, build",
+            usage: "version [--json]",
+            options: [["--json", "the `version` tool result verbatim"]],
+            notes: ["with --server, the remote engine's answer (typescript or rust)"],
+        });
+    }
+    let info;
+    if (cli.flags.server !== undefined) {
+        info = await remoteCall(cli, "version", {});
+    }
+    else {
+        // `schema` is the open database's user_version; without a workspace the
+        // command still answers (spec/cli §3.7: version ∈ NO_WORKSPACE_OK).
+        let store = null;
+        try {
+            store = cli.workspace().store;
+        }
+        catch {
+            store = null;
+        }
+        info = versionInfo(store, hostInfo());
+    }
+    cli.capture?.(info);
+    if (cli.flags.mode !== "human")
+        return emitMachine(cli, info);
+    const { io, style } = cli;
+    const dash = "—";
+    const keys = ["engine", "version", "specs", "schema", "mcp", "runtime", "commit", "built"];
+    const width = Math.max(...keys.map((k) => k.length));
+    const line = (key, value) => {
+        io.out(`${style.dim(key.padEnd(width))}  ${value === null ? style.dim(dash) : String(value)}`);
+    };
+    line("engine", info.engine);
+    line("version", info.version);
+    const names = Object.keys(info.components);
+    const nameWidth = Math.max(0, ...names.map((n) => n.length));
+    for (const name of names)
+        io.out(`  ${style.accent(name.padEnd(nameWidth))}  ${info.components[name]}`);
+    line("specs", Object.entries(info.specs).map(([k, v]) => `${k} ${v}`).join(" · "));
+    line("schema", info.schema);
+    line("mcp", info.mcp.sdk !== undefined ? `${info.mcp.protocol} (sdk ${info.mcp.sdk})` : info.mcp.protocol);
+    line("runtime", info.runtime);
+    line("commit", info.commit);
+    line("built", info.built);
+    return EXIT_OK;
+}
+export const cmdVersion = {
+    name: "version",
+    summary: "Which engine and which versions (binary, components, specs, schema, MCP, runtime, build)",
+    run: (cli, a) => runVersion(cli, a),
+};
+//# sourceMappingURL=version.js.map

package/dist/src/commands.js

@@ -24,6 +24,7 @@ import { cmdRebuild, cmdGc, cmdDoctor, cmdConfig, cmdEmbed } from "./cmd/admin.j
 import { cmdShell } from "./cmd/shell.js";
 import { cmdSource } from "./cmd/source.js";
 import { cmdHelp } from "./cmd/help.js";
+import { cmdVersion } from "./cmd/version.js";
 export const COMMANDS = [
     cmdInit,
     cmdRepos,
@@ -63,6 +64,7 @@ export const COMMANDS = [
     cmdDoctor,
     cmdConfig,
     cmdEmbed,
+    cmdVersion,
     cmdHelp,
 ];
 const BY_NAME = new Map();

package/dist/src/context.js

@@ -89,6 +89,8 @@ export const REMOTE_OK = new Set([
     "apply", "insert", "move", "split", "merge", "done", "append", "node",
     // shell accepts --server itself, then threads it into every line it runs.
     "shell",
+    // version asks the REMOTE engine which engine/versions it is (spec/cli §6).
+    "version",
 ]);
 export { CliUsageError };
 //# sourceMappingURL=context.js.map

package/dist/src/main.d.ts

@@ -1,10 +1,5 @@
 #!/usr/bin/env node
 import { type IO } from "./render.js";
-/**
- * `--version` prints THIS package's version (spec/cli §2.5), read from the
- * nearest `package.json` named `omgbase` above the running module (the source
- * tree and the built `dist/src/` sit at different depths). The engine's own
- * `VERSION` is the fallback only if the package file cannot be found.
- */
-export declare function cliVersion(): string;
+import { cliVersion } from "./build.js";
+export { cliVersion };
 export declare function run(argv: string[], io?: IO, prog?: string): Promise<number>;

package/dist/src/main.js

@@ -1,8 +1,4 @@
 #!/usr/bin/env node
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { VERSION } from "@omgbase/core";
 import { processIO } from "./render.js";
 import { makeCli, progName } from "./context.js";
 import { renderError, EXIT_OK } from "./output.js";
@@ -10,36 +6,12 @@ import { resolveCommand, unknownCommandError } from "./commands.js";
 import { runCommand, parseGlobals } from "./dispatch.js";
 import { closeRemote } from "./cmd/_remote.js";
 import { installSpecSeams } from "./seams.js";
+import { cliVersion } from "./build.js";
 // Hand-rolled router (11 §8: no commander). Splits global flags from the
 // command + its residual argv (parseGlobals, in dispatch.ts), resolves the
 // command (with aliases), then delegates to runCommand for the freshness sweep +
 // dispatch + error mapping — the same path the shell reuses per line.
-/**
- * `--version` prints THIS package's version (spec/cli §2.5), read from the
- * nearest `package.json` named `omgbase` above the running module (the source
- * tree and the built `dist/src/` sit at different depths). The engine's own
- * `VERSION` is the fallback only if the package file cannot be found.
- */
-export function cliVersion() {
-    let dir = dirname(fileURLToPath(import.meta.url));
-    for (;;) {
-        const candidate = join(dir, "package.json");
-        if (existsSync(candidate)) {
-            try {
-                const pkg = JSON.parse(readFileSync(candidate, "utf8"));
-                if (pkg.name === "omgbase" && typeof pkg.version === "string")
-                    return pkg.version;
-            }
-            catch {
-                /* keep walking */
-            }
-        }
-        const parent = dirname(dir);
-        if (parent === dir)
-            return VERSION;
-        dir = parent;
-    }
-}
+export { cliVersion };
 export async function run(argv, io = processIO, prog = "omg") {
     const parsed = parseGlobals(argv);
     const { flags } = parsed;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omgbase",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "Open Markdown Graph Base — CLI",
   "license": "MIT",
   "repository": {
@@ -45,16 +45,16 @@
     "omg": "./dist/src/main.js"
   },
   "dependencies": {
-    "@omgbase/core": "^0.4.1",
+    "@omgbase/core": "^0.6.0",
     "@omgbase/fs-adapter": "^0.2.0",
-    "@omgbase/sync": "^0.4.1",
+    "@omgbase/sync": "^0.4.3",
     "yaml": "^2.9.0"
   },
   "devDependencies": {
     "@simplebrains/recital": "^0.8.1"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json && node scripts/build-info.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "vitest run",
     "lint": "eslint .",