cognitive-core 0.1.0 → 0.2.0

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

@@ -0,0 +1,127 @@
+/**
+ * Tests for Agent Registry
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import {
+  registerAgent,
+  getAgent,
+  listAgentNames,
+  listAgents,
+  getDefaultAgent,
+  resolveAgent,
+  resetRegistry,
+} from '../agent/registry.js';
+import { AGENT_NAMES, AGENT_TYPES } from '../types.js';
+import type { Agent } from '../agent/types.js';
+
+function createMockAgent(name: string, type: string): Agent {
+  return {
+    name,
+    type,
+    description: `Mock ${name} agent`,
+    isPreview: false,
+    protectedDirs: [`.${name}`],
+    detectPresence: async () => false,
+    getSessionDir: async () => '/mock/sessions',
+    getSessionID: (input) => input.sessionID,
+    resolveSessionFile: (dir, id) => `${dir}/${id}.jsonl`,
+    readTranscript: async () => Buffer.from(''),
+    formatResumeCommand: (id) => `mock --resume ${id}`,
+  };
+}
+
+describe('Agent Registry', () => {
+  beforeEach(() => {
+    resetRegistry();
+  });
+
+  it('should register and retrieve an agent', () => {
+    const agent = createMockAgent('test-agent', 'Test Agent');
+    registerAgent('test-agent', () => agent);
+
+    const retrieved = getAgent('test-agent');
+    expect(retrieved).not.toBeNull();
+    expect(retrieved!.name).toBe('test-agent');
+    expect(retrieved!.type).toBe('Test Agent');
+  });
+
+  it('should return null for unknown agent', () => {
+    expect(getAgent('nonexistent')).toBeNull();
+  });
+
+  it('should list registered agent names', () => {
+    registerAgent('alpha', () => createMockAgent('alpha', 'Alpha'));
+    registerAgent('beta', () => createMockAgent('beta', 'Beta'));
+
+    const names = listAgentNames();
+    expect(names).toContain('alpha');
+    expect(names).toContain('beta');
+    // Should be sorted
+    expect(names[0]).toBe('alpha');
+  });
+
+  it('should list all agents', () => {
+    registerAgent('agent-a', () => createMockAgent('agent-a', 'Agent A'));
+    registerAgent('agent-b', () => createMockAgent('agent-b', 'Agent B'));
+
+    const agents = listAgents();
+    expect(agents).toHaveLength(2);
+  });
+
+  it('should cache agent instances', () => {
+    let callCount = 0;
+    registerAgent('cached', () => {
+      callCount++;
+      return createMockAgent('cached', 'Cached');
+    });
+
+    getAgent('cached');
+    getAgent('cached');
+    getAgent('cached');
+
+    expect(callCount).toBe(1);
+  });
+
+  it('should resolve by name', () => {
+    registerAgent('test', () => createMockAgent('test', 'Test'));
+
+    const agent = resolveAgent('test');
+    expect(agent).not.toBeNull();
+    expect(agent!.name).toBe('test');
+  });
+
+  it('should resolve by type', () => {
+    registerAgent('my-agent', () => createMockAgent('my-agent', 'My Agent'));
+
+    const agent = resolveAgent('My Agent');
+    expect(agent).not.toBeNull();
+    expect(agent!.name).toBe('my-agent');
+  });
+
+  it('should return null for unresolvable', () => {
+    expect(resolveAgent('nonexistent')).toBeNull();
+  });
+
+  it('should return default agent when registered', () => {
+    registerAgent(AGENT_NAMES.CLAUDE_CODE, () =>
+      createMockAgent(AGENT_NAMES.CLAUDE_CODE, AGENT_TYPES.CLAUDE_CODE),
+    );
+
+    const agent = getDefaultAgent();
+    expect(agent).not.toBeNull();
+    expect(agent!.name).toBe('claude-code');
+  });
+
+  it('should return null default when not registered', () => {
+    expect(getDefaultAgent()).toBeNull();
+  });
+
+  it('should reset the registry', () => {
+    registerAgent('temp', () => createMockAgent('temp', 'Temp'));
+    expect(listAgentNames()).toHaveLength(1);
+
+    resetRegistry();
+    expect(listAgentNames()).toHaveLength(0);
+  });
+});

package/references/sessionlog/src/__tests__/claude-code-hooks.test.ts

@@ -0,0 +1,225 @@
+/**
+ * Tests for Claude Code Agent hook parsing — task and plan mode events
+ */
+
+import { describe, it, expect } from 'vitest';
+import { createClaudeCodeAgent } from '../agent/agents/claude-code.js';
+import { EventType } from '../types.js';
+
+describe('Claude Code Agent - Task & Plan Mode Hooks', () => {
+  const agent = createClaudeCodeAgent();
+
+  describe('parseHookEvent — post-task-create', () => {
+    it('should parse task create event with tool_input and tool_response', () => {
+      const stdin = JSON.stringify({
+        session_id: 'sess-123',
+        transcript_path: '/path/to/transcript.jsonl',
+        tool_use_id: 'tu-abc',
+        tool_input: {
+          subject: 'Fix authentication bug',
+          description: 'Detailed description of the bug fix',
+          activeForm: 'Fixing authentication bug',
+        },
+        tool_response: {
+          taskId: '42',
+        },
+      });
+
+      const event = agent.parseHookEvent('post-task-create', stdin);
+      expect(event).not.toBeNull();
+      expect(event!.type).toBe(EventType.TaskCreate);
+      expect(event!.sessionID).toBe('sess-123');
+      expect(event!.taskID).toBe('42');
+      expect(event!.taskSubject).toBe('Fix authentication bug');
+      expect(event!.taskActiveForm).toBe('Fixing authentication bug');
+      expect(event!.taskDescription).toBe('Detailed description of the bug fix');
+      expect(event!.toolUseID).toBe('tu-abc');
+    });
+
+    it('should handle missing tool_response gracefully', () => {
+      const stdin = JSON.stringify({
+        session_id: 'sess-123',
+        transcript_path: '/path/to/transcript.jsonl',
+        tool_use_id: 'tu-abc',
+        tool_input: {
+          subject: 'Add tests',
+        },
+      });
+
+      const event = agent.parseHookEvent('post-task-create', stdin);
+      expect(event).not.toBeNull();
+      expect(event!.type).toBe(EventType.TaskCreate);
+      expect(event!.taskID).toBe('');
+      expect(event!.taskSubject).toBe('Add tests');
+    });
+
+    it('should handle malformed JSON', () => {
+      const event = agent.parseHookEvent('post-task-create', 'not json');
+      expect(event).toBeNull();
+    });
+  });
+
+  describe('parseHookEvent — post-task-update', () => {
+    it('should parse task update event', () => {
+      const stdin = JSON.stringify({
+        session_id: 'sess-123',
+        transcript_path: '/path/to/transcript.jsonl',
+        tool_use_id: 'tu-def',
+        tool_input: {
+          taskId: '42',
+          status: 'completed',
+          subject: 'Fix authentication bug',
+        },
+      });
+
+      const event = agent.parseHookEvent('post-task-update', stdin);
+      expect(event).not.toBeNull();
+      expect(event!.type).toBe(EventType.TaskUpdate);
+      expect(event!.taskID).toBe('42');
+      expect(event!.taskStatus).toBe('completed');
+      expect(event!.taskSubject).toBe('Fix authentication bug');
+    });
+
+    it('should handle status-only update', () => {
+      const stdin = JSON.stringify({
+        session_id: 'sess-123',
+        transcript_path: '/path/to/transcript.jsonl',
+        tool_use_id: 'tu-ghi',
+        tool_input: {
+          taskId: '7',
+          status: 'in_progress',
+        },
+      });
+
+      const event = agent.parseHookEvent('post-task-update', stdin);
+      expect(event).not.toBeNull();
+      expect(event!.taskID).toBe('7');
+      expect(event!.taskStatus).toBe('in_progress');
+      expect(event!.taskSubject).toBeUndefined();
+    });
+
+    it('should handle malformed JSON', () => {
+      const event = agent.parseHookEvent('post-task-update', '{invalid');
+      expect(event).toBeNull();
+    });
+  });
+
+  describe('parseHookEvent — post-plan-enter', () => {
+    it('should parse plan mode enter event', () => {
+      const stdin = JSON.stringify({
+        session_id: 'sess-456',
+        transcript_path: '/path/to/transcript.jsonl',
+      });
+
+      const event = agent.parseHookEvent('post-plan-enter', stdin);
+      expect(event).not.toBeNull();
+      expect(event!.type).toBe(EventType.PlanModeEnter);
+      expect(event!.sessionID).toBe('sess-456');
+    });
+
+    it('should handle malformed JSON', () => {
+      const event = agent.parseHookEvent('post-plan-enter', '');
+      expect(event).toBeNull();
+    });
+  });
+
+  describe('parseHookEvent — post-plan-exit', () => {
+    it('should parse plan mode exit event with allowed prompts', () => {
+      const stdin = JSON.stringify({
+        session_id: 'sess-456',
+        transcript_path: '/path/to/transcript.jsonl',
+        tool_input: {
+          allowedPrompts: [
+            { tool: 'Bash', prompt: 'run tests' },
+            { tool: 'Bash', prompt: 'install dependencies' },
+          ],
+        },
+      });
+
+      const event = agent.parseHookEvent('post-plan-exit', stdin);
+      expect(event).not.toBeNull();
+      expect(event!.type).toBe(EventType.PlanModeExit);
+      expect(event!.sessionID).toBe('sess-456');
+      expect(event!.planAllowedPrompts).toHaveLength(2);
+      expect(event!.planAllowedPrompts![0]).toEqual({ tool: 'Bash', prompt: 'run tests' });
+    });
+
+    it('should handle exit without allowed prompts', () => {
+      const stdin = JSON.stringify({
+        session_id: 'sess-456',
+        transcript_path: '/path/to/transcript.jsonl',
+        tool_input: {},
+      });
+
+      const event = agent.parseHookEvent('post-plan-exit', stdin);
+      expect(event).not.toBeNull();
+      expect(event!.type).toBe(EventType.PlanModeExit);
+      expect(event!.planAllowedPrompts).toBeUndefined();
+    });
+
+    it('should extract planFilePath from tool_response object', () => {
+      const stdin = JSON.stringify({
+        session_id: 'sess-456',
+        transcript_path: '/path/to/transcript.jsonl',
+        tool_input: {},
+        tool_response: {
+          planFilePath: '/home/user/.claude/plans/my-plan.md',
+        },
+      });
+
+      const event = agent.parseHookEvent('post-plan-exit', stdin);
+      expect(event).not.toBeNull();
+      expect(event!.planFilePath).toBe('/home/user/.claude/plans/my-plan.md');
+    });
+
+    it('should extract planFilePath from tool_response string message', () => {
+      const stdin = JSON.stringify({
+        session_id: 'sess-456',
+        transcript_path: '/path/to/transcript.jsonl',
+        tool_input: {},
+        tool_response: 'Your plan has been saved to: /home/user/.claude/plans/my-plan.md',
+      });
+
+      const event = agent.parseHookEvent('post-plan-exit', stdin);
+      expect(event).not.toBeNull();
+      expect(event!.planFilePath).toBe('/home/user/.claude/plans/my-plan.md');
+    });
+
+    it('should extract planFilePath from tool_response content field', () => {
+      const stdin = JSON.stringify({
+        session_id: 'sess-456',
+        transcript_path: '/path/to/transcript.jsonl',
+        tool_input: {},
+        tool_response: {
+          content: 'Your plan has been saved to: /home/user/.claude/plans/my-plan.md',
+        },
+      });
+
+      const event = agent.parseHookEvent('post-plan-exit', stdin);
+      expect(event).not.toBeNull();
+      expect(event!.planFilePath).toBe('/home/user/.claude/plans/my-plan.md');
+    });
+
+    it('should handle missing tool_response for planFilePath', () => {
+      const stdin = JSON.stringify({
+        session_id: 'sess-456',
+        transcript_path: '/path/to/transcript.jsonl',
+        tool_input: {},
+      });
+
+      const event = agent.parseHookEvent('post-plan-exit', stdin);
+      expect(event).not.toBeNull();
+      expect(event!.planFilePath).toBeUndefined();
+    });
+  });
+
+  describe('hookNames', () => {
+    it('should include new hook names', () => {
+      const names = agent.hookNames();
+      expect(names).toContain('post-task-create');
+      expect(names).toContain('post-task-update');
+      expect(names).toContain('post-plan-enter');
+      expect(names).toContain('post-plan-exit');
+    });
+  });
+});

package/references/sessionlog/src/__tests__/claude-generator.test.ts

@@ -0,0 +1,46 @@
+/**
+ * Tests for Claude Generator
+ *
+ * Tests the module structure and options handling. Actual CLI invocation
+ * is not tested (would require a real claude binary).
+ */
+
+import { describe, it, expect } from 'vitest';
+import { createClaudeGenerator, DEFAULT_SUMMARIZE_MODEL } from '../summarize/claude-generator.js';
+
+describe('Claude Generator', () => {
+  describe('DEFAULT_SUMMARIZE_MODEL', () => {
+    it('should be sonnet', () => {
+      expect(DEFAULT_SUMMARIZE_MODEL).toBe('sonnet');
+    });
+  });
+
+  describe('createClaudeGenerator', () => {
+    it('should create a generator with default options', () => {
+      const generator = createClaudeGenerator();
+      expect(generator).toBeDefined();
+      expect(typeof generator.generate).toBe('function');
+    });
+
+    it('should create a generator with custom options', () => {
+      const generator = createClaudeGenerator({
+        claudePath: '/usr/local/bin/claude',
+        model: 'opus',
+      });
+      expect(generator).toBeDefined();
+    });
+
+    it('should reject when claude is not found', async () => {
+      const generator = createClaudeGenerator({
+        claudePath: '/nonexistent/claude-binary-that-does-not-exist',
+      });
+
+      await expect(
+        generator.generate({
+          transcript: [{ type: 'user', content: 'Hello' }],
+          filesTouched: [],
+        }),
+      ).rejects.toThrow(/not found|ENOENT/);
+    });
+  });
+});

package/references/sessionlog/src/__tests__/commit-msg.test.ts

@@ -0,0 +1,86 @@
+/**
+ * Tests for commit-msg hook helpers
+ */
+
+import { describe, it, expect } from 'vitest';
+import { hasUserContent, stripCheckpointTrailer } from '../strategy/manual-commit.js';
+
+describe('commit-msg hook helpers', () => {
+  describe('hasUserContent', () => {
+    it('should return true for message with user text', () => {
+      expect(hasUserContent('feat: add login\n\nSessionlog-Checkpoint: abc123def456')).toBe(true);
+    });
+
+    it('should return false for trailer-only message', () => {
+      expect(hasUserContent('\nSessionlog-Checkpoint: abc123def456\n')).toBe(false);
+    });
+
+    it('should return false for comments and trailer only', () => {
+      const msg = [
+        '',
+        '# Please enter the commit message',
+        '# Lines starting with # are ignored',
+        '',
+        'Sessionlog-Checkpoint: abc123def456',
+        '',
+      ].join('\n');
+      expect(hasUserContent(msg)).toBe(false);
+    });
+
+    it('should return true for message with user text and comments', () => {
+      const msg = [
+        'fix: resolve race condition',
+        '',
+        '# Please enter the commit message',
+        'Sessionlog-Checkpoint: abc123def456',
+      ].join('\n');
+      expect(hasUserContent(msg)).toBe(true);
+    });
+
+    it('should return false for empty message', () => {
+      expect(hasUserContent('')).toBe(false);
+    });
+
+    it('should return false for comments only', () => {
+      expect(hasUserContent('# This is a comment\n# Another comment\n')).toBe(false);
+    });
+
+    it('should return false for blank lines only', () => {
+      expect(hasUserContent('\n\n\n')).toBe(false);
+    });
+  });
+
+  describe('stripCheckpointTrailer', () => {
+    it('should remove the trailer line', () => {
+      const msg = 'feat: add feature\n\nSessionlog-Checkpoint: abc123def456\n';
+      const result = stripCheckpointTrailer(msg);
+      expect(result).not.toContain('Sessionlog-Checkpoint');
+      expect(result).toContain('feat: add feature');
+    });
+
+    it('should preserve other lines', () => {
+      const msg = [
+        'feat: add feature',
+        '',
+        'Some body text',
+        'Sessionlog-Checkpoint: abc123def456',
+        '# A comment',
+      ].join('\n');
+      const result = stripCheckpointTrailer(msg);
+      expect(result).toContain('feat: add feature');
+      expect(result).toContain('Some body text');
+      expect(result).toContain('# A comment');
+      expect(result).not.toContain('Sessionlog-Checkpoint');
+    });
+
+    it('should handle message without trailer', () => {
+      const msg = 'feat: add feature\n\nSome body\n';
+      expect(stripCheckpointTrailer(msg)).toBe(msg);
+    });
+
+    it('should handle trailer-only message', () => {
+      const result = stripCheckpointTrailer('Sessionlog-Checkpoint: abc123def456');
+      expect(result.trim()).toBe('');
+    });
+  });
+});