@tenonhq/dovetail-core 0.0.105 → 0.0.107

package/dist/tests/updateSetConfig.test.js

@@ -0,0 +1,126 @@
+"use strict";
+/**
+ * TenonHQ/Dovetail#182: readUpdateSetConfig / writeUpdateSetRouting
+ *
+ * The push-routing file (.dove-update-sets.json) is the source of truth for
+ * `dove push`. These tests pin the read/merge/write contract that keeps it in
+ * sync with createUpdateSet / switchUpdateSet.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var mockFsStore = {};
+jest.mock("fs", function () {
+    return {
+        existsSync: jest.fn(function (p) {
+            return p in mockFsStore;
+        }),
+        readFileSync: jest.fn(function (p) {
+            if (p in mockFsStore)
+                return mockFsStore[p];
+            throw new Error("ENOENT: " + p);
+        }),
+        writeFileSync: jest.fn(function (p, data) {
+            mockFsStore[p] = data;
+        }),
+    };
+});
+var CONFIG_PATH = "/repo/.dove-update-sets.json";
+jest.mock("../projectFiles", function () {
+    return {
+        getUpdateSetsConfigPath: jest.fn(function () {
+            return CONFIG_PATH;
+        }),
+    };
+});
+jest.mock("../Logger", function () {
+    return {
+        logger: {
+            info: jest.fn(),
+            error: jest.fn(),
+            warn: jest.fn(),
+            debug: jest.fn(),
+            success: jest.fn(),
+        },
+    };
+});
+const updateSetConfig_1 = require("../updateSetConfig");
+const Logger_1 = require("../Logger");
+describe("updateSetConfig", function () {
+    beforeEach(function () {
+        for (var k in mockFsStore)
+            delete mockFsStore[k];
+        jest.clearAllMocks();
+    });
+    describe("readUpdateSetConfig", function () {
+        test("returns {} when the file is absent", function () {
+            expect((0, updateSetConfig_1.readUpdateSetConfig)()).toEqual({});
+        });
+        test("parses an existing routing file", function () {
+            mockFsStore[CONFIG_PATH] = JSON.stringify({
+                x_cadso_core: { sys_id: "abc", name: "Set A" },
+            });
+            expect((0, updateSetConfig_1.readUpdateSetConfig)()).toEqual({
+                x_cadso_core: { sys_id: "abc", name: "Set A" },
+            });
+        });
+        test("returns {} and warns on unparseable JSON", function () {
+            mockFsStore[CONFIG_PATH] = "{ not json";
+            expect((0, updateSetConfig_1.readUpdateSetConfig)()).toEqual({});
+            expect(Logger_1.logger.warn).toHaveBeenCalled();
+        });
+        test("returns {} and warns when the file is a non-object (array)", function () {
+            mockFsStore[CONFIG_PATH] = JSON.stringify(["nope"]);
+            expect((0, updateSetConfig_1.readUpdateSetConfig)()).toEqual({});
+            expect(Logger_1.logger.warn).toHaveBeenCalled();
+        });
+    });
+    describe("writeUpdateSetRouting", function () {
+        test("writes a fresh routing entry and returns the path", function () {
+            var written = (0, updateSetConfig_1.writeUpdateSetRouting)({
+                scope: "x_cadso_core",
+                sysId: "new123",
+                name: "New Set",
+            });
+            expect(written).toBe(CONFIG_PATH);
+            expect(JSON.parse(mockFsStore[CONFIG_PATH])).toEqual({
+                x_cadso_core: { sys_id: "new123", name: "New Set" },
+            });
+        });
+        test("merges without clobbering other scopes", function () {
+            mockFsStore[CONFIG_PATH] = JSON.stringify({
+                x_cadso_automate: { sys_id: "keep", name: "Keep Me" },
+            });
+            (0, updateSetConfig_1.writeUpdateSetRouting)({
+                scope: "x_cadso_core",
+                sysId: "new123",
+                name: "New Set",
+            });
+            expect(JSON.parse(mockFsStore[CONFIG_PATH])).toEqual({
+                x_cadso_automate: { sys_id: "keep", name: "Keep Me" },
+                x_cadso_core: { sys_id: "new123", name: "New Set" },
+            });
+        });
+        test("overwrites the same scope's stale entry", function () {
+            mockFsStore[CONFIG_PATH] = JSON.stringify({
+                x_cadso_core: { sys_id: "old", name: "Old Set" },
+            });
+            (0, updateSetConfig_1.writeUpdateSetRouting)({
+                scope: "x_cadso_core",
+                sysId: "fresh",
+                name: "Fresh Set",
+            });
+            expect(JSON.parse(mockFsStore[CONFIG_PATH])).toEqual({
+                x_cadso_core: { sys_id: "fresh", name: "Fresh Set" },
+            });
+        });
+        test("returns null and writes nothing when scope is missing", function () {
+            var written = (0, updateSetConfig_1.writeUpdateSetRouting)({ sysId: "x", name: "y" });
+            expect(written).toBeNull();
+            expect(mockFsStore[CONFIG_PATH]).toBeUndefined();
+        });
+        test("returns null when sys_id or name is blank", function () {
+            expect((0, updateSetConfig_1.writeUpdateSetRouting)({ scope: "x_cadso_core", sysId: "  ", name: "y" })).toBeNull();
+            expect((0, updateSetConfig_1.writeUpdateSetRouting)({ scope: "x_cadso_core", sysId: "x", name: "" })).toBeNull();
+            expect(mockFsStore[CONFIG_PATH]).toBeUndefined();
+        });
+    });
+});

package/dist/updateSetCommands.js

@@ -49,6 +49,7 @@ const commands_1 = require("./commands");
 const chalk_1 = __importDefault(require("chalk"));
 const dovetail_clickup_1 = require("@tenonhq/dovetail-clickup");
 const clickupCommands_1 = require("./clickupCommands");
+const updateSetConfig_1 = require("./updateSetConfig");
 /**
  * Shows the current scope
  */
@@ -233,6 +234,26 @@ async function createUpdateSetCommand(args) {
         if (scope) {
             Logger_1.logger.info(`Scope: ${scope}`);
         }
+        // Keep .dove-update-sets.json in sync with the set we just activated.
+        // `dove push` routes captures by this file (per scope), not by the
+        // instance's active update set — so without this write the new set would
+        // stay empty and pushes would land in whatever stale set the file still
+        // points at (TenonHQ/Dovetail#182).
+        if (scope) {
+            const routed = (0, updateSetConfig_1.writeUpdateSetRouting)({
+                scope,
+                sysId: updateSetSysId,
+                name,
+            });
+            if (routed) {
+                Logger_1.logger.info(chalk_1.default.green(`✓ Push routing updated: ${scope} -> ${name} (${updateSetSysId})`));
+            }
+        }
+        else {
+            Logger_1.logger.warn("No scope provided, so .dove-update-sets.json was not updated. " +
+                "`dove push` routes captures by scope via that file — pass -s <scope> " +
+                "so pushes target this set, or edit .dove-update-sets.json directly.");
+        }
         // If created from a ClickUp task, offer to post a comment back
         if (args._clickupTaskId) {
             try {
@@ -292,6 +313,22 @@ async function switchUpdateSetCommand(args) {
         if (applicationName) {
             Logger_1.logger.info(`Scope: ${applicationName}`);
         }
+        // Keep .dove-update-sets.json in sync so `dove push` routes captures to the
+        // set we just switched to (it routes by this file per scope, not by the
+        // instance's active set — TenonHQ/Dovetail#182). `applicationScope` is the
+        // scope's sys_id, so resolve it back to the scope name the file is keyed on.
+        const scopeName = args.scope || (await resolveScopeName(applicationScope));
+        if (scopeName) {
+            const routed = (0, updateSetConfig_1.writeUpdateSetRouting)({ scope: scopeName, sysId, name });
+            if (routed) {
+                Logger_1.logger.info(chalk_1.default.green(`✓ Push routing updated: ${scopeName} -> ${name} (${sysId})`));
+            }
+        }
+        else {
+            Logger_1.logger.warn("Could not resolve the scope name, so .dove-update-sets.json was not " +
+                "updated. `dove push` routes captures by scope via that file — pass " +
+                "--scope <scope> so pushes target this set.");
+        }
     }
     catch (e) {
         Logger_1.logger.error("Failed to switch update set");
@@ -489,6 +526,30 @@ async function getActiveUpdateSetName(client, scope) {
         return null;
     }
 }
+/**
+ * Resolves a scope's sys_id back to its scope name (e.g. "x_cadso_core"), used
+ * to key the .dove-update-sets.json push-routing entry. Returns undefined when
+ * the input is missing or the lookup fails so the caller can warn instead.
+ */
+async function resolveScopeName(applicationSysId) {
+    if (!applicationSysId || applicationSysId.trim() === "")
+        return undefined;
+    try {
+        const client = (0, snClient_1.defaultClient)();
+        const rows = await (0, snClient_1.unwrapSNResponse)(client.getScopeById(applicationSysId));
+        if (rows && rows.length > 0) {
+            const resolved = rows[0].scope;
+            if (resolved && typeof resolved === "string" && resolved.trim() !== "") {
+                return resolved;
+            }
+        }
+    }
+    catch (e) {
+        Logger_1.logger.debug("Could not resolve scope name from application sys_id: " +
+            (e instanceof Error ? e.message : String(e)));
+    }
+    return undefined;
+}
 /**
  * Helper function to switch to a scope
  */

package/dist/updateSetConfig.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readUpdateSetConfig = readUpdateSetConfig;
+exports.writeUpdateSetRouting = writeUpdateSetRouting;
+const fs_1 = __importDefault(require("fs"));
+const projectFiles_1 = require("./projectFiles");
+const Logger_1 = require("./Logger");
+/**
+ * Read .dove-update-sets.json (or its legacy .sinc- sibling). Returns {} when
+ * the file is absent or unparseable, so callers never have to guard for null.
+ */
+function readUpdateSetConfig() {
+    const configPath = (0, projectFiles_1.getUpdateSetsConfigPath)();
+    try {
+        if (fs_1.default.existsSync(configPath)) {
+            const parsed = JSON.parse(fs_1.default.readFileSync(configPath, "utf8"));
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                return parsed;
+            }
+            Logger_1.logger.warn(`Update set config at ${configPath} is not an object; ignoring it.`);
+        }
+    }
+    catch (e) {
+        Logger_1.logger.warn(`Failed to parse update set config at ${configPath}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    return {};
+}
+/**
+ * Merge a single scope's update set into .dove-update-sets.json so that
+ * `dove push` routes that scope's records to the set the operator just created
+ * or switched to.
+ *
+ * Without this, `dove createUpdateSet` / `dove switchUpdateSet` only flip the
+ * instance's *active* update set, while `dove push` keeps routing via this file
+ * — so a freshly "activated" set can stay empty and the work lands in whatever
+ * stale set the file still points at (TenonHQ/Dovetail#182).
+ *
+ * Returns the path written, or null when any input is missing (no scope name,
+ * sys_id, or set name to route by) so the caller can warn instead.
+ */
+function writeUpdateSetRouting(opts) {
+    const scope = opts.scope ? opts.scope.trim() : "";
+    const sysId = opts.sysId ? opts.sysId.trim() : "";
+    const name = opts.name ? opts.name.trim() : "";
+    if (!scope || !sysId || !name)
+        return null;
+    const configPath = (0, projectFiles_1.getUpdateSetsConfigPath)();
+    const config = readUpdateSetConfig();
+    config[scope] = { sys_id: sysId, name };
+    fs_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    return configPath;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tenonhq/dovetail-core",
-  "version": "0.0.105",
+  "version": "0.0.107",
   "description": "Next-gen file syncer",
   "license": "GPL-3.0",
   "main": "./dist/index.js",
@@ -22,7 +22,7 @@
     "node": ">=22"
   },
   "devDependencies": {
-    "@tenonhq/dovetail-types": "~0.0.19",
+    "@tenonhq/dovetail-types": "~0.0.20",
     "@types/dotenv": "^6.1.1",
     "@types/inquirer": "^8.2.10",
     "@types/jest": "^29.5.5",
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "@tenonhq/dovetail-clickup": "~0.0.12",
-    "@tenonhq/dovetail-schema": "~0.0.11",
+    "@tenonhq/dovetail-schema": "~0.0.12",
     "axios": "^1.5.1",
     "axios-cookiejar-support": "^4.0.7",
     "axios-rate-limit": "^1.3.0",