@bicorne/task-flow 0.1.0

package/dist/hooks/start-mcp-servers.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * hooks/start-mcp-servers.ts
+ * Hook for starting MCP servers with autoStart enabled
+ *
+ * This hook:
+ * 1. Gets MCP server configurations from context
+ * 2. Starts servers with lifecycle.autoStart = true
+ * 3. Returns connection information for downstream use
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const mcp_client_1 = require("../lib/mcp-client");
+/**
+ * Start MCP servers hook
+ * @param context - Hook execution context
+ * @returns Hook execution result
+ */
+function run(context) {
+    const { config, tools } = context;
+    if (!config || !config.projectRoot) {
+        return {
+            check: 'mcp-started',
+            success: false,
+            error: 'missing-config',
+            reason: 'Project root not found in context',
+        };
+    }
+    // Get MCP servers from tools (passed by previous hook)
+    const mcpServers = tools?.mcp || [];
+    if (mcpServers.length === 0) {
+        return {
+            check: 'mcp-started',
+            success: true,
+            message: 'No MCP servers configured',
+            started: [],
+            connectionInfo: [],
+        };
+    }
+    try {
+        console.log('[START-MCP] Starting MCP servers...');
+        // Start MCP servers with autoStart enabled
+        const result = (0, mcp_client_1.startMcpServers)(mcpServers, config.projectRoot);
+        // Get connection information
+        const connectionInfo = (0, mcp_client_1.getMcpConnectionInfo)();
+        const startedCount = result.results.filter(r => r.status === 'started').length;
+        const skippedCount = result.results.filter(r => r.status === 'skipped').length;
+        console.log(`[START-MCP] Started ${startedCount} servers, ${skippedCount} skipped (autoStart=false)`);
+        return {
+            check: 'mcp-started',
+            success: result.success,
+            result,
+            connectionInfo,
+            summary: {
+                totalCount: mcpServers.length,
+                startedCount,
+                skippedCount,
+                failedCount: result.results.filter(r => r.status === 'error').length,
+            },
+        };
+    }
+    catch (error) {
+        console.error('[START-MCP] Failed to start MCP servers:', error.message);
+        return {
+            check: 'mcp-started',
+            success: false,
+            error: error.message,
+            stack: error.stack,
+        };
+    }
+}
+exports.default = {
+    run,
+    name: 'start-mcp-servers',
+};

package/dist/hooks/stop-mcp-servers.d.ts

@@ -0,0 +1,40 @@
+/**
+ * hooks/stop-mcp-servers.ts
+ * Hook for stopping all MCP servers
+ *
+ * This hook:
+ * 1. Stops all running MCP servers
+ * 2. Should be called in post-merge or cleanup phase
+ */
+import { StopResult } from '../lib/mcp-client';
+export interface StopMcpContext {
+    [key: string]: unknown;
+}
+export interface StopMcpResult {
+    check: 'mcp-stopped';
+    success: boolean;
+    error?: string;
+    reason?: string;
+    message?: string;
+    result?: {
+        success: boolean;
+        results: StopResult[];
+    };
+    stopped?: StopResult[];
+    summary?: {
+        stoppedCount: number;
+        errorCount: number;
+    };
+    stack?: string;
+}
+/**
+ * Stop MCP servers hook
+ * @param _context - Hook execution context
+ * @returns Hook execution result
+ */
+export declare function run(_context: StopMcpContext): StopMcpResult;
+declare const _default: {
+    run: typeof run;
+    name: string;
+};
+export default _default;

package/dist/hooks/stop-mcp-servers.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * hooks/stop-mcp-servers.ts
+ * Hook for stopping all MCP servers
+ *
+ * This hook:
+ * 1. Stops all running MCP servers
+ * 2. Should be called in post-merge or cleanup phase
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const mcp_client_1 = require("../lib/mcp-client");
+/**
+ * Stop MCP servers hook
+ * @param _context - Hook execution context
+ * @returns Hook execution result
+ */
+function run(_context) {
+    const runningCount = (0, mcp_client_1.getRunningCount)();
+    if (runningCount === 0) {
+        return {
+            check: 'mcp-stopped',
+            success: true,
+            message: 'No MCP servers running',
+            stopped: [],
+        };
+    }
+    try {
+        console.log(`[STOP-MCP] Stopping ${runningCount} MCP server(s)...`);
+        // Stop all MCP servers
+        const result = (0, mcp_client_1.stopAllMcpServers)();
+        const stoppedCount = result.results.filter(r => r.status !== 'error').length;
+        const errorCount = result.results.filter(r => r.status === 'error').length;
+        console.log(`[STOP-MCP] Stopped ${stoppedCount} servers, ${errorCount} errors`);
+        return {
+            check: 'mcp-stopped',
+            success: result.success,
+            result,
+            summary: {
+                stoppedCount,
+                errorCount,
+            },
+        };
+    }
+    catch (error) {
+        console.error('[STOP-MCP] Failed to stop MCP servers:', error.message);
+        return {
+            check: 'mcp-stopped',
+            success: false,
+            error: error.message,
+            stack: error.stack,
+        };
+    }
+}
+exports.default = {
+    run,
+    name: 'stop-mcp-servers',
+};

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+/**
+ * index.ts
+ * CLI entry point for @bicorne/task-flow
+ *
+ * Supports both traditional CLI commands and slash commands:
+ *   task-flow extract --change my-feature
+ *   /tf:propose my-feature  (in AI chat)
+ */
+declare function printHelp(): void;
+declare function printVersion(): void;
+declare function parseArgs(argv: string[]): {
+    command: string | null;
+    options: Record<string, unknown>;
+    help?: boolean;
+    version?: boolean;
+};
+declare function runCommand(command: string, options: Record<string, unknown>): void;
+declare function handleSlashCommand(input: string): Promise<void>;
+declare function main(): Promise<void>;
+declare const _default: {
+    main: typeof main;
+    printHelp: typeof printHelp;
+    printVersion: typeof printVersion;
+    parseArgs: typeof parseArgs;
+    runCommand: typeof runCommand;
+    handleSlashCommand: typeof handleSlashCommand;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * index.ts
+ * CLI entry point for @bicorne/task-flow
+ *
+ * Supports both traditional CLI commands and slash commands:
+ *   task-flow extract --change my-feature
+ *   /tf:propose my-feature  (in AI chat)
+ */
+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 });
+const path = __importStar(require("path"));
+const slash_1 = require("./slash");
+function printHelp() {
+    console.log(`
+task-flow - Git worktree-based parallel task execution system
+
+Usage:
+  task-flow <command> [options]
+  /tf:<command> [args]           (in AI chat)
+  task-flow /tf:<command> [args] (via CLI)
+
+Commands:
+  init                  Initialize task flow in current project
+  analyze               Scan project and generate AI context JSON
+  extract               Extract project requirements and generate PRD document
+  design                Generate design.md from product-requirement.md
+  tasks                 Generate PHASE-*.json files from PRD and design docs
+  worktree              Create isolated git worktree for task execution
+  start                 Start a task from spec change (legacy)
+  status                Show current task and phase status
+  archive               Archive current task state
+  merge                 Merge completed worktree back to main branch
+  sync                  Sync task execution status to spec
+  help                  Show this help message
+${(0, slash_1.printSlashHelp)()}
+Tasks Command Options:
+  --input <json>        Provide tasks JSON directly (AI input)
+  --yes, -y             Skip interactive confirmation
+  --type <type>         Task type (feat|fix|refactor|test|docs)
+  --priority <level>    Task priority (high|medium|low)
+
+Tasks Command Input Sources (priority order):
+  1. --input parameter: Provide JSON array of tasks
+  2. stdin: Pipe JSON through standard input
+  3. Auto-extraction: Parse product-requirement.md and design.md
+  4. tasks.md: Parse from markdown file (fallback)
+
+Options:
+  --help, -h            Show help for command
+  --version, -v         Show version
+  --force               Force overwrite existing files
+  --yes, -y             Skip interactive confirmation (non-interactive mode)
+
+Examples:
+  /tf:propose add-dark-mode              (in AI chat)
+  /tf:apply add-dark-mode                (in AI chat)
+  /tf:archive --task-id add-dark-mode    (in AI chat)
+  task-flow init
+  task-flow analyze --output context.json
+  task-flow extract --change my-feature --context-file context.json
+  task-flow design --change my-feature --context-file context.json
+  task-flow tasks --change my-feature --yes
+  task-flow worktree --change my-feature --yes
+  task-flow status
+  task-flow merge --dry-run
+
+Environment Variables:
+  HARNESS_ROOT          Root directory for harness state (default: .harness)
+  HARNESS_CONFIG_FILE   Path to config file (default: .harnessrc)
+
+Documentation:
+  https://github.com/didengren/harness-task-flow
+`);
+}
+function printVersion() {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const pkg = require('../package.json');
+    console.log(`@bicorne/task-flow v${pkg.version}`);
+}
+function parseArgs(argv) {
+    const args = {
+        command: null,
+        options: {},
+        help: false,
+        version: false,
+    };
+    for (let i = 2; i < argv.length; i += 1) {
+        const token = argv[i] || '';
+        if (token.startsWith('--')) {
+            const key = token.slice(2);
+            if (key === 'help' || key === 'h') {
+                args.help = true;
+                continue;
+            }
+            if (key === 'version' || key === 'v') {
+                args.version = true;
+                continue;
+            }
+            const next = argv[i + 1];
+            if (!next || next.startsWith('--')) {
+                args.options[key] = true;
+                continue;
+            }
+            args.options[key] = next;
+            i += 1;
+        }
+        else if (token.startsWith('-') && token.length === 2) {
+            const shortOpt = token.slice(1);
+            if (shortOpt === 'h') {
+                args.help = true;
+            }
+            else if (shortOpt === 'v') {
+                args.version = true;
+            }
+        }
+        else if (!args.command) {
+            args.command = token || null;
+        }
+    }
+    return args;
+}
+function runCommand(command, options) {
+    const commandPath = path.resolve(__dirname, 'commands', `${command}.js`);
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const commandModule = require(commandPath);
+        if (typeof commandModule === 'function') {
+            commandModule(options);
+        }
+        else if (commandModule.main && typeof commandModule.main === 'function') {
+            commandModule.main();
+        }
+    }
+    catch (error) {
+        if (error.code === 'MODULE_NOT_FOUND') {
+            console.error(`[ERROR] Unknown command: ${command}`);
+            console.error('Run "task-flow help" for available commands.');
+            process.exit(1);
+        }
+        console.error(`[ERROR] Command failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        process.exit(1);
+    }
+}
+async function handleSlashCommand(input) {
+    const result = await (0, slash_1.runSlashCommand)(input);
+    if (result.success) {
+        console.log('');
+        console.log(`[SLASH] ✓ /tf:${result.command} completed`);
+        if (result.steps) {
+            for (const step of result.steps) {
+                const icon = step.success ? '✓' : '✗';
+                console.log(`  ${icon} ${step.step}: ${step.message || (step.success ? 'OK' : 'Failed')}`);
+            }
+        }
+        console.log('');
+    }
+    else {
+        console.error('');
+        console.error(`[SLASH] ✗ /tf:${result.command} failed`);
+        if (result.error) {
+            console.error(`  Error: ${result.error}`);
+        }
+        if (result.steps) {
+            for (const step of result.steps) {
+                if (!step.success) {
+                    console.error(`  ✗ ${step.step}: ${step.message || 'Failed'}`);
+                }
+            }
+        }
+        console.error('');
+        process.exit(1);
+    }
+}
+async function main() {
+    const rawCommand = process.argv[2] || '';
+    if ((0, slash_1.isSlashCommand)(rawCommand)) {
+        const fullInput = process.argv.slice(2).join(' ');
+        await handleSlashCommand(fullInput);
+        return;
+    }
+    const args = parseArgs(process.argv);
+    if (args.version) {
+        printVersion();
+        process.exit(0);
+    }
+    if (args.help || !args.command) {
+        printHelp();
+        process.exit(0);
+    }
+    if (args.command === 'help') {
+        printHelp();
+        process.exit(0);
+    }
+    runCommand(args.command, args.options);
+}
+main();
+exports.default = {
+    main,
+    printHelp,
+    printVersion,
+    parseArgs,
+    runCommand,
+    handleSlashCommand,
+};

package/dist/lib/archive.d.ts

@@ -0,0 +1,31 @@
+/**
+ * archive.ts
+ * Archive task state to persistent storage
+ */
+export interface ArchiveOptions {
+    cwd?: string;
+    taskId?: string;
+    eventType?: string;
+    status?: string;
+    phase?: string;
+    phaseCompleted?: string;
+    reviewConclusion?: string;
+    reason?: string;
+    completedAt?: string;
+    at?: string;
+    updateState?: boolean;
+}
+export interface ArchiveResult {
+    skipped: boolean;
+    reason?: string;
+    taskId?: string;
+    archivePath?: string;
+}
+/**
+ * Archive task state
+ */
+export declare function archiveTaskState(options?: ArchiveOptions): ArchiveResult;
+declare const _default: {
+    archiveTaskState: typeof archiveTaskState;
+};
+export default _default;

package/dist/lib/archive.js

@@ -0,0 +1,226 @@
+"use strict";
+/**
+ * archive.ts
+ * Archive task state to persistent storage
+ */
+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.archiveTaskState = archiveTaskState;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+const state_1 = require("./state");
+/**
+ * Ensure path uses POSIX separators
+ */
+function ensurePosix(input) {
+    return String(input || '').replace(/\\/g, '/');
+}
+/**
+ * Read JSON file if exists
+ */
+function readJsonIfExists(filePath) {
+    if (!filePath || !fs.existsSync(filePath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get task file path
+ */
+function getTaskFilePath(config, taskId) {
+    return path.resolve(config.tasksDirAbs, `${taskId}.json`);
+}
+/**
+ * Read task JSON file
+ */
+function readTaskJson(config, taskId) {
+    const taskPath = getTaskFilePath(config, taskId);
+    return readJsonIfExists(taskPath);
+}
+/**
+ * Get task summary from JSON
+ */
+function getTaskSummary(taskJson, taskId) {
+    return {
+        taskId,
+        title: taskJson?.title || '',
+        type: taskJson?.type || '',
+        priority: taskJson?.priority || 'medium',
+    };
+}
+/**
+ * Get Spec metadata from task JSON
+ */
+function getMetadataSpec(taskJson) {
+    if (!taskJson?.metadata?.change) {
+        return null;
+    }
+    return {
+        change: taskJson.metadata.change,
+        proposal: taskJson.docs_to_read?.[0] || null,
+        design: taskJson.docs_to_read?.[1] || null,
+        tasks: taskJson.docs_to_read?.[2] || null,
+        manifest: taskJson.metadata?.manifest || null,
+        execution: taskJson.metadata?.execution || null,
+        version: 'v1',
+    };
+}
+/**
+ * Get artifacts paths
+ */
+function getArtifacts(config, taskId, taskJson, spec) {
+    return {
+        task: ensurePosix(path.relative(config.projectRoot, path.resolve(config.tasksDirAbs, `${taskId}.json`))),
+        implementationSnapshot: taskJson?.metadata?.outputs?.snapshot || null,
+        review: taskJson?.metadata?.outputs?.report || null,
+        execution: spec?.execution || null,
+        archive: ensurePosix(path.relative(config.projectRoot, path.resolve(config.archiveDirAbs, `${taskId}.json`))),
+    };
+}
+/**
+ * Build event object
+ */
+function buildEvent(options, state) {
+    return {
+        type: options.eventType || 'state_synced',
+        at: options.at || new Date().toISOString(),
+        status: options.status || state?.status || null,
+        phase: options.phase || state?.currentPhase || null,
+        phaseCompleted: options.phaseCompleted || state?.phaseCompleted || null,
+        reviewConclusion: options.reviewConclusion || state?.reviewConclusion || null,
+        reason: options.reason || state?.lastGateBlockedReason || null,
+    };
+}
+/**
+ * Check if two events are the same
+ */
+function isSameEvent(left, right) {
+    if (!left || !right) {
+        return false;
+    }
+    return left.type === right.type
+        && left.status === right.status
+        && left.phase === right.phase
+        && left.phaseCompleted === right.phaseCompleted
+        && left.reviewConclusion === right.reviewConclusion
+        && left.reason === right.reason;
+}
+/**
+ * Archive task state
+ */
+function archiveTaskState(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 { skipped: true, reason: 'missing-task-id' };
+    }
+    const taskJson = readTaskJson(config, taskId);
+    if (!taskJson) {
+        return { skipped: true, reason: 'missing-task-file' };
+    }
+    const archiveDir = config.archiveDirAbs;
+    const archivePath = path.resolve(archiveDir, `${taskId}.json`);
+    const archiveRelativePath = ensurePosix(path.relative(config.projectRoot, archivePath));
+    const previous = readJsonIfExists(archivePath) || {};
+    const taskSummary = getTaskSummary(taskJson, taskId);
+    const spec = getMetadataSpec(taskJson);
+    const now = options.at || new Date().toISOString();
+    const lifecycleStatus = options.status || state.status || previous.lifecycle?.status || 'initialized';
+    const lifecycle = {
+        createdAt: previous.lifecycle?.createdAt || state.startedAt || now,
+        startedAt: previous.lifecycle?.startedAt || state.startedAt || now,
+        completedAt: lifecycleStatus === 'completed' ? (options.completedAt || now) : (previous.lifecycle?.completedAt || null),
+        lastUpdatedAt: now,
+        status: lifecycleStatus,
+        currentPhase: options.phase || state.currentPhase || null,
+        phaseCompleted: options.phaseCompleted || state.phaseCompleted || null,
+        reviewConclusion: options.reviewConclusion || state.reviewConclusion || null,
+    };
+    const archiveDoc = {
+        taskId,
+        title: taskSummary.title,
+        type: taskSummary.type,
+        priority: taskSummary.priority,
+        spec,
+        lifecycle,
+        artifacts: getArtifacts(config, taskId, taskJson, spec),
+        mergeStrategy: taskJson?.metadata?.mergeStrategy || { type: 'squash', deleteBranch: true, deleteWorktree: true },
+        worktrees: Array.isArray(state.worktrees) ? state.worktrees.filter((item) => item?.task === taskId) : [],
+        lastGate: {
+            blockedAt: state.lastGateBlockedAt || null,
+            reason: options.reason || state.lastGateBlockedReason || null,
+            phase: state.lastGateBlockedPhase || null,
+            missingValidations: Array.isArray(state.lastMissingValidations) ? state.lastMissingValidations : [],
+        },
+        taskPhases: {
+            planning: taskJson?.status || 'pending',
+            implementation: taskJson?.status || 'pending',
+            review: taskJson?.status || 'pending',
+        },
+        events: Array.isArray(previous.events) ? previous.events : [],
+    };
+    const nextEvent = buildEvent(options, state);
+    if (!isSameEvent(archiveDoc.events[archiveDoc.events.length - 1], nextEvent)) {
+        archiveDoc.events.push(nextEvent);
+    }
+    fs.mkdirSync(archiveDir, { recursive: true });
+    fs.writeFileSync(archivePath, JSON.stringify(archiveDoc, null, 2), 'utf8');
+    if (options.updateState !== false) {
+        (0, state_1.addTaskToHistory)({
+            taskId,
+            title: taskSummary.title,
+            status: lifecycleStatus,
+            currentPhase: options.phase || state.currentPhase,
+            phaseCompleted: options.phaseCompleted || state.phaseCompleted,
+            reviewConclusion: options.reviewConclusion || state.reviewConclusion,
+            archivePath: archiveRelativePath,
+        }, config);
+    }
+    return {
+        skipped: false,
+        taskId,
+        archivePath: archiveRelativePath,
+    };
+}
+exports.default = {
+    archiveTaskState,
+};