@soleri/core 2.12.0 → 7.0.0

package/src/__tests__/flows.test.ts

@@ -0,0 +1,604 @@
+/**
+ * Flow engine tests — loader, probes, plan builder, gate evaluator, executor.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createAgentRuntime } from '../runtime/runtime.js';
+import type { AgentRuntime } from '../runtime/types.js';
+import { loadFlowById, loadAllFlows } from '../flows/loader.js';
+import { runProbes } from '../flows/probes.js';
+import {
+  INTENT_TO_FLOW,
+  chainToToolName,
+  chainToRequires,
+  pruneSteps,
+} from '../flows/plan-builder.js';
+import { evaluateCondition, extractScore, resolvePath } from '../flows/gate-evaluator.js';
+import { FlowExecutor } from '../flows/executor.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const FLOWS_DIR = join(__dirname, '..', '..', 'data', 'flows');
+
+// ---------------------------------------------------------------------------
+// Flow Loader
+// ---------------------------------------------------------------------------
+
+describe('Flow Loader', () => {
+  it('should load all 8 flow files', () => {
+    const flows = loadAllFlows(FLOWS_DIR);
+    expect(flows.length).toBe(8);
+  });
+
+  it('should load BUILD-flow by ID', () => {
+    const flow = loadFlowById('BUILD-flow', FLOWS_DIR);
+    expect(flow).not.toBeNull();
+    expect(flow!.id).toBe('BUILD-flow');
+    expect(flow!.steps.length).toBeGreaterThan(0);
+  });
+
+  it('should load FIX-flow by ID', () => {
+    const flow = loadFlowById('FIX-flow', FLOWS_DIR);
+    expect(flow).not.toBeNull();
+    expect(flow!.triggers.modes).toContain('FIX');
+  });
+
+  it('should return null for unknown flow ID', () => {
+    const flow = loadFlowById('NONEXISTENT-flow', FLOWS_DIR);
+    expect(flow).toBeNull();
+  });
+
+  it('each flow should have valid structure', () => {
+    const flows = loadAllFlows(FLOWS_DIR);
+    for (const flow of flows) {
+      expect(flow.id).toBeTruthy();
+      expect(flow.triggers.modes.length).toBeGreaterThan(0);
+      expect(flow.steps.length).toBeGreaterThan(0);
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Intent Mapping
+// ---------------------------------------------------------------------------
+
+describe('Intent to Flow mapping', () => {
+  it('should map BUILD to BUILD-flow', () => {
+    expect(INTENT_TO_FLOW.BUILD).toBe('BUILD-flow');
+  });
+
+  it('should map FIX to FIX-flow', () => {
+    expect(INTENT_TO_FLOW.FIX).toBe('FIX-flow');
+  });
+
+  it('should map DELIVER to DELIVER-flow', () => {
+    expect(INTENT_TO_FLOW.DELIVER).toBe('DELIVER-flow');
+  });
+
+  it('should have all 8 flows mapped', () => {
+    const flowIds = new Set(Object.values(INTENT_TO_FLOW));
+    expect(flowIds.size).toBeGreaterThanOrEqual(8);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Chain to Tool Name
+// ---------------------------------------------------------------------------
+
+describe('chainToToolName', () => {
+  it('should prefix with agentId and convert hyphens', () => {
+    expect(chainToToolName('vault-search', 'myagent')).toBe('myagent_vault_search');
+  });
+
+  it('should handle single-word chains', () => {
+    expect(chainToToolName('validate', 'test')).toBe('test_validate');
+  });
+});
+
+describe('chainToRequires', () => {
+  it('should detect vault requirement', () => {
+    expect(chainToRequires('vault-search')).toBe('vault');
+  });
+
+  it('should detect brain requirement', () => {
+    expect(chainToRequires('brain-recommend')).toBe('brain');
+  });
+
+  it('should detect designSystem requirement', () => {
+    expect(chainToRequires('component-search')).toBe('designSystem');
+  });
+
+  it('should return undefined for recommendation chains', () => {
+    expect(chainToRequires('recommend-style')).toBeUndefined();
+    expect(chainToRequires('get-stack-guidelines')).toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Step Pruning
+// ---------------------------------------------------------------------------
+
+describe('pruneSteps', () => {
+  it('should keep steps with no requirements', () => {
+    const steps = [
+      {
+        id: 's1',
+        name: 'Step 1',
+        tools: ['t1'],
+        parallel: false,
+        requires: [],
+        status: 'pending' as const,
+      },
+    ];
+    const probes = {
+      vault: false,
+      brain: false,
+      designSystem: false,
+      sessionStore: false,
+      projectRules: false,
+      active: true,
+    };
+    const { kept, skipped } = pruneSteps(steps, probes);
+    expect(kept.length).toBe(1);
+    expect(skipped.length).toBe(0);
+  });
+
+  it('should skip steps with unmet requirements', () => {
+    const steps = [
+      {
+        id: 's1',
+        name: 'Vault Step',
+        tools: ['t1'],
+        parallel: false,
+        requires: ['vault' as const],
+        status: 'pending' as const,
+      },
+      {
+        id: 's2',
+        name: 'No Req',
+        tools: ['t2'],
+        parallel: false,
+        requires: [],
+        status: 'pending' as const,
+      },
+    ];
+    const probes = {
+      vault: false,
+      brain: false,
+      designSystem: false,
+      sessionStore: false,
+      projectRules: false,
+      active: true,
+    };
+    const { kept, skipped } = pruneSteps(steps, probes);
+    expect(kept.length).toBe(1);
+    expect(kept[0].id).toBe('s2');
+    expect(skipped.length).toBe(1);
+    expect(skipped[0].reason).toContain('vault');
+  });
+
+  it('should keep steps when requirements are met', () => {
+    const steps = [
+      {
+        id: 's1',
+        name: 'Vault Step',
+        tools: ['t1'],
+        parallel: false,
+        requires: ['vault' as const],
+        status: 'pending' as const,
+      },
+    ];
+    const probes = {
+      vault: true,
+      brain: false,
+      designSystem: false,
+      sessionStore: false,
+      projectRules: false,
+      active: true,
+    };
+    const { kept } = pruneSteps(steps, probes);
+    expect(kept.length).toBe(1);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Gate Evaluator
+// ---------------------------------------------------------------------------
+
+describe('evaluateCondition', () => {
+  it('should evaluate equality', () => {
+    expect(evaluateCondition('count == 0', { count: 0 })).toBe(true);
+    expect(evaluateCondition('count == 0', { count: 5 })).toBe(false);
+  });
+
+  it('should evaluate inequality', () => {
+    expect(evaluateCondition('count != 0', { count: 5 })).toBe(true);
+  });
+
+  it('should evaluate greater than', () => {
+    expect(evaluateCondition('score >= 80', { score: 90 })).toBe(true);
+    expect(evaluateCondition('score >= 80', { score: 70 })).toBe(false);
+  });
+
+  it('should evaluate boolean', () => {
+    expect(evaluateCondition('pass == true', { pass: true })).toBe(true);
+  });
+
+  it('should evaluate truthy path', () => {
+    expect(evaluateCondition('result', { result: 'something' })).toBe(true);
+    expect(evaluateCondition('result', { result: '' })).toBe(false);
+  });
+});
+
+describe('extractScore', () => {
+  it('should extract score from data.score', () => {
+    expect(extractScore({ score: 85 })).toBe(85);
+  });
+
+  it('should extract from nested data', () => {
+    expect(extractScore({ validationScore: 92 })).toBe(92);
+  });
+
+  it('should return 0 if no score found', () => {
+    expect(extractScore({ unrelated: 'data' })).toBe(0);
+  });
+});
+
+describe('resolvePath', () => {
+  it('should resolve simple path', () => {
+    expect(resolvePath({ count: 5 }, 'count')).toBe(5);
+  });
+
+  it('should resolve dotted path', () => {
+    expect(resolvePath({ a: { b: 42 } }, 'a.b')).toBe(42);
+  });
+
+  it('should return undefined for missing path', () => {
+    expect(resolvePath({ a: 1 }, 'b')).toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Executor
+// ---------------------------------------------------------------------------
+
+describe('FlowExecutor', () => {
+  it('should execute a simple plan', async () => {
+    const dispatch = async (tool: string, _params: Record<string, unknown>) => ({
+      tool,
+      status: 'ok',
+      data: { result: true },
+    });
+
+    const executor = new FlowExecutor(dispatch);
+    const plan = {
+      planId: 'test-plan',
+      intent: 'BUILD',
+      flowId: 'BUILD-flow',
+      steps: [
+        {
+          id: 's1',
+          name: 'Step 1',
+          tools: ['tool1'],
+          parallel: false,
+          requires: [],
+          status: 'pending' as const,
+        },
+        {
+          id: 's2',
+          name: 'Step 2',
+          tools: ['tool2'],
+          parallel: false,
+          requires: [],
+          status: 'pending' as const,
+        },
+      ],
+      skipped: [],
+      epilogue: [],
+      warnings: [],
+      summary: 'Test plan',
+      estimatedTools: 2,
+      context: {
+        intent: 'BUILD',
+        probes: {
+          vault: true,
+          brain: false,
+          designSystem: false,
+          sessionStore: true,
+          projectRules: false,
+          active: true,
+        },
+        entities: { components: [], actions: [] },
+        projectPath: '/test',
+      },
+    };
+
+    const result = await executor.execute(plan);
+    expect(result.status).toBe('completed');
+    expect(result.stepsCompleted).toBe(2);
+    expect(result.toolsCalled).toContain('tool1');
+    expect(result.toolsCalled).toContain('tool2');
+  });
+
+  it('should handle STOP gate', async () => {
+    const dispatch = async (tool: string) => ({
+      tool,
+      status: 'ok',
+      data: { pass: false },
+    });
+
+    const executor = new FlowExecutor(dispatch);
+    const plan = {
+      planId: 'test-stop',
+      intent: 'DELIVER',
+      flowId: 'DELIVER-flow',
+      steps: [
+        {
+          id: 's1',
+          name: 'Gate Step',
+          tools: ['check'],
+          parallel: false,
+          requires: [],
+          gate: {
+            type: 'GATE',
+            condition: 'pass == true',
+            onFail: { action: 'STOP', message: 'Failed' },
+          },
+          status: 'pending' as const,
+        },
+        {
+          id: 's2',
+          name: 'After Gate',
+          tools: ['next'],
+          parallel: false,
+          requires: [],
+          status: 'pending' as const,
+        },
+      ],
+      skipped: [],
+      epilogue: [],
+      warnings: [],
+      summary: 'Test stop',
+      estimatedTools: 2,
+      context: {
+        intent: 'DELIVER',
+        probes: {
+          vault: true,
+          brain: false,
+          designSystem: false,
+          sessionStore: true,
+          projectRules: false,
+          active: true,
+        },
+        entities: { components: [], actions: [] },
+        projectPath: '/test',
+      },
+    };
+
+    const result = await executor.execute(plan);
+    expect(result.stepsCompleted).toBeLessThan(2);
+  });
+
+  it('should execute parallel steps', async () => {
+    const callOrder: string[] = [];
+    const dispatch = async (tool: string) => {
+      callOrder.push(tool);
+      return { tool, status: 'ok', data: {} };
+    };
+
+    const executor = new FlowExecutor(dispatch);
+    const plan = {
+      planId: 'test-parallel',
+      intent: 'BUILD',
+      flowId: 'BUILD-flow',
+      steps: [
+        {
+          id: 's1',
+          name: 'Parallel',
+          tools: ['a', 'b', 'c'],
+          parallel: true,
+          requires: [],
+          status: 'pending' as const,
+        },
+      ],
+      skipped: [],
+      epilogue: [],
+      warnings: [],
+      summary: 'Test parallel',
+      estimatedTools: 3,
+      context: {
+        intent: 'BUILD',
+        probes: {
+          vault: true,
+          brain: false,
+          designSystem: false,
+          sessionStore: true,
+          projectRules: false,
+          active: true,
+        },
+        entities: { components: [], actions: [] },
+        projectPath: '/test',
+      },
+    };
+
+    const result = await executor.execute(plan);
+    expect(result.toolsCalled.length).toBe(3);
+    expect(result.toolsCalled).toContain('a');
+    expect(result.toolsCalled).toContain('b');
+    expect(result.toolsCalled).toContain('c');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Context Router
+// ---------------------------------------------------------------------------
+
+import { detectContext, applyContextOverrides } from '../flows/context-router.js';
+import { flowStepsToPlanSteps } from '../flows/plan-builder.js';
+
+describe('detectContext', () => {
+  const emptyEntities = { components: [], actions: [] };
+
+  it('should find "small-component" context for button prompts', () => {
+    const contexts = detectContext('Build a submit button', emptyEntities);
+    expect(contexts).toContain('small-component');
+  });
+
+  it('should find "large-component" context for dashboard prompts', () => {
+    const contexts = detectContext('Create a dashboard layout', emptyEntities);
+    expect(contexts).toContain('large-component');
+  });
+
+  it('should find "form-component" context for input prompts', () => {
+    const contexts = detectContext('Build a select dropdown input', emptyEntities);
+    expect(contexts).toContain('form-component');
+  });
+
+  it('should find "container-component" context for modal prompts', () => {
+    const contexts = detectContext('Build a confirmation dialog', emptyEntities);
+    expect(contexts).toContain('container-component');
+  });
+
+  it('should find "design-fix" context for styling fix prompts', () => {
+    const contexts = detectContext('Fix the color tokens in the header', emptyEntities);
+    expect(contexts).toContain('design-fix');
+  });
+
+  it('should find "a11y-fix" context for accessibility fix prompts', () => {
+    const contexts = detectContext('Fix accessibility issues with ARIA labels', emptyEntities);
+    expect(contexts).toContain('a11y-fix');
+  });
+
+  it('should find "pr-review" context for pull request prompts', () => {
+    const contexts = detectContext('Review this PR diff', emptyEntities);
+    expect(contexts).toContain('pr-review');
+  });
+
+  it('should find "architecture-review" context for architecture prompts', () => {
+    const contexts = detectContext('Review the import structure', emptyEntities);
+    expect(contexts).toContain('architecture-review');
+  });
+
+  it('should return empty array for generic prompts', () => {
+    const contexts = detectContext('Do something useful', emptyEntities);
+    expect(contexts).toHaveLength(0);
+  });
+
+  it('should detect multiple contexts when prompt matches several', () => {
+    const contexts = detectContext(
+      'Build a form with input fields and a submit button',
+      emptyEntities,
+    );
+    expect(contexts).toContain('small-component');
+    expect(contexts).toContain('form-component');
+  });
+
+  it('should also match entity content', () => {
+    const contexts = detectContext('Build this', { components: ['Button'], actions: [] });
+    expect(contexts).toContain('small-component');
+  });
+});
+
+describe('applyContextOverrides', () => {
+  const agentId = 'test';
+
+  function loadBuildSteps(): PlanStep[] {
+    const flow = loadFlowById('BUILD-flow', FLOWS_DIR);
+    return flowStepsToPlanSteps(flow!, agentId);
+  }
+
+  function loadFixSteps(): PlanStep[] {
+    const flow = loadFlowById('FIX-flow', FLOWS_DIR);
+    return flowStepsToPlanSteps(flow!, agentId);
+  }
+
+  it('should skip get-architecture for small-component context', () => {
+    const steps = loadBuildSteps();
+    const result = applyContextOverrides(steps, ['small-component'], 'BUILD-flow', agentId);
+    const ids = result.map((s) => s.id);
+    expect(ids).not.toContain('get-architecture');
+  });
+
+  it('should inject button-semantics-check before validate for small-component', () => {
+    const steps = loadBuildSteps();
+    const result = applyContextOverrides(steps, ['small-component'], 'BUILD-flow', agentId);
+    const ids = result.map((s) => s.id);
+    expect(ids).toContain('ctx-before-validate');
+    const injected = result.find((s) => s.id === 'ctx-before-validate');
+    expect(injected!.tools).toContain('test_button_semantics_check');
+  });
+
+  it('should inject responsive-patterns before validate for large-component', () => {
+    const steps = loadBuildSteps();
+    const result = applyContextOverrides(steps, ['large-component'], 'BUILD-flow', agentId);
+    const ids = result.map((s) => s.id);
+    const beforeIdx = ids.indexOf('ctx-before-validate');
+    const validateIdx = ids.indexOf('validate');
+    expect(beforeIdx).toBeGreaterThan(-1);
+    expect(beforeIdx).toBeLessThan(validateIdx);
+    const injected = result.find((s) => s.id === 'ctx-before-validate');
+    expect(injected!.tools).toContain('test_responsive_patterns');
+  });
+
+  it('should inject performance-check after validate for large-component', () => {
+    const steps = loadBuildSteps();
+    const result = applyContextOverrides(steps, ['large-component'], 'BUILD-flow', agentId);
+    const ids = result.map((s) => s.id);
+    const afterIdx = ids.indexOf('ctx-after-validate');
+    const validateIdx = ids.indexOf('validate');
+    expect(afterIdx).toBeGreaterThan(validateIdx);
+    const injected = result.find((s) => s.id === 'ctx-after-validate');
+    expect(injected!.tools).toContain('test_performance_check');
+  });
+
+  it('should inject contrast-check and token-validation for design-fix context', () => {
+    const steps = loadFixSteps();
+    const result = applyContextOverrides(steps, ['design-fix'], 'FIX-flow', agentId);
+    const injected = result.find((s) => s.id === 'ctx-before-validate');
+    expect(injected).toBeDefined();
+    expect(injected!.tools).toContain('test_contrast_check');
+    expect(injected!.tools).toContain('test_token_validation');
+  });
+
+  it('should return steps unchanged for unknown flow', () => {
+    const steps = loadBuildSteps();
+    const result = applyContextOverrides(steps, ['small-component'], 'UNKNOWN-flow', agentId);
+    expect(result).toEqual(steps);
+  });
+
+  it('should return steps unchanged for empty contexts', () => {
+    const steps = loadBuildSteps();
+    const result = applyContextOverrides(steps, [], 'BUILD-flow', agentId);
+    expect(result).toEqual(steps);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Context Probes
+// ---------------------------------------------------------------------------
+
+describe('Context Probes', () => {
+  let runtime: AgentRuntime;
+
+  beforeEach(() => {
+    runtime = createAgentRuntime({ agentId: 'test-probes', vaultPath: ':memory:' });
+  });
+
+  afterEach(() => {
+    runtime.close();
+  });
+
+  it('should return probe results', async () => {
+    const probes = await runProbes(runtime, '/tmp/nonexistent');
+    expect(typeof probes.vault).toBe('boolean');
+    expect(typeof probes.brain).toBe('boolean');
+    expect(typeof probes.active).toBe('boolean');
+    expect(probes.active).toBe(true);
+  });
+
+  it('should detect vault as available', async () => {
+    const probes = await runProbes(runtime, '/tmp/nonexistent');
+    expect(probes.vault).toBe(true); // :memory: vault is connected
+  });
+});

package/src/__tests__/playbook-registry.test.ts

@@ -308,9 +308,9 @@ describe('mergePlaybooks', () => {
 });
 
 describe('getAllBuiltinPlaybooks', () => {
-  it('should return 6 built-in playbooks', () => {
+  it('should return all built-in playbooks', () => {
     const all = getAllBuiltinPlaybooks();
-    expect(all).toHaveLength(6);
+    expect(all.length).toBeGreaterThanOrEqual(6);
   });
 
   it('should all be generic tier', () => {

package/src/__tests__/playbook-seeder.test.ts

@@ -101,32 +101,32 @@ describe('seedDefaultPlaybooks', () => {
     vault.close();
   });
 
-  it('should seed 6 built-in playbooks into empty vault', () => {
+  it('should seed built-in playbooks into empty vault', () => {
     const result = seedDefaultPlaybooks(vault);
-    expect(result.seeded).toBe(6);
+    expect(result.seeded).toBeGreaterThanOrEqual(6);
     expect(result.skipped).toBe(0);
     expect(result.errors).toBe(0);
-    expect(result.details).toHaveLength(6);
+    expect(result.details.length).toBe(result.seeded);
     expect(result.details.every((d) => d.action === 'seeded')).toBe(true);
 
     // Verify they're in the vault
     const entries = vault.list({ type: 'playbook' });
-    expect(entries).toHaveLength(6);
+    expect(entries.length).toBe(result.seeded);
   });
 
   it('should be idempotent — second call skips all', () => {
-    seedDefaultPlaybooks(vault);
+    const first = seedDefaultPlaybooks(vault);
     const result = seedDefaultPlaybooks(vault);
 
     expect(result.seeded).toBe(0);
-    expect(result.skipped).toBe(6);
+    expect(result.skipped).toBe(first.seeded);
     expect(result.errors).toBe(0);
     expect(result.details.every((d) => d.action === 'skipped')).toBe(true);
   });
 
   it('should not overwrite user modifications', () => {
     // Seed first
-    seedDefaultPlaybooks(vault);
+    const first = seedDefaultPlaybooks(vault);
 
     // Simulate user modifying a playbook by removing and re-adding with different content
     const builtins = getAllBuiltinPlaybooks();
@@ -143,7 +143,7 @@ describe('seedDefaultPlaybooks', () => {
 
     // Re-seed should skip this one
     const result = seedDefaultPlaybooks(vault);
-    expect(result.skipped).toBe(6); // all exist, including user-modified one
+    expect(result.skipped).toBe(first.seeded); // all exist, including user-modified one
 
     // Verify user's version is preserved
     const entry = vault.get(builtins[0].id);