@bicorne/task-flow 0.2.0 → 0.2.1

package/dist/slash/executor.js

@@ -1,366 +1,335 @@
-"use strict";
-/**
- * slash/executor.ts
- * Execute slash commands by dispatching to the appropriate command modules.
- * Supports both single commands and composite (multi-step) commands.
- */
-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.executeSlashCommand = executeSlashCommand;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const registry_1 = require("./registry");
-const extract_1 = require("../commands/extract");
-const design_1 = require("../commands/design");
-const tasks_gen_1 = require("../commands/tasks-gen");
-const worktree_1 = require("../commands/worktree");
-const init_1 = require("../commands/init");
-const status_1 = require("../commands/status");
-const archive_1 = require("../lib/archive");
-const merge_1 = require("../commands/merge");
-const sync_task_to_openspec_1 = require("../spec/sync-task-to-openspec");
-const analyze_1 = require("../commands/analyze");
-const config_1 = require("../lib/config");
-function extractChangeName(parsed) {
-    const firstArg = parsed.args[0];
-    if (firstArg && !firstArg.startsWith('--')) {
-        return firstArg;
-    }
-    for (let i = 0; i < parsed.args.length - 1; i += 1) {
-        if (parsed.args[i] === '--change' || parsed.args[i] === '--task-id') {
-            return parsed.args[i + 1];
-        }
-    }
-    return undefined;
+function e(s) {
+    return "function" != typeof WeakMap ? null : (e = function(e) {
+        return new WeakMap();
+    })(s);
 }
-function extractTaskId(parsed) {
-    for (let i = 0; i < parsed.args.length - 1; i += 1) {
-        if (parsed.args[i] === '--task-id') {
-            return parsed.args[i + 1];
-        }
-    }
-    const firstArg = parsed.args[0];
-    if (firstArg && !firstArg.startsWith('--')) {
-        return firstArg;
+function s(s, t) {
+    var a, r, n;
+    if (!t && s && s.__esModule) return s;
+    if (null === s || "object" != typeof s && "function" != typeof s) return {
+        default: s
+    };
+    if ((a = e(t)) && a.has(s)) return a.get(s);
+    for(var c in r = {
+        __proto__: null
+    }, n = Object.defineProperty && Object.getOwnPropertyDescriptor, s)if ("default" !== c && Object.prototype.hasOwnProperty.call(s, c)) {
+        var o = n ? Object.getOwnPropertyDescriptor(s, c) : null;
+        o && (o.get || o.set) ? Object.defineProperty(r, c, o) : r[c] = s[c];
     }
-    return undefined;
+    return r.default = s, a && a.set(s, r), r;
 }
-function extractFlagValue(parsed, flag) {
-    const idx = parsed.args.indexOf(`--${flag}`);
-    if (idx === -1 || idx + 1 >= parsed.args.length) {
-        return undefined;
-    }
-    return parsed.args[idx + 1];
+function t(e, s) {
+    let t = e.args.indexOf(`--${s}`);
+    if (-1 !== t && !(t + 1 >= e.args.length)) return e.args[t + 1];
 }
-function hasFlag(parsed, flag) {
-    return parsed.args.includes(`--${flag}`) || parsed.args.includes(`-${flag}`);
+function a(e, s) {
+    return e.args.includes(`--${s}`) || e.args.includes(`-${s}`);
 }
-async function executeSingleCommand(commandName, changeName, taskId, parsed, extraContextFile) {
-    const contextFile = extractFlagValue(parsed, 'context-file') || extraContextFile;
-    switch (commandName) {
-        case 'extract': {
-            if (!changeName) {
-                return { step: 'extract', success: false, message: 'Missing change name. Usage: /tf:extract <change-name>' };
+async function r(e, s, r, n, c) {
+    let o = t(n, 'context-file') || c;
+    switch(e){
+        case 'extract':
+            {
+                if (!s) return {
+                    step: 'extract',
+                    success: !1,
+                    message: 'Missing change name. Usage: /tf:extract <change-name>'
+                };
+                let e = await (0, m.extract)({
+                    change: s,
+                    force: a(n, 'force'),
+                    contextFile: o
+                });
+                return {
+                    step: 'extract',
+                    success: e.success,
+                    message: e.success ? `PRD created: ${e.prdPath}` : e.message,
+                    detail: e.success ? {
+                        prdPath: e.prdPath,
+                        changeDir: e.changeDir
+                    } : void 0
+                };
             }
-            const result = await (0, extract_1.extract)({
-                change: changeName,
-                force: hasFlag(parsed, 'force'),
-                contextFile,
-            });
-            return {
-                step: 'extract',
-                success: result.success,
-                message: result.success ? `PRD created: ${result.prdPath}` : result.message,
-                detail: result.success ? { prdPath: result.prdPath, changeDir: result.changeDir } : undefined,
-            };
-        }
-        case 'design': {
-            if (!changeName) {
-                return { step: 'design', success: false, message: 'Missing change name. Usage: /tf:design <change-name>' };
+        case 'design':
+            {
+                if (!s) return {
+                    step: 'design',
+                    success: !1,
+                    message: 'Missing change name. Usage: /tf:design <change-name>'
+                };
+                let e = await (0, g.generateDesign)({
+                    change: s,
+                    force: a(n, 'force'),
+                    skipPrompt: !0,
+                    contextFile: o
+                });
+                return {
+                    step: 'design',
+                    success: e.success,
+                    message: e.success ? `Design created: ${e.designPath}` : e.message,
+                    detail: e.success ? {
+                        designPath: e.designPath
+                    } : void 0
+                };
             }
-            const result = await (0, design_1.generateDesign)({
-                change: changeName,
-                force: hasFlag(parsed, 'force'),
-                skipPrompt: true,
-                contextFile,
-            });
-            return {
-                step: 'design',
-                success: result.success,
-                message: result.success ? `Design created: ${result.designPath}` : result.message,
-                detail: result.success ? { designPath: result.designPath } : undefined,
-            };
-        }
-        case 'tasks': {
-            if (!changeName) {
-                return { step: 'tasks', success: false, message: 'Missing change name. Usage: /tf:tasks <change-name>' };
-            }
-            const result = await (0, tasks_gen_1.generateTasks)({
-                change: changeName,
-                yes: true,
-            });
-            return {
-                step: 'tasks',
-                success: result.success,
-                message: result.success ? `Tasks generated: ${result.generatedFiles?.length || 0} files` : result.message,
-                detail: result.success ? { tasksDir: result.tasksDir, manifestPath: result.manifestPath } : undefined,
-            };
-        }
-        case 'worktree': {
-            if (!changeName) {
-                return { step: 'worktree', success: false, message: 'Missing change name. Usage: /tf:worktree <change-name>' };
+        case 'tasks':
+            {
+                if (!s) return {
+                    step: 'tasks',
+                    success: !1,
+                    message: 'Missing change name. Usage: /tf:tasks <change-name>'
+                };
+                let e = await (0, l.generateTasks)({
+                    change: s,
+                    yes: !0
+                });
+                return {
+                    step: 'tasks',
+                    success: e.success,
+                    message: e.success ? `Tasks generated: ${e.generatedFiles?.length || 0} files` : e.message,
+                    detail: e.success ? {
+                        tasksDir: e.tasksDir,
+                        manifestPath: e.manifestPath
+                    } : void 0
+                };
             }
-            const result = await (0, worktree_1.createWorktree)({
-                change: changeName,
-                yes: true,
-            });
-            return {
-                step: 'worktree',
-                success: result.success,
-                message: result.success ? `Worktree created: ${result.worktreePath}` : result.message,
-                detail: result.success ? { worktreePath: result.worktreePath, branchName: result.branchName } : undefined,
-            };
-        }
-        case 'init': {
-            const result = (0, init_1.initHarness)({
-                force: hasFlag(parsed, 'force'),
-            });
-            return {
-                step: 'init',
-                success: result.success,
-                message: result.success ? 'Task flow initialized' : result.message,
-            };
-        }
-        case 'status': {
-            (0, status_1.showStatus)({});
-            return { step: 'status', success: true, message: 'Status displayed' };
-        }
-        case 'archive': {
-            const tid = taskId || changeName;
-            if (!tid) {
-                return { step: 'archive', success: false, message: 'Missing task ID. Usage: /tf:archive --task-id <id>' };
+        case 'worktree':
+            {
+                if (!s) return {
+                    step: 'worktree',
+                    success: !1,
+                    message: 'Missing change name. Usage: /tf:worktree <change-name>'
+                };
+                let e = await (0, d.createWorktree)({
+                    change: s,
+                    yes: !0
+                });
+                return {
+                    step: 'worktree',
+                    success: e.success,
+                    message: e.success ? `Worktree created: ${e.worktreePath}` : e.message,
+                    detail: e.success ? {
+                        worktreePath: e.worktreePath,
+                        branchName: e.branchName
+                    } : void 0
+                };
             }
-            const result = (0, archive_1.archiveTaskState)({
-                taskId: tid,
-                eventType: 'task_completed',
-                status: 'completed',
-            });
-            if ('skipped' in result && result.skipped) {
-                return { step: 'archive', success: true, message: `Skipped: ${result.reason}` };
+        case 'init':
+            {
+                let e = (0, f.initHarness)({
+                    force: a(n, 'force')
+                });
+                return {
+                    step: 'init',
+                    success: e.success,
+                    message: e.success ? 'Task flow initialized' : e.message
+                };
             }
-            return {
-                step: 'archive',
-                success: true,
-                message: `Archived: ${result.archivePath}`,
+        case 'status':
+            return (0, p.showStatus)({}), {
+                step: 'status',
+                success: !0,
+                message: 'Status displayed'
             };
-        }
-        case 'merge': {
-            const tid = taskId || changeName;
-            if (!tid) {
-                return { step: 'merge', success: false, message: 'Missing task ID. Usage: /tf:merge <task-id>' };
+        case 'archive':
+            {
+                let e = r || s;
+                if (!e) return {
+                    step: 'archive',
+                    success: !1,
+                    message: 'Missing task ID. Usage: /tf:archive --task-id <id>'
+                };
+                let t = (0, h.archiveTaskState)({
+                    taskId: e,
+                    eventType: 'task_completed',
+                    status: 'completed'
+                });
+                if ('skipped' in t && t.skipped) return {
+                    step: 'archive',
+                    success: !0,
+                    message: `Skipped: ${t.reason}`
+                };
+                return {
+                    step: 'archive',
+                    success: !0,
+                    message: `Archived: ${t.archivePath}`
+                };
             }
-            const result = (0, merge_1.mergeTask)({
-                taskId: tid,
-                skipReviewCheck: hasFlag(parsed, 'skip-review-check'),
-                dryRun: hasFlag(parsed, 'dry-run'),
-            });
-            return {
-                step: 'merge',
-                success: result.success,
-                message: result.success ? `Merged: ${result.taskId}` : result.message,
-            };
-        }
-        case 'sync': {
-            const tid = taskId || changeName;
-            if (!tid) {
-                return { step: 'sync', success: false, message: 'Missing task ID. Usage: /tf:sync --task-id <id>' };
+        case 'merge':
+            {
+                let e = r || s;
+                if (!e) return {
+                    step: 'merge',
+                    success: !1,
+                    message: 'Missing task ID. Usage: /tf:merge <task-id>'
+                };
+                let t = (0, k.mergeTask)({
+                    taskId: e,
+                    skipReviewCheck: a(n, 'skip-review-check'),
+                    dryRun: a(n, 'dry-run')
+                });
+                return {
+                    step: 'merge',
+                    success: t.success,
+                    message: t.success ? `Merged: ${t.taskId}` : t.message
+                };
             }
-            const result = (0, sync_task_to_openspec_1.syncTaskToSpec)({ taskId: tid });
-            if (result.skipped) {
-                return { step: 'sync', success: true, message: `Skipped: ${result.reason}` };
+        case 'sync':
+            {
+                let e = r || s;
+                if (!e) return {
+                    step: 'sync',
+                    success: !1,
+                    message: 'Missing task ID. Usage: /tf:sync --task-id <id>'
+                };
+                let t = (0, y.syncTaskToSpec)({
+                    taskId: e
+                });
+                if (t.skipped) return {
+                    step: 'sync',
+                    success: !0,
+                    message: `Skipped: ${t.reason}`
+                };
+                return {
+                    step: 'sync',
+                    success: !0,
+                    message: 'Synced'
+                };
             }
-            return { step: 'sync', success: true, message: 'Synced' };
-        }
         default:
-            return { step: commandName, success: false, message: `Unknown command: ${commandName}` };
-    }
-}
-function findExistingContextFile(projectRoot) {
-    const candidatePaths = [
-        path.resolve(projectRoot, 'context.json'),
-        path.resolve(projectRoot, '.harness', 'context.json'),
-        path.resolve(projectRoot, '.tmp', 'context.json'),
-    ];
-    for (const p of candidatePaths) {
-        if (fs.existsSync(p)) {
-            return p;
-        }
-    }
-    return null;
-}
-function generateTempContextFile(projectRoot) {
-    const tmpDir = path.resolve(projectRoot, '.tmp');
-    if (!fs.existsSync(tmpDir)) {
-        fs.mkdirSync(tmpDir, { recursive: true });
-    }
-    const contextPath = path.resolve(tmpDir, 'context.json');
-    const result = (0, analyze_1.analyzeProject)({ cwd: projectRoot, output: contextPath });
-    if (!result.success || !result.outputPath) {
-        throw new Error(`Failed to generate context: ${result.message}`);
+            return {
+                step: e,
+                success: !1,
+                message: `Unknown command: ${e}`
+            };
     }
-    return result.outputPath;
 }
-async function executeCompositeCommand(cmdDef, changeName, taskId, parsed) {
-    const steps = cmdDef.steps || [];
-    const stepResults = [];
-    let contextFile;
-    console.log(`[SLASH] Executing composite command: /tf:${cmdDef.name}`);
-    console.log(`[SLASH] Steps: ${steps.join(' → ')}`);
-    console.log('');
-    if (cmdDef.name === 'propose') {
-        const explicitContextFile = extractFlagValue(parsed, 'context-file');
-        if (explicitContextFile) {
-            console.log(`[SLASH] ✓ Using explicit context: ${explicitContextFile}`);
-            contextFile = explicitContextFile;
-        }
+async function n(e, s, a, n) {
+    let c, u = e.steps || [], m = [];
+    if (console.log(`[SLASH] Executing composite command: /tf:${e.name}`), console.log(`[SLASH] Steps: ${u.join(' → ')}`), console.log(''), 'propose' === e.name) {
+        let r = t(n, 'context-file');
+        if (r) console.log(`[SLASH] ✓ Using explicit context: ${r}`), c = r;
         else {
-            const config = (0, config_1.loadConfig)({});
-            const projectRoot = config.projectRoot || process.cwd();
-            const existingContext = findExistingContextFile(projectRoot);
-            if (existingContext) {
-                console.log(`[SLASH] ✓ Using existing context: ${existingContext}`);
-                contextFile = existingContext;
-            }
+            let t = (0, S.loadConfig)({}).projectRoot || process.cwd(), r = function(e) {
+                for (let s of [
+                    i.resolve(e, 'context.json'),
+                    i.resolve(e, '.harness', 'context.json'),
+                    i.resolve(e, '.tmp', 'context.json')
+                ])if (o.existsSync(s)) return s;
+                return null;
+            }(t);
+            if (r) console.log(`[SLASH] ✓ Using existing context: ${r}`), c = r;
             else {
                 console.log('[SLASH] → Step: analyze (auto)');
                 try {
-                    contextFile = generateTempContextFile(projectRoot);
-                    console.log(`[SLASH] ✓ analyze: Context generated at ${contextFile}`);
-                    stepResults.push({
+                    c = function(e) {
+                        let s = i.resolve(e, '.tmp');
+                        o.existsSync(s) || o.mkdirSync(s, {
+                            recursive: !0
+                        });
+                        let t = i.resolve(s, 'context.json'), a = (0, $.analyzeProject)({
+                            cwd: e,
+                            output: t
+                        });
+                        if (!a.success || !a.outputPath) throw Error(`Failed to generate context: ${a.message}`);
+                        return a.outputPath;
+                    }(t), console.log(`[SLASH] ✓ analyze: Context generated at ${c}`), m.push({
                         step: 'analyze',
-                        success: true,
-                        message: `Context generated: ${contextFile}`,
-                        detail: { contextPath: contextFile },
+                        success: !0,
+                        message: `Context generated: ${c}`,
+                        detail: {
+                            contextPath: c
+                        }
                     });
-                }
-                catch (error) {
-                    const errorMsg = error instanceof Error ? error.message : 'Unknown error';
-                    console.log(`[SLASH] ✗ analyze: ${errorMsg}`);
-                    return {
-                        success: false,
-                        command: cmdDef.name,
-                        changeName,
-                        taskId,
-                        steps: stepResults,
-                        message: `Failed to generate context: ${errorMsg}`,
-                        error: errorMsg,
+                } catch (r) {
+                    let t = r instanceof Error ? r.message : 'Unknown error';
+                    return console.log(`[SLASH] ✗ analyze: ${t}`), {
+                        success: !1,
+                        command: e.name,
+                        changeName: s,
+                        taskId: a,
+                        steps: m,
+                        message: `Failed to generate context: ${t}`,
+                        error: t
                     };
                 }
                 console.log('');
             }
         }
     }
-    for (const step of steps) {
-        console.log(`[SLASH] → Step: ${step}`);
-        const result = await executeSingleCommand(step, changeName, taskId, parsed, contextFile);
-        stepResults.push(result);
-        if (result.success) {
-            console.log(`[SLASH] ✓ ${step}: ${result.message || 'OK'}`);
-        }
-        else {
-            console.log(`[SLASH] ✗ ${step}: ${result.message || 'Failed'}`);
-            return {
-                success: false,
-                command: cmdDef.name,
-                changeName,
-                taskId,
-                steps: stepResults,
-                message: `Composite command "${cmdDef.name}" failed at step "${step}": ${result.message}`,
-                error: result.message,
-            };
-        }
-        console.log('');
+    for (let t of u){
+        console.log(`[SLASH] → Step: ${t}`);
+        let o = await r(t, s, a, n, c);
+        if (m.push(o), !o.success) return console.log(`[SLASH] ✗ ${t}: ${o.message || 'Failed'}`), {
+            success: !1,
+            command: e.name,
+            changeName: s,
+            taskId: a,
+            steps: m,
+            message: `Composite command "${e.name}" failed at step "${t}": ${o.message}`,
+            error: o.message
+        };
+        console.log(`[SLASH] ✓ ${t}: ${o.message || 'OK'}`), console.log('');
     }
     return {
-        success: true,
-        command: cmdDef.name,
-        changeName,
-        taskId,
-        steps: stepResults,
-        message: `Composite command "/tf:${cmdDef.name}" completed successfully`,
+        success: !0,
+        command: e.name,
+        changeName: s,
+        taskId: a,
+        steps: m,
+        message: `Composite command "/tf:${e.name}" completed successfully`
     };
 }
-async function executeSlashCommand(parsed) {
-    const cmdDef = (0, registry_1.getCommand)(parsed.command);
-    if (!cmdDef) {
-        return {
-            success: false,
-            command: parsed.command,
-            message: `Unknown slash command: /tf:${parsed.command}`,
-            error: `Command "${parsed.command}" not found. Run /tf:help for available commands.`,
-        };
-    }
-    const changeName = extractChangeName(parsed);
-    const taskId = extractTaskId(parsed);
-    if (cmdDef.requiresChange && !changeName) {
-        return {
-            success: false,
-            command: parsed.command,
-            message: `Command "/tf:${parsed.command}" requires a change name. Usage: ${cmdDef.usage}`,
-            error: 'Missing change name',
-        };
-    }
-    if (cmdDef.requiresTaskId && !taskId && !changeName) {
-        return {
-            success: false,
-            command: parsed.command,
-            message: `Command "/tf:${parsed.command}" requires a task ID. Usage: ${cmdDef.usage}`,
-            error: 'Missing task ID',
-        };
-    }
-    if (cmdDef.category === 'composite') {
-        return executeCompositeCommand(cmdDef, changeName, taskId, parsed);
-    }
-    const stepResult = await executeSingleCommand(parsed.command, changeName, taskId, parsed);
+async function c(e) {
+    let s = (0, u.getCommand)(e.command);
+    if (!s) return {
+        success: !1,
+        command: e.command,
+        message: `Unknown slash command: /tf:${e.command}`,
+        error: `Command "${e.command}" not found. Run /tf:help for available commands.`
+    };
+    let t = function(e) {
+        let s = e.args[0];
+        if (s && !s.startsWith('--')) return s;
+        for(let s = 0; s < e.args.length - 1; s += 1)if ('--change' === e.args[s] || '--task-id' === e.args[s]) return e.args[s + 1];
+    }(e), a = function(e) {
+        for(let s = 0; s < e.args.length - 1; s += 1)if ('--task-id' === e.args[s]) return e.args[s + 1];
+        let s = e.args[0];
+        if (s && !s.startsWith('--')) return s;
+    }(e);
+    if (s.requiresChange && !t) return {
+        success: !1,
+        command: e.command,
+        message: `Command "/tf:${e.command}" requires a change name. Usage: ${s.usage}`,
+        error: 'Missing change name'
+    };
+    if (s.requiresTaskId && !a && !t) return {
+        success: !1,
+        command: e.command,
+        message: `Command "/tf:${e.command}" requires a task ID. Usage: ${s.usage}`,
+        error: 'Missing task ID'
+    };
+    if ('composite' === s.category) return n(s, t, a, e);
+    let c = await r(e.command, t, a, e);
     return {
-        success: stepResult.success,
-        command: parsed.command,
-        changeName,
-        taskId,
-        steps: [stepResult],
-        message: stepResult.message,
-        error: stepResult.success ? undefined : stepResult.message,
+        success: c.success,
+        command: e.command,
+        changeName: t,
+        taskId: a,
+        steps: [
+            c
+        ],
+        message: c.message,
+        error: c.success ? void 0 : c.message
     };
 }
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+}), Object.defineProperty(exports, "executeSlashCommand", {
+    enumerable: !0,
+    get: function() {
+        return c;
+    }
+});
+let o = /*#__PURE__*/ s(require("fs")), i = /*#__PURE__*/ s(require("path")), u = require("./registry"), m = require("../commands/extract"), g = require("../commands/design"), l = require("../commands/tasks-gen"), d = require("../commands/worktree"), f = require("../commands/init"), p = require("../commands/status"), h = require("../lib/archive"), k = require("../commands/merge"), y = require("../spec/sync-task-to-openspec"), $ = require("../commands/analyze"), S = require("../lib/config");