@omgbase/core 0.4.0 → 0.5.0

package/dist/src/oqx-js/sql/translate.d.ts

@@ -32,9 +32,22 @@ export interface Frag {
  *   prop  a document property read: a bare key on docs or `doc.<k>` (the scalar-in-scope subquery)
  */
 export type OperandKind = "text" | "int" | "num" | "bool" | "null" | "json" | "prop";
-/** A value-position fragment with the kind of value it denotes. */
+/** A value-position fragment with the kind of value it denotes, plus what the
+ * typed comparison (`typedComparison`) needs to re-shape it: the JSON column +
+ * path behind a `json` read, the document alias + key behind a `prop` read, and
+ * the constant behind a literal/binding (`value`; `bool`/`num`/`null`/text
+ * constants only — a column operand has none). */
 export interface Operand extends Frag {
     kind: OperandKind;
+    json?: {
+        col: string;
+        path: string;
+    };
+    prop?: {
+        docAlias: string;
+        key: string;
+    };
+    value?: unknown;
 }
 /**
  * Per target, the bare identifiers (and `doc.<k>` keys, via the docs set) that
@@ -61,33 +74,43 @@ export declare function translateValue(e: Expr, ctx: TranslateCtx): Frag | null;
  * comparison is pushed only when its two operand kinds are provably compared
  * the same way by SQLite and by the in-memory `equals`/`compare`.
  *
- *   Equality (`==`, `!=`) pushes iff
+ *   Equality (`==`, `!=`) pushes PLAINLY (`IS` / `IS NOT`) iff
  *     • one operand is text — SQLite's typed `IS` and strict `===` agree that a
  *       string equals nothing but an equal string (`5 IS '5'` is false);
  *     • or one operand is null and the other is NOT a property read — the same
  *       absence both ways, except that a list-valued or nested property has no
  *       scalar row (SQL NULL) where in memory the value is an array or object;
  *     • or both operands are numeric (int or num) — an exact integer comparison.
- *   Relational (`<`, `<=`, `>`, `>=`) pushes iff both operands are text or both
- *     are numeric.
+ *   Relational (`<`, `<=`, `>`, `>=`) pushes plainly iff both operands are text
+ *     or both are numeric.
+ *   TYPED pushes (the 1.2 patch, `typedComparison`): a bool literal/binding
+ *     against a json or prop read (`==`, `!=` only) and a num literal/binding
+ *     against a json or prop read (every op) push with the stored type tested
+ *     first — `json_type(x) = 'true'`, `json_type(x) IN ('integer','real') AND
+ *     json_extract(x) <op> ?`, `p.type = 'bool' AND p.val_bool = ?`, `p.type =
+ *     'number' AND p.val_num <op> ?` — wrapped `(…) IS 1` (or `IS NOT 1` for
+ *     `!=`), so an absent or differently typed value is unequal and never
+ *     ordered, exactly as in memory.
  *   Every other pair declines: SQLite sees JSON `true` and `1`, `val_bool` and
- *     `val_num` alike (`checked == 1`, `$ordinal == checked`, `verified == 1`),
- *     orders every integer before every text (`$ordinal < "3"`, `level < "x"`,
- *     `$path > 5`), and two JSON or property reads carry no type at plan time
+ *     `val_num` alike (`$ordinal == checked`, `true == 1`), orders every
+ *     integer before every text (`$ordinal < "3"`, `level < "x"`, `$path > 5`),
+ *     and two JSON or property reads carry no type at plan time
  *     (`attrs.a == attrs.b`, `era == stages`).
  *
- * The resulting grid (P = pushed, D = declined; symmetric) for `==` / `!=`:
+ * The resulting grid (P = pushed plainly, T = typed push, D = declined;
+ * symmetric) for `==` / `!=`:
  *
  *            text  int   num   bool  null  json  prop
  *   text      P     P     P     P     P     P     P
  *   int       P     P     P     D     P     D     D
- *   num       P     P     P     D     P     D     D
- *   bool      P     D     D     D     P     D     D
+ *   num       P     P     P     D     P     T     T
+ *   bool      P     D     D     D     P     T     T
  *   null      P     P     P     P     P     P     D
- *   json      P     D     D     D     P     D     D
- *   prop      P     D     D     D     D     D     D
+ *   json      P     D     T     T     P     D     D
+ *   prop      P     D     T     T     D     D     D
  *
- * and for `<` `<=` `>` `>=` only text×text, int×int, int×num, num×num push.
+ * and for `<` `<=` `>` `>=` text×text, int×int, int×num, num×num push plainly
+ * and num×json, num×prop push typed.
  */
 export declare function comparable(op: string, a: OperandKind, b: OperandKind): boolean;
 /** The complement of `comparable` — kept for readers of the earlier decline-list form. */

package/dist/src/oqx-js/sql/translate.js

@@ -28,7 +28,12 @@
 //     KINDS of its two operands are provably compared the same way — see
 //     `comparable` (the spec/surface §1 decline (a)) — and a name that is a relation, reach-through
 //     or source handle is never read as a property (decline (b),
-//     `NON_PROPERTY_NAMES`).
+//     `NON_PROPERTY_NAMES`). A bool or num literal against a JSON or property
+//     read is a TYPED push (the 1.2 patch): the stored type is tested in SQL
+//     before the value (`json_type(x) = 'true'`, `p.type = 'number' AND
+//     p.val_num >= ?`) and the whole test is wrapped `(…) IS 1` / `IS NOT 1`,
+//     so an absent or differently typed value compares as in memory —
+//     unequal, never ordered. See `typedComparison`.
 //
 // Only forms that are faithful in a POSITIVE, AND-composed context are
 // translated (that is the only context `partitionPushable` pushes into). `||`,
@@ -103,38 +108,46 @@ function intrinsicSql(name, ctx) {
  * unplanned when one is residual: spec/surface §1 decline (c)). */
 export const RESERVED_DOC_BASENAMES = new Set(["id", "path", "updated_at", "content_hash", "body"]);
 const SEG = /^[A-Za-z_][A-Za-z0-9_]*$/; // injection-safe inlined identifier
-// A single-valued document property (the CEL scalar-in-scope rule): the scalar
-// value only when the key has exactly one row in scope and it is card='scalar',
+// The single-scalar-row scope of a document property (the CEL scalar-in-scope
+// rule): the row for `key` on the document only when the key has exactly one
+// row in scope and it is card='scalar' — a list-valued or nested key has none.
+// `select` is the projected expression over the alias `p`.
+function propSubquery(docAlias, key, select) {
+    return `(SELECT ${select} FROM properties p
+           WHERE p.doc_id = ${docAlias}.doc_id AND p.key = '${key}' AND p.card = 'scalar' AND p.deleted_commit IS NULL
+             AND (SELECT COUNT(*) FROM properties p2 WHERE p2.doc_id = ${docAlias}.doc_id AND p2.key = '${key}' AND p2.deleted_commit IS NULL) = 1
+           LIMIT 1)`;
+}
+// A single-valued document property: the scalar value of its one row in scope,
 // else NULL — matching the store context's `docProp` for a scalar read.
 function propScalar(docAlias, key) {
     if (!SEG.test(key))
         return null;
     return {
-        sql: `(SELECT COALESCE(p.val_text, p.val_num, p.val_bool) FROM properties p
-           WHERE p.doc_id = ${docAlias}.doc_id AND p.key = '${key}' AND p.card = 'scalar' AND p.deleted_commit IS NULL
-             AND (SELECT COUNT(*) FROM properties p2 WHERE p2.doc_id = ${docAlias}.doc_id AND p2.key = '${key}' AND p2.deleted_commit IS NULL) = 1
-           LIMIT 1)`,
+        sql: propSubquery(docAlias, key, "COALESCE(p.val_text, p.val_num, p.val_bool)"),
         params: [],
         kind: "prop",
+        prop: { docAlias, key },
     };
 }
 // json_extract path from validated segments, or null if any segment is unsafe.
 function jsonExtract(col, segs) {
     if (segs.some((s) => !SEG.test(s)))
         return null;
-    return { sql: `json_extract(${col}, '$.${segs.join(".")}')`, params: [], kind: "json" };
+    const path = `'$.${segs.join(".")}'`;
+    return { sql: `json_extract(${col}, ${path})`, params: [], kind: "json", json: { col, path } };
 }
 // A literal or binding value as a bound `?` with its kind. better-sqlite3 binds
 // only number/string/bigint/buffer/null — booleans are coerced to 1/0 (how
-// json_extract surfaces JSON booleans); anything else (an array binding, say) is
-// not a scalar and declines.
+// json_extract and `val_bool` surface booleans); anything else (an array
+// binding, say) is not a scalar and declines.
 function constOperand(v) {
     switch (typeof v) {
-        case "string": return { sql: "?", params: [v], kind: "text" };
-        case "number": return { sql: "?", params: [v], kind: "num" };
-        case "boolean": return { sql: "?", params: [v ? 1 : 0], kind: "bool" };
-        case "undefined": return { sql: "?", params: [null], kind: "null" };
-        default: return v === null ? { sql: "?", params: [null], kind: "null" } : null;
+        case "string": return { sql: "?", params: [v], kind: "text", value: v };
+        case "number": return { sql: "?", params: [v], kind: "num", value: v };
+        case "boolean": return { sql: "?", params: [v ? 1 : 0], kind: "bool", value: v };
+        case "undefined": return { sql: "?", params: [null], kind: "null", value: null };
+        default: return v === null ? { sql: "?", params: [null], kind: "null", value: null } : null;
     }
 }
 // The dotted `attrs.a.b` / `doc.x` receiver chain as segments, or null if it is
@@ -262,35 +275,49 @@ const IS_OP = {
  * comparison is pushed only when its two operand kinds are provably compared
  * the same way by SQLite and by the in-memory `equals`/`compare`.
  *
- *   Equality (`==`, `!=`) pushes iff
+ *   Equality (`==`, `!=`) pushes PLAINLY (`IS` / `IS NOT`) iff
  *     • one operand is text — SQLite's typed `IS` and strict `===` agree that a
  *       string equals nothing but an equal string (`5 IS '5'` is false);
  *     • or one operand is null and the other is NOT a property read — the same
  *       absence both ways, except that a list-valued or nested property has no
  *       scalar row (SQL NULL) where in memory the value is an array or object;
  *     • or both operands are numeric (int or num) — an exact integer comparison.
- *   Relational (`<`, `<=`, `>`, `>=`) pushes iff both operands are text or both
- *     are numeric.
+ *   Relational (`<`, `<=`, `>`, `>=`) pushes plainly iff both operands are text
+ *     or both are numeric.
+ *   TYPED pushes (the 1.2 patch, `typedComparison`): a bool literal/binding
+ *     against a json or prop read (`==`, `!=` only) and a num literal/binding
+ *     against a json or prop read (every op) push with the stored type tested
+ *     first — `json_type(x) = 'true'`, `json_type(x) IN ('integer','real') AND
+ *     json_extract(x) <op> ?`, `p.type = 'bool' AND p.val_bool = ?`, `p.type =
+ *     'number' AND p.val_num <op> ?` — wrapped `(…) IS 1` (or `IS NOT 1` for
+ *     `!=`), so an absent or differently typed value is unequal and never
+ *     ordered, exactly as in memory.
  *   Every other pair declines: SQLite sees JSON `true` and `1`, `val_bool` and
- *     `val_num` alike (`checked == 1`, `$ordinal == checked`, `verified == 1`),
- *     orders every integer before every text (`$ordinal < "3"`, `level < "x"`,
- *     `$path > 5`), and two JSON or property reads carry no type at plan time
+ *     `val_num` alike (`$ordinal == checked`, `true == 1`), orders every
+ *     integer before every text (`$ordinal < "3"`, `level < "x"`, `$path > 5`),
+ *     and two JSON or property reads carry no type at plan time
  *     (`attrs.a == attrs.b`, `era == stages`).
  *
- * The resulting grid (P = pushed, D = declined; symmetric) for `==` / `!=`:
+ * The resulting grid (P = pushed plainly, T = typed push, D = declined;
+ * symmetric) for `==` / `!=`:
  *
  *            text  int   num   bool  null  json  prop
  *   text      P     P     P     P     P     P     P
  *   int       P     P     P     D     P     D     D
- *   num       P     P     P     D     P     D     D
- *   bool      P     D     D     D     P     D     D
+ *   num       P     P     P     D     P     T     T
+ *   bool      P     D     D     D     P     T     T
  *   null      P     P     P     P     P     P     D
- *   json      P     D     D     D     P     D     D
- *   prop      P     D     D     D     D     D     D
+ *   json      P     D     T     T     P     D     D
+ *   prop      P     D     T     T     D     D     D
  *
- * and for `<` `<=` `>` `>=` only text×text, int×int, int×num, num×num push.
+ * and for `<` `<=` `>` `>=` text×text, int×int, int×num, num×num push plainly
+ * and num×json, num×prop push typed.
  */
 export function comparable(op, a, b) {
+    return plainComparable(op, a, b) || typedPair(op, a, b) !== null;
+}
+// The plain cells of the grid (P): the two operands compare the same way as-is.
+function plainComparable(op, a, b) {
     const numeric = (k) => k === "int" || k === "num";
     const bothNumeric = numeric(a) && numeric(b);
     if (op === "==" || op === "!=") {
@@ -302,6 +329,18 @@ export function comparable(op, a, b) {
     }
     return (a === "text" && b === "text") || bothNumeric;
 }
+// The typed cells of the grid (T): which side is the constant (`"left"` /
+// `"right"`), or null when the pair is not a typed push. A bool constant pushes
+// typed only under `==` / `!=` (booleans never order); a num constant under any op.
+function typedPair(op, a, b) {
+    const read = (k) => k === "json" || k === "prop";
+    const constant = (k) => k === "num" || (k === "bool" && (op === "==" || op === "!="));
+    if (constant(a) && read(b))
+        return "left";
+    if (constant(b) && read(a))
+        return "right";
+    return null;
+}
 /** The complement of `comparable` — kept for readers of the earlier decline-list form. */
 export function declinedPair(a, b, op = "==") {
     return !comparable(op, a, b);
@@ -333,13 +372,63 @@ function translateComparison(e, ctx) {
     const r = translateOperand(e.right, ctx);
     if (!l || !r)
         return null;
-    if (!comparable(e.op, l.kind, r.kind))
+    if (plainComparable(e.op, l.kind, r.kind)) {
+        // `==`/`!=` → null-safe IS / IS NOT (absence-normalized equality, faithful in
+        // any context). Relational ops → plain SQL: a NULL operand yields NULL, which
+        // is excluded in the positive AND context these fragments are pushed into,
+        // matching `relate`'s absent-operand ⇒ false rule.
+        return { sql: `(${l.sql} ${op} ${r.sql})`, params: [...l.params, ...r.params] };
+    }
+    const side = typedPair(e.op, l.kind, r.kind);
+    if (side === null)
         return null; // decline (a): the positive comparison rule
-    // `==`/`!=` → null-safe IS / IS NOT (absence-normalized equality, faithful in
-    // any context). Relational ops → plain SQL: a NULL operand yields NULL, which
-    // is excluded in the positive AND context these fragments are pushed into,
-    // matching `relate`'s absent-operand ⇒ false rule.
-    return { sql: `(${l.sql} ${op} ${r.sql})`, params: [...l.params, ...r.params] };
+    // Normalize to <read> <op> <constant>, flipping a relational op when the
+    // constant is on the left (`800 < era` ⇔ `era > 800`).
+    return side === "right" ? typedComparison(e.op, l, r) : typedComparison(FLIP[e.op] ?? e.op, r, l);
+}
+const FLIP = { "<": ">", "<=": ">=", ">": "<", ">=": "<=" };
+/**
+ * The typed push (spec/surface §1, 1.2 patch): `read <op> constant` where the
+ * read is a JSON or property read and the constant a bool or num literal/binding.
+ * The stored type is tested before the value, and the whole test is wrapped
+ * `(…) IS 1` for `==` and the relational ops, `(…) IS NOT 1` for `!=` — so a
+ * NULL (absent path, no scalar row) or a `0` (other type, unequal value) reads
+ * as "not equal" / "not ordered", which is the in-memory answer: `checked == 1`
+ * finds nothing, `checked != 1` everything, `level >= 2` only numeric levels.
+ *
+ *   json × bool   (json_type(col, path) = 'true'|'false') IS [NOT] 1        no bind: the type string IS the value
+ *   json × num    (json_type(col, path) IN ('integer','real') AND json_extract(col, path) <op> ?) IS [NOT] 1
+ *   prop × bool   (SELECT p.type = 'bool' AND p.val_bool = ? FROM properties p WHERE <scope> LIMIT 1) IS [NOT] 1   ? = 1|0
+ *   prop × num    (SELECT p.type = 'number' AND p.val_num <op> ? FROM properties p WHERE <scope> LIMIT 1) IS [NOT] 1
+ *
+ * where <op> is `=` for both `==` and `!=` (the `!=` case negates the equality
+ * by its `IS NOT 1` wrap) and the relational operator itself otherwise.
+ *
+ * `<scope>` is `propSubquery`'s single-scalar-row condition, so a list-valued or
+ * nested key yields NULL → unequal/unordered, as in memory.
+ */
+function typedComparison(op, read, constant) {
+    // `!=` is `!equals`: the EQUALITY test, wrapped IS NOT 1 (never `<>` inside —
+    // `(type AND val <> ?) IS NOT 1` would drop every row of the right type with a
+    // different value, the differential caught it).
+    const wrap = op === "!=" ? "IS NOT 1" : "IS 1";
+    const cmp = op === "==" || op === "!=" ? "=" : op;
+    if (read.json) {
+        const { col, path } = read.json;
+        if (constant.kind === "bool") {
+            return { sql: `((json_type(${col}, ${path}) = '${constant.value ? "true" : "false"}') ${wrap})`, params: [] };
+        }
+        return {
+            sql: `((json_type(${col}, ${path}) IN ('integer', 'real') AND json_extract(${col}, ${path}) ${cmp} ?) ${wrap})`,
+            params: [...constant.params],
+        };
+    }
+    if (read.prop) {
+        const { docAlias, key } = read.prop;
+        const test = constant.kind === "bool" ? `p.type = 'bool' AND p.val_bool = ?` : `p.type = 'number' AND p.val_num ${cmp} ?`;
+        return { sql: `(${propSubquery(docAlias, key, test)} ${wrap})`, params: [...constant.params] };
+    }
+    return null;
 }
 // startsWith / contains / endsWith — CASE-SENSITIVE, via substr/instr (never
 // LIKE). `matches` (regex) is declined until a `regexp` UDF is registered.

package/dist/src/search/tasks.d.ts

@@ -35,6 +35,15 @@ export declare function makeBlockContextResolver(store: Store, scope: {
  * `shouldEmbed` floor.
  */
 export declare function buildEmbedTasks(store: Store, repoId: string): EmbedTask[];
+/**
+ * The embedding queue depth without a provider process (spec/search §2.3): the
+ * embeddable blocks (`buildEmbedTasks`) whose current `(content_hash, ctx_hash)`
+ * has no cached vector — for `model` when one is named (the `embedding.model`
+ * setting), else for any model. `omg status` reports it as `embedQueue`;
+ * `EmbeddingWorker.staleBlocks` is the same test keyed by the connected
+ * provider's model.
+ */
+export declare function staleEmbedCount(store: Store, repoId: string, model?: string): number;
 /**
  * Build DocEmbedTask[] for every live document in the repo (doc-grain semantic
  * retrieval). Each task carries the whole-document embed input (header +

package/dist/src/search/tasks.js

@@ -1,7 +1,7 @@
 import { reconstructContent } from "../core/read/document.js";
 import { docPropertiesMerged } from "../core/store/properties.js";
 import { LIVE_LEAF_SQL } from "../core/store/fts.js";
-import { contextPrefix, shouldEmbed, estimateTokens } from "./embeddings.js";
+import { contextPrefix, ctxHashHex, shouldEmbed, estimateTokens } from "./embeddings.js";
 function docTitle(titleByDoc, firstHeadingByDoc, docId, path) {
     const t = titleByDoc.get(docId);
     if (t && t.trim())
@@ -85,6 +85,28 @@ export function buildEmbedTasks(store, repoId) {
     }
     return tasks;
 }
+/**
+ * The embedding queue depth without a provider process (spec/search §2.3): the
+ * embeddable blocks (`buildEmbedTasks`) whose current `(content_hash, ctx_hash)`
+ * has no cached vector — for `model` when one is named (the `embedding.model`
+ * setting), else for any model. `omg status` reports it as `embedQueue`;
+ * `EmbeddingWorker.staleBlocks` is the same test keyed by the connected
+ * provider's model.
+ */
+export function staleEmbedCount(store, repoId, model) {
+    const tasks = buildEmbedTasks(store, repoId);
+    const cached = model
+        ? store.db.prepare("SELECT 1 FROM embeddings WHERE content_hash = ? AND ctx_hash = ? AND model = ?")
+        : store.db.prepare("SELECT 1 FROM embeddings WHERE content_hash = ? AND ctx_hash = ?");
+    let stale = 0;
+    for (const t of tasks) {
+        const key = [Buffer.from(t.contentHashHex, "hex"), Buffer.from(ctxHashHex(t.ctx), "hex")];
+        const hit = model ? cached.get(...key, model) : cached.get(...key);
+        if (!hit)
+            stale++;
+    }
+    return stale;
+}
 // The doc-embedding header: a lightweight identifying line prepended to the
 // body so schema-y atomic notes (a two-line canon definition) embed with their
 // title + type/layer context rather than as near-empty bodies. Kept minimal and

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/sync/admin.d.ts

@@ -57,3 +57,16 @@ export interface SyncStatus {
  *   re-ingested — the exact stale-under-green-light failure this guards against.
  */
 export declare function syncStatus(store: Store, repoId: string, rootPath?: string): SyncStatus;
+/** The `repos` tool's result: every repo of the workspace and whether an `fs` source feeds it. */
+export interface ReposList {
+    repos: {
+        slug: string;
+        hasSource: boolean;
+    }[];
+}
+/**
+ * `repos` (spec/surface §4): the workspace's repos by slug, `hasSource` when an
+ * `fs` source is attached. Shared by the MCP tool and `omg repos --json` so the
+ * shape cannot drift; per-repo counts are `reposStatus`.
+ */
+export declare function reposList(store: Store): ReposList;

package/dist/src/sync/admin.js

@@ -50,4 +50,15 @@ export function syncStatus(store, repoId, rootPath) {
         disk: status.disk,
     };
 }
+/**
+ * `repos` (spec/surface §4): the workspace's repos by slug, `hasSource` when an
+ * `fs` source is attached. Shared by the MCP tool and `omg repos --json` so the
+ * shape cannot drift; per-repo counts are `reposStatus`.
+ */
+export function reposList(store) {
+    const rows = store.db
+        .prepare("SELECT r.slug AS slug, MAX(CASE WHEN s.adapter = 'fs' THEN 1 ELSE 0 END) AS has_fs FROM repos r LEFT JOIN attachments a ON a.repo_id = r.repo_id LEFT JOIN sources s ON s.source_id = a.source_id GROUP BY r.repo_id, r.slug ORDER BY r.slug")
+        .all();
+    return { repos: rows.map((r) => ({ slug: r.slug, hasSource: r.has_fs === 1 })) };
+}
 //# sourceMappingURL=admin.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.0",
+  "version": "0.5.0",
   "description": "Open Markdown Graph Base — embedded engine",
   "license": "MIT",
   "repository": {