@bicorne/task-flow 0.1.0

package/dist/commands/merge/validators.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * commands/merge/validators.ts
+ * Validation utilities for merge command
+ */
+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.validateReview = validateReview;
+exports.validateWorktreeAndBranch = validateWorktreeAndBranch;
+const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
+/**
+ * Parse review conclusion from file content
+ */
+function parseReviewConclusion(file) {
+    try {
+        const content = fs.readFileSync(file, 'utf8');
+        const patterns = [
+            /^\s*(?:结论|Conclusion)\s*:\s*(PASS|NEEDS_WORK|FAIL)\s*$/m,
+            /^##\s*结论\s*:\s*(PASS|NEEDS_WORK|FAIL)\s*$/m,
+            /\*\*(PASS|NEEDS_WORK|FAIL)\*\*/,
+        ];
+        for (const pattern of patterns) {
+            const match = content.match(pattern);
+            if (match) {
+                return match[1] || match[0];
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+/**
+ * Validate review report
+ */
+function validateReview(reviewPath, skipReviewCheck) {
+    if (skipReviewCheck) {
+        return { valid: true };
+    }
+    if (!fs.existsSync(reviewPath)) {
+        return {
+            valid: false,
+            reason: 'missing-review',
+            message: `Review report not found: ${reviewPath}. Use --skip-review-check to override.`,
+        };
+    }
+    const conclusion = parseReviewConclusion(reviewPath);
+    if (conclusion !== 'PASS') {
+        return {
+            valid: false,
+            reason: 'review-not-passed',
+            message: `Review conclusion is ${conclusion}, not PASS. Use --skip-review-check to override.`,
+            conclusion,
+        };
+    }
+    return { valid: true, conclusion };
+}
+/**
+ * Validate worktree and branch
+ */
+function validateWorktreeAndBranch(state, taskId) {
+    const worktree = (state.worktrees || []).find((wt) => wt?.task === taskId);
+    if (!worktree) {
+        return {
+            valid: false,
+            reason: 'missing-worktree',
+            message: 'Worktree info not found in state.json',
+        };
+    }
+    const branch = worktree.branch;
+    if (!branch) {
+        return {
+            valid: false,
+            reason: 'missing-branch-info',
+            message: 'Branch info not found in worktree state',
+        };
+    }
+    try {
+        const showRefResult = (0, child_process_1.spawnSync)('git', ['show-ref', '--verify', '--quiet', `refs/heads/${branch}`], { stdio: 'ignore' });
+        if (showRefResult.status !== 0) {
+            return {
+                valid: false,
+                reason: 'missing-branch',
+                message: `Branch does not exist: ${branch}`,
+            };
+        }
+    }
+    catch {
+        return {
+            valid: false,
+            reason: 'missing-branch',
+            message: `Branch does not exist: ${branch}`,
+        };
+    }
+    try {
+        const diffResult = (0, child_process_1.spawnSync)('git', ['diff-index', '--quiet', 'HEAD', '--'], { stdio: 'ignore' });
+        if (diffResult.status !== 0) {
+            return {
+                valid: false,
+                reason: 'dirty-worktree',
+                message: 'Main worktree has uncommitted changes',
+            };
+        }
+    }
+    catch {
+        return {
+            valid: false,
+            reason: 'dirty-worktree',
+            message: 'Main worktree has uncommitted changes',
+        };
+    }
+    return { valid: true, worktree, branch };
+}

package/dist/commands/merge.d.ts

@@ -0,0 +1,7 @@
+/**
+ * commands/merge.ts
+ * Backward-compatible re-export from merge/ module
+ * @deprecated Import from './merge/index' directly
+ */
+export { mergeTask, main, default } from './merge/index';
+export { MergeOptions, MergeResult, MergeConfig } from './merge/types';

package/dist/commands/merge.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * commands/merge.ts
+ * Backward-compatible re-export from merge/ module
+ * @deprecated Import from './merge/index' directly
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.main = exports.mergeTask = void 0;
+var index_1 = require("./merge/index");
+Object.defineProperty(exports, "mergeTask", { enumerable: true, get: function () { return index_1.mergeTask; } });
+Object.defineProperty(exports, "main", { enumerable: true, get: function () { return index_1.main; } });
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(index_1).default; } });

package/dist/commands/start.d.ts

@@ -0,0 +1,32 @@
+/**
+ * commands/start.ts
+ * Start a new task from Spec change
+ */
+export interface StartOptions {
+    cwd?: string;
+    change?: string;
+    type?: string;
+    priority?: string;
+    worktree?: string;
+    output?: string;
+    force?: boolean;
+    taskId?: string;
+}
+export interface StartResult {
+    success: boolean;
+    reason?: string;
+    message?: string;
+    taskId?: string;
+    taskPath?: string;
+    worktreeName?: string;
+    branch?: string;
+}
+/**
+ * Start a new task
+ */
+export declare function startTask(options?: StartOptions): StartResult;
+export declare function main(): void;
+declare const _default: {
+    startTask: typeof startTask;
+};
+export default _default;

package/dist/commands/start.js

@@ -0,0 +1,265 @@
+"use strict";
+/**
+ * commands/start.ts
+ * Start a new task from Spec change
+ */
+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.startTask = startTask;
+exports.main = main;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const config_1 = require("../lib/config");
+const state_1 = require("../lib/state");
+const archive_1 = require("../lib/archive");
+const sync_task_to_openspec_1 = require("../spec/sync-task-to-openspec");
+function parseArgs(argv) {
+    const args = {};
+    for (let i = 2; i < argv.length; i += 1) {
+        const token = argv[i] || '';
+        if (!token.startsWith('--')) {
+            continue;
+        }
+        const key = token.slice(2);
+        const next = argv[i + 1] || '';
+        if (!next || next.startsWith('--')) {
+            args[key] = true;
+            continue;
+        }
+        args[key] = next;
+        i += 1;
+    }
+    return args;
+}
+function toTaskId(input) {
+    return String(input || '')
+        .trim()
+        .replace(/[^a-zA-Z0-9-_]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+function toWorktreeName(type, taskId) {
+    return `harness-${type}-${taskId}`;
+}
+function getGitBranch(cwd) {
+    try {
+        return (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', { cwd, encoding: 'utf8' }).trim();
+    }
+    catch {
+        return 'main';
+    }
+}
+function updateTaskPlanningStatus(taskPath) {
+    if (!fs.existsSync(taskPath)) {
+        return;
+    }
+    const content = fs.readFileSync(taskPath, 'utf8');
+    const updated = content.replace(/(-\s*name:\s*planning\s*\n(?:[^\n]*\n)*?status:\s*)\S+/m, '$1in_progress');
+    fs.writeFileSync(taskPath, updated, 'utf8');
+}
+/**
+ * Start a new task
+ */
+function startTask(options = {}) {
+    const config = (0, config_1.loadConfig)({ cwd: options.cwd });
+    const change = String(options.change || '').trim();
+    if (!change) {
+        return {
+            success: false,
+            reason: 'missing-change',
+            message: 'Missing required argument: --change <change-name>',
+        };
+    }
+    const taskId = toTaskId(options.taskId || change);
+    if (!taskId) {
+        return {
+            success: false,
+            reason: 'invalid-task-id',
+            message: 'Invalid task id derived from change name',
+        };
+    }
+    // Ensure directories exist
+    (0, config_1.ensureDirectories)(config);
+    // Check if harness is initialized
+    const harnessRootAbs = config.harnessRootAbs;
+    if (!harnessRootAbs) {
+        return {
+            success: false,
+            reason: 'missing-harness-root',
+            message: 'Config missing harnessRootAbs',
+        };
+    }
+    const statePath = path.resolve(harnessRootAbs, 'state.json');
+    if (!fs.existsSync(statePath)) {
+        const initialState = (0, state_1.createInitialState)();
+        fs.mkdirSync(harnessRootAbs, { recursive: true });
+        try {
+            fs.writeFileSync(statePath, JSON.stringify(initialState, null, 2), 'utf8');
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return {
+                success: false,
+                reason: 'file-write-error',
+                message: `Failed to initialize state: ${errorMessage}`,
+            };
+        }
+    }
+    // Run sync-spec-to-task script to generate task JSON
+    const syncScript = path.resolve(__dirname, '../spec/sync-openspec-to-task.js');
+    const syncArgs = [syncScript, '--change', change, '--task-id', taskId];
+    if (options.type) {
+        syncArgs.push('--type', String(options.type));
+    }
+    if (options.priority) {
+        syncArgs.push('--priority', String(options.priority));
+    }
+    if (options.worktree) {
+        syncArgs.push('--worktree', String(options.worktree));
+    }
+    if (options.output) {
+        syncArgs.push('--output', String(options.output));
+    }
+    if (options.force) {
+        syncArgs.push('--force');
+    }
+    const runSync = (0, child_process_1.spawnSync)(process.execPath, syncArgs, {
+        cwd: config.projectRoot,
+        stdio: 'inherit',
+    });
+    if (runSync.status !== 0) {
+        return {
+            success: false,
+            reason: 'sync-failed',
+            message: 'Failed to sync Spec to task',
+        };
+    }
+    // Get task file path
+    const tasksDirAbs = config.tasksDirAbs;
+    const projectRoot = config.projectRoot;
+    if (!tasksDirAbs || !projectRoot) {
+        return {
+            success: false,
+            reason: 'missing-config-paths',
+            message: 'Config missing tasksDirAbs or projectRoot',
+        };
+    }
+    const taskOutputPath = path.resolve(projectRoot, String(options.output || path.relative(projectRoot, path.resolve(tasksDirAbs, `${taskId}.json`))));
+    // Update task JSON planning status
+    updateTaskPlanningStatus(taskOutputPath);
+    // Get git info
+    const now = new Date().toISOString();
+    const worktreeName = process.env.WORKTREE_NAME || toWorktreeName(options.type || 'feat', taskId);
+    const branch = getGitBranch(projectRoot);
+    // Update state
+    const state = (0, state_1.loadState)(config);
+    state.version = state.version || '1.0';
+    state.status = 'running';
+    state.currentPhase = 'planning';
+    state.currentTask = taskId;
+    state.currentSnapshot = null;
+    state.reviewConclusion = null;
+    state.phaseCompleted = null;
+    state.taskHistory = Array.isArray(state.taskHistory) ? state.taskHistory : [];
+    state.startedAt = state.startedAt || now;
+    state.updatedAt = now;
+    // Add worktree
+    const worktreeInfo = {
+        name: worktreeName,
+        path: '.',
+        branch,
+        status: 'active',
+        task: taskId,
+        startedAt: now,
+        lastActivity: now,
+        pendingChanges: [],
+    };
+    (0, state_1.upsertWorktree)(worktreeInfo, config);
+    // Save state to persist worktree info
+    (0, state_1.saveState)(state, config);
+    // Archive task state
+    (0, archive_1.archiveTaskState)({
+        cwd: projectRoot,
+        taskId,
+        eventType: 'task_started',
+        status: 'running',
+        phase: 'planning',
+    });
+    // Sync to Spec
+    (0, sync_task_to_openspec_1.syncTaskToSpec)({ cwd: projectRoot, taskId });
+    return {
+        success: true,
+        taskId,
+        taskPath: taskOutputPath,
+        worktreeName,
+        branch,
+    };
+}
+function main() {
+    const args = parseArgs(process.argv);
+    const result = startTask({
+        cwd: args.cwd,
+        change: args.change,
+        type: args.type,
+        priority: args.priority,
+        worktree: args.worktree,
+        output: args.output,
+        force: args.force === true,
+    });
+    if (!result.success) {
+        console.error(`[START] ${result.message}`);
+        process.exit(1);
+    }
+    console.log('');
+    console.log('[START] Task started successfully!');
+    console.log(`  Task ID: ${result.taskId}`);
+    console.log(`  Task File: ${result.taskPath}`);
+    console.log(`  Worktree: ${result.worktreeName}`);
+    console.log(`  Branch: ${result.branch}`);
+    console.log('');
+    console.log('Next steps:');
+    console.log(`  1. Edit product-requirement.md: spec/changes/${result.taskId}/product-requirement.md`);
+    console.log(`  2. Run: task-flow design --change ${result.taskId}`);
+    console.log('  3. Check status: task-flow status');
+    console.log('');
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}
+exports.default = {
+    startTask,
+};

package/dist/commands/status.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/**
+ * commands/status.ts
+ * Show current task and phase status
+ */
+export interface StatusOptions {
+    cwd?: string;
+}
+export declare function showStatus(options?: StatusOptions): void;
+export declare function main(): void;
+declare const _default: {
+    showStatus: typeof showStatus;
+    main: typeof main;
+};
+export default _default;

package/dist/commands/status.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * commands/status.ts
+ * Show current task and phase status
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showStatus = showStatus;
+exports.main = main;
+const config_1 = require("../lib/config");
+const state_1 = require("../lib/state");
+function parseArgs(argv) {
+    const args = {};
+    for (let i = 2; i < argv.length; i += 1) {
+        const token = argv[i] || '';
+        if (!token.startsWith('--')) {
+            continue;
+        }
+        const key = token.slice(2);
+        const next = argv[i + 1];
+        if (!next || next.startsWith('--')) {
+            args[key] = true;
+            continue;
+        }
+        args[key] = next;
+        i += 1;
+    }
+    return args;
+}
+function formatPhase(phase) {
+    if (!phase) {
+        return 'None';
+    }
+    const labels = {
+        planning: '📋 Planning',
+        implementation: '🔨 Implementation',
+        review: '🔍 Review',
+        merge: '🔀 Merge',
+    };
+    return labels[phase] || phase;
+}
+function formatStatus(status) {
+    const icons = {
+        initialized: '⚪',
+        running: '🟢',
+        paused: '🟡',
+        completed: '✅',
+        failed: '🔴',
+        blocked: '🚫',
+    };
+    return `${icons[status] || '⚪'} ${status}`;
+}
+function showStatus(options = {}) {
+    const config = (0, config_1.loadConfig)({ cwd: options.cwd });
+    const state = (0, state_1.loadState)(config);
+    console.log('');
+    console.log('╔════════════════════════════════════════════════════════╗');
+    console.log('║               Task Flow Status                         ║');
+    console.log('╚════════════════════════════════════════════════════════╝');
+    console.log('');
+    // Overall status
+    console.log(`Status: ${formatStatus(state.status)}`);
+    console.log('');
+    // Current task
+    if (state.currentTask) {
+        console.log(`Current Task: ${state.currentTask}`);
+        console.log(`Current Phase: ${formatPhase(state.currentPhase)}`);
+        console.log(`Phase Completed: ${formatPhase(state.phaseCompleted)}`);
+        if (state.reviewConclusion) {
+            const conclusionIcon = {
+                PASS: '✅',
+                NEEDS_WORK: '🔶',
+                FAIL: '❌',
+            };
+            console.log(`Review Conclusion: ${conclusionIcon[state.reviewConclusion] || '⚪'} ${state.reviewConclusion}`);
+        }
+        if (state.currentSnapshot) {
+            console.log(`Latest Snapshot: ${state.currentSnapshot}`);
+        }
+    }
+    else {
+        console.log('Current Task: None');
+    }
+    console.log('');
+    // Active worktrees
+    const activeWorktrees = (0, state_1.getActiveWorktrees)(config);
+    if (activeWorktrees.length > 0) {
+        console.log(`Worktrees (${activeWorktrees.length}):`);
+        for (const wt of activeWorktrees) {
+            console.log(`  - ${wt.name}`);
+            console.log(`    Branch: ${wt.branch}`);
+            console.log(`    Task: ${wt.task}`);
+            console.log(`    Agent: ${wt.agent}`);
+            console.log(`    Last Activity: ${wt.lastActivity}`);
+            if (wt.pendingChanges && wt.pendingChanges.length > 0) {
+                console.log(`    Pending Changes: ${wt.pendingChanges.join(', ')}`);
+            }
+        }
+    }
+    else {
+        console.log('Worktrees: None');
+    }
+    console.log('');
+    // Recent task history
+    if (state.taskHistory && state.taskHistory.length > 0) {
+        console.log('Task History:');
+        const recent = state.taskHistory.slice(-5).reverse();
+        for (const task of recent) {
+            const icon = {
+                completed: '✅',
+                failed: '❌',
+                running: '🟢',
+            };
+            console.log(`  ${icon[task.status] || '⚪'} ${task.taskId}: ${task.status} (${task.currentPhase || 'no phase'})`);
+        }
+    }
+    console.log('');
+    // Gate blocked info
+    if (state.lastGateBlockedReason) {
+        console.log('⚠️  Gate Blocked:');
+        console.log(`   Phase: ${state.lastGateBlockedPhase || 'unknown'}`);
+        console.log(`   Reason: ${state.lastGateBlockedReason}`);
+        if (state.lastMissingValidations && state.lastMissingValidations.length > 0) {
+            console.log(`   Missing: ${state.lastMissingValidations.join(', ')}`);
+        }
+        console.log('');
+    }
+    console.log(`Started: ${state.startedAt}`);
+    console.log(`Updated: ${state.updatedAt}`);
+    console.log('');
+}
+function main() {
+    const args = parseArgs(process.argv);
+    showStatus({ cwd: args.cwd });
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}
+exports.default = {
+    showStatus,
+    main,
+};

package/dist/commands/sync.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * commands/sync.ts
+ * Sync task execution status to Spec
+ */
+import { syncTaskToSpec } from '../spec/sync-task-to-openspec';
+export declare function main(): void;
+declare const _default: {
+    syncTaskToSpec: typeof syncTaskToSpec;
+};
+export default _default;

package/dist/commands/sync.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * commands/sync.ts
+ * Sync task execution status to Spec
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const sync_task_to_openspec_1 = require("../spec/sync-task-to-openspec");
+function parseArgs(argv) {
+    const args = {};
+    for (let i = 2; i < argv.length; i += 1) {
+        const token = argv[i] || '';
+        if (!token.startsWith('--')) {
+            continue;
+        }
+        const key = token.slice(2);
+        const next = argv[i + 1] || '';
+        if (!next || next.startsWith('--')) {
+            args[key] = true;
+            continue;
+        }
+        args[key] = next;
+        i += 1;
+    }
+    return args;
+}
+/**
+ * Check if result has executionPath property
+ */
+function hasExecutionPath(result) {
+    return !result.skipped && 'executionPath' in result;
+}
+function main() {
+    const args = parseArgs(process.argv);
+    const result = (0, sync_task_to_openspec_1.syncTaskToSpec)({
+        cwd: args.cwd,
+        taskId: args['task-id'],
+    });
+    if (result.skipped) {
+        console.log(`[SYNC] skipped: ${result.reason}`);
+        process.exit(0);
+    }
+    // Type-safe access to executionPath
+    if (hasExecutionPath(result)) {
+        console.log(`[SYNC] updated: ${result.executionPath}`);
+    }
+    else {
+        console.log('[SYNC] task synced but no execution path available');
+    }
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}
+exports.default = {
+    syncTaskToSpec: sync_task_to_openspec_1.syncTaskToSpec,
+};