cognitive-core 0.2.0 → 0.2.2

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

@@ -1,121 +0,0 @@
-/**
- * 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

@@ -1,166 +0,0 @@
-/**
- * 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

@@ -1,333 +0,0 @@
-/**
- * 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',
-    );
-  });
-});