@bicorne/task-flow 0.2.0 → 0.2.1

package/dist/lib/state.js

@@ -1,61 +1,25 @@
-"use strict";
-/**
- * state.ts
- * State management for task-flow
- */
-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;
+function e(t) {
+    return "function" != typeof WeakMap ? null : (e = function(e) {
+        return new WeakMap();
+    })(t);
+}
+function t(t, r) {
+    var n, a, o;
+    if (!r && t && t.__esModule) return t;
+    if (null === t || "object" != typeof t && "function" != typeof t) return {
+        default: t
     };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createInitialState = createInitialState;
-exports.loadState = loadState;
-exports.saveState = saveState;
-exports.updateState = updateState;
-exports.upsertWorktree = upsertWorktree;
-exports.removeWorktree = removeWorktree;
-exports.addTaskToHistory = addTaskToHistory;
-exports.getActiveWorktrees = getActiveWorktrees;
-exports.getWorktreeByTask = getWorktreeByTask;
-exports.clearCurrentTask = clearCurrentTask;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const config_1 = require("./config");
-/**
- * Create initial state object
- * @returns Initial state
- */
-function createInitialState() {
-    const now = new Date().toISOString();
+    if ((n = e(r)) && n.has(t)) return n.get(t);
+    for(var s in a = {
+        __proto__: null
+    }, o = Object.defineProperty && Object.getOwnPropertyDescriptor, t)if ("default" !== s && Object.prototype.hasOwnProperty.call(t, s)) {
+        var l = o ? Object.getOwnPropertyDescriptor(t, s) : null;
+        l && (l.get || l.set) ? Object.defineProperty(a, s, l) : a[s] = t[s];
+    }
+    return a.default = t, n && n.set(t, a), a;
+}
+function r() {
+    let e = new Date().toISOString();
     return {
         version: '1.0',
         status: 'initialized',
@@ -70,224 +34,149 @@ function createInitialState() {
         lastGateBlockedReason: null,
         lastGateBlockedPhase: null,
         lastMissingValidations: [],
-        startedAt: now,
-        updatedAt: now,
+        startedAt: e,
+        updatedAt: e
     };
 }
-/**
- * Load state from file
- * @param config - Config object
- * @returns State object
- */
-function loadState(config) {
-    const cfg = config || (0, config_1.loadConfig)();
-    const statePath = path.resolve(cfg.harnessRootAbs || '.harness', 'state.json');
-    if (!fs.existsSync(statePath)) {
-        return createInitialState();
-    }
+function n(e) {
+    let t = e || (0, S.loadConfig)(), n = h.resolve(t.harnessRootAbs || '.harness', 'state.json');
+    if (!k.existsSync(n)) return r();
     try {
-        return JSON.parse(fs.readFileSync(statePath, 'utf8'));
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        console.warn('[STATE] Failed to load state file, attempting to restore from backup:', errorMessage);
-        // Try to restore from latest backup
+        return JSON.parse(k.readFileSync(n, 'utf8'));
+    } catch (e) {
+        console.warn('[STATE] Failed to load state file, attempting to restore from backup:', e instanceof Error ? e.message : 'Unknown error');
         try {
-            const harnessDir = cfg.harnessRootAbs;
-            if (!harnessDir) {
-                throw new Error('harnessRootAbs is undefined');
-            }
-            const backupPattern = /state\.json\.bak\.(\d+)$/;
-            const files = fs.readdirSync(harnessDir);
-            const backups = files
-                .filter(f => backupPattern.test(f))
-                .sort((a, b) => {
-                const matchA = a.match(backupPattern);
-                const matchB = b.match(backupPattern);
-                return (matchB?.[1] || '0').localeCompare(matchA?.[1] || '0');
+            let e = t.harnessRootAbs;
+            if (!e) throw Error('harnessRootAbs is undefined');
+            let r = /state\.json\.bak\.(\d+)$/, n = k.readdirSync(e).filter((e)=>r.test(e)).sort((e, t)=>{
+                let n = e.match(r), a = t.match(r);
+                return (a?.[1] || '0').localeCompare(n?.[1] || '0');
             });
-            if (backups.length > 0) {
-                const latestBackupName = backups[0];
-                if (!latestBackupName) {
-                    throw new Error('No backup file found');
-                }
-                const latestBackup = path.resolve(harnessDir, latestBackupName);
-                console.log(`[STATE] Restoring from backup: ${latestBackup}`);
-                return JSON.parse(fs.readFileSync(latestBackup, 'utf8'));
+            if (n.length > 0) {
+                let t = n[0];
+                if (!t) throw Error('No backup file found');
+                let r = h.resolve(e, t);
+                return console.log(`[STATE] Restoring from backup: ${r}`), JSON.parse(k.readFileSync(r, 'utf8'));
             }
+        } catch (e) {
+            console.warn('[STATE] Failed to restore from backup:', e instanceof Error ? e.message : 'Unknown error');
         }
-        catch (restoreError) {
-            console.warn('[STATE] Failed to restore from backup:', restoreError instanceof Error ? restoreError.message : 'Unknown error');
-        }
-        console.warn('[STATE] Creating new state');
-        return createInitialState();
+        return console.warn('[STATE] Creating new state'), r();
     }
 }
-/**
- * Save state to file
- * @param state - State object
- * @param config - Config object
- * @returns Success
- */
-function saveState(state, config) {
-    const cfg = config || (0, config_1.loadConfig)();
-    const harnessRoot = cfg.harnessRootAbs;
-    if (!harnessRoot) {
-        console.error('[STATE] harnessRootAbs is undefined, cannot save state');
-        return false;
-    }
-    const statePath = path.resolve(harnessRoot, 'state.json');
+function a(e, t) {
+    let r = (t || (0, S.loadConfig)()).harnessRootAbs;
+    if (!r) return console.error('[STATE] harnessRootAbs is undefined, cannot save state'), !1;
+    let n = h.resolve(r, 'state.json');
     try {
-        state.updatedAt = new Date().toISOString();
-        fs.mkdirSync(harnessRoot, { recursive: true });
-        // Backup existing state file before overwriting (prevent data corruption)
-        if (fs.existsSync(statePath)) {
-            const backupPath = `${statePath}.bak.${Date.now()}`;
+        if (e.updatedAt = new Date().toISOString(), k.mkdirSync(r, {
+            recursive: !0
+        }), k.existsSync(n)) {
+            let e = `${n}.bak.${Date.now()}`;
             try {
-                fs.copyFileSync(statePath, backupPath);
-                console.log(`[STATE] Created backup: ${backupPath}`);
-            }
-            catch (backupError) {
-                console.warn('[STATE] Failed to create backup:', backupError instanceof Error ? backupError.message : 'Unknown error');
+                k.copyFileSync(n, e), console.log(`[STATE] Created backup: ${e}`);
+            } catch (e) {
+                console.warn('[STATE] Failed to create backup:', e instanceof Error ? e.message : 'Unknown error');
             }
         }
-        fs.writeFileSync(statePath, JSON.stringify(state, null, 2), 'utf8');
-        return true;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        console.error('[STATE] Failed to save state:', errorMessage);
-        return false;
+        return k.writeFileSync(n, JSON.stringify(e, null, 2), 'utf8'), !0;
+    } catch (e) {
+        return console.error('[STATE] Failed to save state:', e instanceof Error ? e.message : 'Unknown error'), !1;
     }
 }
-/**
- * Update state with partial changes
- * @param updates - Updates to apply
- * @param config - Config object
- * @returns Updated state
- */
-function updateState(updates, config) {
-    const state = loadState(config);
-    const updated = {
-        ...state,
-        ...updates,
-        updatedAt: new Date().toISOString(),
+function o(e, t) {
+    let r = {
+        ...n(t),
+        ...e,
+        updatedAt: new Date().toISOString()
     };
-    saveState(updated, config);
-    return updated;
+    return a(r, t), r;
 }
-/**
- * Add or update worktree in state
- * @param worktree - Worktree info
- * @param config - Config object
- * @returns Updated state
- */
-function upsertWorktree(worktree, config) {
-    const state = loadState(config);
-    const worktrees = Array.isArray(state.worktrees) ? [...state.worktrees] : [];
-    const existingIndex = worktrees.findIndex((wt) => wt?.name === worktree.name);
-    const now = new Date().toISOString();
-    const nextWorktree = {
-        name: worktree.name || '',
-        path: worktree.path,
-        branch: worktree.branch,
-        status: worktree.status || 'active',
-        agent: worktree.agent || 'implementer',
-        task: worktree.task,
-        startedAt: (existingIndex >= 0 && worktrees[existingIndex]?.startedAt) ? worktrees[existingIndex].startedAt : now,
-        lastActivity: now,
-        pendingChanges: worktree.pendingChanges || [],
+function s(e, t) {
+    let r = n(t), o = Array.isArray(r.worktrees) ? [
+        ...r.worktrees
+    ] : [], s = o.findIndex((t)=>t?.name === e.name), l = new Date().toISOString(), u = {
+        name: e.name || '',
+        path: e.path,
+        branch: e.branch,
+        status: e.status || 'active',
+        agent: e.agent || 'implementer',
+        task: e.task,
+        startedAt: s >= 0 && o[s]?.startedAt ? o[s].startedAt : l,
+        lastActivity: l,
+        pendingChanges: e.pendingChanges || []
     };
-    if (existingIndex >= 0) {
-        worktrees[existingIndex] = nextWorktree;
-    }
-    else {
-        worktrees.push(nextWorktree);
-    }
-    state.worktrees = worktrees;
-    saveState(state, config);
-    return state;
+    return s >= 0 ? o[s] = u : o.push(u), r.worktrees = o, a(r, t), r;
 }
-/**
- * Remove worktree from state
- * @param worktreeName - Worktree name
- * @param config - Config object
- * @returns Updated state
- */
-function removeWorktree(worktreeName, config) {
-    const state = loadState(config);
-    state.worktrees = (state.worktrees || []).filter((wt) => wt?.name !== worktreeName);
-    saveState(state, config);
-    return state;
+function l(e, t) {
+    let r = n(t);
+    return r.worktrees = (r.worktrees || []).filter((t)=>t?.name !== e), a(r, t), r;
 }
-/**
- * Add task to history
- * @param taskInfo - Task info
- * @param config - Config object
- * @returns Updated state
- */
-function addTaskToHistory(taskInfo, config) {
-    const state = loadState(config);
-    const history = Array.isArray(state.taskHistory) ? [...state.taskHistory] : [];
-    const existingIndex = history.findIndex((item) => item?.taskId === taskInfo.taskId);
-    const now = new Date().toISOString();
-    const summary = {
-        taskId: taskInfo.taskId || '',
-        title: taskInfo.title,
-        status: taskInfo.status || 'running',
-        currentPhase: taskInfo.currentPhase ?? null,
-        phaseCompleted: taskInfo.phaseCompleted ?? null,
-        reviewConclusion: taskInfo.reviewConclusion ?? null,
-        startedAt: taskInfo.startedAt || now,
-        completedAt: taskInfo.completedAt ?? null,
-        lastUpdatedAt: now,
-        archivePath: taskInfo.archivePath,
+function u(e, t) {
+    let r = n(t), o = Array.isArray(r.taskHistory) ? [
+        ...r.taskHistory
+    ] : [], s = o.findIndex((t)=>t?.taskId === e.taskId), l = new Date().toISOString(), u = {
+        taskId: e.taskId || '',
+        title: e.title,
+        status: e.status || 'running',
+        currentPhase: e.currentPhase ?? null,
+        phaseCompleted: e.phaseCompleted ?? null,
+        reviewConclusion: e.reviewConclusion ?? null,
+        startedAt: e.startedAt || l,
+        completedAt: e.completedAt ?? null,
+        lastUpdatedAt: l,
+        archivePath: e.archivePath
     };
-    if (existingIndex >= 0) {
-        history[existingIndex] = summary;
-    }
-    else {
-        history.push(summary);
-    }
-    state.taskHistory = history.sort((a, b) => String(b.lastUpdatedAt || '').localeCompare(String(a.lastUpdatedAt || '')));
-    saveState(state, config);
-    return state;
+    return s >= 0 ? o[s] = u : o.push(u), r.taskHistory = o.sort((e, t)=>String(t.lastUpdatedAt || '').localeCompare(String(e.lastUpdatedAt || ''))), a(r, t), r;
 }
-/**
- * Get active worktrees
- * @param config - Config object
- * @returns Active worktrees
- */
-function getActiveWorktrees(config) {
-    const state = loadState(config);
-    return (state.worktrees || []).filter((wt) => wt?.status === 'active');
+function i(e) {
+    return (n(e).worktrees || []).filter((e)=>e?.status === 'active');
 }
-/**
- * Get worktree by task ID
- * @param taskId - Task ID
- * @param config - Config object
- * @returns Worktree or null
- */
-function getWorktreeByTask(taskId, config) {
-    const state = loadState(config);
-    return (state.worktrees || []).find((wt) => wt?.task === taskId) || null;
+function c(e, t) {
+    return (n(t).worktrees || []).find((t)=>t?.task === e) || null;
 }
-/**
- * Clear current task state (after merge)
- * @param config - Config object
- * @returns Updated state
- */
-function clearCurrentTask(config) {
-    const state = loadState(config);
-    const now = new Date().toISOString();
-    state.status = 'completed';
-    state.currentPhase = null;
-    state.currentTask = null;
-    state.currentSnapshot = null;
-    state.reviewConclusion = null;
-    state.phaseCompleted = null;
-    state.worktrees = [];
-    state.updatedAt = now;
-    saveState(state, config);
-    return state;
+function d(e) {
+    let t = n(e), r = new Date().toISOString();
+    return t.status = 'completed', t.currentPhase = null, t.currentTask = null, t.currentSnapshot = null, t.reviewConclusion = null, t.phaseCompleted = null, t.worktrees = [], t.updatedAt = r, a(t, e), t;
 }
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+var p = exports, f = {
+    get addTaskToHistory () {
+        return u;
+    },
+    get clearCurrentTask () {
+        return d;
+    },
+    get createInitialState () {
+        return r;
+    },
+    get getActiveWorktrees () {
+        return i;
+    },
+    get getWorktreeByTask () {
+        return c;
+    },
+    get loadState () {
+        return n;
+    },
+    get removeWorktree () {
+        return l;
+    },
+    get saveState () {
+        return a;
+    },
+    get updateState () {
+        return o;
+    },
+    get upsertWorktree () {
+        return s;
+    }
+};
+for(var g in f)Object.defineProperty(p, g, {
+    enumerable: !0,
+    get: Object.getOwnPropertyDescriptor(f, g).get
+});
+let k = /*#__PURE__*/ t(require("fs")), h = /*#__PURE__*/ t(require("path")), S = require("./config");