@omgbase/core 0.19.0 → 0.23.0

package/dist/src/oqx-js/run.js

@@ -6,8 +6,10 @@
 // in-tree compiler, so every caller and the corpus are unchanged.
 import { parse, PlannedEngine, InMemoryEngine, OqxError, resolveAliases, transform, visit, build, semantics } from "@omgbase/oqx";
 import { makeStoreContext, rowRef } from "./context.js";
-import { SQLiteQueryPlanner, rootTarget } from "./planner.js";
-import { REPO_REMOVED_MESSAGE, TARGETS, bareTargetMessage, pastRootMessage, unknownTargetMessage } from "./root-row.js";
+import { SQLiteQueryPlanner } from "./planner.js";
+import { REPO_REMOVED_MESSAGE, ROOTS, bareTargetMessage, pastRootMessage, unknownTargetMessage } from "./root-row.js";
+import { checkNames } from "./names.js";
+import { DATE_FUNCTIONS, DATE_METHODS, dateFunction, dateMethod } from "./dates.js";
 import { FilterInvalid } from "../search/cel/parser.js";
 import { float32ToBlob } from "../core/vec.js";
 import { encodeCursor as encodeKeyset, decodePathCursor } from "../core/cursor.js";
@@ -72,8 +74,8 @@ export function rootPathLiterals(e) {
 export function checkRootSpellings(q) {
     // A top-level `from <name>` that is no collection (`from edges`, the links
     // target's name before 3.0) would scan an absent root and come back empty:
-    // refused, naming the four collections (root-row.ts).
-    if (q.source.kind === "ident" && !TARGETS.has(q.source.name))
+    // refused, naming the five collections (root-row.ts).
+    if (q.source.kind === "ident" && !ROOTS.has(q.source.name))
         throw new FilterInvalid(unknownTargetMessage(q.source.name), "OQX");
     visit(q, {
         enter(node, ctx) {
@@ -84,14 +86,38 @@ export function checkRootSpellings(q) {
             if (node.kind === "ident" && ctx.depth >= 1 && (node.name === "docs" || node.name === "links")) {
                 throw new FilterInvalid(bareTargetMessage(node.name, ctx.depth), "OQX");
             }
-            if (node.kind === "outer" && TARGETS.has(node.name) && node.levels > ctx.depth) {
+            if (node.kind === "outer" && ROOTS.has(node.name) && node.levels > ctx.depth) {
                 throw new FilterInvalid(pastRootMessage(node.name, node.levels), "OQX");
             }
         },
     });
 }
+// Dates over literals fold to literals (spec/surface §1.3 "Dates and
+// durations", 4.8): `date("today")`, `dur("30 days")`, and a date method whose
+// receiver and arguments are literals (`date("today").minus(dur("30 days"))`,
+// folded inside-out since `transform` maps children first) become the string /
+// number / null they evaluate to — by the SAME functions the context runs, so
+// nothing changes in meaning — before the planner sees the tree. So `where
+// updated_at < date("today")` is a text-vs-text comparison the translator
+// pushes down (a call is otherwise an unconditional decline), and a named point
+// is resolved ONCE per query. A call with the wrong arity is left in place: it
+// raises when evaluated, and an empty source never evaluates it (spec/oqx §11).
+const isLit = (e) => e.kind === "lit";
+export function foldDates(e) {
+    if (e.kind !== "call" || !e.args.every(isLit))
+        return e;
+    const args = e.args.map((a) => a.value);
+    if (e.recv === null) {
+        if (!Object.hasOwn(DATE_FUNCTIONS, e.name) || DATE_FUNCTIONS[e.name] !== args.length)
+            return e;
+        return build.lit(dateFunction(e.name, args).value);
+    }
+    if (!isLit(e.recv) || !Object.hasOwn(DATE_METHODS, e.name) || DATE_METHODS[e.name] !== args.length)
+        return e;
+    return build.lit(dateMethod(e.name, e.recv.value, args).value);
+}
 function rewriteQuery(q) {
-    return transform(q, (e) => (e.kind === "call" && e.recv === null && ROW_FNS.has(e.name) ? { ...e, recv: build.ident("$self") } : rootPathLiterals(e)));
+    return transform(q, (e) => (e.kind === "call" && e.recv === null && ROW_FNS.has(e.name) ? { ...e, recv: build.ident("$self") } : foldDates(rootPathLiterals(e))));
 }
 // A top-level `limit`/`offset` on the collect path is applied by the runner (see
 // oqxRunInner), so it must be a plain number literal here — there is no row to
@@ -165,8 +191,9 @@ function envelopeCollision(items) {
     return null;
 }
 // A hit is a store row (spec/surface §1.4, 1.5). The engine's top-level rows
-// are store rows by construction when the source is a bare root scan and
-// nothing re-projects them; a `follow` destination (`follow before` over a
+// are store rows by construction when the source is a bare root scan (one of
+// the five collections, `revisions` included — the planner's `rootTarget` is
+// narrower: the four it can plan) and nothing re-projects them; a `follow` destination (`follow before` over a
 // frontmatter list of paths), a `from E` re-projection or any other source can
 // reach a scalar, which the injected `id`/`path` reads would render as the
 // junk hit `{ id: "undefined", path: "" }`. For those queries the row itself is
@@ -177,7 +204,7 @@ function envelopeCollision(items) {
 const SELF_KEY = "__oqx_self";
 const SELF_ITEM = build.field(SELF_KEY, build.ident("$it"));
 function mayReachNonRows(q) {
-    return q.follow !== null || q.from.length > 0 || rootTarget(q.source) === null;
+    return q.follow !== null || q.from.length > 0 || !(q.source.kind === "ident" && ROOTS.has(q.source.name));
 }
 function describeValue(v) {
     if (v === null || v === undefined)
@@ -195,7 +222,7 @@ function describeValue(v) {
     return "an object";
 }
 function notAStoreRow(v) {
-    return new FilterInvalid(`a hit must be a document, block, node or link row — the query reached ${describeValue(v)}; to follow document references held in a property use refs(<field>)`, "OQX");
+    return new FilterInvalid(`a hit must be a document, block, node, link or revision row — the query reached ${describeValue(v)}; to follow document references held in a property use refs(<field>)`, "OQX");
 }
 // The reserved key a top-level `values` projection's single item is renamed to,
 // so it rides through id/path injection, keyset paging, and distinct as an
@@ -294,19 +321,36 @@ function oqxRunInner(store, repoId, source, opts) {
     const reserved = reservedAlias(raw.select);
     if (reserved)
         throw reserved;
-    return oqxRunQuery(store, repoId, raw, opts);
+    // The source entry is every read: a tier-3 name on an open kind is a hint.
+    return oqxRunQuery(store, repoId, raw, { unknownNames: "hint", ...opts });
 }
 /**
  * The AST entry (4.1): run an already parsed query — the source path above
  * after `parse`, and the selector compiler (`mutate/select.ts`), which appends
  * its slot items to the RAW tree so a user alias a template reads is inlined
  * by the alias resolution here. Errors are the library's own (`OqxError`);
- * `oqxRun` normalizes them, a caller of this entry does the same.
+ * `oqxRun` normalizes them, a caller of this entry does the same. Unknown
+ * names (4.6) default to `"refuse"` here: this entry's caller is the write
+ * selector, where a name no row carries would select every row; the source
+ * entry passes `"hint"`.
  */
 export function oqxRunQuery(store, repoId, raw, opts = {}) {
+    checkRootSpellings(raw);
+    // Unknown names (spec/surface §1.5): judged over the RAW tree — before alias
+    // resolution and the runner's own items — so an alias is never mistaken for
+    // a row property and the verdict never depends on the rows. The selector
+    // compiler's slot items (`__omg_sel_*`, the templates' expressions) are not
+    // the selector: an expression reading an absent property there is
+    // spec/mutate's `target_missing` / absent value, not an unknown name.
+    const own = { ...raw, select: raw.select.filter((it) => !RESERVED_ALIAS_PREFIXES.some((p) => it.name.startsWith(p))) };
+    const hints = checkNames(store, repoId, own, opts.unknownNames ?? "refuse");
+    const result = runResolved(store, repoId, raw, opts);
+    // `hints` is the last member, present only when there is something to say.
+    return hints.length === 0 ? result : { ...result, hints };
+}
+function runResolved(store, repoId, raw, opts) {
     // The query's `select` aliases are resolved HERE, once, before the runner
     // renames/injects items (an engine evaluates the query it is given).
-    checkRootSpellings(raw);
     const parsed = rewriteQuery(resolveAliases(raw));
     const consumer = parsed.consumer;
     const ctxOpts = opts.semanticVectors ? { semanticVectors: opts.semanticVectors } : {};
@@ -328,6 +372,18 @@ export function oqxRunQuery(store, repoId, raw, opts = {}) {
         const res = engine.run(parsed, []);
         return { hits: [], truncated: false, cursor: null, consumer: "none", none: res.consumer === "none" ? res.none : true };
     }
+    // A grouped query (oqx 0.24, SEMANTICS §24) yields GROUPS, not store rows:
+    // the envelope does not apply — there is no `id`/`path` to inject and no
+    // keyset to page by — so a hit is the group's projection as the query wrote
+    // it (`{ layer, n }`), exactly what `bare` yields for a row query; `bare` is
+    // accepted and changes nothing. Rows that surface as values (`rows collect {
+    // }` with an empty projection, `collect(doc)`) render as `{ id, path }` refs
+    // like every row-as-value. Paging is by position: the query's own
+    // `limit`/`offset` define the set, the tool's `limit` takes the first page,
+    // `truncated` says whether more groups follow, the cursor is always null (as
+    // under a custom `order by`). `distinct` cannot occur (a parse error).
+    if (parsed.groupBy)
+        return runGrouped(engine, parsed, consumer, opts);
     // collect / first / single: inject id + path so every hit carries them. A
     // top-level `select distinct` is applied HERE, not in the engine: the injected
     // id/path are unique per row and would defeat the engine's projection dedup, so
@@ -398,6 +454,34 @@ export function oqxRunQuery(store, repoId, raw, opts = {}) {
         return { hits: [], truncated, cursor, consumer: "collect", values: page.map((s) => s.proj[VALUE_KEY]) };
     return { hits: page.map(render), truncated, cursor, consumer: "collect" };
 }
+// The collect/first/single path of a grouped query (see `runResolved`).
+function runGrouped(engine, parsed, consumer, opts) {
+    const topValues = parsed.values;
+    // A `values` projection rides as a record under VALUE_KEY and is peeled off
+    // the page, as on the row path.
+    const select = topValues ? [{ ...parsed.select[0], name: VALUE_KEY }] : parsed.select;
+    const { limit: topLimit, offset: topOffset } = parsed;
+    const base = consumer === "collect" ? { ...parsed, limit: null, offset: null } : parsed;
+    const res = engine.run({ ...base, values: false, select }, []);
+    const project = (row) => renderValue(row);
+    if (consumer === "first" || consumer === "single") {
+        const row = res.consumer === "first" || res.consumer === "single" ? res.row : null;
+        if (topValues)
+            return { hits: [], truncated: false, cursor: null, consumer, values: row == null ? [] : [project(row)[VALUE_KEY]] };
+        return { hits: row == null ? [] : [project(row)], truncated: false, cursor: null, consumer };
+    }
+    let groups = (res.consumer === "collect" ? res.rows : []).map(project);
+    const offset = constBound(topOffset, "offset") ?? 0;
+    const limit = constBound(topLimit, "limit");
+    if (offset || limit != null)
+        groups = groups.slice(offset, limit == null ? undefined : offset + limit);
+    const cap = opts.limit ?? 50;
+    const truncated = groups.length > cap;
+    const page = groups.slice(0, cap);
+    if (topValues)
+        return { hits: [], truncated, cursor: null, consumer: "collect", values: page.map((g) => g[VALUE_KEY]) };
+    return { hits: page, truncated, cursor: null, consumer: "collect" };
+}
 export async function oqxRunAsync(store, repoId, source, opts = {}, embedQuery) {
     const phrases = collectSemanticPhrases(source);
     if (phrases.length === 0)

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

@@ -53,7 +53,7 @@ import { TARGETS } from "../root-row.js";
  * `translate.test.ts` asserts this set against the store context.
  */
 export const NON_PROPERTY_NAMES = {
-    docs: new Set(["doc", "nodes", "blocks", "out_links", "in_links", "data", "frontmatter", "inline"]),
+    docs: new Set(["doc", "nodes", "blocks", "out_links", "in_links", "revisions", "data", "frontmatter", "inline"]),
     blocks: new Set(["block", "doc", "children", "nodes", "out_links", "section", "attrs"]),
     nodes: new Set(["section", "doc", "block", "blocks", "subsections", "children", "attrs"]),
     links: new Set(["doc", "dst"]),

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

@@ -1,14 +1,14 @@
 export declare const SPEC_VERSIONS: {
-    readonly oqx: "0.21";
+    readonly oqx: "0.24";
     readonly format: "0.2";
     readonly reconcile: "2.3";
-    readonly store: "14.1";
+    readonly store: "15.0";
     readonly properties: "1.1";
     readonly graph: "1.1";
     readonly search: "2.0";
-    readonly mutate: "3.3";
+    readonly mutate: "3.5";
     readonly sync: "2.2";
-    readonly surface: "4.4";
-    readonly cli: "4.3";
+    readonly surface: "4.9";
+    readonly cli: "4.6";
 };
 export type SpecName = keyof typeof SPEC_VERSIONS;

package/dist/src/spec-versions.js

@@ -13,13 +13,13 @@ export const SPEC_VERSIONS = {
     oqx: LANGUAGE_VERSION,
     format: "0.2",
     reconcile: "2.3",
-    store: "14.1",
+    store: "15.0",
     properties: "1.1",
     graph: "1.1",
     search: "2.0",
-    mutate: "3.3",
+    mutate: "3.5",
     sync: "2.2",
-    surface: "4.4",
-    cli: "4.3",
+    surface: "4.9",
+    cli: "4.6",
 };
 //# sourceMappingURL=spec-versions.js.map

package/dist/src/sync/observe.js

@@ -189,9 +189,15 @@ function commitPrepared(store, repoId, prepared, ts, oldHashHex, newHashHex) {
     const conflicted = hasConflictMarkers(content);
     const resolveIds = makeReconcilingResolver(store, repoId, { ts, path, prepared });
     const res = ingestFile(store, repoId, path, content, { ts, origin: "observed", resolveIds, parsed: prepared.tree, conflicted });
-    const rows = store.db
-        .prepare("SELECT kind, count(*) n FROM dispositions WHERE commit_id = ? GROUP BY kind ORDER BY kind")
-        .all(res.commitId);
+    // The outcome counts every verdict the matcher produced, `same` included —
+    // it describes what the matcher saw; the `dispositions` table describes
+    // what changed (spec/store §5.4 step 10, 14.2: `same` is not persisted), so
+    // the counts come from the in-memory result, not the table. Kinds in
+    // bytewise order, as the table query listed them through 14.1.
+    const counts = new Map();
+    for (const d of prepared.result.dispositions)
+        counts.set(d.kind, (counts.get(d.kind) ?? 0) + 1);
+    const rows = [...counts].map(([kind, n]) => ({ kind, n })).sort((a, b) => (a.kind < b.kind ? -1 : a.kind > b.kind ? 1 : 0));
     return {
         docId: res.docId,
         path,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omgbase/core",
-  "version": "0.19.0",
+  "version": "0.23.0",
   "description": "Open Markdown Graph Base — embedded engine",
   "license": "MIT",
   "repository": {
@@ -55,7 +55,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "@omgbase/oqx": "^0.21.0",
+    "@omgbase/oqx": "^0.24.0",
     "better-sqlite3": "^13.0.3",
     "mdast-util-from-markdown": "^2.0.2",
     "mdast-util-frontmatter": "^2.0.1",