@danalexilewis/taskgraph 0.1.0

package/dist/cli/import.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importCommand = importCommand;
+const utils_1 = require("./utils");
+const parser_1 = require("../plan-import/parser");
+const importer_1 = require("../plan-import/importer");
+const commit_1 = require("../db/commit");
+const uuid_1 = require("uuid");
+const neverthrow_1 = require("neverthrow");
+const errors_1 = require("../domain/errors");
+const query_1 = require("../db/query");
+function importCommand(program) {
+    program
+        .command("import")
+        .description("Import tasks and edges from a markdown plan file")
+        .argument("<filePath>", "Path to the markdown plan file (e.g., plans/feature-auth.md)")
+        .requiredOption("--plan <planTitleOrId>", "Title or ID of the plan to associate tasks with")
+        .option("--format <format>", "Plan format: 'legacy' (TASK:/TITLE:/BLOCKED_BY:) or 'cursor' (YAML frontmatter with todos). Default: legacy", "legacy")
+        .action(async (filePath, options, cmd) => {
+        const result = await (0, utils_1.readConfig)().asyncAndThen((config) => {
+            const currentTimestamp = (0, query_1.now)();
+            const parseResult = options.format === "cursor"
+                ? (0, parser_1.parseCursorPlan)(filePath)
+                : (0, parser_1.parsePlanMarkdown)(filePath);
+            return parseResult.asyncAndThen((parsedPlan) => {
+                return neverthrow_1.ResultAsync.fromPromise((async () => {
+                    const q = (0, query_1.query)(config.doltRepoPath);
+                    const { planTitle, planIntent, tasks: parsedTasks, fileTree, risks, tests, } = parsedPlan;
+                    let planId = null;
+                    // Try to find plan by ID first
+                    if (options.plan.length === 36 &&
+                        /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(options.plan)) {
+                        const planResult = await q.select("plan", { columns: ["plan_id"], where: { plan_id: options.plan } });
+                        if (planResult.isOk() && planResult.value.length > 0) {
+                            planId = planResult.value[0].plan_id;
+                        }
+                    }
+                    // If not found by ID, try to find by title
+                    if (!planId) {
+                        const planResult = await q.select("plan", { columns: ["plan_id"], where: { title: options.plan } });
+                        if (planResult.isOk() && planResult.value.length > 0) {
+                            planId = planResult.value[0].plan_id;
+                        }
+                    }
+                    // If plan still not found, create a new one
+                    if (!planId) {
+                        planId = (0, uuid_1.v4)();
+                        const newPlanTitle = planTitle || options.plan;
+                        const newPlanIntent = planIntent || `Imported from ${filePath}`;
+                        const insertPayload = {
+                            plan_id: planId,
+                            title: newPlanTitle,
+                            intent: newPlanIntent,
+                            source_path: filePath,
+                            created_at: currentTimestamp,
+                            updated_at: currentTimestamp,
+                        };
+                        if (options.format === "cursor") {
+                            if (fileTree != null)
+                                insertPayload.file_tree = fileTree;
+                            if (risks != null)
+                                insertPayload.risks = JSON.stringify(risks);
+                            if (tests != null)
+                                insertPayload.tests = JSON.stringify(tests);
+                        }
+                        const insertResult = await q.insert("plan", insertPayload);
+                        if (insertResult.isErr())
+                            throw insertResult.error;
+                        console.log(`Created new plan '${newPlanTitle}' with ID: ${planId}`);
+                        const commitResult = await (0, commit_1.doltCommit)(`plan: create ${newPlanTitle} from import`, config.doltRepoPath, cmd.parent?.opts().noCommit);
+                        if (commitResult.isErr())
+                            throw commitResult.error;
+                    }
+                    if (!planId) {
+                        throw (0, errors_1.buildError)(errors_1.ErrorCode.PLAN_NOT_FOUND, "Could not find or create a plan for the import.");
+                    }
+                    if (options.format === "cursor" && (fileTree != null || risks != null || tests != null)) {
+                        const planUpdatePayload = {
+                            updated_at: currentTimestamp,
+                        };
+                        if (fileTree != null)
+                            planUpdatePayload.file_tree = fileTree;
+                        if (risks != null)
+                            planUpdatePayload.risks = JSON.stringify(risks);
+                        if (tests != null)
+                            planUpdatePayload.tests = JSON.stringify(tests);
+                        const planUpdateResult = await q.update("plan", planUpdatePayload, { plan_id: planId });
+                        if (planUpdateResult.isErr())
+                            throw planUpdateResult.error;
+                    }
+                    const upsertResult = await (0, importer_1.upsertTasksAndEdges)(planId, parsedTasks, config.doltRepoPath, cmd.parent?.opts().noCommit);
+                    if (upsertResult.isErr())
+                        throw upsertResult.error;
+                    return {
+                        filePath,
+                        plan_id: planId,
+                        importedTasksCount: upsertResult.value.importedTasksCount,
+                    };
+                })(), (e) => e);
+            });
+        });
+        result.match((data) => {
+            const resultData = data;
+            if (!cmd.parent?.opts().json) {
+                console.log(`Successfully imported tasks and edges from ${resultData.filePath} to plan ${resultData.plan_id}.`);
+            }
+            else {
+                console.log(JSON.stringify(resultData, null, 2));
+            }
+        }, (error) => {
+            console.error(`Error importing plan from ${filePath}: ${error.message}`);
+            if (cmd.parent?.opts().json) {
+                console.log(JSON.stringify({
+                    status: "error",
+                    code: error.code,
+                    message: error.message,
+                    cause: error.cause,
+                }));
+            }
+            process.exit(1);
+        });
+    });
+}

package/dist/cli/index.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const init_1 = require("./init");
+const plan_1 = require("./plan");
+const task_1 = require("./task");
+const edge_1 = require("./edge");
+const next_1 = require("./next");
+const show_1 = require("./show");
+const start_1 = require("./start");
+const done_1 = require("./done");
+const block_1 = require("./block");
+const split_1 = require("./split");
+const export_1 = require("./export");
+const portfolio_1 = require("./portfolio");
+const import_1 = require("./import");
+const status_1 = require("./status");
+const context_1 = require("./context");
+const note_1 = require("./note");
+const setup_1 = require("./setup");
+const utils_1 = require("./utils");
+const migrate_1 = require("../db/migrate");
+const errors_1 = require("../domain/errors");
+const program = new commander_1.Command();
+/** Commands that create or scaffold; skip auto-migrate (no config or own migration path). */
+const SKIP_MIGRATE_COMMANDS = new Set(["init", "setup"]);
+function topLevelCommand(cmd) {
+    let c = cmd;
+    while (c.parent && c.parent.parent) {
+        c = c.parent;
+    }
+    return c;
+}
+program.hook("preAction", async (_thisCommand, actionCommand) => {
+    const top = topLevelCommand(actionCommand);
+    if (SKIP_MIGRATE_COMMANDS.has(top.name())) {
+        return;
+    }
+    const configResult = (0, utils_1.readConfig)();
+    if (configResult.isErr()) {
+        if (configResult.error.code === errors_1.ErrorCode.CONFIG_NOT_FOUND) {
+            return;
+        }
+        return;
+    }
+    const opts = (0, utils_1.rootOpts)(actionCommand);
+    const noCommit = opts.noCommit ?? false;
+    const runResult = await (0, migrate_1.ensureMigrations)(configResult.value.doltRepoPath, noCommit);
+    runResult.match(() => { }, (e) => {
+        console.error(`Migration failed: ${e.message}`);
+        process.exit(1);
+    });
+});
+program
+    .name("tg")
+    .description("Task Graph CLI for Centaur Development")
+    .version("0.1.0")
+    .option("--json", "Output machine-readable JSON", false)
+    .option("--no-commit", "Do not commit changes to Dolt", false)
+    .option("--commit-msg <msg>", "Override default commit message");
+(0, init_1.initCommand)(program);
+(0, setup_1.setupCommand)(program);
+(0, plan_1.planCommand)(program);
+(0, task_1.taskCommand)(program);
+(0, edge_1.edgeCommand)(program);
+(0, next_1.nextCommand)(program);
+(0, show_1.showCommand)(program);
+(0, start_1.startCommand)(program);
+(0, done_1.doneCommand)(program);
+(0, block_1.blockCommand)(program);
+(0, split_1.splitCommand)(program);
+(0, export_1.exportCommand)(program);
+(0, portfolio_1.portfolioCommand)(program);
+(0, import_1.importCommand)(program);
+(0, status_1.statusCommand)(program);
+(0, note_1.noteCommand)(program);
+(0, context_1.contextCommand)(program);
+program.parse(process.argv);

package/dist/cli/init.js

@@ -0,0 +1,106 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = initCommand;
+const fs_1 = require("fs");
+const execa_1 = require("execa");
+const migrate_1 = require("../db/migrate");
+const path = __importStar(require("path"));
+const utils_1 = require("./utils");
+const neverthrow_1 = require("neverthrow");
+const errors_1 = require("../domain/errors");
+const TASKGRAPH_DIR = ".taskgraph";
+const CONFIG_FILE = path.join(TASKGRAPH_DIR, "config.json");
+function initCommand(program) {
+    program
+        .command("init")
+        .description("Initializes the Dolt repository and applies migrations")
+        .option("--no-commit", "Do not commit changes to Dolt", false)
+        .action(async (options, cmd) => {
+        const repoPath = process.cwd();
+        const taskGraphPath = path.join(repoPath, TASKGRAPH_DIR);
+        const doltRepoPath = path.join(taskGraphPath, "dolt");
+        const initResult = await neverthrow_1.ResultAsync.fromPromise((async () => {
+            if (!(0, fs_1.existsSync)(taskGraphPath)) {
+                (0, fs_1.mkdirSync)(taskGraphPath);
+            }
+            if (!(0, fs_1.existsSync)(doltRepoPath)) {
+                // Create the doltRepoPath directory before initializing Dolt
+                (0, fs_1.mkdirSync)(doltRepoPath, { recursive: true });
+                console.log(`Creating Dolt repository at ${doltRepoPath}...`);
+                await (0, execa_1.execa)(process.env.DOLT_PATH || "dolt", ["init"], {
+                    cwd: doltRepoPath,
+                }); // Changed cwd to doltRepoPath
+                console.log("Dolt repository created.");
+            }
+            else {
+                console.log(`Dolt repository already exists at ${doltRepoPath}.`);
+            }
+            return Promise.resolve(); // Explicitly return a Promise<void>
+        })(), // Invoked the async IIFE
+        (e) => (0, errors_1.buildError)(errors_1.ErrorCode.DB_QUERY_FAILED, "Failed to initialize Dolt repository", e))
+            .andThen(() => (0, migrate_1.applyMigrations)(doltRepoPath, options.noCommit))
+            .andThen(() => (0, migrate_1.applyTaskDimensionsMigration)(doltRepoPath, options.noCommit))
+            .andThen(() => (0, migrate_1.applyPlanRichFieldsMigration)(doltRepoPath, options.noCommit))
+            .andThen(() => (0, migrate_1.applyTaskSuggestedChangesMigration)(doltRepoPath, options.noCommit))
+            .andThen(() => (0, migrate_1.applyTaskDomainSkillJunctionMigration)(doltRepoPath, options.noCommit))
+            .andThen(() => {
+            const config = {
+                doltRepoPath: doltRepoPath,
+            };
+            // Use a valid ErrorCode, e.g., UNKNOWN_ERROR
+            return (0, utils_1.writeConfig)(config, repoPath).mapErr((e) => (0, errors_1.buildError)(errors_1.ErrorCode.UNKNOWN_ERROR, "Failed to write config", e));
+        });
+        initResult.match(() => {
+            if (!cmd.parent?.opts().json) {
+                console.log(`Configuration written to ${CONFIG_FILE}`);
+                console.log("Task Graph initialized successfully.");
+            }
+            // ... rest of the match block remains the same
+        }, (error) => {
+            const appError = error;
+            console.error(`Error initializing Task Graph: ${appError.message}`); // Used appError.message
+            if (cmd.parent?.opts().json) {
+                console.log(JSON.stringify({
+                    status: "error",
+                    code: appError.code,
+                    message: appError.message,
+                    cause: appError.cause,
+                }));
+            }
+            process.exit(1);
+        });
+    });
+}

package/dist/cli/next.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextCommand = nextCommand;
+const utils_1 = require("./utils");
+const neverthrow_1 = require("neverthrow");
+const errors_1 = require("../domain/errors");
+const query_1 = require("../db/query");
+const escape_1 = require("../db/escape");
+function nextCommand(program) {
+    program
+        .command("next")
+        .description("Select runnable tasks")
+        .option("--plan <planId>", "Optional filter by plan ID or title")
+        .option("--domain <domain>", "Filter by task domain (maps to docs/<domain>.md)")
+        .option("--skill <skill>", "Filter by task skill (maps to docs/skills/<skill>.md)")
+        .option("--change-type <type>", "Filter by change type: create, modify, refactor, fix, investigate, test, document")
+        .option("--limit <limit>", "Limit the number of tasks returned", "10")
+        .action(async (options, cmd) => {
+        const result = await (0, utils_1.readConfig)().asyncAndThen((config) => {
+            const limit = parseInt(options.limit, 10);
+            if (isNaN(limit) || limit <= 0) {
+                return (0, neverthrow_1.errAsync)((0, errors_1.buildError)(errors_1.ErrorCode.VALIDATION_FAILED, `Invalid limit: ${options.limit}. Must be a positive integer.`)); // Changed to errAsync
+            }
+            const q = (0, query_1.query)(config.doltRepoPath);
+            let planFilter = "";
+            if (options.plan) {
+                const isUUID = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(options.plan);
+                if (isUUID) {
+                    planFilter = `AND p.plan_id = '${(0, escape_1.sqlEscape)(options.plan)}'`;
+                }
+                else {
+                    planFilter = `AND p.title = '${(0, escape_1.sqlEscape)(options.plan)}'`;
+                }
+            }
+            let domainFilter = "";
+            if (options.domain) {
+                domainFilter = `AND EXISTS (SELECT 1 FROM \`task_domain\` td WHERE td.task_id = t.task_id AND td.domain = '${(0, escape_1.sqlEscape)(options.domain)}')`;
+            }
+            let skillFilter = "";
+            if (options.skill) {
+                skillFilter = `AND EXISTS (SELECT 1 FROM \`task_skill\` ts WHERE ts.task_id = t.task_id AND ts.skill = '${(0, escape_1.sqlEscape)(options.skill)}')`;
+            }
+            let changeTypeFilter = "";
+            if (options.changeType) {
+                changeTypeFilter = `AND t.\`change_type\` = '${(0, escape_1.sqlEscape)(options.changeType)}'`;
+            }
+            const nextTasksQuery = `
+          SELECT t.task_id, t.title, p.title as plan_title, t.risk, t.estimate_mins,
+            (SELECT COUNT(*) FROM \`edge\` e 
+             JOIN \`task\` bt ON e.from_task_id = bt.task_id 
+             WHERE e.to_task_id = t.task_id AND e.type = 'blocks' 
+             AND bt.status NOT IN ('done','canceled')) as unmet_blockers
+          FROM \`task\` t
+          JOIN \`plan\` p ON t.plan_id = p.plan_id
+          WHERE t.status = 'todo'
+          ${planFilter}
+          ${domainFilter}
+          ${skillFilter}
+          ${changeTypeFilter}
+          HAVING unmet_blockers = 0
+          ORDER BY p.priority DESC, t.risk ASC, 
+            CASE WHEN t.estimate_mins IS NULL THEN 1 ELSE 0 END,
+            t.estimate_mins ASC, t.created_at ASC
+          LIMIT ${limit}
+        `;
+            return q.raw(nextTasksQuery);
+        });
+        result.match((tasks) => {
+            const tasksArray = tasks;
+            if (!cmd.parent?.opts().json) {
+                if (tasksArray.length > 0) {
+                    console.log("Runnable Tasks:");
+                    tasksArray.forEach((task) => {
+                        console.log(`  ID: ${task.task_id}, Title: ${task.title}, Plan: ${task.plan_title}, Risk: ${task.risk}, Estimate: ${task.estimate_mins ?? "N/A"}`);
+                    });
+                }
+                else {
+                    console.log("No runnable tasks found.");
+                }
+            }
+            else {
+                console.log(JSON.stringify(tasksArray, null, 2));
+            }
+        }, (error) => {
+            console.error(`Error fetching next tasks: ${error.message}`);
+            if (cmd.parent?.opts().json) {
+                console.log(JSON.stringify({
+                    status: "error",
+                    code: error.code,
+                    message: error.message,
+                    cause: error.cause,
+                }));
+            }
+            process.exit(1);
+        });
+    });
+}

package/dist/cli/note.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noteCommand = noteCommand;
+const uuid_1 = require("uuid");
+const commit_1 = require("../db/commit");
+const utils_1 = require("./utils");
+const neverthrow_1 = require("neverthrow");
+const errors_1 = require("../domain/errors");
+const query_1 = require("../db/query");
+function noteCommand(program) {
+    program
+        .command("note")
+        .description("Append a note event to a task (breadcrumbs for other agents and the human)")
+        .argument("<taskId>", "ID of the task to annotate")
+        .option("--msg <text>", "Note message (required)")
+        .option("--agent <name>", "Agent identifier")
+        .action(async (taskId, options, cmd) => {
+        const msg = options.msg;
+        if (!msg || typeof msg !== "string") {
+            console.error("Error: --msg <text> is required.");
+            process.exit(1);
+        }
+        const agentName = options.agent ?? "default";
+        const result = await (0, utils_1.readConfig)().asyncAndThen((config) => {
+            const currentTimestamp = (0, query_1.now)();
+            const q = (0, query_1.query)(config.doltRepoPath);
+            return q
+                .select("task", {
+                columns: ["task_id"],
+                where: { task_id: taskId },
+            })
+                .andThen((rows) => {
+                if (rows.length === 0) {
+                    return (0, neverthrow_1.err)((0, errors_1.buildError)(errors_1.ErrorCode.TASK_NOT_FOUND, `Task with ID ${taskId} not found.`));
+                }
+                return q
+                    .insert("event", {
+                    event_id: (0, uuid_1.v4)(),
+                    task_id: taskId,
+                    kind: "note",
+                    body: (0, query_1.jsonObj)({
+                        message: msg,
+                        agent: agentName,
+                        timestamp: currentTimestamp,
+                    }),
+                    created_at: currentTimestamp,
+                })
+                    .andThen(() => (0, commit_1.doltCommit)(`task: note ${taskId}`, config.doltRepoPath, cmd.parent?.opts().noCommit))
+                    .map(() => ({ task_id: taskId }));
+            });
+        });
+        result.match((data) => {
+            if (!cmd.parent?.opts().json) {
+                console.log(`Note added to task ${data.task_id}.`);
+            }
+            else {
+                console.log(JSON.stringify(data, null, 2));
+            }
+        }, (error) => {
+            console.error(`Error: ${error.message}`);
+            if (cmd.parent?.opts().json) {
+                console.log(JSON.stringify({
+                    status: "error",
+                    code: error.code,
+                    message: error.message,
+                    cause: error.cause,
+                }));
+            }
+            process.exit(1);
+        });
+    });
+}

package/dist/cli/plan.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planCommand = planCommand;
+const commander_1 = require("commander");
+const uuid_1 = require("uuid");
+const commit_1 = require("../db/commit");
+const utils_1 = require("./utils");
+const query_1 = require("../db/query");
+function planCommand(program) {
+    program
+        .command("plan")
+        .description("Manage plans")
+        .addCommand(planNewCommand())
+        .addCommand(planListCommand());
+}
+function planListCommand() {
+    return new commander_1.Command("list")
+        .alias("ls")
+        .description("List all plans")
+        .action(async (options, cmd) => {
+        const result = await (0, utils_1.readConfig)().asyncAndThen((config) => {
+            const q = (0, query_1.query)(config.doltRepoPath);
+            return q.select("plan", {
+                columns: ["plan_id", "title", "status", "created_at"],
+                orderBy: "`created_at` DESC",
+            });
+        });
+        result.match((plans) => {
+            const plansArray = plans;
+            if (!(0, utils_1.rootOpts)(cmd).json) {
+                if (plansArray.length > 0) {
+                    console.log("Plans:");
+                    plansArray.forEach((p) => {
+                        console.log(`  ${p.plan_id}  ${p.title}  (${p.status})`);
+                    });
+                }
+                else {
+                    console.log("No plans found.");
+                }
+            }
+            else {
+                console.log(JSON.stringify(plansArray, null, 2));
+            }
+        }, (error) => {
+            console.error(`Error listing plans: ${error.message}`);
+            if ((0, utils_1.rootOpts)(cmd).json) {
+                console.log(JSON.stringify({
+                    status: "error",
+                    code: error.code,
+                    message: error.message,
+                    cause: error.cause,
+                }));
+            }
+            process.exit(1);
+        });
+    });
+}
+function planNewCommand() {
+    return new commander_1.Command("new")
+        .description("Create a new plan")
+        .argument("<title>", "Title of the plan")
+        .option("--intent <intent>", "Intent of the plan", "")
+        .option("--source <path>", "Source path (e.g., plans/feature-x.md)")
+        .action(async (title, options, cmd) => {
+        const result = await (0, utils_1.readConfig)().asyncAndThen((config) => {
+            // Removed async, added type
+            const plan_id = (0, uuid_1.v4)();
+            const currentTimestamp = (0, query_1.now)();
+            const q = (0, query_1.query)(config.doltRepoPath);
+            return q
+                .insert("plan", {
+                plan_id,
+                title,
+                intent: options.intent,
+                source_path: options.source ?? null,
+                created_at: currentTimestamp,
+                updated_at: currentTimestamp,
+            })
+                .andThen(() => (0, commit_1.doltCommit)(`plan: create ${title}`, config.doltRepoPath, (0, utils_1.rootOpts)(cmd).noCommit))
+                .map(() => ({
+                plan_id,
+                title,
+                intent: options.intent,
+                source_path: options.source,
+            }));
+        });
+        result.match((data) => {
+            const resultData = data;
+            if (!(0, utils_1.rootOpts)(cmd).json) {
+                console.log(`Plan created with ID: ${resultData.plan_id}`);
+            }
+            else {
+                console.log(JSON.stringify(resultData, null, 2));
+            }
+        }, (error) => {
+            console.error(`Error creating plan: ${error.message}`);
+            if ((0, utils_1.rootOpts)(cmd).json) {
+                console.log(JSON.stringify({
+                    status: "error",
+                    code: error.code,
+                    message: error.message,
+                    cause: error.cause,
+                }));
+            }
+            process.exit(1);
+        });
+    });
+}