@tenonhq/dovetail-core 0.0.85

package/dist/initSystem/orchestrator.js

@@ -0,0 +1,408 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInit = runInit;
+exports.runLogin = runLogin;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const Logger_1 = require("../Logger");
+const FileUtils_1 = require("../FileUtils");
+const discovery_1 = require("./discovery");
+const corePlugin_1 = require("./corePlugin");
+// ============================================================================
+// Init Context
+// ============================================================================
+/**
+ * @description Builds an InitContext from the current environment.
+ * Reads existing .env if present. Pulls process.env fallbacks only for
+ * env keys declared by the provided plugins (no hardcoded allowlist).
+ */
+function buildInitContext(plugins) {
+    const rootDir = process.cwd();
+    const envPath = path_1.default.resolve(rootDir, ".env");
+    const env = {};
+    // Load existing .env values
+    try {
+        const parsed = dotenv_1.default.parse(fs_1.default.readFileSync(envPath, "utf8"));
+        Object.assign(env, parsed);
+    }
+    catch (e) {
+        // No .env yet — starting fresh
+    }
+    // Pull from process.env for keys declared by plugins but missing from .env
+    const pluginEnvKeys = plugins.flatMap(p => (p.login || []).map(h => h.envKey));
+    pluginEnvKeys.forEach(key => {
+        if (process.env[key] && !env[key]) {
+            env[key] = process.env[key];
+        }
+    });
+    let hasConfig = false;
+    try {
+        fs_1.default.accessSync(path_1.default.join(rootDir, "dove.config.js"), fs_1.default.constants.F_OK);
+        hasConfig = true;
+    }
+    catch (e) {
+        try {
+            fs_1.default.accessSync(path_1.default.join(rootDir, "sinc.config.js"), fs_1.default.constants.F_OK);
+            hasConfig = true;
+        }
+        catch (_e) {
+            // No config yet
+        }
+    }
+    return { env, answers: {}, rootDir, hasConfig, inquirer: inquirer_1.default, chalk: chalk_1.default };
+}
+// ============================================================================
+// Plugin Selection
+// ============================================================================
+async function promptPluginSelection(externalPlugins) {
+    if (externalPlugins.length === 0) {
+        return [corePlugin_1.corePlugin];
+    }
+    const choices = externalPlugins.map(plugin => ({
+        name: plugin.displayName + " — " + plugin.description,
+        value: plugin.name,
+        checked: false,
+    }));
+    const answer = await inquirer_1.default.prompt([{
+            type: "checkbox",
+            name: "plugins",
+            message: "Which integrations would you like to configure?",
+            choices,
+        }]);
+    const selectedNames = new Set(answer.plugins);
+    const selected = externalPlugins.filter(p => selectedNames.has(p.name));
+    return [corePlugin_1.corePlugin, ...selected];
+}
+async function collectLoginHooks(hooks, context) {
+    for (const hook of hooks) {
+        const existingValue = context.env[hook.envKey] || "";
+        // Show instructions if provided
+        if (hook.instructions && hook.instructions.length > 0) {
+            Logger_1.logger.info("");
+            hook.instructions.forEach(line => Logger_1.logger.info(line));
+            Logger_1.logger.info("");
+        }
+        // Build the prompt
+        const promptConfig = {
+            type: hook.prompt.type,
+            name: "value",
+            message: hook.prompt.message,
+        };
+        if (hook.prompt.mask) {
+            promptConfig.mask = hook.prompt.mask;
+        }
+        // Show existing value as default for non-password fields
+        if (existingValue && hook.prompt.type !== "password") {
+            promptConfig.default = existingValue;
+        }
+        // Add basic validation for required fields
+        if (hook.required !== false) {
+            promptConfig.validate = (input) => {
+                if (!input || input.trim() === "")
+                    return "This field is required";
+                return true;
+            };
+        }
+        const answer = await inquirer_1.default.prompt([promptConfig]);
+        context.env[hook.envKey] = answer.value.trim();
+    }
+}
+async function runLoginPhase(plugin, context) {
+    const hooks = plugin.login;
+    if (!hooks || hooks.length === 0)
+        return;
+    // Core plugin: retry loop with specific error messages
+    if (plugin.name === "core") {
+        // If .env already has all required credentials, offer to skip login
+        const hasAllCreds = context.env.SN_INSTANCE && context.env.SN_USER && context.env.SN_PASSWORD;
+        if (hasAllCreds) {
+            Logger_1.logger.info("Found existing credentials:");
+            Logger_1.logger.info("  Instance: " + context.env.SN_INSTANCE);
+            Logger_1.logger.info("  User:     " + context.env.SN_USER);
+            Logger_1.logger.info("");
+            const useExisting = await inquirer_1.default.prompt([{
+                    type: "confirm",
+                    name: "confirmed",
+                    message: "Use these credentials?",
+                    default: true,
+                }]);
+            if (useExisting.confirmed) {
+                Logger_1.logger.info("Validating credentials...");
+                const result = await (0, corePlugin_1.validateCoreLogin)(context);
+                if (result === true) {
+                    Logger_1.logger.success(chalk_1.default.green("✓ Connected to " + context.env.SN_INSTANCE));
+                    return;
+                }
+                Logger_1.logger.error(chalk_1.default.red("✗ " + result));
+                Logger_1.logger.info("Please re-enter your credentials.");
+                context.env.SN_PASSWORD = "";
+            }
+        }
+        while (true) {
+            await collectLoginHooks(hooks, context);
+            // Run per-hook validation
+            let hookFailed = false;
+            for (const hook of hooks) {
+                if (hook.validate) {
+                    const result = await hook.validate(context.env[hook.envKey], context);
+                    if (result !== true) {
+                        Logger_1.logger.error(chalk_1.default.red("✗ " + result));
+                        hookFailed = true;
+                        break;
+                    }
+                }
+            }
+            if (hookFailed) {
+                const retry = await inquirer_1.default.prompt([{
+                        type: "confirm",
+                        name: "again",
+                        message: "Try again?",
+                        default: true,
+                    }]);
+                if (!retry.again) {
+                    throw new Error("Login cancelled");
+                }
+                context.env.SN_PASSWORD = "";
+                continue;
+            }
+            Logger_1.logger.info("Validating credentials...");
+            const coreResult = await (0, corePlugin_1.validateCoreLogin)(context);
+            if (coreResult === true) {
+                Logger_1.logger.success(chalk_1.default.green("✓ Connected to " + context.env.SN_INSTANCE));
+                return;
+            }
+            Logger_1.logger.error(chalk_1.default.red("✗ " + coreResult));
+            Logger_1.logger.info("");
+            const retry = await inquirer_1.default.prompt([{
+                    type: "confirm",
+                    name: "again",
+                    message: "Try again?",
+                    default: true,
+                }]);
+            if (!retry.again) {
+                throw new Error("Login cancelled");
+            }
+            // Clear password so it re-prompts; instance and user show as defaults
+            context.env.SN_PASSWORD = "";
+        }
+    }
+    // Non-core plugins: original behavior (no retry loop)
+    await collectLoginHooks(hooks, context);
+    for (const hook of hooks) {
+        if (hook.validate) {
+            const result = await hook.validate(context.env[hook.envKey], context);
+            if (result !== true) {
+                Logger_1.logger.error(chalk_1.default.red("✗ " + result));
+                throw new Error("Validation failed for " + hook.envKey);
+            }
+        }
+    }
+}
+async function runConfigPhase(context) {
+    if (context.hasConfig) {
+        var answer = await inquirer_1.default.prompt([{
+                type: "list",
+                name: "configAction",
+                message: "Existing config (dove.config.js or legacy sinc.config.js) found:",
+                choices: [
+                    { name: "Use current config", value: "keep" },
+                    { name: "Replace config (regenerate after scope selection)", value: "replace" },
+                ],
+            }]);
+        context.answers.configAction = answer.configAction;
+        if (answer.configAction === "keep") {
+            Logger_1.logger.info(chalk_1.default.green("  ✓ Using existing config"));
+        }
+        return;
+    }
+    // No config — will be generated in initialize phase after scopes are selected
+    context.answers.configAction = "generate";
+}
+async function runConfigurePhase(plugin, context) {
+    const hooks = plugin.configure;
+    if (!hooks || hooks.length === 0)
+        return;
+    for (const hook of hooks) {
+        Logger_1.logger.debug("Running configure hook: " + hook.label);
+        const result = await hook.run(context);
+        if (result !== null && result !== undefined) {
+            context.answers[hook.key] = result;
+        }
+    }
+}
+/**
+ * @description Saves env vars declared by plugins to .env (merge-style).
+ * Only writes keys that plugins explicitly declared via login hooks or
+ * configure hooks — never writes transient context values.
+ */
+function saveEnvVars(context, plugins) {
+    const pluginKeys = new Set();
+    plugins.forEach(plugin => {
+        (plugin.login || []).forEach(hook => pluginKeys.add(hook.envKey));
+        (plugin.configure || []).forEach(hook => {
+            if (context.env[hook.key])
+                pluginKeys.add(hook.key);
+        });
+    });
+    const vars = Array.from(pluginKeys)
+        .filter(key => context.env[key])
+        .map(key => ({ key, value: context.env[key] }));
+    if (vars.length > 0) {
+        (0, FileUtils_1.writeEnvVars)({ vars });
+        // Also set on process.env for immediate use
+        vars.forEach(({ key, value }) => { process.env[key] = value; });
+        Logger_1.logger.success(chalk_1.default.green("✓ Saved to .env (existing values preserved)"));
+    }
+}
+async function runInit(options) {
+    let failed = false;
+    try {
+        Logger_1.logger.info("");
+        Logger_1.logger.info(chalk_1.default.bold("  Dovetail Setup"));
+        Logger_1.logger.info("  " + "═".repeat(40));
+        Logger_1.logger.info("");
+        // 1. Discover plugins
+        const externalPlugins = (0, discovery_1.discoverPlugins)();
+        if (externalPlugins.length > 0) {
+            Logger_1.logger.info("  Detected packages:");
+            Logger_1.logger.info("    ● dovetail-core (" + chalk_1.default.cyan("ServiceNow") + ")");
+            externalPlugins.forEach(p => {
+                Logger_1.logger.info("    ● dovetail-" + p.name + " (" + chalk_1.default.cyan(p.displayName) + ")");
+            });
+            Logger_1.logger.info("");
+        }
+        // 2. Select plugins
+        const selectedPlugins = await promptPluginSelection(externalPlugins);
+        // 3. Build context (passes plugins so env fallback uses their declared keys)
+        const context = buildInitContext(selectedPlugins);
+        // 4. Login phase
+        Logger_1.logger.info("");
+        Logger_1.logger.info(chalk_1.default.bold("  ── Login " + "─".repeat(30)));
+        Logger_1.logger.info("");
+        for (const plugin of selectedPlugins) {
+            await runLoginPhase(plugin, context);
+        }
+        // 5. Save env vars after login
+        saveEnvVars(context, selectedPlugins);
+        // 5.5 Config phase
+        Logger_1.logger.info("");
+        Logger_1.logger.info(chalk_1.default.bold("  ── Config " + "─".repeat(29)));
+        Logger_1.logger.info("");
+        await runConfigPhase(context);
+        // 6. Configure phase
+        Logger_1.logger.info("");
+        Logger_1.logger.info(chalk_1.default.bold("  ── Configure " + "─".repeat(26)));
+        Logger_1.logger.info("");
+        for (const plugin of selectedPlugins) {
+            await runConfigurePhase(plugin, context);
+        }
+        // 7. Initialize phase
+        Logger_1.logger.info("");
+        Logger_1.logger.info(chalk_1.default.bold("  ── Initialize " + "─".repeat(25)));
+        Logger_1.logger.info("");
+        for (const plugin of selectedPlugins) {
+            if (plugin.initialize) {
+                try {
+                    await plugin.initialize(context);
+                }
+                catch (e) {
+                    const msg = e instanceof Error ? e.message : String(e);
+                    Logger_1.logger.error("Initialization failed for " + plugin.displayName + ": " + msg);
+                    failed = true;
+                }
+            }
+        }
+        // 8. Summary
+        Logger_1.logger.info("");
+        Logger_1.logger.info("  " + "═".repeat(40));
+        if (failed) {
+            Logger_1.logger.warn("  Setup completed with errors. Review the output above.");
+        }
+        else {
+            Logger_1.logger.success(chalk_1.default.green("  Setup complete!") + " Run " + chalk_1.default.cyan("dove watch") + " to start.");
+        }
+        Logger_1.logger.info("");
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        Logger_1.logger.error("Init failed: " + message);
+    }
+}
+async function runLogin(options) {
+    try {
+        const opts = options || {};
+        // Determine which plugins to log in to
+        let pluginsToLogin;
+        const coreAliases = new Set(["core", "servicenow", "sn"]);
+        if (opts.pluginName) {
+            if (coreAliases.has(opts.pluginName)) {
+                pluginsToLogin = [corePlugin_1.corePlugin];
+            }
+            else {
+                const externalPlugins = (0, discovery_1.discoverPlugins)();
+                const match = externalPlugins.find(p => p.name === opts.pluginName);
+                if (!match) {
+                    Logger_1.logger.error("Plugin '" + opts.pluginName + "' not found. Available plugins:");
+                    externalPlugins.forEach(p => Logger_1.logger.info("  - " + p.name + " (" + p.displayName + ")"));
+                    return;
+                }
+                pluginsToLogin = [match];
+            }
+        }
+        else if (opts.all) {
+            pluginsToLogin = [corePlugin_1.corePlugin, ...(0, discovery_1.discoverPlugins)()];
+        }
+        else {
+            pluginsToLogin = [corePlugin_1.corePlugin];
+        }
+        // Build context with discovered plugins for env key resolution
+        const context = buildInitContext(pluginsToLogin);
+        // Apply CLI flag overrides for non-interactive mode
+        if (opts.instance)
+            context.env.SN_INSTANCE = opts.instance;
+        if (opts.user)
+            context.env.SN_USER = opts.user;
+        if (opts.password)
+            context.env.SN_PASSWORD = opts.password;
+        // Dynamic header based on which plugins are being logged in
+        const pluginNames = pluginsToLogin.map(p => p.displayName).join(" + ");
+        Logger_1.logger.info("");
+        Logger_1.logger.info(chalk_1.default.bold("  " + pluginNames + " Login"));
+        Logger_1.logger.info("  " + "─".repeat(40));
+        Logger_1.logger.info("");
+        // Check if all core credentials provided via flags (non-interactive mode)
+        const hasAllCoreFlags = opts.instance && opts.user && opts.password;
+        if (hasAllCoreFlags && pluginsToLogin.length === 1 && pluginsToLogin[0].name === "core") {
+            Logger_1.logger.info("Validating credentials...");
+            const result = await (0, corePlugin_1.validateCoreLogin)(context);
+            if (result !== true) {
+                Logger_1.logger.error(chalk_1.default.red("✗ " + result));
+                return;
+            }
+            Logger_1.logger.success(chalk_1.default.green("✓ Connected to " + context.env.SN_INSTANCE));
+        }
+        else {
+            for (const plugin of pluginsToLogin) {
+                await runLoginPhase(plugin, context);
+            }
+        }
+        // Save env vars
+        saveEnvVars(context, pluginsToLogin);
+        Logger_1.logger.info("");
+        Logger_1.logger.info("You can now use:");
+        Logger_1.logger.info("  dove init              — Initialize a new project");
+        Logger_1.logger.info("  dove watch             — Watch for changes");
+        Logger_1.logger.info("  dove status            — Check instance connection");
+        Logger_1.logger.info("");
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        Logger_1.logger.error("Login failed: " + message);
+    }
+}

package/dist/logMessages.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logBuildResults = exports.logPushResults = exports.log = void 0;
+exports.logFilePush = logFilePush;
+exports.logDeploy = logDeploy;
+const Logger_1 = require("./Logger");
+const chalk_1 = __importDefault(require("chalk"));
+exports.log = console.log;
+function parseError(err) {
+    return `${err.name}:
+ ${err.message}
+ Stack Trace:
+ ${err.stack || "none"}`;
+}
+function logFilePush(context, res) {
+    const { message, success } = res;
+    const instance = process.env.SN_INSTANCE || "instance";
+    const label = chalk_1.default.bold.blue;
+    const timestamp = new Date().toLocaleTimeString();
+    if (success) {
+        Logger_1.logger.info(chalk_1.default.green("Pushed") + " " + context.tableName + "/" + context.name +
+            " (" + context.targetField + ") to " + instance + " at " + timestamp);
+    }
+    else {
+        Logger_1.logger.error("Failed to push " + context.tableName + "/" + context.name +
+            " (" + context.targetField + ") to " + instance);
+        Logger_1.logger.error(message);
+    }
+}
+function multiLog(files, success, resultSet, successMessage, errorMessage, err) {
+    if (success) {
+        let fileNum = chalk_1.default.bold.blue(resultSet.filter((result) => result).length + "");
+        let message = chalk_1.default.green(`${fileNum} files ${successMessage}`);
+        Logger_1.logger.info(message);
+    }
+    else {
+        Logger_1.logger.error(errorMessage);
+        if (err) {
+            Logger_1.logger.error(parseError(err));
+        }
+    }
+    spacer();
+}
+function logDeploy(files, success, resultSet, err) {
+    multiLog(files, success, resultSet, "successfully deployed", "Failed to deploy files", err);
+}
+function spacer() {
+    Logger_1.logger.info("");
+}
+const logOperationResults = (results, operation) => {
+    const unsuccessful = results.filter((r) => !r.success);
+    const logr = Logger_1.logger.getInternalLogger();
+    const label = (content) => chalk_1.default.bold.blue(content);
+    const success = (content) => chalk_1.default.bold.green(content);
+    const fail = (content) => chalk_1.default.bold.red(content);
+    logr.info(`${label("Total Records:")} ${results.length}`);
+    logr.info(`${label(`Successful ${operation}:`)} ${success(results.length - unsuccessful.length + "")}`);
+    logr.info(`${label(`Failed ${operation}:`)} ${fail(unsuccessful.length + "")}`);
+    if (unsuccessful.length === 0) {
+        return;
+    }
+    Logger_1.logger.error("-".repeat(60));
+    Logger_1.logger.error(fail("Error Summary"));
+    Logger_1.logger.error("-".repeat(60));
+    unsuccessful.forEach(({ message }, index) => {
+        if (unsuccessful.length === 1) {
+            logr.error(message);
+        }
+        logr.error(`${index + 1}. ${message}`);
+    });
+};
+const logPushResults = (results) => {
+    logOperationResults(results, "Pushes");
+};
+exports.logPushResults = logPushResults;
+const logBuildResults = (results) => {
+    logOperationResults(results, "Builds");
+};
+exports.logBuildResults = logBuildResults;

package/dist/loginCommand.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loginCommand = loginCommand;
+const commands_1 = require("./commands");
+const orchestrator_1 = require("./initSystem/orchestrator");
+/**
+ * @description Command handler for `dove login`.
+ * Authenticates with ServiceNow and other integrations, saves credentials to .env.
+ */
+async function loginCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    await (0, orchestrator_1.runLogin)({
+        logLevel: args.logLevel,
+        pluginName: args.plugin || undefined,
+        all: args.all || false,
+        instance: args.instance || undefined,
+        user: args.user || undefined,
+        password: args.password || undefined,
+    });
+}

package/dist/migrateCommand.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateCommand = migrateCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const Logger_1 = require("./Logger");
+const commands_1 = require("./commands");
+// Map legacy -> new artifact filenames at the project root.
+const FILE_RENAMES = [
+    { legacy: "sinc.config.js", next: "dove.config.js" },
+    { legacy: "sinc.manifest.json", next: "dove.manifest.json" },
+    { legacy: "sinc.diff.manifest.json", next: "dove.diff.manifest.json" },
+    { legacy: ".sinc-active-task.json", next: ".dove-active-task.json" },
+    { legacy: ".sinc-update-sets.json", next: ".dove-update-sets.json" },
+    { legacy: ".sinc-recent-edits.json", next: ".dove-recent-edits.json" },
+];
+// Per-scope manifests follow the pattern sinc.manifest.<scope>.json. Glob from disk.
+function collectScopeManifestRenames(rootDir) {
+    let entries = [];
+    try {
+        entries = fs_1.default.readdirSync(rootDir);
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((f) => f.startsWith("sinc.manifest.") && f !== "sinc.manifest.json" && f.endsWith(".json"))
+        .map((f) => ({
+        legacy: f,
+        next: f.replace(/^sinc\.manifest\./, "dove.manifest."),
+    }));
+}
+// Rewrite package.json scripts and dependencies.
+function buildPackageJsonStep(rootDir) {
+    const pkgPath = path_1.default.join(rootDir, "package.json");
+    if (!fs_1.default.existsSync(pkgPath))
+        return null;
+    const original = fs_1.default.readFileSync(pkgPath, "utf8");
+    // Order matters: rewrite the @tenonhq/sincronia-* deps first so the
+    // subsequent \bsinc\b sweep doesn't have to know about package-name
+    // collisions. \bsinc\b doesn't match `sincronia` (no word boundary between
+    // `c` and `r`), so the package-name replace and the script-token replace
+    // are independent. The standalone \bsinc\b catches every CLI invocation
+    // shape — bare (`sinc watch`), chained (`&& sinc push`), prefixed
+    // (`npx sinc`), trailing (`build && sinc deploy`) — without the four
+    // separate fragile regexes we had before.
+    const updated = original
+        .replace(/@tenonhq\/sincronia-/g, "@tenonhq/dovetail-")
+        .replace(/\bsinc\b/g, "dove");
+    if (updated === original)
+        return null;
+    return {
+        description: "Update package.json (rename @tenonhq/sincronia-* deps and `sinc` scripts to `dove`)",
+        apply: () => {
+            fs_1.default.writeFileSync(pkgPath, updated);
+        },
+    };
+}
+function buildFileRenameStep(rootDir, legacy, next) {
+    const legacyPath = path_1.default.join(rootDir, legacy);
+    const nextPath = path_1.default.join(rootDir, next);
+    if (!fs_1.default.existsSync(legacyPath))
+        return null;
+    if (fs_1.default.existsSync(nextPath)) {
+        Logger_1.logger.warn("Skipping rename of " + legacy + " — " + next + " already exists. Resolve manually.");
+        return null;
+    }
+    return {
+        description: "Rename " + legacy + " -> " + next,
+        apply: () => {
+            fs_1.default.renameSync(legacyPath, nextPath);
+        },
+    };
+}
+async function migrateCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    const rootDir = process.cwd();
+    const apply = !!args.apply;
+    const steps = [];
+    // 1. Single-file renames.
+    for (const r of FILE_RENAMES) {
+        const step = buildFileRenameStep(rootDir, r.legacy, r.next);
+        if (step)
+            steps.push(step);
+    }
+    // 2. Per-scope manifest renames.
+    for (const r of collectScopeManifestRenames(rootDir)) {
+        const step = buildFileRenameStep(rootDir, r.legacy, r.next);
+        if (step)
+            steps.push(step);
+    }
+    // 3. package.json rewrite.
+    const pkgStep = buildPackageJsonStep(rootDir);
+    if (pkgStep)
+        steps.push(pkgStep);
+    if (steps.length === 0) {
+        Logger_1.logger.success("Nothing to migrate — project already uses Dovetail filenames.");
+        return;
+    }
+    Logger_1.logger.info("Migration plan (" + steps.length + " step" + (steps.length === 1 ? "" : "s") + "):");
+    steps.forEach((s, i) => {
+        Logger_1.logger.info("  " + (i + 1) + ". " + s.description);
+    });
+    if (!apply) {
+        Logger_1.logger.info("");
+        Logger_1.logger.warn("Dry run only — re-run with `--apply` to perform the migration.");
+        return;
+    }
+    for (const step of steps) {
+        try {
+            step.apply();
+            Logger_1.logger.success("✓ " + step.description);
+        }
+        catch (e) {
+            Logger_1.logger.error("✗ " + step.description + ": " + (e instanceof Error ? e.message : String(e)));
+        }
+    }
+    Logger_1.logger.info("");
+    Logger_1.logger.info("Migration complete. Review the changes, run `npm install` if package.json was updated, and re-import the Dovetail Scripted REST API XML on your ServiceNow instance (see docs/dovetail-servicenow-migration.md).");
+}

package/dist/projectFiles.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getActiveTaskPath = getActiveTaskPath;
+exports.getUpdateSetsConfigPath = getUpdateSetsConfigPath;
+exports.getRecentEditsPath = getRecentEditsPath;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// Resolve a project-root dotfile by its short name (e.g. "active-task" → ".dove-active-task.json").
+// Reads prefer the new `.dove-*` filename; if only the legacy `.sinc-*` sibling exists, it is
+// returned so existing projects keep working until the user runs `dove migrate`. New writes
+// land at the `.dove-*` path when neither file is present yet.
+function resolveDoveDotfile(name) {
+    const dovePath = path_1.default.resolve(process.cwd(), ".dove-" + name + ".json");
+    const sincPath = path_1.default.resolve(process.cwd(), ".sinc-" + name + ".json");
+    if (fs_1.default.existsSync(dovePath))
+        return dovePath;
+    if (fs_1.default.existsSync(sincPath))
+        return sincPath;
+    return dovePath;
+}
+function getActiveTaskPath() {
+    return resolveDoveDotfile("active-task");
+}
+function getUpdateSetsConfigPath() {
+    return resolveDoveDotfile("update-sets");
+}
+function getRecentEditsPath() {
+    return resolveDoveDotfile("recent-edits");
+}