@tenonhq/dovetail-core 0.0.85

package/dist/commands.js

@@ -0,0 +1,378 @@
+"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.setLogLevel = setLogLevel;
+exports.refreshCommand = refreshCommand;
+exports.pushCommand = pushCommand;
+exports.downloadCommand = downloadCommand;
+exports.initCommand = initCommand;
+exports.buildCommand = buildCommand;
+exports.deployCommand = deployCommand;
+exports.taskClearCommand = taskClearCommand;
+exports.statusCommand = statusCommand;
+const ConfigManager = __importStar(require("./config"));
+const AppUtils = __importStar(require("./appUtils"));
+const orchestrator_1 = require("./initSystem/orchestrator");
+const Logger_1 = require("./Logger");
+const FileLogger_1 = require("./FileLogger");
+const logMessages_1 = require("./logMessages");
+const snClient_1 = require("./snClient");
+const inquirer_1 = __importDefault(require("inquirer"));
+const gitUtils_1 = require("./gitUtils");
+const FileUtils_1 = require("./FileUtils");
+const projectFiles_1 = require("./projectFiles");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+function setLogLevel(args) {
+    Logger_1.logger.setLogLevel(args.logLevel);
+}
+async function refreshCommand(args, log = true) {
+    setLogLevel(args);
+    try {
+        if (!log)
+            setLogLevel({ logLevel: "warn" });
+        FileLogger_1.fileLogger.debug("Syncing manifest from instance (force=" + !!args.force + ", benchmark=" + !!args.benchmark + ")");
+        await AppUtils.syncManifest(args.scope, {
+            force: !!args.force,
+            benchmark: !!args.benchmark,
+        });
+        Logger_1.logger.success("Refresh complete!");
+        setLogLevel(args);
+    }
+    catch (e) {
+        throw e;
+    }
+}
+async function pushCommand(args) {
+    setLogLevel(args);
+    try {
+        const { updateSet, ci: skipPrompt, target, diff } = args;
+        let encodedPaths;
+        if (target !== undefined && target !== "")
+            encodedPaths = target;
+        else
+            encodedPaths = await (0, gitUtils_1.gitDiffToEncodedPaths)(diff);
+        const fileList = await AppUtils.getAppFileList(encodedPaths);
+        const instance = process.env.SN_INSTANCE || "unknown";
+        Logger_1.logger.info(fileList.length + " files to push to " + instance);
+        if (!skipPrompt) {
+            const targetServer = process.env.SN_INSTANCE;
+            if (!targetServer) {
+                Logger_1.logger.error("No SN_INSTANCE configured. Set it in your .env file.");
+                return;
+            }
+            const answers = await inquirer_1.default.prompt([
+                {
+                    type: "confirm",
+                    name: "confirmed",
+                    message: "Pushing will overwrite code in your instance. Are you sure?",
+                    default: false,
+                },
+            ]);
+            if (!answers["confirmed"])
+                return;
+        }
+        // Handle --clickup flag: resolve ClickUp task into an update set name
+        let resolvedUpdateSet = updateSet;
+        if (!resolvedUpdateSet && args.clickup) {
+            try {
+                const { resolveClickUpForPush } = await Promise.resolve().then(() => __importStar(require("./clickupPushHelper")));
+                resolvedUpdateSet = await resolveClickUpForPush(args.clickup);
+            }
+            catch (cuErr) {
+                if (cuErr instanceof Error)
+                    Logger_1.logger.error(cuErr.message);
+                process.exit(1);
+            }
+        }
+        // Extract scope from file list and auto-swap to it
+        var pushScope;
+        if (fileList.length > 0) {
+            var fieldKeys = Object.keys(fileList[0].fields);
+            if (fieldKeys.length > 0) {
+                pushScope = fileList[0].fields[fieldKeys[0]].scope;
+            }
+        }
+        if (pushScope) {
+            try {
+                var client = (0, snClient_1.defaultClient)();
+                await client.changeScope(pushScope);
+                Logger_1.logger.info("Switched to scope: " + pushScope);
+            }
+            catch (scopeErr) {
+                Logger_1.logger.warn("Could not auto-switch scope: " + scopeErr);
+            }
+        }
+        // Does not create update set if updateSetName is blank
+        if (resolvedUpdateSet) {
+            if (!skipPrompt) {
+                let answers = await inquirer_1.default.prompt([
+                    {
+                        type: "confirm",
+                        name: "confirmed",
+                        message: `A new Update Set "${resolvedUpdateSet}" will be created for these pushed changes. Do you want to proceed?`,
+                        default: false,
+                    },
+                ]);
+                if (!answers["confirmed"]) {
+                    process.exit(0);
+                }
+            }
+            const newUpdateSet = await AppUtils.createAndAssignUpdateSet(resolvedUpdateSet, pushScope);
+            Logger_1.logger.debug(`New Update Set Created(${newUpdateSet.name}) sys_id:${newUpdateSet.id}`);
+        }
+        const pushResults = await AppUtils.pushFiles(fileList);
+        (0, logMessages_1.logPushResults)(pushResults);
+    }
+    catch (e) {
+        Logger_1.logger.getInternalLogger().error(e);
+        process.exit(1);
+    }
+}
+async function downloadCommand(args) {
+    setLogLevel(args);
+    try {
+        let answers = await inquirer_1.default.prompt([
+            {
+                type: "confirm",
+                name: "confirmed",
+                message: "Downloading will overwrite manifest and files. Are you sure?",
+                default: false,
+            },
+        ]);
+        if (!answers["confirmed"]) {
+            return;
+        }
+        const instance = process.env.SN_INSTANCE || "unknown";
+        Logger_1.logger.info("Downloading from " + instance + " (scope: " + (args.scope || "default") + ")...");
+        const client = (0, snClient_1.defaultClient)();
+        const config = ConfigManager.getConfig();
+        // Resolve config for this scope (strips _ directives for API, provides table whitelist)
+        var resolved = ConfigManager.resolveConfigForScope(args.scope);
+        var apiConfig = Object.assign({}, config, {
+            includes: resolved.apiIncludes,
+            excludes: resolved.apiExcludes,
+        });
+        const man = await (0, snClient_1.unwrapSNResponse)(client.getManifest(args.scope, apiConfig, true));
+        // Client-side table filtering — only keep tables in the _tables whitelist
+        if (resolved.tables && resolved.tables.length > 0) {
+            var allTableNames = Object.keys(man.tables || {});
+            var filtered = {};
+            for (var i = 0; i < allTableNames.length; i++) {
+                if (resolved.tables.indexOf(allTableNames[i]) !== -1) {
+                    filtered[allTableNames[i]] = man.tables[allTableNames[i]];
+                }
+            }
+            var filteredOut = allTableNames.length - Object.keys(filtered).length;
+            if (filteredOut > 0) {
+                Logger_1.logger.info("Filtered " + filteredOut + " tables not in _tables whitelist");
+            }
+            man.tables = filtered;
+        }
+        const tableCount = Object.keys(man.tables).length;
+        var recordCount = 0;
+        Object.keys(man.tables).forEach(function (tableName) {
+            recordCount += Object.keys(man.tables[tableName].records).length;
+        });
+        Logger_1.logger.info("Received " + tableCount + " tables, " + recordCount + " records");
+        FileLogger_1.fileLogger.debug("Download manifest: " + tableCount + " tables, " + recordCount + " records");
+        await AppUtils.processManifest(man, true);
+        Logger_1.logger.success("Download complete — " + recordCount + " records written");
+    }
+    catch (e) {
+        throw e;
+    }
+}
+async function initCommand(args) {
+    setLogLevel(args);
+    try {
+        await (0, orchestrator_1.runInit)({ logLevel: args.logLevel });
+    }
+    catch (e) {
+        throw e;
+    }
+}
+async function buildCommand(args) {
+    setLogLevel(args);
+    try {
+        const encodedPaths = await (0, gitUtils_1.gitDiffToEncodedPaths)(args.diff);
+        const fileList = await AppUtils.getAppFileList(encodedPaths);
+        Logger_1.logger.info(`${fileList.length} files to build.`);
+        const results = await AppUtils.buildFiles(fileList);
+        (0, logMessages_1.logBuildResults)(results);
+    }
+    catch (e) {
+        process.exit(1);
+    }
+}
+async function getDeployPaths() {
+    let changedPaths = [];
+    try {
+        changedPaths = ConfigManager.getDiffFile().changed || [];
+    }
+    catch (e) { }
+    if (changedPaths.length > 0) {
+        const { confirmed } = await inquirer_1.default.prompt([
+            {
+                type: "confirm",
+                name: "confirmed",
+                message: "Would you like to deploy only files changed in your diff file?",
+                default: false,
+            },
+        ]);
+        if (confirmed)
+            return changedPaths;
+    }
+    return (0, FileUtils_1.encodedPathsToFilePaths)(ConfigManager.getBuildPath());
+}
+async function deployCommand(args) {
+    setLogLevel(args);
+    try {
+        const targetServer = process.env.SN_INSTANCE || "";
+        if (!targetServer) {
+            Logger_1.logger.error("No SN_INSTANCE configured. Set it in your .env file.");
+            return;
+        }
+        const { confirmed } = await inquirer_1.default.prompt([
+            {
+                type: "confirm",
+                name: "confirmed",
+                message: "Deploying will overwrite code in your instance. Are you sure?",
+                default: false,
+            },
+        ]);
+        if (!confirmed) {
+            return;
+        }
+        const paths = await getDeployPaths();
+        Logger_1.logger.silly(`${paths.length} paths found...`);
+        Logger_1.logger.silly(JSON.stringify(paths, null, 2));
+        const appFileList = await AppUtils.getAppFileList(paths);
+        // Auto-swap to scope detected from files
+        if (appFileList.length > 0) {
+            var fieldKeys = Object.keys(appFileList[0].fields);
+            if (fieldKeys.length > 0) {
+                var deployScope = appFileList[0].fields[fieldKeys[0]].scope;
+                if (deployScope) {
+                    try {
+                        var client = (0, snClient_1.defaultClient)();
+                        await client.changeScope(deployScope);
+                        Logger_1.logger.info("Switched to scope: " + deployScope);
+                    }
+                    catch (scopeErr) {
+                        Logger_1.logger.warn("Could not auto-switch scope: " + scopeErr);
+                    }
+                }
+            }
+        }
+        const pushResults = await AppUtils.pushFiles(appFileList);
+        (0, logMessages_1.logPushResults)(pushResults);
+    }
+    catch (e) {
+        throw e;
+    }
+}
+async function taskClearCommand(args) {
+    setLogLevel(args);
+    var taskPath = (0, projectFiles_1.getActiveTaskPath)();
+    // Always sweep both filenames so a clear leaves no stale state behind.
+    var legacyTaskPath = path.resolve(process.cwd(), ".sinc-active-task.json");
+    var newTaskPath = path.resolve(process.cwd(), ".dove-active-task.json");
+    if (fs.existsSync(taskPath)) {
+        try {
+            var parsed = JSON.parse(fs.readFileSync(taskPath, "utf8"));
+            var taskName = parsed.taskName || parsed.taskId || "unknown";
+            [newTaskPath, legacyTaskPath].forEach(function (p) {
+                if (fs.existsSync(p))
+                    fs.unlinkSync(p);
+            });
+            Logger_1.logger.success("Active task '" + taskName + "' cleared.");
+        }
+        catch (e) {
+            // File exists but can't be parsed — still remove it
+            [newTaskPath, legacyTaskPath].forEach(function (p) {
+                if (fs.existsSync(p))
+                    fs.unlinkSync(p);
+            });
+            Logger_1.logger.success("Active task file removed.");
+        }
+    }
+    else {
+        Logger_1.logger.info("No active task is currently set.");
+    }
+}
+async function statusCommand() {
+    try {
+        const client = (0, snClient_1.defaultClient)();
+        var config = ConfigManager.getConfig();
+        let scopeObj = await (0, snClient_1.unwrapSNResponse)(client.getCurrentScope());
+        Logger_1.logger.info("Instance:      " + (process.env.SN_INSTANCE || "not set"));
+        Logger_1.logger.info("User:          " + (process.env.SN_USER || "not set"));
+        Logger_1.logger.info("Active scope:  " + scopeObj.scope);
+        // Read update set config
+        var updateSetConfig = {};
+        var updateSetConfigPath = (0, projectFiles_1.getUpdateSetsConfigPath)();
+        try {
+            if (fs.existsSync(updateSetConfigPath)) {
+                updateSetConfig = JSON.parse(fs.readFileSync(updateSetConfigPath, "utf8"));
+            }
+        }
+        catch (e) {
+            Logger_1.logger.warn("Failed to parse update-sets config at " + updateSetConfigPath + ": " + (e instanceof Error ? e.message : String(e)));
+        }
+        if (config.scopes) {
+            var scopeNames = Object.keys(config.scopes);
+            Logger_1.logger.info("\nConfigured scopes (" + scopeNames.length + "):");
+            for (var i = 0; i < scopeNames.length; i++) {
+                var scopeName = scopeNames[i];
+                var scopeConf = config.scopes[scopeName];
+                var srcDir = (typeof scopeConf === "object" && scopeConf.sourceDirectory)
+                    ? scopeConf.sourceDirectory
+                    : "src/" + scopeName;
+                var marker = scopeName === scopeObj.scope ? " (active)" : "";
+                var updateSetInfo = updateSetConfig[scopeName]
+                    ? " [update set: " + updateSetConfig[scopeName].name + "]"
+                    : " [no update set configured]";
+                Logger_1.logger.info("  " + scopeName + marker + " — " + srcDir + updateSetInfo);
+            }
+        }
+    }
+    catch (e) {
+        throw e;
+    }
+}