@bicorne/task-flow 0.1.0 → 0.2.1

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

@@ -1,107 +1,74 @@
-"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);
+let e, t, r;
+function o(e) {
+    return "function" != typeof WeakMap ? null : (o = function(e) {
+        return new WeakMap();
+    })(e);
+}
+function n(e, t) {
+    if (!e || 'string' != typeof e) return '';
+    let r = a.isAbsolute(e) ? e : a.resolve(t, e);
+    return a.relative(t, r).replace(/\\/g, '/');
+}
+function i(e) {
+    let { input: t, config: r } = e, o = process.env.WORKTREE_NAME, i = (0, s.getActiveWorktrees)(r);
+    if (i.length <= 1) return {
+        conflict: !1,
+        reason: 'single-worktree'
     };
-    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;
+    let l = n(t.tool_input?.file_path || t.tool_input?.path, r.projectRoot);
+    if (!l) return {
+        conflict: !1,
+        reason: 'no-file-path'
+    };
+    for (let e of i)if (e.name !== o && (e.pendingChanges || []).map((e)=>n(e, r.projectRoot)).filter(Boolean).includes(l)) return {
+        conflict: !0,
+        file: l,
+        conflictingWorktree: e.name,
+        message: `File ${l} is being modified by ${e.name}`
+    };
+    return {
+        conflict: !1,
+        reason: 'no-conflict'
     };
-})();
-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}`,
-                };
-            }
-        }
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+var l = exports, c = {
+    get checkWorktreeConflict () {
+        return i;
+    },
+    get default () {
+        return p;
+    },
+    get normalizePath () {
+        return n;
     }
-    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
+};
+for(var f in c)Object.defineProperty(l, f, {
+    enumerable: !0,
+    get: Object.getOwnPropertyDescriptor(c, f).get
+});
+let a = /*#__PURE__*/ function(e) {
+    var t, r, n;
+    if (e && e.__esModule) return e;
+    if (null === e || "object" != typeof e && "function" != typeof e) return {
+        default: e
+    };
+    if ((t = o(void 0)) && t.has(e)) return t.get(e);
+    for(var i in r = {
+        __proto__: null
+    }, n = Object.defineProperty && Object.getOwnPropertyDescriptor, e)if ("default" !== i && Object.prototype.hasOwnProperty.call(e, i)) {
+        var l = n ? Object.getOwnPropertyDescriptor(e, i) : null;
+        l && (l.get || l.set) ? Object.defineProperty(r, i, l) : r[i] = e[i];
     }
-    process.exit(0);
-}
-if (require.main === module) {
-    main();
-}
-exports.default = {
-    checkWorktreeConflict,
+    return r.default = e, t && t.set(e, r), r;
+}(require("path")), u = require("../lib/config"), s = require("../lib/state");
+require.main === module && (e = JSON.parse(process.argv[2] || '{}'), t = (0, u.loadConfig)(), (0, s.loadState)(t), (r = i({
+    input: e,
+    config: t
+})).conflict && (console.error(`[CONFLICT] ${r.message}`), console.error(`[CONFLICT] Suggestion: Wait for ${r.conflictingWorktree} to complete or use a different file`), process.exit(2)), process.exit(0));
+let p = {
+    checkWorktreeConflict: i
 };

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

@@ -1,143 +1,151 @@
-"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]; } };
+function e(r) {
+    return "function" != typeof WeakMap ? null : (e = function(e) {
+        return new WeakMap();
+    })(r);
+}
+function r(r, o) {
+    var t, n, s;
+    if (!o && r && r.__esModule) return r;
+    if (null === r || "object" != typeof r && "function" != typeof r) return {
+        default: r
+    };
+    if ((t = e(o)) && t.has(r)) return t.get(r);
+    for(var c in n = {
+        __proto__: null
+    }, s = Object.defineProperty && Object.getOwnPropertyDescriptor, r)if ("default" !== c && Object.prototype.hasOwnProperty.call(r, c)) {
+        var u = s ? Object.getOwnPropertyDescriptor(r, c) : null;
+        u && (u.get || u.set) ? Object.defineProperty(n, c, u) : n[c] = r[c];
     }
-    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 n.default = r, t && t.set(r, n), n;
+}
+async function o(e, r) {
+    if (!e) return {
+        success: !1,
+        error: 'hook-module-not-found'
     };
-    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;
+    let o = e?.run || e?.execute || e?.default || e;
+    if ('function' != typeof o) return {
+        success: !1,
+        error: 'hook-function-not-found'
     };
-})();
-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 };
+        let e = o(r);
+        if (e && 'function' == typeof e.then) {
+            let r = await e;
+            return {
+                success: !0,
+                result: r
+            };
         }
-        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 };
+        return {
+            success: !0,
+            result: e
+        };
+    } catch (e) {
+        return console.error('[HOOK-RUNNER] Hook execution failed:', e instanceof Error ? e.message : 'Unknown error'), {
+            success: !1,
+            error: e instanceof Error ? e.message : 'Unknown error',
+            stack: e instanceof Error ? e.stack : void 0
+        };
     }
 }
-/**
- * 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 };
-    }
+async function t(e, t, n) {
+    let { name: s, script: c, timeout: u = 30000 } = e;
+    console.log(`[HOOK-RUNNER] Executing hook: ${s} (${e.hookName || 'unknown'})`);
+    let f = n || (await Promise.resolve().then(()=>/*#__PURE__*/ r(require("../../lib/config")))).loadConfig(), l = a.isAbsolute(c) ? c : a.resolve(f.projectRoot, c);
+    if (!i.existsSync(l)) return {
+        name: s,
+        success: !1,
+        error: "script-not-found",
+        script: c
+    };
     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);
+        let e = `file://${l}?t=${Date.now()}`, n = await Promise.resolve(e).then((e)=>/*#__PURE__*/ r(require(e))), i = new AbortController(), a = setTimeout(()=>{
+            i.abort(Error(`hook-timeout:${u}ms`));
+        }, u);
         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);
+            let e = o(n.default || n, t), r = await Promise.race([
+                e,
+                new Promise((e, r)=>{
+                    i.signal.addEventListener('abort', ()=>{
+                        r(i.signal.reason);
                     });
-                }),
+                })
             ]);
-            return { name, ...result, script };
-        }
-        finally {
-            clearTimeout(timeoutId);
+            return {
+                name: s,
+                ...r,
+                script: c
+            };
+        } finally{
+            clearTimeout(a);
         }
-    }
-    catch (error) {
-        return { name, success: false, error: error instanceof Error ? error.message : 'Unknown error', script };
+    } catch (e) {
+        return {
+            name: s,
+            success: !1,
+            error: e instanceof Error ? e.message : 'Unknown error',
+            script: c
+        };
     }
 }
-/**
- * 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 };
-    }
+function n(e, r, o) {
+    let { name: t, script: n } = e;
+    console.log(`[HOOK-RUNNER] Executing hook (sync): ${t} (${e.hookName || 'unknown'})`);
+    let s = (0, f.loadHookScript)(n, o);
+    if (!s) return {
+        name: t,
+        success: !1,
+        error: "script-not-found",
+        script: n
+    };
+    let c = s?.run || s?.execute || s?.default || s;
+    if ('function' != typeof c) return {
+        name: t,
+        success: !1,
+        error: 'hook-function-not-found',
+        script: n
+    };
     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 };
+        let e = c(r);
+        if (e && 'function' == typeof e.then) return console.warn('[HOOK-RUNNER] Async hook detected in sync execution:', t), {
+            name: t,
+            success: !1,
+            error: 'async-hook-in-sync-mode',
+            script: n
+        };
+        return {
+            name: t,
+            success: !0,
+            result: e,
+            script: n
+        };
+    } catch (e) {
+        return console.error('[HOOK-RUNNER] Hook execution failed:', e instanceof Error ? e.message : 'Unknown error'), {
+            name: t,
+            success: !1,
+            error: e instanceof Error ? e.message : 'Unknown error',
+            script: n
+        };
     }
 }
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+var s = exports, c = {
+    get executeHookFunction () {
+        return o;
+    },
+    get executeSingleHookAsync () {
+        return t;
+    },
+    get executeSingleHookSync () {
+        return n;
+    }
+};
+for(var u in c)Object.defineProperty(s, u, {
+    enumerable: !0,
+    get: Object.getOwnPropertyDescriptor(c, u).get
+});
+let i = /*#__PURE__*/ r(require("fs")), a = /*#__PURE__*/ r(require("path")), f = require("./loader");