@vibe-agent-toolkit/cli 0.2.0-rc.1 → 0.2.0-rc.11

package/dist/utils/projection-query.js

@@ -0,0 +1,357 @@
+/**
+ * Populating a tree's resource projection and putting it somewhere ASKABLE —
+ * the shared half of every command that runs SQL over it.
+ *
+ * `vat resources query` runs one statement a person typed; `vat resources check`
+ * runs the statements a project wrote down. They differ in what they do with
+ * rows and in nothing else: same population, same store selection, same
+ * ephemeral fallback, same cache tell. This module is that "and in nothing
+ * else", stated once so the two cannot drift into answering about different
+ * corpora.
+ *
+ * ## 🚨 The SQL ALWAYS runs against a per-run in-memory database. Never the store.
+ *
+ * This is a correctness property, not an optimisation choice, and it was learned
+ * the expensive way. The on-disk projection store is **one database per VAT
+ * release, shared by every root on the machine** (`defaultStoreDirectory()` is
+ * `tmpdir/.vat-cache/<version>/projection-<shapeDigest>`), it retains three tree
+ * hashes per root, and its blob tier is never evicted and carries no tree key at
+ * all. `ProjectionStore.readExtent` narrows by `(rootId, treeHash)`; **arbitrary
+ * SQL does not**, and cannot be made to — a `WHERE` clause the caller wrote is
+ * not a key predicate.
+ *
+ * So running a user's statement against the file-backed store answered from
+ * every projection on the machine. Measured on a two-file scratch repository:
+ * `SELECT COUNT(*) FROM resource_realizations` returned **3** with no store and
+ * **5,779** with one, and `WHERE path LIKE 'packages/%'` returned paths from a
+ * different repository entirely. That is a wrong answer and a cross-project
+ * disclosure of link text, heading text and frontmatter — the same material
+ * `store.ts` cites as the reason it chmods the cache `0o700`.
+ *
+ * ⇒ The store's job is to make the POPULATION cheap, and that is all. Whatever
+ * `populate()` returns — served from the store or derived — is written into a
+ * fresh in-memory database that holds this tree and nothing else, and the SQL
+ * runs there. The saving is untouched (it was always in the population: on this
+ * repository {@link ProjectionProvenance.populationMs} reads 1.16-1.18 s derived
+ * against 0.29-0.31 s served), and "one tree, one answer" stops being a claim
+ * about how callers behave and becomes a property of the shape.
+ *
+ * ## The store never reaches a caller
+ *
+ * Work runs against an `ask` closure rather than a store handle. That is
+ * deliberate: `utils/projection-store.ts` is the one module in the toolkit that
+ * knows `@vibe-agent-toolkit/projection-sqlite` exists, and handing commands a
+ * backend-typed object would spread that knowledge to every future verb. A
+ * closure also puts the legible-failure wrapper on the single path that can
+ * throw, so no command can forget it.
+ */
+import { performance } from 'node:perf_hooks';
+import { allDerivedSpecs, buildResourceProjection, PROJECTION_TABLES, splitProjectionByScope, } from '@vibe-agent-toolkit/resources';
+import { gitTrackerForProjectRoot } from '../commands/audit/distributed-tree.js';
+import { populationWiring } from './population-wiring.js';
+import { evaluateLens, lensesNamedBy } from './projection-lenses.js';
+import { openCompileProbe, openEphemeralQueryStore, withPopulationCache } from './projection-store.js';
+/**
+ * The tree hash an in-memory store's one population is filed under.
+ *
+ * ⚠️ Deliberately NOT a tree hash. Nothing else ever opens this database, no
+ * read-back compares the key against another run's, and the store is gone at the
+ * end of the call — so the key only has to be internally consistent. A real
+ * `git write-tree` here would cost a spawn to produce a value nobody reads, and
+ * would invite the reader to believe the ephemeral store is shareable.
+ */
+const EPHEMERAL_TREE_HASH = 'ephemeral';
+/** What SQLite says when a statement names a table the schema does not have. */
+const TABLE_NOT_FOUND = 'no such table:';
+/** What SQLite says when a statement names something the schema does not have. */
+const NAME_NOT_FOUND = [TABLE_NOT_FOUND, 'no such column:'];
+/**
+ * Compile every statement a run intends to ask, against the schema and NO rows,
+ * before anything is populated.
+ *
+ * ## 🔑 What this buys, measured
+ *
+ * SQLite resolves table and column names when a statement is *prepared*, not
+ * when it is stepped — so a typo is knowable before a single row exists. It was
+ * not knowable in practice, because the only place a statement met the schema
+ * was after the projection had been built. On a real adopter tree, `SELECT path,
+ * no_such_column …` cost **8.3 s**, every millisecond of it spent building a
+ * projection the statement could never have read. The same typo now costs the
+ * price of an empty in-memory database — one extra `createSchema` into
+ * `:memory:`, which is the whole overhead this adds on the happy path.
+ *
+ * It also moves the KIND refusals — a second statement, an `ATTACH`, a `PRAGMA`
+ * — in front of the population, so a statement rejected for what it is costs no
+ * more than one rejected for what it names.
+ *
+ * ⚠️ **This is a pre-flight, not a second gate.** `ask` still compiles and runs
+ * the real statement against the real projection, and nothing here is trusted in
+ * place of that. A statement that compiles here can still fail there — SQLite
+ * resolves names against a schema, and this is the same schema, but a run-time
+ * error (a bad cast, an overflow) belongs to stepping and is unreachable from a
+ * prepare.
+ *
+ * ⚠️ It deliberately does not STEP anything. Stepping is where a check's
+ * unbounded cost lives, and a preflight that ran `WITH RECURSIVE …` would hang
+ * before the run it exists to make cheap had begun.
+ *
+ * ⚠️ Each statement comes WITH the values it will be bound to, because the
+ * placeholder count is part of what compiles: a `?` the caller forgot to bind is
+ * SQL NULL at run time, and the statement then selects nothing and reports
+ * success — the same silent class as a typo'd column, and worth the same early
+ * refusal. The backend does the counting; this only has to hand it the values.
+ *
+ * @param statements - Every statement the run will ask, in any order, each with
+ *   the values it will bind
+ * @throws The same legible failure `ask` throws, for the first statement that
+ *   does not compile or does not pair its placeholders with its values
+ */
+export async function assertQueriesCompile(statements) {
+    if (statements.length === 0)
+        return;
+    // 🔑 A compile PROBE, not the query store: this runs before any lens is
+    // evaluated, and the query store has no table for an unevaluated relation.
+    // The probe carries every derived relation and cannot answer a query, so its
+    // empty tables can never be read as a result.
+    const probe = await openCompileProbe();
+    try {
+        for (const { sql, parameters } of statements) {
+            try {
+                probe.assertCompiles(sql, parameters);
+            }
+            catch (error) {
+                throw new Error(describeQueryFailure(sql, error instanceof Error ? error.message : String(error)));
+            }
+        }
+    }
+    finally {
+        await probe.close();
+    }
+}
+/**
+ * Populate the tree, load it into something askable, and hand the caller a way
+ * to ask.
+ *
+ * @param options - The run
+ * @param options.root - Absolute corpus root
+ * @param options.logger - Where blob-stage refusals are reported (stderr, so a
+ *   parseable document on stdout stays parseable)
+ * @param options.preflight - Every statement this run intends to ask, compiled
+ *   against the empty schema BEFORE the population starts. See
+ *   {@link assertQueriesCompile}
+ * @param options.statements - Every statement this run may ask, for LENS
+ *   SELECTION only — never compiled, never bound, and deliberately separate from
+ *   `preflight`. ⛔ Omitting it evaluates EVERY lens, which is the correct answer
+ *   and the expensive one
+ * @param work - Given the asker, where its rows came from, how much of the tree
+ *   they cover, and the ROWS THEMSELVES. The store is open for exactly this call
+ *   and closed however it ends
+ * @returns Whatever `work` returned
+ */
+export async function withQueriedProjection(options, work) {
+    const { root, logger } = options;
+    // 🔑 BEFORE the clock and before the population, because being before the
+    // population is the entire point — see {@link assertQueriesCompile}. It is an
+    // option rather than a step each verb remembers for the same reason everything
+    // else here is shared: a verb that forgot it would silently go back to paying
+    // a full population to learn about a typo, and nothing in its output would say
+    // so.
+    await assertQueriesCompile(options.preflight ?? []);
+    // 🚨 OUTSIDE `withPopulationCache`, and it must stay outside. That helper
+    // awaits `openPopulationCache` — a `git write-tree` spawn plus the backend's
+    // dynamic import and `openSqliteProjectionStore()` — BEFORE it invokes the
+    // callback below, and it pays that cost ONLY when a store is selected. A clock
+    // started inside the callback therefore drops the store's own setup out of the
+    // measurement on precisely the arm the number is used to praise. See
+    // `populationMs` for what that shipped as.
+    //
+    // What is NOT in the span, deliberately: `withPopulationCache`'s `finally`,
+    // which closes the opened cache AFTER `work` returns. A span that ends before
+    // `work` begins cannot contain it, and stretching the span past `work` would
+    // fold the caller's statements into a number whose entire purpose is to be
+    // read against them. The close is a handle release on an already-open
+    // database, not population.
+    let contributorRecords = 0;
+    const populationStart = performance.now();
+    // The file-backed store, when one is selected, and ONLY as a population cache.
+    // Its rows are never queried — see the header.
+    return withPopulationCache({ root }, async (cache) => {
+        // The cache tell. `populate()` short-circuits a hit before any contributor
+        // is constructed, so this staying at zero is the ONLY observable difference
+        // between a served population and a re-derived one. Declared with the clock
+        // above rather than here so the two cannot drift apart when one moves.
+        const gitTracker = await gitTrackerForProjectRoot(root);
+        const projection = await buildResourceProjection({
+            root,
+            ...populationWiring(logger, gitTracker, cache, root),
+            onContributorTiming: () => {
+                contributorRecords += 1;
+            },
+        });
+        // ONE tree, in a database nothing else can reach, built fresh for this call.
+        const store = await openEphemeralQueryStore();
+        try {
+            // The key is read OFF the projection rather than re-derived from the root.
+            // The driver mints `roots.id` with `rootIdFor` and every
+            // `resolution_contexts.rootId` is a foreign key into it, so taking it from
+            // the rows means the key provably describes them — a second derivation
+            // could drift from the first and file rows under an id they do not carry.
+            const rootId = projection.roots[0]?.id;
+            if (rootId === undefined) {
+                throw new Error('The population produced no root row, so there is no id to file its extent under.'
+                    + ' This is a driver invariant rather than a user error — `populate()` adds exactly'
+                    + ' one, and a projection without it cannot be stored or queried.');
+            }
+            const { blobs, extent } = splitProjectionByScope(projection);
+            await store.writeBlobFacts(blobs);
+            await store.writeExtent({ rootId, treeHash: EPHEMERAL_TREE_HASH }, extent);
+            // 🚨 The population clock STOPS HERE, before the lens runs. It used to
+            // stop after, which made `populationSecs` silently CONTAIN `lensSecs`
+            // while this comment and both payloads said it did not. The two numbers
+            // are published side by side precisely so a reader can compare a served
+            // population against a derived one — and folding the lens into the
+            // population put its cost on the arm the store's value is argued from,
+            // which is the "store got worse" reading the separation exists to
+            // prevent. Overlapping spans also made `populationSecs + lensSecs`
+            // over-count wall time for anyone who added them.
+            const populationMs = performance.now() - populationStart;
+            // 🔑 The lenses this run's statements NAME, and no others — zones.md §2
+            // carries why. The relations are still not behind a flag: a surface that
+            // exists only when somebody remembered a flag is one nobody writes a check
+            // against. What decides is the statement, which cannot be forgotten.
+            //
+            // ⛔ The narrowing is safe ONLY because an unevaluated relation does not
+            // EXIST in `store`: the backend creates a derived table on the write that
+            // fills it, so a statement naming one no lens filled fails `no such table`
+            // in SQLite itself — whatever spelling slipped past the selector's scan —
+            // and {@link describeQueryFailure} says why. Create the relations up front
+            // and this becomes a silent wrong answer: an empty table selecting zero rows.
+            const lenses = lensesNamedBy(options.statements);
+            const lensStart = performance.now();
+            for (const lens of lenses) {
+                // Sequential, not `Promise.all`: a lens may populate, and two
+                // populations racing for one projection store is the concurrency this
+                // lane has no reason to invite.
+                await store.writeDerived(await evaluateLens(lens, { projection, root, logger, cache }));
+            }
+            const lensMs = performance.now() - lensStart;
+            // The shared setup is done. Everything after this line is the caller's.
+            const ask = (sql, ...parameters) => {
+                try {
+                    return store.query(sql, ...parameters);
+                }
+                catch (error) {
+                    throw new Error(describeQueryFailure(sql, error instanceof Error ? error.message : String(error)));
+                }
+            };
+            return await work(ask, {
+                population: contributorRecords === 0 ? 'store' : 'derived',
+                populationMs,
+                lensMs,
+                lensesEvaluated: lenses.map((lens) => lens.name),
+            }, 
+            // Read off the PROJECTION rather than counted back out of the store with
+            // a `SELECT COUNT(*)`: a count that travelled through the same `ask` the
+            // caller's statements do would be broken by the very schema drift it
+            // exists to survive, and it is the population's size either way.
+            { membersEnumerated: projection.resourceRealizations.length }, projection);
+        }
+        finally {
+            // Closed however the work ends. An in-memory database is reclaimed with the
+            // process either way, but a command that runs several of these in one
+            // process would otherwise hold every one of them open.
+            await store.close();
+        }
+    });
+}
+/**
+ * The derived relation a `no such table` failure names, if it names one.
+ *
+ * SQLite echoes the reference as written — `edges`, `EDGES`, `main.edges` — so
+ * the schema prefix is dropped and the comparison case-folds, as SQLite's own
+ * name resolution does. Names come from the relation registry, never a list
+ * kept here.
+ *
+ * @param message - What the engine said
+ * @returns The relation's registry spelling, or undefined
+ */
+function unevaluatedRelationIn(message) {
+    const at = message.indexOf(TABLE_NOT_FOUND);
+    if (at === -1)
+        return undefined;
+    const reference = message.slice(at + TABLE_NOT_FOUND.length).trim().split(/\s/u)[0] ?? '';
+    const bare = reference.slice(reference.lastIndexOf('.') + 1).toLowerCase();
+    return allDerivedSpecs().find((spec) => spec.name.toLowerCase() === bare)?.name;
+}
+/**
+ * Turn a rejected statement into a message that names the surface it missed.
+ *
+ * ## Why this wrapper exists
+ *
+ * VAT ships no schema version, by standing rule — the *cache* is safe across a
+ * shape change because its digest self-invalidates, but submitted SQL is not: it
+ * simply breaks. Pre-1.0 that is acceptable. A raw SQLite error reaching the
+ * user is not, because `no such column: contentHash` says nothing about what the
+ * column is called now. It matters more for a CHECK than for a query: a query's
+ * author is at the keyboard, while a check's author wrote it months ago and the
+ * person reading the failure is someone else.
+ *
+ * ⚠️ **A legibility wrapper, not a validator.** It does not parse SQL and does
+ * not check a statement before running it — it reacts to a failure by listing
+ * what the query COULD have named. When the statement mentions a known table,
+ * that table's columns are listed, which is the case that actually answers "what
+ * moved"; otherwise the table names are, which at least answers "what is there".
+ *
+ * 🪤 **Only a name that was not found gets the listing.** The engine also refuses
+ * a write and this backend refuses a second statement, and neither is answered by
+ * a column list — appending one says the problem is the schema when the problem
+ * is what the caller asked for. A wrapper that decorates every failure identically
+ * teaches the reader to skip the decoration, which costs the case it was written for.
+ *
+ * Matching is a plain lowercase substring test rather than a regex: the input is
+ * user text, and a pattern built from it is both a lint failure here and a
+ * needless hazard.
+ *
+ * @param sql - The statement that was submitted
+ * @param message - What the engine said
+ * @returns The message to surface, with the queryable surface appended when the
+ *   failure was a name this projection does not have
+ */
+export function describeQueryFailure(sql, message) {
+    if (!NAME_NOT_FOUND.some((prefix) => message.includes(prefix)))
+        return message;
+    // 🚨 A MISSING DERIVED RELATION IS NOT A TYPO — it is the refusal that makes
+    // lazy lens evaluation an optimisation. The run's database creates a derived
+    // relation only when a lens fills it, so one no lens was evaluated for is
+    // absent, and SQLite refuses it rather than answering `0` from an empty table
+    // (indistinguishable from a tree with no links, and for `vat resources check`
+    // a rule that could no longer fail). The refusal is the engine's, so it holds
+    // for any spelling the lens selector's scan missed; this only says why. For
+    // `check` it surfaces as a `RESOURCE_CHECK_BROKEN` finding naming the rule.
+    // The compile preflight never reaches here with one: its probe has them all.
+    const unevaluated = unevaluatedRelationIn(message);
+    if (unevaluated !== undefined) {
+        return `${message}\n\n`
+            + `This statement reads ${unevaluated}, a derived relation that was not evaluated for this run:`
+            + ' no statement the run DECLARED names it, so no lens producing it ran and there is no answer'
+            + ' to give. Declare this statement (`vat resources query` passes the one it was given;'
+            + ' `vat resources check` passes every statement in `resources.checks`).';
+    }
+    // 🪤 The derived relations belong in this listing even though they are not
+    // projection tables. A user who mistypes `edge_resolution` gets "no such
+    // table" and a list of everything they could have meant — and a list that
+    // omitted the very relation they were reaching for would read as proof it
+    // does not exist. What the listing answers is "what can I name here", which
+    // is the queryable surface, not the registry.
+    const askable = [...Object.values(PROJECTION_TABLES), ...allDerivedSpecs()];
+    const lowered = sql.toLowerCase();
+    const named = askable.filter((spec) => lowered.includes(spec.name.toLowerCase()));
+    const surface = named.length > 0
+        ? named.map((spec) => `  ${spec.name}(${spec.columns.join(', ')})`).join('\n')
+        : askable.map((spec) => `  ${spec.name}`).join('\n');
+    const heading = named.length > 0
+        ? 'The tables this statement names hold these columns:'
+        : 'This tree is queryable through these relations:';
+    return `${message}\n\n${heading}\n${surface}`;
+}
+//# sourceMappingURL=projection-query.js.map

package/dist/utils/projection-query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"projection-query.js","sourceRoot":"","sources":["../../src/utils/projection-query.ts"],"names":[],"mappings":"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"}