@soleri/forge 0.0.1 → 4.0.0

package/dist/templates/test-loader.js

@@ -0,0 +1,146 @@
+/**
+ * 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() {
+    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');
+//# sourceMappingURL=test-loader.js.map

package/dist/templates/test-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-loader.js","sourceRoot":"","sources":["../../src/templates/test-loader.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,UAAU,kBAAkB;IAChC,OAAO,oBAAoB,CAAC;AAC9B,CAAC;AAED,MAAM,oBAAoB,GAAG;IAC3B,uEAAuE;IACvE,6DAA6D;IAC7D,mCAAmC;IACnC,mCAAmC;IACnC,mEAAmE;IACnE,EAAE;IACF,yCAAyC;IACzC,wBAAwB;IACxB,EAAE;IACF,sBAAsB;IACtB,4DAA4D;IAC5D,8CAA8C;IAC9C,OAAO;IACP,EAAE;IACF,qBAAqB;IACrB,wDAAwD;IACxD,OAAO;IACP,EAAE;IACF,2DAA2D;IAC3D,uEAAuE;IACvE,8BAA8B;IAC9B,yBAAyB;IACzB,kBAAkB;IAClB,WAAW;IACX,0BAA0B;IAC1B,4BAA4B;IAC5B,kCAAkC;IAClC,kCAAkC;IAClC,gCAAgC;IAChC,2CAA2C;IAC3C,2BAA2B;IAC3B,YAAY;IACZ,UAAU;IACV,UAAU;IACV,EAAE;IACF,oDAAoD;IACpD,sCAAsC;IACtC,4CAA4C;IAC5C,oDAAoD;IACpD,OAAO;IACP,EAAE;IACF,yDAAyD;IACzD,2CAA2C;IAC3C,uEAAuE;IACvE,iBAAiB;IACjB,2BAA2B;IAC3B,oBAAoB;IACpB,+HAA+H;IAC/H,6HAA6H;IAC7H,YAAY;IACZ,YAAY;IACZ,OAAO;IACP,EAAE;IACF,oDAAoD;IACpD,sCAAsC;IACtC,OAAO;IACP,EAAE;IACF,kEAAkE;IAClE,+DAA+D;IAC/D,sBAAsB;IACtB,yBAAyB;IACzB,kBAAkB;IAClB,8HAA8H;IAC9H,6HAA6H;IAC7H,iHAAiH;IACjH,UAAU;IACV,UAAU;IACV,EAAE;IACF,oDAAoD;IACpD,sCAAsC;IACtC,yCAAyC;IACzC,OAAO;IACP,EAAE;IACF,uDAAuD;IACvD,wEAAwE;IACxE,oBAAoB;IACpB,yBAAyB;IACzB,kBAAkB;IAClB,2HAA2H;IAC3H,UAAU;IACV,UAAU;IACV,EAAE;IACF,oDAAoD;IACpD,sCAAsC;IACtC,OAAO;IACP,EAAE;IACF,uDAAuD;IACvD,mEAAmE;IACnE,oBAAoB;IACpB,yBAAyB;IACzB,kBAAkB;IAClB,uHAAuH;IACvH,UAAU;IACV,UAAU;IACV,EAAE;IACF,oDAAoD;IACpD,sCAAsC;IACtC,0CAA0C;IAC1C,OAAO;IACP,EAAE;IACF,+DAA+D;IAC/D,gEAAgE;IAChE,kCAAkC;IAClC,OAAO;IACP,EAAE;IACF,6DAA6D;IAC7D,0EAA0E;IAC1E,iEAAiE;IACjE,uBAAuB;IACvB,yBAAyB;IACzB,kBAAkB;IAClB,gIAAgI;IAChI,UAAU;IACV,UAAU;IACV,EAAE;IACF,oDAAoD;IACpD,sCAAsC;IACtC,uCAAuC;IACvC,OAAO;IACP,EAAE;IACF,yDAAyD;IACzD,sEAAsE;IACtE,6BAA6B;IAC7B,yBAAyB;IACzB,UAAU;IACV,EAAE;IACF,oDAAoD;IACpD,kCAAkC;IAClC,OAAO;IACP,EAAE;IACF,8CAA8C;IAC9C,oEAAoE;IACpE,oDAAoD;IACpD,kCAAkC;IAClC,OAAO;IACP,KAAK;CACN,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC"}

package/dist/templates/test-planner.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generates src/__tests__/planner.test.ts for a new agent.
+ * Tests the Planner state machine: create, approve, execute, update tasks, complete.
+ */
+export declare function generatePlannerTest(): string;

package/dist/templates/test-planner.js

@@ -0,0 +1,271 @@
+/**
+ * Generates src/__tests__/planner.test.ts for a new agent.
+ * Tests the Planner state machine: create, approve, execute, update tasks, complete.
+ */
+export function generatePlannerTest() {
+    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');
+//# sourceMappingURL=test-planner.js.map

package/dist/templates/test-planner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-planner.js","sourceRoot":"","sources":["../../src/templates/test-planner.ts"],"names":[],"mappings":"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"}

package/dist/templates/test-vault.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generates vault test file for a new agent.
+ * Tests cover: constructor, seed, search (FTS5), get, list, stats, add, remove.
+ */
+export declare function generateVaultTest(): string;