@bicorne/task-flow 0.1.0

package/dist/commands/merge/index.js

@@ -0,0 +1,322 @@
+"use strict";
+/**
+ * commands/merge/index.ts
+ * Merge completed worktree back to main
+ */
+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.mergeTask = mergeTask;
+exports.main = main;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const config_1 = require("../../lib/config");
+const state_1 = require("../../lib/state");
+const validators_1 = require("./validators");
+const merger_1 = require("./merger");
+/**
+ * Parse CLI arguments
+ */
+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;
+}
+/**
+ * Extract merge setting from task file
+ */
+function extractTaskMergeSetting(file, key) {
+    try {
+        const content = fs.readFileSync(file, 'utf8');
+        const lines = content.split('\n');
+        let inMergeStrategy = false;
+        for (const line of lines) {
+            if (/^mergeStrategy:/.test(line)) {
+                inMergeStrategy = true;
+                continue;
+            }
+            if (inMergeStrategy) {
+                if (/^[^\s]/.test(line)) {
+                    break;
+                }
+                const match = line.match(new RegExp(`^\\s+${key}:\\s*(.+)$`));
+                if (match) {
+                    return match?.[1]?.trim() || null;
+                }
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+/**
+ * Get merge configuration from task file
+ */
+function getMergeConfig(taskPath, options) {
+    const mergeType = extractTaskMergeSetting(taskPath, 'type') || 'squash';
+    let deleteBranch = extractTaskMergeSetting(taskPath, 'deleteBranch') !== 'false';
+    let deleteWorktree = extractTaskMergeSetting(taskPath, 'deleteWorktree') !== 'false';
+    if (options.deleteBranch === true) {
+        deleteBranch = true;
+    }
+    if (options.deleteWorktree === true) {
+        deleteWorktree = true;
+    }
+    return { mergeType, deleteBranch, deleteWorktree };
+}
+/**
+ * Print merge summary
+ */
+function printMergeSummary(params) {
+    console.log('');
+    console.log('╔════════════════════════════════════════════════════════╗');
+    console.log('║              Task Flow Merge Summary                   ║');
+    console.log('╚════════════════════════════════════════════════════════╝');
+    console.log('');
+    console.log(`Task ID:        ${params.taskId}`);
+    console.log(`Branch:         ${params.branch}`);
+    console.log(`Worktree:       ${params.worktreeName}`);
+    console.log(`Merge Type:     ${params.mergeType}`);
+    console.log(`Delete Branch:  ${params.deleteBranch}`);
+    console.log(`Delete Worktree: ${params.deleteWorktree}`);
+    console.log(`Dry Run:        ${params.dryRun || false}`);
+    console.log('');
+}
+/**
+ * Update task state after merge
+ */
+function updateTaskStateAfterMerge(config, taskId) {
+    (0, state_1.clearCurrentTask)(config);
+    (0, state_1.addTaskToHistory)({
+        taskId,
+        status: 'completed',
+        completedAt: new Date().toISOString(),
+    }, config);
+    const archiveScript = path.resolve(__dirname, '../../lib/archive.js');
+    (0, child_process_1.spawnSync)(process.execPath, [
+        archiveScript,
+        '--cwd', config.projectRoot,
+        '--task-id', taskId,
+        '--event', 'task_merged',
+        '--status', 'completed',
+        '--phase', 'merge',
+        '--phase-completed', 'review',
+        '--review-conclusion', 'PASS',
+        '--completed-at', new Date().toISOString(),
+    ], { stdio: 'inherit' });
+    const syncScript = path.resolve(__dirname, '../../spec/sync-task-to-openspec.js');
+    (0, child_process_1.spawnSync)(process.execPath, [
+        syncScript,
+        '--cwd', config.projectRoot,
+        '--task-id', taskId,
+    ], { stdio: 'inherit' });
+}
+/**
+ * Execute merge operation
+ */
+async function executeMerge(config, taskId, branch, worktree, mergeType, deleteBranch, deleteWorktree, dryRun) {
+    console.log('[MERGE] Pulling latest changes...');
+    try {
+        const pullResult = (0, child_process_1.spawnSync)('git', ['pull', 'origin', 'main'], { stdio: 'inherit' });
+        if (pullResult.status !== 0) {
+            console.warn('[MERGE] Pull failed, continuing anyway...');
+        }
+    }
+    catch {
+        console.warn('[MERGE] Pull failed, continuing anyway...');
+    }
+    console.log(`[MERGE] Merging branch: ${branch}`);
+    if (!(0, merger_1.performMerge)(branch, mergeType, dryRun)) {
+        return {
+            success: false,
+            reason: 'merge-failed',
+            message: 'Merge failed',
+        };
+    }
+    (0, merger_1.cleanupWorktreeAndBranch)(config, worktree, branch, deleteWorktree, deleteBranch);
+    updateTaskStateAfterMerge(config, taskId);
+    return {
+        success: true,
+        taskId,
+        branch,
+        worktreeName: worktree.name,
+    };
+}
+/**
+ * Merge task
+ */
+function mergeTask(options = {}) {
+    const config = (0, config_1.loadConfig)({ cwd: options.cwd });
+    const state = (0, state_1.loadState)(config);
+    const taskId = options.taskId || state.currentTask;
+    if (!taskId) {
+        return {
+            success: false,
+            reason: 'missing-task-id',
+            message: 'No current task in state.json. Please specify task-id.',
+        };
+    }
+    const taskPath = path.resolve(config.tasksDirAbs, `${taskId}.json`);
+    if (!fs.existsSync(taskPath)) {
+        return {
+            success: false,
+            reason: 'missing-task-file',
+            message: `Task file not found: ${taskPath}`,
+        };
+    }
+    const mergeConfig = getMergeConfig(taskPath, options);
+    const reviewPath = path.resolve(config.reportsDirAbs, `${taskId}-review.md`);
+    const reviewValidation = (0, validators_1.validateReview)(reviewPath, options.skipReviewCheck);
+    if (!reviewValidation.valid) {
+        return {
+            success: false,
+            reason: reviewValidation.reason,
+            message: reviewValidation.message,
+        };
+    }
+    const worktreeValidation = (0, validators_1.validateWorktreeAndBranch)(state, taskId);
+    if (!worktreeValidation.valid) {
+        return {
+            success: false,
+            reason: worktreeValidation.reason,
+            message: worktreeValidation.message,
+        };
+    }
+    const { worktree, branch } = worktreeValidation;
+    printMergeSummary({
+        taskId,
+        branch: branch,
+        worktreeName: worktree.name,
+        mergeType: mergeConfig.mergeType,
+        deleteBranch: mergeConfig.deleteBranch,
+        deleteWorktree: mergeConfig.deleteWorktree,
+        dryRun: options.dryRun,
+    });
+    if (!options.dryRun) {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        return new Promise((resolve) => {
+            rl.question('Proceed with merge? (y/N) ', (answer) => {
+                rl.close();
+                if (!/^[Yy]$/.test(answer)) {
+                    resolve({
+                        success: false,
+                        reason: 'cancelled',
+                        message: 'Merge cancelled',
+                    });
+                    return;
+                }
+                executeMerge(config, taskId, branch, worktree, mergeConfig.mergeType, mergeConfig.deleteBranch, mergeConfig.deleteWorktree, options.dryRun).then(resolve);
+            });
+        });
+    }
+    return {
+        success: true,
+        taskId,
+        branch,
+        worktreeName: worktree.name,
+        dryRun: true,
+    };
+}
+/**
+ * Main entry point
+ */
+function main() {
+    const args = parseArgs(process.argv);
+    const positionalArgs = Array.isArray(args._) ? args._ : [];
+    const result = mergeTask({
+        cwd: args.cwd,
+        taskId: positionalArgs[0] || args['task-id'],
+        skipReviewCheck: args['skip-review-check'] === true,
+        deleteBranch: args['no-delete-branch'] !== true,
+        deleteWorktree: args['no-delete-worktree'] !== true,
+        dryRun: args['dry-run'] === true,
+    });
+    if (result instanceof Promise) {
+        result.then((res) => {
+            if (!res.success) {
+                console.error(`[MERGE] ${res.message}`);
+                process.exit(1);
+            }
+            console.log('');
+            console.log('[MERGE] Merge completed successfully!');
+            console.log(`  Task: ${res.taskId}`);
+            console.log(`  Status: completed`);
+            console.log('');
+            process.exit(0);
+        }).catch((error) => {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error('[MERGE] Error:', errorMessage);
+            process.exit(1);
+        });
+    }
+    else {
+        if (!result.success) {
+            console.error(`[MERGE] ${result.message}`);
+            process.exit(1);
+        }
+        if (result.dryRun) {
+            console.log('[MERGE] Dry run completed. No changes made.');
+        }
+        else {
+            console.log('[MERGE] Merge completed successfully!');
+        }
+        process.exit(0);
+    }
+}
+if (require.main === module) {
+    main();
+}
+exports.default = {
+    mergeTask,
+};

package/dist/commands/merge/merger.d.ts

@@ -0,0 +1,18 @@
+/**
+ * commands/merge/merger.ts
+ * Merge execution utilities
+ */
+import { Config } from '../../lib/config';
+import { WorktreeInfo } from '../../lib/state';
+/**
+ * Handle merge conflicts
+ */
+export declare function handleMergeConflict(): boolean;
+/**
+ * Perform the actual merge
+ */
+export declare function performMerge(branch: string, mergeType: string, dryRun?: boolean): boolean;
+/**
+ * Cleanup worktree and branch
+ */
+export declare function cleanupWorktreeAndBranch(config: Config, worktree: WorktreeInfo, branch: string, deleteWorktree: boolean, deleteBranch: boolean): void;

package/dist/commands/merge/merger.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * commands/merge/merger.ts
+ * Merge execution utilities
+ */
+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.handleMergeConflict = handleMergeConflict;
+exports.performMerge = performMerge;
+exports.cleanupWorktreeAndBranch = cleanupWorktreeAndBranch;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Handle merge conflicts
+ */
+function handleMergeConflict() {
+    try {
+        const conflicted = (0, child_process_1.execSync)('git diff --name-only --diff-filter=U', { encoding: 'utf8' });
+        if (conflicted.trim()) {
+            console.error('[MERGE] Merge conflicts detected:');
+            console.error(conflicted);
+            (0, child_process_1.execSync)('git merge --abort 2>/dev/null || git reset --merge 2>/dev/null || true');
+            return true;
+        }
+    }
+    catch {
+        // no conflicts
+    }
+    return false;
+}
+/**
+ * Perform the actual merge
+ */
+function performMerge(branch, mergeType, dryRun) {
+    if (dryRun) {
+        console.log(`[DRY-RUN] Would merge ${branch} using ${mergeType}`);
+        return true;
+    }
+    try {
+        if (mergeType === 'squash') {
+            const squashResult = (0, child_process_1.spawnSync)('git', ['merge', '--squash', branch], { stdio: 'inherit' });
+            if (squashResult.status !== 0) {
+                console.error('[MERGE] Squash merge failed');
+                return false;
+            }
+            if (handleMergeConflict()) {
+                return false;
+            }
+            try {
+                const commitResult = (0, child_process_1.spawnSync)('git', ['commit', '-m', `feat: merged from harness worktree ${branch}`], { stdio: 'inherit' });
+                if (commitResult.status !== 0) {
+                    console.warn('[MERGE] No changes to commit');
+                }
+            }
+            catch {
+                console.warn('[MERGE] No changes to commit');
+            }
+        }
+        else if (mergeType === 'merge') {
+            const mergeResult = (0, child_process_1.spawnSync)('git', ['merge', '--no-ff', branch, '-m', `feat: merged from harness worktree ${branch}`], { stdio: 'inherit' });
+            if (mergeResult.status !== 0) {
+                console.error('[MERGE] Merge failed');
+                return false;
+            }
+            if (handleMergeConflict()) {
+                return false;
+            }
+        }
+        else if (mergeType === 'rebase') {
+            console.error('[MERGE] Rebase strategy requires worktree rebase - use manual merge for now');
+            return false;
+        }
+        else {
+            console.error(`[MERGE] Unsupported merge strategy: ${mergeType}`);
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        console.error('[MERGE] Merge failed:', errorMessage);
+        return false;
+    }
+}
+/**
+ * Cleanup worktree and branch
+ */
+function cleanupWorktreeAndBranch(config, worktree, branch, deleteWorktree, deleteBranch) {
+    if (deleteWorktree && worktree.path) {
+        const worktreePath = path.resolve(config.projectRoot, worktree.path);
+        if (fs.existsSync(worktreePath)) {
+            console.log(`[MERGE] Removing worktree: ${worktree.name}`);
+            try {
+                const result = (0, child_process_1.spawnSync)('git', ['worktree', 'remove', worktreePath, '--force'], { stdio: 'inherit' });
+                if (result.status !== 0) {
+                    console.warn('[MERGE] Failed to remove worktree');
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                console.warn('[MERGE] Failed to remove worktree:', errorMessage);
+            }
+        }
+    }
+    if (deleteBranch) {
+        console.log(`[MERGE] Deleting branch: ${branch}`);
+        try {
+            const result = (0, child_process_1.spawnSync)('git', ['branch', '-D', branch], { stdio: 'inherit' });
+            if (result.status !== 0) {
+                console.warn('[MERGE] Failed to delete branch');
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.warn('[MERGE] Failed to delete branch:', errorMessage);
+        }
+    }
+}

package/dist/commands/merge/types.d.ts

@@ -0,0 +1,67 @@
+/**
+ * commands/merge/types.ts
+ * Type definitions for merge command
+ */
+import { WorktreeInfo } from '../../lib/state';
+/**
+ * Merge command options
+ */
+export interface MergeOptions {
+    cwd?: string;
+    taskId?: string;
+    skipReviewCheck?: boolean;
+    deleteBranch?: boolean;
+    deleteWorktree?: boolean;
+    dryRun?: boolean;
+}
+/**
+ * Merge command result
+ */
+export interface MergeResult {
+    success: boolean;
+    reason?: string;
+    message?: string;
+    taskId?: string;
+    branch?: string;
+    worktreeName?: string;
+    dryRun?: boolean;
+}
+/**
+ * Merge configuration
+ */
+export interface MergeConfig {
+    mergeType: string;
+    deleteBranch: boolean;
+    deleteWorktree: boolean;
+}
+/**
+ * Validation context for review
+ */
+export interface ReviewValidation {
+    valid: boolean;
+    reason?: string;
+    message?: string;
+    conclusion?: string | null;
+}
+/**
+ * Validation context for worktree and branch
+ */
+export interface WorktreeValidation {
+    valid: boolean;
+    reason?: string;
+    message?: string;
+    worktree?: WorktreeInfo;
+    branch?: string;
+}
+/**
+ * Merge summary parameters
+ */
+export interface MergeSummaryParams {
+    taskId: string;
+    branch: string;
+    worktreeName: string;
+    mergeType: string;
+    deleteBranch: boolean;
+    deleteWorktree: boolean;
+    dryRun?: boolean;
+}

package/dist/commands/merge/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * commands/merge/types.ts
+ * Type definitions for merge command
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/commands/merge/validators.d.ts

@@ -0,0 +1,14 @@
+/**
+ * commands/merge/validators.ts
+ * Validation utilities for merge command
+ */
+import { State } from '../../lib/state';
+import { ReviewValidation, WorktreeValidation } from './types';
+/**
+ * Validate review report
+ */
+export declare function validateReview(reviewPath: string, skipReviewCheck?: boolean): ReviewValidation;
+/**
+ * Validate worktree and branch
+ */
+export declare function validateWorktreeAndBranch(state: State, taskId: string): WorktreeValidation;