@omgbase/core 0.4.1 → 0.5.0

package/dist/src/index.d.ts

@@ -1,4 +1,6 @@
 export { VERSION } from "./core/index.js";
+export { versionInfo, coreVersion, nearestPackageVersion, COMPONENT_PACKAGES, type VersionInfo, type HostInfo } from "./version.js";
+export { SPEC_VERSIONS, type SpecName } from "./spec-versions.js";
 export type { FormatAdapter, AdapterEdge, ProjectedNode, EmbeddingChunk, ReconcileHints } from "./format/adapter.js";
 export { AdapterCapability } from "./format/adapter.js";
 export { registerAdapter, adapterForFormat, adapterForPath, registeredFormats, detectFormat } from "./format/registry.js";

package/dist/src/index.js

@@ -1,4 +1,6 @@
 export { VERSION } from "./core/index.js";
+export { versionInfo, coreVersion, nearestPackageVersion, COMPONENT_PACKAGES } from "./version.js";
+export { SPEC_VERSIONS } from "./spec-versions.js";
 export { AdapterCapability } from "./format/adapter.js";
 export { registerAdapter, adapterForFormat, adapterForPath, registeredFormats, detectFormat } from "./format/registry.js";
 export { markdownAdapter, MARKDOWN_FORMAT } from "./format/markdown.js";

package/dist/src/mcp/server.d.ts

@@ -1,5 +1,6 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { Store } from "../core/store/store.js";
+import { type HostInfo } from "../version.js";
 export interface ServerContext {
     store: Store;
     /** The DEFAULT repo for calls that omit `repo` (ADR-014). Tools accept an
@@ -26,5 +27,12 @@ export interface ServerContext {
      * embedding happens off it. Absent ⇒ mutations don't auto-drain.
      */
     onMutation?: () => void;
+    /**
+     * The serving binary's identity for the `version` tool (spec/surface §4): its
+     * own version, build info and the module its component packages resolve from.
+     * Set by `omg mcp`; absent for a library embedding (the tool then reports the
+     * engine's own version and whatever components resolve from core).
+     */
+    host?: HostInfo;
 }
 export declare function buildServer(ctx: ServerContext): McpServer;

package/dist/src/mcp/server.js

@@ -23,6 +23,7 @@ import { resolve as resolveThing } from "../search/resolve.js";
 import { reposStatus, syncStatus, reposList } from "../sync/admin.js";
 import { observeFile, observeMany, observeDelete } from "../sync/observe.js";
 import { QUERY_SYNTAX } from "./reference.js";
+import { versionInfo } from "../version.js";
 // Kernel-op schemas (04 §1) published as the `apply` tool's op grammar. Giving
 // each op a real schema (rather than z.any()) makes the required fields
 // discoverable in the tool's JSON schema and turns a malformed op — e.g. an
@@ -1069,6 +1070,20 @@ export function buildServer(ctx) {
             return fail(e);
         }
     });
+    // Which engine and which versions (spec/surface §4, 1.4). No repo scope: the
+    // answer is about the binary and its database, not a repo.
+    server.registerTool("version", {
+        description: "Which engine and which versions you are talking to: `{ engine: \"typescript\"|\"rust\", version, components: { <package>: <version> }, specs: { oqx, format, reconcile, store, properties, graph, search, mutate, sync, surface, cli }, schema, mcp: { protocol, sdk? }, runtime, commit, built }`. " +
+            "`version` is the serving binary's own; `components` every omgbase package it is built from; `specs` the spec versions it implements (compile-time constants); `schema` the database's `PRAGMA user_version`; `commit`/`built` the build's git revision and RFC 3339 time (null when unknown). No arguments, no repo scope.",
+        inputSchema: {},
+    }, async () => {
+        try {
+            return ok(versionInfo(store, ctx.host));
+        }
+        catch (e) {
+            return fail(e);
+        }
+    });
     return server;
 }
 //# sourceMappingURL=server.js.map

package/dist/src/spec-versions.d.ts

@@ -0,0 +1,14 @@
+export declare const SPEC_VERSIONS: {
+    readonly oqx: "0.13";
+    readonly format: "0.2";
+    readonly reconcile: "2.3";
+    readonly store: "13.5";
+    readonly properties: "1.1";
+    readonly graph: "1.1";
+    readonly search: "1.2";
+    readonly mutate: "1.2";
+    readonly sync: "1.3";
+    readonly surface: "1.4";
+    readonly cli: "1.1";
+};
+export type SpecName = keyof typeof SPEC_VERSIONS;

package/dist/src/spec-versions.js

@@ -0,0 +1,25 @@
+import { LANGUAGE_VERSION } from "@omgbase/oqx";
+// The spec versions this reference implements (spec/surface §4, the `version`
+// tool's `specs`): one compile-time constant per `spec/<x>/VERSION`, NOT a file
+// read — a published package has no `spec/` next to it. Hand-maintained; the
+// test beside this module (`spec-versions.test.ts`) asserts every entry equals
+// the corresponding `spec/<x>/VERSION` file and that no spec is missing, so a
+// spec bump that forgets this map fails the build. `oqx` is the one entry with
+// a constant of its own: `@omgbase/oqx`'s `LANGUAGE_VERSION`.
+//
+// Key order is the order spec/surface §4 lists them (the CLI prints `specs` in
+// this order).
+export const SPEC_VERSIONS = {
+    oqx: LANGUAGE_VERSION,
+    format: "0.2",
+    reconcile: "2.3",
+    store: "13.5",
+    properties: "1.1",
+    graph: "1.1",
+    search: "1.2",
+    mutate: "1.2",
+    sync: "1.3",
+    surface: "1.4",
+    cli: "1.1",
+};
+//# sourceMappingURL=spec-versions.js.map

package/dist/src/version.d.ts

@@ -0,0 +1,39 @@
+import type { Store } from "./core/store/store.js";
+import { SPEC_VERSIONS } from "./spec-versions.js";
+export interface HostInfo {
+    /** the serving binary's own version — `omgbase`'s package.json (what `--version` prints) */
+    version: string;
+    /** the build's short git revision, from `build-info.json`; null when unknown */
+    commit: string | null;
+    /** the build's RFC 3339 time, from `build-info.json`; null when unknown */
+    built: string | null;
+    /** the host module's `import.meta.url`: the component packages are resolved from its dependency graph */
+    resolveFrom?: string;
+}
+export interface VersionInfo {
+    engine: "typescript";
+    version: string;
+    /** every omgbase package the binary is built from, keys sorted bytewise */
+    components: Record<string, string>;
+    specs: typeof SPEC_VERSIONS;
+    /** `PRAGMA user_version` of the open store; null without one */
+    schema: number | null;
+    mcp: {
+        protocol: string;
+        sdk: string;
+    };
+    runtime: string;
+    commit: string | null;
+    built: string | null;
+}
+/** The omgbase packages the reference binary is built from (spec/surface §4). */
+export declare const COMPONENT_PACKAGES: readonly ["omgbase", "@omgbase/core", "@omgbase/oqx", "@omgbase/sync", "@omgbase/fs-adapter"];
+/** The nearest `package.json` named `name` at or above `fromUrl`'s directory, or null. */
+export declare function nearestPackageVersion(fromUrl: string, name: string): string | null;
+/** The engine's own package version (`@omgbase/core`), from the manifest above this module. */
+export declare function coreVersion(): string;
+/**
+ * The `version` result. `store` supplies `schema`; `host` the binary's own
+ * version, build info and resolution anchor (see the module comment).
+ */
+export declare function versionInfo(store?: Store | null, host?: HostInfo): VersionInfo;

package/dist/src/version.js

@@ -0,0 +1,103 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { LATEST_PROTOCOL_VERSION } from "@modelcontextprotocol/sdk/types.js";
+import { SPEC_VERSIONS } from "./spec-versions.js";
+/** The omgbase packages the reference binary is built from (spec/surface §4). */
+export const COMPONENT_PACKAGES = ["omgbase", "@omgbase/core", "@omgbase/oqx", "@omgbase/sync", "@omgbase/fs-adapter"];
+const MCP_SDK = "@modelcontextprotocol/sdk";
+/** The nearest `package.json` named `name` at or above `fromUrl`'s directory, or null. */
+export function nearestPackageVersion(fromUrl, name) {
+    let dir = dirname(fileURLToPath(fromUrl));
+    for (;;) {
+        const candidate = join(dir, "package.json");
+        if (existsSync(candidate)) {
+            const pkg = readManifest(candidate);
+            if (pkg?.name === name && typeof pkg.version === "string")
+                return pkg.version;
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+function readManifest(path) {
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * `name`'s installed version as seen from `anchors` (module URLs). Node's own
+ * resolver is no use here: the omgbase packages are ESM-only (`exports` with an
+ * `import` condition alone), which a CJS `require.resolve` cannot see, and no
+ * package exports its `package.json`. So this walks what the algorithm would
+ * absent `exports`: the anchor's own package first (a package cannot name
+ * itself), then `node_modules/<name>/package.json` at each ancestor directory —
+ * pnpm's symlinked layout, npm's hoisted global install and a plain checkout all
+ * put the manifest there. Anchors are tried in turn; null when none has it.
+ */
+function resolvePackageVersion(name, anchors) {
+    for (const anchor of anchors) {
+        const own = nearestPackageVersion(anchor, name);
+        if (own !== null)
+            return own;
+        let dir = dirname(fileURLToPath(anchor));
+        for (;;) {
+            const pkg = readManifest(join(dir, "node_modules", name, "package.json"));
+            if (pkg?.name === name && typeof pkg.version === "string")
+                return pkg.version;
+            const parent = dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    return null;
+}
+/** The MCP SDK's version: from the module core itself imports, walking up to its manifest (its `package.json` is not exported). */
+function mcpSdkVersion() {
+    try {
+        return nearestPackageVersion(import.meta.resolve(`${MCP_SDK}/types.js`), MCP_SDK);
+    }
+    catch {
+        return null;
+    }
+}
+/** The engine's own package version (`@omgbase/core`), from the manifest above this module. */
+export function coreVersion() {
+    return nearestPackageVersion(import.meta.url, "@omgbase/core") ?? "0.0.0";
+}
+/**
+ * The `version` result. `store` supplies `schema`; `host` the binary's own
+ * version, build info and resolution anchor (see the module comment).
+ */
+export function versionInfo(store, host) {
+    const anchors = [...(host?.resolveFrom ? [host.resolveFrom] : []), import.meta.url];
+    const components = {};
+    for (const name of COMPONENT_PACKAGES) {
+        // The host IS `omgbase`: its version is what it says it is (the resolver
+        // would find the same manifest above `resolveFrom`, but the host is explicit).
+        const v = name === "omgbase" && host ? host.version : resolvePackageVersion(name, anchors);
+        if (v !== null)
+            components[name] = v;
+    }
+    const sorted = Object.fromEntries(Object.entries(components).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)));
+    const version = host?.version ?? components["omgbase"] ?? coreVersion();
+    const schema = store ? store.db.pragma("user_version", { simple: true }) : null;
+    return {
+        engine: "typescript",
+        version,
+        components: sorted,
+        specs: SPEC_VERSIONS,
+        schema,
+        mcp: { protocol: LATEST_PROTOCOL_VERSION, sdk: mcpSdkVersion() ?? "unknown" },
+        runtime: `node ${process.versions.node}`,
+        commit: host?.commit ?? null,
+        built: host?.built ?? null,
+    };
+}
+//# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omgbase/core",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Open Markdown Graph Base — embedded engine",
   "license": "MIT",
   "repository": {