@renseiai/agentfactory 0.8.8 → 0.8.9

package/dist/src/workflow/concurrency-semaphore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concurrency-semaphore.d.ts","sourceRoot":"","sources":["../../../src/workflow/concurrency-semaphore.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,qBAAa,oBAAoB;IAInB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAH1C,OAAO,CAAC,OAAO,CAAI;IACnB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwB;gBAEnB,aAAa,EAAE,MAAM;IAMlD,qCAAqC;IACrC,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,qCAAqC;IACrC,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,yDAAyD;IACnD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAa9B,uDAAuD;IACvD,OAAO,IAAI,IAAI;CAOhB"}

package/dist/src/workflow/concurrency-semaphore.js

@@ -0,0 +1,46 @@
+/**
+ * Concurrency Semaphore
+ *
+ * Limits the number of concurrent operations. When the limit is reached,
+ * subsequent acquire() calls wait until a slot is released.
+ */
+export class ConcurrencySemaphore {
+    maxConcurrent;
+    current = 0;
+    waiters = [];
+    constructor(maxConcurrent) {
+        this.maxConcurrent = maxConcurrent;
+        if (maxConcurrent < 1) {
+            throw new Error('maxConcurrent must be at least 1');
+        }
+    }
+    /** Current number of active slots */
+    get activeCount() {
+        return this.current;
+    }
+    /** Number of waiters in the queue */
+    get waitingCount() {
+        return this.waiters.length;
+    }
+    /** Acquire a slot. Resolves when a slot is available. */
+    async acquire() {
+        if (this.current < this.maxConcurrent) {
+            this.current++;
+            return;
+        }
+        return new Promise((resolve) => {
+            this.waiters.push(() => {
+                this.current++;
+                resolve();
+            });
+        });
+    }
+    /** Release a slot. Wakes up the next waiter if any. */
+    release() {
+        this.current--;
+        if (this.waiters.length > 0) {
+            const next = this.waiters.shift();
+            next();
+        }
+    }
+}

package/dist/src/workflow/concurrency-semaphore.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=concurrency-semaphore.test.d.ts.map

package/dist/src/workflow/concurrency-semaphore.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concurrency-semaphore.test.d.ts","sourceRoot":"","sources":["../../../src/workflow/concurrency-semaphore.test.ts"],"names":[],"mappings":""}

package/dist/src/workflow/concurrency-semaphore.test.js

@@ -0,0 +1,183 @@
+import { describe, it, expect } from 'vitest';
+import { ConcurrencySemaphore } from './concurrency-semaphore.js';
+describe('ConcurrencySemaphore', () => {
+    describe('construction', () => {
+        it('creates with valid maxConcurrent', () => {
+            const sem = new ConcurrencySemaphore(3);
+            expect(sem.activeCount).toBe(0);
+            expect(sem.waitingCount).toBe(0);
+        });
+        it('creates with maxConcurrent = 1', () => {
+            const sem = new ConcurrencySemaphore(1);
+            expect(sem.activeCount).toBe(0);
+        });
+        it('throws when maxConcurrent is 0', () => {
+            expect(() => new ConcurrencySemaphore(0)).toThrow('maxConcurrent must be at least 1');
+        });
+        it('throws when maxConcurrent is negative', () => {
+            expect(() => new ConcurrencySemaphore(-1)).toThrow('maxConcurrent must be at least 1');
+        });
+    });
+    describe('acquire/release basic flow', () => {
+        it('acquires immediately when under capacity', async () => {
+            const sem = new ConcurrencySemaphore(2);
+            await sem.acquire();
+            expect(sem.activeCount).toBe(1);
+            await sem.acquire();
+            expect(sem.activeCount).toBe(2);
+        });
+        it('releases correctly and decrements activeCount', async () => {
+            const sem = new ConcurrencySemaphore(2);
+            await sem.acquire();
+            await sem.acquire();
+            expect(sem.activeCount).toBe(2);
+            sem.release();
+            expect(sem.activeCount).toBe(1);
+            sem.release();
+            expect(sem.activeCount).toBe(0);
+        });
+    });
+    describe('blocking behavior', () => {
+        it('blocks acquire when at capacity', async () => {
+            const sem = new ConcurrencySemaphore(1);
+            await sem.acquire();
+            expect(sem.activeCount).toBe(1);
+            let acquired = false;
+            const pending = sem.acquire().then(() => {
+                acquired = true;
+            });
+            // The waiter should be queued but not yet resolved
+            await Promise.resolve(); // flush microtasks
+            expect(acquired).toBe(false);
+            expect(sem.waitingCount).toBe(1);
+            // Release to unblock
+            sem.release();
+            await pending;
+            expect(acquired).toBe(true);
+            expect(sem.activeCount).toBe(1);
+            expect(sem.waitingCount).toBe(0);
+        });
+    });
+    describe('FIFO waiter ordering', () => {
+        it('releases waiters in FIFO order', async () => {
+            const sem = new ConcurrencySemaphore(1);
+            await sem.acquire();
+            const order = [];
+            const p1 = sem.acquire().then(() => {
+                order.push(1);
+            });
+            const p2 = sem.acquire().then(() => {
+                order.push(2);
+            });
+            const p3 = sem.acquire().then(() => {
+                order.push(3);
+            });
+            expect(sem.waitingCount).toBe(3);
+            // Release one at a time and let the microtask queue flush
+            sem.release();
+            await p1;
+            sem.release();
+            await p2;
+            sem.release();
+            await p3;
+            expect(order).toEqual([1, 2, 3]);
+        });
+    });
+    describe('activeCount and waitingCount tracking', () => {
+        it('tracks counts accurately through lifecycle', async () => {
+            const sem = new ConcurrencySemaphore(2);
+            expect(sem.activeCount).toBe(0);
+            expect(sem.waitingCount).toBe(0);
+            await sem.acquire();
+            expect(sem.activeCount).toBe(1);
+            expect(sem.waitingCount).toBe(0);
+            await sem.acquire();
+            expect(sem.activeCount).toBe(2);
+            expect(sem.waitingCount).toBe(0);
+            // Third acquire should wait
+            const pending = sem.acquire();
+            // Flush microtasks to make sure the promise callback has run
+            await Promise.resolve();
+            expect(sem.activeCount).toBe(2);
+            expect(sem.waitingCount).toBe(1);
+            sem.release();
+            await pending;
+            expect(sem.activeCount).toBe(2);
+            expect(sem.waitingCount).toBe(0);
+            sem.release();
+            expect(sem.activeCount).toBe(1);
+            sem.release();
+            expect(sem.activeCount).toBe(0);
+        });
+    });
+    describe('maxConcurrent=1 enforces serial execution', () => {
+        it('only one task runs at a time', async () => {
+            const sem = new ConcurrencySemaphore(1);
+            const log = [];
+            const runTask = async (name) => {
+                await sem.acquire();
+                log.push(`${name}:start`);
+                // Simulate async work
+                await new Promise((resolve) => setTimeout(resolve, 10));
+                log.push(`${name}:end`);
+                sem.release();
+            };
+            await Promise.all([runTask('a'), runTask('b'), runTask('c')]);
+            // Each task must start after the previous one ends
+            // The pattern should be: start, end, start, end, start, end
+            for (let i = 0; i < log.length - 1; i += 2) {
+                expect(log[i]).toMatch(/:start$/);
+                expect(log[i + 1]).toMatch(/:end$/);
+            }
+            // Verify no two starts happen before an end
+            let active = 0;
+            for (const entry of log) {
+                if (entry.endsWith(':start'))
+                    active++;
+                if (entry.endsWith(':end'))
+                    active--;
+                expect(active).toBeLessThanOrEqual(1);
+            }
+        });
+    });
+    describe('maxConcurrent=2 with 5 tasks verifies queuing behavior', () => {
+        it('runs at most 2 tasks concurrently', async () => {
+            const sem = new ConcurrencySemaphore(2);
+            let peakConcurrent = 0;
+            let currentConcurrent = 0;
+            const taskOrder = [];
+            const runTask = async (id) => {
+                await sem.acquire();
+                currentConcurrent++;
+                peakConcurrent = Math.max(peakConcurrent, currentConcurrent);
+                taskOrder.push(`start:${id}`);
+                // Simulate varying amounts of work
+                await new Promise((resolve) => setTimeout(resolve, 5 + id * 2));
+                taskOrder.push(`end:${id}`);
+                currentConcurrent--;
+                sem.release();
+            };
+            await Promise.all([
+                runTask(1),
+                runTask(2),
+                runTask(3),
+                runTask(4),
+                runTask(5),
+            ]);
+            // Peak concurrency should never exceed 2
+            expect(peakConcurrent).toBe(2);
+            // All 5 tasks should have started and ended
+            expect(taskOrder.filter((e) => e.startsWith('start:'))).toHaveLength(5);
+            expect(taskOrder.filter((e) => e.startsWith('end:'))).toHaveLength(5);
+            // Verify at no point more than 2 tasks are active
+            let active = 0;
+            for (const entry of taskOrder) {
+                if (entry.startsWith('start:'))
+                    active++;
+                if (entry.startsWith('end:'))
+                    active--;
+                expect(active).toBeLessThanOrEqual(2);
+            }
+        });
+    });
+});

package/dist/src/workflow/gate-state.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Gate State Persistence Layer
+ *
+ * Manages gate lifecycle state for workflow execution gates (signal, timer, webhook).
+ * Uses a storage adapter pattern so that packages/core does not depend on
+ * packages/server (Redis) directly.
+ *
+ * Gates are external conditions that can pause workflow phase transitions until
+ * a condition is met (e.g., human approval signal, timer expiration, webhook callback).
+ */
+import type { GateDefinition } from './workflow-types.js';
+/**
+ * Persisted state for a single gate instance tied to an issue
+ */
+export interface GateState {
+    /** The issue this gate is associated with */
+    issueId: string;
+    /** Unique gate name (from GateDefinition) */
+    gateName: string;
+    /** Gate type: signal (external event), timer (time-based), webhook (HTTP callback) */
+    gateType: 'signal' | 'timer' | 'webhook';
+    /** Current gate status */
+    status: 'pending' | 'active' | 'satisfied' | 'timed-out';
+    /** When the gate was triggered (phase entered), epoch ms */
+    activatedAt: number;
+    /** When the gate condition was met, epoch ms */
+    satisfiedAt?: number;
+    /** When the timeout fired, epoch ms */
+    timedOutAt?: number;
+    /** Action to take when gate times out */
+    timeoutAction?: 'escalate' | 'skip' | 'fail';
+    /** What satisfied the gate (comment ID, webhook payload hash, timer ID) */
+    signalSource?: string;
+    /** Authentication token for webhook gates (used to validate incoming callbacks) */
+    webhookToken?: string;
+    /** Duration string from gate definition (e.g., "4h") */
+    timeoutDuration?: string;
+    /** Computed absolute timestamp for timeout deadline, epoch ms */
+    timeoutDeadline?: number;
+}
+/**
+ * Storage adapter for gate state persistence.
+ * Implementations can back this with Redis, in-memory maps, etc.
+ */
+export interface GateStorage {
+    /** Get the state of a specific gate for an issue */
+    getGateState(issueId: string, gateName: string): Promise<GateState | null>;
+    /** Set the state of a specific gate for an issue */
+    setGateState(issueId: string, gateName: string, state: GateState): Promise<void>;
+    /** Get all active (status === 'active') gates for an issue */
+    getActiveGates(issueId: string): Promise<GateState[]>;
+    /** Clear all gate states for an issue */
+    clearGateStates(issueId: string): Promise<void>;
+}
+/**
+ * In-memory gate storage for testing and local development
+ */
+export declare class InMemoryGateStorage implements GateStorage {
+    private store;
+    /** Build a composite key from issueId and gateName */
+    private key;
+    getGateState(issueId: string, gateName: string): Promise<GateState | null>;
+    setGateState(issueId: string, gateName: string, state: GateState): Promise<void>;
+    getActiveGates(issueId: string): Promise<GateState[]>;
+    clearGateStates(issueId: string): Promise<void>;
+}
+/**
+ * Initialize the gate state manager with a storage adapter.
+ * Must be called before using gate state management functions.
+ */
+export declare function initGateStorage(storage: GateStorage): void;
+/**
+ * Parse a duration string into milliseconds.
+ *
+ * Supported formats:
+ * - "15s" - seconds
+ * - "30m" - minutes
+ * - "4h"  - hours
+ * - "2d"  - days
+ *
+ * @param duration - Duration string (e.g., "4h", "30m", "2d", "15s")
+ * @returns Duration in milliseconds
+ * @throws Error if the duration format is invalid
+ */
+export declare function parseDuration(duration: string): number;
+/**
+ * Activate a gate for an issue, creating an active gate state with a computed
+ * timeout deadline (if the gate definition includes a timeout).
+ *
+ * @param issueId - The issue identifier
+ * @param gateDef - The gate definition from the workflow
+ * @param storage - The gate storage adapter to use
+ * @returns The created GateState
+ */
+export declare function activateGate(issueId: string, gateDef: GateDefinition, storage: GateStorage): Promise<GateState>;
+/**
+ * Mark a gate as satisfied, recording what source satisfied it.
+ *
+ * @param issueId - The issue identifier
+ * @param gateName - The gate name to satisfy
+ * @param source - What satisfied the gate (e.g., comment ID, webhook payload hash, timer ID)
+ * @param storage - The gate storage adapter to use
+ * @returns The updated GateState, or null if the gate was not found
+ */
+export declare function satisfyGate(issueId: string, gateName: string, source: string, storage: GateStorage): Promise<GateState | null>;
+/**
+ * Mark a gate as timed-out.
+ *
+ * @param issueId - The issue identifier
+ * @param gateName - The gate name to time out
+ * @param storage - The gate storage adapter to use
+ * @returns The updated GateState, or null if the gate was not found
+ */
+export declare function timeoutGate(issueId: string, gateName: string, storage: GateStorage): Promise<GateState | null>;
+//# sourceMappingURL=gate-state.d.ts.map

package/dist/src/workflow/gate-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate-state.d.ts","sourceRoot":"","sources":["../../../src/workflow/gate-state.ts"],"names":[],"mappings":"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"}

package/dist/src/workflow/gate-state.js

@@ -0,0 +1,185 @@
+/**
+ * Gate State Persistence Layer
+ *
+ * Manages gate lifecycle state for workflow execution gates (signal, timer, webhook).
+ * Uses a storage adapter pattern so that packages/core does not depend on
+ * packages/server (Redis) directly.
+ *
+ * Gates are external conditions that can pause workflow phase transitions until
+ * a condition is met (e.g., human approval signal, timer expiration, webhook callback).
+ */
+const log = {
+    info: (msg, data) => console.log(`[gate-state] ${msg}`, data ? JSON.stringify(data) : ''),
+    warn: (msg, data) => console.warn(`[gate-state] ${msg}`, data ? JSON.stringify(data) : ''),
+    error: (msg, data) => console.error(`[gate-state] ${msg}`, data ? JSON.stringify(data) : ''),
+    debug: (_msg, _data) => { },
+};
+/**
+ * In-memory gate storage for testing and local development
+ */
+export class InMemoryGateStorage {
+    store = new Map();
+    /** Build a composite key from issueId and gateName */
+    key(issueId, gateName) {
+        return `${issueId}:${gateName}`;
+    }
+    async getGateState(issueId, gateName) {
+        return this.store.get(this.key(issueId, gateName)) ?? null;
+    }
+    async setGateState(issueId, gateName, state) {
+        this.store.set(this.key(issueId, gateName), state);
+    }
+    async getActiveGates(issueId) {
+        const results = [];
+        for (const [key, state] of this.store) {
+            if (key.startsWith(`${issueId}:`) && state.status === 'active') {
+                results.push(state);
+            }
+        }
+        return results;
+    }
+    async clearGateStates(issueId) {
+        const keysToDelete = [];
+        for (const key of this.store.keys()) {
+            if (key.startsWith(`${issueId}:`)) {
+                keysToDelete.push(key);
+            }
+        }
+        for (const key of keysToDelete) {
+            this.store.delete(key);
+        }
+    }
+}
+// ============================================
+// Module-level storage reference
+// ============================================
+let _storage = null;
+/**
+ * Initialize the gate state manager with a storage adapter.
+ * Must be called before using gate state management functions.
+ */
+export function initGateStorage(storage) {
+    _storage = storage;
+    log.info('Gate storage initialized');
+}
+/**
+ * Get the current storage adapter, throwing if not initialized
+ */
+function getStorage() {
+    if (!_storage) {
+        throw new Error('Gate storage not initialized. Call initGateStorage() first.');
+    }
+    return _storage;
+}
+// ============================================
+// Duration Parsing
+// ============================================
+/**
+ * Parse a duration string into milliseconds.
+ *
+ * Supported formats:
+ * - "15s" - seconds
+ * - "30m" - minutes
+ * - "4h"  - hours
+ * - "2d"  - days
+ *
+ * @param duration - Duration string (e.g., "4h", "30m", "2d", "15s")
+ * @returns Duration in milliseconds
+ * @throws Error if the duration format is invalid
+ */
+export function parseDuration(duration) {
+    const match = duration.match(/^(\d+)(s|m|h|d)$/);
+    if (!match) {
+        throw new Error(`Invalid duration format: "${duration}". Expected format like "4h", "30m", "2d", "15s".`);
+    }
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    switch (unit) {
+        case 's': return value * 1000;
+        case 'm': return value * 60 * 1000;
+        case 'h': return value * 60 * 60 * 1000;
+        case 'd': return value * 24 * 60 * 60 * 1000;
+        default: throw new Error(`Unknown duration unit: "${unit}"`);
+    }
+}
+// ============================================
+// Gate Lifecycle Helpers
+// ============================================
+/**
+ * Activate a gate for an issue, creating an active gate state with a computed
+ * timeout deadline (if the gate definition includes a timeout).
+ *
+ * @param issueId - The issue identifier
+ * @param gateDef - The gate definition from the workflow
+ * @param storage - The gate storage adapter to use
+ * @returns The created GateState
+ */
+export async function activateGate(issueId, gateDef, storage) {
+    const now = Date.now();
+    const state = {
+        issueId,
+        gateName: gateDef.name,
+        gateType: gateDef.type,
+        status: 'active',
+        activatedAt: now,
+    };
+    // Compute timeout deadline if gate has a timeout configuration
+    if (gateDef.timeout) {
+        state.timeoutAction = gateDef.timeout.action;
+        state.timeoutDuration = gateDef.timeout.duration;
+        state.timeoutDeadline = now + parseDuration(gateDef.timeout.duration);
+    }
+    await storage.setGateState(issueId, gateDef.name, state);
+    log.info('Gate activated', { issueId, gateName: gateDef.name, gateType: gateDef.type });
+    return state;
+}
+/**
+ * Mark a gate as satisfied, recording what source satisfied it.
+ *
+ * @param issueId - The issue identifier
+ * @param gateName - The gate name to satisfy
+ * @param source - What satisfied the gate (e.g., comment ID, webhook payload hash, timer ID)
+ * @param storage - The gate storage adapter to use
+ * @returns The updated GateState, or null if the gate was not found
+ */
+export async function satisfyGate(issueId, gateName, source, storage) {
+    const state = await storage.getGateState(issueId, gateName);
+    if (!state) {
+        log.warn('Cannot satisfy gate: not found', { issueId, gateName });
+        return null;
+    }
+    if (state.status !== 'active') {
+        log.warn('Cannot satisfy gate: not in active status', { issueId, gateName, status: state.status });
+        return null;
+    }
+    state.status = 'satisfied';
+    state.satisfiedAt = Date.now();
+    state.signalSource = source;
+    await storage.setGateState(issueId, gateName, state);
+    log.info('Gate satisfied', { issueId, gateName, source });
+    return state;
+}
+/**
+ * Mark a gate as timed-out.
+ *
+ * @param issueId - The issue identifier
+ * @param gateName - The gate name to time out
+ * @param storage - The gate storage adapter to use
+ * @returns The updated GateState, or null if the gate was not found
+ */
+export async function timeoutGate(issueId, gateName, storage) {
+    const state = await storage.getGateState(issueId, gateName);
+    if (!state) {
+        log.warn('Cannot timeout gate: not found', { issueId, gateName });
+        return null;
+    }
+    if (state.status !== 'active') {
+        log.warn('Cannot timeout gate: not in active status', { issueId, gateName, status: state.status });
+        return null;
+    }
+    state.status = 'timed-out';
+    state.timedOutAt = Date.now();
+    await storage.setGateState(issueId, gateName, state);
+    log.info('Gate timed out', { issueId, gateName, timeoutAction: state.timeoutAction });
+    return state;
+}

package/dist/src/workflow/gate-state.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gate-state.test.d.ts.map

package/dist/src/workflow/gate-state.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate-state.test.d.ts","sourceRoot":"","sources":["../../../src/workflow/gate-state.test.ts"],"names":[],"mappings":""}