cognitive-core 0.1.0 → 0.2.0

package/references/sessionlog/src/__tests__/event-log.test.ts

@@ -0,0 +1,183 @@
+/**
+ * Tests for the event log module (JSONL checkpoint event log).
+ *
+ * Covers:
+ * - appendCheckpointEvent writes valid JSONL
+ * - readCheckpointEvents returns events in order
+ * - Pruning with maxEvents keeps only the last N
+ * - Missing file returns empty array
+ * - Exports from the main index
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import {
+  appendCheckpointEvent,
+  readCheckpointEvents,
+  type CheckpointEvent,
+} from '../events/event-log.js';
+import { SESSIONLOG_EVENTS_FILE } from '../types.js';
+
+// Also verify re-exports from main index
+import {
+  appendCheckpointEvent as indexAppend,
+  readCheckpointEvents as indexRead,
+  SESSIONLOG_EVENTS_FILE as indexEventsFile,
+} from '../index.js';
+
+describe('event-log', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sessionlog-events-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  function makeEvent(id: string, overrides?: Partial<CheckpointEvent>): CheckpointEvent {
+    return {
+      type: 'checkpoint_committed',
+      timestamp: new Date().toISOString(),
+      checkpointID: id,
+      sessionID: 'sess-1',
+      agent: 'Claude Code',
+      filesTouched: ['src/app.ts'],
+      checkpointsCount: 1,
+      ...overrides,
+    };
+  }
+
+  function eventsFilePath(): string {
+    return path.join(tmpDir, SESSIONLOG_EVENTS_FILE);
+  }
+
+  describe('appendCheckpointEvent', () => {
+    it('should create the events file and write a JSONL line', async () => {
+      const event = makeEvent('cp-001');
+      await appendCheckpointEvent(tmpDir, event);
+
+      const raw = fs.readFileSync(eventsFilePath(), 'utf-8');
+      const lines = raw.trim().split('\n');
+      expect(lines).toHaveLength(1);
+
+      const parsed = JSON.parse(lines[0]);
+      expect(parsed.type).toBe('checkpoint_committed');
+      expect(parsed.checkpointID).toBe('cp-001');
+      expect(parsed.agent).toBe('Claude Code');
+    });
+
+    it('should append multiple events as separate lines', async () => {
+      await appendCheckpointEvent(tmpDir, makeEvent('cp-001'));
+      await appendCheckpointEvent(tmpDir, makeEvent('cp-002'));
+      await appendCheckpointEvent(tmpDir, makeEvent('cp-003'));
+
+      const raw = fs.readFileSync(eventsFilePath(), 'utf-8');
+      const lines = raw.trim().split('\n');
+      expect(lines).toHaveLength(3);
+      expect(JSON.parse(lines[0]).checkpointID).toBe('cp-001');
+      expect(JSON.parse(lines[2]).checkpointID).toBe('cp-003');
+    });
+
+    it('should include optional fields when present', async () => {
+      const event = makeEvent('cp-001', {
+        branch: 'feature/auth',
+        tokenUsage: {
+          inputTokens: 5000,
+          outputTokens: 1200,
+          cacheCreationTokens: 0,
+          cacheReadTokens: 3000,
+          apiCallCount: 8,
+        },
+      });
+      await appendCheckpointEvent(tmpDir, event);
+
+      const events = readCheckpointEvents(tmpDir);
+      expect(events[0].branch).toBe('feature/auth');
+      expect(events[0].tokenUsage?.inputTokens).toBe(5000);
+    });
+  });
+
+  describe('readCheckpointEvents', () => {
+    it('should return empty array for missing file', () => {
+      const events = readCheckpointEvents(tmpDir);
+      expect(events).toEqual([]);
+    });
+
+    it('should return events in chronological order', async () => {
+      await appendCheckpointEvent(tmpDir, makeEvent('cp-001'));
+      await appendCheckpointEvent(tmpDir, makeEvent('cp-002'));
+
+      const events = readCheckpointEvents(tmpDir);
+      expect(events).toHaveLength(2);
+      expect(events[0].checkpointID).toBe('cp-001');
+      expect(events[1].checkpointID).toBe('cp-002');
+    });
+
+    it('should skip malformed lines', async () => {
+      // Write a valid line, a bad line, and another valid line
+      const filePath = eventsFilePath();
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      fs.writeFileSync(
+        filePath,
+        JSON.stringify(makeEvent('cp-001')) +
+          '\n' +
+          'not valid json\n' +
+          JSON.stringify(makeEvent('cp-002')) +
+          '\n',
+      );
+
+      const events = readCheckpointEvents(tmpDir);
+      expect(events).toHaveLength(2);
+      expect(events[0].checkpointID).toBe('cp-001');
+      expect(events[1].checkpointID).toBe('cp-002');
+    });
+  });
+
+  describe('pruning with maxEvents', () => {
+    it('should keep only the last N events', async () => {
+      for (let i = 1; i <= 5; i++) {
+        await appendCheckpointEvent(tmpDir, makeEvent(`cp-${String(i).padStart(3, '0')}`), {
+          maxEvents: 3,
+        });
+      }
+
+      const events = readCheckpointEvents(tmpDir);
+      expect(events).toHaveLength(3);
+      expect(events[0].checkpointID).toBe('cp-003');
+      expect(events[1].checkpointID).toBe('cp-004');
+      expect(events[2].checkpointID).toBe('cp-005');
+    });
+
+    it('should not prune when maxEvents is 0', async () => {
+      for (let i = 1; i <= 5; i++) {
+        await appendCheckpointEvent(tmpDir, makeEvent(`cp-${String(i).padStart(3, '0')}`), {
+          maxEvents: 0,
+        });
+      }
+
+      const events = readCheckpointEvents(tmpDir);
+      expect(events).toHaveLength(5);
+    });
+
+    it('should not prune when maxEvents is undefined', async () => {
+      for (let i = 1; i <= 5; i++) {
+        await appendCheckpointEvent(tmpDir, makeEvent(`cp-${String(i).padStart(3, '0')}`));
+      }
+
+      const events = readCheckpointEvents(tmpDir);
+      expect(events).toHaveLength(5);
+    });
+  });
+
+  describe('exports', () => {
+    it('should export from main index', () => {
+      expect(indexAppend).toBe(appendCheckpointEvent);
+      expect(indexRead).toBe(readCheckpointEvents);
+      expect(indexEventsFile).toBe(SESSIONLOG_EVENTS_FILE);
+    });
+  });
+});

package/references/sessionlog/src/__tests__/flush-sentinel.test.ts

@@ -0,0 +1,105 @@
+/**
+ * Tests for prepareTranscript flush sentinel (Claude Code agent)
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { createClaudeCodeAgent } from '../agent/agents/claude-code.js';
+import { hasTranscriptPreparer } from '../agent/types.js';
+
+describe('Claude Code prepareTranscript', () => {
+  let tmpDir: string;
+  const agent = createClaudeCodeAgent();
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'flush-sentinel-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('should implement TranscriptPreparer', () => {
+    expect(hasTranscriptPreparer(agent)).toBe(true);
+  });
+
+  it('should resolve quickly when sentinel is present', async () => {
+    const transcriptPath = path.join(tmpDir, 'session.jsonl');
+    const now = new Date().toISOString();
+
+    // Write a transcript with the stop hook sentinel
+    const lines = [
+      JSON.stringify({ type: 'user', message: { content: 'hello' }, timestamp: now }),
+      JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: 'hi' }] },
+        timestamp: now,
+      }),
+      JSON.stringify({ type: 'hook_progress', message: 'hooks claude-code stop', timestamp: now }),
+    ];
+    fs.writeFileSync(transcriptPath, lines.join('\n') + '\n');
+
+    const start = Date.now();
+    await agent.prepareTranscript(transcriptPath);
+    const elapsed = Date.now() - start;
+
+    // Should find sentinel quickly (well under the 3s timeout)
+    expect(elapsed).toBeLessThan(1000);
+  });
+
+  it('should timeout gracefully when sentinel is missing', async () => {
+    const transcriptPath = path.join(tmpDir, 'session.jsonl');
+
+    // Write transcript WITHOUT sentinel
+    const lines = [
+      JSON.stringify({
+        type: 'user',
+        message: { content: 'hello' },
+        timestamp: new Date().toISOString(),
+      }),
+    ];
+    fs.writeFileSync(transcriptPath, lines.join('\n') + '\n');
+
+    const start = Date.now();
+    await agent.prepareTranscript(transcriptPath);
+    const elapsed = Date.now() - start;
+
+    // Should wait up to ~3s then proceed
+    expect(elapsed).toBeGreaterThanOrEqual(2500);
+    expect(elapsed).toBeLessThan(5000);
+  }, 10000);
+
+  it('should timeout gracefully when file does not exist', async () => {
+    const start = Date.now();
+    await agent.prepareTranscript(path.join(tmpDir, 'nonexistent.jsonl'));
+    const elapsed = Date.now() - start;
+
+    // Should wait up to ~3s then proceed
+    expect(elapsed).toBeGreaterThanOrEqual(2500);
+    expect(elapsed).toBeLessThan(5000);
+  }, 10000);
+
+  it('should ignore sentinel with old timestamp', async () => {
+    const transcriptPath = path.join(tmpDir, 'session.jsonl');
+
+    // Write a sentinel with a very old timestamp
+    const oldTimestamp = new Date(Date.now() - 60_000).toISOString();
+    const lines = [
+      JSON.stringify({
+        type: 'hook_progress',
+        message: 'hooks claude-code stop',
+        timestamp: oldTimestamp,
+      }),
+    ];
+    fs.writeFileSync(transcriptPath, lines.join('\n') + '\n');
+
+    const start = Date.now();
+    await agent.prepareTranscript(transcriptPath);
+    const elapsed = Date.now() - start;
+
+    // Old sentinel should be ignored, so we should timeout
+    expect(elapsed).toBeGreaterThanOrEqual(2500);
+  }, 10000);
+});

package/references/sessionlog/src/__tests__/gemini-agent.test.ts

@@ -0,0 +1,375 @@
+/**
+ * Tests for Gemini CLI Agent
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { createGeminiCLIAgent, parseGeminiTranscript } from '../agent/agents/gemini-cli.js';
+import { EventType } from '../types.js';
+
+describe('Gemini CLI Agent', () => {
+  const agent = createGeminiCLIAgent();
+
+  describe('basic properties', () => {
+    it('should have correct name and type', () => {
+      expect(agent.name).toBe('gemini');
+      expect(agent.type).toBe('Gemini CLI');
+      expect(agent.isPreview).toBe(true);
+    });
+
+    it('should protect .gemini directory', () => {
+      expect(agent.protectedDirs).toContain('.gemini');
+    });
+  });
+
+  describe('detectPresence', () => {
+    let tmpDir: string;
+
+    beforeEach(() => {
+      tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gemini-test-'));
+    });
+
+    afterEach(() => {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('should detect presence when .gemini dir exists', async () => {
+      fs.mkdirSync(path.join(tmpDir, '.gemini'));
+      expect(await agent.detectPresence(tmpDir)).toBe(true);
+    });
+
+    it('should return false when .gemini dir does not exist', async () => {
+      expect(await agent.detectPresence(tmpDir)).toBe(false);
+    });
+  });
+
+  describe('formatResumeCommand', () => {
+    it('should include session ID', () => {
+      const cmd = agent.formatResumeCommand('sess-123');
+      expect(cmd).toContain('sess-123');
+      expect(cmd).toContain('gemini');
+    });
+  });
+
+  describe('hookNames', () => {
+    it('should return all 11 hooks', () => {
+      const names = agent.hookNames();
+      expect(names).toHaveLength(11);
+      expect(names).toContain('session-start');
+      expect(names).toContain('session-end');
+      expect(names).toContain('before-agent');
+      expect(names).toContain('after-agent');
+      expect(names).toContain('before-model');
+      expect(names).toContain('after-model');
+      expect(names).toContain('pre-compress');
+    });
+  });
+
+  describe('parseHookEvent', () => {
+    it('should parse session-start event', () => {
+      const stdin = JSON.stringify({ session_id: 'gem-123' });
+      const event = agent.parseHookEvent('session-start', stdin);
+      expect(event).not.toBeNull();
+      expect(event!.type).toBe(EventType.SessionStart);
+      expect(event!.sessionID).toBe('gem-123');
+    });
+
+    it('should parse before-agent as TurnStart', () => {
+      const stdin = JSON.stringify({
+        session_id: 'gem-456',
+        prompt: 'Add a function',
+      });
+      const event = agent.parseHookEvent('before-agent', stdin);
+      expect(event).not.toBeNull();
+      expect(event!.type).toBe(EventType.TurnStart);
+    });
+
+    it('should parse after-agent as TurnEnd', () => {
+      const stdin = JSON.stringify({ session_id: 'gem-789' });
+      const event = agent.parseHookEvent('after-agent', stdin);
+      expect(event).not.toBeNull();
+      expect(event!.type).toBe(EventType.TurnEnd);
+    });
+
+    it('should parse pre-compress as Compaction', () => {
+      const stdin = JSON.stringify({ session_id: 'gem-111' });
+      const event = agent.parseHookEvent('pre-compress', stdin);
+      expect(event).not.toBeNull();
+      expect(event!.type).toBe(EventType.Compaction);
+    });
+
+    it('should return null for pass-through hooks', () => {
+      const stdin = JSON.stringify({ session_id: 'gem-222' });
+      expect(agent.parseHookEvent('before-tool', stdin)).toBeNull();
+      expect(agent.parseHookEvent('after-tool', stdin)).toBeNull();
+      expect(agent.parseHookEvent('before-model', stdin)).toBeNull();
+      expect(agent.parseHookEvent('notification', stdin)).toBeNull();
+    });
+
+    it('should return null for invalid JSON', () => {
+      expect(agent.parseHookEvent('session-start', 'bad')).toBeNull();
+    });
+  });
+
+  describe('parseGeminiTranscript', () => {
+    it('should parse string content', () => {
+      const data = JSON.stringify({
+        messages: [
+          { type: 'user', content: 'Hello' },
+          { type: 'gemini', content: 'Hi there' },
+        ],
+      });
+
+      const transcript = parseGeminiTranscript(data);
+      expect(transcript.messages).toHaveLength(2);
+      expect(transcript.messages[0].content).toBe('Hello');
+      expect(transcript.messages[1].content).toBe('Hi there');
+    });
+
+    it('should parse array content (text parts)', () => {
+      const data = JSON.stringify({
+        messages: [
+          {
+            type: 'gemini',
+            content: [{ text: 'Part 1' }, { text: 'Part 2' }],
+          },
+        ],
+      });
+
+      const transcript = parseGeminiTranscript(data);
+      expect(transcript.messages[0].content).toBe('Part 1\nPart 2');
+    });
+
+    it('should handle empty messages array', () => {
+      const data = JSON.stringify({ messages: [] });
+      const transcript = parseGeminiTranscript(data);
+      expect(transcript.messages).toHaveLength(0);
+    });
+
+    it('should preserve tool calls', () => {
+      const data = JSON.stringify({
+        messages: [
+          {
+            type: 'gemini',
+            content: 'Working on it...',
+            toolCalls: [{ id: 'tc1', name: 'edit_file', args: { path: 'foo.ts' } }],
+          },
+        ],
+      });
+
+      const transcript = parseGeminiTranscript(data);
+      expect(transcript.messages[0].toolCalls).toHaveLength(1);
+      expect(transcript.messages[0].toolCalls![0].name).toBe('edit_file');
+    });
+  });
+
+  describe('hook installation', () => {
+    let tmpDir: string;
+
+    beforeEach(() => {
+      tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gemini-hooks-'));
+      fs.mkdirSync(path.join(tmpDir, '.gemini'), { recursive: true });
+    });
+
+    afterEach(() => {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('should install hooks to .gemini/settings.json', async () => {
+      const count = await agent.installHooks(tmpDir);
+      expect(count).toBe(12);
+
+      const settingsPath = path.join(tmpDir, '.gemini', 'settings.json');
+      const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+      expect(settings.hooksConfig.enabled).toBe(true);
+      expect(settings.hooks).toBeDefined();
+    });
+
+    it('should be idempotent', async () => {
+      await agent.installHooks(tmpDir);
+      const count = await agent.installHooks(tmpDir);
+      expect(count).toBe(0);
+    });
+
+    it('should report hooks as installed', async () => {
+      expect(await agent.areHooksInstalled(tmpDir)).toBe(false);
+      await agent.installHooks(tmpDir);
+      expect(await agent.areHooksInstalled(tmpDir)).toBe(true);
+    });
+
+    it('should uninstall hooks', async () => {
+      await agent.installHooks(tmpDir);
+      await agent.uninstallHooks(tmpDir);
+      expect(await agent.areHooksInstalled(tmpDir)).toBe(false);
+    });
+  });
+
+  describe('TranscriptAnalyzer', () => {
+    let tmpDir: string;
+
+    beforeEach(() => {
+      tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gemini-transcript-'));
+    });
+
+    afterEach(() => {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('should get transcript position', async () => {
+      const transcriptPath = path.join(tmpDir, 'session.json');
+      fs.writeFileSync(
+        transcriptPath,
+        JSON.stringify({
+          messages: [
+            { type: 'user', content: 'Hello' },
+            { type: 'gemini', content: 'Hi' },
+            { type: 'user', content: 'Thanks' },
+          ],
+        }),
+      );
+
+      const pos = await agent.getTranscriptPosition(transcriptPath);
+      expect(pos).toBe(3);
+    });
+
+    it('should extract modified files from offset', async () => {
+      const transcriptPath = path.join(tmpDir, 'session.json');
+      fs.writeFileSync(
+        transcriptPath,
+        JSON.stringify({
+          messages: [
+            { type: 'user', content: 'Fix the file' },
+            {
+              type: 'gemini',
+              content: 'Done',
+              toolCalls: [
+                { id: 'tc1', name: 'edit_file', args: { file_path: 'src/app.ts' } },
+                { id: 'tc2', name: 'write_file', args: { path: 'src/utils.ts' } },
+              ],
+            },
+          ],
+        }),
+      );
+
+      const result = await agent.extractModifiedFilesFromOffset(transcriptPath, 0);
+      expect(result.files).toContain('src/app.ts');
+      expect(result.files).toContain('src/utils.ts');
+      expect(result.currentPosition).toBe(2);
+    });
+
+    it('should extract prompts from offset', async () => {
+      const transcriptPath = path.join(tmpDir, 'session.json');
+      fs.writeFileSync(
+        transcriptPath,
+        JSON.stringify({
+          messages: [
+            { type: 'user', content: 'First prompt' },
+            { type: 'gemini', content: 'Response' },
+            { type: 'user', content: 'Second prompt' },
+          ],
+        }),
+      );
+
+      const prompts = await agent.extractPrompts(transcriptPath, 0);
+      expect(prompts).toEqual(['First prompt', 'Second prompt']);
+    });
+
+    it('should extract prompts from specific offset', async () => {
+      const transcriptPath = path.join(tmpDir, 'session.json');
+      fs.writeFileSync(
+        transcriptPath,
+        JSON.stringify({
+          messages: [
+            { type: 'user', content: 'Old prompt' },
+            { type: 'gemini', content: 'Response' },
+            { type: 'user', content: 'New prompt' },
+          ],
+        }),
+      );
+
+      const prompts = await agent.extractPrompts(transcriptPath, 2);
+      expect(prompts).toEqual(['New prompt']);
+    });
+
+    it('should extract last assistant response as summary', async () => {
+      const transcriptPath = path.join(tmpDir, 'session.json');
+      fs.writeFileSync(
+        transcriptPath,
+        JSON.stringify({
+          messages: [
+            { type: 'user', content: 'Do something' },
+            { type: 'gemini', content: 'First response' },
+            { type: 'user', content: 'More' },
+            { type: 'gemini', content: 'Final response' },
+          ],
+        }),
+      );
+
+      const summary = await agent.extractSummary(transcriptPath);
+      expect(summary).toBe('Final response');
+    });
+  });
+
+  describe('TokenCalculator', () => {
+    it('should calculate token usage from transcript', async () => {
+      const data = Buffer.from(
+        JSON.stringify({
+          messages: [
+            { type: 'user', content: 'Hello' },
+            { type: 'gemini', content: 'Hi', tokens: { input: 100, output: 50, cached: 10 } },
+            { type: 'user', content: 'More' },
+            { type: 'gemini', content: 'Done', tokens: { input: 200, output: 100, cached: 20 } },
+          ],
+        }),
+      );
+
+      const usage = await agent.calculateTokenUsage(data, 0);
+      expect(usage.inputTokens).toBe(300);
+      expect(usage.outputTokens).toBe(150);
+      expect(usage.cacheReadTokens).toBe(30);
+      expect(usage.apiCallCount).toBe(2);
+    });
+
+    it('should calculate from offset', async () => {
+      const data = Buffer.from(
+        JSON.stringify({
+          messages: [
+            { type: 'gemini', content: 'Old', tokens: { input: 100, output: 50, cached: 0 } },
+            { type: 'gemini', content: 'New', tokens: { input: 200, output: 100, cached: 0 } },
+          ],
+        }),
+      );
+
+      const usage = await agent.calculateTokenUsage(data, 1);
+      expect(usage.inputTokens).toBe(200);
+      expect(usage.outputTokens).toBe(100);
+      expect(usage.apiCallCount).toBe(1);
+    });
+  });
+
+  describe('TranscriptChunker', () => {
+    it('should chunk large transcripts', async () => {
+      const messages = Array.from({ length: 50 }, (_, i) => ({
+        type: i % 2 === 0 ? 'user' : 'gemini',
+        content: 'x'.repeat(100),
+      }));
+      const content = Buffer.from(JSON.stringify({ messages }));
+      const chunks = await agent.chunkTranscript(content, 500);
+      expect(chunks.length).toBeGreaterThan(1);
+    });
+
+    it('should reassemble chunks back', async () => {
+      const messages = [
+        { type: 'user', content: 'Hello' },
+        { type: 'gemini', content: 'World' },
+      ];
+      const content = Buffer.from(JSON.stringify({ messages }));
+      const chunks = await agent.chunkTranscript(content, 50);
+      const reassembled = await agent.reassembleTranscript(chunks);
+      const parsed = JSON.parse(reassembled.toString('utf-8'));
+      expect(parsed.messages).toHaveLength(2);
+    });
+  });
+});