cognitive-core 0.2.0 → 0.2.2

package/tests/utils/error-classifier.test.ts

@@ -0,0 +1,149 @@
+import { describe, it, expect } from 'vitest';
+import {
+  classifyError,
+  classifyErrorType,
+  type ErrorType,
+} from '../../src/utils/error-classifier.js';
+
+describe('classifyError', () => {
+  it('should return null for empty string', () => {
+    expect(classifyError('')).toBeNull();
+  });
+
+  it('should return null for undefined-ish input', () => {
+    expect(classifyError(null as unknown as string)).toBeNull();
+  });
+
+  it('should classify type errors', () => {
+    expect(classifyError('TypeError: Cannot read properties of undefined')?.type).toBe('type-error');
+    expect(classifyError('type error occurred')?.type).toBe('type-error');
+    expect(classifyError('some type and some error')?.type).toBe('type-error');
+  });
+
+  it('should classify import/module errors', () => {
+    expect(classifyError('Cannot find module "foo"')?.type).toBe('import-error');
+    expect(classifyError('Module not found: bar')?.type).toBe('import-error');
+    expect(classifyError('import failed for xyz')?.type).toBe('import-error');
+  });
+
+  it('should classify syntax errors', () => {
+    expect(classifyError('SyntaxError: Unexpected token')?.type).toBe('syntax-error');
+    expect(classifyError('syntax error near "("')?.type).toBe('syntax-error');
+  });
+
+  it('should classify timeouts', () => {
+    expect(classifyError('Timeout: operation exceeded 30s')?.type).toBe('timeout');
+    expect(classifyError('Request timed out')?.type).toBe('timeout');
+    expect(classifyError('Connection time out')?.type).toBe('timeout');
+  });
+
+  it('should classify permission errors', () => {
+    expect(classifyError('Permission denied')?.type).toBe('permission-error');
+    expect(classifyError('403 Forbidden')?.type).toBe('permission-error');
+    expect(classifyError('Unauthorized access')?.type).toBe('permission-error');
+  });
+
+  it('should classify not-found errors', () => {
+    expect(classifyError('File not found')?.type).toBe('not-found');
+    expect(classifyError('No such file or directory')?.type).toBe('not-found');
+    expect(classifyError('Missing dependency')?.type).toBe('not-found');
+  });
+
+  it('should classify network errors', () => {
+    expect(classifyError('ECONNREFUSED 127.0.0.1:3000')?.type).toBe('network-error');
+    expect(classifyError('ENOTFOUND api.example.com')?.type).toBe('network-error');
+    expect(classifyError('Network unreachable')?.type).toBe('network-error');
+    expect(classifyError('connection refused')?.type).toBe('network-error');
+  });
+
+  it('should classify test failures', () => {
+    expect(classifyError('test failed: should return 42')?.type).toBe('test-failure');
+    expect(classifyError('FAIL tests/foo.test.ts')?.type).toBe('test-failure');
+  });
+
+  it('should classify assertion errors', () => {
+    expect(classifyError('assertion: expected 1 to equal 2')?.type).toBe('assertion-error');
+    expect(classifyError('AssertionError: values differ')?.type).toBe('assertion-error');
+  });
+
+  it('should classify general errors as fallback', () => {
+    expect(classifyError('An unknown exception occurred')?.type).toBe('general-error');
+    expect(classifyError('Error: something went wrong')?.type).toBe('general-error');
+  });
+
+  it('should return null when no pattern matches', () => {
+    expect(classifyError('everything is fine')).toBeNull();
+    expect(classifyError('success')).toBeNull();
+  });
+
+  it('should include a description with each classification', () => {
+    const result = classifyError('TypeError: bad input');
+    expect(result).not.toBeNull();
+    expect(result!.description).toBeTruthy();
+    expect(typeof result!.description).toBe('string');
+  });
+
+  // BUG: Rule ordering means "type-error" takes priority over more specific patterns
+  // when both keywords appear. This documents the current behavior.
+  describe('rule priority (first-match-wins)', () => {
+    it('should match type-error before import-error when both keywords present', () => {
+      // "type" + "error" triggers type-error rule even if "import" is also present
+      const result = classifyError('type error during import');
+      expect(result?.type).toBe('type-error');
+    });
+
+    it('should match import-error before not-found for module not found', () => {
+      // "Cannot find module" matches import-error before not-found
+      const result = classifyError('Cannot find module "foo"');
+      expect(result?.type).toBe('import-error');
+    });
+
+    it('should match assertion-error before test-failure for assertion strings', () => {
+      // "assertion" matches assertion-error before test-failure
+      const result = classifyError('test assertion failed');
+      expect(result?.type).toBe('assertion-error');
+    });
+
+    it('should match network-error before not-found for ENOTFOUND', () => {
+      const result = classifyError('ENOTFOUND api.example.com');
+      expect(result?.type).toBe('network-error');
+    });
+  });
+});
+
+describe('classifyErrorType', () => {
+  it('should return just the type string', () => {
+    expect(classifyErrorType('TypeError: bad')).toBe('type-error');
+  });
+
+  it('should return null for empty input', () => {
+    expect(classifyErrorType('')).toBeNull();
+  });
+
+  it('should return null for no match', () => {
+    expect(classifyErrorType('all good')).toBeNull();
+  });
+
+  it('should agree with classifyError', () => {
+    const inputs = [
+      'TypeError: x',
+      'Cannot find module "y"',
+      'SyntaxError: z',
+      'Timeout exceeded',
+      'Permission denied',
+      'File not found',
+      'ECONNREFUSED',
+      'test failed',
+      'assertion error',
+      'general exception',
+      '',
+      'no match here',
+    ];
+
+    for (const input of inputs) {
+      const full = classifyError(input);
+      const typeOnly = classifyErrorType(input);
+      expect(typeOnly).toBe(full?.type ?? null);
+    }
+  });
+});

package/tests/utils/trajectory-helpers.test.ts

@@ -0,0 +1,163 @@
+import { describe, it, expect } from 'vitest';
+import {
+  detectRepeatedActions,
+  extractToolNames,
+  type RepeatedAction,
+} from '../../src/utils/trajectory-helpers.js';
+
+describe('detectRepeatedActions', () => {
+  it('should return empty array for empty steps', () => {
+    expect(detectRepeatedActions([])).toEqual([]);
+  });
+
+  it('should return empty array when no actions reach threshold', () => {
+    const steps = [
+      { action: 'read file.ts' },
+      { action: 'edit file.ts' },
+      { action: 'run tests' },
+    ];
+    expect(detectRepeatedActions(steps)).toEqual([]);
+  });
+
+  it('should detect repeated actions at default threshold (3)', () => {
+    const steps = [
+      { action: 'read file.ts' },
+      { action: 'read file.ts' },
+      { action: 'read file.ts' },
+      { action: 'edit file.ts' },
+    ];
+    const repeated = detectRepeatedActions(steps);
+    expect(repeated).toHaveLength(1);
+    expect(repeated[0].action).toBe('read file.ts');
+    expect(repeated[0].count).toBe(3);
+  });
+
+  it('should support custom threshold', () => {
+    const steps = [
+      { action: 'read file.ts' },
+      { action: 'read file.ts' },
+      { action: 'edit file.ts' },
+    ];
+    // threshold=2 should flag "read file.ts"
+    const repeated = detectRepeatedActions(steps, 2);
+    expect(repeated).toHaveLength(1);
+    expect(repeated[0].count).toBe(2);
+  });
+
+  it('should normalize actions to lowercase and truncate to 50 chars by default', () => {
+    const longAction = 'A'.repeat(100);
+    const steps = [
+      { action: longAction },
+      { action: longAction },
+      { action: longAction },
+    ];
+    const repeated = detectRepeatedActions(steps);
+    expect(repeated).toHaveLength(1);
+    // Normalized: lowercased + truncated to 50 chars
+    expect(repeated[0].action).toBe('a'.repeat(50));
+  });
+
+  it('should use custom normalize function', () => {
+    const steps = [
+      { action: 'Read file.ts' },
+      { action: 'read FILE.ts' },
+      { action: 'READ file.TS' },
+    ];
+    // Without custom normalize, default lowercasing groups these
+    const repeated = detectRepeatedActions(steps, 3);
+    expect(repeated).toHaveLength(1);
+
+    // With custom normalize that preserves case, they'd be different
+    const repeatedStrict = detectRepeatedActions(steps, 3, (a) => a);
+    expect(repeatedStrict).toHaveLength(0);
+  });
+
+  it('should skip steps with falsy action', () => {
+    const steps = [
+      { action: 'read' },
+      { action: '' },
+      { action: 'read' },
+      { action: 'read' },
+    ];
+    const repeated = detectRepeatedActions(steps);
+    expect(repeated).toHaveLength(1);
+    expect(repeated[0].count).toBe(3);
+  });
+
+  it('should detect multiple repeated actions', () => {
+    const steps = [
+      { action: 'read file.ts' },
+      { action: 'edit file.ts' },
+      { action: 'read file.ts' },
+      { action: 'edit file.ts' },
+      { action: 'read file.ts' },
+      { action: 'edit file.ts' },
+    ];
+    const repeated = detectRepeatedActions(steps);
+    expect(repeated).toHaveLength(2);
+  });
+});
+
+describe('extractToolNames', () => {
+  it('should return empty set for empty steps', () => {
+    expect(extractToolNames([])).toEqual(new Set());
+  });
+
+  it('should extract simple tool names', () => {
+    const steps = [
+      { action: 'Read src/index.ts' },
+      { action: 'Edit src/index.ts line 5' },
+    ];
+    const tools = extractToolNames(steps);
+    expect(tools.has('Read')).toBe(true);
+    expect(tools.has('Edit')).toBe(true);
+  });
+
+  it('should extract tool names with tool_use: prefix', () => {
+    const steps = [
+      { action: 'tool_use: Read src/index.ts' },
+      { action: 'tool_use: Write /tmp/out.txt' },
+    ];
+    const tools = extractToolNames(steps);
+    expect(tools.has('Read')).toBe(true);
+    expect(tools.has('Write')).toBe(true);
+  });
+
+  it('should handle mixed formats', () => {
+    const steps = [
+      { action: 'Read foo.ts' },
+      { action: 'tool_use: Bash echo hello' },
+    ];
+    const tools = extractToolNames(steps);
+    expect(tools.has('Read')).toBe(true);
+    expect(tools.has('Bash')).toBe(true);
+  });
+
+  it('should skip steps with falsy action', () => {
+    const steps = [
+      { action: '' },
+      { action: 'Read foo.ts' },
+    ];
+    const tools = extractToolNames(steps);
+    expect(tools.size).toBe(1);
+  });
+
+  it('should deduplicate tool names', () => {
+    const steps = [
+      { action: 'Read a.ts' },
+      { action: 'Read b.ts' },
+      { action: 'Read c.ts' },
+    ];
+    const tools = extractToolNames(steps);
+    expect(tools.size).toBe(1);
+    expect(tools.has('Read')).toBe(true);
+  });
+
+  it('should handle camelCase tool names', () => {
+    const steps = [
+      { action: 'searchAndReplace foo bar' },
+    ];
+    const tools = extractToolNames(steps);
+    expect(tools.has('searchAndReplace')).toBe(true);
+  });
+});