cognitive-core 0.2.1 → 0.2.3

package/tests/integration/curated-sources-e2e.test.ts

@@ -0,0 +1,502 @@
+/**
+ * Integration test: Curated playbook sources (local + git)
+ *
+ * Verifies the full flow from Atlas config → source resolution → playbook
+ * loading → search/retrieval. Uses real git repos, real SQLite, no mocks.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { Atlas, createAtlas } from '../../src/atlas.js';
+import { mkdtemp, rm, mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { execFile as execFileCb } from 'node:child_process';
+import { promisify } from 'node:util';
+import { existsSync } from 'node:fs';
+
+const execFile = promisify(execFileCb);
+
+/**
+ * Helper: create a local bare git repo with playbook JSON files.
+ */
+async function createGitPlaybookRepo(
+  baseDir: string,
+  playbooks: Array<{
+    name: string;
+    domain: string;
+    situation: string;
+    confidence?: number;
+  }>,
+  opts?: { subdir?: string; manifest?: boolean; tag?: string },
+): Promise<string> {
+  const repoDir = join(baseDir, `bare-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`);
+  await mkdir(repoDir);
+  await execFile('git', ['init', '--bare', repoDir]);
+
+  const workDir = join(baseDir, `work-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`);
+  await mkdir(workDir);
+  await execFile('git', ['clone', repoDir, workDir]);
+  await execFile('git', ['config', 'commit.gpgSign', 'false'], { cwd: workDir });
+
+  const subdir = opts?.subdir ?? 'playbooks';
+  const pbDir = join(workDir, subdir);
+  await mkdir(pbDir, { recursive: true });
+
+  for (const pb of playbooks) {
+    await writeFile(
+      join(pbDir, `${pb.name}.json`),
+      JSON.stringify({
+        name: pb.name,
+        applicability: {
+          situations: [pb.situation],
+          triggers: [`${pb.name} trigger`],
+          domains: [pb.domain],
+        },
+        guidance: {
+          strategy: `Strategy for ${pb.name}`,
+          tactics: [`Tactic 1 for ${pb.name}`, `Tactic 2 for ${pb.name}`],
+        },
+        verification: {
+          successIndicators: [`${pb.name} succeeds`],
+          failureIndicators: [`${pb.name} fails`],
+        },
+        confidence: pb.confidence ?? 0.8,
+        curatedBy: 'integration-test',
+      }),
+    );
+  }
+
+  if (opts?.manifest) {
+    await writeFile(
+      join(workDir, 'cognitive-core.json'),
+      JSON.stringify({ playbooks: subdir, name: 'test-source' }),
+    );
+  }
+
+  await execFile('git', ['add', '.'], { cwd: workDir });
+  await execFile('git', ['commit', '-m', 'Add playbooks'], {
+    cwd: workDir,
+    env: {
+      ...process.env,
+      GIT_AUTHOR_NAME: 'Test',
+      GIT_AUTHOR_EMAIL: 'test@test.com',
+      GIT_COMMITTER_NAME: 'Test',
+      GIT_COMMITTER_EMAIL: 'test@test.com',
+    },
+  });
+  await execFile('git', ['push', 'origin', 'HEAD'], { cwd: workDir });
+
+  if (opts?.tag) {
+    await execFile('git', ['tag', opts.tag], { cwd: workDir });
+    await execFile('git', ['push', 'origin', opts.tag], { cwd: workDir });
+  }
+
+  return repoDir;
+}
+
+describe('Curated sources integration', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'curated-source-e2e-'));
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  // ========================================================================
+  // Local path sources
+  // ========================================================================
+
+  it('should load playbooks from a local path via sources[]', async () => {
+    // Create local playbooks directory
+    const localDir = join(tempDir, 'local-playbooks');
+    await mkdir(localDir);
+    await writeFile(
+      join(localDir, 'local-review.json'),
+      JSON.stringify({
+        name: 'local-review',
+        applicability: {
+          situations: ['Code review for local project'],
+          triggers: ['review needed'],
+          domains: ['code-review'],
+        },
+        guidance: {
+          strategy: 'Review code thoroughly',
+          tactics: ['Check logic', 'Check tests'],
+        },
+        confidence: 0.85,
+      }),
+    );
+
+    const atlas = createAtlas({
+      storage: { baseDir: join(tempDir, '.atlas') },
+      curatedPlaybooks: {
+        sources: [localDir],
+      },
+    });
+    await atlas.init();
+
+    const memory = atlas.getMemory();
+    expect(await memory.playbooks.count()).toBe(1);
+
+    const pb = await memory.playbooks.getByName('local-review');
+    expect(pb).toBeDefined();
+    expect(pb!.provenance?.origin).toBe('curated');
+    expect(pb!.confidence).toBe(0.85);
+
+    // Should be searchable
+    const matches = await memory.playbooks.findMatching('code review');
+    expect(matches.length).toBeGreaterThan(0);
+    expect(matches[0].playbook.name).toBe('local-review');
+
+    await atlas.close();
+  });
+
+  it('should load from local source with nested subdirectories', async () => {
+    const localDir = join(tempDir, 'nested-playbooks');
+    const subA = join(localDir, 'review');
+    const subB = join(localDir, 'planning', 'deep');
+    await mkdir(subA, { recursive: true });
+    await mkdir(subB, { recursive: true });
+
+    await writeFile(join(localDir, 'root.json'), JSON.stringify({
+      name: 'root-pb',
+      applicability: { situations: ['Root'], domains: ['general'] },
+      guidance: { strategy: 'Root', tactics: ['Root tactic'] },
+    }));
+    await writeFile(join(subA, 'review.json'), JSON.stringify({
+      name: 'nested-review',
+      applicability: { situations: ['Review'], domains: ['review'] },
+      guidance: { strategy: 'Review', tactics: ['Review tactic'] },
+    }));
+    await writeFile(join(subB, 'deep-plan.json'), JSON.stringify({
+      name: 'deep-plan',
+      applicability: { situations: ['Planning'], domains: ['planning'] },
+      guidance: { strategy: 'Plan', tactics: ['Plan tactic'] },
+    }));
+
+    const atlas = createAtlas({
+      storage: { baseDir: join(tempDir, '.atlas') },
+      curatedPlaybooks: { sources: [localDir] },
+    });
+    await atlas.init();
+
+    expect(await atlas.getMemory().playbooks.count()).toBe(3);
+    expect(await atlas.getMemory().playbooks.getByName('root-pb')).toBeDefined();
+    expect(await atlas.getMemory().playbooks.getByName('nested-review')).toBeDefined();
+    expect(await atlas.getMemory().playbooks.getByName('deep-plan')).toBeDefined();
+
+    await atlas.close();
+  });
+
+  // ========================================================================
+  // Git sources
+  // ========================================================================
+
+  it('should clone a git repo source and load its playbooks', async () => {
+    const repoDir = await createGitPlaybookRepo(tempDir, [
+      { name: 'git-review', domain: 'review', situation: 'Git-based code review' },
+      { name: 'git-planning', domain: 'planning', situation: 'Git-based planning' },
+    ]);
+
+    const atlas = createAtlas({
+      storage: { baseDir: join(tempDir, '.atlas') },
+      curatedPlaybooks: {
+        sources: [`git:${repoDir}`],
+      },
+    });
+    await atlas.init();
+
+    const memory = atlas.getMemory();
+    expect(await memory.playbooks.count()).toBe(2);
+
+    const review = await memory.playbooks.getByName('git-review');
+    expect(review).toBeDefined();
+    expect(review!.provenance?.origin).toBe('curated');
+    expect(review!.provenance?.sourceFile).toMatch(/^git:/);
+    expect(review!.provenance?.curatedBy).toBe('integration-test');
+
+    const planning = await memory.playbooks.getByName('git-planning');
+    expect(planning).toBeDefined();
+
+    // Verify searchable
+    const matches = await memory.playbooks.findMatching('code review');
+    expect(matches.some(m => m.playbook.name === 'git-review')).toBe(true);
+
+    await atlas.close();
+  });
+
+  it('should clone a git repo with tag ref', async () => {
+    const repoDir = await createGitPlaybookRepo(
+      tempDir,
+      [{ name: 'tagged-pb', domain: 'ops', situation: 'Tagged release' }],
+      { tag: 'v1.0.0' },
+    );
+
+    const atlas = createAtlas({
+      storage: { baseDir: join(tempDir, '.atlas') },
+      curatedPlaybooks: {
+        sources: [`git:${repoDir}#v1.0.0`],
+      },
+    });
+    await atlas.init();
+
+    expect(await atlas.getMemory().playbooks.count()).toBe(1);
+    expect(await atlas.getMemory().playbooks.getByName('tagged-pb')).toBeDefined();
+
+    await atlas.close();
+  });
+
+  it('should discover playbook dir via manifest', async () => {
+    const repoDir = await createGitPlaybookRepo(
+      tempDir,
+      [{ name: 'manifest-pb', domain: 'custom', situation: 'Custom dir via manifest' }],
+      { subdir: 'my-custom-dir', manifest: true },
+    );
+
+    const atlas = createAtlas({
+      storage: { baseDir: join(tempDir, '.atlas') },
+      curatedPlaybooks: {
+        sources: [`git:${repoDir}`],
+      },
+    });
+    await atlas.init();
+
+    expect(await atlas.getMemory().playbooks.count()).toBe(1);
+    expect(await atlas.getMemory().playbooks.getByName('manifest-pb')).toBeDefined();
+
+    await atlas.close();
+  });
+
+  // ========================================================================
+  // Mixed sources + bundled seed pack
+  // ========================================================================
+
+  it('should load from bundled + git + local sources simultaneously', async () => {
+    // Git source
+    const repoDir = await createGitPlaybookRepo(tempDir, [
+      { name: 'git-pb', domain: 'git-domain', situation: 'From git' },
+    ]);
+
+    // Local source
+    const localDir = join(tempDir, 'local-source');
+    await mkdir(localDir);
+    await writeFile(join(localDir, 'local.json'), JSON.stringify({
+      name: 'local-pb',
+      applicability: { situations: ['From local'], domains: ['local-domain'] },
+      guidance: { strategy: 'Local', tactics: ['Local tactic'] },
+    }));
+
+    const atlas = createAtlas({
+      storage: { baseDir: join(tempDir, '.atlas') },
+      curatedPlaybooks: {
+        loadBundledSeedPack: true,
+        sources: [`git:${repoDir}`, localDir],
+      },
+    });
+    await atlas.init();
+
+    const memory = atlas.getMemory();
+    const count = await memory.playbooks.count();
+    expect(count).toBe(27); // 25 bundled + 1 git + 1 local
+
+    expect(await memory.playbooks.getByName('git-pb')).toBeDefined();
+    expect(await memory.playbooks.getByName('local-pb')).toBeDefined();
+    expect(await memory.playbooks.getByName('review-orchestration')).toBeDefined(); // from bundled
+
+    await atlas.close();
+  });
+
+  // ========================================================================
+  // Persistence across restarts
+  // ========================================================================
+
+  it('should skip re-cloning on second init when SHA unchanged', async () => {
+    const repoDir = await createGitPlaybookRepo(tempDir, [
+      { name: 'persist-pb', domain: 'persist', situation: 'Persisted' },
+    ]);
+
+    const atlasDir = join(tempDir, '.atlas');
+    const config = {
+      storage: { baseDir: atlasDir },
+      curatedPlaybooks: {
+        sources: [`git:${repoDir}`],
+      },
+    };
+
+    // First init — clones and loads
+    const atlas1 = createAtlas(config);
+    await atlas1.init();
+    expect(await atlas1.getMemory().playbooks.count()).toBe(1);
+    await atlas1.close();
+
+    // Second init — should use cached SHA, skip reload
+    // Playbooks are already in SQLite from first init
+    const atlas2 = createAtlas(config);
+    await atlas2.init();
+    expect(await atlas2.getMemory().playbooks.count()).toBe(1);
+
+    const pb = await atlas2.getMemory().playbooks.getByName('persist-pb');
+    expect(pb).toBeDefined();
+
+    await atlas2.close();
+  });
+
+  it('should detect new commits and reload on next init', async () => {
+    const repoDir = await createGitPlaybookRepo(tempDir, [
+      { name: 'original-pb', domain: 'evolve', situation: 'Original version' },
+    ]);
+
+    const atlasDir = join(tempDir, '.atlas');
+    const config = {
+      storage: { baseDir: atlasDir },
+      curatedPlaybooks: {
+        sources: [`git:${repoDir}`],
+        cache: { maxAgeMs: 0 }, // always stale → always re-fetch
+        recreateOnInit: true,   // reload when updated
+      },
+    };
+
+    // First init
+    const atlas1 = createAtlas(config);
+    await atlas1.init();
+    expect(await atlas1.getMemory().playbooks.count()).toBe(1);
+    await atlas1.close();
+
+    // Push a new playbook to the repo
+    const workDir = join(tempDir, 'update-work');
+    await mkdir(workDir);
+    await execFile('git', ['clone', repoDir, workDir]);
+    await execFile('git', ['config', 'commit.gpgSign', 'false'], { cwd: workDir });
+    await writeFile(
+      join(workDir, 'playbooks', 'new-pb.json'),
+      JSON.stringify({
+        name: 'new-pb',
+        applicability: { situations: ['Newly added'], domains: ['evolve'] },
+        guidance: { strategy: 'New', tactics: ['New tactic'] },
+      }),
+    );
+    await execFile('git', ['add', '.'], { cwd: workDir });
+    await execFile('git', ['commit', '-m', 'Add new playbook'], {
+      cwd: workDir,
+      env: {
+        ...process.env,
+        GIT_AUTHOR_NAME: 'Test',
+        GIT_AUTHOR_EMAIL: 'test@test.com',
+        GIT_COMMITTER_NAME: 'Test',
+        GIT_COMMITTER_EMAIL: 'test@test.com',
+      },
+    });
+    await execFile('git', ['push', 'origin', 'HEAD'], { cwd: workDir });
+
+    // Second init — should detect new SHA and reload
+    const atlas2 = createAtlas(config);
+    await atlas2.init();
+    expect(await atlas2.getMemory().playbooks.count()).toBe(2);
+    expect(await atlas2.getMemory().playbooks.getByName('original-pb')).toBeDefined();
+    expect(await atlas2.getMemory().playbooks.getByName('new-pb')).toBeDefined();
+    await atlas2.close();
+  });
+
+  // ========================================================================
+  // Per-source recreate isolation
+  // ========================================================================
+
+  it('should recreate only the specified source without clobbering others', async () => {
+    const repoA = await createGitPlaybookRepo(tempDir, [
+      { name: 'source-a-pb', domain: 'a', situation: 'From source A' },
+    ]);
+    const repoB = await createGitPlaybookRepo(tempDir, [
+      { name: 'source-b-pb', domain: 'b', situation: 'From source B' },
+    ]);
+
+    const atlasDir = join(tempDir, '.atlas');
+
+    // First init with both sources
+    const atlas1 = createAtlas({
+      storage: { baseDir: atlasDir },
+      curatedPlaybooks: {
+        sources: [`git:${repoA}`, `git:${repoB}`],
+        cache: { maxAgeMs: 0 },
+        recreateOnInit: true,
+      },
+    });
+    await atlas1.init();
+    expect(await atlas1.getMemory().playbooks.count()).toBe(2);
+    await atlas1.close();
+
+    // Second init — recreate triggers per-source delete + reload
+    // Both sources should still have their playbooks
+    const atlas2 = createAtlas({
+      storage: { baseDir: atlasDir },
+      curatedPlaybooks: {
+        sources: [`git:${repoA}`, `git:${repoB}`],
+        cache: { maxAgeMs: 0 },
+        recreateOnInit: true,
+      },
+    });
+    await atlas2.init();
+    expect(await atlas2.getMemory().playbooks.count()).toBe(2);
+    expect(await atlas2.getMemory().playbooks.getByName('source-a-pb')).toBeDefined();
+    expect(await atlas2.getMemory().playbooks.getByName('source-b-pb')).toBeDefined();
+    await atlas2.close();
+  });
+
+  // ========================================================================
+  // Cache directory structure
+  // ========================================================================
+
+  it('should create cache directory under storage.baseDir', async () => {
+    const repoDir = await createGitPlaybookRepo(tempDir, [
+      { name: 'cache-test-pb', domain: 'cache', situation: 'Cache test' },
+    ]);
+
+    const atlasDir = join(tempDir, '.atlas');
+    const atlas = createAtlas({
+      storage: { baseDir: atlasDir },
+      curatedPlaybooks: {
+        sources: [`git:${repoDir}`],
+        cache: { dir: 'my-cache' },
+      },
+    });
+    await atlas.init();
+
+    // Verify cache dir was created
+    expect(existsSync(join(atlasDir, 'my-cache'))).toBe(true);
+
+    await atlas.close();
+  });
+
+  // ========================================================================
+  // Error resilience
+  // ========================================================================
+
+  it('should skip invalid git source and continue with others', async () => {
+    const localDir = join(tempDir, 'fallback-local');
+    await mkdir(localDir);
+    await writeFile(join(localDir, 'ok.json'), JSON.stringify({
+      name: 'fallback-pb',
+      applicability: { situations: ['Fallback'], domains: ['test'] },
+      guidance: { strategy: 'Fallback', tactics: ['Fallback'] },
+    }));
+
+    const atlas = createAtlas({
+      storage: { baseDir: join(tempDir, '.atlas') },
+      curatedPlaybooks: {
+        sources: [
+          'git:/nonexistent/repo/that/does/not/exist',
+          localDir,
+        ],
+      },
+    });
+    await atlas.init();
+
+    // Invalid git source should be skipped; local source should load
+    expect(await atlas.getMemory().playbooks.count()).toBe(1);
+    expect(await atlas.getMemory().playbooks.getByName('fallback-pb')).toBeDefined();
+
+    await atlas.close();
+  });
+});