@soleri/forge 3.0.0 → 4.1.0

package/dist/templates/planner.js

@@ -1,150 +0,0 @@
-/**
- * Generates src/planning/planner.ts for a new agent.
- * The Planner provides JSON-file-backed plan management with state machine transitions.
- */
-export function generatePlanner() {
-    return PLANNER_TEMPLATE;
-}
-const PLANNER_TEMPLATE = [
-    "import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';",
-    "import { dirname } from 'node:path';",
-    '',
-    "export type PlanStatus = 'draft' | 'approved' | 'executing' | 'completed';",
-    "export type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'skipped' | 'failed';",
-    '',
-    'export interface PlanTask {',
-    '  id: string;',
-    '  title: string;',
-    '  description: string;',
-    '  status: TaskStatus;',
-    '  updatedAt: number;',
-    '}',
-    '',
-    'export interface Plan {',
-    '  id: string;',
-    '  objective: string;',
-    '  scope: string;',
-    '  status: PlanStatus;',
-    '  decisions: string[];',
-    '  tasks: PlanTask[];',
-    '  createdAt: number;',
-    '  updatedAt: number;',
-    '}',
-    '',
-    'export interface PlanStore {',
-    '  version: string;',
-    '  plans: Plan[];',
-    '}',
-    '',
-    'export class Planner {',
-    '  private filePath: string;',
-    '  private store: PlanStore;',
-    '',
-    '  constructor(filePath: string) {',
-    '    this.filePath = filePath;',
-    '    this.store = this.load();',
-    '  }',
-    '',
-    '  private load(): PlanStore {',
-    '    if (!existsSync(this.filePath)) {',
-    "      return { version: '1.0', plans: [] };",
-    '    }',
-    '    try {',
-    "      const data = readFileSync(this.filePath, 'utf-8');",
-    '      return JSON.parse(data) as PlanStore;',
-    '    } catch {',
-    "      return { version: '1.0', plans: [] };",
-    '    }',
-    '  }',
-    '',
-    '  private save(): void {',
-    '    mkdirSync(dirname(this.filePath), { recursive: true });',
-    "    writeFileSync(this.filePath, JSON.stringify(this.store, null, 2), 'utf-8');",
-    '  }',
-    '',
-    '  create(params: { objective: string; scope: string; decisions?: string[]; tasks?: Array<{ title: string; description: string }> }): Plan {',
-    '    const now = Date.now();',
-    '    const plan: Plan = {',
-    '      id: `plan-${now}-${Math.random().toString(36).slice(2, 8)}`,',
-    '      objective: params.objective,',
-    '      scope: params.scope,',
-    "      status: 'draft',",
-    '      decisions: params.decisions ?? [],',
-    '      tasks: (params.tasks ?? []).map((t, i) => ({',
-    '        id: `task-${i + 1}`,',
-    '        title: t.title,',
-    '        description: t.description,',
-    "        status: 'pending' as TaskStatus,",
-    '        updatedAt: now,',
-    '      })),',
-    '      createdAt: now,',
-    '      updatedAt: now,',
-    '    };',
-    '    this.store.plans.push(plan);',
-    '    this.save();',
-    '    return plan;',
-    '  }',
-    '',
-    '  get(planId: string): Plan | null {',
-    '    return this.store.plans.find((p) => p.id === planId) ?? null;',
-    '  }',
-    '',
-    '  list(): Plan[] {',
-    '    return [...this.store.plans];',
-    '  }',
-    '',
-    '  approve(planId: string): Plan {',
-    '    const plan = this.get(planId);',
-    '    if (!plan) throw new Error(`Plan not found: ${planId}`);',
-    "    if (plan.status !== 'draft') throw new Error(`Cannot approve plan in '${plan.status}' status — must be 'draft'`);",
-    "    plan.status = 'approved';",
-    '    plan.updatedAt = Date.now();',
-    '    this.save();',
-    '    return plan;',
-    '  }',
-    '',
-    '  startExecution(planId: string): Plan {',
-    '    const plan = this.get(planId);',
-    '    if (!plan) throw new Error(`Plan not found: ${planId}`);',
-    "    if (plan.status !== 'approved') throw new Error(`Cannot execute plan in '${plan.status}' status — must be 'approved'`);",
-    "    plan.status = 'executing';",
-    '    plan.updatedAt = Date.now();',
-    '    this.save();',
-    '    return plan;',
-    '  }',
-    '',
-    '  updateTask(planId: string, taskId: string, status: TaskStatus): Plan {',
-    '    const plan = this.get(planId);',
-    '    if (!plan) throw new Error(`Plan not found: ${planId}`);',
-    "    if (plan.status !== 'executing') throw new Error(`Cannot update tasks on plan in '${plan.status}' status — must be 'executing'`);",
-    '    const task = plan.tasks.find((t) => t.id === taskId);',
-    '    if (!task) throw new Error(`Task not found: ${taskId}`);',
-    '    task.status = status;',
-    '    task.updatedAt = Date.now();',
-    '    plan.updatedAt = Date.now();',
-    "    // Auto-transition: if plan is executing and first task starts, that's fine",
-    '    // Auto-start execution when approving and updating first task',
-    '    this.save();',
-    '    return plan;',
-    '  }',
-    '',
-    '  complete(planId: string): Plan {',
-    '    const plan = this.get(planId);',
-    '    if (!plan) throw new Error(`Plan not found: ${planId}`);',
-    "    if (plan.status !== 'executing') throw new Error(`Cannot complete plan in '${plan.status}' status — must be 'executing'`);",
-    "    plan.status = 'completed';",
-    '    plan.updatedAt = Date.now();',
-    '    this.save();',
-    '    return plan;',
-    '  }',
-    '',
-    '  getExecuting(): Plan[] {',
-    "    return this.store.plans.filter((p) => p.status === 'executing');",
-    '  }',
-    '',
-    '  getActive(): Plan[] {',
-    "    return this.store.plans.filter((p) => p.status === 'draft' || p.status === 'approved' || p.status === 'executing');",
-    '  }',
-    '}',
-].join('\n');
-//# sourceMappingURL=planner.js.map

package/dist/templates/planner.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"planner.js","sourceRoot":"","sources":["../../src/templates/planner.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,UAAU,eAAe;IAC7B,OAAO,gBAAgB,CAAC;AAC1B,CAAC;AAED,MAAM,gBAAgB,GAAG;IACvB,+EAA+E;IAC/E,sCAAsC;IACtC,EAAE;IACF,4EAA4E;IAC5E,0FAA0F;IAC1F,EAAE;IACF,6BAA6B;IAC7B,eAAe;IACf,kBAAkB;IAClB,wBAAwB;IACxB,uBAAuB;IACvB,sBAAsB;IACtB,GAAG;IACH,EAAE;IACF,yBAAyB;IACzB,eAAe;IACf,sBAAsB;IACtB,kBAAkB;IAClB,uBAAuB;IACvB,wBAAwB;IACxB,sBAAsB;IACtB,sBAAsB;IACtB,sBAAsB;IACtB,GAAG;IACH,EAAE;IACF,8BAA8B;IAC9B,oBAAoB;IACpB,kBAAkB;IAClB,GAAG;IACH,EAAE;IACF,wBAAwB;IACxB,6BAA6B;IAC7B,6BAA6B;IAC7B,EAAE;IACF,mCAAmC;IACnC,+BAA+B;IAC/B,+BAA+B;IAC/B,KAAK;IACL,EAAE;IACF,+BAA+B;IAC/B,uCAAuC;IACvC,6CAA6C;IAC7C,OAAO;IACP,WAAW;IACX,0DAA0D;IAC1D,6CAA6C;IAC7C,eAAe;IACf,6CAA6C;IAC7C,OAAO;IACP,KAAK;IACL,EAAE;IACF,0BAA0B;IAC1B,6DAA6D;IAC7D,iFAAiF;IACjF,KAAK;IACL,EAAE;IACF,6IAA6I;IAC7I,6BAA6B;IAC7B,0BAA0B;IAC1B,oEAAoE;IACpE,oCAAoC;IACpC,4BAA4B;IAC5B,wBAAwB;IACxB,0CAA0C;IAC1C,oDAAoD;IACpD,8BAA8B;IAC9B,yBAAyB;IACzB,qCAAqC;IACrC,0CAA0C;IAC1C,yBAAyB;IACzB,YAAY;IACZ,uBAAuB;IACvB,uBAAuB;IACvB,QAAQ;IACR,kCAAkC;IAClC,kBAAkB;IAClB,kBAAkB;IAClB,KAAK;IACL,EAAE;IACF,sCAAsC;IACtC,mEAAmE;IACnE,KAAK;IACL,EAAE;IACF,oBAAoB;IACpB,mCAAmC;IACnC,KAAK;IACL,EAAE;IACF,mCAAmC;IACnC,oCAAoC;IACpC,8DAA8D;IAC9D,uHAAuH;IACvH,+BAA+B;IAC/B,kCAAkC;IAClC,kBAAkB;IAClB,kBAAkB;IAClB,KAAK;IACL,EAAE;IACF,0CAA0C;IAC1C,oCAAoC;IACpC,8DAA8D;IAC9D,6HAA6H;IAC7H,gCAAgC;IAChC,kCAAkC;IAClC,kBAAkB;IAClB,kBAAkB;IAClB,KAAK;IACL,EAAE;IACF,0EAA0E;IAC1E,oCAAoC;IACpC,8DAA8D;IAC9D,uIAAuI;IACvI,2DAA2D;IAC3D,8DAA8D;IAC9D,2BAA2B;IAC3B,kCAAkC;IAClC,kCAAkC;IAClC,iFAAiF;IACjF,oEAAoE;IACpE,kBAAkB;IAClB,kBAAkB;IAClB,KAAK;IACL,EAAE;IACF,oCAAoC;IACpC,oCAAoC;IACpC,8DAA8D;IAC9D,gIAAgI;IAChI,gCAAgC;IAChC,kCAAkC;IAClC,kBAAkB;IAClB,kBAAkB;IAClB,KAAK;IACL,EAAE;IACF,4BAA4B;IAC5B,sEAAsE;IACtE,KAAK;IACL,EAAE;IACF,yBAAyB;IACzB,yHAAyH;IACzH,KAAK;IACL,GAAG;CACJ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC"}

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

@@ -1,6 +0,0 @@
-/**
- * Generates brain test file for a new agent.
- * Tests cover: TF-IDF scoring, intelligent search, auto-tagging,
- * duplicate detection, feedback, adaptive weights, vocabulary.
- */
-export declare function generateBrainTest(): string;

package/dist/templates/test-brain.js

@@ -1,474 +0,0 @@
-/**
- * Generates brain test file for a new agent.
- * Tests cover: TF-IDF scoring, intelligent search, auto-tagging,
- * duplicate detection, feedback, adaptive weights, vocabulary.
- */
-export function generateBrainTest() {
-    return BRAIN_TEST_TEMPLATE;
-}
-const BRAIN_TEST_TEMPLATE = [
-    "import { describe, it, expect, beforeEach, afterEach } from 'vitest';",
-    "import { Vault } from '../vault/vault.js';",
-    "import { Brain } from '../brain/brain.js';",
-    "import type { IntelligenceEntry } from '../intelligence/types.js';",
-    '',
-    'function makeEntry(overrides: Partial<IntelligenceEntry> = {}): IntelligenceEntry {',
-    '  return {',
-    "    id: overrides.id ?? 'test-1',",
-    "    type: overrides.type ?? 'pattern',",
-    "    domain: overrides.domain ?? 'testing',",
-    "    title: overrides.title ?? 'Test Pattern',",
-    "    severity: overrides.severity ?? 'warning',",
-    "    description: overrides.description ?? 'A test pattern for unit tests.',",
-    "    tags: overrides.tags ?? ['testing', 'assertions'],",
-    '  };',
-    '}',
-    '',
-    "describe('Brain', () => {",
-    '  let vault: Vault;',
-    '  let brain: Brain;',
-    '',
-    '  beforeEach(() => {',
-    "    vault = new Vault(':memory:');",
-    '    brain = new Brain(vault);',
-    '  });',
-    '',
-    '  afterEach(() => {',
-    '    vault.close();',
-    '  });',
-    '',
-    '  // ─── Constructor ──────────────────────────────────────────────',
-    '',
-    "  describe('constructor', () => {",
-    "    it('should create brain with empty vocabulary on empty vault', () => {",
-    '      expect(brain.getVocabularySize()).toBe(0);',
-    '    });',
-    '',
-    "    it('should build vocabulary from existing entries', () => {",
-    '      vault.seed([',
-    "        makeEntry({ id: 'v1', title: 'Input validation pattern', description: 'Always validate user input at boundaries.', tags: ['validation', 'security'] }),",
-    "        makeEntry({ id: 'v2', title: 'Caching strategy', description: 'Use cache-aside for read-heavy workloads.', tags: ['caching', 'performance'] }),",
-    '      ]);',
-    '      const brain2 = new Brain(vault);',
-    '      expect(brain2.getVocabularySize()).toBeGreaterThan(0);',
-    '    });',
-    '  });',
-    '',
-    '  // ─── Intelligent Search ──────────────────────────────────────',
-    '',
-    "  describe('intelligentSearch', () => {",
-    '    beforeEach(() => {',
-    '      vault.seed([',
-    "        makeEntry({ id: 'is-1', title: 'Input validation pattern', description: 'Always validate user input at system boundaries to prevent injection attacks.', domain: 'security', severity: 'critical', tags: ['validation', 'security', 'input'] }),",
-    "        makeEntry({ id: 'is-2', title: 'Caching strategy for APIs', description: 'Use cache-aside pattern for read-heavy API workloads.', domain: 'performance', severity: 'warning', tags: ['caching', 'api', 'performance'] }),",
-    "        makeEntry({ id: 'is-3', title: 'Error handling best practices', description: 'Use typed errors with context for better debugging experience.', domain: 'clean-code', severity: 'suggestion', tags: ['errors', 'debugging'] }),",
-    '      ]);',
-    '      brain = new Brain(vault);',
-    '    });',
-    '',
-    "    it('should return ranked results', () => {",
-    "      const results = brain.intelligentSearch('validation input');",
-    '      expect(results.length).toBeGreaterThan(0);',
-    "      expect(results[0].entry.id).toBe('is-1');",
-    '    });',
-    '',
-    "    it('should include score breakdown', () => {",
-    "      const results = brain.intelligentSearch('validation');",
-    '      expect(results.length).toBeGreaterThan(0);',
-    '      const breakdown = results[0].breakdown;',
-    "      expect(breakdown).toHaveProperty('semantic');",
-    "      expect(breakdown).toHaveProperty('severity');",
-    "      expect(breakdown).toHaveProperty('recency');",
-    "      expect(breakdown).toHaveProperty('tagOverlap');",
-    "      expect(breakdown).toHaveProperty('domainMatch');",
-    "      expect(breakdown).toHaveProperty('total');",
-    '      expect(breakdown.total).toBe(results[0].score);',
-    '    });',
-    '',
-    "    it('should return empty array for no matches', () => {",
-    "      const results = brain.intelligentSearch('xyznonexistent');",
-    '      expect(results).toEqual([]);',
-    '    });',
-    '',
-    "    it('should respect limit', () => {",
-    "      const results = brain.intelligentSearch('pattern', { limit: 1 });",
-    '      expect(results.length).toBeLessThanOrEqual(1);',
-    '    });',
-    '',
-    "    it('should filter by domain', () => {",
-    "      const results = brain.intelligentSearch('pattern', { domain: 'security' });",
-    "      expect(results.every((r) => r.entry.domain === 'security')).toBe(true);",
-    '    });',
-    '',
-    "    it('should boost domain matches when domain is specified', () => {",
-    "      const withDomain = brain.intelligentSearch('pattern', { domain: 'security' });",
-    '      if (withDomain.length > 0) {',
-    '        expect(withDomain[0].breakdown.domainMatch).toBe(1.0);',
-    '      }',
-    '    });',
-    '',
-    "    it('should boost severity in scoring', () => {",
-    "      const results = brain.intelligentSearch('pattern');",
-    '      if (results.length >= 2) {',
-    '        // Critical entry should have higher severity score',
-    "        const critical = results.find((r) => r.entry.severity === 'critical');",
-    "        const suggestion = results.find((r) => r.entry.severity === 'suggestion');",
-    '        if (critical && suggestion) {',
-    '          expect(critical.breakdown.severity).toBeGreaterThan(suggestion.breakdown.severity);',
-    '        }',
-    '      }',
-    '    });',
-    '',
-    "    it('should boost tag overlap when tags provided', () => {",
-    "      const results = brain.intelligentSearch('pattern', { tags: ['validation', 'security'] });",
-    '      if (results.length > 0) {',
-    '        // The security entry with matching tags should have tag overlap > 0',
-    "        const secEntry = results.find((r) => r.entry.id === 'is-1');",
-    '        if (secEntry) {',
-    '          expect(secEntry.breakdown.tagOverlap).toBeGreaterThan(0);',
-    '        }',
-    '      }',
-    '    });',
-    '',
-    "    it('should handle search on empty vault gracefully', () => {",
-    "      const emptyVault = new Vault(':memory:');",
-    '      const emptyBrain = new Brain(emptyVault);',
-    "      const results = emptyBrain.intelligentSearch('anything');",
-    '      expect(results).toEqual([]);',
-    '      emptyVault.close();',
-    '    });',
-    '  });',
-    '',
-    '  // ─── Enrich and Capture ─────────────────────────────────────',
-    '',
-    "  describe('enrichAndCapture', () => {",
-    "    it('should capture entry and return auto-tags', () => {",
-    '      const result = brain.enrichAndCapture({',
-    "        id: 'cap-1',",
-    "        type: 'pattern',",
-    "        domain: 'security',",
-    "        title: 'SQL injection prevention',",
-    "        severity: 'critical',",
-    "        description: 'Always use parameterized queries to prevent SQL injection attacks on database.',",
-    '        tags: [],',
-    '      });',
-    '      expect(result.captured).toBe(true);',
-    "      expect(result.id).toBe('cap-1');",
-    '      expect(result.autoTags.length).toBeGreaterThan(0);',
-    '    });',
-    '',
-    "    it('should merge auto-tags with user-provided tags', () => {",
-    '      const result = brain.enrichAndCapture({',
-    "        id: 'cap-2',",
-    "        type: 'pattern',",
-    "        domain: 'security',",
-    "        title: 'XSS prevention methods',",
-    "        severity: 'critical',",
-    "        description: 'Sanitize all user input before rendering in the browser to prevent cross-site scripting.',",
-    "        tags: ['user-tag'],",
-    '      });',
-    '      expect(result.captured).toBe(true);',
-    '      // Verify the entry in vault has merged tags',
-    "      const entry = vault.get('cap-2');",
-    '      expect(entry).not.toBeNull();',
-    "      expect(entry!.tags).toContain('user-tag');",
-    '      expect(entry!.tags.length).toBeGreaterThan(1);',
-    '    });',
-    '',
-    "    it('should store entry in vault', () => {",
-    '      brain.enrichAndCapture({',
-    "        id: 'cap-3',",
-    "        type: 'rule',",
-    "        domain: 'testing',",
-    "        title: 'Always test edge cases',",
-    "        severity: 'warning',",
-    "        description: 'Write tests for boundary values, null inputs, and error conditions.',",
-    "        tags: ['testing'],",
-    '      });',
-    "      const entry = vault.get('cap-3');",
-    '      expect(entry).not.toBeNull();',
-    "      expect(entry!.title).toBe('Always test edge cases');",
-    '    });',
-    '',
-    "    it('should update vocabulary incrementally after capture', () => {",
-    '      const sizeBefore = brain.getVocabularySize();',
-    '      brain.enrichAndCapture({',
-    "        id: 'cap-4',",
-    "        type: 'pattern',",
-    "        domain: 'performance',",
-    "        title: 'Connection pooling optimization',",
-    "        severity: 'warning',",
-    "        description: 'Use connection pooling for database connections to reduce overhead and improve throughput.',",
-    "        tags: ['database', 'performance'],",
-    '      });',
-    '      expect(brain.getVocabularySize()).toBeGreaterThan(sizeBefore);',
-    '    });',
-    '',
-    "    it('should capture entry without tags and auto-generate them', () => {",
-    '      const result = brain.enrichAndCapture({',
-    "        id: 'cap-5',",
-    "        type: 'anti-pattern',",
-    "        domain: 'clean-code',",
-    "        title: 'Deeply nested conditionals',",
-    "        severity: 'warning',",
-    "        description: 'Avoid deeply nested if-else blocks. Use early returns and guard clauses instead.',",
-    '        tags: [],',
-    '      });',
-    '      expect(result.captured).toBe(true);',
-    '      expect(result.autoTags.length).toBeGreaterThan(0);',
-    "      const entry = vault.get('cap-5');",
-    '      expect(entry!.tags.length).toBeGreaterThan(0);',
-    '    });',
-    '  });',
-    '',
-    '  // ─── Duplicate Detection ────────────────────────────────────',
-    '',
-    "  describe('duplicate detection', () => {",
-    '    beforeEach(() => {',
-    '      vault.seed([',
-    '        makeEntry({',
-    "          id: 'dup-existing',",
-    "          domain: 'security',",
-    "          title: 'Input validation pattern for user forms',",
-    "          description: 'Always validate user input at system boundaries to prevent injection attacks.',",
-    "          tags: ['validation', 'security'],",
-    '        }),',
-    '      ]);',
-    '      brain = new Brain(vault);',
-    '    });',
-    '',
-    "    it('should warn on similar entry', () => {",
-    '      const result = brain.enrichAndCapture({',
-    "        id: 'dup-new-1',",
-    "        type: 'pattern',",
-    "        domain: 'security',",
-    "        title: 'Input validation pattern for user forms and APIs',",
-    "        severity: 'warning',",
-    "        description: 'Validate all user input at boundaries to block injection vectors.',",
-    "        tags: ['validation'],",
-    '      });',
-    '      // Should still capture (warn threshold, not block)',
-    '      expect(result.captured).toBe(true);',
-    '      // May have a duplicate warning if similarity >= 0.6',
-    '      if (result.duplicate) {',
-    "        expect(result.duplicate.id).toBe('dup-existing');",
-    '        expect(result.duplicate.similarity).toBeGreaterThanOrEqual(0.6);',
-    '      }',
-    '    });',
-    '',
-    "    it('should allow dissimilar entries without duplicate warning', () => {",
-    '      const result = brain.enrichAndCapture({',
-    "        id: 'dup-different',",
-    "        type: 'pattern',",
-    "        domain: 'security',",
-    "        title: 'Rate limiting configuration',",
-    "        severity: 'warning',",
-    "        description: 'Configure rate limits on API endpoints to prevent abuse.',",
-    "        tags: ['rate-limiting'],",
-    '      });',
-    '      expect(result.captured).toBe(true);',
-    '    });',
-    '  });',
-    '',
-    '  // ─── Record Feedback ────────────────────────────────────────',
-    '',
-    "  describe('recordFeedback', () => {",
-    "    it('should record feedback in database', () => {",
-    "      brain.recordFeedback('test query', 'entry-1', 'accepted');",
-    '      const stats = brain.getStats();',
-    '      expect(stats.feedbackCount).toBe(1);',
-    '    });',
-    '',
-    "    it('should record multiple feedback entries', () => {",
-    "      brain.recordFeedback('query-1', 'entry-1', 'accepted');",
-    "      brain.recordFeedback('query-2', 'entry-2', 'dismissed');",
-    "      brain.recordFeedback('query-3', 'entry-3', 'accepted');",
-    '      const stats = brain.getStats();',
-    '      expect(stats.feedbackCount).toBe(3);',
-    '    });',
-    '',
-    "    it('should keep default weights below feedback threshold', () => {",
-    '      for (let i = 0; i < 10; i++) {',
-    "        brain.recordFeedback('q' + i, 'e' + i, 'accepted');",
-    '      }',
-    '      const stats = brain.getStats();',
-    '      expect(stats.weights.semantic).toBeCloseTo(0.40, 2);',
-    '    });',
-    '  });',
-    '',
-    '  // ─── Adaptive Weights ───────────────────────────────────────',
-    '',
-    "  describe('adaptive weights', () => {",
-    "    it('should adjust weights after reaching feedback threshold', () => {",
-    '      // Record 30+ feedback entries with high accept rate',
-    '      for (let i = 0; i < 35; i++) {',
-    "        brain.recordFeedback('query-' + i, 'entry-' + i, 'accepted');",
-    '      }',
-    '      const stats = brain.getStats();',
-    '      // Semantic weight should increase with high accept rate',
-    '      expect(stats.weights.semantic).toBeGreaterThan(0.40);',
-    '    });',
-    '',
-    "    it('should decrease semantic weight with high dismiss rate', () => {",
-    '      for (let i = 0; i < 35; i++) {',
-    "        brain.recordFeedback('query-' + i, 'entry-' + i, 'dismissed');",
-    '      }',
-    '      const stats = brain.getStats();',
-    '      expect(stats.weights.semantic).toBeLessThan(0.40);',
-    '    });',
-    '',
-    "    it('should keep weights bounded within ±0.15 of defaults', () => {",
-    '      for (let i = 0; i < 50; i++) {',
-    "        brain.recordFeedback('query-' + i, 'entry-' + i, 'accepted');",
-    '      }',
-    '      const stats = brain.getStats();',
-    '      expect(stats.weights.semantic).toBeLessThanOrEqual(0.55);',
-    '      expect(stats.weights.semantic).toBeGreaterThanOrEqual(0.25);',
-    '    });',
-    '',
-    "    it('should normalize weights to sum to 1.0', () => {",
-    '      for (let i = 0; i < 35; i++) {',
-    "        brain.recordFeedback('query-' + i, 'entry-' + i, 'accepted');",
-    '      }',
-    '      const stats = brain.getStats();',
-    '      const sum = stats.weights.semantic + stats.weights.severity + stats.weights.recency + stats.weights.tagOverlap + stats.weights.domainMatch;',
-    '      expect(sum).toBeCloseTo(1.0, 5);',
-    '    });',
-    '',
-    "    it('should keep default weights with balanced feedback', () => {",
-    '      // 50/50 accept/dismiss rate',
-    '      for (let i = 0; i < 20; i++) {',
-    "        brain.recordFeedback('qa-' + i, 'ea-' + i, 'accepted');",
-    '      }',
-    '      for (let i = 0; i < 20; i++) {',
-    "        brain.recordFeedback('qd-' + i, 'ed-' + i, 'dismissed');",
-    '      }',
-    '      const stats = brain.getStats();',
-    '      // With balanced feedback, semantic weight should stay near default',
-    '      expect(stats.weights.semantic).toBeCloseTo(0.40, 1);',
-    '    });',
-    '  });',
-    '',
-    '  // ─── Vocabulary ─────────────────────────────────────────────',
-    '',
-    "  describe('vocabulary', () => {",
-    "    it('should rebuild vocabulary from vault entries', () => {",
-    '      vault.seed([',
-    "        makeEntry({ id: 'voc-1', title: 'Authentication pattern', description: 'JWT tokens for API auth.', tags: ['auth', 'jwt'] }),",
-    "        makeEntry({ id: 'voc-2', title: 'Authorization rules', description: 'Role-based access control.', tags: ['rbac', 'auth'] }),",
-    '      ]);',
-    '      brain.rebuildVocabulary();',
-    '      expect(brain.getVocabularySize()).toBeGreaterThan(0);',
-    '    });',
-    '',
-    "    it('should clear vocabulary when vault is empty', () => {",
-    "      vault.seed([makeEntry({ id: 'voc-3', title: 'Temp entry', description: 'Will be removed.', tags: ['temp'] })]);",
-    '      brain.rebuildVocabulary();',
-    '      expect(brain.getVocabularySize()).toBeGreaterThan(0);',
-    "      vault.remove('voc-3');",
-    '      brain.rebuildVocabulary();',
-    '      expect(brain.getVocabularySize()).toBe(0);',
-    '    });',
-    '',
-    "    it('should persist vocabulary to database', () => {",
-    '      vault.seed([',
-    "        makeEntry({ id: 'voc-4', title: 'Persistent vocabulary test', description: 'Testing database persistence.', tags: ['persistence'] }),",
-    '      ]);',
-    '      brain.rebuildVocabulary();',
-    '      const db = vault.getDb();',
-    "      const count = (db.prepare('SELECT COUNT(*) as count FROM brain_vocabulary').get() as { count: number }).count;",
-    '      expect(count).toBeGreaterThan(0);',
-    '    });',
-    '',
-    "    it('should handle rebuild on empty vault gracefully', () => {",
-    '      brain.rebuildVocabulary();',
-    '      expect(brain.getVocabularySize()).toBe(0);',
-    '    });',
-    '  });',
-    '',
-    '  // ─── Stats ──────────────────────────────────────────────────',
-    '',
-    "  describe('getStats', () => {",
-    "    it('should return stats with zero counts for new brain', () => {",
-    '      const stats = brain.getStats();',
-    '      expect(stats.vocabularySize).toBe(0);',
-    '      expect(stats.feedbackCount).toBe(0);',
-    '      expect(stats.weights.semantic).toBeCloseTo(0.40, 2);',
-    '    });',
-    '',
-    "    it('should return correct vocabulary size after seeding', () => {",
-    '      vault.seed([',
-    "        makeEntry({ id: 'st-1', title: 'Pattern one', description: 'Description one.', tags: ['a'] }),",
-    "        makeEntry({ id: 'st-2', title: 'Pattern two', description: 'Description two.', tags: ['b'] }),",
-    '      ]);',
-    '      brain.rebuildVocabulary();',
-    '      const stats = brain.getStats();',
-    '      expect(stats.vocabularySize).toBeGreaterThan(0);',
-    '    });',
-    '',
-    "    it('should return correct feedback count', () => {",
-    "      brain.recordFeedback('q1', 'e1', 'accepted');",
-    "      brain.recordFeedback('q2', 'e2', 'dismissed');",
-    '      const stats = brain.getStats();',
-    '      expect(stats.feedbackCount).toBe(2);',
-    '    });',
-    '  });',
-    '',
-    '  // ─── Get Relevant Patterns ──────────────────────────────────',
-    '',
-    "  describe('getRelevantPatterns', () => {",
-    "    it('should return ranked results for query context', () => {",
-    '      vault.seed([',
-    "        makeEntry({ id: 'rel-1', title: 'Authentication pattern', description: 'JWT for API auth.', domain: 'security', tags: ['auth'] }),",
-    "        makeEntry({ id: 'rel-2', title: 'Database indexing', description: 'Index frequently queried columns.', domain: 'performance', tags: ['indexing'] }),",
-    '      ]);',
-    '      brain = new Brain(vault);',
-    "      const results = brain.getRelevantPatterns({ query: 'authentication', domain: 'security' });",
-    '      expect(results.length).toBeGreaterThan(0);',
-    '    });',
-    '',
-    "    it('should return empty for no context matches', () => {",
-    "      const results = brain.getRelevantPatterns({ query: 'nonexistent' });",
-    '      expect(results).toEqual([]);',
-    '    });',
-    '  });',
-    '',
-    '  // ─── Graceful Degradation ───────────────────────────────────',
-    '',
-    "  describe('graceful degradation', () => {",
-    "    it('should work without vocabulary (empty vault)', () => {",
-    '      expect(brain.getVocabularySize()).toBe(0);',
-    "      const results = brain.intelligentSearch('anything');",
-    '      expect(results).toEqual([]);',
-    '    });',
-    '',
-    "    it('should fall back to severity + recency scoring when vocabulary is empty', () => {",
-    '      // Seed entries but create brain before vocabulary can build',
-    '      vault.seed([',
-    "        makeEntry({ id: 'gd-1', title: 'Fallback test pattern', description: 'Testing graceful degradation.', severity: 'critical', tags: ['fallback'] }),",
-    '      ]);',
-    '      // Rebuild brain to pick up vocabulary',
-    '      brain = new Brain(vault);',
-    "      const results = brain.intelligentSearch('fallback test');",
-    '      expect(results.length).toBeGreaterThan(0);',
-    '      // Should have a score even with vocabulary',
-    '      expect(results[0].score).toBeGreaterThan(0);',
-    '    });',
-    '',
-    "    it('should handle capture on empty vault without errors', () => {",
-    '      const result = brain.enrichAndCapture({',
-    "        id: 'gd-cap-1',",
-    "        type: 'pattern',",
-    "        domain: 'testing',",
-    "        title: 'First pattern ever',",
-    "        severity: 'warning',",
-    "        description: 'The very first pattern captured in an empty vault.',",
-    '        tags: [],',
-    '      });',
-    '      expect(result.captured).toBe(true);',
-    '      expect(result.autoTags.length).toBeGreaterThan(0);',
-    '    });',
-    '  });',
-    '});',
-].join('\n');
-//# sourceMappingURL=test-brain.js.map

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

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