@legioncodeinc/nectar 0.0.1

package/dist/hive-graph/deeplake-heal.js

@@ -0,0 +1,118 @@
+import { buildAddColumnSql, buildCreateTableSql } from "./schema.js";
+import { TransportError } from "./deeplake-transport.js";
+/**
+ * Classify a `query`-kind `TransportError` message as a missing-table failure
+ * (mirrors honeycomb's `classifyFailure`, `src/daemon/storage/heal.ts:77-98`,
+ * missing-table branch only). Auth/permission failures are excluded first so a
+ * message that happens to mention a relation is never misread as a schema gap.
+ */
+export function isMissingTableError(err) {
+    if (err.kind !== "query")
+        return false;
+    if (/permission denied|must be owner|not authorized|forbidden|unauthorized/i.test(err.message)) {
+        return false;
+    }
+    // A missing-COLUMN failure on the live backend also mentions the relation
+    // ('Column does not exist: column "x" of relation "t" does not exist'), so
+    // exclude the column form first or the wrong heal branch (CREATE TABLE)
+    // fires and the ALTER never happens (found by the PRD-018 close-out QA).
+    if (missingColumnName(err) !== null)
+        return false;
+    return /table does not exist|relation ["']?[A-Za-z_][A-Za-z0-9_.]*["']? does not exist|no such table/i.test(err.message);
+}
+/**
+ * Extract the missing-column name from a `query`-kind `TransportError`, or null
+ * when the message is not a missing-column failure. Auth/permission failures are
+ * excluded first (same anti-mask rule as {@link isMissingTableError}) so a
+ * message that happens to mention a column is never misread as a schema gap.
+ * Recognizes the common phrasings across SQL backends (`column "x" does not
+ * exist`, `no such column: x`, `unknown column 'x'`, `undefined column: x`).
+ */
+export function missingColumnName(err) {
+    if (err.kind !== "query")
+        return null;
+    if (/permission denied|must be owner|not authorized|forbidden|unauthorized/i.test(err.message)) {
+        return null;
+    }
+    // Quote matcher: the transport surfaces the backend's raw JSON error body,
+    // so quotes around identifiers arrive JSON-escaped (`\"embed_model\"`).
+    // `Q` tolerates optional backslashes before an optional quote character.
+    const q = String.raw `\\*["'\u0060]?`;
+    const name = "([A-Za-z_][A-Za-z0-9_]*)";
+    const relation = String.raw `[A-Za-z_][A-Za-z0-9_.]*`;
+    const patterns = [
+        // The live Deep Lake backend's INSERT-path form (measured 2026-07-03):
+        // '400: {"error":"Column does not exist: column \"embed_model\" of
+        // relation \"hive_graph_versions\" does not exist", ...}'. Must come
+        // before the plain form and be recognized at all: without it the trailing
+        // 'relation ... does not exist' text matches the missing-TABLE classifier
+        // instead and the heal issues a useless CREATE rather than the ALTER.
+        new RegExp(`column ${q}${name}${q} of relation ${q}${relation}${q} does not exist`, "i"),
+        new RegExp(`column ${q}${name}${q} does not exist`, "i"),
+        new RegExp(`no such column:?\\s*${q}${name}${q}`, "i"),
+        new RegExp(`unknown column ${q}${name}${q}`, "i"),
+        new RegExp(`undefined column:?\\s*${q}${name}${q}`, "i"),
+    ];
+    for (const re of patterns) {
+        const m = re.exec(err.message);
+        if (m !== null && m[1] !== undefined)
+            return m[1];
+    }
+    return null;
+}
+/**
+ * Run a write, healing the two additive schema gaps EXACTLY ONCE each:
+ *   - a missing-table failure -> CREATE the table (IF NOT EXISTS) and retry;
+ *   - a missing-column failure whose column is a nullable additive column in
+ *     `table` -> `ALTER TABLE ADD COLUMN` and retry (PRD-018i / NEC-018).
+ * Any other failure (or a success) returns/throws immediately and unhealed. A
+ * second failure after a heal propagates without a further retry (no loop).
+ *
+ * `runWrite` is the original statement's thunk so the retry re-issues the
+ * identical write.
+ */
+export async function withHeal(transport, table, runWrite) {
+    try {
+        return await runWrite();
+    }
+    catch (err) {
+        if (!(err instanceof TransportError))
+            throw err;
+        if (isMissingTableError(err)) {
+            // Missing table: create it (IF NOT EXISTS makes concurrent heals
+            // converge), then retry the original write exactly once. Any failure from
+            // here on (the create itself, or the retried write) propagates unchanged.
+            await transport.query(buildCreateTableSql(table));
+            return runWrite();
+        }
+        const column = missingColumnName(err);
+        if (column !== null) {
+            const def = table.columns.find((c) => c.name === column);
+            // Only heal a column the current catalog actually defines AND that is a
+            // nullable additive column (NOT NULL columns are part of the CREATE set and
+            // never arrive via ALTER; refusing them keeps a stray message from ALTERing
+            // a bogus column). A future non-additive add must extend this rule.
+            if (def !== undefined && !def.notNull) {
+                // Deep Lake SQL has no `ADD COLUMN IF NOT EXISTS`, so two concurrent
+                // heals can both observe the missing-column failure and both issue the
+                // bare ALTER; the loser's ALTER then fails with a duplicate-column
+                // error even though the column it wanted is now there (CodeRabbit
+                // PR-18 finding #3). Swallow exactly that shape of failure and proceed
+                // to the retry - the column exists, which is all the heal needs - and
+                // let any OTHER ALTER failure (permission, connection, a genuine
+                // schema conflict) propagate unchanged.
+                try {
+                    await transport.query(buildAddColumnSql(table, def));
+                }
+                catch (alterErr) {
+                    const alreadyExists = alterErr instanceof TransportError && /already exists|duplicate column/i.test(alterErr.message);
+                    if (!alreadyExists)
+                        throw alterErr;
+                }
+                return runWrite();
+            }
+        }
+        throw err;
+    }
+}
+//# sourceMappingURL=deeplake-heal.js.map

package/dist/hive-graph/deeplake-heal.js.map

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

package/dist/hive-graph/deeplake-store.d.ts

@@ -0,0 +1,199 @@
+/**
+ * The Deep Lake-backed HiveGraphStore adapter (PRD-005).
+ *
+ * `DeepLakeHiveGraphStore` is the durable substrate for the two hive-graph
+ * tables (`hive_graph`, `hive_graph_versions`), reached over the network
+ * through nectar's own transport (`deeplake-transport.ts`) per ADR-0002 -
+ * never by importing the honeycomb runtime in-process. It is an ADDITIONAL
+ * adapter alongside `InMemoryHiveGraphStore` (`memory-store.ts`), not a
+ * replacement of it: the in-memory store keeps backing the file-registration
+ * ladder's tests and local dev, unchanged.
+ *
+ * `DeepLakeHiveGraphStore implements AsyncHiveGraphStore`
+ * (`store.ts`), not the synchronous `HiveGraphStore`. See the docblock on
+ * `AsyncHiveGraphStore` for why: the ladder's synchronous contract cannot be
+ * honored by a store that does real HTTP I/O, and wiring the ladder to an
+ * async store is a future PRD's decision, not this adapter's.
+ *
+ * All reads are scoped by `org_id`/`workspace_id`/`project_id` wherever the
+ * method receives a `Tenancy` (`listLatestVersions`, `latestVersionByPath`,
+ * `latestVersionByHash`), per PRD-005c's soft-filter contract - the
+ * `project_id` predicate is never omitted from those queries. The four
+ * by-nectar-only methods (`getIdentity`, `touchIdentity`, `nextSeq`,
+ * `latestVersion`) take no `Tenancy` parameter in the `HiveGraphStore` /
+ * `AsyncHiveGraphStore` seam itself - `nectar` is a globally-unique 26-char
+ * ULID (`ulid.ts`) and `InMemoryHiveGraphStore` looks those up by nectar
+ * alone too (no tenancy filter), so this adapter matches that seam exactly
+ * for drop-in-replacement parity rather than inventing extra scoping the
+ * interface does not carry.
+ */
+import type { HiveGraphRow, HiveGraphVersionRow, Tenancy } from "./model.js";
+import type { AsyncHiveGraphStore, LatestVersion } from "./store.js";
+import type { DeepLakeCredentials } from "./deeplake-credentials.js";
+import type { QueryRunner } from "./deeplake-heal.js";
+/** Options for {@link DeepLakeHiveGraphStore}. */
+export interface DeepLakeHiveGraphStoreOptions {
+    /** Loaded via `deeplake-credentials.ts#loadDeepLakeCredentials`. */
+    readonly credentials: DeepLakeCredentials;
+    /** Per-statement timeout override in ms; see `DEFAULT_TRANSPORT_TIMEOUT_MS`. */
+    readonly timeoutMs?: number;
+    /**
+     * TEST-ONLY SEAM: inject a fake `QueryRunner` instead of constructing a
+     * real `HttpDeepLakeTransport` from `credentials`. When absent (the
+     * production path, and the default for every existing caller), the
+     * constructor builds a real `HttpDeepLakeTransport` from `credentials`
+     * exactly as before this option existed. `credentials` is still required
+     * even when `transport` is supplied (a test passes a trivial placeholder
+     * object; nothing in the class reads `credentials` again once the
+     * transport is constructed), which keeps this a strict addition rather
+     * than a change to the required shape of the options object.
+     */
+    readonly transport?: QueryRunner;
+}
+export declare class DeepLakeHiveGraphStore implements AsyncHiveGraphStore {
+    private readonly transport;
+    /**
+     * Per-nectar append serialization (PRD-018g / NEC-011 AC-018g.3). Deep Lake has
+     * no transaction or unique constraint, so `nextSeq` + `appendVersion` as two
+     * statements is a read-then-write race: two concurrent writers can read the
+     * same MAX(seq) and both append `seq+1`. Chaining every seq-allocating append
+     * for a nectar through one promise makes the allocate-and-append pair atomic
+     * within THIS store instance, so no duplicate `(nectar, seq)` is produced by
+     * writers sharing the store.
+     */
+    private readonly seqChains;
+    constructor(options: DeepLakeHiveGraphStoreOptions);
+    /**
+     * Run a READ statement, tolerating a missing-table failure as "no data yet"
+     * (an empty result), exactly like honeycomb's read-path guard
+     * (`tableExists`, `src/daemon/storage/heal.ts:171-175`) fails OPEN rather
+     * than provoking a CREATE. Only the missing-table shape is tolerated; a
+     * genuine connection/timeout/permission/syntax failure still propagates.
+     * Reads never create a table - only a write does, via `withHeal`.
+     */
+    private readTolerant;
+    /**
+     * Insert-only mint, mirroring honeycomb's SELECT-before-INSERT write
+     * pattern (`selectBeforeInsert`, `src/daemon/storage/writes.ts:325-360`)
+     * rather than relying on a Deep Lake UNIQUE constraint: the Deep Lake SQL
+     * surface this adapter targets has no reliably-enforced uniqueness
+     * constraint to lean on, so "does the nectar already exist" is answered by
+     * probing first. Both the probe and the insert are heal-aware (a fresh
+     * tenancy's tables may not exist yet).
+     *
+     * After the insert, a best-effort re-verify SELECT counts the rows for the
+     * nectar; more than one means a race doubled it. Deep Lake offers no
+     * transactions, so this cannot PREVENT a race, only make it observable
+     * (the same limitation honeycomb documents). In practice a real race here
+     * is a near-zero-probability event - a nectar is a 26-char ULID with 80
+     * bits of randomness (`ulid.ts`), not a narrow key space two writers could
+     * plausibly collide on - so a failure of the re-verify SELECT itself
+     * (e.g. a transient network hiccup immediately after a successful insert)
+     * does not fail the whole call; the insert already succeeded and the
+     * re-verify is an observability nicety, not the source of truth.
+     */
+    insertIdentity(row: HiveGraphRow): Promise<void>;
+    getIdentity(nectar: string): Promise<HiveGraphRow | undefined>;
+    /**
+     * Bump `last_update_date` via an in-place `UPDATE`.
+     *
+     * KNOWN CAVEAT: honeycomb's own operational history found that an in-place
+     * `UPDATE ... WHERE id = ...` does not reliably land on this backend under
+     * load - a by-id point read can still return a pre-update snapshot from a
+     * stale segment (see honeycomb `src/daemon/storage/catalog/tenancy.ts:475-489`,
+     * where the equivalent revoke-by-UPDATE was RETIRED in favor of an
+     * append-only version-bump for that reason). `hive_graph`'s catalog entry
+     * (`schema.ts`) nonetheless declares `writePattern: "update-or-insert"` for
+     * this exact field, and `last_update_date` is a low-stakes denormalized
+     * "last observed change" timestamp (not an authorization-bearing flag like
+     * the retired revoke), so this adapter uses `UPDATE` as declared rather than
+     * inventing an append-based scheme the schema does not define. If
+     * `last_update_date` staleness proves to be a real problem in practice, a
+     * future PRD should revisit this the same way honeycomb did - not this
+     * adapter, which mirrors the declared write pattern faithfully.
+     */
+    touchIdentity(nectar: string, lastUpdateDate: string): Promise<void>;
+    appendVersion(row: HiveGraphVersionRow): Promise<void>;
+    /**
+     * Allocate the next monotonic seq for `row.nectar` and append `row` at it,
+     * atomically with respect to other seq-allocating appends for the SAME nectar
+     * through this store (PRD-018g AC-018g.3). Returns the seq actually written.
+     * `row.seq` is ignored; the store owns seq allocation here so the caller never
+     * hand-computes a colliding value. Non-seq appends (`appendVersion`) that a
+     * caller has already sequenced are unaffected.
+     */
+    appendVersionAtNextSeq(row: HiveGraphVersionRow): Promise<number>;
+    private allocateAndAppend;
+    /**
+     * The next monotonic seq for a nectar: MAX(seq)+1 over every version row,
+     * computed client-side by {@link reduceLatestVersion} rather than trusted
+     * to an SQL `ORDER BY`/`LIMIT`/`MAX()` clause. See that function's docblock
+     * for why.
+     */
+    nextSeq(nectar: string): Promise<number>;
+    /** The latest (MAX seq) version row for a nectar; see {@link reduceLatestVersion}. */
+    latestVersion(nectar: string): Promise<HiveGraphVersionRow | undefined>;
+    /**
+     * Every nectar's latest version, scoped by the full tenancy predicate
+     * (`org_id`/`workspace_id`/`project_id`, PRD-005c). Fetches every identity
+     * and every version row for the tenancy and reduces to "latest per nectar"
+     * in application code, mirroring `InMemoryHiveGraphStore.listLatestVersions`'s
+     * iterate-and-reduce shape rather than pushing a `GROUP BY`/window-function
+     * reduction into SQL. This is not optimized for a very large per-tenant
+     * row count; a future PRD could push the "latest per nectar" reduction into
+     * SQL if that becomes the bottleneck. It is not this adapter's job to
+     * diverge from the reference in-memory implementation's behavior to chase
+     * that optimization prematurely.
+     */
+    listLatestVersions(tenancy: Tenancy): Promise<LatestVersion[]>;
+    /**
+     * Every nectar's latest DESCRIBED version, scoped by the full tenancy
+     * predicate (PRD-011c's projection scan). Mirrors {@link listLatestVersions}'s
+     * two-SELECT-then-reduce-in-application-code shape, but reduces each nectar's
+     * version group with {@link reduceLatestDescribedVersion} and omits nectars
+     * that have no described version. The projection builder overlays this onto
+     * {@link listLatestVersions} so a minted-but-undescribed nectar still keeps a
+     * minimal entry.
+     */
+    listLatestDescribedVersions(tenancy: Tenancy): Promise<LatestVersion[]>;
+    latestVersionByPath(tenancy: Tenancy, path: string): Promise<LatestVersion | undefined>;
+    latestVersionByHash(tenancy: Tenancy, contentHash: string): Promise<LatestVersion | undefined>;
+    /**
+     * By-path / by-hash lookup with predicate pushdown (NEC-042 item 8 /
+     * AC-018l.15). The pre-fix path called {@link listLatestVersions}, which
+     * scans the ENTIRE tenancy (all identities + all version rows) per probe -
+     * O(all rows) on what becomes a per-file-event hot path. Instead:
+     *
+     *   1. push the column predicate down (`WHERE path = ...` / `WHERE
+     *      content_hash = ...`) to find only the candidate nectars that ever
+     *      carried the value;
+     *   2. fetch the full history for JUST those candidates and reduce
+     *      latest-per-nectar client-side with the shared {@link reduceLatestVersion}
+     *      MAX(seq) helper (the client-side reduction is kept, not trusted to an
+     *      SQL ORDER BY, matching the rest of this adapter);
+     *   3. return the nectar whose LATEST version satisfies the predicate, which
+     *      preserves the reference `listLatestVersions().find` semantics (a nectar
+     *      renamed AWAY from the path is not a false positive).
+     */
+    private latestVersionByColumn;
+    /**
+     * Delete a nectar (identity + versions) scoped to `tenancy`, the SOLE deletion
+     * path (`prune --confirm`, PRD-006d). Both DELETE statements carry the full
+     * tenancy predicate (`org_id`/`workspace_id`/`project_id`, never omitting
+     * `project_id`) alongside the nectar key, so a nectar minted under another
+     * project is never removed by a delete issued in this tenancy (AC-20).
+     *
+     * The delete path deliberately does NOT go through `withHeal`: a missing table
+     * means there is nothing to delete, so it is a harmless no-op, NOT a reason to
+     * CREATE a fresh (empty) table. `deleteTolerant` therefore swallows only the
+     * missing-table transport error (via `isMissingTableError`, the same
+     * classification the read path uses) and lets every other failure propagate.
+     */
+    deleteNectar(tenancy: Tenancy, nectar: string): Promise<void>;
+    /**
+     * Run a DELETE, tolerating a missing-table failure as "nothing to delete" (a
+     * no-op). Never creates a table. Any other transport failure propagates.
+     */
+    private deleteTolerant;
+}
+//# sourceMappingURL=deeplake-store.d.ts.map

package/dist/hive-graph/deeplake-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deeplake-store.d.ts","sourceRoot":"","sources":["../../src/hive-graph/deeplake-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,KAAK,EAAkB,YAAY,EAAE,mBAAmB,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE7F,OAAO,KAAK,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAErE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAGrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAOtD,kDAAkD;AAClD,MAAM,WAAW,6BAA6B;IAC5C,oEAAoE;IACpE,QAAQ,CAAC,WAAW,EAAE,mBAAmB,CAAC;IAC1C,gFAAgF;IAChF,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,WAAW,CAAC;CAClC;AAgND,qBAAa,sBAAuB,YAAW,mBAAmB;IAChE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAc;IACxC;;;;;;;;OAQG;IACH,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAuC;gBAErD,OAAO,EAAE,6BAA6B;IAYlD;;;;;;;OAOG;YACW,YAAY;IAS1B;;;;;;;;;;;;;;;;;;;OAmBG;IACG,cAAc,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBhD,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC;IAMpE;;;;;;;;;;;;;;;;;OAiBG;IACG,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAOpE,aAAa,CAAC,GAAG,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAK5D;;;;;;;OAOG;IACG,sBAAsB,CAAC,GAAG,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC;YA6BzD,iBAAiB;IAM/B;;;;;OAKG;IACG,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAY9C,sFAAsF;IAChF,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC;IAM7E;;;;;;;;;;;OAWG;IACG,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IA8BpE;;;;;;;;OAQG;IACG,2BAA2B,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IA2BvE,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC;IAIvF,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC;IAIpG;;;;;;;;;;;;;;;;OAgBG;YACW,qBAAqB;IAqCnC;;;;;;;;;;;;OAYG;IACG,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAWnE;;;OAGG;YACW,cAAc;CAQ7B"}