@tenonhq/dovetail-core 0.0.85

package/dist/benchmark.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * Opt-in benchmark collector for `sinc refresh`. Wired into snClient via
+ * setBenchmarkSink — when null (the default), there is zero overhead.
+ *
+ * PR #36 changed refresh from "download files absent from disk" to "bulk-download
+ * every manifest file and compare before writing". That shifted the request
+ * profile silently. This collector surfaces the numbers so regressions are
+ * visible.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BenchmarkCollector = void 0;
+class BenchmarkCollector {
+    httpSamples = [];
+    scopeSamples = [];
+    currentScope = null;
+    recordHttp(sample) {
+        this.httpSamples.push(sample);
+    }
+    startScope(scopeName) {
+        this.currentScope = {
+            name: scopeName,
+            startedAt: Date.now(),
+            httpStart: this.httpSamples.length,
+            bytesStart: this.totalBytes(),
+        };
+    }
+    endScope(filesWritten, filesUnchanged) {
+        if (!this.currentScope)
+            return;
+        var scope = this.currentScope;
+        this.scopeSamples.push({
+            scopeName: scope.name,
+            wallTimeMs: Date.now() - scope.startedAt,
+            httpRequests: this.httpSamples.length - scope.httpStart,
+            filesWritten: filesWritten,
+            filesUnchanged: filesUnchanged,
+            totalResponseBytes: this.totalBytes() - scope.bytesStart,
+        });
+        this.currentScope = null;
+    }
+    getHttpSamples() {
+        return this.httpSamples.slice();
+    }
+    getScopeSamples() {
+        return this.scopeSamples.slice();
+    }
+    totalBytes() {
+        var total = 0;
+        for (var i = 0; i < this.httpSamples.length; i++) {
+            total += this.httpSamples[i].responseBytes;
+        }
+        return total;
+    }
+    formatSummary() {
+        var lines = [];
+        lines.push("");
+        lines.push("=".repeat(72));
+        lines.push("Refresh Benchmark");
+        lines.push("=".repeat(72));
+        if (this.httpSamples.length === 0) {
+            lines.push("(no samples recorded)");
+            return lines.join("\n");
+        }
+        var latencies = this.httpSamples
+            .map(function (s) { return s.durationMs; })
+            .sort(function (a, b) { return a - b; });
+        var p50 = percentile(latencies, 0.5);
+        var p95 = percentile(latencies, 0.95);
+        var max = latencies[latencies.length - 1];
+        var totalBytes = this.totalBytes();
+        lines.push("Overall: " + this.httpSamples.length + " HTTP requests, " +
+            formatBytes(totalBytes) + " received");
+        lines.push("Latency: p50 " + p50 + "ms | p95 " + p95 + "ms | max " + max + "ms");
+        if (this.scopeSamples.length > 0) {
+            lines.push("");
+            lines.push("Per-scope:");
+            for (var i = 0; i < this.scopeSamples.length; i++) {
+                var s = this.scopeSamples[i];
+                lines.push("  " + s.scopeName + ": " +
+                    s.wallTimeMs + "ms wall, " +
+                    s.httpRequests + " req, " +
+                    formatBytes(s.totalResponseBytes) + ", " +
+                    s.filesWritten + " written / " + s.filesUnchanged + " unchanged");
+            }
+        }
+        lines.push("=".repeat(72));
+        return lines.join("\n");
+    }
+}
+exports.BenchmarkCollector = BenchmarkCollector;
+function percentile(sortedAsc, p) {
+    if (sortedAsc.length === 0)
+        return 0;
+    var idx = Math.min(sortedAsc.length - 1, Math.floor(sortedAsc.length * p));
+    return sortedAsc[idx];
+}
+function formatBytes(n) {
+    if (n < 1024)
+        return n + "B";
+    if (n < 1024 * 1024)
+        return (n / 1024).toFixed(1) + "KB";
+    return (n / (1024 * 1024)).toFixed(2) + "MB";
+}

package/dist/bootstrap.js

@@ -0,0 +1,62 @@
+"use strict";
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+const dotenv_1 = __importDefault(require("dotenv"));
+const ConfigManager = __importStar(require("./config"));
+const Logger_1 = require("./Logger");
+async function init() {
+    let configLoaded = false;
+    try {
+        await ConfigManager.loadConfigs();
+        configLoaded = true;
+    }
+    catch (e) {
+        Logger_1.logger.error("Failed to load configuration: " + String(e));
+    }
+    if (configLoaded) {
+        try {
+            let path = ConfigManager.getEnvPath();
+            dotenv_1.default.config({ path });
+        }
+        catch (e) {
+            Logger_1.logger.error("Failed to load environment: " + String(e));
+        }
+    }
+    (await Promise.resolve().then(() => __importStar(require("./commander")))).initCommands();
+}

package/dist/claudeCommand.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initClaudeCommand = initClaudeCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const Logger_1 = require("./Logger");
+const commands_1 = require("./commands");
+function findSkillsDir() {
+    // Walk up from __dirname looking for a skills/ directory with .md files
+    // Handles both dist/ and dist/core/src/ output structures, plus monorepo layout
+    let dir = __dirname;
+    const root = path_1.default.parse(dir).root;
+    while (dir !== root) {
+        dir = path_1.default.dirname(dir);
+        const candidate = path_1.default.join(dir, "skills");
+        if (fs_1.default.existsSync(candidate) &&
+            fs_1.default.statSync(candidate).isDirectory() &&
+            fs_1.default.readdirSync(candidate).some(function (f) {
+                return f.endsWith(".md");
+            })) {
+            return candidate;
+        }
+    }
+    return null;
+}
+async function initClaudeCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    var skillsDir = findSkillsDir();
+    if (!skillsDir) {
+        Logger_1.logger.error("Could not find Dovetail skills directory.");
+        process.exit(1);
+        return;
+    }
+    // Target: <cwd>/.claude/commands/
+    const targetDir = path_1.default.resolve(process.cwd(), ".claude", "commands");
+    fs_1.default.mkdirSync(targetDir, { recursive: true });
+    // Copy .md files
+    const files = fs_1.default.readdirSync(skillsDir).filter((f) => f.endsWith(".md"));
+    let copied = 0;
+    let skipped = 0;
+    for (const file of files) {
+        const dest = path_1.default.join(targetDir, file);
+        if (fs_1.default.existsSync(dest) && !args.force) {
+            Logger_1.logger.info(`Skipped (exists): ${file}`);
+            skipped++;
+        }
+        else {
+            fs_1.default.copyFileSync(path_1.default.join(skillsDir, file), dest);
+            Logger_1.logger.info(`Copied: ${file}`);
+            copied++;
+        }
+    }
+    Logger_1.logger.success(`Init complete! ${copied} skills copied, ${skipped} skipped. ✅`);
+    if (skipped > 0) {
+        Logger_1.logger.info("Use --force to overwrite existing files.");
+    }
+}

package/dist/clickupCommands.js

@@ -0,0 +1,472 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clickupTasksCommand = clickupTasksCommand;
+exports.clickupTaskCommand = clickupTaskCommand;
+exports.clickupCreateCommand = clickupCreateCommand;
+exports.clickupUpdateCommand = clickupUpdateCommand;
+exports.clickupCommentCommand = clickupCommentCommand;
+exports.clickupSetupCommand = clickupSetupCommand;
+exports.clickupTeamsCommand = clickupTeamsCommand;
+exports.clickupSpacesCommand = clickupSpacesCommand;
+exports.clickupListsCommand = clickupListsCommand;
+exports.refineUpdateSetName = refineUpdateSetName;
+const dovetail_clickup_1 = require("@tenonhq/dovetail-clickup");
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const Logger_1 = require("./Logger");
+const commands_1 = require("./commands");
+const FileUtils_1 = require("./FileUtils");
+// --- Token & API Helpers ---
+function getClickUpToken() {
+    var token = process.env.CLICKUP_API_TOKEN;
+    if (!token || token === "") {
+        throw new Error("CLICKUP_API_TOKEN not set. Run 'dove clickup setup' or add CLICKUP_API_TOKEN to your .env file.");
+    }
+    return token;
+}
+function getApi() {
+    return (0, dovetail_clickup_1.createClickUpApi)({ token: getClickUpToken() });
+}
+/**
+ * @description Resolves the team ID automatically. Uses --team flag if provided,
+ * otherwise calls getTeams() and auto-selects if there's only one.
+ * Only prompts interactively when the user belongs to multiple teams.
+ */
+async function resolveTeamId(api, args) {
+    // Explicit --team flag takes priority
+    if (args.team) {
+        return args.team;
+    }
+    var teams = await api.getTeams();
+    if (teams.length === 0) {
+        throw new Error("No ClickUp workspaces found. Verify your API token.");
+    }
+    if (teams.length === 1) {
+        return teams[0].id;
+    }
+    // Multiple teams — must prompt
+    var teamChoices = teams.map(function (t) {
+        return { name: t.name, value: t.id };
+    });
+    var teamAnswer = await inquirer_1.default.prompt([
+        {
+            type: "list",
+            name: "teamId",
+            message: "Select a workspace:",
+            choices: teamChoices,
+        },
+    ]);
+    return teamAnswer.teamId;
+}
+// --- Commands ---
+/**
+ * @description Lists tasks assigned to the authenticated user, grouped by status.
+ */
+async function clickupTasksCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    try {
+        var api = getApi();
+        var teamId = await resolveTeamId(api, args);
+        Logger_1.logger.info("Fetching your tasks...");
+        var statusFilters;
+        if (args.status && Array.isArray(args.status)) {
+            statusFilters = args.status;
+        }
+        var result = await api.listMyTasks({
+            teamId: teamId,
+            statuses: statusFilters,
+        });
+        if (result.total === 0) {
+            Logger_1.logger.info("No tasks assigned to you.");
+            return;
+        }
+        var output = (0, dovetail_clickup_1.formatForClaude)({ tasks: result.tasks });
+        console.log(output);
+    }
+    catch (e) {
+        Logger_1.logger.error("Failed to list tasks");
+        if (e instanceof Error)
+            Logger_1.logger.error(e.message);
+        throw e;
+    }
+}
+/**
+ * @description Gets details for a single ClickUp task.
+ */
+async function clickupTaskCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    try {
+        var api = getApi();
+        var parsed = (0, dovetail_clickup_1.parseClickUpIdentifier)(args.id);
+        Logger_1.logger.info("Fetching task " + parsed.taskId + "...");
+        var task = await api.getTask({ taskId: parsed.taskId });
+        var output = (0, dovetail_clickup_1.formatTaskDetail)({ task: task });
+        console.log(output);
+    }
+    catch (e) {
+        Logger_1.logger.error("Failed to get task");
+        if (e instanceof Error)
+            Logger_1.logger.error(e.message);
+        throw e;
+    }
+}
+/**
+ * @description Creates a new task in a ClickUp list (interactive).
+ */
+async function clickupCreateCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    try {
+        var api = getApi();
+        var listId = args.listId;
+        var answers = await inquirer_1.default.prompt([
+            {
+                type: "input",
+                name: "name",
+                message: "Task name:",
+                validate: function (input) {
+                    if (!input || input.trim() === "")
+                        return "Task name is required";
+                    return true;
+                },
+            },
+            {
+                type: "input",
+                name: "description",
+                message: "Description (optional):",
+            },
+            {
+                type: "input",
+                name: "status",
+                message: "Status (optional, e.g., 'to do'):",
+            },
+            {
+                type: "list",
+                name: "priority",
+                message: "Priority:",
+                choices: [
+                    { name: "None", value: undefined },
+                    { name: "Urgent", value: 1 },
+                    { name: "High", value: 2 },
+                    { name: "Normal", value: 3 },
+                    { name: "Low", value: 4 },
+                ],
+            },
+        ]);
+        Logger_1.logger.info("Creating task...");
+        var task = await api.createTask({
+            listId: listId,
+            name: answers.name,
+            description: answers.description || undefined,
+            status: answers.status || undefined,
+            priority: answers.priority,
+        });
+        Logger_1.logger.success(chalk_1.default.green("✓ Task created: " + task.name));
+        Logger_1.logger.info("  ID: " + task.id);
+        Logger_1.logger.info("  URL: " + task.url);
+    }
+    catch (e) {
+        Logger_1.logger.error("Failed to create task");
+        if (e instanceof Error)
+            Logger_1.logger.error(e.message);
+        throw e;
+    }
+}
+/**
+ * @description Updates an existing ClickUp task (interactive).
+ */
+async function clickupUpdateCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    try {
+        var api = getApi();
+        var parsed = (0, dovetail_clickup_1.parseClickUpIdentifier)(args.taskId);
+        Logger_1.logger.info("Fetching current task state...");
+        var task = await api.getTask({ taskId: parsed.taskId });
+        var currentStatus = task.status && task.status.status ? task.status.status : "";
+        var answers = await inquirer_1.default.prompt([
+            {
+                type: "input",
+                name: "name",
+                message: "Name:",
+                default: task.name,
+            },
+            {
+                type: "input",
+                name: "status",
+                message: "Status:",
+                default: currentStatus,
+            },
+            {
+                type: "list",
+                name: "priority",
+                message: "Priority:",
+                choices: [
+                    { name: "No change", value: undefined },
+                    { name: "Urgent", value: 1 },
+                    { name: "High", value: 2 },
+                    { name: "Normal", value: 3 },
+                    { name: "Low", value: 4 },
+                    { name: "None", value: 0 },
+                ],
+            },
+        ]);
+        var updates = { taskId: parsed.taskId };
+        if (answers.name !== task.name) {
+            updates.name = answers.name;
+        }
+        if (answers.status !== currentStatus) {
+            updates.status = answers.status;
+        }
+        if (answers.priority !== undefined) {
+            updates.priority = answers.priority;
+        }
+        // Check if anything changed
+        if (Object.keys(updates).length <= 1) {
+            Logger_1.logger.info("No changes made.");
+            return;
+        }
+        Logger_1.logger.info("Updating task...");
+        var updated = await api.updateTask(updates);
+        Logger_1.logger.success(chalk_1.default.green("✓ Task updated: " + updated.name));
+    }
+    catch (e) {
+        Logger_1.logger.error("Failed to update task");
+        if (e instanceof Error)
+            Logger_1.logger.error(e.message);
+        throw e;
+    }
+}
+/**
+ * @description Adds a comment to a ClickUp task.
+ */
+async function clickupCommentCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    try {
+        var api = getApi();
+        var parsed = (0, dovetail_clickup_1.parseClickUpIdentifier)(args.taskId);
+        var msg = args.msg;
+        if (!msg || msg.trim() === "") {
+            throw new Error("Comment message is required.");
+        }
+        Logger_1.logger.info("Adding comment to task " + parsed.taskId + "...");
+        await api.addComment({ taskId: parsed.taskId, commentText: msg });
+        Logger_1.logger.success(chalk_1.default.green("✓ Comment added"));
+    }
+    catch (e) {
+        Logger_1.logger.error("Failed to add comment");
+        if (e instanceof Error)
+            Logger_1.logger.error(e.message);
+        throw e;
+    }
+}
+/**
+ * @description Interactive setup wizard for ClickUp API token and team configuration.
+ */
+async function clickupSetupCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    try {
+        Logger_1.logger.info(chalk_1.default.bold("\nClickUp Setup"));
+        Logger_1.logger.info("─".repeat(40));
+        Logger_1.logger.info("");
+        Logger_1.logger.info("To get your ClickUp API token:");
+        Logger_1.logger.info("  1. Go to ClickUp → Settings (bottom-left) → Apps");
+        Logger_1.logger.info('  2. Under "API Token", click Generate');
+        Logger_1.logger.info("  3. Copy the token and paste it below");
+        Logger_1.logger.info("");
+        var answers = await inquirer_1.default.prompt([
+            {
+                type: "password",
+                name: "token",
+                message: "ClickUp API Token:",
+                mask: "*",
+                validate: function (input) {
+                    if (!input || input.trim() === "")
+                        return "API token is required";
+                    return true;
+                },
+            },
+        ]);
+        var token = answers.token.trim();
+        // Validate the token by fetching teams
+        Logger_1.logger.info("Validating token...");
+        var api = (0, dovetail_clickup_1.createClickUpApi)({ token: token });
+        var teams = await api.getTeams();
+        if (teams.length === 0) {
+            throw new Error("Token is valid but no workspaces found. Check your ClickUp permissions.");
+        }
+        Logger_1.logger.success(chalk_1.default.green("✓ Token valid"));
+        // Show discovered workspaces
+        for (var i = 0; i < teams.length; i++) {
+            var memberCount = teams[i].members ? teams[i].members.length : 0;
+            Logger_1.logger.info("  Workspace: " + teams[i].name + " (" + memberCount + " members)");
+        }
+        // Write token to .env file
+        (0, FileUtils_1.writeEnvVar)({ key: "CLICKUP_API_TOKEN", value: token });
+        Logger_1.logger.info("");
+        Logger_1.logger.success(chalk_1.default.green("✓ ClickUp configured! Token saved to .env"));
+        Logger_1.logger.info("");
+        Logger_1.logger.info("You can now use:");
+        Logger_1.logger.info("  dove clickup tasks        — List your tasks");
+        Logger_1.logger.info("  dove clickup task <id>     — Get task details");
+        Logger_1.logger.info("  dove createUpdateSet -cu <task-id> — Create update set from task");
+    }
+    catch (e) {
+        Logger_1.logger.error("ClickUp setup failed");
+        if (e instanceof Error)
+            Logger_1.logger.error(e.message);
+        throw e;
+    }
+}
+/**
+ * @description Lists all ClickUp workspaces/teams the token has access to.
+ */
+async function clickupTeamsCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    try {
+        var api = getApi();
+        Logger_1.logger.info("Fetching teams...");
+        var teams = await api.getTeams();
+        if (teams.length === 0) {
+            Logger_1.logger.info("No workspaces found for this token.");
+            return;
+        }
+        Logger_1.logger.info(chalk_1.default.bold("\nWorkspaces / Teams:"));
+        Logger_1.logger.info("─".repeat(40));
+        for (var i = 0; i < teams.length; i++) {
+            var team = teams[i];
+            var memberCount = team.members ? team.members.length : 0;
+            console.log("  " + team.name + " — ID: " + team.id + " (" + memberCount + " members)");
+        }
+        console.log("");
+    }
+    catch (e) {
+        Logger_1.logger.error("Failed to list teams");
+        if (e instanceof Error)
+            Logger_1.logger.error(e.message);
+        throw e;
+    }
+}
+/**
+ * @description Lists available ClickUp spaces in a workspace.
+ */
+async function clickupSpacesCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    try {
+        var api = getApi();
+        var teamId = await resolveTeamId(api, args);
+        Logger_1.logger.info("Fetching spaces...");
+        var spaces = await api.getSpaces({ teamId: teamId });
+        if (spaces.length === 0) {
+            Logger_1.logger.info("No spaces found in this workspace.");
+            return;
+        }
+        Logger_1.logger.info(chalk_1.default.bold("\nSpaces:"));
+        Logger_1.logger.info("─".repeat(40));
+        for (var i = 0; i < spaces.length; i++) {
+            var space = spaces[i];
+            var visibility = space.private ? "(private)" : "(public)";
+            console.log("  " + space.name + " — ID: " + space.id + " " + visibility);
+        }
+        console.log("");
+    }
+    catch (e) {
+        Logger_1.logger.error("Failed to list spaces");
+        if (e instanceof Error)
+            Logger_1.logger.error(e.message);
+        throw e;
+    }
+}
+/**
+ * @description Lists available ClickUp lists in a folder or folderless lists in a space.
+ */
+async function clickupListsCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    try {
+        var api = getApi();
+        var id = args.spaceOrFolder;
+        // Try as folder first, fall back to space
+        Logger_1.logger.info("Fetching lists...");
+        var lists;
+        try {
+            lists = await api.getLists({ folderId: id });
+        }
+        catch (folderErr) {
+            // If folder fails, try getting folders from a space
+            Logger_1.logger.debug("Not a folder ID, trying as space...");
+            var folders = await api.getFolders({ spaceId: id });
+            if (folders.length === 0) {
+                Logger_1.logger.info("No folders or lists found for ID: " + id);
+                return;
+            }
+            Logger_1.logger.info(chalk_1.default.bold("\nFolders & Lists:"));
+            Logger_1.logger.info("─".repeat(50));
+            for (var f = 0; f < folders.length; f++) {
+                var folder = folders[f];
+                console.log("\n  📁 " + folder.name + " (ID: " + folder.id + ")");
+                if (folder.lists && folder.lists.length > 0) {
+                    for (var l = 0; l < folder.lists.length; l++) {
+                        var fList = folder.lists[l];
+                        var countLabel = fList.task_count !== null ? " (" + fList.task_count + " tasks)" : "";
+                        console.log("     " + fList.name + " — ID: " + fList.id + countLabel);
+                    }
+                }
+            }
+            console.log("");
+            return;
+        }
+        if (lists.length === 0) {
+            Logger_1.logger.info("No lists found.");
+            return;
+        }
+        Logger_1.logger.info(chalk_1.default.bold("\nLists:"));
+        Logger_1.logger.info("─".repeat(40));
+        for (var i = 0; i < lists.length; i++) {
+            var list = lists[i];
+            var taskCount = list.task_count !== null ? " (" + list.task_count + " tasks)" : "";
+            console.log("  " + list.name + " — ID: " + list.id + taskCount);
+        }
+        console.log("");
+    }
+    catch (e) {
+        Logger_1.logger.error("Failed to list");
+        if (e instanceof Error)
+            Logger_1.logger.error(e.message);
+        throw e;
+    }
+}
+// --- Claude CLI Refiner ---
+/**
+ * @description Generates a refined update set name using Claude CLI, with fallback.
+ * @param params - Object with taskName, taskId, and taskDescription.
+ * @returns The refined or convention-based update set name.
+ */
+function refineUpdateSetName(params) {
+    var execSync = require("child_process").execSync;
+    // Sanitize inputs for shell safety
+    var safeName = params.taskName.replace(/['"\\]/g, "");
+    var safeDesc = params.taskDescription
+        .replace(/['"\\]/g, "")
+        .substring(0, 200);
+    try {
+        var prompt = "Generate a concise ServiceNow update set name (under 80 chars) for this ClickUp task. " +
+            "The name should be descriptive and professional. " +
+            "Task: " + safeName + ". " +
+            "Description: " + safeDesc + ". " +
+            "Return ONLY the update set name, nothing else.";
+        var result = execSync('claude -p "' + prompt.replace(/"/g, '\\"') + '" --output-format text', { encoding: "utf8", timeout: 30000, stdio: ["pipe", "pipe", "pipe"] });
+        var refined = result.trim();
+        if (refined && refined.length > 0 && refined.length <= 100) {
+            return refined;
+        }
+    }
+    catch (e) {
+        // Claude CLI not available or failed — fall back to convention
+    }
+    // Fallback: clean up the task name for use as an update set name
+    return params.taskName
+        .replace(/[^a-zA-Z0-9\s\-_]/g, "")
+        .trim()
+        .substring(0, 80);
+}