@bicorne/task-flow 0.1.0 → 0.2.1

package/dist/slash/index.js

@@ -1,45 +1,71 @@
+async function e(e) {
+    if (!(0, m.isSlashCommand)(e)) return {
+        success: !1,
+        command: '',
+        message: `Not a valid slash command: "${e}". Format: /tf:<command> [args]`,
+        error: 'Invalid slash command format'
+    };
+    let r = (0, m.parseSlashCommand)(e);
+    return r.valid ? (0, n.executeSlashCommand)(r) : {
+        success: !1,
+        command: '',
+        message: r.error,
+        error: r.error
+    };
+}
 "use strict";
-/**
- * slash/index.ts
- * Facade module for the slash command system
- *
- * Provides a single entry point for parsing and executing slash commands.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeSlashCommand = exports.printSlashHelp = exports.hasCommand = exports.getSingleCommands = exports.getCompositeCommands = exports.getAllCommands = exports.getCommand = exports.formatSlashCommand = exports.isSlashCommand = exports.parseSlashCommand = void 0;
-exports.runSlashCommand = runSlashCommand;
-var parser_1 = require("./parser");
-Object.defineProperty(exports, "parseSlashCommand", { enumerable: true, get: function () { return parser_1.parseSlashCommand; } });
-Object.defineProperty(exports, "isSlashCommand", { enumerable: true, get: function () { return parser_1.isSlashCommand; } });
-Object.defineProperty(exports, "formatSlashCommand", { enumerable: true, get: function () { return parser_1.formatSlashCommand; } });
-var registry_1 = require("./registry");
-Object.defineProperty(exports, "getCommand", { enumerable: true, get: function () { return registry_1.getCommand; } });
-Object.defineProperty(exports, "getAllCommands", { enumerable: true, get: function () { return registry_1.getAllCommands; } });
-Object.defineProperty(exports, "getCompositeCommands", { enumerable: true, get: function () { return registry_1.getCompositeCommands; } });
-Object.defineProperty(exports, "getSingleCommands", { enumerable: true, get: function () { return registry_1.getSingleCommands; } });
-Object.defineProperty(exports, "hasCommand", { enumerable: true, get: function () { return registry_1.hasCommand; } });
-Object.defineProperty(exports, "printSlashHelp", { enumerable: true, get: function () { return registry_1.printSlashHelp; } });
-var executor_1 = require("./executor");
-Object.defineProperty(exports, "executeSlashCommand", { enumerable: true, get: function () { return executor_1.executeSlashCommand; } });
-const parser_2 = require("./parser");
-const executor_2 = require("./executor");
-async function runSlashCommand(input) {
-    if (!(0, parser_2.isSlashCommand)(input)) {
-        return {
-            success: false,
-            command: '',
-            message: `Not a valid slash command: "${input}". Format: /tf:<command> [args]`,
-            error: 'Invalid slash command format',
-        };
-    }
-    const parsed = (0, parser_2.parseSlashCommand)(input);
-    if (!parsed.valid) {
-        return {
-            success: false,
-            command: '',
-            message: parsed.error,
-            error: parsed.error,
-        };
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+var r = exports, t = {
+    get ParsedSlashCommand () {
+        return m.ParsedSlashCommand;
+    },
+    get SlashCommandDef () {
+        return s.SlashCommandDef;
+    },
+    get SlashExecResult () {
+        return n.SlashExecResult;
+    },
+    get StepResult () {
+        return n.StepResult;
+    },
+    get executeSlashCommand () {
+        return n.executeSlashCommand;
+    },
+    get formatSlashCommand () {
+        return m.formatSlashCommand;
+    },
+    get getAllCommands () {
+        return s.getAllCommands;
+    },
+    get getCommand () {
+        return s.getCommand;
+    },
+    get getCompositeCommands () {
+        return s.getCompositeCommands;
+    },
+    get getSingleCommands () {
+        return s.getSingleCommands;
+    },
+    get hasCommand () {
+        return s.hasCommand;
+    },
+    get isSlashCommand () {
+        return m.isSlashCommand;
+    },
+    get parseSlashCommand () {
+        return m.parseSlashCommand;
+    },
+    get printSlashHelp () {
+        return s.printSlashHelp;
+    },
+    get runSlashCommand () {
+        return e;
     }
-    return (0, executor_2.executeSlashCommand)(parsed);
-}
+};
+for(var a in t)Object.defineProperty(r, a, {
+    enumerable: !0,
+    get: Object.getOwnPropertyDescriptor(t, a).get
+});
+let m = require("./parser"), s = require("./registry"), n = require("./executor");

package/dist/slash/parser.js

@@ -1,101 +1,88 @@
-"use strict";
-/**
- * slash/parser.ts
- * Parse slash command strings like /tf:propose or /taskflow:apply
- *
- * Format: /<namespace>:<command> [args...]
- * Examples:
- *   /tf:propose add-dark-mode
- *   /taskflow:apply
- *   /tf:archive --task-id my-feature
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VALID_NAMESPACES = exports.DEFAULT_NAMESPACE = void 0;
-exports.parseSlashCommand = parseSlashCommand;
-exports.isSlashCommand = isSlashCommand;
-exports.formatSlashCommand = formatSlashCommand;
-const DEFAULT_NAMESPACE = 'tf';
-exports.DEFAULT_NAMESPACE = DEFAULT_NAMESPACE;
-const VALID_NAMESPACES = ['tf', 'taskflow'];
-exports.VALID_NAMESPACES = VALID_NAMESPACES;
-function isValidNamespace(ns) {
-    return VALID_NAMESPACES.includes(ns);
-}
-function parseSlashCommand(input) {
-    const trimmed = input.trim();
-    if (!trimmed.startsWith('/')) {
-        return {
-            valid: false,
-            namespace: '',
-            command: '',
-            args: [],
-            raw: trimmed,
-            error: `Slash command must start with "/". Got: "${trimmed}"`,
-        };
-    }
-    const withoutSlash = trimmed.slice(1);
-    const colonIndex = withoutSlash.indexOf(':');
-    if (colonIndex === -1) {
-        return {
-            valid: false,
-            namespace: '',
-            command: '',
-            args: [],
-            raw: trimmed,
-            error: `Slash command must contain ":" separator. Format: /<namespace>:<command>. Got: "${trimmed}"`,
-        };
-    }
-    const namespace = withoutSlash.slice(0, colonIndex);
-    const remainder = withoutSlash.slice(colonIndex + 1);
-    if (!namespace) {
-        return {
-            valid: false,
-            namespace: '',
-            command: '',
-            args: [],
-            raw: trimmed,
-            error: `Missing namespace before ":". Format: /<namespace>:<command>. Got: "${trimmed}"`,
-        };
-    }
-    if (!isValidNamespace(namespace)) {
-        return {
-            valid: false,
-            namespace,
-            command: '',
-            args: [],
-            raw: trimmed,
-            error: `Unknown namespace "${namespace}". Valid namespaces: ${VALID_NAMESPACES.join(', ')}`,
-        };
-    }
-    const tokens = remainder.split(/\s+/).filter(Boolean);
-    const command = tokens[0] || '';
-    if (!command) {
-        return {
-            valid: false,
-            namespace,
-            command: '',
-            args: [],
-            raw: trimmed,
-            error: `Missing command after "${namespace}:". Format: /${namespace}:<command>. Got: "${trimmed}"`,
-        };
-    }
-    const args = tokens.slice(1);
-    return {
-        valid: true,
-        namespace,
-        command,
-        args,
-        raw: trimmed,
+function e(e) {
+    let r = e.trim();
+    if (!r.startsWith('/')) return {
+        valid: !1,
+        namespace: '',
+        command: '',
+        args: [],
+        raw: r,
+        error: `Slash command must start with "/". Got: "${r}"`
+    };
+    let a = r.slice(1), t = a.indexOf(':');
+    if (-1 === t) return {
+        valid: !1,
+        namespace: '',
+        command: '',
+        args: [],
+        raw: r,
+        error: `Slash command must contain ":" separator. Format: /<namespace>:<command>. Got: "${r}"`
+    };
+    let n = a.slice(0, t), s = a.slice(t + 1);
+    if (!n) return {
+        valid: !1,
+        namespace: '',
+        command: '',
+        args: [],
+        raw: r,
+        error: `Missing namespace before ":". Format: /<namespace>:<command>. Got: "${r}"`
+    };
+    if (!m.includes(n)) return {
+        valid: !1,
+        namespace: n,
+        command: '',
+        args: [],
+        raw: r,
+        error: `Unknown namespace "${n}". Valid namespaces: ${m.join(', ')}`
+    };
+    let o = s.split(/\s+/).filter(Boolean), i = o[0] || '';
+    return i ? {
+        valid: !0,
+        namespace: n,
+        command: i,
+        args: o.slice(1),
+        raw: r
+    } : {
+        valid: !1,
+        namespace: n,
+        command: '',
+        args: [],
+        raw: r,
+        error: `Missing command after "${n}:". Format: /${n}:<command>. Got: "${r}"`
     };
 }
-function isSlashCommand(input) {
-    const trimmed = input.trim();
-    if (!trimmed.startsWith('/')) {
-        return false;
-    }
-    const withoutSlash = trimmed.slice(1);
-    return withoutSlash.includes(':');
+function r(e) {
+    let r = e.trim();
+    return !!r.startsWith('/') && r.slice(1).includes(':');
 }
-function formatSlashCommand(namespace, command) {
-    return `/${namespace}:${command}`;
+function a(e, r) {
+    return `/${e}:${r}`;
 }
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+var t = exports, n = {
+    get DEFAULT_NAMESPACE () {
+        return o;
+    },
+    get VALID_NAMESPACES () {
+        return m;
+    },
+    get formatSlashCommand () {
+        return a;
+    },
+    get isSlashCommand () {
+        return r;
+    },
+    get parseSlashCommand () {
+        return e;
+    }
+};
+for(var s in n)Object.defineProperty(t, s, {
+    enumerable: !0,
+    get: Object.getOwnPropertyDescriptor(n, s).get
+});
+let o = 'tf', m = [
+    'tf',
+    'taskflow'
+];

package/dist/slash/registry.js

@@ -1,155 +1,167 @@
+function e(e) {
+    return c[e];
+}
+function t() {
+    return Object.values(c);
+}
+function a() {
+    return Object.values(c).filter((e)=>'composite' === e.category);
+}
+function r() {
+    return Object.values(c).filter((e)=>'single' === e.category);
+}
+function s(e) {
+    return e in c;
+}
+function n() {
+    let e = [
+        '',
+        'Slash Commands:',
+        '',
+        '  Composite (multi-step):'
+    ];
+    for (let t of a())e.push(`    ${t.usage.padEnd(40)} ${t.description}`);
+    for (let t of (e.push(''), e.push('  Single:'), r()))e.push(`    ${t.usage.padEnd(40)} ${t.description}`);
+    return e.push(''), e.push('  Examples:'), e.push('    /tf:propose add-dark-mode    →  extract + design + tasks'), e.push('    /tf:apply add-dark-mode      →  create worktree'), e.push('    /tf:archive --task-id feat   →  archive + sync'), e.push(''), e.join('\n');
+}
 "use strict";
-/**
- * slash/registry.ts
- * Slash command registry — defines all available slash commands,
- * their argument schemas, and whether they are composite (multi-step).
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCommand = getCommand;
-exports.getAllCommands = getAllCommands;
-exports.getCompositeCommands = getCompositeCommands;
-exports.getSingleCommands = getSingleCommands;
-exports.hasCommand = hasCommand;
-exports.printSlashHelp = printSlashHelp;
-const COMMANDS = {
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+var i = exports, o = {
+    get getAllCommands () {
+        return t;
+    },
+    get getCommand () {
+        return e;
+    },
+    get getCompositeCommands () {
+        return a;
+    },
+    get getSingleCommands () {
+        return r;
+    },
+    get hasCommand () {
+        return s;
+    },
+    get printSlashHelp () {
+        return n;
+    }
+};
+for(var d in o)Object.defineProperty(i, d, {
+    enumerable: !0,
+    get: Object.getOwnPropertyDescriptor(o, d).get
+});
+let c = {
     propose: {
         name: 'propose',
         description: 'Create a full change proposal (extract → design → tasks)',
         category: 'composite',
-        requiresChange: true,
-        requiresTaskId: false,
-        steps: ['extract', 'design', 'tasks'],
+        requiresChange: !0,
+        requiresTaskId: !1,
+        steps: [
+            'extract',
+            'design',
+            'tasks'
+        ],
         usage: '/tf:propose <change-name>',
-        example: '/tf:propose add-dark-mode',
+        example: '/tf:propose add-dark-mode'
     },
     apply: {
         name: 'apply',
         description: 'Apply a change by creating worktree and starting implementation',
         category: 'composite',
-        requiresChange: true,
-        requiresTaskId: false,
-        steps: ['worktree'],
+        requiresChange: !0,
+        requiresTaskId: !1,
+        steps: [
+            'worktree'
+        ],
         usage: '/tf:apply <change-name>',
-        example: '/tf:apply add-dark-mode',
+        example: '/tf:apply add-dark-mode'
     },
     archive: {
         name: 'archive',
         description: 'Archive a completed change (archive → sync)',
         category: 'composite',
-        requiresChange: false,
-        requiresTaskId: true,
-        steps: ['archive', 'sync'],
+        requiresChange: !1,
+        requiresTaskId: !0,
+        steps: [
+            'archive',
+            'sync'
+        ],
         usage: '/tf:archive --task-id <task-id>',
-        example: '/tf:archive --task-id add-dark-mode',
+        example: '/tf:archive --task-id add-dark-mode'
     },
     init: {
         name: 'init',
         description: 'Initialize task flow in current project',
         category: 'single',
-        requiresChange: false,
-        requiresTaskId: false,
+        requiresChange: !1,
+        requiresTaskId: !1,
         usage: '/tf:init',
-        example: '/tf:init',
+        example: '/tf:init'
     },
     status: {
         name: 'status',
         description: 'Show current task and phase status',
         category: 'single',
-        requiresChange: false,
-        requiresTaskId: false,
+        requiresChange: !1,
+        requiresTaskId: !1,
         usage: '/tf:status',
-        example: '/tf:status',
+        example: '/tf:status'
     },
     extract: {
         name: 'extract',
         description: 'Extract project requirements and generate PRD document',
         category: 'single',
-        requiresChange: true,
-        requiresTaskId: false,
+        requiresChange: !0,
+        requiresTaskId: !1,
         usage: '/tf:extract <change-name>',
-        example: '/tf:extract add-dark-mode',
+        example: '/tf:extract add-dark-mode'
     },
     design: {
         name: 'design',
         description: 'Generate technical specification from PRD',
         category: 'single',
-        requiresChange: true,
-        requiresTaskId: false,
+        requiresChange: !0,
+        requiresTaskId: !1,
         usage: '/tf:design <change-name>',
-        example: '/tf:design add-dark-mode',
+        example: '/tf:design add-dark-mode'
     },
     tasks: {
         name: 'tasks',
         description: 'Generate PHASE-*.json task files from PRD and design',
         category: 'single',
-        requiresChange: true,
-        requiresTaskId: false,
+        requiresChange: !0,
+        requiresTaskId: !1,
         usage: '/tf:tasks <change-name>',
-        example: '/tf:tasks add-dark-mode',
+        example: '/tf:tasks add-dark-mode'
     },
     worktree: {
         name: 'worktree',
         description: 'Create isolated git worktree for task execution',
         category: 'single',
-        requiresChange: true,
-        requiresTaskId: false,
+        requiresChange: !0,
+        requiresTaskId: !1,
         usage: '/tf:worktree <change-name>',
-        example: '/tf:worktree add-dark-mode',
+        example: '/tf:worktree add-dark-mode'
     },
     merge: {
         name: 'merge',
         description: 'Merge completed worktree back to main branch',
         category: 'single',
-        requiresChange: false,
-        requiresTaskId: true,
+        requiresChange: !1,
+        requiresTaskId: !0,
         usage: '/tf:merge <task-id>',
-        example: '/tf:merge add-dark-mode',
+        example: '/tf:merge add-dark-mode'
     },
     sync: {
         name: 'sync',
         description: 'Sync task execution status to spec',
         category: 'single',
-        requiresChange: false,
-        requiresTaskId: true,
+        requiresChange: !1,
+        requiresTaskId: !0,
         usage: '/tf:sync --task-id <task-id>',
-        example: '/tf:sync --task-id add-dark-mode',
-    },
-};
-function getCommand(name) {
-    return COMMANDS[name];
-}
-function getAllCommands() {
-    return Object.values(COMMANDS);
-}
-function getCompositeCommands() {
-    return Object.values(COMMANDS).filter((cmd) => cmd.category === 'composite');
-}
-function getSingleCommands() {
-    return Object.values(COMMANDS).filter((cmd) => cmd.category === 'single');
-}
-function hasCommand(name) {
-    return name in COMMANDS;
-}
-function printSlashHelp() {
-    const lines = [
-        '',
-        'Slash Commands:',
-        '',
-        '  Composite (multi-step):',
-    ];
-    for (const cmd of getCompositeCommands()) {
-        lines.push(`    ${cmd.usage.padEnd(40)} ${cmd.description}`);
+        example: '/tf:sync --task-id add-dark-mode'
     }
-    lines.push('');
-    lines.push('  Single:');
-    for (const cmd of getSingleCommands()) {
-        lines.push(`    ${cmd.usage.padEnd(40)} ${cmd.description}`);
-    }
-    lines.push('');
-    lines.push('  Examples:');
-    lines.push('    /tf:propose add-dark-mode    →  extract + design + tasks');
-    lines.push('    /tf:apply add-dark-mode      →  create worktree');
-    lines.push('    /tf:archive --task-id feat   →  archive + sync');
-    lines.push('');
-    return lines.join('\n');
-}
+};