@bicorne/task-flow 0.1.0 → 0.2.1

package/dist/hooks/hook-runner.js

@@ -1,30 +1,96 @@
+function e(o) {
+    return "function" != typeof WeakMap ? null : (e = function(e) {
+        return new WeakMap();
+    })(o);
+}
 "use strict";
-/**
- * hooks/hook-runner.ts
- * Backward-compatible re-export from hook-runner/ module
- * @deprecated Import from './hook-runner/index' directly
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+var o = exports, t = {
+    get HOOK_LIFECYCLE () {
+        return n.HOOK_LIFECYCLE;
+    },
+    get HookConfig () {
+        return u.HookConfig;
+    },
+    get HookContext () {
+        return u.HookContext;
+    },
+    get HookExecutionResult () {
+        return u.HookExecutionResult;
+    },
+    get HookLifecycle () {
+        return u.HookLifecycle;
+    },
+    get HookResult () {
+        return u.HookResult;
+    },
+    get LoadedHooksConfig () {
+        return u.LoadedHooksConfig;
+    },
+    get createHookConfig () {
+        return n.createHookConfig;
+    },
+    get default () {
+        return n.default;
+    },
+    get executeHookFunction () {
+        return c.executeHookFunction;
+    },
+    get executeSingleHookAsync () {
+        return c.executeSingleHookAsync;
+    },
+    get executeSingleHookSync () {
+        return c.executeSingleHookSync;
+    },
+    get getDefaultHooksPath () {
+        return i.getDefaultHooksPath;
+    },
+    get getHookLifecycle () {
+        return n.getHookLifecycle;
+    },
+    get getHooksForPhase () {
+        return n.getHooksForPhase;
+    },
+    get loadHookScript () {
+        return i.loadHookScript;
+    },
+    get loadHookScriptAsync () {
+        return i.loadHookScriptAsync;
+    },
+    get loadHooksConfig () {
+        return i.loadHooksConfig;
+    },
+    get runHook () {
+        return n.runHook;
+    },
+    get runHookChain () {
+        return n.runHookChain;
+    },
+    get runHookSync () {
+        return n.runHookSync;
+    },
+    get validateHookConfig () {
+        return n.validateHookConfig;
+    }
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeSingleHookSync = exports.executeSingleHookAsync = exports.executeHookFunction = exports.loadHookScriptAsync = exports.loadHookScript = exports.loadHooksConfig = exports.getDefaultHooksPath = exports.default = exports.HOOK_LIFECYCLE = exports.createHookConfig = exports.validateHookConfig = exports.getHooksForPhase = exports.getHookLifecycle = exports.runHookChain = exports.runHookSync = exports.runHook = void 0;
-var index_1 = require("./hook-runner/index");
-Object.defineProperty(exports, "runHook", { enumerable: true, get: function () { return index_1.runHook; } });
-Object.defineProperty(exports, "runHookSync", { enumerable: true, get: function () { return index_1.runHookSync; } });
-Object.defineProperty(exports, "runHookChain", { enumerable: true, get: function () { return index_1.runHookChain; } });
-Object.defineProperty(exports, "getHookLifecycle", { enumerable: true, get: function () { return index_1.getHookLifecycle; } });
-Object.defineProperty(exports, "getHooksForPhase", { enumerable: true, get: function () { return index_1.getHooksForPhase; } });
-Object.defineProperty(exports, "validateHookConfig", { enumerable: true, get: function () { return index_1.validateHookConfig; } });
-Object.defineProperty(exports, "createHookConfig", { enumerable: true, get: function () { return index_1.createHookConfig; } });
-Object.defineProperty(exports, "HOOK_LIFECYCLE", { enumerable: true, get: function () { return index_1.HOOK_LIFECYCLE; } });
-Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(index_1).default; } });
-var loader_1 = require("./hook-runner/loader");
-Object.defineProperty(exports, "getDefaultHooksPath", { enumerable: true, get: function () { return loader_1.getDefaultHooksPath; } });
-Object.defineProperty(exports, "loadHooksConfig", { enumerable: true, get: function () { return loader_1.loadHooksConfig; } });
-Object.defineProperty(exports, "loadHookScript", { enumerable: true, get: function () { return loader_1.loadHookScript; } });
-Object.defineProperty(exports, "loadHookScriptAsync", { enumerable: true, get: function () { return loader_1.loadHookScriptAsync; } });
-var executor_1 = require("./hook-runner/executor");
-Object.defineProperty(exports, "executeHookFunction", { enumerable: true, get: function () { return executor_1.executeHookFunction; } });
-Object.defineProperty(exports, "executeSingleHookAsync", { enumerable: true, get: function () { return executor_1.executeSingleHookAsync; } });
-Object.defineProperty(exports, "executeSingleHookSync", { enumerable: true, get: function () { return executor_1.executeSingleHookSync; } });
+for(var r in t)Object.defineProperty(o, r, {
+    enumerable: !0,
+    get: Object.getOwnPropertyDescriptor(t, r).get
+});
+let n = /*#__PURE__*/ function(o) {
+    var t, r, n;
+    if (o && o.__esModule) return o;
+    if (null === o || "object" != typeof o && "function" != typeof o) return {
+        default: o
+    };
+    if ((t = e(void 0)) && t.has(o)) return t.get(o);
+    for(var u in r = {
+        __proto__: null
+    }, n = Object.defineProperty && Object.getOwnPropertyDescriptor, o)if ("default" !== u && Object.prototype.hasOwnProperty.call(o, u)) {
+        var i = n ? Object.getOwnPropertyDescriptor(o, u) : null;
+        i && (i.get || i.set) ? Object.defineProperty(r, u, i) : r[u] = o[u];
+    }
+    return r.default = o, t && t.set(o, r), r;
+}(require("./hook-runner/index")), u = require("./hook-runner/types"), i = require("./hook-runner/loader"), c = require("./hook-runner/executor");

package/dist/hooks/phase-complete-detector.js

@@ -1,203 +1,137 @@
-"use strict";
-/**
- * hooks/phase-complete-detector.ts
- * Detect phase completion and update state
- */
-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;
+let e, t, r, o, s;
+function n(e) {
+    return "function" != typeof WeakMap ? null : (n = function(e) {
+        return new WeakMap();
+    })(e);
+}
+function a(e, t) {
+    var r, o, s;
+    if (!t && e && e.__esModule) return e;
+    if (null === e || "object" != typeof e && "function" != typeof e) return {
+        default: e
     };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateTaskJsonPhaseStatus = updateTaskJsonPhaseStatus;
-exports.detectPhaseCompletion = detectPhaseCompletion;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const config_1 = require("../lib/config");
-const state_1 = require("../lib/state");
-const archive_1 = require("../lib/archive");
-const phase_gate_validator_1 = require("./phase-gate-validator");
-const sync_task_to_openspec_1 = require("../spec/sync-task-to-openspec");
-/**
- * Update task JSON phase status with error handling
- */
-function updateTaskJsonPhaseStatus(taskPath, phaseName, status) {
-    if (!fs.existsSync(taskPath)) {
-        console.warn(`[PHASE-DETECTOR] Task file not found: ${taskPath}`);
-        return false;
-    }
-    try {
-        const content = fs.readFileSync(taskPath, 'utf8');
-        const taskJson = JSON.parse(content);
-        taskJson.status = status;
-        fs.writeFileSync(taskPath, JSON.stringify(taskJson, null, 2), 'utf8');
-        console.log(`[PHASE-DETECTOR] Updated task JSON: ${phaseName} phase -> ${status}`);
-        return true;
-    }
-    catch (e) {
-        console.error(`[PHASE-DETECTOR] Error updating task JSON: ${e.message}`);
-        return false;
-    }
+    if ((r = n(t)) && r.has(e)) return r.get(e);
+    for(var a in o = {
+        __proto__: null
+    }, s = Object.defineProperty && Object.getOwnPropertyDescriptor, e)if ("default" !== a && Object.prototype.hasOwnProperty.call(e, a)) {
+        var i = s ? Object.getOwnPropertyDescriptor(e, a) : null;
+        i && (i.get || i.set) ? Object.defineProperty(o, a, i) : o[a] = e[a];
+    }
+    return o.default = e, r && r.set(e, o), o;
 }
-/**
- * Log gate blocked warnings with type-safe access
- */
-function logGateBlockedWarnings(gateResult) {
-    if (!gateResult) {
-        return;
-    }
-    console.warn(`[PHASE-DETECTOR] Phase blocked: ${gateResult.reason}`);
-    const missingValidations = Array.isArray(gateResult.missingValidations)
-        ? gateResult.missingValidations
-        : [];
-    if (missingValidations.length > 0) {
-        console.warn(`[PHASE-DETECTOR] Missing: ${missingValidations.join(', ')}`);
+function i(e, t, r) {
+    if (!d.existsSync(e)) return console.warn(`[PHASE-DETECTOR] Task file not found: ${e}`), !1;
+    try {
+        let o = d.readFileSync(e, 'utf8'), s = JSON.parse(o);
+        return s.status = r, d.writeFileSync(e, JSON.stringify(s, null, 2), 'utf8'), console.log(`[PHASE-DETECTOR] Updated task JSON: ${t} phase -> ${r}`), !0;
+    } catch (e) {
+        return console.error(`[PHASE-DETECTOR] Error updating task JSON: ${e.message}`), !1;
     }
 }
-/**
- * Detect phase completion
- * @param options - Options
- * @returns Detection result
- */
-function detectPhaseCompletion(options) {
-    const { filePath, config, state } = options;
-    if (!filePath.includes('.harness/')) {
-        return { detected: false, reason: 'not-harness-file' };
-    }
-    const taskId = state.currentTask;
-    if (!taskId) {
-        return { detected: false, reason: 'no-current-task' };
-    }
-    const gateResult = (0, phase_gate_validator_1.assessTransitionGate)({ taskId, filePath, state, config });
-    if (gateResult.skipped) {
-        return { detected: false, reason: 'gate-skipped' };
-    }
-    if (!gateResult.allowed) {
-        // Update state with blocked gate info
-        (0, state_1.updateState)({
-            lastGateBlockedAt: new Date().toISOString(),
-            lastGateBlockedReason: gateResult.reason,
-            lastGateBlockedPhase: gateResult.phaseCompleted || null,
-            lastMissingValidations: gateResult.missingValidations || [],
-        }, config);
-        // Archive task state
-        (0, archive_1.archiveTaskState)({
-            cwd: config.projectRoot,
-            taskId,
-            eventType: 'gate_blocked',
-            status: state.status || 'running',
-            phase: state.currentPhase || undefined,
-            phaseCompleted: gateResult.phaseCompleted || state.phaseCompleted || undefined,
-            reviewConclusion: state.reviewConclusion || undefined,
-            reason: gateResult.reason,
-        });
-        // Sync to Spec
-        (0, sync_task_to_openspec_1.syncTaskToSpec)({ cwd: config.projectRoot, taskId });
-        return {
-            detected: true,
-            blocked: true,
-            gateResult,
-        };
-    }
-    // Phase transition allowed
-    const newPhase = gateResult.nextPhase;
-    const phaseCompleted = gateResult.phaseCompleted;
-    // Update state
-    (0, state_1.updateState)({
-        currentPhase: newPhase,
-        phaseCompleted,
-        reviewConclusion: gateResult.reviewConclusion || state.reviewConclusion || null,
+function l(e) {
+    let { filePath: t, config: r, state: o } = e;
+    if (!t.includes('.harness/')) return {
+        detected: !1,
+        reason: 'not-harness-file'
+    };
+    let s = o.currentTask;
+    if (!s) return {
+        detected: !1,
+        reason: 'no-current-task'
+    };
+    let n = (0, k.assessTransitionGate)({
+        taskId: s,
+        filePath: t,
+        state: o,
+        config: r
+    });
+    if (n.skipped) return {
+        detected: !1,
+        reason: 'gate-skipped'
+    };
+    if (!n.allowed) return (0, h.updateState)({
+        lastGateBlockedAt: new Date().toISOString(),
+        lastGateBlockedReason: n.reason,
+        lastGateBlockedPhase: n.phaseCompleted || null,
+        lastMissingValidations: n.missingValidations || []
+    }, r), (0, v.archiveTaskState)({
+        cwd: r.projectRoot,
+        taskId: s,
+        eventType: 'gate_blocked',
+        status: o.status || 'running',
+        phase: o.currentPhase || void 0,
+        phaseCompleted: n.phaseCompleted || o.phaseCompleted || void 0,
+        reviewConclusion: o.reviewConclusion || void 0,
+        reason: n.reason
+    }), (0, P.syncTaskToSpec)({
+        cwd: r.projectRoot,
+        taskId: s
+    }), {
+        detected: !0,
+        blocked: !0,
+        gateResult: n
+    };
+    let a = n.nextPhase, l = n.phaseCompleted;
+    (0, h.updateState)({
+        currentPhase: a,
+        phaseCompleted: l,
+        reviewConclusion: n.reviewConclusion || o.reviewConclusion || null,
         lastGateBlockedAt: null,
         lastGateBlockedReason: null,
         lastGateBlockedPhase: null,
-        lastMissingValidations: [],
-    }, config);
-    // Update task JSON phase statuses
-    const taskPath = path.resolve(config.tasksDirAbs, `${taskId}.json`);
-    if (phaseCompleted) {
-        updateTaskJsonPhaseStatus(taskPath, phaseCompleted, 'completed');
-    }
-    if (newPhase && newPhase !== 'merge') {
-        updateTaskJsonPhaseStatus(taskPath, newPhase, 'in_progress');
-    }
-    // Archive task state
-    (0, archive_1.archiveTaskState)({
-        cwd: config.projectRoot,
-        taskId,
+        lastMissingValidations: []
+    }, r);
+    let c = f.resolve(r.tasksDirAbs, `${s}.json`);
+    return l && i(c, l, 'completed'), a && 'merge' !== a && i(c, a, 'in_progress'), (0, v.archiveTaskState)({
+        cwd: r.projectRoot,
+        taskId: s,
         eventType: 'phase_transition',
-        status: state.status || 'running',
-        phase: newPhase || undefined,
-        phaseCompleted: phaseCompleted || undefined,
-        reviewConclusion: gateResult.reviewConclusion || undefined,
-    });
-    // Sync to Spec
-    (0, sync_task_to_openspec_1.syncTaskToSpec)({ cwd: config.projectRoot, taskId });
-    return {
-        detected: true,
-        blocked: false,
-        phaseCompleted,
-        newPhase,
-        gateResult,
+        status: o.status || 'running',
+        phase: a || void 0,
+        phaseCompleted: l || void 0,
+        reviewConclusion: n.reviewConclusion || void 0
+    }), (0, P.syncTaskToSpec)({
+        cwd: r.projectRoot,
+        taskId: s
+    }), {
+        detected: !0,
+        blocked: !1,
+        phaseCompleted: l,
+        newPhase: a,
+        gateResult: n
     };
 }
-/**
- * Main entry point for hook usage
- */
-function main() {
-    const input = JSON.parse(process.argv[2] || '{}');
-    const filePath = input.tool_input?.file_path || input.tool_input?.path || '';
-    const config = (0, config_1.loadConfig)();
-    const state = (0, state_1.loadState)(config);
-    if (!state?.currentTask) {
-        process.exit(0);
-    }
-    const result = detectPhaseCompletion({ filePath, config, state });
-    if (!result.detected || result.reason) {
-        process.exit(0);
-    }
-    if (result.blocked) {
-        logGateBlockedWarnings(result.gateResult);
-    }
-    else {
-        console.log(`[PHASE-DETECTOR] Phase transition: ${result.phaseCompleted} -> ${result.newPhase}`);
-        if (result.gateResult?.reviewConclusion) {
-            console.log(`[PHASE-DETECTOR] Review conclusion: ${result.gateResult.reviewConclusion}`);
-        }
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+var c = exports, u = {
+    get default () {
+        return T;
+    },
+    get detectPhaseCompletion () {
+        return l;
+    },
+    get updateTaskJsonPhaseStatus () {
+        return i;
     }
-    process.exit(0);
-}
-if (require.main === module) {
-    main();
-}
-exports.default = {
-    detectPhaseCompletion,
-    updateTaskJsonPhaseStatus,
+};
+for(var p in u)Object.defineProperty(c, p, {
+    enumerable: !0,
+    get: Object.getOwnPropertyDescriptor(u, p).get
+});
+let d = /*#__PURE__*/ a(require("fs")), f = /*#__PURE__*/ a(require("path")), g = require("../lib/config"), h = require("../lib/state"), v = require("../lib/archive"), k = require("./phase-gate-validator"), P = require("../spec/sync-task-to-openspec");
+require.main === module && (e = JSON.parse(process.argv[2] || '{}'), t = e.tool_input?.file_path || e.tool_input?.path || '', r = (0, g.loadConfig)(), o = (0, h.loadState)(r), o?.currentTask || process.exit(0), (!(s = l({
+    filePath: t,
+    config: r,
+    state: o
+})).detected || s.reason) && process.exit(0), s.blocked ? function(e) {
+    if (!e) return;
+    console.warn(`[PHASE-DETECTOR] Phase blocked: ${e.reason}`);
+    let t = Array.isArray(e.missingValidations) ? e.missingValidations : [];
+    t.length > 0 && console.warn(`[PHASE-DETECTOR] Missing: ${t.join(', ')}`);
+}(s.gateResult) : (console.log(`[PHASE-DETECTOR] Phase transition: ${s.phaseCompleted} -> ${s.newPhase}`), s.gateResult?.reviewConclusion && console.log(`[PHASE-DETECTOR] Review conclusion: ${s.gateResult.reviewConclusion}`)), process.exit(0));
+let T = {
+    detectPhaseCompletion: l,
+    updateTaskJsonPhaseStatus: i
 };