@tenonhq/dovetail-core 0.0.85

package/dist/tests/benchmarkRefresh.test.js

@@ -0,0 +1,265 @@
+"use strict";
+/**
+ * Unit tests for the --benchmark flag on `sinc refresh`.
+ *
+ * Two layers:
+ *   1. BenchmarkCollector in isolation — covers p50/p95/max math and the
+ *      formatSummary string the CLI prints.
+ *   2. refreshAllFiles wired to a collector — asserts startScope/endScope
+ *      bookends the scope and that filesWritten/filesUnchanged match what
+ *      refresh actually did.
+ *
+ * The axios interceptor hook (snClient.setBenchmarkSink) is exercised by the
+ * real-run integration against workstudio — not here. This suite covers the
+ * collector contract and the appUtils lifecycle.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const benchmark_1 = require("../benchmark");
+// ---------- mocks for refreshAllFiles test (must come before importing) ----
+var mockLogger = {
+    info: jest.fn(),
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    success: jest.fn(),
+    getLogLevel: function () { return "warn"; },
+};
+var mockFileLogger = {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+};
+var mockClient = {
+    getManifest: jest.fn(),
+    getMissingFiles: jest.fn(),
+};
+jest.mock("../Logger", function () { return { logger: mockLogger }; });
+jest.mock("../FileLogger", function () { return { fileLogger: mockFileLogger }; });
+jest.mock("../snClient", function () {
+    return {
+        defaultClient: function () { return mockClient; },
+        unwrapSNResponse: function (p) { return Promise.resolve(p).then(function (r) { return r; }); },
+        processPushResponse: jest.fn(),
+        retryOnErr: jest.fn(),
+        retryOnHttpErr: jest.fn(),
+        unwrapTableAPIFirstItem: jest.fn(),
+        setBenchmarkSink: jest.fn(),
+    };
+});
+var mockConfig = {
+    getConfig: jest.fn().mockReturnValue({ scopes: { x_cadso_core: {} }, tableOptions: {} }),
+    getManifest: jest.fn().mockResolvedValue({
+        x_cadso_core: { scope: "x_cadso_core", tables: {} },
+    }),
+    getSourcePathForScope: jest.fn(),
+    getSourcePath: jest.fn(),
+    getManifestPath: jest.fn().mockReturnValue("/tmp/dove.manifest.json"),
+    resolveConfigForScope: jest.fn().mockImplementation(function () {
+        return { tables: ["sys_script_include"], fieldOverrides: {}, apiIncludes: {}, apiExcludes: {} };
+    }),
+    isMultiScopeManifest: jest.fn().mockReturnValue(true),
+    updateManifest: jest.fn(),
+};
+jest.mock("../config", function () { return mockConfig; });
+jest.mock("progress", function () {
+    return jest.fn().mockImplementation(function () { return { tick: jest.fn() }; });
+});
+jest.mock("../FileUtils", function () {
+    var actual = jest.requireActual("../FileUtils");
+    return Object.assign({}, actual, {
+        writeScopeManifest: jest.fn().mockResolvedValue(undefined),
+    });
+});
+const AppUtils = __importStar(require("../appUtils"));
+// ---------- collector unit tests ----------
+describe("BenchmarkCollector", function () {
+    test("formatSummary reports empty state when nothing recorded", function () {
+        var collector = new benchmark_1.BenchmarkCollector();
+        var summary = collector.formatSummary();
+        expect(summary).toContain("Refresh Benchmark");
+        expect(summary).toContain("(no samples recorded)");
+    });
+    test("percentiles reflect the recorded latencies", function () {
+        var collector = new benchmark_1.BenchmarkCollector();
+        // 10, 20, 30, ..., 100 — p50 at index 5 = 60, p95 at index 9 = 100.
+        for (var i = 1; i <= 10; i++) {
+            collector.recordHttp({
+                path: "/api/test",
+                tableCount: 1,
+                durationMs: i * 10,
+                statusCode: 200,
+                responseBytes: 100,
+            });
+        }
+        var summary = collector.formatSummary();
+        expect(summary).toContain("p50 60ms");
+        expect(summary).toContain("p95 100ms");
+        expect(summary).toContain("max 100ms");
+        expect(summary).toContain("10 HTTP requests");
+    });
+    test("scope samples record wall time, request counts, and file counts", function () {
+        var collector = new benchmark_1.BenchmarkCollector();
+        collector.startScope("x_cadso_core");
+        collector.recordHttp({
+            path: "/api/bulkDownload",
+            tableCount: 3,
+            durationMs: 50,
+            statusCode: 200,
+            responseBytes: 2048,
+        });
+        collector.recordHttp({
+            path: "/api/bulkDownload",
+            tableCount: 3,
+            durationMs: 80,
+            statusCode: 200,
+            responseBytes: 4096,
+        });
+        collector.endScope(7, 42);
+        var scopes = collector.getScopeSamples();
+        expect(scopes).toHaveLength(1);
+        expect(scopes[0].scopeName).toBe("x_cadso_core");
+        expect(scopes[0].httpRequests).toBe(2);
+        expect(scopes[0].totalResponseBytes).toBe(2048 + 4096);
+        expect(scopes[0].filesWritten).toBe(7);
+        expect(scopes[0].filesUnchanged).toBe(42);
+        expect(scopes[0].wallTimeMs).toBeGreaterThanOrEqual(0);
+        var summary = collector.formatSummary();
+        expect(summary).toContain("x_cadso_core:");
+        expect(summary).toContain("7 written / 42 unchanged");
+    });
+    test("formatBytes switches units at KB and MB thresholds", function () {
+        var collector = new benchmark_1.BenchmarkCollector();
+        collector.recordHttp({ path: "/a", tableCount: 1, durationMs: 1, statusCode: 200, responseBytes: 500 });
+        expect(collector.formatSummary()).toContain("500B received");
+        var collector2 = new benchmark_1.BenchmarkCollector();
+        collector2.recordHttp({ path: "/a", tableCount: 1, durationMs: 1, statusCode: 200, responseBytes: 2048 });
+        expect(collector2.formatSummary()).toContain("2.0KB received");
+        var collector3 = new benchmark_1.BenchmarkCollector();
+        collector3.recordHttp({ path: "/a", tableCount: 1, durationMs: 1, statusCode: 200, responseBytes: 2 * 1024 * 1024 });
+        expect(collector3.formatSummary()).toContain("2.00MB received");
+    });
+    test("endScope is a no-op when no scope is active", function () {
+        var collector = new benchmark_1.BenchmarkCollector();
+        collector.endScope(5, 5);
+        expect(collector.getScopeSamples()).toHaveLength(0);
+    });
+});
+// ---------- refreshAllFiles integration with collector ----------
+describe("refreshAllFiles — benchmarkCollector lifecycle", function () {
+    var tmpRoot;
+    beforeEach(function () {
+        jest.clearAllMocks();
+        tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "sinc-bench-test-"));
+        mockConfig.getSourcePathForScope.mockReturnValue(tmpRoot);
+        mockConfig.getSourcePath.mockReturnValue(tmpRoot);
+    });
+    afterEach(function () {
+        try {
+            fs.rmSync(tmpRoot, { recursive: true, force: true });
+        }
+        catch (e) { }
+    });
+    test("endScope captures filesWritten and filesUnchanged for a refresh pass", async function () {
+        // "Stale" file — content diverges from what the mock returns → will be written.
+        fs.mkdirSync(path.join(tmpRoot, "sys_script_include", "StaleRec"), { recursive: true });
+        fs.writeFileSync(path.join(tmpRoot, "sys_script_include", "StaleRec", "script.js"), "var x = 1;");
+        // "Matching" file — content matches → counted as unchanged.
+        fs.mkdirSync(path.join(tmpRoot, "sys_script_include", "SameRec"), { recursive: true });
+        var matching = "var same = true;";
+        fs.writeFileSync(path.join(tmpRoot, "sys_script_include", "SameRec", "script.js"), matching);
+        var manifest = {
+            scope: "x_cadso_core",
+            tables: {
+                sys_script_include: {
+                    records: {
+                        StaleRec: { name: "StaleRec", sys_id: "sysid_Stale", files: [{ name: "script", type: "js" }] },
+                        SameRec: { name: "SameRec", sys_id: "sysid_Same", files: [{ name: "script", type: "js" }] },
+                    },
+                },
+            },
+        };
+        mockClient.getManifest.mockResolvedValue(manifest);
+        mockClient.getMissingFiles.mockResolvedValue({
+            sys_script_include: {
+                records: {
+                    StaleRec: {
+                        name: "StaleRec", sys_id: "sysid_Stale",
+                        files: [{ name: "script", type: "js", content: "var x = 99; // new from instance" }],
+                    },
+                    SameRec: {
+                        name: "SameRec", sys_id: "sysid_Same",
+                        files: [{ name: "script", type: "js", content: matching }],
+                    },
+                },
+            },
+        });
+        var collector = new benchmark_1.BenchmarkCollector();
+        collector.startScope("x_cadso_core");
+        await AppUtils.refreshAllFiles(manifest, tmpRoot, {
+            benchmarkCollector: collector,
+        });
+        var scopes = collector.getScopeSamples();
+        expect(scopes).toHaveLength(1);
+        expect(scopes[0].scopeName).toBe("x_cadso_core");
+        // One file had divergent content → written. One matched → unchanged.
+        expect(scopes[0].filesWritten).toBe(1);
+        expect(scopes[0].filesUnchanged).toBe(1);
+    });
+    test("endScope(0, 0) on error path so the collector still closes cleanly", async function () {
+        mockClient.getMissingFiles.mockRejectedValue(new Error("boom"));
+        var manifest = {
+            scope: "x_cadso_core",
+            tables: {
+                sys_script_include: {
+                    records: {
+                        Rec: { name: "Rec", sys_id: "sysid_Rec", files: [{ name: "script", type: "js" }] },
+                    },
+                },
+            },
+        };
+        var collector = new benchmark_1.BenchmarkCollector();
+        collector.startScope("x_cadso_core");
+        await expect(AppUtils.refreshAllFiles(manifest, tmpRoot, { benchmarkCollector: collector })).rejects.toThrow("boom");
+        var scopes = collector.getScopeSamples();
+        expect(scopes).toHaveLength(1);
+        expect(scopes[0].filesWritten).toBe(0);
+        expect(scopes[0].filesUnchanged).toBe(0);
+    });
+});

package/dist/tests/clickupCommands.test.js

@@ -0,0 +1,384 @@
+"use strict";
+// --- Mock setup (must be before imports) ---
+Object.defineProperty(exports, "__esModule", { value: true });
+var mockApi = {
+    getAuthorizedUser: jest.fn(),
+    getTask: jest.fn(),
+    listMyTasks: jest.fn(),
+    listTeamTasks: jest.fn(),
+    createTask: jest.fn(),
+    updateTask: jest.fn(),
+    updateTaskStatus: jest.fn(),
+    deleteTask: jest.fn(),
+    addComment: jest.fn(),
+    getTeams: jest.fn(),
+    getSpaces: jest.fn(),
+    getFolders: jest.fn(),
+    getLists: jest.fn(),
+    getSpaceLists: jest.fn(),
+    getListTasks: jest.fn(),
+};
+jest.mock("@tenonhq/dovetail-clickup", function () {
+    return {
+        createClickUpApi: jest.fn(function () {
+            return mockApi;
+        }),
+        parseClickUpIdentifier: jest.fn(function (input) {
+            return { taskId: input, raw: input };
+        }),
+        formatForClaude: jest.fn(function () {
+            return "## Formatted tasks";
+        }),
+        formatTaskDetail: jest.fn(function () {
+            return "## Task detail";
+        }),
+        formatTaskSummary: jest.fn(function () {
+            return "Task summary";
+        }),
+    };
+});
+jest.mock("inquirer", function () {
+    return {
+        default: {
+            prompt: jest.fn(),
+        },
+        prompt: jest.fn(),
+    };
+});
+jest.mock("../Logger", function () {
+    return {
+        logger: {
+            info: jest.fn(),
+            error: jest.fn(),
+            warn: jest.fn(),
+            debug: jest.fn(),
+            success: jest.fn(),
+        },
+    };
+});
+jest.mock("../commands", function () {
+    return {
+        setLogLevel: jest.fn(),
+    };
+});
+jest.mock("chalk", function () {
+    var identity = function (s) { return s; };
+    identity.green = identity;
+    identity.bold = identity;
+    return {
+        default: identity,
+        green: identity,
+        bold: identity,
+    };
+});
+jest.mock("fs", function () {
+    var actual = jest.requireActual("fs");
+    return Object.assign({}, actual, {
+        readFileSync: jest.fn(),
+        writeFileSync: jest.fn(),
+        existsSync: jest.fn(),
+        promises: actual.promises,
+    });
+});
+jest.mock("child_process");
+// --- Imports (after mocks) ---
+const clickupCommands_1 = require("../clickupCommands");
+const dovetail_clickup_1 = require("@tenonhq/dovetail-clickup");
+const Logger_1 = require("../Logger");
+// --- Tests ---
+describe("refineUpdateSetName", function () {
+    var execSync;
+    beforeEach(function () {
+        jest.clearAllMocks();
+        execSync = require("child_process").execSync;
+    });
+    it("returns Claude CLI result when valid and under 100 chars", function () {
+        execSync.mockReturnValue("  Fix Login Redirect Issue  \n");
+        var result = (0, clickupCommands_1.refineUpdateSetName)({
+            taskName: "Fix login redirect",
+            taskId: "abc123",
+            taskDescription: "Users are redirected to wrong page",
+        });
+        expect(result).toBe("Fix Login Redirect Issue");
+    });
+    it("falls back to cleaned task name when Claude CLI returns empty", function () {
+        execSync.mockReturnValue("  \n");
+        var result = (0, clickupCommands_1.refineUpdateSetName)({
+            taskName: "Fix Bug #42",
+            taskId: "abc123",
+            taskDescription: "Something broke",
+        });
+        expect(result).toBe("Fix Bug 42");
+    });
+    it("falls back when Claude CLI returns string over 100 chars", function () {
+        execSync.mockReturnValue("A".repeat(101));
+        var result = (0, clickupCommands_1.refineUpdateSetName)({
+            taskName: "Short Name",
+            taskId: "abc123",
+            taskDescription: "",
+        });
+        expect(result).toBe("Short Name");
+    });
+    it("falls back when Claude CLI throws (not installed)", function () {
+        execSync.mockImplementation(function () {
+            throw new Error("command not found: claude");
+        });
+        var result = (0, clickupCommands_1.refineUpdateSetName)({
+            taskName: "Fix Bug",
+            taskId: "abc123",
+            taskDescription: "",
+        });
+        expect(result).toBe("Fix Bug");
+    });
+    it("falls back when Claude CLI times out", function () {
+        execSync.mockImplementation(function () {
+            var err = new Error("ETIMEDOUT");
+            err.killed = true;
+            throw err;
+        });
+        var result = (0, clickupCommands_1.refineUpdateSetName)({
+            taskName: "Timeout Task",
+            taskId: "abc123",
+            taskDescription: "",
+        });
+        expect(result).toBe("Timeout Task");
+    });
+    it("strips special characters in fallback", function () {
+        execSync.mockImplementation(function () {
+            throw new Error("not available");
+        });
+        var result = (0, clickupCommands_1.refineUpdateSetName)({
+            taskName: "Fix: Bug #123 (urgent!)",
+            taskId: "abc123",
+            taskDescription: "",
+        });
+        expect(result).toBe("Fix Bug 123 urgent");
+    });
+    it("truncates fallback to 80 characters", function () {
+        execSync.mockImplementation(function () {
+            throw new Error("not available");
+        });
+        var longName = "A".repeat(100);
+        var result = (0, clickupCommands_1.refineUpdateSetName)({
+            taskName: longName,
+            taskId: "abc123",
+            taskDescription: "",
+        });
+        expect(result.length).toBeLessThanOrEqual(80);
+    });
+    it("sanitizes quotes and backslashes from input before passing to CLI", function () {
+        execSync.mockReturnValue("Clean Name");
+        (0, clickupCommands_1.refineUpdateSetName)({
+            taskName: "Fix 'quotes' and \"double\" and \\backslash",
+            taskId: "abc123",
+            taskDescription: "Desc with 'quotes' and \\slashes",
+        });
+        var callArgs = execSync.mock.calls[0][0];
+        expect(callArgs).not.toContain("'quotes'");
+        expect(callArgs).not.toContain("\\backslash");
+    });
+});
+describe("clickupTaskCommand", 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("fetches and formats a task on happy path", async function () {
+        var mockTask = { id: "t1", name: "Test Task" };
+        mockApi.getTask.mockResolvedValue(mockTask);
+        var consoleSpy = jest.spyOn(console, "log").mockImplementation();
+        await (0, clickupCommands_1.clickupTaskCommand)({ id: "t1", logLevel: "info" });
+        expect(dovetail_clickup_1.parseClickUpIdentifier).toHaveBeenCalledWith("t1");
+        expect(mockApi.getTask).toHaveBeenCalledWith({ taskId: "t1" });
+        expect(dovetail_clickup_1.formatTaskDetail).toHaveBeenCalled();
+        expect(consoleSpy).toHaveBeenCalledWith("## Task detail");
+        consoleSpy.mockRestore();
+    });
+    it("throws when CLICKUP_API_TOKEN is missing", async function () {
+        delete process.env.CLICKUP_API_TOKEN;
+        await expect((0, clickupCommands_1.clickupTaskCommand)({ id: "t1", logLevel: "info" })).rejects.toThrow("CLICKUP_API_TOKEN not set");
+    });
+    it("logs and re-throws API errors", async function () {
+        mockApi.getTask.mockRejectedValue(new Error("API down"));
+        await expect((0, clickupCommands_1.clickupTaskCommand)({ id: "t1", logLevel: "info" })).rejects.toThrow("API down");
+        expect(Logger_1.logger.error).toHaveBeenCalledWith("Failed to get task");
+    });
+});
+describe("clickupTasksCommand", function () {
+    var originalEnv;
+    beforeEach(function () {
+        jest.clearAllMocks();
+        originalEnv = process.env.CLICKUP_API_TOKEN;
+        process.env.CLICKUP_API_TOKEN = "pk_test_token";
+        // Auto-resolve team (single team)
+        mockApi.getTeams.mockResolvedValue([{ id: "team1", name: "Tenon" }]);
+    });
+    afterEach(function () {
+        if (originalEnv !== undefined) {
+            process.env.CLICKUP_API_TOKEN = originalEnv;
+        }
+        else {
+            delete process.env.CLICKUP_API_TOKEN;
+        }
+    });
+    it("formats and outputs tasks on happy path", async function () {
+        mockApi.listMyTasks.mockResolvedValue({
+            tasks: [{ id: "t1", name: "Task" }],
+            byStatus: { "in progress": [{ id: "t1" }] },
+            total: 1,
+        });
+        var consoleSpy = jest.spyOn(console, "log").mockImplementation();
+        await (0, clickupCommands_1.clickupTasksCommand)({ logLevel: "info" });
+        expect(mockApi.listMyTasks).toHaveBeenCalled();
+        expect(dovetail_clickup_1.formatForClaude).toHaveBeenCalled();
+        expect(consoleSpy).toHaveBeenCalledWith("## Formatted tasks");
+        consoleSpy.mockRestore();
+    });
+    it("logs message when no tasks found", async function () {
+        mockApi.listMyTasks.mockResolvedValue({
+            tasks: [],
+            byStatus: {},
+            total: 0,
+        });
+        await (0, clickupCommands_1.clickupTasksCommand)({ logLevel: "info" });
+        expect(Logger_1.logger.info).toHaveBeenCalledWith("No tasks assigned to you.");
+    });
+    it("uses explicit --team flag when provided", async function () {
+        mockApi.listMyTasks.mockResolvedValue({ tasks: [], byStatus: {}, total: 0 });
+        await (0, clickupCommands_1.clickupTasksCommand)({ team: "explicit-team", logLevel: "info" });
+        expect(mockApi.listMyTasks).toHaveBeenCalledWith(expect.objectContaining({ teamId: "explicit-team" }));
+        // Should NOT call getTeams when --team is provided
+        expect(mockApi.getTeams).not.toHaveBeenCalled();
+    });
+    it("passes status filter from args", async function () {
+        mockApi.listMyTasks.mockResolvedValue({ tasks: [], byStatus: {}, total: 0 });
+        await (0, clickupCommands_1.clickupTasksCommand)({
+            logLevel: "info",
+            status: ["in progress", "blocked"],
+        });
+        expect(mockApi.listMyTasks).toHaveBeenCalledWith(expect.objectContaining({
+            statuses: ["in progress", "blocked"],
+        }));
+    });
+});
+describe("clickupCommentCommand", 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("adds comment to task", async function () {
+        mockApi.addComment.mockResolvedValue({});
+        await (0, clickupCommands_1.clickupCommentCommand)({ taskId: "t1", msg: "Hello!", logLevel: "info" });
+        expect(mockApi.addComment).toHaveBeenCalledWith({
+            taskId: "t1",
+            commentText: "Hello!",
+        });
+    });
+    it("throws when message is empty", async function () {
+        await expect((0, clickupCommands_1.clickupCommentCommand)({ taskId: "t1", msg: "", logLevel: "info" })).rejects.toThrow("Comment message is required");
+    });
+    it("throws when message is whitespace-only", async function () {
+        await expect((0, clickupCommands_1.clickupCommentCommand)({ taskId: "t1", msg: "   ", logLevel: "info" })).rejects.toThrow("Comment message is required");
+    });
+});
+describe("clickupTeamsCommand", 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("lists teams with member counts", async function () {
+        mockApi.getTeams.mockResolvedValue([
+            { id: "t1", name: "Tenon", members: [{ user: {} }, { user: {} }] },
+        ]);
+        var consoleSpy = jest.spyOn(console, "log").mockImplementation();
+        await (0, clickupCommands_1.clickupTeamsCommand)({ logLevel: "info" });
+        expect(mockApi.getTeams).toHaveBeenCalled();
+        var output = consoleSpy.mock.calls.map(function (c) { return c[0]; }).join("\n");
+        expect(output).toContain("Tenon");
+        expect(output).toContain("2 members");
+        consoleSpy.mockRestore();
+    });
+    it("logs message when no teams found", async function () {
+        mockApi.getTeams.mockResolvedValue([]);
+        await (0, clickupCommands_1.clickupTeamsCommand)({ logLevel: "info" });
+        expect(Logger_1.logger.info).toHaveBeenCalledWith("No workspaces found for this token.");
+    });
+});
+describe("getClickUpToken (via commands)", function () {
+    var originalEnv;
+    beforeEach(function () {
+        originalEnv = process.env.CLICKUP_API_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 empty string", async function () {
+        process.env.CLICKUP_API_TOKEN = "";
+        await expect((0, clickupCommands_1.clickupTaskCommand)({ id: "t1", logLevel: "info" })).rejects.toThrow("CLICKUP_API_TOKEN not set");
+    });
+    it("throws when CLICKUP_API_TOKEN is undefined", async function () {
+        delete process.env.CLICKUP_API_TOKEN;
+        await expect((0, clickupCommands_1.clickupTaskCommand)({ id: "t1", logLevel: "info" })).rejects.toThrow("CLICKUP_API_TOKEN not set");
+    });
+});
+describe("resolveTeamId (tested via clickupTasksCommand)", 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("auto-selects when only one team exists", async function () {
+        mockApi.getTeams.mockResolvedValue([{ id: "solo-team", name: "Solo" }]);
+        mockApi.listMyTasks.mockResolvedValue({ tasks: [], byStatus: {}, total: 0 });
+        await (0, clickupCommands_1.clickupTasksCommand)({ logLevel: "info" });
+        expect(mockApi.listMyTasks).toHaveBeenCalledWith(expect.objectContaining({ teamId: "solo-team" }));
+    });
+    it("throws when no teams found", async function () {
+        mockApi.getTeams.mockResolvedValue([]);
+        await expect((0, clickupCommands_1.clickupTasksCommand)({ logLevel: "info" })).rejects.toThrow("No ClickUp workspaces found");
+    });
+});