@bicorne/task-flow 0.1.0

package/dist/lib/state.js

@@ -0,0 +1,293 @@
+"use strict";
+/**
+ * state.ts
+ * State management for task-flow
+ */
+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.createInitialState = createInitialState;
+exports.loadState = loadState;
+exports.saveState = saveState;
+exports.updateState = updateState;
+exports.upsertWorktree = upsertWorktree;
+exports.removeWorktree = removeWorktree;
+exports.addTaskToHistory = addTaskToHistory;
+exports.getActiveWorktrees = getActiveWorktrees;
+exports.getWorktreeByTask = getWorktreeByTask;
+exports.clearCurrentTask = clearCurrentTask;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+/**
+ * Create initial state object
+ * @returns Initial state
+ */
+function createInitialState() {
+    const now = new Date().toISOString();
+    return {
+        version: '1.0',
+        status: 'initialized',
+        currentPhase: null,
+        currentTask: null,
+        currentSnapshot: null,
+        reviewConclusion: null,
+        phaseCompleted: null,
+        taskHistory: [],
+        worktrees: [],
+        lastGateBlockedAt: null,
+        lastGateBlockedReason: null,
+        lastGateBlockedPhase: null,
+        lastMissingValidations: [],
+        startedAt: now,
+        updatedAt: now,
+    };
+}
+/**
+ * Load state from file
+ * @param config - Config object
+ * @returns State object
+ */
+function loadState(config) {
+    const cfg = config || (0, config_1.loadConfig)();
+    const statePath = path.resolve(cfg.harnessRootAbs || '.harness', 'state.json');
+    if (!fs.existsSync(statePath)) {
+        return createInitialState();
+    }
+    try {
+        return JSON.parse(fs.readFileSync(statePath, 'utf8'));
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        console.warn('[STATE] Failed to load state file, attempting to restore from backup:', errorMessage);
+        // Try to restore from latest backup
+        try {
+            const harnessDir = cfg.harnessRootAbs;
+            if (!harnessDir) {
+                throw new Error('harnessRootAbs is undefined');
+            }
+            const backupPattern = /state\.json\.bak\.(\d+)$/;
+            const files = fs.readdirSync(harnessDir);
+            const backups = files
+                .filter(f => backupPattern.test(f))
+                .sort((a, b) => {
+                const matchA = a.match(backupPattern);
+                const matchB = b.match(backupPattern);
+                return (matchB?.[1] || '0').localeCompare(matchA?.[1] || '0');
+            });
+            if (backups.length > 0) {
+                const latestBackupName = backups[0];
+                if (!latestBackupName) {
+                    throw new Error('No backup file found');
+                }
+                const latestBackup = path.resolve(harnessDir, latestBackupName);
+                console.log(`[STATE] Restoring from backup: ${latestBackup}`);
+                return JSON.parse(fs.readFileSync(latestBackup, 'utf8'));
+            }
+        }
+        catch (restoreError) {
+            console.warn('[STATE] Failed to restore from backup:', restoreError instanceof Error ? restoreError.message : 'Unknown error');
+        }
+        console.warn('[STATE] Creating new state');
+        return createInitialState();
+    }
+}
+/**
+ * Save state to file
+ * @param state - State object
+ * @param config - Config object
+ * @returns Success
+ */
+function saveState(state, config) {
+    const cfg = config || (0, config_1.loadConfig)();
+    const harnessRoot = cfg.harnessRootAbs;
+    if (!harnessRoot) {
+        console.error('[STATE] harnessRootAbs is undefined, cannot save state');
+        return false;
+    }
+    const statePath = path.resolve(harnessRoot, 'state.json');
+    try {
+        state.updatedAt = new Date().toISOString();
+        fs.mkdirSync(harnessRoot, { recursive: true });
+        // Backup existing state file before overwriting (prevent data corruption)
+        if (fs.existsSync(statePath)) {
+            const backupPath = `${statePath}.bak.${Date.now()}`;
+            try {
+                fs.copyFileSync(statePath, backupPath);
+                console.log(`[STATE] Created backup: ${backupPath}`);
+            }
+            catch (backupError) {
+                console.warn('[STATE] Failed to create backup:', backupError instanceof Error ? backupError.message : 'Unknown error');
+            }
+        }
+        fs.writeFileSync(statePath, JSON.stringify(state, null, 2), 'utf8');
+        return true;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        console.error('[STATE] Failed to save state:', errorMessage);
+        return false;
+    }
+}
+/**
+ * Update state with partial changes
+ * @param updates - Updates to apply
+ * @param config - Config object
+ * @returns Updated state
+ */
+function updateState(updates, config) {
+    const state = loadState(config);
+    const updated = {
+        ...state,
+        ...updates,
+        updatedAt: new Date().toISOString(),
+    };
+    saveState(updated, config);
+    return updated;
+}
+/**
+ * Add or update worktree in state
+ * @param worktree - Worktree info
+ * @param config - Config object
+ * @returns Updated state
+ */
+function upsertWorktree(worktree, config) {
+    const state = loadState(config);
+    const worktrees = Array.isArray(state.worktrees) ? [...state.worktrees] : [];
+    const existingIndex = worktrees.findIndex((wt) => wt?.name === worktree.name);
+    const now = new Date().toISOString();
+    const nextWorktree = {
+        name: worktree.name || '',
+        path: worktree.path,
+        branch: worktree.branch,
+        status: worktree.status || 'active',
+        agent: worktree.agent || 'implementer',
+        task: worktree.task,
+        startedAt: (existingIndex >= 0 && worktrees[existingIndex]?.startedAt) ? worktrees[existingIndex].startedAt : now,
+        lastActivity: now,
+        pendingChanges: worktree.pendingChanges || [],
+    };
+    if (existingIndex >= 0) {
+        worktrees[existingIndex] = nextWorktree;
+    }
+    else {
+        worktrees.push(nextWorktree);
+    }
+    state.worktrees = worktrees;
+    saveState(state, config);
+    return state;
+}
+/**
+ * Remove worktree from state
+ * @param worktreeName - Worktree name
+ * @param config - Config object
+ * @returns Updated state
+ */
+function removeWorktree(worktreeName, config) {
+    const state = loadState(config);
+    state.worktrees = (state.worktrees || []).filter((wt) => wt?.name !== worktreeName);
+    saveState(state, config);
+    return state;
+}
+/**
+ * Add task to history
+ * @param taskInfo - Task info
+ * @param config - Config object
+ * @returns Updated state
+ */
+function addTaskToHistory(taskInfo, config) {
+    const state = loadState(config);
+    const history = Array.isArray(state.taskHistory) ? [...state.taskHistory] : [];
+    const existingIndex = history.findIndex((item) => item?.taskId === taskInfo.taskId);
+    const now = new Date().toISOString();
+    const summary = {
+        taskId: taskInfo.taskId || '',
+        title: taskInfo.title,
+        status: taskInfo.status || 'running',
+        currentPhase: taskInfo.currentPhase ?? null,
+        phaseCompleted: taskInfo.phaseCompleted ?? null,
+        reviewConclusion: taskInfo.reviewConclusion ?? null,
+        startedAt: taskInfo.startedAt || now,
+        completedAt: taskInfo.completedAt ?? null,
+        lastUpdatedAt: now,
+        archivePath: taskInfo.archivePath,
+    };
+    if (existingIndex >= 0) {
+        history[existingIndex] = summary;
+    }
+    else {
+        history.push(summary);
+    }
+    state.taskHistory = history.sort((a, b) => String(b.lastUpdatedAt || '').localeCompare(String(a.lastUpdatedAt || '')));
+    saveState(state, config);
+    return state;
+}
+/**
+ * Get active worktrees
+ * @param config - Config object
+ * @returns Active worktrees
+ */
+function getActiveWorktrees(config) {
+    const state = loadState(config);
+    return (state.worktrees || []).filter((wt) => wt?.status === 'active');
+}
+/**
+ * Get worktree by task ID
+ * @param taskId - Task ID
+ * @param config - Config object
+ * @returns Worktree or null
+ */
+function getWorktreeByTask(taskId, config) {
+    const state = loadState(config);
+    return (state.worktrees || []).find((wt) => wt?.task === taskId) || null;
+}
+/**
+ * Clear current task state (after merge)
+ * @param config - Config object
+ * @returns Updated state
+ */
+function clearCurrentTask(config) {
+    const state = loadState(config);
+    const now = new Date().toISOString();
+    state.status = 'completed';
+    state.currentPhase = null;
+    state.currentTask = null;
+    state.currentSnapshot = null;
+    state.reviewConclusion = null;
+    state.phaseCompleted = null;
+    state.worktrees = [];
+    state.updatedAt = now;
+    saveState(state, config);
+    return state;
+}

package/dist/slash/executor.d.ts

@@ -0,0 +1,22 @@
+/**
+ * slash/executor.ts
+ * Execute slash commands by dispatching to the appropriate command modules.
+ * Supports both single commands and composite (multi-step) commands.
+ */
+import { ParsedSlashCommand } from './parser';
+export interface SlashExecResult {
+    success: boolean;
+    command: string;
+    changeName?: string;
+    taskId?: string;
+    steps?: StepResult[];
+    message?: string;
+    error?: string;
+}
+export interface StepResult {
+    step: string;
+    success: boolean;
+    message?: string;
+    detail?: Record<string, unknown>;
+}
+export declare function executeSlashCommand(parsed: ParsedSlashCommand): Promise<SlashExecResult>;

package/dist/slash/executor.js

@@ -0,0 +1,259 @@
+"use strict";
+/**
+ * slash/executor.ts
+ * Execute slash commands by dispatching to the appropriate command modules.
+ * Supports both single commands and composite (multi-step) commands.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeSlashCommand = executeSlashCommand;
+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");
+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 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;
+    }
+    return undefined;
+}
+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 hasFlag(parsed, flag) {
+    return parsed.args.includes(`--${flag}`) || parsed.args.includes(`-${flag}`);
+}
+async function executeSingleCommand(commandName, changeName, taskId, parsed) {
+    switch (commandName) {
+        case 'extract': {
+            if (!changeName) {
+                return { step: 'extract', success: false, message: 'Missing change name. Usage: /tf:extract <change-name>' };
+            }
+            const result = await (0, extract_1.extract)({
+                change: changeName,
+                force: hasFlag(parsed, 'force'),
+                contextFile: extractFlagValue(parsed, 'context-file'),
+            });
+            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>' };
+            }
+            const result = await (0, design_1.generateDesign)({
+                change: changeName,
+                force: hasFlag(parsed, 'force'),
+                skipPrompt: true,
+                contextFile: extractFlagValue(parsed, 'context-file'),
+            });
+            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>' };
+            }
+            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>' };
+            }
+            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}` };
+            }
+            return {
+                step: 'archive',
+                success: true,
+                message: `Archived: ${result.archivePath}`,
+            };
+        }
+        case 'merge': {
+            const tid = taskId || changeName;
+            if (!tid) {
+                return { step: 'merge', success: false, message: 'Missing task ID. Usage: /tf:merge <task-id>' };
+            }
+            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>' };
+            }
+            const result = (0, sync_task_to_openspec_1.syncTaskToSpec)({ taskId: tid });
+            if (result.skipped) {
+                return { step: 'sync', success: true, message: `Skipped: ${result.reason}` };
+            }
+            return { step: 'sync', success: true, message: 'Synced' };
+        }
+        default:
+            return { step: commandName, success: false, message: `Unknown command: ${commandName}` };
+    }
+}
+async function executeCompositeCommand(cmdDef, changeName, taskId, parsed) {
+    const steps = cmdDef.steps || [];
+    const stepResults = [];
+    console.log(`[SLASH] Executing composite command: /tf:${cmdDef.name}`);
+    console.log(`[SLASH] Steps: ${steps.join(' → ')}`);
+    console.log('');
+    for (const step of steps) {
+        console.log(`[SLASH] → Step: ${step}`);
+        const result = await executeSingleCommand(step, changeName, taskId, parsed);
+        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('');
+    }
+    return {
+        success: true,
+        command: cmdDef.name,
+        changeName,
+        taskId,
+        steps: stepResults,
+        message: `Composite command "/tf:${cmdDef.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);
+    return {
+        success: stepResult.success,
+        command: parsed.command,
+        changeName,
+        taskId,
+        steps: [stepResult],
+        message: stepResult.message,
+        error: stepResult.success ? undefined : stepResult.message,
+    };
+}

package/dist/slash/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * slash/index.ts
+ * Facade module for the slash command system
+ *
+ * Provides a single entry point for parsing and executing slash commands.
+ */
+export { parseSlashCommand, isSlashCommand, formatSlashCommand, ParsedSlashCommand } from './parser';
+export { getCommand, getAllCommands, getCompositeCommands, getSingleCommands, hasCommand, printSlashHelp, SlashCommandDef } from './registry';
+export { executeSlashCommand, SlashExecResult, StepResult } from './executor';
+import { SlashExecResult } from './executor';
+export declare function runSlashCommand(input: string): Promise<SlashExecResult>;

package/dist/slash/index.js

@@ -0,0 +1,45 @@
+"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,
+        };
+    }
+    return (0, executor_2.executeSlashCommand)(parsed);
+}

package/dist/slash/parser.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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
+ */
+export interface ParsedSlashCommand {
+    valid: boolean;
+    namespace: string;
+    command: string;
+    args: string[];
+    raw: string;
+    error?: string;
+}
+declare const DEFAULT_NAMESPACE = "tf";
+declare const VALID_NAMESPACES: readonly ["tf", "taskflow"];
+export declare function parseSlashCommand(input: string): ParsedSlashCommand;
+export declare function isSlashCommand(input: string): boolean;
+export declare function formatSlashCommand(namespace: string, command: string): string;
+export { DEFAULT_NAMESPACE, VALID_NAMESPACES };