@tenonhq/dovetail-core 0.0.104 → 0.0.106

package/dist/tests/reconcileBaseline.test.js

@@ -0,0 +1,103 @@
+"use strict";
+// Tests for the reconcile baseline: defensive read (degrades to null, never
+// throws), write round-trip, the pure dirty-check, and live-snapshot capture.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const baseline_1 = require("../reconcile/baseline");
+const live = (sys_id, updatedOn) => ({
+    table: "sys_script",
+    scope: "x_cadso_core",
+    name: sys_id,
+    sys_id,
+    updatedOn,
+    fields: {},
+});
+function tmpRoot() {
+    return fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dove-reconcile-base-"));
+}
+describe("readBaseline — defensive", () => {
+    it("returns null when the file is absent", () => {
+        expect((0, baseline_1.readBaseline)(tmpRoot(), "tenonworkstudio")).toBeNull();
+    });
+    it("returns null on malformed JSON", () => {
+        const root = tmpRoot();
+        fs_1.default.writeFileSync(path_1.default.join(root, baseline_1.BASELINE_FILENAME), "{not json");
+        expect((0, baseline_1.readBaseline)(root, "tenonworkstudio")).toBeNull();
+    });
+    it("returns null on wrong version or non-string record map", () => {
+        const root = tmpRoot();
+        fs_1.default.writeFileSync(path_1.default.join(root, baseline_1.BASELINE_FILENAME), JSON.stringify({ version: 2, instance: "x", records: {} }));
+        expect((0, baseline_1.readBaseline)(root, "x")).toBeNull();
+        const root2 = tmpRoot();
+        fs_1.default.writeFileSync(path_1.default.join(root2, baseline_1.BASELINE_FILENAME), JSON.stringify({ version: 1, instance: "x", records: { a: 5 } }));
+        expect((0, baseline_1.readBaseline)(root2, "x")).toBeNull();
+    });
+    it("returns null when the baseline was captured against another instance", () => {
+        const root = tmpRoot();
+        (0, baseline_1.writeBaseline)(root, {
+            version: 1,
+            instance: "tenonworkshop",
+            records: { a: "t" },
+        });
+        expect((0, baseline_1.readBaseline)(root, "tenonworkstudio")).toBeNull();
+    });
+    it("round-trips a valid baseline", () => {
+        const root = tmpRoot();
+        (0, baseline_1.writeBaseline)(root, {
+            version: 1,
+            instance: "tenonworkstudio",
+            records: { a: "2026-06-01 00:00:00" },
+        });
+        const got = (0, baseline_1.readBaseline)(root, "tenonworkstudio");
+        expect(got).not.toBeNull();
+        expect(got.records.a).toBe("2026-06-01 00:00:00");
+    });
+});
+describe("baselineFromLive + baselineSysIds", () => {
+    it("captures sys_id -> updatedOn from the live set", () => {
+        const base = (0, baseline_1.baselineFromLive)("tenonworkstudio", [
+            live("a", "t1"),
+            live("b", "t2"),
+        ]);
+        expect(base.records).toEqual({ a: "t1", b: "t2" });
+        expect(base.instance).toBe("tenonworkstudio");
+    });
+    it("baselineSysIds is null for a null baseline and a Set otherwise", () => {
+        expect((0, baseline_1.baselineSysIds)(null)).toBeNull();
+        const set = (0, baseline_1.baselineSysIds)({ version: 1, instance: "x", records: { a: "t" } });
+        expect(set).not.toBeNull();
+        expect(set.has("a")).toBe(true);
+    });
+});
+describe("computeDirty", () => {
+    it("returns [] with no baseline", () => {
+        expect((0, baseline_1.computeDirty)({ baseline: null, live: [live("a", "t2")] })).toEqual([]);
+    });
+    it("flags a baseline record whose live updatedOn moved", () => {
+        const dirty = (0, baseline_1.computeDirty)({
+            baseline: { version: 1, instance: "x", records: { a: "t1", b: "t1" } },
+            live: [live("a", "t2"), live("b", "t1")],
+        });
+        expect(dirty).toHaveLength(1);
+        expect(dirty[0]).toMatchObject({ sys_id: "a", reason: "changed-since-baseline" });
+    });
+    it("does not flag records absent from the baseline (those are deletes/creates, not drift)", () => {
+        const dirty = (0, baseline_1.computeDirty)({
+            baseline: { version: 1, instance: "x", records: {} },
+            live: [live("new", "t9")],
+        });
+        expect(dirty).toEqual([]);
+    });
+    it("ignores empty timestamps rather than false-flagging", () => {
+        const dirty = (0, baseline_1.computeDirty)({
+            baseline: { version: 1, instance: "x", records: { a: "" } },
+            live: [live("a", "t2")],
+        });
+        expect(dirty).toEqual([]);
+    });
+});

package/dist/tests/reconcileFields.test.js

@@ -0,0 +1,24 @@
+"use strict";
+// Tests for the field-comparison rules: metaData is excluded from the content
+// diff; everything else is a comparable field with a stable "<name>.<type>" key.
+Object.defineProperty(exports, "__esModule", { value: true });
+const fields_1 = require("../reconcile/fields");
+describe("isComparableField", () => {
+    it("excludes the metaData.json bookkeeping file", () => {
+        expect((0, fields_1.isComparableField)({ name: "metaData", type: "json" })).toBe(false);
+    });
+    it("includes a real field file", () => {
+        expect((0, fields_1.isComparableField)({ name: "script", type: "js" })).toBe(true);
+    });
+    it("includes a json field that is not metaData", () => {
+        expect((0, fields_1.isComparableField)({ name: "composition", type: "json" })).toBe(true);
+    });
+    it("includes a field that happens to be named metaData but is not json", () => {
+        expect((0, fields_1.isComparableField)({ name: "metaData", type: "txt" })).toBe(true);
+    });
+});
+describe("fieldKey", () => {
+    it("joins name and type", () => {
+        expect((0, fields_1.fieldKey)({ name: "script", type: "js" })).toBe("script.js");
+    });
+});

package/dist/tests/reconcileGitignore.test.js

@@ -0,0 +1,51 @@
+"use strict";
+// Tests for the gitignore-ensure compute step plus the I/O wrapper.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const gitignore_1 = require("../reconcile/gitignore");
+const ENTRY = ".dove-reconcile-baseline.json";
+describe("hasGitignoreEntry", () => {
+    it("detects a present entry ignoring surrounding whitespace", () => {
+        expect((0, gitignore_1.hasGitignoreEntry)("node_modules\n" + ENTRY + "\n", ENTRY)).toBe(true);
+        expect((0, gitignore_1.hasGitignoreEntry)("  " + ENTRY + "  \n", ENTRY)).toBe(true);
+    });
+    it("does not match a commented line", () => {
+        expect((0, gitignore_1.hasGitignoreEntry)("# " + ENTRY + "\n", ENTRY)).toBe(false);
+    });
+    it("returns false when absent", () => {
+        expect((0, gitignore_1.hasGitignoreEntry)("node_modules\n", ENTRY)).toBe(false);
+    });
+});
+describe("ensureEntryContent", () => {
+    it("creates content when the file does not exist", () => {
+        const out = (0, gitignore_1.ensureEntryContent)(null, ENTRY);
+        expect(out.changed).toBe(true);
+        expect(out.content).toBe(ENTRY + "\n");
+    });
+    it("appends with a separating newline when the file lacks a trailing one", () => {
+        const out = (0, gitignore_1.ensureEntryContent)("node_modules", ENTRY);
+        expect(out.changed).toBe(true);
+        expect(out.content).toBe("node_modules\n" + ENTRY + "\n");
+    });
+    it("is a no-op when the entry is already present", () => {
+        const existing = "node_modules\n" + ENTRY + "\n";
+        const out = (0, gitignore_1.ensureEntryContent)(existing, ENTRY);
+        expect(out.changed).toBe(false);
+        expect(out.content).toBe(existing);
+    });
+});
+describe("ensureGitignored — I/O", () => {
+    it("creates .gitignore with the entry, then is idempotent", () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dove-gitignore-"));
+        const first = (0, gitignore_1.ensureGitignored)(root, ENTRY);
+        expect(first.changed).toBe(true);
+        expect(fs_1.default.readFileSync(path_1.default.join(root, ".gitignore"), "utf8")).toContain(ENTRY);
+        const second = (0, gitignore_1.ensureGitignored)(root, ENTRY);
+        expect(second.changed).toBe(false);
+    });
+});

package/dist/tests/reconcileMultiPass.test.js

@@ -0,0 +1,74 @@
+"use strict";
+// Tests for the generic multi-pass op loop: clean ops, emergent ordering (a
+// record blocked until its dependency resolves), a genuine failure surviving a
+// no-progress pass, and thrown-error handling. Exercised for both delete
+// ordering (children before parents) and create ordering (parents before
+// children).
+Object.defineProperty(exports, "__esModule", { value: true });
+const multiPass_1 = require("../reconcile/multiPass");
+const rec = (sys_id, kind) => ({
+    kind,
+    table: "sys_script",
+    scope: "x_cadso_core",
+    sys_id,
+    name: sys_id,
+    fieldDeltas: [],
+});
+describe("runMultiPassOps", () => {
+    it("completes everything in a single clean pass", async () => {
+        const calls = [];
+        const exec = async (c) => {
+            calls.push(c.sys_id);
+            return { ok: true };
+        };
+        const out = await (0, multiPass_1.runMultiPassOps)([rec("a", "delete"), rec("b", "delete")], exec);
+        expect(out.every((o) => o.ok)).toBe(true);
+        expect(calls.sort()).toEqual(["a", "b"]);
+    });
+    it("resolves DELETE ordering: parent succeeds only after child is gone", async () => {
+        const deleted = new Set();
+        const exec = async (c) => {
+            if (c.sys_id === "parent" && !deleted.has("child")) {
+                return { ok: false, error: "still referenced by child" };
+            }
+            deleted.add(c.sys_id);
+            return { ok: true };
+        };
+        const out = await (0, multiPass_1.runMultiPassOps)([rec("parent", "delete"), rec("child", "delete")], exec);
+        expect(out.every((o) => o.ok)).toBe(true);
+    });
+    it("resolves CREATE ordering: child succeeds only after parent exists", async () => {
+        const created = new Set();
+        const exec = async (c) => {
+            if (c.sys_id === "child" && !created.has("parent")) {
+                return { ok: false, error: "parent does not exist yet" };
+            }
+            created.add(c.sys_id);
+            return { ok: true };
+        };
+        // child attempted first, fails, then succeeds on the pass after parent.
+        const out = await (0, multiPass_1.runMultiPassOps)([rec("child", "create"), rec("parent", "create")], exec);
+        expect(out.every((o) => o.ok)).toBe(true);
+        expect(created.has("child")).toBe(true);
+    });
+    it("reports a record that fails for a non-ordering reason", async () => {
+        const exec = async (c) => c.sys_id === "locked" ? { ok: false, error: "ACL blocked" } : { ok: true };
+        const out = await (0, multiPass_1.runMultiPassOps)([rec("ok", "delete"), rec("locked", "delete")], exec);
+        const failed = out.filter((o) => !o.ok);
+        expect(failed).toHaveLength(1);
+        expect(failed[0].change.sys_id).toBe("locked");
+        expect(failed[0].error).toBe("ACL blocked");
+    });
+    it("treats a thrown executor error as a failure", async () => {
+        const exec = async () => {
+            throw new Error("network down");
+        };
+        const out = await (0, multiPass_1.runMultiPassOps)([rec("a", "create")], exec);
+        expect(out[0].ok).toBe(false);
+        expect(out[0].error).toBe("network down");
+    });
+    it("returns [] for no changes", async () => {
+        const out = await (0, multiPass_1.runMultiPassOps)([], async () => ({ ok: true }));
+        expect(out).toEqual([]);
+    });
+});

package/dist/tests/reconcileRecordDiff.test.js

@@ -0,0 +1,125 @@
+"use strict";
+// Tests for the pure reconcile record-diff engine — CRUD classification by
+// sys_id, field-level deltas, and delete disambiguation against the baseline.
+Object.defineProperty(exports, "__esModule", { value: true });
+const recordDiff_1 = require("../reconcile/recordDiff");
+const rec = (over) => ({
+    table: "sys_script_include",
+    scope: "x_cadso_core",
+    name: over.sys_id,
+    updatedOn: "2026-06-01 00:00:00",
+    fields: { "script.js": "var a = 1;" },
+    ...over,
+});
+describe("diffRecords — classification", () => {
+    it("marks a branch-only record as create", () => {
+        const diff = (0, recordDiff_1.diffRecords)({
+            branch: [rec({ sys_id: "a" })],
+            live: [],
+            baselineSysIds: new Set(),
+        });
+        expect(diff.creates.map((c) => c.sys_id)).toEqual(["a"]);
+        expect(diff.updates).toHaveLength(0);
+        expect(diff.deletes).toHaveLength(0);
+    });
+    it("marks identical records as unchanged (not update)", () => {
+        const diff = (0, recordDiff_1.diffRecords)({
+            branch: [rec({ sys_id: "a", fields: { "script.js": "X" } })],
+            live: [rec({ sys_id: "a", fields: { "script.js": "X" } })],
+            baselineSysIds: new Set(["a"]),
+        });
+        expect(diff.unchangedCount).toBe(1);
+        expect(diff.updates).toHaveLength(0);
+        expect(diff.creates).toHaveLength(0);
+        expect(diff.deletes).toHaveLength(0);
+    });
+    it("marks a content difference as update with a changed field delta", () => {
+        const diff = (0, recordDiff_1.diffRecords)({
+            branch: [rec({ sys_id: "a", fields: { "script.js": "NEW" } })],
+            live: [rec({ sys_id: "a", fields: { "script.js": "OLD" } })],
+            baselineSysIds: new Set(["a"]),
+        });
+        expect(diff.updates).toHaveLength(1);
+        const deltas = diff.updates[0].fieldDeltas;
+        expect(deltas).toHaveLength(1);
+        expect(deltas[0]).toMatchObject({
+            field: "script.js",
+            onBranch: true,
+            onLive: true,
+            changed: true,
+        });
+    });
+    it("reports a field present only on the branch and only on the instance", () => {
+        const diff = (0, recordDiff_1.diffRecords)({
+            branch: [rec({ sys_id: "a", fields: { "script.js": "X", "extra.js": "Y" } })],
+            live: [rec({ sys_id: "a", fields: { "script.js": "X", "old.js": "Z" } })],
+            baselineSysIds: new Set(["a"]),
+        });
+        const deltas = diff.updates[0].fieldDeltas;
+        const byField = Object.fromEntries(deltas.map((d) => [d.field, d]));
+        expect(byField["extra.js"]).toMatchObject({ onBranch: true, onLive: false, changed: false });
+        expect(byField["old.js"]).toMatchObject({ onBranch: false, onLive: true, changed: false });
+        // unchanged shared field is not emitted
+        expect(byField["script.js"]).toBeUndefined();
+    });
+});
+describe("diffRecords — delete disambiguation", () => {
+    it("marks an instance-only record in the baseline as a tracked delete", () => {
+        const diff = (0, recordDiff_1.diffRecords)({
+            branch: [],
+            live: [rec({ sys_id: "gone" })],
+            baselineSysIds: new Set(["gone"]),
+        });
+        expect(diff.deletes).toHaveLength(1);
+        expect(diff.deletes[0].deleteDisposition).toBe("tracked");
+    });
+    it("marks an instance-only record absent from the baseline as local-new (drift)", () => {
+        const diff = (0, recordDiff_1.diffRecords)({
+            branch: [],
+            live: [rec({ sys_id: "mine" })],
+            baselineSysIds: new Set(["other"]),
+        });
+        expect(diff.deletes[0].deleteDisposition).toBe("local-new");
+    });
+    it("marks every instance-only record no-baseline when no baseline exists", () => {
+        const diff = (0, recordDiff_1.diffRecords)({
+            branch: [],
+            live: [rec({ sys_id: "x" }), rec({ sys_id: "y" })],
+            baselineSysIds: null,
+        });
+        expect(diff.deletes.map((d) => d.deleteDisposition)).toEqual([
+            "no-baseline",
+            "no-baseline",
+        ]);
+    });
+});
+describe("diffRecords — ordering & convergence", () => {
+    it("sorts each bucket by table then name", () => {
+        const diff = (0, recordDiff_1.diffRecords)({
+            branch: [
+                rec({ sys_id: "2", table: "sys_script", name: "b" }),
+                rec({ sys_id: "1", table: "sys_script", name: "a" }),
+                rec({ sys_id: "3", table: "sys_script_include", name: "a" }),
+            ],
+            live: [],
+            baselineSysIds: new Set(),
+        });
+        expect(diff.creates.map((c) => c.table + "/" + c.name)).toEqual([
+            "sys_script/a",
+            "sys_script/b",
+            "sys_script_include/a",
+        ]);
+    });
+    it("an already-converged instance produces an empty diff (idempotent)", () => {
+        const records = [rec({ sys_id: "a" }), rec({ sys_id: "b" })];
+        const diff = (0, recordDiff_1.diffRecords)({
+            branch: records,
+            live: records,
+            baselineSysIds: new Set(["a", "b"]),
+        });
+        expect(diff.creates).toHaveLength(0);
+        expect(diff.updates).toHaveLength(0);
+        expect(diff.deletes).toHaveLength(0);
+        expect(diff.unchangedCount).toBe(2);
+    });
+});

package/dist/tests/reconcileReport.test.js

@@ -0,0 +1,136 @@
+"use strict";
+// Tests for the pure reconcile report renderer — convergence message, drift
+// banner, instance deep-links, delete partitioning, and the report-only schema
+// section.
+Object.defineProperty(exports, "__esModule", { value: true });
+const report_1 = require("../reconcile/report");
+const emptyDiff = () => ({
+    creates: [],
+    updates: [],
+    deletes: [],
+    unchangedCount: 0,
+});
+const change = (over) => ({
+    table: "sys_script_include",
+    scope: "x_cadso_core",
+    name: over.sys_id,
+    fieldDeltas: [],
+    ...over,
+});
+const scope = (over) => ({
+    scope: "x_cadso_core",
+    diff: emptyDiff(),
+    dirty: [],
+    hasBaseline: true,
+    schema: null,
+    ...over,
+});
+describe("formatReconcileReport", () => {
+    it("reports an in-sync scope and a zeroed summary", () => {
+        const out = (0, report_1.formatReconcileReport)({
+            instanceHost: "tenonworkstudio",
+            branchRef: "main",
+            scopes: [scope({ diff: { ...emptyDiff(), unchangedCount: 12 } })],
+            schemaSkippedReason: null,
+        });
+        expect(out).toContain("in sync (12 records match the instance)");
+        expect(out).toContain("Summary: 0 create, 0 update, 0 delete");
+    });
+    it("renders create/update/delete rows with instance deep links", () => {
+        const diff = {
+            creates: [change({ sys_id: "c1", kind: "create", name: "NewThing" })],
+            updates: [
+                change({
+                    sys_id: "u1",
+                    kind: "update",
+                    name: "Edited",
+                    fieldDeltas: [{ field: "script.js", onBranch: true, onLive: true, changed: true }],
+                }),
+            ],
+            deletes: [change({ sys_id: "d1", kind: "delete", name: "Gone", deleteDisposition: "tracked" })],
+            unchangedCount: 0,
+        };
+        const out = (0, report_1.formatReconcileReport)({
+            instanceHost: "tenonworkstudio",
+            branchRef: "feat/x",
+            scopes: [scope({ diff })],
+            schemaSkippedReason: null,
+        });
+        expect(out).toContain("CREATE (1):");
+        expect(out).toContain("UPDATE (1):");
+        expect(out).toContain("DELETE (1):");
+        expect(out).toContain("https://tenonworkstudio.service-now.com/sys_script_include.do?sys_id=c1");
+        expect(out).toContain("- script.js (changed)");
+        expect(out).toContain("Summary: 1 create, 1 update, 1 delete");
+    });
+    it("keeps local-new instance-only records out of DELETE and never proposes deleting them", () => {
+        const diff = {
+            ...emptyDiff(),
+            deletes: [change({ sys_id: "mine", kind: "delete", name: "DevMade", deleteDisposition: "local-new" })],
+        };
+        const out = (0, report_1.formatReconcileReport)({
+            instanceHost: "tenonworkstudio",
+            branchRef: "main",
+            scopes: [scope({ diff })],
+            schemaSkippedReason: null,
+        });
+        expect(out).toContain("INSTANCE-ONLY");
+        expect(out).not.toContain("DELETE (");
+        expect(out).toContain("Summary: 0 create, 0 update, 0 delete, 1 instance-only kept");
+    });
+    it("surfaces drift and warns that apply would refuse", () => {
+        const out = (0, report_1.formatReconcileReport)({
+            instanceHost: "tenonworkstudio",
+            branchRef: "main",
+            scopes: [
+                scope({
+                    dirty: [
+                        { sys_id: "x", table: "sys_script", name: "Touched", reason: "changed-since-baseline" },
+                    ],
+                }),
+            ],
+            schemaSkippedReason: null,
+        });
+        expect(out).toContain("DRIFT — instance changed since baseline");
+        expect(out).toContain("Apply would REFUSE: 1 record(s) changed on the instance since baseline");
+    });
+    it("warns when no baseline exists for the scope", () => {
+        const out = (0, report_1.formatReconcileReport)({
+            instanceHost: "tenonworkstudio",
+            branchRef: "main",
+            scopes: [scope({ hasBaseline: false })],
+            schemaSkippedReason: null,
+        });
+        expect(out).toContain("no baseline for this instance");
+    });
+    it("renders schema deltas as report-only with dictionary links", () => {
+        const schemaDiff = {
+            instance: "tenonworkstudio",
+            from: { ref: "snap", generated_at: "" },
+            to: { ref: "live", generated_at: "" },
+            scope: "x_cadso_core",
+            summary: { breaking: 1, warn: 0, info: 0 },
+            tables: [],
+            fields: [{ table: "x_cadso_thing", field: "old_col", change: "removed", severity: "BREAKING" }],
+            exit_code: 1,
+        };
+        const out = (0, report_1.formatReconcileReport)({
+            instanceHost: "tenonworkstudio",
+            branchRef: "main",
+            scopes: [scope({ schema: schemaDiff })],
+            schemaSkippedReason: null,
+        });
+        expect(out).toContain("SCHEMA — report-only");
+        expect(out).toContain("removed x_cadso_thing.old_col");
+        expect(out).toContain("sys_dictionary_list.do?sysparm_query=name=x_cadso_thing^element=old_col");
+    });
+    it("notes when the schema arm was skipped", () => {
+        const out = (0, report_1.formatReconcileReport)({
+            instanceHost: "tenonworkstudio",
+            branchRef: "main",
+            scopes: [scope({})],
+            schemaSkippedReason: "no snapshot found",
+        });
+        expect(out).toContain("Schema diff skipped: no snapshot found");
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tenonhq/dovetail-core",
-  "version": "0.0.104",
+  "version": "0.0.106",
   "description": "Next-gen file syncer",
   "license": "GPL-3.0",
   "main": "./dist/index.js",