cognitive-core 0.1.2 → 0.2.0

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

@@ -0,0 +1,103 @@
+/**
+ * Tests for Input Validation
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  validateSessionID,
+  validateToolUseID,
+  validateAgentID,
+  validateAgentSessionID,
+} from '../utils/validation.js';
+
+describe('Input Validation', () => {
+  describe('validateSessionID', () => {
+    it('should accept valid session IDs', () => {
+      expect(() => validateSessionID('abc-123')).not.toThrow();
+      expect(() => validateSessionID('2025-01-01-session')).not.toThrow();
+      expect(() => validateSessionID('a')).not.toThrow();
+    });
+
+    it('should reject empty session ID', () => {
+      expect(() => validateSessionID('')).toThrow('cannot be empty');
+    });
+
+    it('should reject forward slash', () => {
+      expect(() => validateSessionID('foo/bar')).toThrow('path separators');
+    });
+
+    it('should reject backslash', () => {
+      expect(() => validateSessionID('foo\\bar')).toThrow('path separators');
+    });
+
+    it('should reject path traversal attempts', () => {
+      expect(() => validateSessionID('../etc/passwd')).toThrow('path separators');
+      expect(() => validateSessionID('..\\windows\\system32')).toThrow('path separators');
+    });
+
+    it('should allow dots without slashes', () => {
+      expect(() => validateSessionID('session.1')).not.toThrow();
+      expect(() => validateSessionID('...')).not.toThrow();
+    });
+  });
+
+  describe('validateToolUseID', () => {
+    it('should accept valid tool use IDs', () => {
+      expect(() => validateToolUseID('toolu_abc123')).not.toThrow();
+      expect(() => validateToolUseID('abc-def-123')).not.toThrow();
+    });
+
+    it('should accept empty (optional field)', () => {
+      expect(() => validateToolUseID('')).not.toThrow();
+    });
+
+    it('should reject IDs with slashes', () => {
+      expect(() => validateToolUseID('foo/bar')).toThrow('alphanumeric');
+    });
+
+    it('should reject IDs with spaces', () => {
+      expect(() => validateToolUseID('foo bar')).toThrow('alphanumeric');
+    });
+
+    it('should reject IDs with dots', () => {
+      expect(() => validateToolUseID('foo.bar')).toThrow('alphanumeric');
+    });
+  });
+
+  describe('validateAgentID', () => {
+    it('should accept valid agent IDs', () => {
+      expect(() => validateAgentID('claude-code')).not.toThrow();
+      expect(() => validateAgentID('agent_1')).not.toThrow();
+    });
+
+    it('should accept empty (optional field)', () => {
+      expect(() => validateAgentID('')).not.toThrow();
+    });
+
+    it('should reject IDs with special characters', () => {
+      expect(() => validateAgentID('agent@1')).toThrow('alphanumeric');
+      expect(() => validateAgentID('agent:1')).toThrow('alphanumeric');
+    });
+  });
+
+  describe('validateAgentSessionID', () => {
+    it('should accept valid agent session IDs', () => {
+      expect(() =>
+        validateAgentSessionID('2025-01-01-8f76b0e8-b8f1-4a87-9186-848bdd83d62e'),
+      ).not.toThrow();
+      expect(() => validateAgentSessionID('session_123')).not.toThrow();
+    });
+
+    it('should reject empty agent session ID', () => {
+      expect(() => validateAgentSessionID('')).toThrow('cannot be empty');
+    });
+
+    it('should reject IDs with path separators', () => {
+      expect(() => validateAgentSessionID('foo/bar')).toThrow('alphanumeric');
+    });
+
+    it('should reject IDs with spaces', () => {
+      expect(() => validateAgentSessionID('foo bar')).toThrow('alphanumeric');
+    });
+  });
+});

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

@@ -0,0 +1,57 @@
+/**
+ * Tests for Worktree Utilities
+ */
+
+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 { getWorktreeID } from '../utils/worktree.js';
+
+describe('Worktree Utilities', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'worktree-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  describe('getWorktreeID', () => {
+    it('should return empty string for main worktree', async () => {
+      // Main worktree has .git as a directory
+      fs.mkdirSync(path.join(tmpDir, '.git'));
+      const id = await getWorktreeID(tmpDir);
+      expect(id).toBe('');
+    });
+
+    it('should extract worktree ID from linked worktree', async () => {
+      // Linked worktree has .git as a file pointing to worktrees/<name>
+      fs.writeFileSync(path.join(tmpDir, '.git'), 'gitdir: /repo/.git/worktrees/my-feature\n');
+      const id = await getWorktreeID(tmpDir);
+      expect(id).toBe('my-feature');
+    });
+
+    it('should handle trailing slash in gitdir', async () => {
+      fs.writeFileSync(path.join(tmpDir, '.git'), 'gitdir: /repo/.git/worktrees/feature-branch/\n');
+      const id = await getWorktreeID(tmpDir);
+      expect(id).toBe('feature-branch');
+    });
+
+    it('should throw for missing .git', async () => {
+      await expect(getWorktreeID(tmpDir)).rejects.toThrow('failed to stat .git');
+    });
+
+    it('should throw for invalid .git file format', async () => {
+      fs.writeFileSync(path.join(tmpDir, '.git'), 'invalid content\n');
+      await expect(getWorktreeID(tmpDir)).rejects.toThrow('invalid .git file format');
+    });
+
+    it('should throw for gitdir without worktrees path', async () => {
+      fs.writeFileSync(path.join(tmpDir, '.git'), 'gitdir: /some/other/path\n');
+      await expect(getWorktreeID(tmpDir)).rejects.toThrow('no worktrees');
+    });
+  });
+});