cognitive-core 0.2.1 → 0.2.2

package/tests/memory/compound-engineering-seed.test.ts

@@ -0,0 +1,338 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { PlaybookLibrary, createPlaybookLibrary } from '../../src/memory/playbook.js';
+import { loadCuratedPlaybooks, BUNDLED_SEED_PACK_DIR } from '../../src/memory/curated-loader.js';
+import { createSqlitePersistence } from '../../src/persistence/index.js';
+import { createAtlas } from '../../src/atlas.js';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const SEED_DIR = join(__dirname, '../../playbooks/compound-engineering');
+
+describe('Compound Engineering Seed Pack', () => {
+  let tempDir: string;
+  let library: PlaybookLibrary;
+  let persistence: ReturnType<typeof createSqlitePersistence>;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'atlas-ce-seed-'));
+    persistence = createSqlitePersistence({ baseDir: tempDir });
+    await persistence.init();
+    library = createPlaybookLibrary(persistence);
+    await library.init();
+  });
+
+  afterEach(async () => {
+    await library.close();
+    persistence.close();
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('should load all seed playbooks without errors', async () => {
+    const result = await loadCuratedPlaybooks(SEED_DIR, library);
+
+    expect(result.errors).toEqual([]);
+    expect(result.loaded).toBe(25);
+    expect(result.skipped).toBe(0);
+  });
+
+  it('should mark all playbooks as curated', async () => {
+    await loadCuratedPlaybooks(SEED_DIR, library);
+
+    const curated = await library.getByOrigin('curated');
+    expect(curated).toHaveLength(25);
+    for (const p of curated) {
+      expect(p.provenance.origin).toBe('curated');
+      expect(['compound-engineering', 'cognitive-core']).toContain(p.provenance.curatedBy);
+    }
+  });
+
+  it('should set higher confidence for curated playbooks (>= 0.7)', async () => {
+    await loadCuratedPlaybooks(SEED_DIR, library);
+
+    const all = await library.getAll();
+    for (const p of all) {
+      expect(p.confidence).toBeGreaterThanOrEqual(0.7);
+    }
+  });
+
+  it('should load expected playbook names', async () => {
+    await loadCuratedPlaybooks(SEED_DIR, library);
+
+    const expectedNames = [
+      // Original 11
+      'review-orchestration',
+      'correctness-review',
+      'testing-review',
+      'maintainability-review',
+      'agent-native-review',
+      'knowledge-compounding',
+      'brainstorm-requirements',
+      'implementation-planning',
+      'systematic-execution',
+      'learnings-research',
+      'confidence-calibration',
+      // Code review personas
+      'security-review',
+      'performance-review',
+      'reliability-review',
+      'adversarial-review',
+      'api-contract-review',
+      'data-migration-safety',
+      'project-standards-review',
+      // Plan review
+      'plan-adversarial-review',
+      'plan-feasibility-review',
+      // Workflows
+      'bug-reproduction',
+      'agent-native-architecture',
+      'issue-pattern-analysis',
+      'deployment-verification',
+      // Cognitive-core native
+      'error-recovery-patterns',
+    ];
+
+    for (const name of expectedNames) {
+      const p = await library.getByName(name);
+      expect(p, `missing playbook: ${name}`).toBeDefined();
+    }
+  });
+
+  it('should cover expected domains', async () => {
+    await loadCuratedPlaybooks(SEED_DIR, library);
+
+    const domains = await library.getDomains();
+    expect(domains).toContain('code-review');
+    expect(domains).toContain('software-engineering');
+    expect(domains).toContain('quality-assurance');
+    expect(domains).toContain('planning');
+    expect(domains).toContain('knowledge-management');
+    expect(domains).toContain('security');
+    expect(domains).toContain('performance');
+    expect(domains).toContain('reliability');
+    expect(domains).toContain('debugging');
+    expect(domains).toContain('deployment');
+  });
+
+  it('should have non-empty guidance for all playbooks', async () => {
+    await loadCuratedPlaybooks(SEED_DIR, library);
+
+    const all = await library.getAll();
+    for (const p of all) {
+      expect(p.guidance.strategy.length, `${p.name} has empty strategy`).toBeGreaterThan(0);
+      expect(p.guidance.tactics.length, `${p.name} has no tactics`).toBeGreaterThan(0);
+    }
+  });
+
+  it('should have verification criteria for all playbooks', async () => {
+    await loadCuratedPlaybooks(SEED_DIR, library);
+
+    const all = await library.getAll();
+    for (const p of all) {
+      expect(
+        p.verification.successIndicators.length,
+        `${p.name} has no success indicators`
+      ).toBeGreaterThan(0);
+      expect(
+        p.verification.failureIndicators.length,
+        `${p.name} has no failure indicators`
+      ).toBeGreaterThan(0);
+    }
+  });
+
+  it('should support recreate workflow for seed updates', async () => {
+    // Load initial
+    await loadCuratedPlaybooks(SEED_DIR, library);
+    expect(await library.count()).toBe(25);
+
+    // Recreate — simulates updating the seed pack
+    const result = await loadCuratedPlaybooks(SEED_DIR, library, { recreate: true });
+    expect(result.recreated).toBe(true);
+    expect(result.loaded).toBe(25);
+    expect(await library.count()).toBe(25);
+  });
+
+  it('should be findable by relevant search queries', async () => {
+    await loadCuratedPlaybooks(SEED_DIR, library);
+
+    const reviewMatches = await library.findMatching('code review before PR');
+    expect(reviewMatches.length).toBeGreaterThan(0);
+    const reviewNames = reviewMatches.map(m => m.playbook.name);
+    expect(reviewNames).toContain('review-orchestration');
+
+    const planMatches = await library.findMatching('create implementation plan for feature');
+    expect(planMatches.length).toBeGreaterThan(0);
+
+    const knowledgeMatches = await library.findMatching('document solved problem');
+    expect(knowledgeMatches.length).toBeGreaterThan(0);
+  });
+});
+
+describe('BUNDLED_SEED_PACK_DIR', () => {
+  it('should resolve to a valid directory', () => {
+    const { existsSync } = require('node:fs');
+    expect(existsSync(BUNDLED_SEED_PACK_DIR)).toBe(true);
+  });
+
+  it('should match the manual SEED_DIR path', () => {
+    // Both should point to the same playbooks directory
+    const { realpathSync } = require('node:fs');
+    expect(realpathSync(BUNDLED_SEED_PACK_DIR)).toBe(realpathSync(SEED_DIR));
+  });
+});
+
+describe('Atlas.init() with loadBundledSeedPack', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'atlas-init-seed-'));
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('should not load seed pack by default', async () => {
+    const atlas = createAtlas({ storage: { baseDir: tempDir } });
+    await atlas.init();
+
+    const memory = atlas.getMemory();
+    const count = await memory.playbooks.count();
+    expect(count).toBe(0);
+
+    await atlas.close();
+  });
+
+  it('should load seed pack when loadBundledSeedPack is true', async () => {
+    const atlas = createAtlas({
+      storage: { baseDir: tempDir },
+      curatedPlaybooks: { loadBundledSeedPack: true },
+    });
+    await atlas.init();
+
+    const memory = atlas.getMemory();
+    const count = await memory.playbooks.count();
+    expect(count).toBe(25);
+
+    // Verify they're curated
+    const curated = await memory.playbooks.getByOrigin('curated');
+    expect(curated).toHaveLength(25);
+
+    await atlas.close();
+  });
+
+  it('should skip already-loaded seed pack on second init', async () => {
+    const config = {
+      storage: { baseDir: tempDir },
+      curatedPlaybooks: { loadBundledSeedPack: true },
+    };
+
+    // First init
+    const atlas1 = createAtlas(config);
+    await atlas1.init();
+    expect(await atlas1.getMemory().playbooks.count()).toBe(25);
+    await atlas1.close();
+
+    // Second init — should skip (already loaded by name)
+    const atlas2 = createAtlas(config);
+    await atlas2.init();
+    expect(await atlas2.getMemory().playbooks.count()).toBe(25);
+    await atlas2.close();
+  });
+
+  it('should load from additional directories', async () => {
+    const customDir = join(tempDir, 'custom-playbooks');
+    const { mkdirSync, writeFileSync } = require('node:fs');
+    mkdirSync(customDir, { recursive: true });
+    writeFileSync(join(customDir, 'custom.json'), JSON.stringify({
+      name: 'custom-playbook',
+      applicability: { situations: ['Custom situation'], domains: ['custom'] },
+      guidance: { strategy: 'Custom strategy', tactics: ['Custom tactic'] },
+    }));
+
+    const atlas = createAtlas({
+      storage: { baseDir: tempDir },
+      curatedPlaybooks: {
+        loadBundledSeedPack: true,
+        additionalDirs: [customDir],
+      },
+    });
+    await atlas.init();
+
+    const count = await atlas.getMemory().playbooks.count();
+    expect(count).toBe(26); // 25 bundled + 1 custom
+
+    const custom = await atlas.getMemory().playbooks.getByName('custom-playbook');
+    expect(custom).toBeDefined();
+
+    await atlas.close();
+  });
+
+  it('should support recreateOnInit for seed updates', async () => {
+    const config = {
+      storage: { baseDir: tempDir },
+      curatedPlaybooks: { loadBundledSeedPack: true, recreateOnInit: true },
+    };
+
+    // First init
+    const atlas1 = createAtlas(config);
+    await atlas1.init();
+    expect(await atlas1.getMemory().playbooks.count()).toBe(25);
+    await atlas1.close();
+
+    // Second init with recreate — should reload all
+    const atlas2 = createAtlas(config);
+    await atlas2.init();
+    expect(await atlas2.getMemory().playbooks.count()).toBe(25);
+    await atlas2.close();
+  });
+
+  it('should load from sources (local path)', async () => {
+    // Create a local source directory with playbooks
+    const sourceDir = join(tempDir, 'my-source', 'playbooks');
+    const { mkdirSync, writeFileSync } = require('node:fs');
+    mkdirSync(sourceDir, { recursive: true });
+    writeFileSync(join(sourceDir, 'src-pb.json'), JSON.stringify({
+      name: 'source-playbook',
+      applicability: { situations: ['Source test'], domains: ['testing'] },
+      guidance: { strategy: 'Source strategy', tactics: ['Source tactic'] },
+      confidence: 0.9,
+    }));
+
+    const atlas = createAtlas({
+      storage: { baseDir: tempDir },
+      curatedPlaybooks: {
+        // Use the parent dir as source — discoverPlaybookDir should find playbooks/
+        sources: [sourceDir],
+      },
+    });
+    await atlas.init();
+
+    // Local sources are loaded directly (not via git resolver)
+    // But the sources flow resolves them as local paths first.
+    // Since sourceDir exists and is local, it will be loaded.
+    const count = await atlas.getMemory().playbooks.count();
+    expect(count).toBe(1);
+
+    const pb = await atlas.getMemory().playbooks.getByName('source-playbook');
+    expect(pb).toBeDefined();
+    expect(pb!.provenance?.origin).toBe('curated');
+
+    await atlas.close();
+  });
+
+  it('should accept new config shape with cache settings', () => {
+    // Verify the config schema accepts the new fields without error
+    const atlas = createAtlas({
+      storage: { baseDir: tempDir },
+      curatedPlaybooks: {
+        loadBundledSeedPack: false,
+        sources: ['github:org/repo#v1.0.0', '/local/path'],
+        cache: { dir: 'my-cache', maxAgeMs: 3600_000 },
+        recreateOnInit: false,
+      },
+    });
+    // No init — just verify config was accepted
+    expect(atlas).toBeDefined();
+  });
+});

package/tests/memory/curated-loader-extended.test.ts

@@ -0,0 +1,225 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { PlaybookLibrary, createPlaybookLibrary } from '../../src/memory/playbook.js';
+import { loadCuratedPlaybooks } from '../../src/memory/curated-loader.js';
+import { createSqlitePersistence } from '../../src/persistence/index.js';
+import { mkdtemp, rm, mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+function makePlaybookJson(name: string, domain: string, curatedBy?: string) {
+  return JSON.stringify({
+    name,
+    applicability: {
+      situations: [`${name} situation`],
+      triggers: [`${name} trigger`],
+      domains: [domain],
+    },
+    guidance: {
+      strategy: `${name} strategy`,
+      tactics: [`${name} tactic 1`, `${name} tactic 2`],
+    },
+    verification: {
+      successIndicators: ['Indicator'],
+      failureIndicators: ['Bad indicator'],
+    },
+    confidence: 0.8,
+    curatedBy: curatedBy ?? 'test',
+  });
+}
+
+describe('Recursive curated loading', () => {
+  let tempDir: string;
+  let library: PlaybookLibrary;
+  let persistence: ReturnType<typeof createSqlitePersistence>;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'curated-recursive-'));
+    persistence = createSqlitePersistence({ baseDir: tempDir });
+    await persistence.init();
+    library = createPlaybookLibrary(persistence);
+    await library.init();
+  });
+
+  afterEach(async () => {
+    await library.close();
+    persistence.close();
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('should load playbooks from nested subdirectories', async () => {
+    const sourceDir = join(tempDir, 'playbooks');
+    const subDir = join(sourceDir, 'code-review');
+    const deepDir = join(sourceDir, 'planning', 'deep');
+    await mkdir(subDir, { recursive: true });
+    await mkdir(deepDir, { recursive: true });
+
+    await writeFile(join(sourceDir, 'root.json'), makePlaybookJson('root-pb', 'general'));
+    await writeFile(join(subDir, 'review.json'), makePlaybookJson('review-pb', 'code-review'));
+    await writeFile(join(deepDir, 'plan.json'), makePlaybookJson('plan-pb', 'planning'));
+
+    const result = await loadCuratedPlaybooks(sourceDir, library);
+
+    expect(result.loaded).toBe(3);
+    expect(result.errors).toEqual([]);
+
+    expect(await library.getByName('root-pb')).toBeDefined();
+    expect(await library.getByName('review-pb')).toBeDefined();
+    expect(await library.getByName('plan-pb')).toBeDefined();
+  });
+
+  it('should skip non-json files in subdirectories', async () => {
+    const sourceDir = join(tempDir, 'playbooks');
+    await mkdir(sourceDir);
+
+    await writeFile(join(sourceDir, 'valid.json'), makePlaybookJson('valid-pb', 'general'));
+    await writeFile(join(sourceDir, 'readme.md'), '# Not a playbook');
+    await writeFile(join(sourceDir, 'data.txt'), 'some text');
+
+    const result = await loadCuratedPlaybooks(sourceDir, library);
+    expect(result.loaded).toBe(1);
+  });
+});
+
+describe('Source-aware recreate (deleteByCuratedSource)', () => {
+  let tempDir: string;
+  let library: PlaybookLibrary;
+  let persistence: ReturnType<typeof createSqlitePersistence>;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'curated-source-'));
+    persistence = createSqlitePersistence({ baseDir: tempDir });
+    await persistence.init();
+    library = createPlaybookLibrary(persistence);
+    await library.init();
+  });
+
+  afterEach(async () => {
+    await library.close();
+    persistence.close();
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('should track source in provenance.sourceFile', async () => {
+    const sourceDir = join(tempDir, 'source-a');
+    await mkdir(sourceDir);
+    await writeFile(join(sourceDir, 'a.json'), makePlaybookJson('pb-a', 'general'));
+
+    await loadCuratedPlaybooks(sourceDir, library, {
+      sourceId: 'github:org/repo-a',
+    });
+
+    const pb = await library.getByName('pb-a');
+    expect(pb).toBeDefined();
+    expect(pb!.provenance?.sourceFile).toMatch(/^github:org\/repo-a:/);
+  });
+
+  it('should delete only playbooks from a specific source on recreate', async () => {
+    const sourceA = join(tempDir, 'source-a');
+    const sourceB = join(tempDir, 'source-b');
+    await mkdir(sourceA);
+    await mkdir(sourceB);
+
+    await writeFile(join(sourceA, 'a.json'), makePlaybookJson('pb-a', 'general'));
+    await writeFile(join(sourceB, 'b.json'), makePlaybookJson('pb-b', 'general'));
+
+    // Load from both sources
+    await loadCuratedPlaybooks(sourceA, library, { sourceId: 'source-a' });
+    await loadCuratedPlaybooks(sourceB, library, { sourceId: 'source-b' });
+    expect(await library.count()).toBe(2);
+
+    // Recreate only source-a
+    await loadCuratedPlaybooks(sourceA, library, {
+      sourceId: 'source-a',
+      recreate: true,
+    });
+
+    // source-b's playbook should still exist
+    expect(await library.count()).toBe(2);
+    expect(await library.getByName('pb-a')).toBeDefined();
+    expect(await library.getByName('pb-b')).toBeDefined();
+  });
+
+  it('should delete all curated when no sourceId on recreate', async () => {
+    const sourceA = join(tempDir, 'source-a');
+    const sourceB = join(tempDir, 'source-b');
+    await mkdir(sourceA);
+    await mkdir(sourceB);
+
+    await writeFile(join(sourceA, 'a.json'), makePlaybookJson('pb-a', 'general'));
+    await writeFile(join(sourceB, 'b.json'), makePlaybookJson('pb-b', 'general'));
+
+    await loadCuratedPlaybooks(sourceA, library, { sourceId: 'source-a' });
+    await loadCuratedPlaybooks(sourceB, library, { sourceId: 'source-b' });
+    expect(await library.count()).toBe(2);
+
+    // Recreate without sourceId — deletes all curated, then reloads source-a
+    await loadCuratedPlaybooks(sourceA, library, { recreate: true });
+
+    // Only source-a playbooks remain
+    expect(await library.count()).toBe(1);
+    expect(await library.getByName('pb-a')).toBeDefined();
+    expect(await library.getByName('pb-b')).toBeUndefined();
+  });
+
+  it('should handle malformed JSON gracefully and continue loading others', async () => {
+    const sourceDir = join(tempDir, 'source-mixed');
+    await mkdir(sourceDir);
+
+    await writeFile(join(sourceDir, 'good.json'), makePlaybookJson('good-pb', 'general'));
+    await writeFile(join(sourceDir, 'bad.json'), '{ this is not valid json !!!');
+    await writeFile(join(sourceDir, 'also-good.json'), makePlaybookJson('also-good-pb', 'general'));
+
+    const result = await loadCuratedPlaybooks(sourceDir, library);
+
+    expect(result.loaded).toBe(2);
+    expect(result.errors.length).toBe(1);
+    expect(result.errors[0].file).toBe('bad.json');
+    expect(result.errors[0].error).toContain('JSON');
+  });
+
+  it('should report error for JSON missing required fields', async () => {
+    const sourceDir = join(tempDir, 'source-invalid');
+    await mkdir(sourceDir);
+
+    // Valid JSON but missing required playbook fields
+    await writeFile(
+      join(sourceDir, 'incomplete.json'),
+      JSON.stringify({ name: 'only-name' }),
+    );
+    await writeFile(join(sourceDir, 'good.json'), makePlaybookJson('good-pb', 'general'));
+
+    const result = await loadCuratedPlaybooks(sourceDir, library);
+
+    expect(result.loaded).toBe(1);
+    expect(result.errors.length).toBe(1);
+    expect(result.errors[0].error).toContain('Missing required fields');
+  });
+
+  it('should return empty result for non-existent directory', async () => {
+    const result = await loadCuratedPlaybooks('/nonexistent/dir', library);
+    expect(result.loaded).toBe(0);
+    expect(result.skipped).toBe(0);
+    expect(result.errors).toEqual([]);
+    expect(result.recreated).toBe(false);
+  });
+
+  it('deleteByCuratedSource should only affect matching prefix', async () => {
+    const sourceDir = join(tempDir, 'source');
+    await mkdir(sourceDir);
+    await writeFile(join(sourceDir, 'x.json'), makePlaybookJson('pb-x', 'general'));
+    await writeFile(join(sourceDir, 'y.json'), makePlaybookJson('pb-y', 'general'));
+
+    await loadCuratedPlaybooks(sourceDir, library, { sourceId: 'github:org/repo' });
+    expect(await library.count()).toBe(2);
+
+    // Delete by a non-matching prefix
+    const deleted = await library.deleteByCuratedSource('github:other/repo');
+    expect(deleted).toBe(0);
+    expect(await library.count()).toBe(2);
+
+    // Delete by matching prefix
+    const deleted2 = await library.deleteByCuratedSource('github:org/repo');
+    expect(deleted2).toBe(2);
+    expect(await library.count()).toBe(0);
+  });
+});