@danalexilewis/taskgraph 0.1.0

package/dist/cli/portfolio.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.portfolioCommand = portfolioCommand;
+const commander_1 = require("commander");
+const utils_1 = require("./utils"); // Import Config
+const neverthrow_1 = require("neverthrow");
+const errors_1 = require("../domain/errors");
+const query_1 = require("../db/query");
+function portfolioCommand(program) {
+    program
+        .command("portfolio")
+        .description("Analyze portfolio views")
+        .addCommand(portfolioOverlapsCommand())
+        .addCommand(portfolioHotspotsCommand());
+}
+function portfolioOverlapsCommand() {
+    return new commander_1.Command("overlaps")
+        .description("Find tasks shared by multiple feature_key")
+        .option("--min <count>", "Minimum number of features for overlap", "2")
+        .action(async (options, cmd) => {
+        const result = await (0, utils_1.readConfig)().asyncAndThen((config) => {
+            const q = (0, query_1.query)(config.doltRepoPath);
+            const minFeatures = parseInt(options.min, 10);
+            if (isNaN(minFeatures) || minFeatures <= 0) {
+                return (0, neverthrow_1.errAsync)((0, errors_1.buildError)(errors_1.ErrorCode.VALIDATION_FAILED, `Invalid min count: ${options.min}. Must be a positive integer.`));
+            }
+            const relatesOverlapsQuery = `
+          SELECT
+            t1.task_id, t1.title, t1.feature_key,
+            GROUP_CONCAT(DISTINCT t2.feature_key ORDER BY t2.feature_key) as related_features,
+            COUNT(DISTINCT t2.feature_key) as feature_count
+          FROM \`task\` t1
+          JOIN \`edge\` e ON t1.task_id = e.from_task_id AND e.type = 'relates'
+          JOIN \`task\` t2 ON e.to_task_id = t2.task_id
+          WHERE t1.feature_key IS NOT NULL AND t2.feature_key IS NOT NULL AND t1.feature_key != t2.feature_key
+          GROUP BY t1.task_id, t1.title, t1.feature_key
+          HAVING feature_count >= ${minFeatures} -1;
+        `;
+            const areaHotspotQuery = `
+          SELECT
+            area,
+            COUNT(DISTINCT task_id) as task_count,
+            GROUP_CONCAT(DISTINCT feature_key ORDER BY feature_key) as features_in_area,
+            COUNT(DISTINCT feature_key) as feature_key_count
+          FROM \`task\`
+          WHERE area IS NOT NULL
+          GROUP BY area
+          HAVING feature_key_count >= ${minFeatures};
+        `;
+            return q.raw(relatesOverlapsQuery).andThen((relatesOverlapsResult) => {
+                const relatesOverlaps = relatesOverlapsResult;
+                return q.raw(areaHotspotQuery).map((areaHotspotsResult) => {
+                    const areaHotspots = areaHotspotsResult;
+                    return { relatesOverlaps, areaHotspots };
+                });
+            });
+        });
+        result.match((data) => {
+            const resultData = data;
+            if (!cmd.parent?.opts().json) {
+                if (resultData.relatesOverlaps.length > 0) {
+                    console.log(`\nTasks with explicit 'relates' overlaps (min ${options.min} features):`);
+                    resultData.relatesOverlaps.forEach((overlap) => {
+                        console.log(`  - Task ID: ${overlap.task_id}, Title: ${overlap.title}, Features: ${overlap.feature_key}, ${overlap.related_features}`);
+                    });
+                }
+                if (resultData.areaHotspots.length > 0) {
+                    console.log(`\nAreas with tasks from multiple features (min ${options.min} features):`);
+                    resultData.areaHotspots.forEach((hotspot) => {
+                        console.log(`  - Area: ${hotspot.area}, Tasks: ${hotspot.task_count}, Features: ${hotspot.features_in_area}`);
+                    });
+                }
+                if (resultData.relatesOverlaps.length === 0 &&
+                    resultData.areaHotspots.length === 0) {
+                    console.log("No overlaps found based on current criteria.");
+                }
+            }
+            else {
+                console.log(JSON.stringify(resultData, null, 2));
+            }
+        }, (error) => {
+            console.error(`Error fetching portfolio overlaps: ${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);
+        });
+    });
+}
+function portfolioHotspotsCommand() {
+    return new commander_1.Command("hotspots")
+        .description("Counts tasks per area, plus tasks touched by multiple features")
+        .action(async (options, cmd) => {
+        const result = await (0, utils_1.readConfig)().asyncAndThen((config) => {
+            const q = (0, query_1.query)(config.doltRepoPath);
+            const tasksPerAreaQuery = `
+          SELECT area, COUNT(*) as task_count
+          FROM \`task\`
+          WHERE area IS NOT NULL
+          GROUP BY area
+          ORDER BY task_count DESC;
+        `;
+            const multiFeatureTasksQuery = `
+          SELECT task_id, title, GROUP_CONCAT(DISTINCT feature_key) as features
+          FROM \`task\`
+          WHERE feature_key IS NOT NULL
+          GROUP BY task_id, title
+          HAVING COUNT(DISTINCT feature_key) > 1;
+        `;
+            return q.raw(tasksPerAreaQuery).andThen((tasksPerAreaResult) => {
+                const tasksPerArea = tasksPerAreaResult;
+                return q.raw(multiFeatureTasksQuery).map((multiFeatureTasksResult) => {
+                    const multiFeatureTasks = multiFeatureTasksResult;
+                    return { tasksPerArea, multiFeatureTasks };
+                });
+            });
+        });
+        result.match((data) => {
+            const resultData = data;
+            if (!cmd.parent?.opts().json) {
+                if (resultData.tasksPerArea.length > 0) {
+                    console.log("\nTasks per Area:");
+                    resultData.tasksPerArea.forEach((item) => {
+                        console.log(`  - Area: ${item.area}, Tasks: ${item.task_count}`);
+                    });
+                }
+                if (resultData.multiFeatureTasks.length > 0) {
+                    console.log("\nTasks touched by multiple features:");
+                    resultData.multiFeatureTasks.forEach((item) => {
+                        console.log(`  - Task ID: ${item.task_id}, Title: ${item.title}, Features: ${item.features}`);
+                    });
+                }
+                if (resultData.tasksPerArea.length === 0 &&
+                    resultData.multiFeatureTasks.length === 0) {
+                    console.log("No hotspots found.");
+                }
+            }
+            else {
+                console.log(JSON.stringify(resultData, null, 2));
+            }
+        }, (error) => {
+            console.error(`Error fetching portfolio hotspots: ${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/setup.js

@@ -0,0 +1,142 @@
+"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.setupCommand = setupCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const neverthrow_1 = require("neverthrow");
+const errors_1 = require("../domain/errors");
+function copyTree(srcDir, destDir, repoRoot, options, result) {
+    const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(srcDir, entry.name);
+        const destPath = path.join(destDir, entry.name);
+        if (entry.isDirectory()) {
+            if (!fs.existsSync(destPath)) {
+                fs.mkdirSync(destPath, { recursive: true });
+            }
+            copyTree(srcPath, destPath, repoRoot, options, result);
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        const rel = path.relative(repoRoot, destPath);
+        if (fs.existsSync(destPath) && !options.force) {
+            result.skipped.push(rel);
+            continue;
+        }
+        fs.mkdirSync(path.dirname(destPath), { recursive: true });
+        fs.copyFileSync(srcPath, destPath);
+        result.created.push(rel);
+    }
+}
+function setupCommand(program) {
+    program
+        .command("setup")
+        .description("Scaffold repo conventions (docs/skills, example domain docs, and optional Cursor rules)")
+        .option("--no-docs", "Do not scaffold docs/ (domain docs + docs/skills)")
+        .option("--no-cursor", "Do not scaffold Cursor rules (.cursor/rules) and .cursor/memory.md")
+        .option("--force", "Overwrite existing files", false)
+        .action(async (rawOptions, cmd) => {
+        const raw = rawOptions;
+        const options = {
+            docs: raw.docs ?? true,
+            cursor: raw.cursor ?? true,
+            force: raw.force ?? false,
+        };
+        const repoRoot = process.cwd();
+        // At runtime this file is at dist/cli/setup.js; templates live at dist/template.
+        const templateRoot = path.join(__dirname, "..", "template");
+        const run = () => {
+            const result = { created: [], skipped: [] };
+            if (!fs.existsSync(templateRoot)) {
+                throw (0, errors_1.buildError)(errors_1.ErrorCode.FILE_READ_FAILED, `Template directory missing: ${templateRoot}`);
+            }
+            if (options.docs) {
+                const docsSrc = path.join(templateRoot, "docs");
+                copyTree(docsSrc, path.join(repoRoot, "docs"), repoRoot, options, result);
+            }
+            if (options.cursor) {
+                const cursorSrc = path.join(templateRoot, ".cursor");
+                copyTree(cursorSrc, path.join(repoRoot, ".cursor"), repoRoot, options, result);
+                const agentMdSrc = path.join(templateRoot, "AGENT.md");
+                const agentMdDest = path.join(repoRoot, "AGENT.md");
+                if (fs.existsSync(agentMdSrc)) {
+                    const rel = path.relative(repoRoot, agentMdDest);
+                    if (fs.existsSync(agentMdDest) && !options.force) {
+                        result.skipped.push(rel);
+                    }
+                    else {
+                        fs.copyFileSync(agentMdSrc, agentMdDest);
+                        result.created.push(rel);
+                    }
+                }
+            }
+            const json = Boolean(cmd.parent?.opts().json);
+            if (json) {
+                console.log(JSON.stringify({
+                    status: "ok",
+                    created: result.created.sort(),
+                    skipped: result.skipped.sort(),
+                }));
+                return;
+            }
+            console.log("TaskGraph scaffold complete.");
+            if (result.created.length > 0) {
+                console.log("Created:");
+                result.created.sort().forEach((p) => console.log(`  + ${p}`));
+            }
+            if (result.skipped.length > 0) {
+                console.log("Skipped (already exists):");
+                result.skipped.sort().forEach((p) => console.log(`  = ${p}`));
+                console.log("Tip: re-run with --force to overwrite.");
+            }
+        };
+        const res = await neverthrow_1.ResultAsync.fromPromise(Promise.resolve().then(run), (e) => (0, errors_1.buildError)(errors_1.ErrorCode.FILE_READ_FAILED, "Failed to scaffold repo files", e));
+        res.match(() => { }, (error) => {
+            const appError = error;
+            console.error(`Error: ${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/show.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showCommand = showCommand;
+const utils_1 = require("./utils"); // Import Config
+const neverthrow_1 = require("neverthrow");
+const errors_1 = require("../domain/errors");
+const query_1 = require("../db/query");
+function showCommand(program) {
+    program
+        .command("show")
+        .description("Prints task details, blockers, dependents, and recent events")
+        .argument("<taskId>", "ID of the task to show")
+        .action(async (taskId, options, cmd) => {
+        const result = await (0, utils_1.readConfig)().asyncAndThen((config) => {
+            const q = (0, query_1.query)(config.doltRepoPath);
+            return neverthrow_1.ResultAsync.fromPromise((async () => {
+                const taskDetailQueryResult = await q.raw(`SELECT t.*, p.title as plan_title
+              FROM \`task\` t
+              JOIN \`plan\` p ON t.plan_id = p.plan_id
+              WHERE t.task_id = '${taskId}';`);
+                if (taskDetailQueryResult.isErr())
+                    throw taskDetailQueryResult.error;
+                const taskDetailsArray = taskDetailQueryResult.value;
+                if (taskDetailsArray.length === 0) {
+                    throw (0, errors_1.buildError)(errors_1.ErrorCode.TASK_NOT_FOUND, `Task with ID ${taskId} not found.`);
+                }
+                const taskDetails = taskDetailsArray[0];
+                const blockersResult = await q.raw(`
+              SELECT e.from_task_id, t.title, t.status, e.reason
+              FROM \`edge\` e
+              JOIN \`task\` t ON e.from_task_id = t.task_id
+              WHERE e.to_task_id = '${taskId}' AND e.type = 'blocks';
+            `);
+                const blockers = blockersResult.isOk() ? blockersResult.value : [];
+                const dependentsResult = await q.raw(`
+              SELECT e.to_task_id, e.type, t.title, t.status, e.reason
+              FROM \`edge\` e
+              JOIN \`task\` t ON e.to_task_id = t.task_id
+              WHERE e.from_task_id = '${taskId}';
+            `);
+                const dependents = dependentsResult.isOk()
+                    ? dependentsResult.value
+                    : [];
+                const eventsResult = await q.raw(`
+              SELECT kind, body, created_at, actor
+              FROM \`event\`
+              WHERE task_id = '${taskId}'
+              ORDER BY created_at DESC
+              LIMIT 10;
+            `);
+                const events = eventsResult.isOk() ? eventsResult.value : [];
+                const noteEvents = events.filter((e) => e.kind === "note");
+                const domainsResult = await q.select("task_domain", { columns: ["domain"], where: { task_id: taskId } });
+                const skillsResult = await q.select("task_skill", { columns: ["skill"], where: { task_id: taskId } });
+                const domains = domainsResult.isOk()
+                    ? domainsResult.value.map((r) => r.domain)
+                    : [];
+                const skills = skillsResult.isOk()
+                    ? skillsResult.value.map((r) => r.skill)
+                    : [];
+                return {
+                    taskDetails,
+                    blockers,
+                    dependents,
+                    events,
+                    noteEvents,
+                    domains,
+                    skills,
+                };
+            })(), (e) => e);
+        });
+        result.match((data) => {
+            const resultData = data;
+            if (!cmd.parent?.opts().json) {
+                const task = resultData.taskDetails;
+                console.log(`Task Details (ID: ${task.task_id}):`);
+                console.log(`  Title: ${task.title}`);
+                console.log(`  Plan: ${task.plan_title} (ID: ${task.plan_id})`);
+                console.log(`  Status: ${task.status}`);
+                console.log(`  Owner: ${task.owner}`);
+                console.log(`  Area: ${task.area ?? "N/A"}`);
+                if (resultData.domains.length > 0)
+                    console.log(`  Domains: ${resultData.domains.join(", ")}`);
+                if (resultData.skills.length > 0)
+                    console.log(`  Skills: ${resultData.skills.join(", ")}`);
+                console.log(`  Risk: ${task.risk}`);
+                console.log(`  Estimate: ${task.estimate_mins ?? "N/A"} minutes`);
+                console.log(`  Intent: ${task.intent ?? "N/A"}`);
+                console.log(`  Scope In: ${task.scope_in ?? "N/A"}`);
+                console.log(`  Scope Out: ${task.scope_out ?? "N/A"}`);
+                console.log(`  Acceptance: ${task.acceptance ? JSON.stringify(task.acceptance) : "N/A"}`);
+                console.log(`  Created At: ${task.created_at}`);
+                console.log(`  Updated At: ${task.updated_at}`);
+                if (resultData.blockers.length > 0) {
+                    console.log("\nBlockers:");
+                    resultData.blockers.forEach((b) => {
+                        console.log(`  - Task ID: ${b.from_task_id}, Title: ${b.title}, Status: ${b.status}, Reason: ${b.reason ?? "N/A"}`);
+                    });
+                }
+                if (resultData.dependents.length > 0) {
+                    console.log("\nDependents:");
+                    resultData.dependents.forEach((d) => {
+                        const edge = d;
+                        const typeInfo = edge.type ? `, Type: ${edge.type}` : "";
+                        console.log(`  - Task ID: ${edge.to_task_id}, Title: ${edge.title}, Status: ${edge.status}${typeInfo}, Reason: ${edge.reason ?? "N/A"}`);
+                    });
+                }
+                if (resultData.noteEvents.length > 0) {
+                    console.log("\nRecent Notes:");
+                    resultData.noteEvents.slice(0, 5).forEach((e) => {
+                        const body = typeof e.body === "string"
+                            ? JSON.parse(e.body)
+                            : e.body;
+                        const msg = body?.message ?? JSON.stringify(e.body);
+                        const agent = body?.agent ?? e.actor ?? "unknown";
+                        console.log(`  - [${e.created_at}] ${agent}: ${msg}`);
+                    });
+                }
+                if (resultData.events.length > 0) {
+                    console.log("\nRecent Events:");
+                    resultData.events.forEach((e) => {
+                        console.log(`  - Kind: ${e.kind}, Actor: ${e.actor}, Created: ${e.created_at}, Body: ${JSON.stringify(e.body)}`);
+                    });
+                }
+            }
+            else {
+                console.log(JSON.stringify(resultData, null, 2));
+            }
+        }, (error) => {
+            console.error(`Error showing task: ${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/split.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitCommand = splitCommand;
+const uuid_1 = require("uuid");
+const commit_1 = require("../db/commit");
+const utils_1 = require("./utils"); // Import Config
+const types_1 = require("../domain/types");
+const neverthrow_1 = require("neverthrow");
+const errors_1 = require("../domain/errors");
+const query_1 = require("../db/query");
+function splitCommand(program) {
+    program
+        .command("split")
+        .description("Decompose a task into multiple subtasks")
+        .argument("<taskId>", "ID of the task to split")
+        .requiredOption("--into <titles>", "Pipe-separated titles of new subtasks (e.g., 'Task 1|Task 2')")
+        .option("--keep-original", "Keep the original task as a parent (default: true)", true)
+        .option("--link-direction <direction>", "Direction of the new edges (original-to-new or new-to-original)", "original-to-new")
+        .action(async (taskId, options, cmd) => {
+        const result = await (0, utils_1.readConfig)().asyncAndThen((config) => {
+            // Removed async, added type
+            const currentTimestamp = (0, query_1.now)();
+            return neverthrow_1.ResultAsync.fromPromise((async () => {
+                const q = (0, query_1.query)(config.doltRepoPath);
+                const originalTaskQueryResult = await q.select("task", {
+                    where: { task_id: taskId },
+                });
+                if (originalTaskQueryResult.isErr())
+                    throw originalTaskQueryResult.error;
+                const originalTasks = originalTaskQueryResult.value;
+                if (originalTasks.length === 0) {
+                    throw (0, errors_1.buildError)(errors_1.ErrorCode.TASK_NOT_FOUND, `Task with ID ${taskId} not found.`);
+                }
+                const originalTask = originalTasks[0];
+                const originalDomainsResult = await q.select("task_domain", { columns: ["domain"], where: { task_id: taskId } });
+                const originalSkillsResult = await q.select("task_skill", { columns: ["skill"], where: { task_id: taskId } });
+                const originalDomains = originalDomainsResult.isOk()
+                    ? originalDomainsResult.value
+                    : [];
+                const originalSkills = originalSkillsResult.isOk()
+                    ? originalSkillsResult.value
+                    : [];
+                const newTitles = options.into
+                    .split("|")
+                    .map((s) => s.trim());
+                const newTasks = [];
+                const taskMappings = [];
+                for (const title of newTitles) {
+                    const newTaskId = (0, uuid_1.v4)();
+                    const newTask = {
+                        task_id: newTaskId,
+                        plan_id: originalTask.plan_id,
+                        feature_key: originalTask.feature_key,
+                        title: title,
+                        intent: originalTask.intent,
+                        scope_in: originalTask.scope_in,
+                        scope_out: originalTask.scope_out,
+                        acceptance: originalTask.acceptance,
+                        status: types_1.TaskStatusSchema.enum.todo, // New tasks start as todo
+                        owner: originalTask.owner,
+                        area: originalTask.area,
+                        risk: originalTask.risk,
+                        estimate_mins: null, // Estimate can be re-evaluated for subtasks
+                        created_at: currentTimestamp,
+                        updated_at: currentTimestamp,
+                        external_key: null,
+                        change_type: originalTask.change_type ?? null,
+                        suggested_changes: originalTask.suggested_changes ?? null,
+                    };
+                    newTasks.push(newTask);
+                    taskMappings.push({ original: taskId, new: newTaskId });
+                    const insertTaskResult = await q.insert("task", {
+                        task_id: newTask.task_id,
+                        plan_id: newTask.plan_id,
+                        feature_key: newTask.feature_key ?? null,
+                        title: newTask.title,
+                        intent: newTask.intent ?? null,
+                        scope_in: newTask.scope_in ?? null,
+                        scope_out: newTask.scope_out ?? null,
+                        acceptance: newTask.acceptance
+                            ? (0, query_1.jsonObj)({ val: JSON.stringify(newTask.acceptance) })
+                            : null,
+                        status: newTask.status,
+                        owner: newTask.owner,
+                        area: newTask.area ?? null,
+                        risk: newTask.risk,
+                        estimate_mins: newTask.estimate_mins ?? null,
+                        created_at: newTask.created_at,
+                        updated_at: newTask.updated_at,
+                        external_key: newTask.external_key ?? null,
+                        change_type: newTask.change_type ?? null,
+                        suggested_changes: newTask.suggested_changes ?? null,
+                    });
+                    if (insertTaskResult.isErr())
+                        throw (0, errors_1.buildError)(errors_1.ErrorCode.DB_QUERY_FAILED, "Failed to insert new task", insertTaskResult.error);
+                    const insertNewTaskEventResult = await q.insert("event", {
+                        event_id: (0, uuid_1.v4)(),
+                        task_id: newTask.task_id,
+                        kind: "created",
+                        body: (0, query_1.jsonObj)({ title: newTask.title, splitFrom: taskId }),
+                        created_at: currentTimestamp,
+                    });
+                    if (insertNewTaskEventResult.isErr())
+                        throw (0, errors_1.buildError)(errors_1.ErrorCode.DB_QUERY_FAILED, "Failed to insert new task event", insertNewTaskEventResult.error);
+                    for (const { domain } of originalDomains) {
+                        const dr = await q.insert("task_domain", {
+                            task_id: newTask.task_id,
+                            domain,
+                        });
+                        if (dr.isErr())
+                            throw dr.error;
+                    }
+                    for (const { skill } of originalSkills) {
+                        const sr = await q.insert("task_skill", {
+                            task_id: newTask.task_id,
+                            skill,
+                        });
+                        if (sr.isErr())
+                            throw sr.error;
+                    }
+                    let fromId = taskId;
+                    let toId = newTask.task_id;
+                    if (options.linkDirection === "new-to-original") {
+                        fromId = newTask.task_id;
+                        toId = taskId;
+                    }
+                    const insertEdgeResult = await q.insert("edge", {
+                        from_task_id: fromId,
+                        to_task_id: toId,
+                        type: "relates",
+                        reason: "split dependency",
+                    });
+                    if (insertEdgeResult.isErr())
+                        throw (0, errors_1.buildError)(errors_1.ErrorCode.DB_QUERY_FAILED, "Failed to insert new edge", insertEdgeResult.error);
+                }
+                if (!options.keepOriginal) {
+                    const updateOriginalTaskResult = await q.update("task", { status: "canceled", updated_at: currentTimestamp }, { task_id: taskId });
+                    if (updateOriginalTaskResult.isErr())
+                        throw (0, errors_1.buildError)(errors_1.ErrorCode.DB_QUERY_FAILED, "Failed to update original task", updateOriginalTaskResult.error);
+                }
+                const insertSplitEventResult = await q.insert("event", {
+                    event_id: (0, uuid_1.v4)(),
+                    task_id: taskId,
+                    kind: "split",
+                    body: (0, query_1.jsonObj)({
+                        newTasks: newTasks.map((t) => ({
+                            id: t.task_id,
+                            title: t.title,
+                        })),
+                        taskMappings,
+                    }),
+                    created_at: currentTimestamp,
+                });
+                if (insertSplitEventResult.isErr())
+                    throw (0, errors_1.buildError)(errors_1.ErrorCode.DB_QUERY_FAILED, "Failed to insert split event", insertSplitEventResult.error);
+                const commitResult = await (0, commit_1.doltCommit)(`task: split ${taskId} into ${newTitles.join(", ")}`, config.doltRepoPath, cmd.parent?.opts().noCommit);
+                if (commitResult.isErr())
+                    throw commitResult.error;
+                return {
+                    original_task_id: taskId,
+                    new_tasks: newTasks.map((t) => ({
+                        task_id: t.task_id,
+                        title: t.title,
+                    })),
+                    status: options.keepOriginal ? originalTask.status : "canceled",
+                };
+            })(), (e) => e);
+        });
+        result.match((data) => {
+            const resultData = data;
+            if (!cmd.parent?.opts().json) {
+                console.log(`Task ${resultData.original_task_id} split into new tasks.`);
+                resultData.new_tasks.forEach((task) => console.log(`  - ${task.title} (ID: ${task.task_id})`));
+            }
+            else {
+                console.log(JSON.stringify(resultData, null, 2));
+            }
+        }, (error) => {
+            console.error(`Error splitting task: ${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);
+        });
+    });
+}