@omgbase/core 0.21.0 → 0.23.0

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

@@ -9,6 +9,7 @@ import { makeStoreContext, rowRef } from "./context.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";
@@ -91,8 +92,32 @@ export function checkRootSpellings(q) {
         },
     });
 }
+// 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
@@ -347,6 +372,18 @@ function runResolved(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
@@ -417,6 +454,34 @@ function runResolved(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/spec-versions.d.ts

@@ -1,14 +1,14 @@
 export declare const SPEC_VERSIONS: {
-    readonly oqx: "0.23";
+    readonly oqx: "0.24";
     readonly format: "0.2";
     readonly reconcile: "2.3";
-    readonly store: "14.2";
+    readonly store: "15.0";
     readonly properties: "1.1";
     readonly graph: "1.1";
     readonly search: "2.0";
     readonly mutate: "3.5";
     readonly sync: "2.2";
-    readonly surface: "4.7";
-    readonly cli: "4.5";
+    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.2",
+    store: "15.0",
     properties: "1.1",
     graph: "1.1",
     search: "2.0",
     mutate: "3.5",
     sync: "2.2",
-    surface: "4.7",
-    cli: "4.5",
+    surface: "4.9",
+    cli: "4.6",
 };
 //# sourceMappingURL=spec-versions.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omgbase/core",
-  "version": "0.21.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.23.0",
+    "@omgbase/oqx": "^0.24.0",
     "better-sqlite3": "^13.0.3",
     "mdast-util-from-markdown": "^2.0.2",
     "mdast-util-frontmatter": "^2.0.1",