@auxiora/workflows 1.0.0

package/tests/autonomous-executor.test.ts

@@ -0,0 +1,369 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { WorkflowEngine } from '../src/engine.js';
+import { AutonomousExecutor } from '../src/autonomous-executor.js';
+import type { AutonomousExecutorDeps, GateCheckResult } from '../src/autonomous-executor.js';
+
+function createMockDeps(engine: WorkflowEngine, overrides: Partial<AutonomousExecutorDeps> = {}): AutonomousExecutorDeps {
+  return {
+    workflowEngine: engine,
+    trustGate: {
+      gate: vi.fn<[string, string, number], GateCheckResult>().mockReturnValue({
+        allowed: true,
+        message: 'Allowed',
+      }),
+    },
+    trustEngine: {
+      recordOutcome: vi.fn(),
+    },
+    auditTrail: {
+      record: vi.fn().mockResolvedValue({ id: 'audit-1' }),
+      markRolledBack: vi.fn().mockResolvedValue(true),
+    },
+    executeTool: vi.fn().mockResolvedValue({ success: true, output: 'done' }),
+    ...overrides,
+  };
+}
+
+async function createTestWorkflow(engine: WorkflowEngine, options?: { autonomous?: boolean }) {
+  const workflow = await engine.createWorkflow({
+    name: 'Test Autonomous',
+    description: 'A test workflow',
+    createdBy: 'system',
+    autonomous: options?.autonomous ?? true,
+    steps: [
+      {
+        name: 'Read config',
+        description: 'Read the config file',
+        assigneeId: 'system',
+        action: {
+          tool: 'file_read',
+          params: { path: '/etc/config.json' },
+          trustDomain: 'files',
+          trustRequired: 1,
+        },
+      },
+      {
+        name: 'Send report',
+        description: 'Send the report email',
+        assigneeId: 'system',
+        dependsOn: ['step-1'],
+        action: {
+          tool: 'email_compose',
+          params: { to: 'user@example.com', subject: 'Report' },
+          trustDomain: 'email',
+          trustRequired: 2,
+        },
+      },
+    ],
+  });
+  await engine.startWorkflow(workflow.id);
+  return workflow;
+}
+
+describe('AutonomousExecutor', () => {
+  let tmpDir: string;
+  let engine: WorkflowEngine;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'auto-exec-'));
+    engine = new WorkflowEngine({ dir: tmpDir });
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  describe('tick', () => {
+    it('should execute active autonomous workflow steps', async () => {
+      const workflow = await createTestWorkflow(engine);
+      const deps = createMockDeps(engine);
+      const executor = new AutonomousExecutor(deps);
+
+      const result = await executor.tick();
+
+      expect(result.workflowsProcessed).toBe(1);
+      expect(result.stepsExecuted).toBe(1); // Only step-1 (step-2 depends on it)
+      expect(deps.executeTool).toHaveBeenCalledWith('file_read', { path: '/etc/config.json' });
+      expect(deps.trustGate.gate).toHaveBeenCalledWith('files', 'file_read', 1);
+      expect(deps.trustEngine.recordOutcome).toHaveBeenCalledWith('files', true);
+    });
+
+    it('should advance dependent steps after completion', async () => {
+      const workflow = await createTestWorkflow(engine);
+      const deps = createMockDeps(engine);
+      const executor = new AutonomousExecutor(deps);
+
+      // First tick: execute step-1
+      await executor.tick();
+
+      // Second tick: step-2 should now be active
+      const result = await executor.tick();
+
+      expect(result.stepsExecuted).toBe(1);
+      expect(deps.executeTool).toHaveBeenCalledWith('email_compose', {
+        to: 'user@example.com',
+        subject: 'Report',
+      });
+    });
+
+    it('should complete workflow when all steps finish', async () => {
+      const workflow = await createTestWorkflow(engine);
+      const onCompleted = vi.fn();
+      const deps = createMockDeps(engine, { onWorkflowCompleted: onCompleted });
+      const executor = new AutonomousExecutor(deps);
+
+      // Two ticks to complete both steps
+      await executor.tick();
+      await executor.tick();
+
+      const status = await engine.getStatus(workflow.id);
+      expect(status?.workflow.status).toBe('completed');
+      expect(onCompleted).toHaveBeenCalledWith(workflow.id);
+    });
+
+    it('should skip non-autonomous workflows', async () => {
+      await engine.createWorkflow({
+        name: 'Human Workflow',
+        description: 'Not autonomous',
+        createdBy: 'user',
+        steps: [
+          { name: 'Manual step', description: 'Do this by hand', assigneeId: 'user' },
+        ],
+      });
+
+      const deps = createMockDeps(engine);
+      const executor = new AutonomousExecutor(deps);
+
+      const result = await executor.tick();
+
+      expect(result.workflowsProcessed).toBe(0);
+      expect(deps.executeTool).not.toHaveBeenCalled();
+    });
+
+    it('should skip steps without actions', async () => {
+      const workflow = await engine.createWorkflow({
+        name: 'Mixed Workflow',
+        description: 'Has both auto and manual steps',
+        createdBy: 'system',
+        autonomous: true,
+        steps: [
+          { name: 'Manual review', description: 'Review by human', assigneeId: 'user-bob' },
+          {
+            name: 'Auto deploy',
+            description: 'Auto deploy',
+            assigneeId: 'system',
+            dependsOn: ['step-1'],
+            action: {
+              tool: 'bash',
+              params: { command: 'deploy.sh' },
+              trustDomain: 'shell',
+              trustRequired: 3,
+            },
+          },
+        ],
+      });
+      await engine.startWorkflow(workflow.id);
+
+      const deps = createMockDeps(engine);
+      const executor = new AutonomousExecutor(deps);
+
+      const result = await executor.tick();
+
+      // step-1 is active but has no action, step-2 is pending (depends on step-1)
+      expect(result.stepsExecuted).toBe(0);
+      expect(deps.executeTool).not.toHaveBeenCalled();
+    });
+
+    it('should not process concurrently', async () => {
+      await createTestWorkflow(engine);
+      const deps = createMockDeps(engine, {
+        executeTool: vi.fn().mockImplementation(
+          () => new Promise((resolve) => setTimeout(() => resolve({ success: true, output: 'ok' }), 50)),
+        ),
+      });
+      const executor = new AutonomousExecutor(deps);
+
+      // Start two ticks simultaneously
+      const [r1, r2] = await Promise.all([executor.tick(), executor.tick()]);
+
+      // One should have been skipped
+      const total = r1.stepsExecuted + r2.stepsExecuted;
+      expect(total).toBe(1);
+    });
+  });
+
+  describe('trust gating', () => {
+    it('should skip steps when trust is denied', async () => {
+      await createTestWorkflow(engine);
+      const deps = createMockDeps(engine, {
+        trustGate: {
+          gate: vi.fn<[string, string, number], GateCheckResult>().mockReturnValue({
+            allowed: false,
+            message: 'Trust level too low',
+          }),
+        },
+      });
+      const executor = new AutonomousExecutor(deps);
+
+      const result = await executor.tick();
+
+      expect(result.stepsSkipped).toBe(1);
+      expect(result.stepsExecuted).toBe(0);
+      expect(deps.executeTool).not.toHaveBeenCalled();
+    });
+
+    it('should not fail the step on trust denial', async () => {
+      const workflow = await createTestWorkflow(engine);
+      const deps = createMockDeps(engine, {
+        trustGate: {
+          gate: vi.fn<[string, string, number], GateCheckResult>().mockReturnValue({
+            allowed: false,
+            message: 'Denied',
+          }),
+        },
+      });
+      const executor = new AutonomousExecutor(deps);
+
+      await executor.tick();
+
+      // Step should still be active (not failed)
+      const status = await engine.getStatus(workflow.id);
+      const step1 = status?.workflow.steps.find((s) => s.id === 'step-1');
+      expect(step1?.status).toBe('active');
+    });
+  });
+
+  describe('failure handling', () => {
+    it('should mark step as failed when tool fails', async () => {
+      const workflow = await createTestWorkflow(engine);
+      const onFailed = vi.fn();
+      const deps = createMockDeps(engine, {
+        executeTool: vi.fn().mockResolvedValue({ success: false, error: 'File not found' }),
+        onStepFailed: onFailed,
+      });
+      const executor = new AutonomousExecutor(deps);
+
+      const result = await executor.tick();
+
+      expect(result.stepsFailed).toBe(1);
+      expect(deps.trustEngine.recordOutcome).toHaveBeenCalledWith('files', false);
+      expect(onFailed).toHaveBeenCalledWith(workflow.id, 'step-1', 'File not found');
+    });
+
+    it('should handle tool execution exceptions', async () => {
+      const workflow = await createTestWorkflow(engine);
+      const deps = createMockDeps(engine, {
+        executeTool: vi.fn().mockRejectedValue(new Error('Connection refused')),
+      });
+      const executor = new AutonomousExecutor(deps);
+
+      const result = await executor.tick();
+
+      expect(result.stepsFailed).toBe(1);
+      expect(deps.trustEngine.recordOutcome).toHaveBeenCalledWith('files', false);
+    });
+
+    it('should attempt rollback on failure when rollback tool is defined', async () => {
+      const workflow = await engine.createWorkflow({
+        name: 'Rollback Test',
+        description: 'Test rollback',
+        createdBy: 'system',
+        autonomous: true,
+        steps: [
+          {
+            name: 'Write file',
+            description: 'Write then rollback',
+            assigneeId: 'system',
+            action: {
+              tool: 'file_write',
+              params: { path: '/tmp/test.txt', content: 'data' },
+              trustDomain: 'files',
+              trustRequired: 2,
+              rollbackTool: 'file_write',
+              rollbackParams: { path: '/tmp/test.txt', content: '' },
+            },
+          },
+        ],
+      });
+      await engine.startWorkflow(workflow.id);
+
+      const executeTool = vi.fn()
+        .mockResolvedValueOnce({ success: false, error: 'Disk full' }) // Main tool fails
+        .mockResolvedValueOnce({ success: true, output: 'Rolled back' }); // Rollback succeeds
+
+      const deps = createMockDeps(engine, { executeTool });
+      const executor = new AutonomousExecutor(deps);
+
+      await executor.tick();
+
+      expect(executeTool).toHaveBeenCalledTimes(2);
+      expect(executeTool).toHaveBeenNthCalledWith(2, 'file_write', {
+        path: '/tmp/test.txt',
+        content: '',
+      });
+      expect(deps.auditTrail.markRolledBack).toHaveBeenCalledWith('audit-1');
+    });
+  });
+
+  describe('audit trail', () => {
+    it('should record audit entries for executed steps', async () => {
+      await createTestWorkflow(engine);
+      const deps = createMockDeps(engine);
+      const executor = new AutonomousExecutor(deps);
+
+      await executor.tick();
+
+      // Two audit records: one pending (before execution), one success (after)
+      expect(deps.auditTrail.record).toHaveBeenCalledTimes(2);
+
+      const firstCall = (deps.auditTrail.record as any).mock.calls[0][0];
+      expect(firstCall.outcome).toBe('pending');
+      expect(firstCall.domain).toBe('files');
+
+      const secondCall = (deps.auditTrail.record as any).mock.calls[1][0];
+      expect(secondCall.outcome).toBe('success');
+    });
+  });
+
+  describe('callbacks', () => {
+    it('should call onStepCompleted on success', async () => {
+      const workflow = await createTestWorkflow(engine);
+      const onCompleted = vi.fn();
+      const deps = createMockDeps(engine, { onStepCompleted: onCompleted });
+      const executor = new AutonomousExecutor(deps);
+
+      await executor.tick();
+
+      expect(onCompleted).toHaveBeenCalledWith(workflow.id, 'step-1', 'done');
+    });
+  });
+
+  describe('start/stop', () => {
+    it('should start and stop the timer', () => {
+      const deps = createMockDeps(engine);
+      const executor = new AutonomousExecutor(deps);
+
+      expect(executor.isRunning()).toBe(false);
+
+      executor.start(60_000);
+      expect(executor.isRunning()).toBe(true);
+
+      executor.stop();
+      expect(executor.isRunning()).toBe(false);
+    });
+
+    it('should not start twice', () => {
+      const deps = createMockDeps(engine);
+      const executor = new AutonomousExecutor(deps);
+
+      executor.start(60_000);
+      executor.start(60_000); // Should be no-op
+
+      expect(executor.isRunning()).toBe(true);
+      executor.stop();
+    });
+  });
+});

package/tests/workflows.test.ts

@@ -0,0 +1,290 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { WorkflowEngine } from '../src/engine.js';
+import { ApprovalManager } from '../src/approval.js';
+import { ReminderService } from '../src/reminder.js';
+
+describe('WorkflowEngine', () => {
+  let tmpDir: string;
+  let engine: WorkflowEngine;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'workflows-'));
+    engine = new WorkflowEngine({ dir: tmpDir });
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('should create a workflow', async () => {
+    const workflow = await engine.createWorkflow({
+      name: 'Deploy Feature',
+      description: 'Deploy the new feature to production',
+      createdBy: 'user-alice',
+      steps: [
+        { name: 'Code Review', description: 'Review the code', assigneeId: 'user-bob' },
+        { name: 'QA Test', description: 'Run QA tests', assigneeId: 'user-charlie', dependsOn: ['step-1'] },
+        { name: 'Deploy', description: 'Deploy to prod', assigneeId: 'user-alice', dependsOn: ['step-2'] },
+      ],
+    });
+
+    expect(workflow.id).toMatch(/^wf-/);
+    expect(workflow.status).toBe('pending');
+    expect(workflow.steps).toHaveLength(3);
+    expect(workflow.events).toHaveLength(1);
+    expect(workflow.events[0].type).toBe('created');
+  });
+
+  it('should start a workflow and activate first steps', async () => {
+    const created = await engine.createWorkflow({
+      name: 'Test',
+      description: 'Test workflow',
+      createdBy: 'user-alice',
+      steps: [
+        { name: 'Step 1', description: 'First', assigneeId: 'user-bob' },
+        { name: 'Step 2', description: 'Second', assigneeId: 'user-charlie', dependsOn: ['step-1'] },
+      ],
+    });
+
+    const started = await engine.startWorkflow(created.id);
+    expect(started).toBeDefined();
+    expect(started!.status).toBe('active');
+    expect(started!.steps[0].status).toBe('active');
+    expect(started!.steps[1].status).toBe('pending');
+  });
+
+  it('should complete a step and advance dependencies', async () => {
+    const created = await engine.createWorkflow({
+      name: 'Sequential',
+      description: 'Sequential workflow',
+      createdBy: 'user-alice',
+      steps: [
+        { name: 'Step 1', description: 'First', assigneeId: 'user-bob' },
+        { name: 'Step 2', description: 'Second', assigneeId: 'user-charlie', dependsOn: ['step-1'] },
+      ],
+    });
+
+    await engine.startWorkflow(created.id);
+    const updated = await engine.completeStep(created.id, 'step-1', 'user-bob', 'Looks good');
+
+    expect(updated).toBeDefined();
+    expect(updated!.steps[0].status).toBe('completed');
+    expect(updated!.steps[0].completedBy).toBe('user-bob');
+    expect(updated!.steps[1].status).toBe('active'); // Advanced!
+  });
+
+  it('should complete workflow when all steps done', async () => {
+    const created = await engine.createWorkflow({
+      name: 'Simple',
+      description: 'Simple workflow',
+      createdBy: 'user-alice',
+      steps: [
+        { name: 'Only Step', description: 'The only step', assigneeId: 'user-bob' },
+      ],
+    });
+
+    await engine.startWorkflow(created.id);
+    const updated = await engine.completeStep(created.id, 'step-1', 'user-bob');
+
+    expect(updated!.status).toBe('completed');
+    expect(updated!.completedAt).toBeDefined();
+  });
+
+  it('should get workflow status with progress', async () => {
+    const created = await engine.createWorkflow({
+      name: 'Progress',
+      description: 'Track progress',
+      createdBy: 'user-alice',
+      steps: [
+        { name: 'Step 1', description: 'First', assigneeId: 'user-bob' },
+        { name: 'Step 2', description: 'Second', assigneeId: 'user-bob' },
+      ],
+    });
+
+    await engine.startWorkflow(created.id);
+    await engine.completeStep(created.id, 'step-1', 'user-bob');
+
+    const status = await engine.getStatus(created.id);
+    expect(status).toBeDefined();
+    expect(status!.progress).toBe(0.5);
+  });
+
+  it('should list active workflows', async () => {
+    await engine.createWorkflow({
+      name: 'Active',
+      description: 'Will be started',
+      createdBy: 'user-alice',
+      steps: [{ name: 'Step', description: 'Step', assigneeId: 'user-bob' }],
+    });
+
+    const active = await engine.listActive();
+    expect(active).toHaveLength(1);
+  });
+
+  it('should cancel a workflow', async () => {
+    const created = await engine.createWorkflow({
+      name: 'Cancel Me',
+      description: 'To be cancelled',
+      createdBy: 'user-alice',
+      steps: [{ name: 'Step', description: 'Step', assigneeId: 'user-bob' }],
+    });
+
+    await engine.startWorkflow(created.id);
+    const cancelled = await engine.cancelWorkflow(created.id);
+    expect(cancelled).toBe(true);
+
+    const workflow = await engine.getWorkflow(created.id);
+    expect(workflow!.status).toBe('cancelled');
+  });
+
+  it('should list workflows by user', async () => {
+    await engine.createWorkflow({
+      name: 'Alice Workflow',
+      description: 'Created by alice',
+      createdBy: 'user-alice',
+      steps: [{ name: 'Step', description: 'For bob', assigneeId: 'user-bob' }],
+    });
+
+    const aliceWorkflows = await engine.listByUser('user-alice');
+    expect(aliceWorkflows).toHaveLength(1);
+
+    const bobWorkflows = await engine.listByUser('user-bob');
+    expect(bobWorkflows).toHaveLength(1); // Bob is assignee
+  });
+
+  it('should handle parallel steps', async () => {
+    const created = await engine.createWorkflow({
+      name: 'Parallel',
+      description: 'Steps run in parallel',
+      createdBy: 'user-alice',
+      steps: [
+        { name: 'Review A', description: 'Review part A', assigneeId: 'user-bob' },
+        { name: 'Review B', description: 'Review part B', assigneeId: 'user-charlie' },
+        { name: 'Merge', description: 'Merge results', assigneeId: 'user-alice', dependsOn: ['step-1', 'step-2'] },
+      ],
+    });
+
+    await engine.startWorkflow(created.id);
+    let wf = await engine.getWorkflow(created.id);
+    expect(wf!.steps[0].status).toBe('active');
+    expect(wf!.steps[1].status).toBe('active');
+    expect(wf!.steps[2].status).toBe('pending');
+
+    await engine.completeStep(created.id, 'step-1', 'user-bob');
+    wf = await engine.getWorkflow(created.id);
+    expect(wf!.steps[2].status).toBe('pending'); // Still waiting for step-2
+
+    await engine.completeStep(created.id, 'step-2', 'user-charlie');
+    wf = await engine.getWorkflow(created.id);
+    expect(wf!.steps[2].status).toBe('active'); // Now ready
+  });
+});
+
+describe('ApprovalManager', () => {
+  let tmpDir: string;
+  let manager: ApprovalManager;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'approvals-'));
+    manager = new ApprovalManager({ dir: tmpDir });
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('should create an approval request', async () => {
+    const request = await manager.requestApproval(
+      'wf-1',
+      'step-1',
+      'user-alice',
+      ['user-bob', 'user-charlie'],
+      'Please approve the deploy',
+    );
+
+    expect(request.id).toMatch(/^appr-/);
+    expect(request.status).toBe('pending');
+    expect(request.approverIds).toContain('user-bob');
+  });
+
+  it('should approve a request', async () => {
+    const request = await manager.requestApproval(
+      'wf-1', 'step-1', 'user-alice', ['user-bob'], 'Approve this',
+    );
+
+    const approved = await manager.approve(request.id, 'user-bob', 'Looks good');
+    expect(approved).toBeDefined();
+    expect(approved!.status).toBe('approved');
+    expect(approved!.decidedBy).toBe('user-bob');
+  });
+
+  it('should reject a request', async () => {
+    const request = await manager.requestApproval(
+      'wf-1', 'step-1', 'user-alice', ['user-bob'], 'Approve this',
+    );
+
+    const rejected = await manager.reject(request.id, 'user-bob', 'Needs changes');
+    expect(rejected).toBeDefined();
+    expect(rejected!.status).toBe('rejected');
+    expect(rejected!.decisionReason).toBe('Needs changes');
+  });
+
+  it('should not allow non-approver to decide', async () => {
+    const request = await manager.requestApproval(
+      'wf-1', 'step-1', 'user-alice', ['user-bob'], 'Approve this',
+    );
+
+    const result = await manager.approve(request.id, 'user-charlie');
+    expect(result).toBeUndefined();
+  });
+
+  it('should list pending approvals for a user', async () => {
+    await manager.requestApproval('wf-1', 'step-1', 'user-alice', ['user-bob'], 'Request 1');
+    await manager.requestApproval('wf-1', 'step-2', 'user-alice', ['user-charlie'], 'Request 2');
+
+    const bobPending = await manager.getPending('user-bob');
+    expect(bobPending).toHaveLength(1);
+
+    const allPending = await manager.getPending();
+    expect(allPending).toHaveLength(2);
+  });
+
+  it('should not return already-decided approvals', async () => {
+    const request = await manager.requestApproval(
+      'wf-1', 'step-1', 'user-alice', ['user-bob'], 'Approve this',
+    );
+    await manager.approve(request.id, 'user-bob');
+
+    const pending = await manager.getPending('user-bob');
+    expect(pending).toHaveLength(0);
+  });
+});
+
+describe('ReminderService', () => {
+  let service: ReminderService;
+
+  beforeEach(() => {
+    service = new ReminderService();
+  });
+
+  afterEach(() => {
+    service.shutdown();
+  });
+
+  it('should track active reminders', () => {
+    expect(service.getActiveCount()).toBe(0);
+  });
+
+  it('should cancel reminders', () => {
+    service.cancelReminder('wf-1', 'step-1');
+    expect(service.getActiveCount()).toBe(0);
+  });
+
+  it('should shutdown cleanly', () => {
+    service.shutdown();
+    expect(service.getActiveCount()).toBe(0);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "references": [
+    { "path": "../core" },
+    { "path": "../logger" },
+    { "path": "../audit" }
+  ]
+}