@tenonhq/dovetail-core 0.0.85

package/dist/tests/clickupPushHelper.test.js

@@ -0,0 +1,124 @@
+"use strict";
+// --- Mock setup (must be before imports) ---
+Object.defineProperty(exports, "__esModule", { value: true });
+var mockApi = {
+    getTask: jest.fn(),
+};
+jest.mock("@tenonhq/dovetail-clickup", function () {
+    return {
+        createClickUpApi: jest.fn(function () {
+            return mockApi;
+        }),
+        parseClickUpIdentifier: jest.fn(function (input) {
+            return { taskId: input.replace(/.*\/t\//, ""), raw: input };
+        }),
+    };
+});
+jest.mock("../clickupCommands", function () {
+    return {
+        refineUpdateSetName: jest.fn(function (params) {
+            return "Refined: " + params.taskName;
+        }),
+    };
+});
+jest.mock("../Logger", function () {
+    return {
+        logger: {
+            info: jest.fn(),
+            error: jest.fn(),
+            warn: jest.fn(),
+            debug: jest.fn(),
+            success: jest.fn(),
+        },
+    };
+});
+jest.mock("chalk", function () {
+    var identity = function (s) { return s; };
+    identity.green = identity;
+    return {
+        default: identity,
+        green: identity,
+    };
+});
+// --- Imports (after mocks) ---
+const clickupPushHelper_1 = require("../clickupPushHelper");
+const dovetail_clickup_1 = require("@tenonhq/dovetail-clickup");
+const clickupCommands_1 = require("../clickupCommands");
+// --- Tests ---
+describe("resolveClickUpForPush", function () {
+    var originalEnv;
+    beforeEach(function () {
+        jest.clearAllMocks();
+        originalEnv = process.env.CLICKUP_API_TOKEN;
+        process.env.CLICKUP_API_TOKEN = "pk_test_token";
+    });
+    afterEach(function () {
+        if (originalEnv !== undefined) {
+            process.env.CLICKUP_API_TOKEN = originalEnv;
+        }
+        else {
+            delete process.env.CLICKUP_API_TOKEN;
+        }
+    });
+    it("throws when CLICKUP_API_TOKEN is not set", async function () {
+        delete process.env.CLICKUP_API_TOKEN;
+        await expect((0, clickupPushHelper_1.resolveClickUpForPush)("abc123")).rejects.toThrow("CLICKUP_API_TOKEN not set");
+    });
+    it("throws when CLICKUP_API_TOKEN is empty", async function () {
+        process.env.CLICKUP_API_TOKEN = "";
+        await expect((0, clickupPushHelper_1.resolveClickUpForPush)("abc123")).rejects.toThrow("CLICKUP_API_TOKEN not set");
+    });
+    it("resolves task and returns refined update set name", async function () {
+        mockApi.getTask.mockResolvedValue({
+            id: "abc123",
+            name: "Fix Login Bug",
+            description: "Login page has redirect issue",
+        });
+        var result = await (0, clickupPushHelper_1.resolveClickUpForPush)("abc123");
+        expect(dovetail_clickup_1.parseClickUpIdentifier).toHaveBeenCalledWith("abc123");
+        expect(dovetail_clickup_1.createClickUpApi).toHaveBeenCalledWith({ token: "pk_test_token" });
+        expect(mockApi.getTask).toHaveBeenCalled();
+        expect(clickupCommands_1.refineUpdateSetName).toHaveBeenCalledWith({
+            taskName: "Fix Login Bug",
+            taskId: "abc123",
+            taskDescription: "Login page has redirect issue",
+        });
+        expect(result).toBe("Refined: Fix Login Bug");
+    });
+    it("passes empty string for description when task has no description", async function () {
+        mockApi.getTask.mockResolvedValue({
+            id: "abc123",
+            name: "No Desc Task",
+            description: "",
+        });
+        await (0, clickupPushHelper_1.resolveClickUpForPush)("abc123");
+        expect(clickupCommands_1.refineUpdateSetName).toHaveBeenCalledWith(expect.objectContaining({
+            taskDescription: "",
+        }));
+    });
+    it("passes empty string when description is undefined", async function () {
+        mockApi.getTask.mockResolvedValue({
+            id: "abc123",
+            name: "Undefined Desc",
+            description: undefined,
+        });
+        await (0, clickupPushHelper_1.resolveClickUpForPush)("abc123");
+        expect(clickupCommands_1.refineUpdateSetName).toHaveBeenCalledWith(expect.objectContaining({
+            taskDescription: "",
+        }));
+    });
+    it("propagates API errors", async function () {
+        mockApi.getTask.mockRejectedValue(new Error("Task not found"));
+        await expect((0, clickupPushHelper_1.resolveClickUpForPush)("missing123")).rejects.toThrow("Task not found");
+    });
+    it("works with ClickUp URL input", async function () {
+        mockApi.getTask.mockResolvedValue({
+            id: "86a3bx7wz",
+            name: "URL Task",
+            description: "From URL",
+        });
+        // The mock parseClickUpIdentifier strips the URL prefix
+        await (0, clickupPushHelper_1.resolveClickUpForPush)("https://app.clickup.com/t/86a3bx7wz");
+        expect(dovetail_clickup_1.parseClickUpIdentifier).toHaveBeenCalledWith("https://app.clickup.com/t/86a3bx7wz");
+    });
+});

package/dist/tests/configFallback.test.js

@@ -0,0 +1,68 @@
+"use strict";
+// Tests for the dove.config.js / sinc.config.js loader fallback in config.ts.
+// Covers: dove.config.js wins when both are present (no warning); sinc.config.js
+// is accepted when alone (with a deprecation warning); neither present walks
+// up the tree (returns false at the filesystem root).
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var mockLogger = {
+    info: jest.fn(),
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    success: jest.fn(),
+    getLogLevel: function () { return "debug"; },
+    setLogLevel: jest.fn(),
+};
+jest.mock("../Logger", function () {
+    return { logger: mockLogger };
+});
+jest.mock("../defaultOptions", function () {
+    return { includes: {}, excludes: {}, tableOptions: {}, scopes: {} };
+});
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../config");
+function makeTempDir() {
+    return fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dove-config-test-"));
+}
+function rmrf(dir) {
+    fs_1.default.rmSync(dir, { recursive: true, force: true });
+}
+describe("loadConfigPath fallback", function () {
+    var tmp = "";
+    beforeEach(function () {
+        jest.clearAllMocks();
+        tmp = makeTempDir();
+    });
+    afterEach(function () {
+        rmrf(tmp);
+    });
+    it("prefers dove.config.js when both files exist (no warning)", async function () {
+        fs_1.default.writeFileSync(path_1.default.join(tmp, "dove.config.js"), "module.exports = {};\n");
+        fs_1.default.writeFileSync(path_1.default.join(tmp, "sinc.config.js"), "module.exports = {};\n");
+        var result = await (0, config_1.loadConfigPath)(tmp);
+        expect(result).toBe(path_1.default.join(tmp, "dove.config.js"));
+        expect(mockLogger.warn).not.toHaveBeenCalled();
+    });
+    it("falls back to sinc.config.js with a deprecation warning when only legacy exists", async function () {
+        fs_1.default.writeFileSync(path_1.default.join(tmp, "sinc.config.js"), "module.exports = {};\n");
+        var result = await (0, config_1.loadConfigPath)(tmp);
+        expect(result).toBe(path_1.default.join(tmp, "sinc.config.js"));
+        expect(mockLogger.warn).toHaveBeenCalledTimes(1);
+        expect(mockLogger.warn.mock.calls[0][0]).toContain("legacy 'sinc.config.js'");
+        expect(mockLogger.warn.mock.calls[0][0]).toContain("dove migrate");
+    });
+    it("returns false when neither file exists anywhere up the tree (from a temp dir)", async function () {
+        // Nested empty subdir to exercise the recursive walk-up at least one step.
+        var nested = path_1.default.join(tmp, "subdir");
+        fs_1.default.mkdirSync(nested);
+        var result = await (0, config_1.loadConfigPath)(nested);
+        // The walk eventually reaches filesystem root and returns false. We don't
+        // assert on intermediate behavior — just the terminal result.
+        expect(result).toBe(false);
+    });
+});

package/dist/tests/cred.test.js

@@ -0,0 +1,59 @@
+"use strict";
+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 path_1 = __importDefault(require("path"));
+const bootstrap_1 = require("../bootstrap");
+let envPath = path_1.default.join(process.cwd(), ".env");
+test('Credentials undefined when file is missing', async () => {
+    // Removes any existing test env file from past tests
+    if (fs_1.default.existsSync(envPath)) {
+        fs_1.default.unlinkSync(envPath);
+    }
+    // Run init command (command being tested)
+    await (0, bootstrap_1.init)();
+    // Check "process" variables match expected results
+    expect(process.env.SN_USER).toBeUndefined();
+    expect(process.env.SN_PASSWORD).toBeUndefined();
+    expect(process.env.SN_INSTANCE).toBeUndefined();
+});
+test('Credentials undefined when file is broken', async () => {
+    // Sample Credential Data
+    let t_user = "Tyler";
+    let t_pass = "Edwards";
+    let t_instance = "dev90755.service-now.com";
+    // Create a faulty .env file
+    fs_1.default.writeFile(envPath, 'SN_USR=' + t_user + ' \nSN_PASWORD' + t_pass + ' \nSN_INSTACE=' + t_instance, (err) => {
+        if (err)
+            throw err;
+    });
+    // Run init command (command being tested)
+    await (0, bootstrap_1.init)();
+    // Check "process" variables match expected results
+    expect(process.env.SN_USER).toBeUndefined();
+    expect(process.env.SN_PASSWORD).toBeUndefined();
+    expect(process.env.SN_INSTANCE).toBeUndefined();
+});
+test('Credentials correct when file is correct', async () => {
+    // Sample Credential Data
+    let t_user = "Tyler";
+    let t_pass = "Edwards";
+    let t_instance = "dev90755.service-now.com";
+    // Create a correct .env file
+    fs_1.default.writeFile(envPath, 'SN_USER=' + t_user + ' \nSN_PASSWORD=' + t_pass + ' \nSN_INSTANCE=' + t_instance, (err) => {
+        if (err)
+            throw err;
+    });
+    // Run init command (command being tested)
+    await (0, bootstrap_1.init)();
+    // Check "process" variables match expected results
+    expect(process.env.SN_USER).toEqual(t_user);
+    expect(process.env.SN_PASSWORD).toEqual(t_pass);
+    expect(process.env.SN_INSTANCE).toEqual(t_instance);
+});
+// Cleans up leftover files
+if (fs_1.default.existsSync(envPath)) {
+    fs_1.default.unlinkSync(envPath);
+}

package/dist/tests/discovery.test.js

@@ -0,0 +1,67 @@
+"use strict";
+// --- Mock setup (must be before imports) ---
+Object.defineProperty(exports, "__esModule", { value: true });
+var mockReaddirSync = jest.fn();
+jest.mock("fs", function () {
+    var actual = jest.requireActual("fs");
+    return Object.assign({}, actual, {
+        readdirSync: mockReaddirSync,
+    });
+});
+jest.mock("../Logger", function () {
+    return {
+        logger: {
+            info: jest.fn(),
+            error: jest.fn(),
+            warn: jest.fn(),
+            debug: jest.fn(),
+            success: jest.fn(),
+        },
+    };
+});
+const discovery_1 = require("../initSystem/discovery");
+const Logger_1 = require("../Logger");
+describe("discoverPlugins", function () {
+    beforeEach(function () {
+        mockReaddirSync.mockReset();
+        // Default: no directories found
+        mockReaddirSync.mockImplementation(function () {
+            throw new Error("ENOENT");
+        });
+    });
+    it("returns empty array when no node_modules found", function () {
+        const plugins = (0, discovery_1.discoverPlugins)();
+        expect(plugins).toEqual([]);
+    });
+    it("skips sincronia-core and sincronia-types", function () {
+        mockReaddirSync.mockReturnValue([
+            "sincronia-core",
+            "sincronia-types",
+        ]);
+        const plugins = (0, discovery_1.discoverPlugins)();
+        expect(plugins).toEqual([]);
+    });
+    it("warns on plugin load failure", function () {
+        mockReaddirSync.mockReturnValue(["sincronia-nonexistent"]);
+        (0, discovery_1.discoverPlugins)();
+        expect(Logger_1.logger.warn).toHaveBeenCalled();
+    });
+    it("skips packages without sincPlugin export", function () {
+        mockReaddirSync.mockReturnValue(["sincronia-sass-plugin"]);
+        // sass-plugin exists but doesn't export sincPlugin — it just won't be added
+        const plugins = (0, discovery_1.discoverPlugins)();
+        const names = plugins.map(function (p) { return p.name; });
+        expect(names).not.toContain("sass-plugin");
+    });
+    it("skips sincronia-dashboard and sincronia-schema", function () {
+        Logger_1.logger.warn.mockClear();
+        mockReaddirSync.mockReturnValue([
+            "sincronia-dashboard",
+            "sincronia-schema",
+        ]);
+        const plugins = (0, discovery_1.discoverPlugins)();
+        expect(plugins).toEqual([]);
+        // No require() attempted, so no warn from load failure
+        expect(Logger_1.logger.warn).not.toHaveBeenCalled();
+    });
+});

package/dist/tests/ensureUpdateSetWarnings.test.js

@@ -0,0 +1,218 @@
+"use strict";
+/**
+ * Tests for US-006: Surface warning when no update set is configured
+ *
+ * Validates:
+ * - Prominent warning when readActiveTask() returns null and no update set configured
+ * - Warning message includes specific text about Default and remediation steps
+ * - Invalid scope name produces a clear error (not a global-scope update set)
+ * - scopeSysId validated before creating update set; null/undefined skips with error
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+// --- Mock setup ---
+const mockSNClient = {
+    getScopeId: jest.fn(),
+    getUserSysId: jest.fn(),
+    getCurrentAppUserPrefSysId: jest.fn(),
+    updateCurrentAppUserPref: jest.fn(),
+    createCurrentAppUserPref: jest.fn(),
+    changeScope: jest.fn().mockResolvedValue(undefined),
+    createUpdateSet: jest.fn(),
+    changeUpdateSet: jest.fn(),
+    client: {
+        get: jest.fn(),
+    },
+};
+jest.mock("../snClient", () => ({
+    defaultClient: jest.fn(() => mockSNClient),
+    unwrapSNResponse: jest.fn((val) => val),
+}));
+jest.mock("../FileUtils", () => ({
+    getFileContextFromPath: jest.fn(),
+    getFileContextWithSkipReason: jest.fn(),
+}));
+jest.mock("../appUtils", () => ({
+    groupAppFiles: jest.fn(),
+    pushFiles: jest.fn(),
+}));
+jest.mock("../logMessages", () => ({
+    logFilePush: jest.fn(),
+}));
+jest.mock("../recentEdits", () => ({
+    writeRecentEdit: jest.fn(),
+}));
+jest.mock("../Logger", () => ({
+    logger: {
+        info: jest.fn(),
+        error: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        success: jest.fn(),
+        getLogLevel: jest.fn().mockReturnValue("info"),
+    },
+}));
+jest.mock("../config", () => ({
+    loadConfigs: jest.fn().mockResolvedValue(undefined),
+    getConfig: jest.fn(),
+    getRootDir: jest.fn().mockReturnValue("/project"),
+    updateManifest: jest.fn(),
+    getManifest: jest.fn(),
+    getSourcePath: jest.fn().mockReturnValue("/project/src"),
+    getScopeManifestPath: jest.fn((scope) => `/project/dove.manifest.${scope}.json`),
+    getManifestPath: jest.fn().mockReturnValue("/project/dove.manifest.json"),
+}));
+// Filesystem mock store
+var mockFsStore = {};
+jest.mock("fs", () => ({
+    existsSync: jest.fn((p) => {
+        return p in mockFsStore;
+    }),
+    readFileSync: jest.fn((p) => {
+        if (p in mockFsStore)
+            return mockFsStore[p];
+        throw new Error("ENOENT: " + p);
+    }),
+    writeFileSync: jest.fn((p, data) => {
+        mockFsStore[p] = data;
+    }),
+    statSync: jest.fn(() => ({ mtimeMs: Date.now() })),
+    promises: {
+        readFile: jest.fn(),
+        writeFile: jest.fn(),
+        readdir: jest.fn(),
+        mkdir: jest.fn(),
+        access: jest.fn(),
+        stat: jest.fn(),
+    },
+}));
+jest.mock("chokidar", () => ({
+    watch: jest.fn(() => ({
+        on: jest.fn().mockReturnThis(),
+        close: jest.fn(),
+    })),
+}));
+jest.mock("lodash", () => {
+    var actual = jest.requireActual("lodash");
+    return {
+        ...actual,
+        debounce: jest.fn((fn) => {
+            var wrapper = jest.fn();
+            wrapper.cancel = jest.fn();
+            wrapper.flush = jest.fn(() => fn());
+            return wrapper;
+        }),
+    };
+});
+jest.mock("axios", () => ({
+    default: {
+        create: jest.fn(() => ({
+            get: jest.fn().mockResolvedValue({ data: { result: null } }),
+        })),
+    },
+}));
+// --- Imports ---
+const Logger_1 = require("../Logger");
+const MultiScopeWatcher_1 = require("../MultiScopeWatcher");
+// --- Tests ---
+describe("US-006: Surface warning when no update set is configured", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFsStore = {};
+        // Default: scope switching succeeds
+        mockSNClient.getScopeId.mockResolvedValue([{ sys_id: "scope_sys_id" }]);
+        mockSNClient.getUserSysId.mockResolvedValue([{ sys_id: "user_sys_id" }]);
+        mockSNClient.getCurrentAppUserPrefSysId.mockResolvedValue([{ sys_id: "pref_sys_id" }]);
+        mockSNClient.updateCurrentAppUserPref.mockResolvedValue({});
+        mockSNClient.createCurrentAppUserPref.mockResolvedValue({});
+    });
+    afterEach(() => {
+        (0, MultiScopeWatcher_1.stopMultiScopeWatching)();
+    });
+    it("warns with specific message when no active task and no update set configured", async () => {
+        // No .dove-update-sets.json and no .dove-active-task.json
+        await MultiScopeWatcher_1.multiScopeWatcher.ensureUpdateSetForScope("x_test_core");
+        expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("No update set configured for scope x_test_core"));
+        expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("Changes will go to Default"));
+        expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("dove createUpdateSet"));
+        expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("activate a task in the dashboard"));
+    });
+    it("does not warn when update set already configured for scope", async () => {
+        // Pre-populate the update set config
+        var configPath = require("path").resolve(process.cwd(), ".dove-update-sets.json");
+        mockFsStore[configPath] = JSON.stringify({
+            x_test_core: { sys_id: "us_123", name: "My Update Set" }
+        });
+        await MultiScopeWatcher_1.multiScopeWatcher.ensureUpdateSetForScope("x_test_core");
+        // Should return early — no warning
+        expect(Logger_1.logger.warn).not.toHaveBeenCalled();
+        expect(Logger_1.logger.error).not.toHaveBeenCalled();
+    });
+    it("logs error and skips creation when scope not found on instance (scopeSysId is undefined)", async () => {
+        // Active task exists so we get past the no-task check
+        var taskPath = require("path").resolve(process.cwd(), ".dove-active-task.json");
+        mockFsStore[taskPath] = JSON.stringify({
+            taskId: "abc123",
+            taskName: "Test Task",
+            taskDescription: "Test",
+            updateSetName: "CU-abc123 Test Task",
+            description: "Test update set",
+            taskUrl: "https://example.com",
+            scopes: {},
+        });
+        // getScopeId returns empty — scope doesn't exist
+        mockSNClient.getScopeId.mockResolvedValue([]);
+        await MultiScopeWatcher_1.multiScopeWatcher.ensureUpdateSetForScope("x_invalid_scope");
+        expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("x_invalid_scope"));
+        expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("not found on the instance"));
+        // Should NOT attempt to create an update set
+        expect(mockSNClient.createUpdateSet).not.toHaveBeenCalled();
+        expect(mockSNClient.client.get).not.toHaveBeenCalled();
+    });
+    it("logs error and skips creation when getScopeId returns null", async () => {
+        var taskPath = require("path").resolve(process.cwd(), ".dove-active-task.json");
+        mockFsStore[taskPath] = JSON.stringify({
+            taskId: "abc123",
+            taskName: "Test Task",
+            taskDescription: "Test",
+            updateSetName: "CU-abc123 Test Task",
+            description: "Test update set",
+            taskUrl: "https://example.com",
+            scopes: {},
+        });
+        // getScopeId returns null
+        mockSNClient.getScopeId.mockResolvedValue(null);
+        await MultiScopeWatcher_1.multiScopeWatcher.ensureUpdateSetForScope("x_bad_scope");
+        expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("x_bad_scope"));
+        expect(Logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining("not found on the instance"));
+        expect(mockSNClient.createUpdateSet).not.toHaveBeenCalled();
+    });
+    it("proceeds to create update set when scope is valid", async () => {
+        var taskPath = require("path").resolve(process.cwd(), ".dove-active-task.json");
+        mockFsStore[taskPath] = JSON.stringify({
+            taskId: "abc123",
+            taskName: "Test Task",
+            taskDescription: "Test",
+            updateSetName: "CU-abc123 Test Task",
+            description: "Test update set",
+            taskUrl: "https://example.com",
+            scopes: {},
+        });
+        // Valid scope
+        mockSNClient.getScopeId.mockResolvedValue([{ sys_id: "valid_scope_sys_id" }]);
+        // Search returns existing update set
+        mockSNClient.client.get.mockResolvedValue({
+            data: { result: [{ sys_id: "us_existing", name: "CU-abc123 Test Task", state: "in progress" }] }
+        });
+        // changeUpdateSet succeeds
+        mockSNClient.changeUpdateSet.mockResolvedValue(undefined);
+        await MultiScopeWatcher_1.multiScopeWatcher.ensureUpdateSetForScope("x_valid_scope");
+        // Should have searched for existing update sets (scope was valid)
+        expect(mockSNClient.client.get).toHaveBeenCalled();
+        // No "not found on the instance" error
+        var errorCalls = Logger_1.logger.error.mock.calls.map(function (c) { return c[0]; });
+        var hasInvalidScopeError = errorCalls.some(function (msg) {
+            return msg.indexOf("not found on the instance") !== -1;
+        });
+        expect(hasInvalidScopeError).toBe(false);
+    });
+});