@bicorne/task-flow 0.1.0

package/dist/hooks/check-worktree-conflict.js

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * hooks/check-worktree-conflict.ts
+ * Check for worktree conflicts to prevent multi-agent file conflicts
+ */
+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.normalizePath = normalizePath;
+exports.checkWorktreeConflict = checkWorktreeConflict;
+const path = __importStar(require("path"));
+const config_1 = require("../lib/config");
+const state_1 = require("../lib/state");
+function normalizePath(inputPath, projectRoot) {
+    if (!inputPath || typeof inputPath !== 'string') {
+        return '';
+    }
+    const absolutePath = path.isAbsolute(inputPath) ? inputPath : path.resolve(projectRoot, inputPath);
+    return path.relative(projectRoot, absolutePath).replace(/\\/g, '/');
+}
+/**
+ * Check for worktree conflicts
+ * @param options - Options
+ * @returns Result
+ */
+function checkWorktreeConflict(options) {
+    const { input, config } = options;
+    const currentWorktree = process.env.WORKTREE_NAME;
+    const activeWorktrees = (0, state_1.getActiveWorktrees)(config);
+    if (activeWorktrees.length <= 1) {
+        return { conflict: false, reason: 'single-worktree' };
+    }
+    // Check if current operation involves file path
+    const targetFile = normalizePath(input.tool_input?.file_path || input.tool_input?.path, config.projectRoot);
+    if (!targetFile) {
+        return { conflict: false, reason: 'no-file-path' };
+    }
+    // Check if other active worktrees are modifying the same file
+    for (const wt of activeWorktrees) {
+        if (wt.name !== currentWorktree) {
+            const wtChanges = (wt.pendingChanges || [])
+                .map((p) => normalizePath(p, config.projectRoot))
+                .filter(Boolean);
+            if (wtChanges.includes(targetFile)) {
+                return {
+                    conflict: true,
+                    file: targetFile,
+                    conflictingWorktree: wt.name,
+                    message: `File ${targetFile} is being modified by ${wt.name}`,
+                };
+            }
+        }
+    }
+    return { conflict: false, reason: 'no-conflict' };
+}
+/**
+ * Main entry point for hook usage
+ */
+function main() {
+    const input = JSON.parse(process.argv[2] || '{}');
+    const config = (0, config_1.loadConfig)();
+    (0, state_1.loadState)(config);
+    const result = checkWorktreeConflict({ input, config });
+    if (result.conflict) {
+        console.error(`[CONFLICT] ${result.message}`);
+        console.error(`[CONFLICT] Suggestion: Wait for ${result.conflictingWorktree} to complete or use a different file`);
+        process.exit(2); // Non-zero exit to block operation
+    }
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}
+exports.default = {
+    checkWorktreeConflict,
+};

package/dist/hooks/hook-runner/executor.d.ts

@@ -0,0 +1,18 @@
+/**
+ * hooks/hook-runner/executor.ts
+ * Hook execution utilities
+ */
+import { Config } from '../../lib/config';
+import { HookConfig, HookContext, HookResult } from './types';
+/**
+ * Execute a hook module
+ */
+export declare function executeHookFunction(hookModule: Record<string, unknown> | null, context: HookContext): Promise<HookResult>;
+/**
+ * Execute a single hook with timeout control
+ */
+export declare function executeSingleHookAsync(hookConfig: HookConfig, context: HookContext, config: Config): Promise<HookResult>;
+/**
+ * Execute a single hook synchronously
+ */
+export declare function executeSingleHookSync(hookConfig: HookConfig, context: HookContext, config: Config): HookResult;

package/dist/hooks/hook-runner/executor.js

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * hooks/hook-runner/executor.ts
+ * Hook 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.executeHookFunction = executeHookFunction;
+exports.executeSingleHookAsync = executeSingleHookAsync;
+exports.executeSingleHookSync = executeSingleHookSync;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const loader_1 = require("./loader");
+/**
+ * Execute a hook module
+ */
+async function executeHookFunction(hookModule, context) {
+    if (!hookModule) {
+        return { success: false, error: 'hook-module-not-found' };
+    }
+    const hookFn = hookModule?.run
+        || hookModule?.execute
+        || hookModule?.default
+        || hookModule;
+    if (typeof hookFn !== 'function') {
+        return { success: false, error: 'hook-function-not-found' };
+    }
+    try {
+        const result = hookFn(context);
+        if (result && typeof result.then === 'function') {
+            const asyncResult = await result;
+            return { success: true, result: asyncResult };
+        }
+        return { success: true, result };
+    }
+    catch (error) {
+        console.error('[HOOK-RUNNER] Hook execution failed:', error instanceof Error ? error.message : 'Unknown error');
+        return { success: false, error: error instanceof Error ? error.message : 'Unknown error', stack: error instanceof Error ? error.stack : undefined };
+    }
+}
+/**
+ * Execute a single hook with timeout control
+ */
+async function executeSingleHookAsync(hookConfig, context, config) {
+    const { name, script, timeout = 30000 } = hookConfig;
+    console.log(`[HOOK-RUNNER] Executing hook: ${name} (${hookConfig.hookName || 'unknown'})`);
+    // Use dynamic import for async execution
+    const cfg = config || (await Promise.resolve().then(() => __importStar(require('../../lib/config')))).loadConfig();
+    const absolutePath = path.isAbsolute(script)
+        ? script
+        : path.resolve(cfg.projectRoot, script);
+    if (!fs.existsSync(absolutePath)) {
+        return { name, success: false, error: 'script-not-found', script };
+    }
+    try {
+        const fileUrl = `file://${absolutePath}?t=${Date.now()}`;
+        const hookModule = await Promise.resolve(`${fileUrl}`).then(s => __importStar(require(s)));
+        const abortController = new AbortController();
+        const timeoutId = setTimeout(() => {
+            abortController.abort(new Error(`hook-timeout:${timeout}ms`));
+        }, timeout);
+        try {
+            const executePromise = executeHookFunction(hookModule.default || hookModule, context);
+            const result = await Promise.race([
+                executePromise,
+                new Promise((_, reject) => {
+                    abortController.signal.addEventListener('abort', () => {
+                        reject(abortController.signal.reason);
+                    });
+                }),
+            ]);
+            return { name, ...result, script };
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    catch (error) {
+        return { name, success: false, error: error instanceof Error ? error.message : 'Unknown error', script };
+    }
+}
+/**
+ * Execute a single hook synchronously
+ */
+function executeSingleHookSync(hookConfig, context, config) {
+    const { name, script } = hookConfig;
+    console.log(`[HOOK-RUNNER] Executing hook (sync): ${name} (${hookConfig.hookName || 'unknown'})`);
+    const hookModule = (0, loader_1.loadHookScript)(script, config);
+    if (!hookModule) {
+        return { name, success: false, error: 'script-not-found', script };
+    }
+    const hookFn = hookModule?.run
+        || hookModule?.execute
+        || hookModule?.default
+        || hookModule;
+    if (typeof hookFn !== 'function') {
+        return { name, success: false, error: 'hook-function-not-found', script };
+    }
+    try {
+        const result = hookFn(context);
+        if (result && typeof result.then === 'function') {
+            console.warn('[HOOK-RUNNER] Async hook detected in sync execution:', name);
+            return { name, success: false, error: 'async-hook-in-sync-mode', script };
+        }
+        return { name, success: true, result, script };
+    }
+    catch (error) {
+        console.error('[HOOK-RUNNER] Hook execution failed:', error instanceof Error ? error.message : 'Unknown error');
+        return { name, success: false, error: error instanceof Error ? error.message : 'Unknown error', script };
+    }
+}

package/dist/hooks/hook-runner/index.d.ts

@@ -0,0 +1,64 @@
+/**
+ * hooks/hook-runner/index.ts
+ * Unified hook execution engine for task-flow
+ */
+import { Config } from '../../lib/config';
+import { HookLifecycle, HookConfig, HookContext, HookExecutionResult } from './types';
+import { loadHooksConfig, loadHookScript, loadHookScriptAsync } from './loader';
+import { executeHookFunction } from './executor';
+/**
+ * Hook lifecycle definitions
+ */
+export declare const HOOK_LIFECYCLE: Record<string, HookLifecycle>;
+/**
+ * Run a single hook by name
+ */
+export declare function runHook(hookName: string, context: HookContext): Promise<HookExecutionResult>;
+/**
+ * Run a single hook by name (sync)
+ */
+export declare function runHookSync(hookName: string, context: HookContext): HookExecutionResult;
+/**
+ * Run a chain of hooks
+ */
+export declare function runHookChain(hookNames: string[], context: HookContext): Promise<HookExecutionResult>;
+/**
+ * Get hook lifecycle info
+ */
+export declare function getHookLifecycle(hookName: string): HookLifecycle | null;
+/**
+ * Get hooks for a phase and timing
+ */
+export declare function getHooksForPhase(phase: string, timing: string, config?: Config): (HookConfig & {
+    hookName: string;
+    lifecycle: HookLifecycle;
+})[];
+/**
+ * Validate hook config
+ */
+export declare function validateHookConfig(hookConfig: HookConfig): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Create hook config
+ */
+export declare function createHookConfig(name: string, script: string, options?: {
+    enabled?: boolean;
+    timeout?: number;
+}): HookConfig;
+declare const _default: {
+    runHook: typeof runHook;
+    runHookSync: typeof runHookSync;
+    runHookChain: typeof runHookChain;
+    loadHooksConfig: typeof loadHooksConfig;
+    loadHookScript: typeof loadHookScript;
+    loadHookScriptAsync: typeof loadHookScriptAsync;
+    executeHookFunction: typeof executeHookFunction;
+    getHookLifecycle: typeof getHookLifecycle;
+    getHooksForPhase: typeof getHooksForPhase;
+    validateHookConfig: typeof validateHookConfig;
+    createHookConfig: typeof createHookConfig;
+    HOOK_LIFECYCLE: Record<string, HookLifecycle>;
+};
+export default _default;

package/dist/hooks/hook-runner/index.js

@@ -0,0 +1,220 @@
+"use strict";
+/**
+ * hooks/hook-runner/index.ts
+ * Unified hook execution engine for task-flow
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HOOK_LIFECYCLE = void 0;
+exports.runHook = runHook;
+exports.runHookSync = runHookSync;
+exports.runHookChain = runHookChain;
+exports.getHookLifecycle = getHookLifecycle;
+exports.getHooksForPhase = getHooksForPhase;
+exports.validateHookConfig = validateHookConfig;
+exports.createHookConfig = createHookConfig;
+const config_1 = require("../../lib/config");
+const loader_1 = require("./loader");
+const executor_1 = require("./executor");
+/**
+ * Hook lifecycle definitions
+ */
+exports.HOOK_LIFECYCLE = {
+    'pre-design': { phase: 'design', timing: 'pre' },
+    'post-design': { phase: 'design', timing: 'post' },
+    'pre-planning': { phase: 'planning', timing: 'pre' },
+    'post-planning': { phase: 'planning', timing: 'post' },
+    'pre-implementation': { phase: 'implementation', timing: 'pre' },
+    'post-implementation': { phase: 'implementation', timing: 'post' },
+    'pre-review': { phase: 'review', timing: 'pre' },
+    'post-review': { phase: 'review', timing: 'post' },
+    'pre-merge': { phase: 'merge', timing: 'pre' },
+    'post-merge': { phase: 'merge', timing: 'post' },
+    'pre-command': { phase: 'command', timing: 'pre' },
+    'post-command': { phase: 'command', timing: 'post' },
+};
+/**
+ * Run enabled hooks async
+ */
+async function runEnabledHooks(enabledHooks, context, config, hookName) {
+    const results = [];
+    let allSuccess = true;
+    for (const hookConfig of enabledHooks) {
+        const result = await (0, executor_1.executeSingleHookAsync)(hookConfig, context, config);
+        results.push(result);
+        if (!result.success) {
+            allSuccess = false;
+        }
+    }
+    return {
+        success: allSuccess,
+        executed: results.length,
+        results,
+        hookName,
+    };
+}
+/**
+ * Run enabled hooks sync
+ */
+function runEnabledHooksSync(enabledHooks, context, config, hookName) {
+    const results = [];
+    let allSuccess = true;
+    for (const hookConfig of enabledHooks) {
+        const result = (0, executor_1.executeSingleHookSync)(hookConfig, context, config);
+        results.push(result);
+        if (!result.success) {
+            allSuccess = false;
+        }
+    }
+    return {
+        success: allSuccess,
+        executed: results.length,
+        results,
+        hookName,
+    };
+}
+/**
+ * Run a single hook by name
+ */
+async function runHook(hookName, context) {
+    const config = context?.config || (0, config_1.loadConfig)();
+    const hooksConfig = (0, loader_1.loadHooksConfig)(config);
+    if (!hooksConfig.hooks || !hooksConfig.hooks[hookName]) {
+        return {
+            success: true,
+            executed: 0,
+            results: [],
+            message: `no-hooks-configured:${hookName}`,
+        };
+    }
+    const hooks = hooksConfig.hooks[hookName];
+    const enabledHooks = hooks.filter((h) => h.enabled !== false);
+    if (enabledHooks.length === 0) {
+        return {
+            success: true,
+            executed: 0,
+            results: [],
+            message: `no-enabled-hooks:${hookName}`,
+        };
+    }
+    return runEnabledHooks(enabledHooks, context, config, hookName);
+}
+/**
+ * Run a single hook by name (sync)
+ */
+function runHookSync(hookName, context) {
+    const config = context?.config || (0, config_1.loadConfig)();
+    const hooksConfig = (0, loader_1.loadHooksConfig)(config);
+    if (!hooksConfig.hooks || !hooksConfig.hooks[hookName]) {
+        return {
+            success: true,
+            executed: 0,
+            results: [],
+            message: `no-hooks-configured:${hookName}`,
+        };
+    }
+    const hooks = hooksConfig.hooks[hookName];
+    const enabledHooks = hooks.filter((h) => h.enabled !== false);
+    if (enabledHooks.length === 0) {
+        return {
+            success: true,
+            executed: 0,
+            results: [],
+            message: `no-enabled-hooks:${hookName}`,
+        };
+    }
+    return runEnabledHooksSync(enabledHooks, context, config, hookName);
+}
+/**
+ * Run a chain of hooks
+ */
+async function runHookChain(hookNames, context) {
+    const results = [];
+    let allSuccess = true;
+    for (const hookName of hookNames) {
+        const result = await runHook(hookName, context);
+        results.push(result);
+        if (!result.success) {
+            allSuccess = false;
+            break;
+        }
+    }
+    return {
+        success: allSuccess,
+        executed: results.length,
+        results: results.flatMap((r) => r.results),
+        hookNames,
+    };
+}
+/**
+ * Get hook lifecycle info
+ */
+function getHookLifecycle(hookName) {
+    return exports.HOOK_LIFECYCLE[hookName] || null;
+}
+/**
+ * Get hooks for a phase and timing
+ */
+function getHooksForPhase(phase, timing, config) {
+    const cfg = config || (0, config_1.loadConfig)();
+    const hooksConfig = (0, loader_1.loadHooksConfig)(cfg);
+    if (!hooksConfig.hooks) {
+        return [];
+    }
+    const matchingHooks = [];
+    for (const [hookName, lifecycle] of Object.entries(exports.HOOK_LIFECYCLE)) {
+        if (lifecycle.phase === phase && lifecycle.timing === timing) {
+            const hooks = hooksConfig.hooks[hookName] || [];
+            matchingHooks.push(...hooks.map((h) => ({
+                ...h,
+                hookName,
+                lifecycle,
+            })));
+        }
+    }
+    return matchingHooks;
+}
+/**
+ * Validate hook config
+ */
+function validateHookConfig(hookConfig) {
+    const errors = [];
+    if (!hookConfig.name || typeof hookConfig.name !== 'string') {
+        errors.push('hook-must-have-name');
+    }
+    if (!hookConfig.script || typeof hookConfig.script !== 'string') {
+        errors.push('hook-must-have-script');
+    }
+    if (hookConfig.timeout !== undefined && typeof hookConfig.timeout !== 'number') {
+        errors.push('hook-timeout-must-be-number');
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Create hook config
+ */
+function createHookConfig(name, script, options = {}) {
+    return {
+        name,
+        script,
+        enabled: options.enabled !== false,
+        timeout: options.timeout || 30000,
+        ...options,
+    };
+}
+exports.default = {
+    runHook,
+    runHookSync,
+    runHookChain,
+    loadHooksConfig: loader_1.loadHooksConfig,
+    loadHookScript: loader_1.loadHookScript,
+    loadHookScriptAsync: loader_1.loadHookScriptAsync,
+    executeHookFunction: executor_1.executeHookFunction,
+    getHookLifecycle,
+    getHooksForPhase,
+    validateHookConfig,
+    createHookConfig,
+    HOOK_LIFECYCLE: exports.HOOK_LIFECYCLE,
+};

package/dist/hooks/hook-runner/loader.d.ts

@@ -0,0 +1,23 @@
+/**
+ * hooks/hook-runner/loader.ts
+ * Hook loading utilities
+ */
+import { Config } from '../../lib/config';
+import { LoadedHooksConfig } from './types';
+/**
+ * Get default hooks path
+ */
+export declare function getDefaultHooksPath(config: Config): string;
+/**
+ * Load hooks config from file
+ */
+export declare function loadHooksConfig(config?: Config): LoadedHooksConfig;
+/**
+ * Load hook script with dynamic import to avoid require.cache issues
+ */
+export declare function loadHookScriptAsync(scriptPath: string, config?: Config): Promise<Record<string, unknown> | null>;
+/**
+ * Load hook script (legacy sync version)
+ * @deprecated Use loadHookScriptAsync instead
+ */
+export declare function loadHookScript(scriptPath: string, config?: Config): Record<string, unknown> | null;