@tenonhq/dovetail-core 0.0.85

package/dist/updateSetCommands.js

@@ -0,0 +1,702 @@
+"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.showCurrentScopeCommand = showCurrentScopeCommand;
+exports.changeScopeCommand = changeScopeCommand;
+exports.showCurrentUpdateSetCommand = showCurrentUpdateSetCommand;
+exports.createUpdateSetCommand = createUpdateSetCommand;
+exports.switchUpdateSetCommand = switchUpdateSetCommand;
+exports.listUpdateSetsCommand = listUpdateSetsCommand;
+const inquirer_1 = __importDefault(require("inquirer"));
+const snClient_1 = require("./snClient");
+const Logger_1 = require("./Logger");
+const commands_1 = require("./commands");
+const chalk_1 = __importDefault(require("chalk"));
+const dovetail_clickup_1 = require("@tenonhq/dovetail-clickup");
+const clickupCommands_1 = require("./clickupCommands");
+/**
+ * Shows the current scope
+ */
+async function showCurrentScopeCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    try {
+        const client = (0, snClient_1.defaultClient)();
+        const scopeObj = await (0, snClient_1.unwrapSNResponse)(client.getCurrentScope());
+        if (scopeObj && scopeObj.scope) {
+            Logger_1.logger.info(chalk_1.default.bold("\nCurrent Scope:"));
+            Logger_1.logger.info("─".repeat(40));
+            Logger_1.logger.info(chalk_1.default.green(`► ${scopeObj.displayName || scopeObj.scope}`));
+            Logger_1.logger.info(`  Scope ID: ${scopeObj.scope}`);
+            Logger_1.logger.info(`  Sys ID: ${scopeObj.sys_id}`);
+            // Also show current update set for this scope
+            const updateSet = await getCurrentUpdateSetDetails();
+            if (updateSet) {
+                Logger_1.logger.info(`  Update Set: ${updateSet.name}`);
+            }
+        }
+        else {
+            Logger_1.logger.warn("Unable to retrieve current scope information");
+        }
+    }
+    catch (e) {
+        Logger_1.logger.error("Failed to get current scope");
+        if (e instanceof Error)
+            Logger_1.logger.error(e.message);
+        throw e;
+    }
+}
+/**
+ * Changes the current scope
+ */
+async function changeScopeCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    try {
+        const client = (0, snClient_1.defaultClient)();
+        // Get scope from args or prompt
+        let scope = args.scope;
+        if (!scope) {
+            const inquirer = (await Promise.resolve().then(() => __importStar(require("inquirer")))).default;
+            const answers = await inquirer.prompt([{
+                    type: "input",
+                    name: "scope",
+                    message: "Enter scope to switch to (e.g., x_cadso_core):",
+                    validate: (input) => {
+                        if (!input || input.trim() === "") {
+                            return "Scope is required";
+                        }
+                        return true;
+                    }
+                }]);
+            scope = answers.scope;
+        }
+        Logger_1.logger.info(`Switching to scope: ${scope}`);
+        // Call the changeScope API
+        const response = await client.changeScope(scope);
+        let result = await response.data;
+        // Handle wrapped response
+        if (result && result.result) {
+            result = result.result;
+        }
+        if (result && result.message === 'Success') {
+            Logger_1.logger.success(chalk_1.default.green(`✓ Successfully switched to scope: ${scope}`));
+            // Try to get and show the current update set for this scope
+            const updateSet = await getCurrentUpdateSetDetails(scope);
+            if (updateSet) {
+                Logger_1.logger.info(`Current update set: ${updateSet.name}`);
+            }
+        }
+        else if (result && result.error) {
+            throw new Error(`Failed to switch scope: ${result.error}`);
+        }
+        else {
+            throw new Error("Failed to switch scope - unexpected response");
+        }
+    }
+    catch (e) {
+        Logger_1.logger.error("Failed to change scope");
+        if (e instanceof Error) {
+            Logger_1.logger.error(e.message);
+            if (e.response) {
+                Logger_1.logger.error(`Response status: ${e.response.status}`);
+                Logger_1.logger.error(`Response data: ${JSON.stringify(e.response.data)}`);
+            }
+        }
+        throw e;
+    }
+}
+/**
+ * Shows the current active update set
+ */
+async function showCurrentUpdateSetCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    try {
+        const client = (0, snClient_1.defaultClient)();
+        const response = await client.getCurrentUpdateSet(args.scope);
+        let result = await response.data;
+        // Handle wrapped response
+        if (result && result.result) {
+            result = result.result;
+        }
+        Logger_1.logger.debug(`API Response: ${JSON.stringify(result)}`);
+        if (result && result.sysId) {
+            Logger_1.logger.info(chalk_1.default.bold("\nCurrent Update Set:"));
+            Logger_1.logger.info("─".repeat(40));
+            Logger_1.logger.info(chalk_1.default.green(`► ${result.name || 'Unknown'}`));
+            Logger_1.logger.info(`  ID: ${result.sysId}`);
+            if (args.scope) {
+                Logger_1.logger.info(`  Scope: ${args.scope}`);
+            }
+        }
+        else if (result && result.error) {
+            Logger_1.logger.warn(`Error from API: ${result.error}`);
+        }
+        else {
+            Logger_1.logger.warn("No update set is currently active or unable to retrieve update set information");
+        }
+    }
+    catch (e) {
+        Logger_1.logger.error("Failed to get current update set");
+        if (e instanceof Error) {
+            Logger_1.logger.error(e.message);
+            if (e.response) {
+                Logger_1.logger.error(`Response status: ${e.response.status}`);
+                Logger_1.logger.error(`Response data: ${JSON.stringify(e.response.data)}`);
+            }
+        }
+        throw e;
+    }
+}
+/**
+ * Creates a new update set with the given name and switches to it
+ */
+async function createUpdateSetCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    try {
+        const client = (0, snClient_1.defaultClient)();
+        // If --clickup is provided, fetch task data and generate name/description
+        if (args.clickup && !args.name) {
+            var clickupResult = await resolveClickUpTaskForUpdateSet(args.clickup);
+            args.name = clickupResult.name;
+            if (!args.description) {
+                args.description = clickupResult.description;
+            }
+            args._clickupTaskId = clickupResult.taskId;
+        }
+        // Get update set details from user
+        const { name, description, scope } = await promptForUpdateSetDetails(args);
+        let scopeSysId;
+        if (scope) {
+            // Get scope sys_id if scope name provided
+            const scopeResult = await (0, snClient_1.unwrapSNResponse)(client.getScopeId(scope));
+            if (scopeResult.length === 0) {
+                throw new Error(`Scope "${scope}" not found`);
+            }
+            scopeSysId = scopeResult[0].sys_id;
+            // Switch to the target scope first
+            Logger_1.logger.info(`Switching to scope: ${scope}`);
+            await switchToScope(scopeSysId, scope);
+        }
+        // Create the update set in the correct scope
+        Logger_1.logger.info(`Creating update set: ${name}`);
+        const createResponse = client.createUpdateSet(name, scopeSysId, description);
+        const createResult = await (0, snClient_1.unwrapSNResponse)(createResponse);
+        const updateSetSysId = createResult.sys_id;
+        // Switch to the new update set
+        Logger_1.logger.info(`Activating update set: ${name}`);
+        try {
+            await switchToUpdateSet(updateSetSysId, name, scope);
+            Logger_1.logger.info(chalk_1.default.green(`✓ Update set "${name}" created and activated`));
+        }
+        catch (switchError) {
+            Logger_1.logger.warn(`Update set "${name}" created but could not be activated automatically`);
+            Logger_1.logger.info(`You can manually switch to it using: npx dove switchUpdateSet --name "${name}"`);
+            if (switchError instanceof Error) {
+                Logger_1.logger.warn(`Switch error: ${switchError.message}`);
+            }
+        }
+        Logger_1.logger.info(`Update Set ID: ${updateSetSysId}`);
+        if (scope) {
+            Logger_1.logger.info(`Scope: ${scope}`);
+        }
+        // If created from a ClickUp task, offer to post a comment back
+        if (args._clickupTaskId) {
+            try {
+                var token = process.env.CLICKUP_API_TOKEN;
+                if (token) {
+                    var commentAnswer = await inquirer_1.default.prompt([{
+                            type: "confirm",
+                            name: "postComment",
+                            message: "Post a comment to the ClickUp task linking this update set?",
+                            default: true,
+                        }]);
+                    if (commentAnswer.postComment) {
+                        var clickupApi = (0, dovetail_clickup_1.createClickUpApi)({ token: token });
+                        await clickupApi.addComment({
+                            taskId: args._clickupTaskId,
+                            commentText: "ServiceNow Update Set created: " + name + " (ID: " + updateSetSysId + ")",
+                        });
+                        Logger_1.logger.success(chalk_1.default.green("✓ Comment posted to ClickUp task"));
+                    }
+                }
+            }
+            catch (commentErr) {
+                Logger_1.logger.warn("Could not post comment to ClickUp task");
+                if (commentErr instanceof Error)
+                    Logger_1.logger.debug(commentErr.message);
+            }
+        }
+    }
+    catch (e) {
+        Logger_1.logger.error("Failed to create update set");
+        if (e instanceof Error)
+            Logger_1.logger.error(e.message);
+        throw e;
+    }
+}
+/**
+ * Switches to an existing update set
+ */
+async function switchUpdateSetCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    try {
+        const client = (0, snClient_1.defaultClient)();
+        // Get update set to switch to
+        const targetUpdateSet = await selectUpdateSet(args.name, args.scope);
+        if (!targetUpdateSet) {
+            throw new Error("No update set selected");
+        }
+        // Extract the actual values from display_value objects
+        const sysId = typeof targetUpdateSet.sys_id === 'object' && targetUpdateSet.sys_id !== null ? targetUpdateSet.sys_id.value : targetUpdateSet.sys_id;
+        const name = typeof targetUpdateSet.name === 'object' && targetUpdateSet.name !== null ? targetUpdateSet.name.value : targetUpdateSet.name;
+        const applicationName = (targetUpdateSet.application && targetUpdateSet.application.display_value) || (typeof targetUpdateSet.application === 'object' && targetUpdateSet.application !== null ? targetUpdateSet.application.value : targetUpdateSet.application);
+        const applicationScope = typeof targetUpdateSet.application === 'object' && targetUpdateSet.application !== null ? targetUpdateSet.application.value : targetUpdateSet.application;
+        // Switch to the selected update set
+        await switchToUpdateSet(sysId, name, args.scope || applicationScope);
+        Logger_1.logger.info(chalk_1.default.green(`✓ Switched to update set: ${name}`));
+        Logger_1.logger.info(`Update Set ID: ${sysId}`);
+        if (applicationName) {
+            Logger_1.logger.info(`Scope: ${applicationName}`);
+        }
+    }
+    catch (e) {
+        Logger_1.logger.error("Failed to switch update set");
+        if (e instanceof Error)
+            Logger_1.logger.error(e.message);
+        throw e;
+    }
+}
+/**
+ * Lists all open/in-progress update sets
+ */
+async function listUpdateSetsCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    try {
+        const client = (0, snClient_1.defaultClient)();
+        // Build query for update sets
+        let query = "state=in progress";
+        if (args.scope) {
+            // Get scope sys_id if scope name provided
+            const scopeResult = await (0, snClient_1.unwrapSNResponse)(client.getScopeId(args.scope));
+            if (scopeResult.length === 0) {
+                throw new Error(`Scope "${args.scope}" not found`);
+            }
+            query += `^application=${scopeResult[0].sys_id}`;
+        }
+        // Get list of update sets
+        const updateSets = await getUpdateSets(query);
+        if (updateSets.length === 0) {
+            Logger_1.logger.info("No in-progress update sets found");
+            return;
+        }
+        // Get current update set
+        const currentUpdateSetId = await getCurrentUpdateSetId();
+        // Display update sets
+        Logger_1.logger.info(chalk_1.default.bold("\nIn-Progress Update Sets:"));
+        Logger_1.logger.info("─".repeat(80));
+        updateSets.forEach((updateSet) => {
+            // Handle both plain values and display_value objects
+            const sysId = typeof updateSet.sys_id === 'object' && updateSet.sys_id !== null ? updateSet.sys_id.value : updateSet.sys_id;
+            const name = typeof updateSet.name === 'object' && updateSet.name !== null ? updateSet.name.value : updateSet.name;
+            const description = typeof updateSet.description === 'object' && updateSet.description !== null ? updateSet.description.value : updateSet.description;
+            const createdBy = typeof updateSet.sys_created_by === 'object' && updateSet.sys_created_by !== null ? updateSet.sys_created_by.display_value || updateSet.sys_created_by.value : updateSet.sys_created_by;
+            const applicationName = (updateSet.application && updateSet.application.display_value) || (typeof updateSet.application === 'object' && updateSet.application !== null ? updateSet.application.value : updateSet.application);
+            const isCurrent = sysId === currentUpdateSetId;
+            const marker = isCurrent ? chalk_1.default.green("► ") : "  ";
+            const displayName = isCurrent ? chalk_1.default.green(name) : name;
+            console.log(`${marker}${displayName}`);
+            if (description) {
+                console.log(`    Description: ${description}`);
+            }
+            if (applicationName) {
+                console.log(`    Scope: ${applicationName}`);
+            }
+            console.log(`    Created: ${formatDate(updateSet.sys_created_on)} by ${createdBy}`);
+            console.log(`    ID: ${sysId}`);
+            console.log("");
+        });
+        if (currentUpdateSetId) {
+            Logger_1.logger.info(chalk_1.default.dim("► indicates current active update set"));
+        }
+    }
+    catch (e) {
+        Logger_1.logger.error("Failed to list update sets");
+        if (e instanceof Error)
+            Logger_1.logger.error(e.message);
+        throw e;
+    }
+}
+/**
+ * Helper function to prompt for update set details
+ */
+async function promptForUpdateSetDetails(args) {
+    const questions = [];
+    if (!args.name) {
+        questions.push({
+            type: "input",
+            name: "name",
+            message: "Update set name:",
+            validate: (input) => {
+                if (!input || input.trim() === "") {
+                    return "Update set name is required";
+                }
+                return true;
+            }
+        });
+    }
+    if (!args.description && !args.skipDescription) {
+        questions.push({
+            type: "input",
+            name: "description",
+            message: "Description (optional):"
+        });
+    }
+    if (!args.scope && !args.skipScope) {
+        questions.push({
+            type: "input",
+            name: "scope",
+            message: "Scope (optional, e.g., x_company_app):"
+        });
+    }
+    const answers = questions.length > 0 ? await inquirer_1.default.prompt(questions) : {};
+    return {
+        name: args.name || answers.name,
+        description: args.description || answers.description,
+        scope: args.scope || answers.scope
+    };
+}
+/**
+ * Helper function to switch to an update set using the new API endpoint.
+ * Verifies the switch was successful by reading back the current update set.
+ */
+async function switchToUpdateSet(updateSetSysId, name, scope) {
+    const client = (0, snClient_1.defaultClient)();
+    Logger_1.logger.debug(`Switching to update set - sysId: ${updateSetSysId}, name: ${name}, scope: ${scope}`);
+    // Use the new changeUpdateSet endpoint
+    // Can use either sysId or name+scope combination
+    const params = {};
+    if (updateSetSysId) {
+        params.sysId = updateSetSysId;
+    }
+    if (name) {
+        params.name = name;
+    }
+    if (scope) {
+        params.scope = scope;
+    }
+    const response = await client.changeUpdateSet(params);
+    let result = await response.data;
+    // Handle wrapped response
+    if (result && result.result) {
+        result = result.result;
+    }
+    Logger_1.logger.debug(`Change update set response: ${JSON.stringify(result)}`);
+    if (result.error) {
+        throw new Error(result.error);
+    }
+    // Check if the message indicates success
+    if (result.message && !result.message.includes("Success") && !result.message.includes("changed")) {
+        throw new Error(result.message);
+    }
+    // Verify the switch was successful
+    var verified = await verifyActiveUpdateSet(client, updateSetSysId, scope);
+    if (!verified) {
+        // Retry once
+        Logger_1.logger.warn("Update set verification failed, retrying switch...");
+        var retryResponse = await client.changeUpdateSet(params);
+        var retryResult = await retryResponse.data;
+        if (retryResult && retryResult.result) {
+            retryResult = retryResult.result;
+        }
+        if (retryResult.error) {
+            throw new Error(retryResult.error);
+        }
+        var retryVerified = await verifyActiveUpdateSet(client, updateSetSysId, scope);
+        if (!retryVerified) {
+            var currentName = await getActiveUpdateSetName(client, scope);
+            throw new Error("Update set " + (name || updateSetSysId) + " was created but could not be activated. Current update set is " + (currentName || "unknown") + ".");
+        }
+    }
+}
+/**
+ * Verifies the currently active update set matches the expected sys_id.
+ */
+async function verifyActiveUpdateSet(client, expectedSysId, scope) {
+    try {
+        var response = await client.getCurrentUpdateSet(scope);
+        var result = await response.data;
+        if (result && result.result) {
+            result = result.result;
+        }
+        if (result && result.sysId === expectedSysId) {
+            return true;
+        }
+        Logger_1.logger.warn("Verification mismatch: expected " + expectedSysId + ", got " + (result && result.sysId ? result.sysId : "null"));
+        return false;
+    }
+    catch (e) {
+        Logger_1.logger.warn("Verification check failed: " + (e instanceof Error ? e.message : String(e)));
+        return false;
+    }
+}
+/**
+ * Gets the name of the currently active update set for error messages.
+ */
+async function getActiveUpdateSetName(client, scope) {
+    try {
+        var response = await client.getCurrentUpdateSet(scope);
+        var result = await response.data;
+        if (result && result.result) {
+            result = result.result;
+        }
+        return (result && result.name) ? result.name : null;
+    }
+    catch (e) {
+        return null;
+    }
+}
+/**
+ * Helper function to switch to a scope
+ */
+async function switchToScope(scopeSysId, scopeName) {
+    const client = (0, snClient_1.defaultClient)();
+    // Get current user sys_id
+    const userSysId = await (0, snClient_1.unwrapTableAPIFirstItem)(client.getUserSysId(), "sys_id");
+    // Get or create user preference for current app
+    try {
+        const curAppUserPrefId = await (0, snClient_1.unwrapTableAPIFirstItem)(client.getCurrentAppUserPrefSysId(userSysId), "sys_id");
+        // Update existing preference
+        await client.updateCurrentAppUserPref(scopeSysId, curAppUserPrefId);
+    }
+    catch (e) {
+        // Create new preference if it doesn't exist
+        await client.createCurrentAppUserPref(scopeSysId, userSysId);
+    }
+    Logger_1.logger.info(`Switched to scope: ${scopeName}`);
+}
+/**
+ * Helper function to get update sets based on query
+ */
+async function getUpdateSets(query) {
+    const client = (0, snClient_1.defaultClient)();
+    const endpoint = "api/now/table/sys_update_set";
+    const response = client.client.get(endpoint, {
+        params: {
+            sysparm_query: query,
+            sysparm_fields: "sys_id,name,description,state,application,application.name,sys_created_on,sys_created_by",
+            sysparm_limit: 100,
+            sysparm_display_value: "all"
+        }
+    });
+    return (0, snClient_1.unwrapSNResponse)(response);
+}
+/**
+ * Helper function to get current update set ID using the new endpoint
+ */
+async function getCurrentUpdateSetId(scope) {
+    try {
+        const client = (0, snClient_1.defaultClient)();
+        const response = await client.getCurrentUpdateSet(scope);
+        let result = await response.data;
+        // Handle wrapped response
+        if (result && result.result) {
+            result = result.result;
+        }
+        if (result && result.sysId) {
+            return result.sysId;
+        }
+        return null;
+    }
+    catch (e) {
+        return null;
+    }
+}
+/**
+ * Helper function to get current update set details
+ */
+async function getCurrentUpdateSetDetails(scope) {
+    try {
+        const client = (0, snClient_1.defaultClient)();
+        const response = await client.getCurrentUpdateSet(scope);
+        let result = await response.data;
+        // Handle wrapped response
+        if (result && result.result) {
+            result = result.result;
+        }
+        if (result && result.sysId) {
+            return {
+                sysId: result.sysId,
+                name: result.name || 'Unknown'
+            };
+        }
+        return null;
+    }
+    catch (e) {
+        return null;
+    }
+}
+/**
+ * Helper function to select an update set from a list
+ */
+async function selectUpdateSet(nameFilter, scopeFilter) {
+    let query = "state=in progress";
+    if (scopeFilter) {
+        const client = (0, snClient_1.defaultClient)();
+        const scopeResult = await (0, snClient_1.unwrapSNResponse)(client.getScopeId(scopeFilter));
+        if (scopeResult.length === 0) {
+            Logger_1.logger.error(`Scope "${scopeFilter}" not found`);
+            return null;
+        }
+        query += `^application=${scopeResult[0].sys_id}`;
+    }
+    const updateSets = await getUpdateSets(query);
+    if (updateSets.length === 0) {
+        Logger_1.logger.info("No in-progress update sets found");
+        return null;
+    }
+    // Filter by name if provided
+    let filteredSets = updateSets;
+    if (nameFilter) {
+        filteredSets = updateSets.filter(us => {
+            const name = typeof us.name === 'object' && us.name !== null ? us.name.value : us.name;
+            return name.toLowerCase().includes(nameFilter.toLowerCase());
+        });
+        if (filteredSets.length === 0) {
+            Logger_1.logger.error(`No update sets found matching "${nameFilter}"`);
+            return null;
+        }
+        // If exact match found, use it
+        const exactMatch = filteredSets.find(us => {
+            const name = typeof us.name === 'object' && us.name !== null ? us.name.value : us.name;
+            return name.toLowerCase() === nameFilter.toLowerCase();
+        });
+        if (exactMatch) {
+            return exactMatch;
+        }
+        // If only one match, use it
+        if (filteredSets.length === 1) {
+            return filteredSets[0];
+        }
+    }
+    // Prompt user to select from list
+    const choices = filteredSets.map(us => {
+        const name = typeof us.name === 'object' && us.name !== null ? us.name.value : us.name;
+        const description = typeof us.description === 'object' && us.description !== null ? us.description.value : us.description;
+        const applicationName = (us.application && us.application.display_value) || (typeof us.application === 'object' && us.application !== null ? us.application.value : us.application);
+        return {
+            name: `${name}${applicationName ? ` (${applicationName})` : ""} - ${description || "No description"}`,
+            value: us
+        };
+    });
+    const { selectedUpdateSet } = await inquirer_1.default.prompt([
+        {
+            type: "list",
+            name: "selectedUpdateSet",
+            message: "Select an update set:",
+            choices,
+            pageSize: 15
+        }
+    ]);
+    return selectedUpdateSet;
+}
+/**
+ * Helper function to format date
+ */
+/**
+ * Resolves a ClickUp task identifier into an update set name and description.
+ * Uses Claude CLI for name refinement with convention-based fallback.
+ */
+async function resolveClickUpTaskForUpdateSet(clickupIdentifier) {
+    var token = process.env.CLICKUP_API_TOKEN;
+    if (!token || token === "") {
+        throw new Error("CLICKUP_API_TOKEN not set. Run 'dove clickup setup' or add it to your .env file.");
+    }
+    var parsed = (0, dovetail_clickup_1.parseClickUpIdentifier)(clickupIdentifier);
+    Logger_1.logger.info("Fetching ClickUp task: " + parsed.taskId + "...");
+    var api = (0, dovetail_clickup_1.createClickUpApi)({ token: token });
+    var task = await api.getTask({ taskId: parsed.taskId });
+    Logger_1.logger.success(chalk_1.default.green('✓ Found: "' + task.name + '"'));
+    Logger_1.logger.info("");
+    // Generate update set name via Claude CLI (with fallback)
+    Logger_1.logger.info("Generating update set name...");
+    var suggestedName = (0, clickupCommands_1.refineUpdateSetName)({
+        taskName: task.name,
+        taskId: task.id,
+        taskDescription: task.description || "",
+    });
+    Logger_1.logger.success(chalk_1.default.green('✓ Suggested name: "' + suggestedName + '"'));
+    // Generate description from task summary
+    var suggestedDescription = (0, dovetail_clickup_1.formatTaskSummary)({ task: task });
+    // Let user confirm or edit
+    var confirmAnswers = await inquirer_1.default.prompt([
+        {
+            type: "input",
+            name: "name",
+            message: "Update set name:",
+            default: suggestedName,
+            validate: function (input) {
+                if (!input || input.trim() === "")
+                    return "Name is required";
+                return true;
+            },
+        },
+        {
+            type: "input",
+            name: "description",
+            message: "Description:",
+            default: suggestedDescription,
+        },
+    ]);
+    return {
+        name: confirmAnswers.name,
+        description: confirmAnswers.description,
+        taskId: parsed.taskId,
+    };
+}
+function formatDate(dateString) {
+    try {
+        const actualDateString = typeof dateString === 'object' && dateString !== null ? dateString.display_value || dateString.value : dateString;
+        const date = new Date(actualDateString);
+        if (isNaN(date.getTime())) {
+            return actualDateString || "Unknown";
+        }
+        return `${date.toLocaleDateString()} ${date.toLocaleTimeString()}`;
+    }
+    catch (e) {
+        return typeof dateString === 'string' ? dateString : "Unknown";
+    }
+}