cognitive-core 0.2.1 → 0.2.2

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

@@ -1,338 +0,0 @@
-/**
- * Tests for OpenCode 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 {
-  createOpenCodeAgent,
-  extractTextFromParts,
-  parseExportSession,
-  extractAllUserPrompts,
-} from '../agent/agents/opencode.js';
-import { EventType } from '../types.js';
-
-describe('OpenCode Agent', () => {
-  const agent = createOpenCodeAgent();
-
-  describe('basic properties', () => {
-    it('should have correct name and type', () => {
-      expect(agent.name).toBe('opencode');
-      expect(agent.type).toBe('OpenCode');
-      expect(agent.isPreview).toBe(true);
-    });
-
-    it('should protect .opencode directory', () => {
-      expect(agent.protectedDirs).toContain('.opencode');
-    });
-  });
-
-  describe('detectPresence', () => {
-    let tmpDir: string;
-
-    beforeEach(() => {
-      tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencode-test-'));
-    });
-
-    afterEach(() => {
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    });
-
-    it('should detect .opencode directory', async () => {
-      fs.mkdirSync(path.join(tmpDir, '.opencode'));
-      expect(await agent.detectPresence(tmpDir)).toBe(true);
-    });
-
-    it('should detect opencode.json', async () => {
-      fs.writeFileSync(path.join(tmpDir, 'opencode.json'), '{}');
-      expect(await agent.detectPresence(tmpDir)).toBe(true);
-    });
-
-    it('should return false when neither exists', async () => {
-      expect(await agent.detectPresence(tmpDir)).toBe(false);
-    });
-  });
-
-  describe('formatResumeCommand', () => {
-    it('should include session ID', () => {
-      const cmd = agent.formatResumeCommand('sess-abc');
-      expect(cmd).toBe('opencode -s sess-abc');
-    });
-
-    it('should handle empty session ID', () => {
-      const cmd = agent.formatResumeCommand('');
-      expect(cmd).toBe('opencode');
-    });
-  });
-
-  describe('resolveSessionFile', () => {
-    it('should resolve to JSON file', () => {
-      const result = agent.resolveSessionFile('/sessions', 'abc123');
-      expect(result).toBe(path.join('/sessions', 'abc123.json'));
-    });
-  });
-
-  describe('hookNames', () => {
-    it('should return all 5 hooks', () => {
-      const names = agent.hookNames();
-      expect(names).toHaveLength(5);
-      expect(names).toContain('session-start');
-      expect(names).toContain('session-end');
-      expect(names).toContain('turn-start');
-      expect(names).toContain('turn-end');
-      expect(names).toContain('compaction');
-    });
-  });
-
-  describe('parseHookEvent', () => {
-    it('should parse session-start', () => {
-      const stdin = JSON.stringify({ session_id: 'oc-123' });
-      const event = agent.parseHookEvent('session-start', stdin);
-      expect(event).not.toBeNull();
-      expect(event!.type).toBe(EventType.SessionStart);
-      expect(event!.sessionID).toBe('oc-123');
-    });
-
-    it('should parse turn-start with prompt', () => {
-      const stdin = JSON.stringify({ session_id: 'oc-456', prompt: 'Add tests' });
-      const event = agent.parseHookEvent('turn-start', stdin);
-      expect(event).not.toBeNull();
-      expect(event!.type).toBe(EventType.TurnStart);
-    });
-
-    it('should parse turn-end', () => {
-      const stdin = JSON.stringify({ session_id: 'oc-789' });
-      const event = agent.parseHookEvent('turn-end', stdin);
-      expect(event).not.toBeNull();
-      expect(event!.type).toBe(EventType.TurnEnd);
-    });
-
-    it('should parse compaction', () => {
-      const stdin = JSON.stringify({ session_id: 'oc-111' });
-      const event = agent.parseHookEvent('compaction', stdin);
-      expect(event).not.toBeNull();
-      expect(event!.type).toBe(EventType.Compaction);
-    });
-
-    it('should parse session-end', () => {
-      const stdin = JSON.stringify({ session_id: 'oc-222' });
-      const event = agent.parseHookEvent('session-end', stdin);
-      expect(event).not.toBeNull();
-      expect(event!.type).toBe(EventType.SessionEnd);
-    });
-
-    it('should return null for unknown hook', () => {
-      expect(agent.parseHookEvent('unknown', '{}')).toBeNull();
-    });
-
-    it('should return null for invalid JSON', () => {
-      expect(agent.parseHookEvent('session-start', 'bad')).toBeNull();
-    });
-  });
-
-  describe('hook installation', () => {
-    let tmpDir: string;
-
-    beforeEach(() => {
-      tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencode-hooks-'));
-    });
-
-    afterEach(() => {
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    });
-
-    it('should install plugin file', async () => {
-      const count = await agent.installHooks(tmpDir);
-      expect(count).toBe(5);
-
-      const pluginPath = path.join(tmpDir, '.opencode', 'plugins', 'sessionlog.ts');
-      const content = fs.readFileSync(pluginPath, 'utf-8');
-      expect(content).toContain('sessionlog enable --agent opencode');
-    });
-
-    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(), 'opencode-transcript-'));
-    });
-
-    afterEach(() => {
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    });
-
-    const sampleSession = {
-      info: { id: 'sess-1', title: 'Test' },
-      messages: [
-        {
-          info: { id: 'msg-1', role: 'user', time: { created: 1000 } },
-          parts: [{ type: 'text', text: 'Fix the bug' }],
-        },
-        {
-          info: { id: 'msg-2', role: 'assistant', time: { created: 1001 } },
-          parts: [
-            { type: 'text', text: 'I will fix it.' },
-            {
-              type: 'tool',
-              tool: 'edit',
-              state: { status: 'completed', input: { filePath: 'src/app.ts' } },
-            },
-          ],
-        },
-        {
-          info: { id: 'msg-3', role: 'user', time: { created: 1002 } },
-          parts: [{ type: 'text', text: 'Thanks' }],
-        },
-      ],
-    };
-
-    it('should get transcript position', async () => {
-      const transcriptPath = path.join(tmpDir, 'session.json');
-      fs.writeFileSync(transcriptPath, JSON.stringify(sampleSession));
-      const pos = await agent.getTranscriptPosition(transcriptPath);
-      expect(pos).toBe(3);
-    });
-
-    it('should extract modified files', async () => {
-      const transcriptPath = path.join(tmpDir, 'session.json');
-      fs.writeFileSync(transcriptPath, JSON.stringify(sampleSession));
-      const result = await agent.extractModifiedFilesFromOffset(transcriptPath, 0);
-      expect(result.files).toContain('src/app.ts');
-      expect(result.currentPosition).toBe(3);
-    });
-
-    it('should extract prompts', async () => {
-      const transcriptPath = path.join(tmpDir, 'session.json');
-      fs.writeFileSync(transcriptPath, JSON.stringify(sampleSession));
-      const prompts = await agent.extractPrompts(transcriptPath, 0);
-      expect(prompts).toEqual(['Fix the bug', 'Thanks']);
-    });
-
-    it('should extract summary from last assistant message', async () => {
-      const transcriptPath = path.join(tmpDir, 'session.json');
-      fs.writeFileSync(transcriptPath, JSON.stringify(sampleSession));
-      const summary = await agent.extractSummary(transcriptPath);
-      expect(summary).toBe('I will fix it.');
-    });
-  });
-
-  describe('TokenCalculator', () => {
-    it('should calculate token usage', async () => {
-      const session = {
-        info: { id: 'sess-1' },
-        messages: [
-          {
-            info: {
-              id: 'msg-1',
-              role: 'assistant',
-              time: { created: 1 },
-              tokens: { input: 100, output: 50, reasoning: 10, cache: { read: 5, write: 3 } },
-            },
-            parts: [{ type: 'text', text: 'Hello' }],
-          },
-          {
-            info: {
-              id: 'msg-2',
-              role: 'assistant',
-              time: { created: 2 },
-              tokens: { input: 200, output: 100, reasoning: 20, cache: { read: 10, write: 7 } },
-            },
-            parts: [{ type: 'text', text: 'World' }],
-          },
-        ],
-      };
-
-      const usage = await agent.calculateTokenUsage(Buffer.from(JSON.stringify(session)), 0);
-      expect(usage.inputTokens).toBe(300);
-      expect(usage.outputTokens).toBe(150);
-      expect(usage.cacheReadTokens).toBe(15);
-      expect(usage.cacheCreationTokens).toBe(10);
-      expect(usage.apiCallCount).toBe(2);
-    });
-  });
-});
-
-describe('OpenCode Exported Helpers', () => {
-  describe('extractTextFromParts', () => {
-    it('should extract text from parts', () => {
-      const parts = [
-        { type: 'text', text: 'Hello' },
-        { type: 'tool', tool: 'edit' },
-        { type: 'text', text: 'World' },
-      ];
-      expect(extractTextFromParts(parts)).toBe('Hello\nWorld');
-    });
-
-    it('should return empty for no text parts', () => {
-      const parts = [{ type: 'tool', tool: 'edit' }];
-      expect(extractTextFromParts(parts)).toBe('');
-    });
-  });
-
-  describe('parseExportSession', () => {
-    it('should parse valid session JSON', () => {
-      const data = JSON.stringify({
-        info: { id: 'sess-1' },
-        messages: [{ info: { id: 'msg-1', role: 'user', time: { created: 1 } }, parts: [] }],
-      });
-      const session = parseExportSession(data);
-      expect(session).not.toBeNull();
-      expect(session!.info.id).toBe('sess-1');
-      expect(session!.messages).toHaveLength(1);
-    });
-
-    it('should return null for empty input', () => {
-      expect(parseExportSession('')).toBeNull();
-      expect(parseExportSession('  ')).toBeNull();
-    });
-  });
-
-  describe('extractAllUserPrompts', () => {
-    it('should extract user prompts from session', () => {
-      const data = JSON.stringify({
-        info: { id: 'sess-1' },
-        messages: [
-          {
-            info: { id: 'msg-1', role: 'user', time: { created: 1 } },
-            parts: [{ type: 'text', text: 'First' }],
-          },
-          {
-            info: { id: 'msg-2', role: 'assistant', time: { created: 2 } },
-            parts: [{ type: 'text', text: 'Response' }],
-          },
-          {
-            info: { id: 'msg-3', role: 'user', time: { created: 3 } },
-            parts: [{ type: 'text', text: 'Second' }],
-          },
-        ],
-      });
-      const prompts = extractAllUserPrompts(data);
-      expect(prompts).toEqual(['First', 'Second']);
-    });
-
-    it('should return empty for empty data', () => {
-      expect(extractAllUserPrompts('')).toEqual([]);
-    });
-  });
-});

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

@@ -1,136 +0,0 @@
-/**
- * Tests for Secret Redaction
- */
-
-import { describe, it, expect } from 'vitest';
-import { shannonEntropy, detectSecrets, redactString, redactJSONL } from '../security/redaction.js';
-
-describe('Secret Redaction', () => {
-  describe('shannonEntropy', () => {
-    it('should return 0 for empty string', () => {
-      expect(shannonEntropy('')).toBe(0);
-    });
-
-    it('should return 0 for single-character string', () => {
-      expect(shannonEntropy('a')).toBe(0);
-    });
-
-    it('should return low entropy for repeated characters', () => {
-      expect(shannonEntropy('aaaaaaaaaa')).toBe(0);
-    });
-
-    it('should return higher entropy for varied characters', () => {
-      const entropy = shannonEntropy('abcdefghij');
-      expect(entropy).toBeGreaterThan(3);
-    });
-
-    it('should return high entropy for random-looking strings', () => {
-      const entropy = shannonEntropy('k8sF3mR9pLzX7qNvA2wJ');
-      expect(entropy).toBeGreaterThan(4);
-    });
-  });
-
-  describe('detectSecrets', () => {
-    it('should detect high-entropy strings', () => {
-      const text = 'api_key=k8sF3mR9pLzX7qNvA2wJbTcYdEhGiKlM';
-      const regions = detectSecrets(text);
-      expect(regions.length).toBeGreaterThan(0);
-    });
-
-    it('should detect known API key patterns', () => {
-      const text = 'token: ghp_1234567890abcdefghijklmnopqrstuvwxyz';
-      const regions = detectSecrets(text);
-      expect(regions.length).toBeGreaterThan(0);
-    });
-
-    it('should detect AWS access keys', () => {
-      const text = 'aws_key: AKIAIOSFODNN7EXAMPLE';
-      const regions = detectSecrets(text);
-      expect(regions.length).toBeGreaterThan(0);
-    });
-
-    it('should not detect normal text', () => {
-      const text = 'Hello world, this is a normal message.';
-      const regions = detectSecrets(text);
-      expect(regions).toHaveLength(0);
-    });
-
-    it('should detect Anthropic API keys', () => {
-      const text = 'key: sk-ant-' + 'a'.repeat(90);
-      const regions = detectSecrets(text);
-      expect(regions.length).toBeGreaterThan(0);
-    });
-  });
-
-  describe('redactString', () => {
-    it('should redact high-entropy strings', () => {
-      const text = 'password=k8sF3mR9pLzX7qNvA2wJbTcY';
-      const result = redactString(text);
-      expect(result).toContain('REDACTED');
-      expect(result).not.toContain('k8sF3mR9');
-    });
-
-    it('should not modify normal text', () => {
-      const text = 'This is perfectly normal text.';
-      expect(redactString(text)).toBe(text);
-    });
-
-    it('should redact GitHub tokens', () => {
-      const text = 'GITHUB_TOKEN=ghp_1234567890abcdefghijklmnopqrstuvwxyz';
-      const result = redactString(text);
-      expect(result).toContain('REDACTED');
-    });
-  });
-
-  describe('redactJSONL', () => {
-    it('should redact secrets in JSONL values', () => {
-      const line = JSON.stringify({
-        type: 'assistant',
-        message: { content: 'The key is ghp_1234567890abcdefghijklmnopqrstuvwxyz' },
-      });
-      const result = redactJSONL(line);
-      const parsed = JSON.parse(result);
-      expect(parsed.message.content).toContain('REDACTED');
-    });
-
-    it('should preserve safe fields', () => {
-      const line = JSON.stringify({
-        type: 'user',
-        uuid: 'abc-123',
-        session_id: 'session-456',
-      });
-      const result = redactJSONL(line);
-      const parsed = JSON.parse(result);
-      expect(parsed.uuid).toBe('abc-123');
-      expect(parsed.session_id).toBe('session-456');
-      expect(parsed.type).toBe('user');
-    });
-
-    it('should handle multiple lines', () => {
-      const lines = [
-        JSON.stringify({ type: 'user', message: 'hello' }),
-        JSON.stringify({ type: 'assistant', message: 'world' }),
-      ].join('\n');
-      const result = redactJSONL(lines);
-      const parts = result.split('\n').filter(Boolean);
-      expect(parts).toHaveLength(2);
-    });
-
-    it('should handle malformed JSON gracefully', () => {
-      const input = 'not json {{{';
-      const result = redactJSONL(input);
-      expect(result).toBeDefined();
-    });
-
-    it('should skip image objects', () => {
-      const line = JSON.stringify({
-        type: 'assistant',
-        content: [{ type: 'image', data: 'k8sF3mR9pLzX7qNvA2wJbTcY' }],
-      });
-      const result = redactJSONL(line);
-      const parsed = JSON.parse(result);
-      // Image objects should be preserved as-is
-      expect(parsed.content[0].data).toBe('k8sF3mR9pLzX7qNvA2wJbTcY');
-    });
-  });
-});