@pellux/goodvibes-sdk 0.18.3 → 0.18.11

package/dist/platform/tools/workflow/index.d.ts

@@ -0,0 +1,106 @@
+import type { Tool } from '../../types/tools.js';
+interface WorkflowDefinition {
+    name: string;
+    states: string[];
+    transitions: Record<string, string[]>;
+    description: string;
+}
+export declare const WORKFLOW_DEFINITIONS: Readonly<Record<string, WorkflowDefinition>>;
+export interface WorkflowInstance {
+    id: string;
+    definition: string;
+    currentState: string;
+    task: string;
+    startedAt: number;
+    completedAt?: number;
+    transitions: number;
+    context: Record<string, unknown>;
+    cancelled?: boolean;
+}
+export declare class WorkflowManager {
+    private workflows;
+    start(definition: string, task: string): WorkflowInstance;
+    getStatus(id: string): WorkflowInstance | null;
+    transition(id: string, targetState: string): {
+        success: boolean;
+        error?: string;
+    };
+    cancel(id: string): boolean;
+    list(): WorkflowInstance[];
+}
+export interface TriggerDefinition {
+    id: string;
+    event: string;
+    condition?: string;
+    action: string;
+    enabled: boolean;
+}
+export declare class TriggerManager {
+    private triggers;
+    add(def: {
+        event: string;
+        condition?: string;
+        action: string;
+    }): TriggerDefinition;
+    remove(id: string): boolean;
+    enable(id: string): boolean;
+    disable(id: string): boolean;
+    list(): TriggerDefinition[];
+}
+export interface ScheduleEntry {
+    name: string;
+    interval: string;
+    command: string;
+    lastRun?: number;
+    nextRun?: number;
+    enabled: boolean;
+}
+/**
+ * Parse an interval string like '30s', '5m', '1h' to milliseconds.
+ * Returns null if the format is unrecognised.
+ */
+export declare function parseInterval(interval: string): number | null;
+export declare class ScheduleManager {
+    private schedules;
+    /** Timer IDs keyed by schedule name */
+    private timers;
+    /** Spawned process handles tracked for cleanup in destroy() */
+    private spawnedProcs;
+    add(name: string, interval: string, command: string): ScheduleEntry;
+    remove(name: string): boolean;
+    enable(name: string): boolean;
+    disable(name: string): boolean;
+    list(): ScheduleEntry[];
+    /** Stop all timers and clear state when the manager is disposed. */
+    destroy(): void;
+    /** Execute a schedule tick: run the command and update lastRun/nextRun. */
+    private _tick;
+    private _clearTimer;
+}
+export interface WorkflowInput {
+    mode: 'start' | 'status' | 'transition' | 'cancel' | 'list' | 'triggers' | 'schedule';
+    definition?: string;
+    task?: string;
+    workflowId?: string;
+    targetState?: string;
+    triggerAction?: 'list' | 'add' | 'remove' | 'enable' | 'disable';
+    triggerId?: string;
+    triggerDefinition?: {
+        event: string;
+        condition?: string;
+        action: string;
+    };
+    scheduleAction?: 'list' | 'add' | 'remove';
+    scheduleName?: string;
+    scheduleInterval?: string;
+    scheduleCommand?: string;
+}
+export interface WorkflowServices {
+    readonly workflowManager: WorkflowManager;
+    readonly triggerManager: TriggerManager;
+    readonly scheduleManager: ScheduleManager;
+}
+export declare function createWorkflowServices(): WorkflowServices;
+export declare function createWorkflowTool(services: WorkflowServices): Tool;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/platform/tools/workflow/index.d.ts.map

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

package/dist/platform/tools/workflow/index.js

@@ -0,0 +1,443 @@
+import { workflowSchema } from './schema.js';
+import { summarizeError } from '../../utils/error-display.js';
+export const WORKFLOW_DEFINITIONS = Object.freeze(JSON.parse(JSON.stringify({
+    wrfc: {
+        name: 'WRFC Loop',
+        states: ['gather', 'plan', 'apply', 'review', 'revision', 'complete'],
+        transitions: {
+            gather: ['plan'],
+            plan: ['apply'],
+            apply: ['review'],
+            review: ['revision', 'complete'],
+            revision: ['apply'],
+        },
+        description: 'Full work-review-fix cycle',
+    },
+    fix_loop: {
+        name: 'Fix Loop',
+        states: ['apply', 'test', 'verify', 'complete'],
+        transitions: { apply: ['test'], test: ['verify', 'apply'], verify: ['complete'] },
+        description: 'Apply fix, test, verify',
+    },
+    test_then_fix: {
+        name: 'Test Then Fix',
+        states: ['test', 'fix', 'verify', 'complete'],
+        transitions: { test: ['fix'], fix: ['verify'], verify: ['complete', 'fix'] },
+        description: 'Run tests, fix failures, verify',
+    },
+    review_only: {
+        name: 'Review Only',
+        states: ['review', 'complete'],
+        transitions: { review: ['complete'] },
+        description: 'Skip to review phase',
+    },
+})));
+const WORKFLOW_EVICT_AFTER_MS = 60 * 60 * 1000; // 1 hour
+const WORKFLOW_MAX_COMPLETED = 50;
+export class WorkflowManager {
+    workflows = new Map();
+    start(definition, task) {
+        const def = WORKFLOW_DEFINITIONS[definition];
+        if (!def) {
+            throw new Error(`Unknown workflow definition: ${definition}`);
+        }
+        const id = `wf-${crypto.randomUUID().slice(0, 8)}`;
+        const instance = {
+            id,
+            definition,
+            currentState: def.states[0],
+            task,
+            startedAt: Date.now(),
+            transitions: 0,
+            context: {},
+        };
+        this.workflows.set(id, instance);
+        return instance;
+    }
+    getStatus(id) {
+        return this.workflows.get(id) ?? null;
+    }
+    transition(id, targetState) {
+        const instance = this.workflows.get(id);
+        if (!instance) {
+            return { success: false, error: `Workflow not found: ${id}` };
+        }
+        if (instance.cancelled) {
+            return { success: false, error: 'Workflow is cancelled' };
+        }
+        const def = WORKFLOW_DEFINITIONS[instance.definition];
+        const allowed = def?.transitions[instance.currentState] ?? [];
+        if (!allowed.includes(targetState)) {
+            return {
+                success: false,
+                error: `Invalid transition: ${instance.currentState} -> ${targetState}. Allowed: [${allowed.join(', ')}]`,
+            };
+        }
+        instance.currentState = targetState;
+        instance.transitions += 1;
+        if (targetState === 'complete') {
+            instance.completedAt = Date.now();
+        }
+        return { success: true };
+    }
+    cancel(id) {
+        const instance = this.workflows.get(id);
+        if (!instance)
+            return false;
+        instance.cancelled = true;
+        instance.completedAt = Date.now();
+        return true;
+    }
+    list() {
+        const now = Date.now();
+        // Evict old completed/cancelled workflows
+        for (const [id, wf] of this.workflows) {
+            if (wf.completedAt !== undefined && now - wf.completedAt > WORKFLOW_EVICT_AFTER_MS) {
+                this.workflows.delete(id);
+            }
+        }
+        // Cap completed workflows at max
+        const all = Array.from(this.workflows.values());
+        const completed = all.filter(w => w.completedAt !== undefined);
+        if (completed.length > WORKFLOW_MAX_COMPLETED) {
+            completed.sort((a, b) => (a.completedAt ?? 0) - (b.completedAt ?? 0));
+            const toEvict = completed.slice(0, completed.length - WORKFLOW_MAX_COMPLETED);
+            for (const wf of toEvict)
+                this.workflows.delete(wf.id);
+        }
+        return Array.from(this.workflows.values());
+    }
+}
+export class TriggerManager {
+    triggers = new Map();
+    add(def) {
+        const id = `trg-${crypto.randomUUID().slice(0, 8)}`;
+        const trigger = {
+            id,
+            event: def.event,
+            condition: def.condition,
+            action: def.action,
+            enabled: true,
+        };
+        this.triggers.set(id, trigger);
+        return trigger;
+    }
+    remove(id) {
+        return this.triggers.delete(id);
+    }
+    enable(id) {
+        const trigger = this.triggers.get(id);
+        if (!trigger)
+            return false;
+        trigger.enabled = true;
+        return true;
+    }
+    disable(id) {
+        const trigger = this.triggers.get(id);
+        if (!trigger)
+            return false;
+        trigger.enabled = false;
+        return true;
+    }
+    list() {
+        return Array.from(this.triggers.values());
+    }
+}
+/**
+ * Parse an interval string like '30s', '5m', '1h' to milliseconds.
+ * Returns null if the format is unrecognised.
+ */
+export function parseInterval(interval) {
+    const match = interval.trim().match(/^(\d+(?:\.\d+)?)(s|m|h|d)$/);
+    if (!match)
+        return null;
+    const value = parseFloat(match[1]);
+    switch (match[2]) {
+        case 's': return value * 1_000;
+        case 'm': return value * 60_000;
+        case 'h': return value * 3_600_000;
+        case 'd': return value * 86_400_000;
+        default: return null;
+    }
+}
+export class ScheduleManager {
+    schedules = new Map();
+    /** Timer IDs keyed by schedule name */
+    timers = new Map();
+    /** Spawned process handles tracked for cleanup in destroy() */
+    spawnedProcs = [];
+    add(name, interval, command) {
+        // Clear existing timer if re-adding
+        this._clearTimer(name);
+        const now = Date.now();
+        const intervalMs = parseInterval(interval);
+        const entry = {
+            name,
+            interval,
+            command,
+            enabled: true,
+            nextRun: intervalMs !== null ? now + intervalMs : undefined,
+        };
+        this.schedules.set(name, entry);
+        if (intervalMs !== null) {
+            const timer = setInterval(() => this._tick(name), intervalMs);
+            this.timers.set(name, timer);
+        }
+        return entry;
+    }
+    remove(name) {
+        this._clearTimer(name);
+        return this.schedules.delete(name);
+    }
+    enable(name) {
+        const entry = this.schedules.get(name);
+        if (!entry)
+            return false;
+        if (entry.enabled)
+            return true;
+        entry.enabled = true;
+        // Restart timer
+        const intervalMs = parseInterval(entry.interval);
+        if (intervalMs !== null && !this.timers.has(name)) {
+            entry.nextRun = Date.now() + intervalMs;
+            const timer = setInterval(() => this._tick(name), intervalMs);
+            this.timers.set(name, timer);
+        }
+        return true;
+    }
+    disable(name) {
+        const entry = this.schedules.get(name);
+        if (!entry)
+            return false;
+        entry.enabled = false;
+        this._clearTimer(name);
+        entry.nextRun = undefined;
+        return true;
+    }
+    list() {
+        return Array.from(this.schedules.values());
+    }
+    /** Stop all timers and clear state when the manager is disposed. */
+    destroy() {
+        for (const name of this.timers.keys()) {
+            this._clearTimer(name);
+        }
+        this.schedules.clear();
+        // Kill any still-running spawned processes
+        for (const { proc } of this.spawnedProcs) {
+            try {
+                proc.kill();
+            }
+            catch { /* non-fatal */ }
+        }
+        this.spawnedProcs = [];
+    }
+    /** Execute a schedule tick: run the command and update lastRun/nextRun. */
+    _tick(name) {
+        const entry = this.schedules.get(name);
+        if (!entry || !entry.enabled)
+            return;
+        const now = Date.now();
+        entry.lastRun = now;
+        const intervalMs = parseInterval(entry.interval);
+        entry.nextRun = intervalMs !== null ? now + intervalMs : undefined;
+        // Parse command string
+        const parts = entry.command.split(/\s+/).filter(Boolean);
+        if (parts.length === 0)
+            return;
+        try {
+            const proc = Bun.spawn(parts, {
+                env: { ...process.env, GV_SCHEDULE_NAME: name },
+                stdout: 'ignore',
+                stderr: 'ignore',
+            });
+            const pid = proc.pid;
+            this.spawnedProcs.push({ pid, proc });
+            proc.exited.then(() => {
+                // Remove from tracking once the process has exited
+                const idx = this.spawnedProcs.findIndex(p => p.pid === pid);
+                if (idx !== -1)
+                    this.spawnedProcs.splice(idx, 1);
+            }).catch(() => { });
+        }
+        catch {
+            // Spawn failure is non-fatal for the scheduler
+        }
+    }
+    _clearTimer(name) {
+        const timer = this.timers.get(name);
+        if (timer !== undefined) {
+            clearInterval(timer);
+            this.timers.delete(name);
+        }
+    }
+}
+export function createWorkflowServices() {
+    return {
+        workflowManager: new WorkflowManager(),
+        triggerManager: new TriggerManager(),
+        scheduleManager: new ScheduleManager(),
+    };
+}
+// ---------------------------------------------------------------------------
+// Tool implementation
+// ---------------------------------------------------------------------------
+export function createWorkflowTool(services) {
+    return {
+        definition: workflowSchema,
+        async execute(args) {
+            try {
+                if (!args.mode || typeof args.mode !== 'string') {
+                    return { success: false, error: 'Missing required "mode" field' };
+                }
+                const input = args;
+                const wm = services.workflowManager;
+                const tm = services.triggerManager;
+                const sm = services.scheduleManager;
+                switch (input.mode) {
+                    case 'start': {
+                        if (!input.definition) {
+                            return { success: false, error: 'mode "start" requires "definition"' };
+                        }
+                        if (!input.task) {
+                            return { success: false, error: 'mode "start" requires "task"' };
+                        }
+                        if (!WORKFLOW_DEFINITIONS[input.definition]) {
+                            return { success: false, error: `Unknown workflow definition: ${input.definition}` };
+                        }
+                        const instance = wm.start(input.definition, input.task);
+                        return { success: true, output: JSON.stringify(instance) };
+                    }
+                    case 'status': {
+                        if (!input.workflowId) {
+                            return { success: false, error: 'mode "status" requires "workflowId"' };
+                        }
+                        const instance = wm.getStatus(input.workflowId);
+                        if (!instance) {
+                            return { success: false, error: `Workflow not found: ${input.workflowId}` };
+                        }
+                        return { success: true, output: JSON.stringify(instance) };
+                    }
+                    case 'transition': {
+                        if (!input.workflowId) {
+                            return { success: false, error: 'mode "transition" requires "workflowId"' };
+                        }
+                        if (!input.targetState) {
+                            return { success: false, error: 'mode "transition" requires "targetState"' };
+                        }
+                        const result = wm.transition(input.workflowId, input.targetState);
+                        if (!result.success) {
+                            return { success: false, error: result.error };
+                        }
+                        const updated = wm.getStatus(input.workflowId);
+                        return { success: true, output: JSON.stringify(updated) };
+                    }
+                    case 'cancel': {
+                        if (!input.workflowId) {
+                            return { success: false, error: 'mode "cancel" requires "workflowId"' };
+                        }
+                        const cancelled = wm.cancel(input.workflowId);
+                        if (!cancelled) {
+                            return { success: false, error: `Workflow not found: ${input.workflowId}` };
+                        }
+                        return { success: true, output: JSON.stringify({ cancelled: true, workflowId: input.workflowId }) };
+                    }
+                    case 'list': {
+                        const workflows = wm.list();
+                        return { success: true, output: JSON.stringify({ workflows, count: workflows.length }) };
+                    }
+                    case 'triggers': {
+                        const action = input.triggerAction ?? 'list';
+                        switch (action) {
+                            case 'list': {
+                                const triggers = tm.list();
+                                return { success: true, output: JSON.stringify({ triggers, count: triggers.length }) };
+                            }
+                            case 'add': {
+                                if (!input.triggerDefinition) {
+                                    return { success: false, error: 'triggers/add requires "triggerDefinition"' };
+                                }
+                                const trigger = tm.add(input.triggerDefinition);
+                                return { success: true, output: JSON.stringify(trigger) };
+                            }
+                            case 'remove': {
+                                if (!input.triggerId) {
+                                    return { success: false, error: 'triggers/remove requires "triggerId"' };
+                                }
+                                const removed = tm.remove(input.triggerId);
+                                return { success: true, output: JSON.stringify({ removed, triggerId: input.triggerId }) };
+                            }
+                            case 'enable': {
+                                if (!input.triggerId) {
+                                    return { success: false, error: 'triggers/enable requires "triggerId"' };
+                                }
+                                const enabled = tm.enable(input.triggerId);
+                                if (!enabled) {
+                                    return { success: false, error: `Trigger not found: ${input.triggerId}` };
+                                }
+                                return { success: true, output: JSON.stringify({ enabled: true, triggerId: input.triggerId }) };
+                            }
+                            case 'disable': {
+                                if (!input.triggerId) {
+                                    return { success: false, error: 'triggers/disable requires "triggerId"' };
+                                }
+                                const disabled = tm.disable(input.triggerId);
+                                if (!disabled) {
+                                    return { success: false, error: `Trigger not found: ${input.triggerId}` };
+                                }
+                                return { success: true, output: JSON.stringify({ disabled: true, triggerId: input.triggerId }) };
+                            }
+                            default: {
+                                const exhaustive = action;
+                                return { success: false, error: `Unknown triggerAction: ${exhaustive}` };
+                            }
+                        }
+                    }
+                    case 'schedule': {
+                        const action = input.scheduleAction ?? 'list';
+                        switch (action) {
+                            case 'list': {
+                                const schedules = sm.list();
+                                return { success: true, output: JSON.stringify({ schedules, count: schedules.length }) };
+                            }
+                            case 'add': {
+                                if (!input.scheduleName) {
+                                    return { success: false, error: 'schedule/add requires "scheduleName"' };
+                                }
+                                if (!input.scheduleInterval) {
+                                    return { success: false, error: 'schedule/add requires "scheduleInterval"' };
+                                }
+                                if (!input.scheduleCommand) {
+                                    return { success: false, error: 'schedule/add requires "scheduleCommand"' };
+                                }
+                                const entry = sm.add(input.scheduleName, input.scheduleInterval, input.scheduleCommand);
+                                return { success: true, output: JSON.stringify(entry) };
+                            }
+                            case 'remove': {
+                                if (!input.scheduleName) {
+                                    return { success: false, error: 'schedule/remove requires "scheduleName"' };
+                                }
+                                const removed = sm.remove(input.scheduleName);
+                                return { success: true, output: JSON.stringify({ removed, scheduleName: input.scheduleName }) };
+                            }
+                            default: {
+                                const exhaustive = action;
+                                return { success: false, error: `Unknown scheduleAction: ${exhaustive}` };
+                            }
+                        }
+                    }
+                    default: {
+                        const exhaustive = input.mode;
+                        return { success: false, error: `Unknown mode: ${exhaustive}` };
+                    }
+                }
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    error: summarizeError(err),
+                };
+            }
+        },
+    };
+}

package/dist/platform/tools/workflow/schema.d.ts

@@ -0,0 +1,7 @@
+import type { ToolDefinition } from '../../types/tools.js';
+/**
+ * JSON Schema for the workflow tool's input.
+ * Manages WRFC state machines, automation triggers, and scheduled tasks.
+ */
+export declare const workflowSchema: ToolDefinition;
+//# sourceMappingURL=schema.d.ts.map

package/dist/platform/tools/workflow/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/platform/tools/workflow/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,cA0F5B,CAAC"}

package/dist/platform/tools/workflow/schema.js

@@ -0,0 +1,94 @@
+/**
+ * JSON Schema for the workflow tool's input.
+ * Manages WRFC state machines, automation triggers, and scheduled tasks.
+ */
+export const workflowSchema = {
+    name: 'workflow',
+    description: 'Internal automation plumbing — NOT for executing tasks or spawning agents. ' +
+        'To run work, use the agent tool instead. ' +
+        'This tool only manages: triggers (event-driven automations that fire shell commands on hook events), ' +
+        'schedule (recurring background commands on intervals), ' +
+        'and workflow state tracking (internal bookkeeping — does not execute anything). ' +
+        'Modes: triggers (manage event-driven automations), schedule (manage recurring tasks), ' +
+        'start/status/transition/cancel/list (state tracking only — no execution).',
+    sideEffects: ['workflow', 'state'],
+    concurrency: 'serial',
+    parameters: {
+        type: 'object',
+        required: ['mode'],
+        properties: {
+            mode: {
+                type: 'string',
+                enum: ['start', 'status', 'transition', 'cancel', 'list', 'triggers', 'schedule'],
+                description: 'Operation mode.',
+            },
+            // mode: start
+            definition: {
+                type: 'string',
+                enum: ['wrfc', 'fix_loop', 'test_then_fix', 'review_only'],
+                description: 'Workflow definition to instantiate (mode: start).',
+            },
+            task: {
+                type: 'string',
+                description: 'Task description for the workflow (mode: start).',
+            },
+            // mode: status / cancel
+            workflowId: {
+                type: 'string',
+                description: 'Workflow instance ID (mode: status, transition, cancel).',
+            },
+            // mode: transition
+            targetState: {
+                type: 'string',
+                description: 'State to transition to (mode: transition).',
+            },
+            // mode: triggers
+            triggerAction: {
+                type: 'string',
+                enum: ['list', 'add', 'remove', 'enable', 'disable'],
+                description: 'Trigger management action (mode: triggers).',
+            },
+            triggerId: {
+                type: 'string',
+                description: 'Trigger ID for remove/enable/disable actions (mode: triggers).',
+            },
+            triggerDefinition: {
+                type: 'object',
+                description: 'Trigger definition for add action (mode: triggers).',
+                required: ['event', 'action'],
+                properties: {
+                    event: {
+                        type: 'string',
+                        description: 'Hook event pattern to match (e.g. Pre:tool:*, Post:file:write).',
+                    },
+                    condition: {
+                        type: 'string',
+                        description: 'Optional condition expression evaluated against event payload.',
+                    },
+                    action: {
+                        type: 'string',
+                        description: 'Action to execute when trigger fires.',
+                    },
+                },
+            },
+            // mode: schedule
+            scheduleAction: {
+                type: 'string',
+                enum: ['list', 'add', 'remove'],
+                description: 'Schedule management action (mode: schedule).',
+            },
+            scheduleName: {
+                type: 'string',
+                description: 'Unique name for the schedule entry.',
+            },
+            scheduleInterval: {
+                type: 'string',
+                description: "Repeat interval, e.g. '5m', '1h', '30s' (mode: schedule, action: add).",
+            },
+            scheduleCommand: {
+                type: 'string',
+                description: 'Command to run on each interval tick (mode: schedule, action: add).',
+            },
+        },
+    },
+};

package/dist/platform/tools/worklist/index.d.ts

@@ -0,0 +1,3 @@
+import type { Tool } from '../../types/tools.js';
+export declare const worklistTool: Tool;
+//# sourceMappingURL=index.d.ts.map

package/dist/platform/tools/worklist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/platform/tools/worklist/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AA+DjD,eAAO,MAAM,YAAY,EAAE,IAyG1B,CAAC"}