@tenonhq/dovetail-core 0.0.85

package/dist/clickupPushHelper.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveClickUpForPush = resolveClickUpForPush;
+const dovetail_clickup_1 = require("@tenonhq/dovetail-clickup");
+const clickupCommands_1 = require("./clickupCommands");
+const Logger_1 = require("./Logger");
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * @description Resolves a ClickUp task identifier into an update set name for the push command.
+ * @param clickupIdentifier - A ClickUp task ID or URL.
+ * @returns The resolved update set name.
+ */
+async function resolveClickUpForPush(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 + '"'));
+    var name = (0, clickupCommands_1.refineUpdateSetName)({
+        taskName: task.name,
+        taskId: task.id,
+        taskDescription: task.description || "",
+    });
+    Logger_1.logger.success(chalk_1.default.green('✓ Update set name: "' + name + '"'));
+    return name;
+}

package/dist/commander.js

@@ -0,0 +1,466 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommands = initCommands;
+const commands_1 = require("./commands");
+const allScopesCommands_1 = require("./allScopesCommands");
+const updateSetCommands_1 = require("./updateSetCommands");
+const dashboardCommand_1 = require("./dashboardCommand");
+const schemaCommand_1 = require("./schemaCommand");
+const claudeCommand_1 = require("./claudeCommand");
+const createRecordCommand_1 = require("./createRecordCommand");
+const deleteRecordCommand_1 = require("./deleteRecordCommand");
+const migrateCommand_1 = require("./migrateCommand");
+const clickupCommands_1 = require("./clickupCommands");
+const loginCommand_1 = require("./loginCommand");
+const yargs_1 = __importDefault(require("yargs"));
+async function initCommands() {
+    const sharedOptions = {
+        logLevel: {
+            default: "info",
+        },
+    };
+    yargs_1.default
+        .command(["watch", "w", "watchAllScopes"], "Watch all scopes for file changes and sync to ServiceNow", (cmdArgs) => {
+        cmdArgs.options({
+            ...sharedOptions,
+            noDashboard: {
+                type: "boolean",
+                default: false,
+                describe: "Skip launching the dashboard web UI",
+            },
+            port: {
+                alias: "p",
+                type: "number",
+                describe: "Dashboard port (default: DASHBOARD_PORT env or 3456)",
+            },
+            monitorInterval: {
+                type: "number",
+                default: 120,
+                describe: "Update set monitoring interval in seconds (default: 120)",
+            },
+            noMonitoring: {
+                type: "boolean",
+                default: false,
+                describe: "Disable background update set monitoring",
+            },
+        });
+        return cmdArgs;
+    }, async (args) => {
+        await (0, allScopesCommands_1.watchAllScopesCommand)(args);
+    })
+        .command(["refresh", "r"], "Pull latest manifest and file contents from the ServiceNow instance", (cmdArgs) => {
+        cmdArgs.options({
+            ...sharedOptions,
+            force: {
+                alias: "f",
+                type: "boolean",
+                default: false,
+                describe: "Overwrite local files even when content matches the instance",
+            },
+            scope: {
+                alias: "s",
+                type: "string",
+                describe: "Refresh a single scope (default: all declared scopes)",
+            },
+            benchmark: {
+                alias: "b",
+                type: "boolean",
+                default: false,
+                describe: "Log per-scope and aggregate HTTP latency, bytes, and file counts",
+            },
+        });
+        return cmdArgs;
+    }, async (args) => {
+        await (0, commands_1.refreshCommand)(args);
+    })
+        .command(["push [target]"], "[DESTRUCTIVE] Push all files from current local files to ServiceNow instance.", (cmdArgs) => {
+        cmdArgs.options({
+            ...sharedOptions,
+            diff: {
+                alias: "d",
+                type: "string",
+                default: "",
+                describe: "Specify branch to do git diff against",
+            },
+            updateSet: {
+                alias: "us",
+                type: "string",
+                default: "",
+                describe: "Will create a new update set with the provided anme to store all changes into",
+            },
+            clickup: {
+                alias: "cu",
+                type: "string",
+                describe: "ClickUp task ID or URL — creates update set from ClickUp task data",
+            },
+            ci: {
+                type: "boolean",
+                default: false,
+                describe: "Will skip confirmation prompts during the push process",
+            },
+        });
+        return cmdArgs;
+    }, async (args) => {
+        await (0, commands_1.pushCommand)(args);
+    })
+        .command("download <scope>", "Downloads a scoped application's files from ServiceNow. Must specify a scope prefix for a scoped app.", sharedOptions, async (args) => {
+        await (0, commands_1.downloadCommand)(args);
+    })
+        .command("init", "Set up Dovetail — discovers installed packages, authenticates, and configures your project", sharedOptions, commands_1.initCommand)
+        .command("login [plugin]", "Authenticate with ServiceNow and other integrations", function (cmdArgs) {
+        cmdArgs.positional("plugin", {
+            describe: "Plugin name to login (e.g., clickup). Omit for ServiceNow only.",
+            type: "string",
+        });
+        cmdArgs.options({
+            ...sharedOptions,
+            all: {
+                type: "boolean",
+                default: false,
+                describe: "Login to all detected integrations",
+            },
+            instance: {
+                type: "string",
+                describe: "ServiceNow instance URL (non-interactive)",
+            },
+            user: {
+                type: "string",
+                describe: "ServiceNow username (non-interactive)",
+            },
+            password: {
+                type: "string",
+                describe: "ServiceNow password (non-interactive)",
+            },
+        });
+        return cmdArgs;
+    }, loginCommand_1.loginCommand)
+        .command("initScopes", "Provisions an initial project for the scopes defined in the config", {
+        ...sharedOptions,
+        delay: {
+            alias: "d",
+            type: "number",
+            default: 0,
+            describe: "Delay in milliseconds between API calls (to prevent server overload)",
+        },
+    }, allScopesCommands_1.initScopesCommand)
+        .command("build", "Build application files locally", (cmdArgs) => {
+        cmdArgs.options({
+            ...sharedOptions,
+            diff: {
+                alias: "d",
+                type: "string",
+                default: "",
+                describe: "Specify branch to do git diff against",
+            },
+        });
+        return cmdArgs;
+    }, async (args) => {
+        await (0, commands_1.buildCommand)(args);
+    })
+        .command("deploy", "Deploy local build files to the scoped application", sharedOptions, commands_1.deployCommand)
+        .command("create <table>", "Create a new record on the ServiceNow instance", (cmdArgs) => {
+        cmdArgs.positional("table", {
+            describe: "ServiceNow table name (e.g., sys_script_include)",
+            type: "string",
+        });
+        cmdArgs.options({
+            ...sharedOptions,
+            name: {
+                alias: "n",
+                type: "string",
+                describe: "Record name",
+            },
+            scope: {
+                alias: "s",
+                type: "string",
+                describe: "Target scope (e.g., x_cadso_core)",
+            },
+            from: {
+                alias: "f",
+                type: "string",
+                describe: "Path to JSON file with field values",
+            },
+            field: {
+                type: "array",
+                describe: "Field values as key=value pairs (e.g., --field active=true)",
+            },
+            ci: {
+                type: "boolean",
+                default: false,
+                describe: "Skip interactive prompts",
+            },
+        });
+        return cmdArgs;
+    }, createRecordCommand_1.createRecordCommand)
+        .command("delete <table> [name]", "Delete a record from the ServiceNow instance", (cmdArgs) => {
+        cmdArgs.positional("table", {
+            describe: "ServiceNow table name (e.g., sys_script_include)",
+            type: "string",
+        });
+        cmdArgs.positional("name", {
+            describe: "Record name to delete",
+            type: "string",
+        });
+        cmdArgs.options({
+            ...sharedOptions,
+            scope: {
+                alias: "s",
+                type: "string",
+                describe: "Target scope (e.g., x_cadso_core)",
+            },
+            sysid: {
+                type: "string",
+                describe: "Delete by sys_id directly (skip manifest lookup)",
+            },
+            ci: {
+                type: "boolean",
+                default: false,
+                describe: "Skip confirmation prompt",
+            },
+            keepLocal: {
+                type: "boolean",
+                default: false,
+                describe: "Keep local files after deleting from instance",
+            },
+        });
+        return cmdArgs;
+    }, deleteRecordCommand_1.deleteRecordCommand)
+        .command("status", "Get information about the connected instance", sharedOptions, commands_1.statusCommand)
+        .command("createUpdateSet", "Create a new update set and switch to it", (cmdArgs) => {
+        cmdArgs.options({
+            ...sharedOptions,
+            name: {
+                alias: "n",
+                type: "string",
+                describe: "Name of the update set to create",
+            },
+            description: {
+                alias: "d",
+                type: "string",
+                describe: "Description of the update set",
+            },
+            scope: {
+                alias: "s",
+                type: "string",
+                describe: "Scope for the update set (e.g., x_company_app)",
+            },
+            skipDescription: {
+                type: "boolean",
+                default: false,
+                describe: "Skip prompting for description",
+            },
+            skipScope: {
+                type: "boolean",
+                default: false,
+                describe: "Skip prompting for scope",
+            },
+            clickup: {
+                alias: "cu",
+                type: "string",
+                describe: "ClickUp task ID or URL to generate update set name and description from",
+            },
+        });
+        return cmdArgs;
+    }, updateSetCommands_1.createUpdateSetCommand)
+        .command("switchUpdateSet", "Switch to an existing update set", (cmdArgs) => {
+        cmdArgs.options({
+            ...sharedOptions,
+            name: {
+                alias: "n",
+                type: "string",
+                describe: "Name or partial name of the update set to switch to",
+            },
+            scope: {
+                alias: "s",
+                type: "string",
+                describe: "Filter update sets by scope",
+            },
+        });
+        return cmdArgs;
+    }, updateSetCommands_1.switchUpdateSetCommand)
+        .command("listUpdateSets", "List all in-progress update sets", (cmdArgs) => {
+        cmdArgs.options({
+            ...sharedOptions,
+            scope: {
+                alias: "s",
+                type: "string",
+                describe: "Filter update sets by scope",
+            },
+        });
+        return cmdArgs;
+    }, updateSetCommands_1.listUpdateSetsCommand)
+        .command("currentUpdateSet", "Show the current active update set", (cmdArgs) => {
+        cmdArgs.options({
+            ...sharedOptions,
+            scope: {
+                alias: "s",
+                type: "string",
+                describe: "Scope to check update set for",
+            },
+        });
+        return cmdArgs;
+    }, updateSetCommands_1.showCurrentUpdateSetCommand)
+        .command("changeScope", "Change to a different scope", (cmdArgs) => {
+        cmdArgs.options({
+            ...sharedOptions,
+            scope: {
+                alias: "s",
+                type: "string",
+                describe: "Scope to switch to (e.g., x_cadso_core)",
+            },
+        });
+        return cmdArgs;
+    }, updateSetCommands_1.changeScopeCommand)
+        .command("currentScope", "Show the current active scope", (cmdArgs) => {
+        cmdArgs.options({
+            ...sharedOptions,
+        });
+        return cmdArgs;
+    }, updateSetCommands_1.showCurrentScopeCommand)
+        .command("dashboard", "Launch the Update Set Dashboard web UI", (cmdArgs) => {
+        cmdArgs.options({
+            ...sharedOptions,
+            port: {
+                alias: "p",
+                type: "number",
+                describe: "Dashboard port (default: DASHBOARD_PORT env or 3456)",
+            },
+        });
+        return cmdArgs;
+    }, async (args) => {
+        await (0, dashboardCommand_1.dashboardCommand)(args);
+    })
+        .command("schema <subcommand>", "Manage ServiceNow table schemas (subcommands: pull)", (cmdArgs) => {
+        cmdArgs.positional("subcommand", {
+            describe: "Schema subcommand to run",
+            choices: ["pull"],
+        });
+        cmdArgs.options({
+            ...sharedOptions,
+            output: {
+                alias: "o",
+                type: "string",
+                describe: "Output directory for schema files (default: schema/)",
+            },
+            scope: {
+                alias: "s",
+                type: "string",
+                describe: "Pull schema for a single scope (default: all scopes from dove.config.js)",
+            },
+        });
+        return cmdArgs;
+    }, async (args) => {
+        if (args.subcommand === "pull") {
+            await (0, schemaCommand_1.schemaPullCommand)(args);
+        }
+    })
+        .command("init-claude", "Install Dovetail Claude Code skills to .claude/commands/", (cmdArgs) => {
+        cmdArgs.options({
+            ...sharedOptions,
+            force: {
+                alias: "f",
+                type: "boolean",
+                default: false,
+                describe: "Overwrite existing skill files",
+            },
+        });
+        return cmdArgs;
+    }, async (args) => {
+        await (0, claudeCommand_1.initClaudeCommand)(args);
+    })
+        .command("clickup", "ClickUp task management commands", function (cmdArgs) {
+        return cmdArgs
+            .command("tasks", "List my tasks grouped by status", function (sub) {
+            sub.options({
+                ...sharedOptions,
+                team: {
+                    type: "string",
+                    describe: "ClickUp team/workspace ID",
+                },
+                status: {
+                    type: "array",
+                    describe: "Filter by status(es)",
+                },
+            });
+            return sub;
+        }, clickupCommands_1.clickupTasksCommand)
+            .command("task <id>", "Get task details", function (sub) {
+            sub.positional("id", {
+                describe: "ClickUp task ID or URL",
+                type: "string",
+            });
+            sub.options(sharedOptions);
+            return sub;
+        }, clickupCommands_1.clickupTaskCommand)
+            .command("create <list-id>", "Create a task (interactive)", function (sub) {
+            sub.positional("listId", {
+                describe: "ClickUp list ID to create the task in",
+                type: "string",
+            });
+            sub.options(sharedOptions);
+            return sub;
+        }, clickupCommands_1.clickupCreateCommand)
+            .command("update <task-id>", "Update a task (interactive)", function (sub) {
+            sub.positional("taskId", {
+                describe: "ClickUp task ID or URL",
+                type: "string",
+            });
+            sub.options(sharedOptions);
+            return sub;
+        }, clickupCommands_1.clickupUpdateCommand)
+            .command("comment <task-id> <msg>", "Add comment to task", function (sub) {
+            sub.positional("taskId", {
+                describe: "ClickUp task ID or URL",
+                type: "string",
+            });
+            sub.positional("msg", {
+                describe: "Comment message",
+                type: "string",
+            });
+            sub.options(sharedOptions);
+            return sub;
+        }, clickupCommands_1.clickupCommentCommand)
+            .command("teams", "List workspaces/teams your token belongs to", sharedOptions, clickupCommands_1.clickupTeamsCommand)
+            .command("setup", "Configure ClickUp API token and default workspace", sharedOptions, clickupCommands_1.clickupSetupCommand)
+            .command("spaces", "List available spaces in a workspace", function (sub) {
+            sub.options({
+                ...sharedOptions,
+                team: {
+                    type: "string",
+                    describe: "ClickUp team/workspace ID",
+                },
+            });
+            return sub;
+        }, clickupCommands_1.clickupSpacesCommand)
+            .command("lists <space-or-folder>", "List available lists in a folder or space", function (sub) {
+            sub.positional("spaceOrFolder", {
+                describe: "Space ID or folder ID",
+                type: "string",
+            });
+            sub.options(sharedOptions);
+            return sub;
+        }, clickupCommands_1.clickupListsCommand)
+            .demandCommand(1, "Please specify a clickup subcommand");
+    }, function () {
+        /* subcommands handle execution */
+    })
+        .command("migrate", "Migrate a project from Sincronia to Dovetail (renames sinc.* artifacts, updates package.json deps and scripts)", {
+        ...sharedOptions,
+        apply: {
+            type: "boolean",
+            default: false,
+            describe: "Actually perform the migration. Without this flag, only the plan is printed.",
+        },
+    }, migrateCommand_1.migrateCommand)
+        .command("task", "Manage the active ClickUp task for update set routing", function (cmdArgs) {
+        return cmdArgs
+            .command("clear", "Clear the active task (removes .dove-active-task.json)", sharedOptions, commands_1.taskClearCommand)
+            .demandCommand(1, "Please specify a task subcommand (e.g., clear)");
+    }, function () {
+        /* subcommands handle execution */
+    })
+        .help().argv;
+}