@bicorne/task-flow 0.2.0 → 0.2.1

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

@@ -1,220 +1,205 @@
-"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;
-        }
+async function e(e, t, o, n) {
+    let s = [], r = !0;
+    for (let n of e){
+        let e = await (0, m.executeSingleHookAsync)(n, t, o);
+        s.push(e), e.success || (r = !1);
     }
     return {
-        success: allSuccess,
-        executed: results.length,
-        results,
-        hookName,
+        success: r,
+        executed: s.length,
+        results: s,
+        hookName: n
     };
 }
-/**
- * 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,
+async function t(t, o) {
+    let n = o?.config || (0, p.loadConfig)(), s = (0, g.loadHooksConfig)(n);
+    if (!s.hooks || !s.hooks[t]) return {
+        success: !0,
+        executed: 0,
+        results: [],
+        message: `no-hooks-configured:${t}`
     };
+    let r = s.hooks[t].filter((e)=>!1 !== e.enabled);
+    return 0 === r.length ? {
+        success: !0,
+        executed: 0,
+        results: [],
+        message: `no-enabled-hooks:${t}`
+    } : e(r, o, n, t);
 }
-/**
- * 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}`,
-        };
+function o(e, t) {
+    let o = t?.config || (0, p.loadConfig)(), n = (0, g.loadHooksConfig)(o);
+    if (!n.hooks || !n.hooks[e]) return {
+        success: !0,
+        executed: 0,
+        results: [],
+        message: `no-hooks-configured:${e}`
+    };
+    let s = n.hooks[e].filter((e)=>!1 !== e.enabled);
+    if (0 === s.length) return {
+        success: !0,
+        executed: 0,
+        results: [],
+        message: `no-enabled-hooks:${e}`
+    };
+    let r = [], i = !0;
+    for (let e of s){
+        let n = (0, m.executeSingleHookSync)(e, t, o);
+        r.push(n), n.success || (i = !1);
     }
-    return runEnabledHooksSync(enabledHooks, context, config, hookName);
+    return {
+        success: i,
+        executed: r.length,
+        results: r,
+        hookName: e
+    };
 }
-/**
- * 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;
+async function n(e, o) {
+    let n = [], s = !0;
+    for (let r of e){
+        let e = await t(r, o);
+        if (n.push(e), !e.success) {
+            s = !1;
             break;
         }
     }
     return {
-        success: allSuccess,
-        executed: results.length,
-        results: results.flatMap((r) => r.results),
-        hookNames,
+        success: s,
+        executed: n.length,
+        results: n.flatMap((e)=>e.results),
+        hookNames: e
     };
 }
-/**
- * Get hook lifecycle info
- */
-function getHookLifecycle(hookName) {
-    return exports.HOOK_LIFECYCLE[hookName] || null;
+function s(e) {
+    return f[e] || 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,
+function r(e, t, o) {
+    let n = o || (0, p.loadConfig)(), s = (0, g.loadHooksConfig)(n);
+    if (!s.hooks) return [];
+    let r = [];
+    for (let [o, n] of Object.entries(f))if (n.phase === e && n.timing === t) {
+        let e = s.hooks[o] || [];
+        r.push(...e.map((e)=>({
+                ...e,
+                hookName: o,
+                lifecycle: n
             })));
-        }
     }
-    return matchingHooks;
+    return r;
 }
-/**
- * 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,
+function i(e) {
+    let t = [];
+    return e.name && 'string' == typeof e.name || t.push('hook-must-have-name'), e.script && 'string' == typeof e.script || t.push("hook-must-have-script"), void 0 !== e.timeout && 'number' != typeof e.timeout && t.push('hook-timeout-must-be-number'), {
+        valid: 0 === t.length,
+        errors: t
     };
 }
-/**
- * Create hook config
- */
-function createHookConfig(name, script, options = {}) {
+function u(e, t, o = {}) {
     return {
-        name,
-        script,
-        enabled: options.enabled !== false,
-        timeout: options.timeout || 30000,
-        ...options,
+        name: e,
+        script: t,
+        enabled: !1 !== o.enabled,
+        timeout: o.timeout || 30000,
+        ...o
     };
 }
-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,
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+var a = exports, c = {
+    get HOOK_LIFECYCLE () {
+        return f;
+    },
+    get createHookConfig () {
+        return u;
+    },
+    get default () {
+        return h;
+    },
+    get getHookLifecycle () {
+        return s;
+    },
+    get getHooksForPhase () {
+        return r;
+    },
+    get runHook () {
+        return t;
+    },
+    get runHookChain () {
+        return n;
+    },
+    get runHookSync () {
+        return o;
+    },
+    get validateHookConfig () {
+        return i;
+    }
+};
+for(var l in c)Object.defineProperty(a, l, {
+    enumerable: !0,
+    get: Object.getOwnPropertyDescriptor(c, l).get
+});
+let p = require("../../lib/config"), g = require("./loader"), m = require("./executor"), f = {
+    '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'
+    }
+}, h = {
+    runHook: t,
+    runHookSync: o,
+    runHookChain: n,
+    loadHooksConfig: g.loadHooksConfig,
+    loadHookScript: g.loadHookScript,
+    loadHookScriptAsync: g.loadHookScriptAsync,
+    executeHookFunction: m.executeHookFunction,
+    getHookLifecycle: s,
+    getHooksForPhase: r,
+    validateHookConfig: i,
+    createHookConfig: u,
+    HOOK_LIFECYCLE: f
 };

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

@@ -1,126 +1,87 @@
-"use strict";
-/**
- * hooks/hook-runner/loader.ts
- * Hook loading 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.getDefaultHooksPath = getDefaultHooksPath;
-exports.loadHooksConfig = loadHooksConfig;
-exports.loadHookScriptAsync = loadHookScriptAsync;
-exports.loadHookScript = loadHookScript;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const config_1 = require("../../lib/config");
-/**
- * Default hooks config
- */
-const DEFAULT_HOOKS_CONFIG = {
-    hooks: {},
-};
-/**
- * Get default hooks path
- */
-function getDefaultHooksPath(config) {
-    return path.resolve(config.harnessRootAbs, 'hooks.json');
+function e(r) {
+    return "function" != typeof WeakMap ? null : (e = function(e) {
+        return new WeakMap();
+    })(r);
 }
-/**
- * Load hooks config from file
- */
-function loadHooksConfig(config) {
-    const cfg = config || (0, config_1.loadConfig)();
-    const hooksPath = getDefaultHooksPath(cfg);
-    if (!fs.existsSync(hooksPath)) {
-        return { ...DEFAULT_HOOKS_CONFIG, configPath: hooksPath };
+function r(r, o) {
+    var t, n, i;
+    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 l in n = {
+        __proto__: null
+    }, i = Object.defineProperty && Object.getOwnPropertyDescriptor, r)if ("default" !== l && Object.prototype.hasOwnProperty.call(r, l)) {
+        var s = i ? Object.getOwnPropertyDescriptor(r, l) : null;
+        s && (s.get || s.set) ? Object.defineProperty(n, l, s) : n[l] = r[l];
     }
+    return n.default = r, t && t.set(r, n), n;
+}
+function o(e) {
+    return a.resolve(e.harnessRootAbs, 'hooks.json');
+}
+function t(e) {
+    let r = o(e || (0, f.loadConfig)());
+    if (!c.existsSync(r)) return {
+        ...p,
+        configPath: r
+    };
     try {
-        const content = fs.readFileSync(hooksPath, 'utf8');
-        const parsed = JSON.parse(content);
+        let e = c.readFileSync(r, 'utf8'), o = JSON.parse(e);
         return {
-            ...DEFAULT_HOOKS_CONFIG,
-            ...parsed,
-            configPath: hooksPath,
+            ...p,
+            ...o,
+            configPath: r
+        };
+    } catch (e) {
+        return console.warn('[HOOK-RUNNER] Failed to load hooks config:', e instanceof Error ? e.message : 'Unknown error'), {
+            ...p,
+            configPath: r
         };
-    }
-    catch (error) {
-        console.warn('[HOOK-RUNNER] Failed to load hooks config:', error instanceof Error ? error.message : 'Unknown error');
-        return { ...DEFAULT_HOOKS_CONFIG, configPath: hooksPath };
     }
 }
-/**
- * Load hook script with dynamic import to avoid require.cache issues
- */
-async function loadHookScriptAsync(scriptPath, config) {
-    const cfg = config || (0, config_1.loadConfig)();
-    const absolutePath = path.isAbsolute(scriptPath)
-        ? scriptPath
-        : path.resolve(cfg.projectRoot, scriptPath);
-    if (!fs.existsSync(absolutePath)) {
-        console.warn('[HOOK-RUNNER] Hook script not found:', absolutePath);
-        return null;
-    }
+async function n(e, o) {
+    let t = o || (0, f.loadConfig)(), n = a.isAbsolute(e) ? e : a.resolve(t.projectRoot, e);
+    if (!c.existsSync(n)) return console.warn("[HOOK-RUNNER] Hook script not found:", n), null;
     try {
-        const fileUrl = `file://${absolutePath}?t=${Date.now()}`;
-        const hookModule = await Promise.resolve(`${fileUrl}`).then(s => __importStar(require(s)));
-        return hookModule.default || hookModule;
-    }
-    catch (error) {
-        console.error('[HOOK-RUNNER] Failed to load hook script:', absolutePath, error instanceof Error ? error.message : 'Unknown error');
-        return null;
+        let e = `file://${n}?t=${Date.now()}`, o = await Promise.resolve(e).then((e)=>/*#__PURE__*/ r(require(e)));
+        return o.default || o;
+    } catch (e) {
+        return console.error("[HOOK-RUNNER] Failed to load hook script:", n, e instanceof Error ? e.message : 'Unknown error'), null;
     }
 }
-/**
- * Load hook script (legacy sync version)
- * @deprecated Use loadHookScriptAsync instead
- */
-function loadHookScript(scriptPath, config) {
-    const cfg = config || (0, config_1.loadConfig)();
-    const absolutePath = path.isAbsolute(scriptPath)
-        ? scriptPath
-        : path.resolve(cfg.projectRoot, scriptPath);
-    if (!fs.existsSync(absolutePath)) {
-        console.warn('[HOOK-RUNNER] Hook script not found:', absolutePath);
-        return null;
-    }
+function i(e, r) {
+    let o = r || (0, f.loadConfig)(), t = a.isAbsolute(e) ? e : a.resolve(o.projectRoot, e);
+    if (!c.existsSync(t)) return console.warn("[HOOK-RUNNER] Hook script not found:", t), null;
     try {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const hookModule = require(absolutePath);
-        return hookModule;
-    }
-    catch (error) {
-        console.error('[HOOK-RUNNER] Failed to load hook script:', absolutePath, error instanceof Error ? error.message : 'Unknown error');
-        return null;
+        return require(t);
+    } catch (e) {
+        return console.error("[HOOK-RUNNER] Failed to load hook script:", t, e instanceof Error ? e.message : 'Unknown error'), null;
     }
 }
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+var l = exports, s = {
+    get getDefaultHooksPath () {
+        return o;
+    },
+    get loadHookScript () {
+        return i;
+    },
+    get loadHookScriptAsync () {
+        return n;
+    },
+    get loadHooksConfig () {
+        return t;
+    }
+};
+for(var u in s)Object.defineProperty(l, u, {
+    enumerable: !0,
+    get: Object.getOwnPropertyDescriptor(s, u).get
+});
+let c = /*#__PURE__*/ r(require("fs")), a = /*#__PURE__*/ r(require("path")), f = require("../../lib/config"), p = {
+    hooks: {}
+};

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

@@ -1,6 +1,4 @@
 "use strict";
-/**
- * hooks/hook-runner/types.ts
- * Type definitions for hook runner
- */
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});