@soleri/forge 3.0.0 → 4.0.0

package/src/templates/test-loader.ts

@@ -1,146 +0,0 @@
-/**
- * Generates intelligence loader test file for a new agent.
- * Tests cover: load valid JSON bundles, skip invalid entries, missing dir, malformed JSON.
- */
-export function generateLoaderTest(): string {
-  return LOADER_TEST_TEMPLATE;
-}
-
-const LOADER_TEST_TEMPLATE = [
-  "import { describe, it, expect, beforeEach, afterEach } from 'vitest';",
-  "import { mkdirSync, rmSync, writeFileSync } from 'node:fs';",
-  "import { join } from 'node:path';",
-  "import { tmpdir } from 'node:os';",
-  "import { loadIntelligenceData } from '../intelligence/loader.js';",
-  '',
-  "describe('Intelligence Loader', () => {",
-  '  let tempDir: string;',
-  '',
-  '  beforeEach(() => {',
-  '    tempDir = join(tmpdir(), `loader-test-${Date.now()}`);',
-  '    mkdirSync(tempDir, { recursive: true });',
-  '  });',
-  '',
-  '  afterEach(() => {',
-  '    rmSync(tempDir, { recursive: true, force: true });',
-  '  });',
-  '',
-  "  it('should load valid entries from JSON files', () => {",
-  "    writeFileSync(join(tempDir, 'test-domain.json'), JSON.stringify({",
-  "      domain: 'test-domain',",
-  "      version: '1.0.0',",
-  '      entries: [',
-  '        {',
-  "          id: 'entry-1',",
-  "          type: 'pattern',",
-  "          domain: 'test-domain',",
-  "          title: 'Test Pattern',",
-  "          severity: 'warning',",
-  "          description: 'A test pattern.',",
-  "          tags: ['test'],",
-  '        },',
-  '      ],',
-  '    }));',
-  '',
-  '    const entries = loadIntelligenceData(tempDir);',
-  '    expect(entries).toHaveLength(1);',
-  "    expect(entries[0].id).toBe('entry-1');",
-  "    expect(entries[0].domain).toBe('test-domain');",
-  '  });',
-  '',
-  "  it('should load entries from multiple files', () => {",
-  "    for (const domain of ['api', 'db']) {",
-  '      writeFileSync(join(tempDir, `${domain}.json`), JSON.stringify({',
-  '        domain,',
-  "        version: '1.0.0',",
-  '        entries: [',
-  "          { id: `${domain}-1`, type: 'pattern', domain, title: 'P1', severity: 'warning', description: 'Desc', tags: ['t'] },",
-  "          { id: `${domain}-2`, type: 'rule', domain, title: 'R1', severity: 'critical', description: 'Desc', tags: ['t'] },",
-  '        ],',
-  '      }));',
-  '    }',
-  '',
-  '    const entries = loadIntelligenceData(tempDir);',
-  '    expect(entries).toHaveLength(4);',
-  '  });',
-  '',
-  "  it('should skip entries with missing required fields', () => {",
-  "    writeFileSync(join(tempDir, 'bad.json'), JSON.stringify({",
-  "      domain: 'bad',",
-  "      version: '1.0.0',",
-  '      entries: [',
-  "        { id: '', type: 'pattern', domain: 'bad', title: 'Missing ID', severity: 'warning', description: 'D', tags: ['t'] },",
-  "        { id: 'ok-1', type: 'pattern', domain: 'bad', title: 'Valid', severity: 'warning', description: 'D', tags: ['t'] },",
-  "        { type: 'pattern', domain: 'bad', title: 'No ID', severity: 'warning', description: 'D', tags: ['t'] },",
-  '      ],',
-  '    }));',
-  '',
-  '    const entries = loadIntelligenceData(tempDir);',
-  '    expect(entries).toHaveLength(1);',
-  "    expect(entries[0].id).toBe('ok-1');",
-  '  });',
-  '',
-  "  it('should skip entries with invalid type', () => {",
-  "    writeFileSync(join(tempDir, 'invalid-type.json'), JSON.stringify({",
-  "      domain: 'x',",
-  "      version: '1.0.0',",
-  '      entries: [',
-  "        { id: 'bad-type', type: 'unknown', domain: 'x', title: 'T', severity: 'warning', description: 'D', tags: ['t'] },",
-  '      ],',
-  '    }));',
-  '',
-  '    const entries = loadIntelligenceData(tempDir);',
-  '    expect(entries).toHaveLength(0);',
-  '  });',
-  '',
-  "  it('should accept entries with empty tags', () => {",
-  "    writeFileSync(join(tempDir, 'no-tags.json'), JSON.stringify({",
-  "      domain: 'x',",
-  "      version: '1.0.0',",
-  '      entries: [',
-  "        { id: 'no-tags', type: 'pattern', domain: 'x', title: 'T', severity: 'warning', description: 'D', tags: [] },",
-  '      ],',
-  '    }));',
-  '',
-  '    const entries = loadIntelligenceData(tempDir);',
-  '    expect(entries).toHaveLength(1);',
-  '    expect(entries[0].tags).toEqual([]);',
-  '  });',
-  '',
-  "  it('should return empty for nonexistent directory', () => {",
-  "    const entries = loadIntelligenceData('/nonexistent/path');",
-  '    expect(entries).toEqual([]);',
-  '  });',
-  '',
-  "  it('should skip malformed JSON files gracefully', () => {",
-  "    writeFileSync(join(tempDir, 'broken.json'), '{ not valid json }}}');",
-  "    writeFileSync(join(tempDir, 'valid.json'), JSON.stringify({",
-  "      domain: 'good',",
-  "      version: '1.0.0',",
-  '      entries: [',
-  "        { id: 'v1', type: 'rule', domain: 'good', title: 'Good', severity: 'suggestion', description: 'Works', tags: ['ok'] },",
-  '      ],',
-  '    }));',
-  '',
-  '    const entries = loadIntelligenceData(tempDir);',
-  '    expect(entries).toHaveLength(1);',
-  "    expect(entries[0].id).toBe('v1');",
-  '  });',
-  '',
-  "  it('should skip files without entries array', () => {",
-  "    writeFileSync(join(tempDir, 'no-entries.json'), JSON.stringify({",
-  "      domain: 'incomplete',",
-  "      version: '1.0.0',",
-  '    }));',
-  '',
-  '    const entries = loadIntelligenceData(tempDir);',
-  '    expect(entries).toEqual([]);',
-  '  });',
-  '',
-  "  it('should ignore non-JSON files', () => {",
-  "    writeFileSync(join(tempDir, 'readme.txt'), 'Not a JSON file');",
-  '    const entries = loadIntelligenceData(tempDir);',
-  '    expect(entries).toEqual([]);',
-  '  });',
-  '});',
-].join('\n');

package/src/templates/test-planner.ts

@@ -1,271 +0,0 @@
-/**
- * Generates src/__tests__/planner.test.ts for a new agent.
- * Tests the Planner state machine: create, approve, execute, update tasks, complete.
- */
-export function generatePlannerTest(): string {
-  return PLANNER_TEST_TEMPLATE;
-}
-
-const PLANNER_TEST_TEMPLATE = [
-  "import { describe, it, expect, beforeEach, afterEach } from 'vitest';",
-  "import { Planner } from '../planning/planner.js';",
-  "import { mkdirSync, rmSync } from 'node:fs';",
-  "import { join } from 'node:path';",
-  "import { tmpdir } from 'node:os';",
-  '',
-  "describe('Planner', () => {",
-  '  let tempDir: string;',
-  '  let planner: Planner;',
-  '',
-  '  beforeEach(() => {',
-  '    tempDir = join(tmpdir(), `planner-test-${Date.now()}`);',
-  '    mkdirSync(tempDir, { recursive: true });',
-  "    planner = new Planner(join(tempDir, 'plans.json'));",
-  '  });',
-  '',
-  '  afterEach(() => {',
-  '    rmSync(tempDir, { recursive: true, force: true });',
-  '  });',
-  '',
-  "  describe('create', () => {",
-  "    it('should create a plan in draft status', () => {",
-  "      const plan = planner.create({ objective: 'Add auth', scope: 'backend' });",
-  '      expect(plan.id).toMatch(/^plan-/);',
-  "      expect(plan.status).toBe('draft');",
-  "      expect(plan.objective).toBe('Add auth');",
-  "      expect(plan.scope).toBe('backend');",
-  '    });',
-  '',
-  "    it('should create a plan with tasks', () => {",
-  '      const plan = planner.create({',
-  "        objective: 'Add auth',",
-  "        scope: 'backend',",
-  '        tasks: [',
-  "          { title: 'Add JWT', description: 'Implement JWT signing' },",
-  "          { title: 'Add middleware', description: 'Auth middleware' },",
-  '        ],',
-  '      });',
-  '      expect(plan.tasks).toHaveLength(2);',
-  "      expect(plan.tasks[0].id).toBe('task-1');",
-  "      expect(plan.tasks[0].status).toBe('pending');",
-  "      expect(plan.tasks[1].id).toBe('task-2');",
-  '    });',
-  '',
-  "    it('should create a plan with decisions', () => {",
-  '      const plan = planner.create({',
-  "        objective: 'Add caching',",
-  "        scope: 'api',",
-  "        decisions: ['Use Redis', 'TTL of 5 minutes'],",
-  '      });',
-  "      expect(plan.decisions).toEqual(['Use Redis', 'TTL of 5 minutes']);",
-  '    });',
-  '',
-  "    it('should persist plan to disk', () => {",
-  "      planner.create({ objective: 'Test persistence', scope: 'test' });",
-  "      const planner2 = new Planner(join(tempDir, 'plans.json'));",
-  '      expect(planner2.list()).toHaveLength(1);',
-  '    });',
-  '  });',
-  '',
-  "  describe('get', () => {",
-  "    it('should return a plan by id', () => {",
-  "      const created = planner.create({ objective: 'Find me', scope: 'test' });",
-  '      const found = planner.get(created.id);',
-  '      expect(found).not.toBeNull();',
-  "      expect(found!.objective).toBe('Find me');",
-  '    });',
-  '',
-  "    it('should return null for unknown id', () => {",
-  "      expect(planner.get('plan-nonexistent')).toBeNull();",
-  '    });',
-  '  });',
-  '',
-  "  describe('list', () => {",
-  "    it('should list all plans', () => {",
-  "      planner.create({ objective: 'Plan A', scope: 'a' });",
-  "      planner.create({ objective: 'Plan B', scope: 'b' });",
-  '      expect(planner.list()).toHaveLength(2);',
-  '    });',
-  '',
-  "    it('should return empty array when no plans', () => {",
-  '      expect(planner.list()).toEqual([]);',
-  '    });',
-  '  });',
-  '',
-  "  describe('approve', () => {",
-  "    it('should transition draft to approved', () => {",
-  "      const plan = planner.create({ objective: 'Approve me', scope: 'test' });",
-  '      const approved = planner.approve(plan.id);',
-  "      expect(approved.status).toBe('approved');",
-  '    });',
-  '',
-  "    it('should throw when approving non-draft plan', () => {",
-  "      const plan = planner.create({ objective: 'Already approved', scope: 'test' });",
-  '      planner.approve(plan.id);',
-  "      expect(() => planner.approve(plan.id)).toThrow('must be');",
-  '    });',
-  '',
-  "    it('should throw for unknown plan', () => {",
-  "      expect(() => planner.approve('plan-xxx')).toThrow('not found');",
-  '    });',
-  '  });',
-  '',
-  "  describe('startExecution', () => {",
-  "    it('should transition approved to executing', () => {",
-  "      const plan = planner.create({ objective: 'Execute me', scope: 'test' });",
-  '      planner.approve(plan.id);',
-  '      const executing = planner.startExecution(plan.id);',
-  "      expect(executing.status).toBe('executing');",
-  '    });',
-  '',
-  "    it('should throw when executing non-approved plan', () => {",
-  "      const plan = planner.create({ objective: 'Not approved', scope: 'test' });",
-  "      expect(() => planner.startExecution(plan.id)).toThrow('must be');",
-  '    });',
-  '  });',
-  '',
-  "  describe('updateTask', () => {",
-  "    it('should update task status on executing plan', () => {",
-  '      const plan = planner.create({',
-  "        objective: 'Task test',",
-  "        scope: 'test',",
-  "        tasks: [{ title: 'Task 1', description: 'Do thing' }],",
-  '      });',
-  '      planner.approve(plan.id);',
-  '      planner.startExecution(plan.id);',
-  "      const updated = planner.updateTask(plan.id, 'task-1', 'in_progress');",
-  "      expect(updated.tasks[0].status).toBe('in_progress');",
-  '    });',
-  '',
-  "    it('should support all task statuses', () => {",
-  '      const plan = planner.create({',
-  "        objective: 'Status test',",
-  "        scope: 'test',",
-  '        tasks: [',
-  "          { title: 'T1', description: 'd' },",
-  "          { title: 'T2', description: 'd' },",
-  "          { title: 'T3', description: 'd' },",
-  "          { title: 'T4', description: 'd' },",
-  "          { title: 'T5', description: 'd' },",
-  '        ],',
-  '      });',
-  '      planner.approve(plan.id);',
-  '      planner.startExecution(plan.id);',
-  "      planner.updateTask(plan.id, 'task-1', 'completed');",
-  "      planner.updateTask(plan.id, 'task-2', 'skipped');",
-  "      planner.updateTask(plan.id, 'task-3', 'failed');",
-  "      planner.updateTask(plan.id, 'task-4', 'in_progress');",
-  '      const result = planner.get(plan.id)!;',
-  "      expect(result.tasks[0].status).toBe('completed');",
-  "      expect(result.tasks[1].status).toBe('skipped');",
-  "      expect(result.tasks[2].status).toBe('failed');",
-  "      expect(result.tasks[3].status).toBe('in_progress');",
-  "      expect(result.tasks[4].status).toBe('pending');",
-  '    });',
-  '',
-  "    it('should throw when updating tasks on non-executing plan', () => {",
-  '      const plan = planner.create({',
-  "        objective: 'Not executing',",
-  "        scope: 'test',",
-  "        tasks: [{ title: 'T1', description: 'd' }],",
-  '      });',
-  "      expect(() => planner.updateTask(plan.id, 'task-1', 'completed')).toThrow('must be');",
-  '    });',
-  '',
-  "    it('should throw for unknown task', () => {",
-  '      const plan = planner.create({',
-  "        objective: 'Unknown task',",
-  "        scope: 'test',",
-  "        tasks: [{ title: 'T1', description: 'd' }],",
-  '      });',
-  '      planner.approve(plan.id);',
-  '      planner.startExecution(plan.id);',
-  "      expect(() => planner.updateTask(plan.id, 'task-99', 'completed')).toThrow('not found');",
-  '    });',
-  '  });',
-  '',
-  "  describe('complete', () => {",
-  "    it('should transition executing to completed', () => {",
-  "      const plan = planner.create({ objective: 'Complete me', scope: 'test' });",
-  '      planner.approve(plan.id);',
-  '      planner.startExecution(plan.id);',
-  '      const completed = planner.complete(plan.id);',
-  "      expect(completed.status).toBe('completed');",
-  '    });',
-  '',
-  "    it('should throw when completing non-executing plan', () => {",
-  "      const plan = planner.create({ objective: 'Not executing', scope: 'test' });",
-  "      expect(() => planner.complete(plan.id)).toThrow('must be');",
-  '    });',
-  '  });',
-  '',
-  "  describe('getExecuting', () => {",
-  "    it('should return only executing plans', () => {",
-  "      const p1 = planner.create({ objective: 'Executing', scope: 'a' });",
-  "      planner.create({ objective: 'Draft', scope: 'b' });",
-  '      planner.approve(p1.id);',
-  '      planner.startExecution(p1.id);',
-  '      const executing = planner.getExecuting();',
-  '      expect(executing).toHaveLength(1);',
-  "      expect(executing[0].objective).toBe('Executing');",
-  '    });',
-  '',
-  "    it('should return empty when nothing is executing', () => {",
-  "      planner.create({ objective: 'Draft only', scope: 'test' });",
-  '      expect(planner.getExecuting()).toEqual([]);',
-  '    });',
-  '  });',
-  '',
-  "  describe('getActive', () => {",
-  "    it('should return draft, approved, and executing plans', () => {",
-  "      const p1 = planner.create({ objective: 'Draft', scope: 'a' });",
-  "      const p2 = planner.create({ objective: 'Approved', scope: 'b' });",
-  "      const p3 = planner.create({ objective: 'Executing', scope: 'c' });",
-  "      const p4 = planner.create({ objective: 'Completed', scope: 'd' });",
-  '      planner.approve(p2.id);',
-  '      planner.approve(p3.id);',
-  '      planner.startExecution(p3.id);',
-  '      planner.approve(p4.id);',
-  '      planner.startExecution(p4.id);',
-  '      planner.complete(p4.id);',
-  '      const active = planner.getActive();',
-  '      expect(active).toHaveLength(3);',
-  "      expect(active.map((p) => p.status).sort()).toEqual(['approved', 'draft', 'executing']);",
-  '    });',
-  '  });',
-  '',
-  "  describe('full lifecycle', () => {",
-  "    it('should support draft → approved → executing → completed with tasks', () => {",
-  '      const plan = planner.create({',
-  "        objective: 'Full lifecycle test',",
-  "        scope: 'integration',",
-  "        decisions: ['Use TDD'],",
-  '        tasks: [',
-  "          { title: 'Write tests', description: 'Write failing tests first' },",
-  "          { title: 'Implement', description: 'Make tests pass' },",
-  "          { title: 'Refactor', description: 'Clean up' },",
-  '        ],',
-  '      });',
-  "      expect(plan.status).toBe('draft');",
-  '',
-  '      planner.approve(plan.id);',
-  "      expect(planner.get(plan.id)!.status).toBe('approved');",
-  '',
-  '      planner.startExecution(plan.id);',
-  "      expect(planner.get(plan.id)!.status).toBe('executing');",
-  '',
-  "      planner.updateTask(plan.id, 'task-1', 'in_progress');",
-  "      planner.updateTask(plan.id, 'task-1', 'completed');",
-  "      planner.updateTask(plan.id, 'task-2', 'in_progress');",
-  "      planner.updateTask(plan.id, 'task-2', 'completed');",
-  "      planner.updateTask(plan.id, 'task-3', 'skipped');",
-  '',
-  '      const final = planner.complete(plan.id);',
-  "      expect(final.status).toBe('completed');",
-  "      expect(final.tasks[0].status).toBe('completed');",
-  "      expect(final.tasks[1].status).toBe('completed');",
-  "      expect(final.tasks[2].status).toBe('skipped');",
-  '    });',
-  '  });',
-  '});',
-].join('\n');