@soleri/core 9.0.3 → 9.2.0

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

@@ -1,249 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { PlaybookExecutor } from '../playbooks/playbook-executor.js';
-import { tddPlaybook } from '../playbooks/generic/tdd.js';
-import { brainstormingPlaybook } from '../playbooks/generic/brainstorming.js';
-import { mergePlaybooks } from '../playbooks/playbook-registry.js';
-import type { PlaybookDefinition } from '../playbooks/playbook-types.js';
-
-describe('PlaybookExecutor', () => {
-  let executor: PlaybookExecutor;
-
-  beforeEach(() => {
-    executor = new PlaybookExecutor();
-  });
-
-  // ─── start ──────────────────────────────────────────────────────
-
-  describe('start', () => {
-    it('should start a session from a PlaybookDefinition', () => {
-      const result = executor.start(tddPlaybook);
-
-      expect(result.sessionId).toMatch(/^pbk-/);
-      expect(result.label).toBe('Test-Driven Development');
-      expect(result.totalSteps).toBeGreaterThan(0);
-      expect(result.currentStep.index).toBe(0);
-      expect(result.currentStep.status).toBe('active');
-      expect(result.tools).toContain('search_intelligent');
-      expect(result.gates.length).toBeGreaterThan(0);
-    });
-
-    it('should start a session from a MergedPlaybook', () => {
-      const merged = mergePlaybooks(tddPlaybook, undefined);
-      const result = executor.start(merged);
-
-      expect(result.sessionId).toMatch(/^pbk-/);
-      expect(result.label).toBe('Test-Driven Development');
-      expect(result.totalSteps).toBeGreaterThan(0);
-    });
-
-    it('should parse numbered steps from playbook text', () => {
-      const result = executor.start(tddPlaybook);
-
-      // TDD playbook has 4 numbered steps
-      expect(result.totalSteps).toBe(4);
-      expect(result.currentStep.title).toContain('RED');
-    });
-
-    it('should track session in listSessions', () => {
-      executor.start(tddPlaybook);
-      executor.start(brainstormingPlaybook);
-
-      const sessions = executor.listSessions();
-      expect(sessions).toHaveLength(2);
-    });
-  });
-
-  // ─── step ───────────────────────────────────────────────────────
-
-  describe('step', () => {
-    it('should advance to the next step', () => {
-      const { sessionId } = executor.start(tddPlaybook);
-
-      const result = executor.step(sessionId, { output: 'Wrote failing test' });
-
-      expect('error' in result).toBe(false);
-      if ('error' in result) return;
-
-      expect(result.completedStep.status).toBe('done');
-      expect(result.completedStep.output).toBe('Wrote failing test');
-      expect(result.nextStep).not.toBeNull();
-      expect(result.nextStep!.status).toBe('active');
-      expect(result.progress.done).toBe(1);
-      expect(result.isComplete).toBe(false);
-    });
-
-    it('should mark step as skipped when skip=true', () => {
-      const { sessionId } = executor.start(tddPlaybook);
-
-      const result = executor.step(sessionId, { skip: true });
-
-      expect('error' in result).toBe(false);
-      if ('error' in result) return;
-
-      expect(result.completedStep.status).toBe('skipped');
-    });
-
-    it('should signal completion when all steps are done', () => {
-      const { sessionId, totalSteps } = executor.start(tddPlaybook);
-
-      let result;
-      for (let i = 0; i < totalSteps; i++) {
-        result = executor.step(sessionId, { output: `Step ${i + 1} done` });
-      }
-
-      expect(result).toBeDefined();
-      expect('error' in result!).toBe(false);
-      if ('error' in result!) return;
-
-      expect(result!.isComplete).toBe(true);
-      expect(result!.nextStep).toBeNull();
-      expect(result!.progress.done).toBe(totalSteps);
-    });
-
-    it('should return error for unknown session', () => {
-      const result = executor.step('nonexistent');
-      expect('error' in result).toBe(true);
-    });
-  });
-
-  // ─── complete ───────────────────────────────────────────────────
-
-  describe('complete', () => {
-    it('should complete a session with all gates passed', () => {
-      const { sessionId, totalSteps } = executor.start(tddPlaybook);
-
-      // Advance through all steps
-      for (let i = 0; i < totalSteps; i++) {
-        executor.step(sessionId);
-      }
-
-      const result = executor.complete(sessionId, {
-        gateResults: { 'tdd-red': true, 'tdd-green': true },
-      });
-
-      expect('error' in result).toBe(false);
-      if ('error' in result) return;
-
-      expect(result.status).toBe('completed');
-      expect(result.gatesPassed).toBe(true);
-      expect(result.unsatisfiedGates).toHaveLength(0);
-      expect(result.duration).toBeGreaterThanOrEqual(0);
-    });
-
-    it('should report unsatisfied gates', () => {
-      const { sessionId, totalSteps } = executor.start(tddPlaybook);
-
-      for (let i = 0; i < totalSteps; i++) {
-        executor.step(sessionId);
-      }
-
-      // Only pass one of two gates
-      const result = executor.complete(sessionId, {
-        gateResults: { 'tdd-red': true },
-      });
-
-      expect('error' in result).toBe(false);
-      if ('error' in result) return;
-
-      expect(result.gatesPassed).toBe(false);
-      expect(result.unsatisfiedGates.length).toBeGreaterThan(0);
-      expect(result.unsatisfiedGates[0]).toContain('tdd-green');
-    });
-
-    it('should abort a session', () => {
-      const { sessionId } = executor.start(tddPlaybook);
-
-      // Only do one step then abort
-      executor.step(sessionId);
-      const result = executor.complete(sessionId, { abort: true });
-
-      expect('error' in result).toBe(false);
-      if ('error' in result) return;
-
-      expect(result.status).toBe('aborted');
-    });
-
-    it('should remove session after completion', () => {
-      const { sessionId, totalSteps } = executor.start(tddPlaybook);
-
-      for (let i = 0; i < totalSteps; i++) {
-        executor.step(sessionId);
-      }
-
-      executor.complete(sessionId);
-
-      expect(executor.getSession(sessionId)).toBeUndefined();
-      expect(executor.listSessions()).toHaveLength(0);
-    });
-
-    it('should return error for unknown session', () => {
-      const result = executor.complete('nonexistent');
-      expect('error' in result).toBe(true);
-    });
-  });
-
-  // ─── getSession ─────────────────────────────────────────────────
-
-  describe('getSession', () => {
-    it('should return active session state', () => {
-      const { sessionId } = executor.start(tddPlaybook);
-
-      const session = executor.getSession(sessionId);
-      expect(session).toBeDefined();
-      expect(session!.status).toBe('active');
-      expect(session!.playbookId).toBe('generic-tdd');
-    });
-
-    it('should reflect step progress', () => {
-      const { sessionId } = executor.start(tddPlaybook);
-      executor.step(sessionId, { output: 'done' });
-
-      const session = executor.getSession(sessionId);
-      expect(session!.currentStepIndex).toBe(1);
-      expect(session!.steps[0].status).toBe('done');
-      expect(session!.steps[1].status).toBe('active');
-    });
-  });
-
-  // ─── edge cases ─────────────────────────────────────────────────
-
-  describe('edge cases', () => {
-    it('should handle playbook with no parseable steps', () => {
-      const minimal: PlaybookDefinition = {
-        id: 'test-minimal',
-        tier: 'generic',
-        title: 'Minimal',
-        trigger: 'test',
-        description: 'A minimal playbook',
-        steps: 'Just do the thing',
-        expectedOutcome: 'Done',
-        category: 'test',
-        tags: [],
-        matchIntents: ['BUILD'],
-        matchKeywords: [],
-        gates: [],
-        taskTemplates: [],
-        toolInjections: [],
-        verificationCriteria: [],
-      };
-
-      const result = executor.start(minimal);
-
-      // Falls back to a single step
-      expect(result.totalSteps).toBe(1);
-      expect(result.currentStep.title).toBe('Minimal');
-    });
-
-    it('should not allow stepping a completed session', () => {
-      const { sessionId, totalSteps } = executor.start(tddPlaybook);
-
-      for (let i = 0; i < totalSteps; i++) {
-        executor.step(sessionId);
-      }
-      executor.complete(sessionId);
-
-      const result = executor.step(sessionId);
-      expect('error' in result).toBe(true);
-    });
-  });
-});

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

@@ -1,326 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  scorePlaybook,
-  matchPlaybooks,
-  mergePlaybooks,
-  getBuiltinPlaybook,
-  getAllBuiltinPlaybooks,
-} from '../playbooks/playbook-registry.js';
-import type { PlaybookDefinition } from '../playbooks/playbook-types.js';
-
-describe('scorePlaybook', () => {
-  it('should add 10 for intent match', () => {
-    const pb = getBuiltinPlaybook('generic-tdd')!;
-    expect(scorePlaybook(pb, 'BUILD', '')).toBe(10);
-  });
-
-  it('should add 5 per keyword match', () => {
-    const pb = getBuiltinPlaybook('generic-tdd')!;
-    // 'implement' and 'build' are keywords
-    expect(scorePlaybook(pb, undefined, 'implement and build')).toBe(10);
-  });
-
-  it('should combine intent + keyword scores', () => {
-    const pb = getBuiltinPlaybook('generic-tdd')!;
-    // BUILD intent (10) + 'implement' (5) + 'feature' (5) = 20
-    expect(scorePlaybook(pb, 'BUILD', 'implement a feature')).toBe(20);
-  });
-
-  it('should return 0 for unrelated content', () => {
-    const pb = getBuiltinPlaybook('generic-tdd')!;
-    expect(scorePlaybook(pb, 'REVIEW', 'nothing related here')).toBe(0);
-  });
-
-  it('should be case-insensitive for keywords', () => {
-    const pb = getBuiltinPlaybook('generic-systematic-debugging')!;
-    expect(scorePlaybook(pb, undefined, 'FIX THE BUG')).toBeGreaterThan(0);
-  });
-});
-
-describe('matchPlaybooks', () => {
-  it('should match TDD for BUILD intent with "implement"', () => {
-    const result = matchPlaybooks('BUILD', 'implement the new feature');
-    expect(result.playbook).not.toBeNull();
-    expect(result.genericMatch?.id).toBe('generic-tdd');
-  });
-
-  it('should match systematic-debugging for FIX intent', () => {
-    const result = matchPlaybooks('FIX', 'fix the broken authentication bug');
-    expect(result.playbook).not.toBeNull();
-    expect(result.genericMatch?.id).toBe('generic-systematic-debugging');
-  });
-
-  it('should match brainstorming for PLAN intent', () => {
-    const result = matchPlaybooks('PLAN', 'design a new architecture from scratch');
-    expect(result.playbook).not.toBeNull();
-    expect(result.genericMatch?.id).toBe('generic-brainstorming');
-  });
-
-  it('should match code-review for REVIEW intent', () => {
-    const result = matchPlaybooks('REVIEW', 'review this pull request');
-    expect(result.playbook).not.toBeNull();
-    expect(result.genericMatch?.id).toBe('generic-code-review');
-  });
-
-  it('should return null playbook for unrelated text with no intent', () => {
-    const result = matchPlaybooks(undefined, 'random unrelated text xyz');
-    expect(result.playbook).toBeNull();
-  });
-
-  it('should prefer vault playbooks over builtins', () => {
-    const vaultPlaybook: PlaybookDefinition = {
-      id: 'custom-tdd',
-      tier: 'generic',
-      title: 'Custom TDD',
-      trigger: 'Custom TDD trigger',
-      description: 'Custom TDD description',
-      steps: 'Custom steps',
-      expectedOutcome: 'Custom outcome',
-      category: 'methodology',
-      tags: ['tdd'],
-      matchIntents: ['BUILD', 'FIX'],
-      matchKeywords: [
-        'implement',
-        'build',
-        'create',
-        'add',
-        'fix',
-        'refactor',
-        'feature',
-        'code',
-        'custom-unique-keyword',
-      ],
-      gates: [],
-      taskTemplates: [],
-      toolInjections: [],
-      verificationCriteria: [],
-    };
-
-    // The vault playbook should score higher because it has more keyword matches
-    const result = matchPlaybooks(
-      'BUILD',
-      'implement and build and create with custom-unique-keyword',
-      [vaultPlaybook],
-    );
-    expect(result.genericMatch?.id).toBe('custom-tdd');
-  });
-
-  it('should resolve domain extends to correct generic', () => {
-    const domainPlaybook: PlaybookDefinition = {
-      id: 'domain-component-build',
-      tier: 'domain',
-      title: 'Component Build',
-      trigger: 'Build a component',
-      description: 'Build with design tokens',
-      steps: 'Domain steps',
-      expectedOutcome: 'Component built with tokens',
-      extends: 'generic-tdd',
-      category: 'design-system',
-      tags: ['component', 'build'],
-      matchIntents: ['BUILD'],
-      matchKeywords: ['component', 'build'],
-      gates: [{ phase: 'completion', requirement: 'Tokens validated', checkType: 'token-check' }],
-      taskTemplates: [],
-      toolInjections: ['validate_tokens'],
-      verificationCriteria: ['All tokens are semantic'],
-    };
-
-    const result = matchPlaybooks('BUILD', 'build a component', [domainPlaybook]);
-    expect(result.domainMatch?.id).toBe('domain-component-build');
-    // Should resolve the extended generic
-    expect(result.genericMatch?.id).toBe('generic-tdd');
-    expect(result.playbook?.label).toContain('extends');
-  });
-});
-
-describe('mergePlaybooks', () => {
-  it('should concatenate gates (generic first, then domain)', () => {
-    const generic = getBuiltinPlaybook('generic-tdd')!;
-    const domain: PlaybookDefinition = {
-      id: 'domain-test',
-      tier: 'domain',
-      title: 'Domain Test',
-      trigger: '',
-      description: '',
-      steps: '',
-      expectedOutcome: '',
-      category: 'test',
-      tags: [],
-      matchIntents: [],
-      matchKeywords: [],
-      gates: [{ phase: 'completion', requirement: 'Domain gate', checkType: 'domain-gate' }],
-      taskTemplates: [],
-      toolInjections: [],
-      verificationCriteria: [],
-    };
-
-    const merged = mergePlaybooks(generic, domain);
-    expect(merged.mergedGates.length).toBe(generic.gates.length + 1);
-    expect(merged.mergedGates[0]).toEqual(generic.gates[0]);
-    expect(merged.mergedGates[merged.mergedGates.length - 1].checkType).toBe('domain-gate');
-  });
-
-  it('should override tasks at same order+taskType', () => {
-    const generic: PlaybookDefinition = {
-      id: 'g',
-      tier: 'generic',
-      title: 'G',
-      trigger: '',
-      description: '',
-      steps: '',
-      expectedOutcome: '',
-      category: 'test',
-      tags: [],
-      matchIntents: [],
-      matchKeywords: [],
-      gates: [],
-      taskTemplates: [
-        {
-          taskType: 'test',
-          titleTemplate: 'Generic test',
-          acceptanceCriteria: ['generic'],
-          tools: [],
-          order: 'before-implementation',
-        },
-      ],
-      toolInjections: [],
-      verificationCriteria: [],
-    };
-
-    const domain: PlaybookDefinition = {
-      ...generic,
-      id: 'd',
-      tier: 'domain',
-      title: 'D',
-      taskTemplates: [
-        {
-          taskType: 'test',
-          titleTemplate: 'Domain test',
-          acceptanceCriteria: ['domain'],
-          tools: ['custom_tool'],
-          order: 'before-implementation',
-        },
-      ],
-    };
-
-    const merged = mergePlaybooks(generic, domain);
-    // Domain should override the same order+taskType
-    expect(merged.mergedTasks).toHaveLength(1);
-    expect(merged.mergedTasks[0].titleTemplate).toBe('Domain test');
-  });
-
-  it('should deduplicate tools', () => {
-    const generic: PlaybookDefinition = {
-      id: 'g',
-      tier: 'generic',
-      title: 'G',
-      trigger: '',
-      description: '',
-      steps: '',
-      expectedOutcome: '',
-      category: 'test',
-      tags: [],
-      matchIntents: [],
-      matchKeywords: [],
-      gates: [],
-      taskTemplates: [],
-      toolInjections: ['search_intelligent', 'shared_tool'],
-      verificationCriteria: [],
-    };
-
-    const domain: PlaybookDefinition = {
-      ...generic,
-      id: 'd',
-      tier: 'domain',
-      title: 'D',
-      toolInjections: ['shared_tool', 'domain_tool'],
-    };
-
-    const merged = mergePlaybooks(generic, domain);
-    expect(merged.mergedTools).toHaveLength(3);
-    expect(merged.mergedTools).toContain('search_intelligent');
-    expect(merged.mergedTools).toContain('shared_tool');
-    expect(merged.mergedTools).toContain('domain_tool');
-  });
-
-  it('should deduplicate verification criteria', () => {
-    const generic: PlaybookDefinition = {
-      id: 'g',
-      tier: 'generic',
-      title: 'G',
-      trigger: '',
-      description: '',
-      steps: '',
-      expectedOutcome: '',
-      category: 'test',
-      tags: [],
-      matchIntents: [],
-      matchKeywords: [],
-      gates: [],
-      taskTemplates: [],
-      toolInjections: [],
-      verificationCriteria: ['Tests pass', 'Build succeeds'],
-    };
-
-    const domain: PlaybookDefinition = {
-      ...generic,
-      id: 'd',
-      tier: 'domain',
-      title: 'D',
-      verificationCriteria: ['Tests pass', 'Tokens validated'],
-    };
-
-    const merged = mergePlaybooks(generic, domain);
-    expect(merged.mergedVerification).toHaveLength(3);
-  });
-
-  it('should build correct label for generic + domain', () => {
-    const generic = getBuiltinPlaybook('generic-tdd')!;
-    const domain: PlaybookDefinition = {
-      id: 'd',
-      tier: 'domain',
-      title: 'Component Build',
-      trigger: '',
-      description: '',
-      steps: '',
-      expectedOutcome: '',
-      category: 'test',
-      tags: [],
-      matchIntents: [],
-      matchKeywords: [],
-      gates: [],
-      taskTemplates: [],
-      toolInjections: [],
-      verificationCriteria: [],
-    };
-
-    const merged = mergePlaybooks(generic, domain);
-    expect(merged.label).toBe('Component Build (extends Test-Driven Development)');
-  });
-
-  it('should handle generic-only merge', () => {
-    const generic = getBuiltinPlaybook('generic-tdd')!;
-    const merged = mergePlaybooks(generic, undefined);
-    expect(merged.label).toBe(generic.title);
-    expect(merged.generic).toBe(generic);
-    expect(merged.domain).toBeUndefined();
-  });
-});
-
-describe('getAllBuiltinPlaybooks', () => {
-  it('should return all built-in playbooks', () => {
-    const all = getAllBuiltinPlaybooks();
-    expect(all.length).toBeGreaterThanOrEqual(6);
-  });
-
-  it('should all be generic tier', () => {
-    const all = getAllBuiltinPlaybooks();
-    expect(all.every((p) => p.tier === 'generic')).toBe(true);
-  });
-
-  it('should have unique IDs', () => {
-    const all = getAllBuiltinPlaybooks();
-    const ids = all.map((p) => p.id);
-    expect(new Set(ids).size).toBe(ids.length);
-  });
-});