@bicorne/task-flow 0.1.0

package/dist/lib/constants.js

@@ -0,0 +1,247 @@
+"use strict";
+/**
+ * lib/constants.ts
+ * Shared constants and magic strings for task-flow
+ *
+ * Centralizes all magic strings, status values, phase names, and error codes
+ * to ensure consistency across the codebase.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULTS = exports.ERROR_CODES = exports.EVENT_TYPES = exports.SKILL_FORMAT = exports.AGENT_TYPES = exports.VALIDATION_ALIASES = exports.GATE_VALIDATIONS = exports.HOOK_NAMES = exports.STATE_FILES = exports.DIR_NAMES = exports.FILE_PATTERNS = exports.ALLOWED_COMMANDS = exports.DEFAULT_MERGE_CONFIG = exports.MERGE_TYPE = exports.VALIDATED_STATUSES = exports.VALIDATION_STATUS = exports.REVIEW_CONCLUSION = exports.STATUS = exports.PHASE = void 0;
+exports.isAllowedCommand = isAllowedCommand;
+/**
+ * Phase names
+ */
+exports.PHASE = {
+    PLANNING: 'planning',
+    IMPLEMENTATION: 'implementation',
+    REVIEW: 'review',
+    MERGE: 'merge',
+};
+/**
+ * Status values
+ */
+exports.STATUS = {
+    PENDING: 'pending',
+    RUNNING: 'running',
+    COMPLETED: 'completed',
+    BLOCKED: 'blocked',
+    FAILED: 'failed',
+    SKIPPED: 'skipped',
+    ACTIVE: 'active',
+};
+/**
+ * Review conclusions
+ */
+exports.REVIEW_CONCLUSION = {
+    PASS: 'PASS',
+    NEEDS_WORK: 'NEEDS_WORK',
+    FAIL: 'FAIL',
+};
+/**
+ * Validation status values
+ */
+exports.VALIDATION_STATUS = {
+    PASS: 'pass',
+    PASSED: 'passed',
+    SUCCESS: 'success',
+    OK: 'ok',
+    TRUE: 'true',
+    FAIL: 'fail',
+    FAILED: 'failed',
+};
+/**
+ * Validated status values (for passed validations)
+ */
+exports.VALIDATED_STATUSES = [
+    exports.VALIDATION_STATUS.PASS,
+    exports.VALIDATION_STATUS.PASSED,
+    exports.VALIDATION_STATUS.SUCCESS,
+    exports.VALIDATION_STATUS.OK,
+    exports.VALIDATION_STATUS.TRUE,
+];
+/**
+ * Merge strategy types
+ */
+exports.MERGE_TYPE = {
+    SQUASH: 'squash',
+    MERGE: 'merge',
+    REBASE: 'rebase',
+};
+/**
+ * Default merge configuration
+ */
+exports.DEFAULT_MERGE_CONFIG = {
+    type: exports.MERGE_TYPE.SQUASH,
+    deleteBranch: true,
+    deleteWorktree: true,
+};
+/**
+ * Allowed commands for CLI execution (security whitelist)
+ */
+exports.ALLOWED_COMMANDS = [
+    'git',
+    'node',
+    'pnpm',
+    'npm',
+    'yarn',
+    'tsc',
+    'eslint',
+    'prettier',
+    'jest',
+    'vitest',
+    'mocha',
+    'tsx',
+    'ts-node',
+];
+/**
+ * Check if a command is allowed
+ * @param cmd - Command to check
+ * @returns True if command is allowed
+ */
+function isAllowedCommand(cmd) {
+    return exports.ALLOWED_COMMANDS.includes(cmd);
+}
+/**
+ * File patterns
+ */
+exports.FILE_PATTERNS = {
+    TASK_JSON: /^.+\.json$/,
+    SNAPSHOT_JSON: /.+-impl\.json$/,
+    REVIEW_MD: /.+-review\.md$/,
+    PROPOSAL_MD: /^proposal\.md$/,
+    DESIGN_MD: /^design\.md$/,
+    TASKS_MD: /^tasks\.md$/,
+    EXECUTION_JSON: /^execution\.json$/,
+    MANIFEST_JSON: /^manifest\.json$/,
+};
+/**
+ * Directory names
+ */
+exports.DIR_NAMES = {
+    HARNESS: '.harness',
+    SPEC: 'spec',
+    CHANGES: 'changes',
+    TASKS: 'tasks',
+    SNAPSHOTS: 'snapshots',
+    REPORTS: 'reports',
+    ARCHIVE: 'archive',
+    WORKTREES: '.worktrees',
+    SKILLS: 'skills',
+};
+/**
+ * State file names
+ */
+exports.STATE_FILES = {
+    STATE: 'state.json',
+    CONFIG: '.harnessrc',
+    HOOKS: 'hooks.json',
+    MCP: 'mcp.json',
+    SKILLS: 'skills.json',
+};
+/**
+ * Hook names
+ */
+exports.HOOK_NAMES = {
+    PRE_DESIGN: 'pre-design',
+    POST_DESIGN: 'post-design',
+    PRE_TASKS: 'pre-tasks',
+    POST_TASKS: 'post-tasks',
+    PRE_WORKTREE: 'pre-worktree',
+    POST_WORKTREE: 'post-worktree',
+    PRE_SNAPSHOT: 'pre-snapshot',
+    POST_SNAPSHOT: 'post-snapshot',
+    PRE_REVIEW: 'pre-review',
+    POST_REVIEW: 'post-review',
+    PRE_MERGE: 'pre-merge',
+    POST_MERGE: 'post-merge',
+};
+/**
+ * Gate validation names
+ */
+exports.GATE_VALIDATIONS = {
+    BUILD_PASSES: 'build-passes',
+    TESTS_PASS: 'tests-pass',
+    TYPECHECK_PASSES: 'typecheck-passes',
+    LINT_PASSES: 'lint-passes',
+    SECURITY_CHECK: 'security-check',
+    COVERAGE_GE_80: 'coverage-ge-80',
+    REVIEW_CONCLUSION: 'review-conclusion',
+    PLANNING_READY: 'planning-ready',
+};
+/**
+ * Validation aliases (maps validation name to alternative names)
+ */
+exports.VALIDATION_ALIASES = {
+    [exports.GATE_VALIDATIONS.BUILD_PASSES]: ['build-passes', 'build-pass', 'build', 'build-success'],
+    [exports.GATE_VALIDATIONS.TESTS_PASS]: ['tests-pass', 'test-pass', 'tests', 'test', 'unit-tests-pass'],
+    [exports.GATE_VALIDATIONS.TYPECHECK_PASSES]: ['typecheck-passes', 'type-check', 'typecheck', 'typescript-pass'],
+    [exports.GATE_VALIDATIONS.LINT_PASSES]: ['lint-passes', 'lint-pass', 'lint'],
+    [exports.GATE_VALIDATIONS.SECURITY_CHECK]: ['security-check', 'security-scan', 'security-review'],
+    [exports.GATE_VALIDATIONS.COVERAGE_GE_80]: ['coverage-ge-80', 'coverage-threshold', 'coverage-passes'],
+    [exports.GATE_VALIDATIONS.REVIEW_CONCLUSION]: ['review-conclusion', 'conclusion'],
+};
+/**
+ * Agent types
+ */
+exports.AGENT_TYPES = {
+    CLAUDE_CODE: 'claude-code',
+    TRAE: 'trae',
+    QODER: 'qoder',
+};
+/**
+ * Skill formats
+ */
+exports.SKILL_FORMAT = {
+    COPY_SKILL_MD: 'copy-skill-md',
+    COPY_DIRECTORY: 'copy-directory',
+    SYMLINK: 'symlink',
+};
+/**
+ * Event types for archiving
+ */
+exports.EVENT_TYPES = {
+    TASK_STARTED: 'task_started',
+    PHASE_STARTED: 'phase_started',
+    PHASE_COMPLETED: 'phase_completed',
+    SNAPSHOT_CREATED: 'snapshot_created',
+    REVIEW_COMPLETED: 'review_completed',
+    TASK_MERGED: 'task_merged',
+    TASK_COMPLETED: 'task_completed',
+    GATE_BLOCKED: 'gate_blocked',
+};
+/**
+ * Error codes
+ */
+exports.ERROR_CODES = {
+    MISSING_CHANGE: 'missing-change',
+    INVALID_CHANGE: 'invalid-change',
+    MISSING_TASK_ID: 'missing-task-id',
+    INVALID_TASK_ID: 'invalid-task-id',
+    MISSING_TASK_FILE: 'missing-task-file',
+    MISSING_SPEC: 'missing-spec',
+    MISSING_METADATA: 'missing-metadata',
+    ALREADY_EXISTS: 'already-exists',
+    NOT_FOUND: 'not-found',
+    VALIDATION_FAILED: 'validation-failed',
+    GATE_BLOCKED: 'gate-blocked',
+    MERGE_FAILED: 'merge-failed',
+    WORKTREE_CONFLICT: 'worktree-conflict',
+    REVIEW_NOT_PASSED: 'review-not-passed',
+    MISSING_REVIEW: 'missing-review',
+    MISSING_WORKTREE: 'missing-worktree',
+    MISSING_BRANCH: 'missing-branch',
+    DIRTY_WORKTREE: 'dirty-worktree',
+    CANCELLED: 'cancelled',
+    SYNC_FAILED: 'sync-failed',
+    UNKNOWN_ERROR: 'unknown-error',
+};
+/**
+ * Default values
+ */
+exports.DEFAULTS = {
+    TIMEOUT: 300000, // 5 minutes
+    FORCE_KILL_TIMEOUT: 5000, // 5 seconds
+    MAX_HISTORY_ENTRIES: 100,
+    MAX_WORKTREES: 10,
+};

package/dist/lib/interactive.d.ts

@@ -0,0 +1,31 @@
+/**
+ * lib/interactive.ts
+ * Interactive CLI utilities for user confirmation
+ */
+export interface ConfirmOptions {
+    message: string;
+    defaultYes?: boolean;
+}
+export interface SelectOptions {
+    message: string;
+    choices: string[];
+    defaultIndex?: number;
+}
+export interface InputOptions {
+    message: string;
+    default?: string;
+    validator?: (input: string) => boolean | string;
+}
+export declare function confirm(options: ConfirmOptions): Promise<boolean>;
+export declare function select(options: SelectOptions): Promise<string>;
+export declare function input(options: InputOptions): Promise<string>;
+export declare function confirmOrExit(message: string, defaultYes?: boolean): Promise<void>;
+export declare function printPreview(title: string, items: Record<string, string | number | boolean>): void;
+declare const _default: {
+    confirm: typeof confirm;
+    select: typeof select;
+    input: typeof input;
+    confirmOrExit: typeof confirmOrExit;
+    printPreview: typeof printPreview;
+};
+export default _default;

package/dist/lib/interactive.js

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * lib/interactive.ts
+ * Interactive CLI utilities for user confirmation
+ */
+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.confirm = confirm;
+exports.select = select;
+exports.input = input;
+exports.confirmOrExit = confirmOrExit;
+exports.printPreview = printPreview;
+const readline = __importStar(require("readline"));
+function confirm(options) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const hint = options.defaultYes !== false ? '[Y/n]' : '[y/N]';
+    const prompt = `${options.message} ${hint}: `;
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            rl.close();
+            const input = answer.trim().toLowerCase();
+            if (input === '') {
+                resolve(options.defaultYes !== false);
+            }
+            else if (input === 'y' || input === 'yes') {
+                resolve(true);
+            }
+            else if (input === 'n' || input === 'no') {
+                resolve(false);
+            }
+            else {
+                resolve(options.defaultYes !== false);
+            }
+        });
+        rl.on('error', () => {
+            rl.close();
+            resolve(options.defaultYes !== false);
+        });
+    });
+}
+function select(options) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const choicesDisplay = options.choices
+        .map((c, i) => `  ${i + 1}. ${c}`)
+        .join('\n');
+    const defaultHint = options.defaultIndex !== undefined
+        ? ` (default: ${options.defaultIndex + 1})`
+        : '';
+    const prompt = `${options.message}${defaultHint}\n${choicesDisplay}\nSelect: `;
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            rl.close();
+            const input = answer.trim();
+            if (input === '' && options.defaultIndex !== undefined) {
+                resolve(options.choices[options.defaultIndex] || options.choices[0] || '');
+                return;
+            }
+            const index = parseInt(input, 10) - 1;
+            if (index >= 0 && index < options.choices.length) {
+                resolve(options.choices[index] || options.choices[0] || '');
+            }
+            else {
+                resolve(options.choices[0] || '');
+            }
+        });
+        rl.on('error', () => {
+            rl.close();
+            resolve(options.choices[0] || '');
+        });
+    });
+}
+function input(options) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const hint = options.default ? ` (default: ${options.default})` : '';
+    const prompt = `${options.message}${hint}: `;
+    return new Promise((resolve) => {
+        const ask = () => {
+            rl.question(prompt, (answer) => {
+                const value = answer.trim() || options.default || '';
+                if (options.validator) {
+                    const result = options.validator(value);
+                    if (result === true) {
+                        rl.close();
+                        resolve(value);
+                    }
+                    else {
+                        const errorMsg = typeof result === 'string' ? result : 'Invalid input';
+                        console.log(`  Error: ${errorMsg}`);
+                        ask();
+                    }
+                }
+                else {
+                    rl.close();
+                    resolve(value);
+                }
+            });
+        };
+        ask();
+        rl.on('error', () => {
+            rl.close();
+            resolve(options.default || '');
+        });
+    });
+}
+async function confirmOrExit(message, defaultYes = false) {
+    const confirmed = await confirm({ message, defaultYes });
+    if (!confirmed) {
+        console.log('\nOperation cancelled.');
+        process.exit(0);
+    }
+}
+function printPreview(title, items) {
+    console.log(`\n${title}:`);
+    for (const [key, value] of Object.entries(items)) {
+        console.log(`  ${key}: ${value}`);
+    }
+    console.log('');
+}
+exports.default = {
+    confirm,
+    select,
+    input,
+    confirmOrExit,
+    printPreview,
+};

package/dist/lib/mcp-client.d.ts

@@ -0,0 +1,156 @@
+/**
+ * lib/mcp-client.ts
+ * MCP Server lifecycle management
+ *
+ * Features:
+ * - Start/stop MCP servers
+ * - Timeout control
+ * - State management
+ * - Connection info retrieval
+ */
+import { ChildProcess } from 'child_process';
+/**
+ * MCP Server configuration interface
+ */
+export interface McpServerConfig {
+    name: string;
+    command: string;
+    args?: string[];
+    enabled?: boolean;
+    lifecycle?: {
+        autoStart?: boolean;
+        timeout?: number;
+    };
+}
+/**
+ * Server state interface
+ */
+export interface ServerState {
+    name: string;
+    pid: number;
+    process: ChildProcess;
+    startedAt: Date;
+    status: string;
+    timeout: number;
+    config: McpServerConfig;
+    timeoutTimer?: NodeJS.Timeout;
+    forceKillTimer?: NodeJS.Timeout;
+}
+/**
+ * Start result interface
+ */
+export interface StartResult {
+    name: string;
+    status: string;
+    pid?: number;
+    command?: string;
+    startedAt?: string;
+    reason?: string;
+    error?: string;
+    stack?: string;
+}
+/**
+ * Stop result interface
+ */
+export interface StopResult {
+    name: string;
+    status: string;
+    pid?: number;
+    error?: string;
+}
+/**
+ * Status info interface
+ */
+export interface StatusInfo {
+    name: string;
+    status: string;
+    pid: number;
+    startedAt: string;
+    uptime: number;
+    timeout: number;
+}
+/**
+ * Connection info interface
+ */
+export interface ConnectionInfo {
+    name: string;
+    transportType: string;
+    pid: number;
+    status: string;
+}
+/**
+ * Start MCP Servers
+ * @param mcpServers - List of MCP server configurations
+ * @param projectRoot - Project root directory
+ * @returns Start result
+ */
+export declare function startMcpServers(mcpServers: McpServerConfig[], projectRoot: string): {
+    success: boolean;
+    results: StartResult[];
+};
+/**
+ * Start single MCP Server
+ * @param mcp - MCP server configuration
+ * @param projectRoot - Project root directory
+ * @returns Start result
+ */
+export declare function startMcpServer(mcp: McpServerConfig, projectRoot: string): StartResult;
+/**
+ * Stop MCP Server
+ * @param name - Server name
+ * @returns Stop result
+ */
+export declare function stopMcpServer(name: string): StopResult;
+/**
+ * Stop all MCP Servers
+ * @returns Stop result
+ */
+export declare function stopAllMcpServers(): {
+    success: boolean;
+    results: StopResult[];
+    stoppedCount: number;
+};
+/**
+ * Get MCP Server status
+ * @param name - Server name
+ * @returns Status info
+ */
+export declare function getMcpStatus(name: string): StatusInfo;
+/**
+ * Get all MCP Servers status
+ * @returns List of status info
+ */
+export declare function getAllMcpStatus(): StatusInfo[];
+/**
+ * Get MCP connection info (for injection to Agent)
+ * @returns List of connection info
+ */
+export declare function getMcpConnectionInfo(): ConnectionInfo[];
+/**
+ * Manually start MCP Server (for CLI commands)
+ * @param mcp - MCP server configuration
+ * @param projectRoot - Project root directory
+ * @returns Start result
+ */
+export declare function startMcpServerManual(mcp: McpServerConfig, projectRoot: string): StartResult;
+/**
+ * Get count of running MCP Servers
+ * @returns Running count
+ */
+export declare function getRunningCount(): number;
+/**
+ * Clean up all state (before process exit)
+ */
+export declare function cleanup(): void;
+declare const _default: {
+    startMcpServers: typeof startMcpServers;
+    stopMcpServer: typeof stopMcpServer;
+    stopAllMcpServers: typeof stopAllMcpServers;
+    getMcpStatus: typeof getMcpStatus;
+    getAllMcpStatus: typeof getAllMcpStatus;
+    getMcpConnectionInfo: typeof getMcpConnectionInfo;
+    getRunningCount: typeof getRunningCount;
+    startMcpServerManual: typeof startMcpServerManual;
+    cleanup: typeof cleanup;
+};
+export default _default;