cognitive-core 0.1.2 → 0.2.0

package/tests/integration/entire-e2e.test.ts

@@ -1,187 +1,376 @@
 /**
- * End-to-end integration test: SessionBank + EntireTrajectorySource
- * against REAL Entire CLI checkpoint data on the orphan branch.
+ * End-to-end integration test: SessionBank with both Entire CLI and
+ * SessionLog checkpoint formats, including auto-detection.
  *
- * This test reads data captured by the actual Entire CLI v0.4.6
- * (not fixtures) from the `entire/checkpoints/v1` orphan branch.
+ * Creates temp git repos with orphan branches containing fixture data.
  */
 import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { mkdtemp, rm, readFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { execFileSync } from 'node:child_process';
 import { SessionBank } from '../../src/session-bank/session-bank';
-import { EntireTrajectorySource } from '../../src/learning/trajectory-sources/entire';
+import { SessionTrajectorySource } from '../../src/learning/trajectory-sources/entire';
 
-describe('Entire CLI E2E Integration', () => {
-  let bank: SessionBank;
-  let source: EntireTrajectorySource;
+const FIXTURES = join(import.meta.dirname, '..', 'session-bank', 'fixtures');
+
+function git(cwd: string, args: string[]): string {
+  return execFileSync('git', ['-c', 'commit.gpgsign=false', ...args], {
+    cwd,
+    encoding: 'utf-8',
+    env: {
+      ...process.env,
+      GIT_AUTHOR_NAME: 'Test',
+      GIT_AUTHOR_EMAIL: 'test@test.com',
+      GIT_COMMITTER_NAME: 'Test',
+      GIT_COMMITTER_EMAIL: 'test@test.com',
+    },
+  }).trim();
+}
+
+function hashObject(cwd: string, content: string): string {
+  return execFileSync('git', ['hash-object', '-w', '--stdin'], {
+    cwd,
+    input: content,
+    encoding: 'utf-8',
+  }).trim();
+}
+
+function mktree(cwd: string, entries: string): string {
+  return execFileSync('git', ['mktree'], {
+    cwd,
+    input: entries,
+    encoding: 'utf-8',
+  }).trim();
+}
+
+function commitTree(cwd: string, treeHash: string, message: string): string {
+  return execFileSync(
+    'git',
+    ['-c', 'commit.gpgsign=false', 'commit-tree', treeHash, '-m', message],
+    {
+      cwd,
+      encoding: 'utf-8',
+      env: {
+        ...process.env,
+        GIT_AUTHOR_NAME: 'Test',
+        GIT_AUTHOR_EMAIL: 'test@test.com',
+        GIT_COMMITTER_NAME: 'Test',
+        GIT_COMMITTER_EMAIL: 'test@test.com',
+      },
+    },
+  ).trim();
+}
+
+/** Create an orphan branch with fixture data. */
+async function addOrphanBranch(
+  tmpDir: string,
+  branchName: string,
+  opts: {
+    metadataFixture: string; // path relative to FIXTURES
+    transcriptFixture: string;
+    rootMetaFixture: string;
+    shard: string; // e.g. "a3"
+    rest: string; // e.g. "b2c4d5e6f7"
+    sessionIndex: string; // e.g. "0" or "1"
+  },
+): Promise<void> {
+  const metaContent = await readFile(
+    join(FIXTURES, ...opts.metadataFixture.split('/')),
+    'utf-8',
+  );
+  const transcriptContent = await readFile(
+    join(FIXTURES, ...opts.transcriptFixture.split('/')),
+    'utf-8',
+  );
+  const rootMetaContent = await readFile(
+    join(FIXTURES, opts.rootMetaFixture),
+    'utf-8',
+  );
+
+  const filler = hashObject(tmpDir, 'filler');
+  const metaHash = hashObject(tmpDir, metaContent);
+  const transHash = hashObject(tmpDir, transcriptContent);
+  const rootMetaHash = hashObject(tmpDir, rootMetaContent);
+
+  const sessionTree = mktree(
+    tmpDir,
+    [
+      `100644 blob ${filler}\tcontent_hash.txt`,
+      `100644 blob ${filler}\tcontext.md`,
+      `100644 blob ${transHash}\tfull.jsonl`,
+      `100644 blob ${metaHash}\tmetadata.json`,
+      `100644 blob ${filler}\tprompt.txt`,
+    ].join('\n') + '\n',
+  );
+
+  const checkpointTree = mktree(
+    tmpDir,
+    [
+      `040000 tree ${sessionTree}\t${opts.sessionIndex}`,
+      `100644 blob ${rootMetaHash}\tmetadata.json`,
+    ].join('\n') + '\n',
+  );
+
+  const shardTree = mktree(
+    tmpDir,
+    `040000 tree ${checkpointTree}\t${opts.rest}\n`,
+  );
+
+  const rootTree = mktree(tmpDir, `040000 tree ${shardTree}\t${opts.shard}\n`);
+
+  const orphanCommit = commitTree(tmpDir, rootTree, `checkpoint on ${branchName}`);
+  git(tmpDir, ['update-ref', `refs/heads/${branchName}`, orphanCommit]);
+}
+
+describe('Session Bank E2E', () => {
+  let tmpDir: string;
 
   beforeAll(async () => {
-    bank = new SessionBank({
-      repoPath: process.cwd(),
-      branch: 'entire/checkpoints/v1',
-      stateDir: '/tmp/atlas-e2e-test-state',
-      cache: true,
+    tmpDir = await mkdtemp(join(tmpdir(), 'e2e-session-bank-'));
+
+    // Initialize repo
+    git(tmpDir, ['init']);
+    const emptyTree = git(tmpDir, ['hash-object', '-t', 'tree', '/dev/null']);
+    const mainCommit = commitTree(tmpDir, emptyTree, 'initial');
+    git(tmpDir, ['update-ref', 'refs/heads/master', mainCommit]);
+
+    // Create Entire-format orphan branch
+    await addOrphanBranch(tmpDir, 'entire/checkpoints/v1', {
+      metadataFixture: 'simple-session/metadata.json',
+      transcriptFixture: 'simple-session/full.jsonl',
+      rootMetaFixture: 'root-metadata.json',
+      shard: 'a3',
+      rest: 'b2c4d5e6f7',
+      sessionIndex: '0',
     });
 
-    await bank.init();
-    source = new EntireTrajectorySource(bank);
+    // Create SessionLog-format orphan branch
+    await addOrphanBranch(tmpDir, 'sessionlog/checkpoints/v1', {
+      metadataFixture: 'sessionlog-session/metadata.json',
+      transcriptFixture: 'sessionlog-session/full.jsonl',
+      rootMetaFixture: 'sessionlog-root-metadata.json',
+      shard: 'c4',
+      rest: 'd5e6f7a8b9',
+      sessionIndex: '1',
+    });
   });
 
   afterAll(async () => {
-    if (bank) {
-      await bank.close();
-    }
+    if (tmpDir) await rm(tmpDir, { recursive: true, force: true });
   });
 
-  describe('SessionBank against real Entire data', () => {
-    it('should detect the orphan branch exists', () => {
-      expect(bank.isAvailable()).toBe(true);
-    });
+  // ─── Entire CLI format ──────────────────────────────────────
 
-    it('should list checkpoints from real data', async () => {
-      const checkpoints = await bank.listCheckpoints();
-      expect(checkpoints.length).toBeGreaterThanOrEqual(1);
+  describe('Entire CLI format (explicit branch)', () => {
+    it('should discover sessions from Entire branch', async () => {
+      const bank = new SessionBank({
+        repoPath: tmpDir,
+        branch: 'entire/checkpoints/v1',
+        stateDir: join(tmpDir, '.state-entire'),
+      });
+      await bank.init();
 
-      const checkpoint = checkpoints[0];
-      expect(checkpoint.checkpointId).toBeTruthy();
-      expect(checkpoint.path).toBeTruthy();
-      expect(checkpoint.sessionCount).toBeGreaterThanOrEqual(1);
-    });
+      expect(bank.isAvailable()).toBe(true);
+      expect(bank.getBranch()).toBe('entire/checkpoints/v1');
 
-    it('should discover sessions with metadata', async () => {
       const sessions = await bank.discover();
       expect(sessions.length).toBeGreaterThanOrEqual(1);
+      expect(sessions[0].sessionId).toContain('2026-01-08');
+      expect(sessions[0].metadata.agent).toBe('Claude Code');
 
-      const session = sessions[0];
-      expect(session.sessionId).toBe('test-session-e2e');
-      expect(session.metadata.agent).toBe('Claude Code');
-      expect(session.metadata.strategy).toBe('manual-commit');
-      expect(session.metadata.filesTouched).toContain('src/e2e-test-marker.ts');
-      expect(session.metadata.branch).toBe('claude/session-bank-design-41pv3');
+      await bank.close();
     });
 
-    it('should query sessions and load transcripts', async () => {
+    it('should query and load Entire transcripts', async () => {
+      const bank = new SessionBank({
+        repoPath: tmpDir,
+        branch: 'entire/checkpoints/v1',
+        stateDir: join(tmpDir, '.state-entire-q'),
+      });
+      await bank.init();
+
       const result = await bank.query();
       expect(result.sessions.length).toBeGreaterThanOrEqual(1);
-      expect(result.total).toBeGreaterThanOrEqual(1);
-
-      const session = result.sessions[0];
-      // Transcript should be loaded with actual messages
-      expect(session.transcript).toBeDefined();
-      expect(session.transcript.length).toBeGreaterThan(0);
+      expect(result.sessions[0].transcript.length).toBeGreaterThan(0);
 
-      // Check we have user messages (from "human" type in Entire JSONL)
-      const userMessages = session.transcript.filter(
-        (m) => m.role === 'user'
+      const userMessages = result.sessions[0].transcript.filter(
+        (m) => m.role === 'user',
       );
       expect(userMessages.length).toBeGreaterThan(0);
 
-      // Check we have assistant messages
-      const assistantMessages = session.transcript.filter(
-        (m) => m.role === 'assistant'
-      );
-      expect(assistantMessages.length).toBeGreaterThan(0);
+      await bank.close();
     });
 
-    it('should filter sessions by branch', async () => {
-      const result = await bank.query({
-        branch: 'claude/session-bank-design-41pv3',
+    it('should synthesize Entire sessions into trajectories', async () => {
+      const bank = new SessionBank({
+        repoPath: tmpDir,
+        branch: 'entire/checkpoints/v1',
+        stateDir: join(tmpDir, '.state-entire-t'),
       });
-      expect(result.sessions.length).toBeGreaterThanOrEqual(1);
+      await bank.init();
 
-      const noResults = await bank.query({
-        branch: 'nonexistent-branch',
-      });
-      expect(noResults.sessions.length).toBe(0);
+      const source = new SessionTrajectorySource(bank);
+      const items = await source.load();
+      expect(items.length).toBeGreaterThanOrEqual(1);
+
+      const { trajectory } = items[0];
+      expect(trajectory.id).toContain('sessionlog-');
+      expect(trajectory.metadata.source).toBe('sessionlog');
+      expect(trajectory.task.description).toBeTruthy();
+      expect(trajectory.steps.length).toBeGreaterThan(0);
+
+      await bank.close();
     });
+  });
+
+  // ─── SessionLog format ──────────────────────────────────────
 
-    it('should search across transcript content', async () => {
-      const result = await bank.query({
-        search: 'hello world',
+  describe('SessionLog format (explicit branch)', () => {
+    it('should discover sessions from SessionLog branch', async () => {
+      const bank = new SessionBank({
+        repoPath: tmpDir,
+        branch: 'sessionlog/checkpoints/v1',
+        stateDir: join(tmpDir, '.state-sl'),
       });
-      expect(result.sessions.length).toBeGreaterThanOrEqual(1);
-    });
+      await bank.init();
 
-    it('should count sessions', async () => {
-      const count = await bank.count();
-      expect(count).toBeGreaterThanOrEqual(1);
-    });
+      expect(bank.isAvailable()).toBe(true);
+      expect(bank.getBranch()).toBe('sessionlog/checkpoints/v1');
+
+      const sessions = await bank.discover();
+      expect(sessions.length).toBeGreaterThanOrEqual(1);
+      expect(sessions[0].sessionId).toContain('2026-02-15');
+      expect(sessions[0].metadata.agent).toBe('Claude Code');
 
-    it('should find session by ID', async () => {
-      const session = await bank.getBySessionId('test-session-e2e');
-      expect(session).toBeDefined();
-      expect(session!.sessionId).toBe('test-session-e2e');
+      await bank.close();
     });
-  });
 
-  describe('EntireTrajectorySource against real data', () => {
-    it('should count available trajectories', async () => {
-      const count = await source.count();
-      expect(count).toBeGreaterThanOrEqual(1);
+    it('should query and load SessionLog transcripts', async () => {
+      const bank = new SessionBank({
+        repoPath: tmpDir,
+        branch: 'sessionlog/checkpoints/v1',
+        stateDir: join(tmpDir, '.state-sl-q'),
+      });
+      await bank.init();
+
+      const result = await bank.query();
+      expect(result.sessions.length).toBeGreaterThanOrEqual(1);
+      expect(result.sessions[0].transcript.length).toBeGreaterThan(0);
+
+      await bank.close();
     });
 
-    it('should load and synthesize trajectories from real data', async () => {
+    it('should synthesize SessionLog sessions into trajectories', async () => {
+      const bank = new SessionBank({
+        repoPath: tmpDir,
+        branch: 'sessionlog/checkpoints/v1',
+        stateDir: join(tmpDir, '.state-sl-t'),
+      });
+      await bank.init();
+
+      const source = new SessionTrajectorySource(bank);
       const items = await source.load();
       expect(items.length).toBeGreaterThanOrEqual(1);
 
-      // load() returns TrajectoryWithAnalysis[]
       const { trajectory } = items[0];
-      expect(trajectory.id).toContain('entire-');
-      expect(trajectory.task).toBeDefined();
+      expect(trajectory.id).toContain('sessionlog-');
+      expect(trajectory.metadata.source).toBe('sessionlog');
       expect(trajectory.task.description).toBeTruthy();
-      expect(trajectory.steps).toBeDefined();
-      expect(trajectory.outcome).toBeDefined();
-      expect(trajectory.metadata).toBeDefined();
-
-      // Metadata should have Entire provenance
-      expect(trajectory.metadata?.source).toBe('entire');
-      expect(trajectory.metadata?.checkpointId).toBeTruthy();
-      expect(trajectory.metadata?.sessionId).toBe('test-session-e2e');
+
+      await bank.close();
     });
+  });
 
-    it('should extract steps from real tool_use blocks', async () => {
-      const items = await source.load();
-      const { trajectory } = items[0];
+  // ─── Default branch ─────────────────────────────────────────
 
-      // Our transcript had a Write tool_use
-      const writeStep = trajectory.steps.find(
-        (s) => s.action && s.action.includes('Write')
-      );
-      expect(writeStep).toBeDefined();
-      expect(writeStep!.action).toContain('Write');
-    });
+  describe('default branch', () => {
+    it('should use sessionlog/checkpoints/v1 by default', async () => {
+      const bank = new SessionBank({
+        repoPath: tmpDir,
+        stateDir: join(tmpDir, '.state-default'),
+      });
+      await bank.init();
 
-    it('should infer domain from files touched', async () => {
-      const items = await source.load();
-      const { trajectory } = items[0];
+      expect(bank.isAvailable()).toBe(true);
+      expect(bank.getBranch()).toBe('sessionlog/checkpoints/v1');
+
+      const sessions = await bank.discover();
+      expect(sessions.length).toBeGreaterThanOrEqual(1);
+      expect(sessions[0].sessionId).toContain('2026-02-15');
 
-      // Files touched include .ts files, so domain should be typescript
-      expect(trajectory.task.domain).toBe('typescript');
+      await bank.close();
     });
 
-    it('should determine outcome from real data', async () => {
-      const items = await source.load();
-      const { trajectory } = items[0];
+    it('should report unavailable when default branch missing', async () => {
+      // Create a repo with only an Entire branch (no sessionlog)
+      const noSl = await mkdtemp(join(tmpdir(), 'e2e-no-sl-'));
+      git(noSl, ['init']);
+      const emptyTree = git(noSl, [
+        'hash-object',
+        '-t',
+        'tree',
+        '/dev/null',
+      ]);
+      const mainCommit = commitTree(noSl, emptyTree, 'initial');
+      git(noSl, ['update-ref', 'refs/heads/master', mainCommit]);
+
+      await addOrphanBranch(noSl, 'entire/checkpoints/v1', {
+        metadataFixture: 'simple-session/metadata.json',
+        transcriptFixture: 'simple-session/full.jsonl',
+        rootMetaFixture: 'root-metadata.json',
+        shard: 'a3',
+        rest: 'b2c4d5e6f7',
+        sessionIndex: '0',
+      });
+
+      // No explicit branch — defaults to sessionlog, which doesn't exist
+      const bank = new SessionBank({
+        repoPath: noSl,
+        stateDir: join(noSl, '.state'),
+      });
+      await bank.init();
 
-      expect(trajectory.outcome.success).toBeDefined();
-      expect(typeof trajectory.outcome.success).toBe('boolean');
+      expect(bank.isAvailable()).toBe(false);
+
+      await bank.close();
+      await rm(noSl, { recursive: true, force: true });
     });
 
-    it('should produce valid Trajectory shape', async () => {
-      const items = await source.load();
-      const { trajectory } = items[0];
+    it('should use explicit entire branch when configured', async () => {
+      // Same repo — explicitly request Entire branch
+      const entireOnly = await mkdtemp(join(tmpdir(), 'e2e-entire-explicit-'));
+      git(entireOnly, ['init']);
+      const emptyTree = git(entireOnly, [
+        'hash-object',
+        '-t',
+        'tree',
+        '/dev/null',
+      ]);
+      const mainCommit = commitTree(entireOnly, emptyTree, 'initial');
+      git(entireOnly, ['update-ref', 'refs/heads/master', mainCommit]);
+
+      await addOrphanBranch(entireOnly, 'entire/checkpoints/v1', {
+        metadataFixture: 'simple-session/metadata.json',
+        transcriptFixture: 'simple-session/full.jsonl',
+        rootMetaFixture: 'root-metadata.json',
+        shard: 'a3',
+        rest: 'b2c4d5e6f7',
+        sessionIndex: '0',
+      });
 
-      expect(trajectory).toMatchObject({
-        id: expect.stringContaining('entire-'),
-        task: expect.objectContaining({
-          domain: expect.any(String),
-          description: expect.any(String),
-        }),
-        outcome: expect.objectContaining({
-          success: expect.any(Boolean),
-        }),
-        metadata: expect.objectContaining({
-          source: 'entire',
-        }),
+      const bank = new SessionBank({
+        repoPath: entireOnly,
+        branch: 'entire/checkpoints/v1',
+        stateDir: join(entireOnly, '.state'),
       });
+      await bank.init();
+
+      expect(bank.isAvailable()).toBe(true);
+      expect(bank.getBranch()).toBe('entire/checkpoints/v1');
+
+      await bank.close();
+      await rm(entireOnly, { recursive: true, force: true });
     });
   });
 });