cognitive-core 0.1.0 → 0.2.0

package/references/sessionlog/src/__tests__/transcript-timestamp.test.ts

@@ -0,0 +1,121 @@
+/**
+ * Tests for Transcript Timestamp Extraction
+ */
+
+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 {
+  parseTimestampFromJSONL,
+  getLastTimestampFromBytes,
+  getLastTimestampFromFile,
+} from '../utils/transcript-timestamp.js';
+
+describe('Transcript Timestamp Extraction', () => {
+  describe('parseTimestampFromJSONL', () => {
+    it('should parse valid ISO timestamp', () => {
+      const line = JSON.stringify({ timestamp: '2025-01-15T10:30:00Z', type: 'user' });
+      const result = parseTimestampFromJSONL(line);
+      expect(result).not.toBeNull();
+      expect(result!.toISOString()).toBe('2025-01-15T10:30:00.000Z');
+    });
+
+    it('should parse timestamp with offset', () => {
+      const line = JSON.stringify({ timestamp: '2025-06-15T10:30:00+05:00' });
+      const result = parseTimestampFromJSONL(line);
+      expect(result).not.toBeNull();
+    });
+
+    it('should return null for empty string', () => {
+      expect(parseTimestampFromJSONL('')).toBeNull();
+    });
+
+    it('should return null for invalid JSON', () => {
+      expect(parseTimestampFromJSONL('not json')).toBeNull();
+    });
+
+    it('should return null for missing timestamp field', () => {
+      const line = JSON.stringify({ type: 'user', message: 'hello' });
+      expect(parseTimestampFromJSONL(line)).toBeNull();
+    });
+
+    it('should return null for invalid timestamp', () => {
+      const line = JSON.stringify({ timestamp: 'not-a-date' });
+      expect(parseTimestampFromJSONL(line)).toBeNull();
+    });
+  });
+
+  describe('getLastTimestampFromBytes', () => {
+    it('should get timestamp from last line', () => {
+      const content = [
+        JSON.stringify({ timestamp: '2025-01-15T10:00:00Z', type: 'user' }),
+        JSON.stringify({ timestamp: '2025-01-15T10:05:00Z', type: 'assistant' }),
+        JSON.stringify({ timestamp: '2025-01-15T10:10:00Z', type: 'user' }),
+      ].join('\n');
+
+      const result = getLastTimestampFromBytes(content);
+      expect(result).not.toBeNull();
+      expect(result!.toISOString()).toBe('2025-01-15T10:10:00.000Z');
+    });
+
+    it('should skip trailing empty lines', () => {
+      const content = JSON.stringify({ timestamp: '2025-01-15T10:00:00Z' }) + '\n\n\n';
+      const result = getLastTimestampFromBytes(content);
+      expect(result).not.toBeNull();
+      expect(result!.toISOString()).toBe('2025-01-15T10:00:00.000Z');
+    });
+
+    it('should return null for empty content', () => {
+      expect(getLastTimestampFromBytes('')).toBeNull();
+      expect(getLastTimestampFromBytes(Buffer.alloc(0))).toBeNull();
+    });
+
+    it('should handle Buffer input', () => {
+      const buf = Buffer.from(JSON.stringify({ timestamp: '2025-01-15T10:00:00Z' }) + '\n');
+      const result = getLastTimestampFromBytes(buf);
+      expect(result).not.toBeNull();
+    });
+
+    it('should return null if no lines have timestamps', () => {
+      const content = [
+        JSON.stringify({ type: 'user' }),
+        JSON.stringify({ type: 'assistant' }),
+      ].join('\n');
+      expect(getLastTimestampFromBytes(content)).toBeNull();
+    });
+  });
+
+  describe('getLastTimestampFromFile', () => {
+    let tmpDir: string;
+
+    beforeEach(() => {
+      tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'timestamp-test-'));
+    });
+
+    afterEach(() => {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('should read timestamp from file', async () => {
+      const filePath = path.join(tmpDir, 'transcript.jsonl');
+      fs.writeFileSync(filePath, JSON.stringify({ timestamp: '2025-01-15T10:00:00Z' }) + '\n');
+
+      const result = await getLastTimestampFromFile(filePath);
+      expect(result).not.toBeNull();
+      expect(result!.toISOString()).toBe('2025-01-15T10:00:00.000Z');
+    });
+
+    it('should return null for missing file', async () => {
+      const result = await getLastTimestampFromFile('/nonexistent/file.jsonl');
+      expect(result).toBeNull();
+    });
+
+    it('should return null for file without timestamps', async () => {
+      const filePath = path.join(tmpDir, 'no-timestamps.jsonl');
+      fs.writeFileSync(filePath, JSON.stringify({ type: 'user' }) + '\n');
+      const result = await getLastTimestampFromFile(filePath);
+      expect(result).toBeNull();
+    });
+  });
+});

package/references/sessionlog/src/__tests__/types.test.ts

@@ -0,0 +1,166 @@
+/**
+ * Tests for Sessionlog Core Types
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  validateCheckpointID,
+  checkpointIDPath,
+  emptyTokenUsage,
+  addTokenUsage,
+  EventType,
+  CHECKPOINT_ID_LENGTH,
+  CHECKPOINT_ID_PATTERN,
+  AGENT_NAMES,
+  AGENT_TYPES,
+  DEFAULT_AGENT_NAME,
+} from '../types.js';
+
+describe('Sessionlog Types', () => {
+  describe('Agent Constants', () => {
+    it('should have expected agent names', () => {
+      expect(AGENT_NAMES.CLAUDE_CODE).toBe('claude-code');
+      expect(AGENT_NAMES.CURSOR).toBe('cursor');
+      expect(AGENT_NAMES.GEMINI).toBe('gemini');
+      expect(AGENT_NAMES.OPENCODE).toBe('opencode');
+    });
+
+    it('should have expected agent types', () => {
+      expect(AGENT_TYPES.CLAUDE_CODE).toBe('Claude Code');
+      expect(AGENT_TYPES.CURSOR).toBe('Cursor IDE');
+      expect(AGENT_TYPES.GEMINI).toBe('Gemini CLI');
+    });
+
+    it('should have Claude Code as default agent', () => {
+      expect(DEFAULT_AGENT_NAME).toBe('claude-code');
+    });
+  });
+
+  describe('EventType', () => {
+    it('should have task and plan mode event types', () => {
+      expect(EventType.TaskCreate).toBe(8);
+      expect(EventType.TaskUpdate).toBe(9);
+      expect(EventType.PlanModeEnter).toBe(10);
+      expect(EventType.PlanModeExit).toBe(11);
+    });
+
+    it('should not conflict with existing event types', () => {
+      const values = [
+        EventType.SessionStart,
+        EventType.TurnStart,
+        EventType.TurnEnd,
+        EventType.Compaction,
+        EventType.SessionEnd,
+        EventType.SubagentStart,
+        EventType.SubagentEnd,
+        EventType.TaskCreate,
+        EventType.TaskUpdate,
+        EventType.PlanModeEnter,
+        EventType.PlanModeExit,
+      ];
+      const unique = new Set(values);
+      expect(unique.size).toBe(values.length);
+    });
+  });
+
+  describe('Checkpoint ID', () => {
+    it('should validate correct checkpoint IDs', () => {
+      expect(validateCheckpointID('a3b2c4d5e6f7')).toBe(true);
+      expect(validateCheckpointID('000000000000')).toBe(true);
+      expect(validateCheckpointID('abcdef123456')).toBe(true);
+    });
+
+    it('should reject invalid checkpoint IDs', () => {
+      expect(validateCheckpointID('')).toBe(false);
+      expect(validateCheckpointID('short')).toBe(false);
+      expect(validateCheckpointID('a3b2c4d5e6f7g')).toBe(false); // too long
+      expect(validateCheckpointID('ABCDEF123456')).toBe(false); // uppercase
+      expect(validateCheckpointID('xxxxxxxxxxxx')).toBe(false); // non-hex
+    });
+
+    it('should shard checkpoint ID into path', () => {
+      expect(checkpointIDPath('a3b2c4d5e6f7')).toBe('a3/b2c4d5e6f7');
+      expect(checkpointIDPath('00abcdef1234')).toBe('00/abcdef1234');
+    });
+
+    it('should have correct ID length constant', () => {
+      expect(CHECKPOINT_ID_LENGTH).toBe(12);
+    });
+
+    it('should have correct ID pattern', () => {
+      expect(CHECKPOINT_ID_PATTERN.test('a3b2c4d5e6f7')).toBe(true);
+      expect(CHECKPOINT_ID_PATTERN.test('invalid')).toBe(false);
+    });
+  });
+
+  describe('Token Usage', () => {
+    it('should create empty token usage', () => {
+      const usage = emptyTokenUsage();
+      expect(usage.inputTokens).toBe(0);
+      expect(usage.outputTokens).toBe(0);
+      expect(usage.cacheCreationTokens).toBe(0);
+      expect(usage.cacheReadTokens).toBe(0);
+      expect(usage.apiCallCount).toBe(0);
+      expect(usage.subagentTokens).toBeUndefined();
+    });
+
+    it('should add token usage', () => {
+      const a = {
+        inputTokens: 100,
+        outputTokens: 50,
+        cacheCreationTokens: 10,
+        cacheReadTokens: 5,
+        apiCallCount: 2,
+      };
+      const b = {
+        inputTokens: 200,
+        outputTokens: 100,
+        cacheCreationTokens: 20,
+        cacheReadTokens: 10,
+        apiCallCount: 3,
+      };
+
+      const result = addTokenUsage(a, b);
+      expect(result.inputTokens).toBe(300);
+      expect(result.outputTokens).toBe(150);
+      expect(result.cacheCreationTokens).toBe(30);
+      expect(result.cacheReadTokens).toBe(15);
+      expect(result.apiCallCount).toBe(5);
+    });
+
+    it('should handle subagent tokens in addition', () => {
+      const a = {
+        inputTokens: 100,
+        outputTokens: 50,
+        cacheCreationTokens: 0,
+        cacheReadTokens: 0,
+        apiCallCount: 1,
+        subagentTokens: {
+          inputTokens: 50,
+          outputTokens: 25,
+          cacheCreationTokens: 0,
+          cacheReadTokens: 0,
+          apiCallCount: 1,
+        },
+      };
+      const b = {
+        inputTokens: 100,
+        outputTokens: 50,
+        cacheCreationTokens: 0,
+        cacheReadTokens: 0,
+        apiCallCount: 1,
+      };
+
+      const result = addTokenUsage(a, b);
+      expect(result.subagentTokens).toBeDefined();
+      expect(result.subagentTokens!.inputTokens).toBe(50);
+    });
+
+    it('should return undefined subagent when neither has it', () => {
+      const a = emptyTokenUsage();
+      const b = emptyTokenUsage();
+      const result = addTokenUsage(a, b);
+      expect(result.subagentTokens).toBeUndefined();
+    });
+  });
+});

package/references/sessionlog/src/__tests__/utils.test.ts

@@ -0,0 +1,333 @@
+/**
+ * Tests for Utility Modules
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  truncateRunes,
+  collapseWhitespace,
+  capitalizeFirst,
+  countLines,
+} from '../utils/string-utils.js';
+import {
+  parseFromBytes,
+  parseFromBytesAtLine,
+  sliceFromLine,
+  extractUserContent,
+} from '../utils/transcript-parse.js';
+import { stripIDEContextTags } from '../utils/ide-tags.js';
+import { normalizeStoredPath } from '../utils/paths.js';
+import {
+  parseCheckpoint,
+  parseAllSessions,
+  parseStrategy,
+  formatStrategy,
+  formatCheckpoint,
+  formatShadowCommit,
+} from '../utils/trailers.js';
+
+describe('String Utils', () => {
+  describe('truncateRunes', () => {
+    it('should not truncate short strings', () => {
+      expect(truncateRunes('hello', 10)).toBe('hello');
+    });
+
+    it('should truncate long strings with suffix', () => {
+      expect(truncateRunes('hello world', 5)).toBe('hello...');
+    });
+
+    it('should use custom suffix', () => {
+      expect(truncateRunes('hello world', 5, '…')).toBe('hello…');
+    });
+
+    it('should handle empty string', () => {
+      expect(truncateRunes('', 5)).toBe('');
+    });
+
+    it('should handle multi-byte characters correctly', () => {
+      const emoji = '😀😁😂🤣😃';
+      expect(truncateRunes(emoji, 3)).toBe('😀😁😂...');
+    });
+  });
+
+  describe('collapseWhitespace', () => {
+    it('should collapse multiple spaces', () => {
+      expect(collapseWhitespace('hello   world')).toBe('hello world');
+    });
+
+    it('should collapse newlines', () => {
+      expect(collapseWhitespace('hello\n\nworld')).toBe('hello world');
+    });
+
+    it('should trim', () => {
+      expect(collapseWhitespace('  hello  ')).toBe('hello');
+    });
+  });
+
+  describe('capitalizeFirst', () => {
+    it('should capitalize first letter', () => {
+      expect(capitalizeFirst('hello')).toBe('Hello');
+    });
+
+    it('should handle empty string', () => {
+      expect(capitalizeFirst('')).toBe('');
+    });
+  });
+
+  describe('countLines', () => {
+    it('should count 0 for empty', () => {
+      expect(countLines('')).toBe(0);
+    });
+
+    it('should count 1 for no newline', () => {
+      expect(countLines('hello')).toBe(1);
+    });
+
+    it('should count correctly with newlines', () => {
+      expect(countLines('a\nb\nc\n')).toBe(3);
+    });
+
+    it('should count extra line without trailing newline', () => {
+      expect(countLines('a\nb\nc')).toBe(3);
+    });
+  });
+});
+
+describe('Transcript Parse', () => {
+  describe('parseFromBytes', () => {
+    it('should parse JSONL content', () => {
+      const jsonl = [
+        JSON.stringify({ type: 'user', message: { content: 'Hello' } }),
+        JSON.stringify({ type: 'assistant', message: { content: 'Hi' } }),
+      ].join('\n');
+
+      const lines = parseFromBytes(jsonl);
+      expect(lines).toHaveLength(2);
+      expect(lines[0].type).toBe('user');
+      expect(lines[1].type).toBe('assistant');
+    });
+
+    it('should skip malformed JSON lines', () => {
+      const input = '{"type":"user"}\nnot json\n{"type":"assistant"}\n';
+      const lines = parseFromBytes(input);
+      expect(lines).toHaveLength(2);
+    });
+
+    it('should handle buffer input', () => {
+      const buf = Buffer.from('{"type":"user"}\n');
+      const lines = parseFromBytes(buf);
+      expect(lines).toHaveLength(1);
+    });
+
+    it('should normalize role to type (Cursor format)', () => {
+      const input = JSON.stringify({ role: 'user', message: {} });
+      const lines = parseFromBytes(input);
+      expect(lines[0].type).toBe('user');
+    });
+  });
+
+  describe('parseFromBytesAtLine', () => {
+    it('should parse from a specific line', () => {
+      const jsonl = [
+        JSON.stringify({ type: 'user', message: { content: 'First' } }),
+        JSON.stringify({ type: 'assistant', message: { content: 'Second' } }),
+        JSON.stringify({ type: 'user', message: { content: 'Third' } }),
+      ].join('\n');
+
+      const lines = parseFromBytesAtLine(jsonl, 2);
+      expect(lines).toHaveLength(1);
+      expect(lines[0].type).toBe('user');
+    });
+  });
+
+  describe('sliceFromLine', () => {
+    it('should return full buffer for startLine 0', () => {
+      const buf = Buffer.from('line0\nline1\nline2\n');
+      const sliced = sliceFromLine(buf, 0);
+      expect(sliced.toString()).toBe('line0\nline1\nline2\n');
+    });
+
+    it('should slice from line 1', () => {
+      const buf = Buffer.from('line0\nline1\nline2\n');
+      const sliced = sliceFromLine(buf, 1);
+      expect(sliced.toString()).toBe('line1\nline2\n');
+    });
+
+    it('should slice from line 2', () => {
+      const buf = Buffer.from('line0\nline1\nline2\n');
+      const sliced = sliceFromLine(buf, 2);
+      expect(sliced.toString()).toBe('line2\n');
+    });
+
+    it('should return empty for out-of-range', () => {
+      const buf = Buffer.from('line0\nline1\n');
+      const sliced = sliceFromLine(buf, 10);
+      expect(sliced.length).toBe(0);
+    });
+
+    it('should handle empty buffer', () => {
+      const sliced = sliceFromLine(Buffer.alloc(0), 0);
+      expect(sliced.length).toBe(0);
+    });
+  });
+
+  describe('extractUserContent', () => {
+    it('should extract string content', () => {
+      expect(extractUserContent({ content: 'Hello world' })).toBe('Hello world');
+    });
+
+    it('should extract array content', () => {
+      const msg = {
+        content: [
+          { type: 'text', text: 'Part 1' },
+          { type: 'image', data: 'base64' },
+          { type: 'text', text: 'Part 2' },
+        ],
+      };
+      expect(extractUserContent(msg)).toBe('Part 1\n\nPart 2');
+    });
+
+    it('should return empty for null', () => {
+      expect(extractUserContent(null)).toBe('');
+    });
+
+    it('should strip IDE context tags', () => {
+      const msg = { content: '<ide_opened_file>foo.ts</ide_opened_file>Hello' };
+      const result = extractUserContent(msg);
+      expect(result).not.toContain('ide_opened_file');
+      expect(result).toContain('Hello');
+    });
+  });
+});
+
+describe('IDE Tags', () => {
+  describe('stripIDEContextTags', () => {
+    it('should strip ide_opened_file tags', () => {
+      expect(stripIDEContextTags('<ide_opened_file>foo.ts</ide_opened_file>Code here')).toBe(
+        'Code here',
+      );
+    });
+
+    it('should strip ide_selection tags', () => {
+      expect(stripIDEContextTags('Text <ide_selection>selected</ide_selection> more')).toBe(
+        'Text  more',
+      );
+    });
+
+    it('should strip system-reminder tags', () => {
+      expect(stripIDEContextTags('<system-reminder>stuff</system-reminder>Content')).toBe(
+        'Content',
+      );
+    });
+
+    it('should strip user_query tags but keep content', () => {
+      expect(stripIDEContextTags('<user_query>Hello world</user_query>')).toBe('Hello world');
+    });
+
+    it('should handle text without tags', () => {
+      expect(stripIDEContextTags('Just normal text')).toBe('Just normal text');
+    });
+  });
+});
+
+describe('Trailers', () => {
+  describe('parseCheckpoint', () => {
+    it('should parse checkpoint from trailer', () => {
+      const message = 'Some commit\n\nSessionlog-Checkpoint: abc123def456';
+      const [cpID, found] = parseCheckpoint(message);
+      expect(found).toBe(true);
+      expect(cpID).toBe('abc123def456');
+    });
+
+    it('should return null for no checkpoint', () => {
+      const [cpID, found] = parseCheckpoint('Simple commit message');
+      expect(found).toBe(false);
+      expect(cpID).toBeNull();
+    });
+  });
+
+  describe('parseAllSessions', () => {
+    it('should parse session IDs from trailers', () => {
+      const message = 'Commit\n\nSessionlog-Session: session-1\nSessionlog-Session: session-2';
+      const sessions = parseAllSessions(message);
+      expect(sessions).toContain('session-1');
+      expect(sessions).toContain('session-2');
+    });
+
+    it('should return empty for no sessions', () => {
+      const sessions = parseAllSessions('Simple message');
+      expect(sessions).toHaveLength(0);
+    });
+  });
+
+  describe('parseStrategy', () => {
+    it('should parse strategy from trailer', () => {
+      const message = 'Commit\n\nSessionlog-Strategy: manual';
+      const [strategy, found] = parseStrategy(message);
+      expect(found).toBe(true);
+      expect(strategy).toBe('manual');
+    });
+
+    it('should return empty for no strategy', () => {
+      const [strategy, found] = parseStrategy('Simple message');
+      expect(found).toBe(false);
+      expect(strategy).toBe('');
+    });
+  });
+
+  describe('format functions', () => {
+    it('should format strategy trailer', () => {
+      const result = formatStrategy('Fix bug', 'manual');
+      expect(result).toContain('Fix bug');
+      expect(result).toContain('Sessionlog-Strategy: manual');
+    });
+
+    it('should format checkpoint trailer', () => {
+      const result = formatCheckpoint('Add feature', 'abc123def456' as any);
+      expect(result).toContain('Add feature');
+      expect(result).toContain('Sessionlog-Checkpoint: abc123def456');
+    });
+
+    it('should format shadow commit with session', () => {
+      const result = formatShadowCommit('Update code', 'meta/dir', 'session-1');
+      expect(result).toContain('Update code');
+      expect(result).toContain('Sessionlog-Metadata: meta/dir');
+      expect(result).toContain('Sessionlog-Session: session-1');
+      expect(result).toContain('Sessionlog-Strategy: manual-commit');
+    });
+  });
+});
+
+describe('normalizeStoredPath', () => {
+  const cwd = '/Users/alex/project';
+
+  it('should make paths under CWD relative', () => {
+    expect(normalizeStoredPath('/Users/alex/project/src/app.ts', cwd)).toBe('src/app.ts');
+  });
+
+  it('should keep paths outside CWD absolute', () => {
+    expect(normalizeStoredPath('/Users/alex/.claude/plans/plan.md', cwd)).toBe(
+      '/Users/alex/.claude/plans/plan.md',
+    );
+  });
+
+  it('should return already-relative paths unchanged', () => {
+    expect(normalizeStoredPath('src/app.ts', cwd)).toBe('src/app.ts');
+  });
+
+  it('should handle CWD root path', () => {
+    expect(normalizeStoredPath('/Users/alex/project', cwd)).toBe('');
+  });
+
+  it('should handle paths with shared prefix but outside CWD', () => {
+    expect(normalizeStoredPath('/Users/alex/project-other/file.ts', cwd)).toBe(
+      '/Users/alex/project-other/file.ts',
+    );
+  });
+
+  it('should handle deeply nested paths under CWD', () => {
+    expect(normalizeStoredPath('/Users/alex/project/src/hooks/lifecycle.ts', cwd)).toBe(
+      'src/hooks/lifecycle.ts',
+    );
+  });
+});