cognitive-core 0.2.4 → 0.3.1

package/tests/types/trajectory.test.ts

@@ -1,253 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  TrajectorySchema,
-  createTrajectory,
-  isSuccessful,
-  getKeySteps,
-  type Trajectory,
-} from '../../src/types/trajectory.js';
-import { createTask } from '../../src/types/task.js';
-import { createStep } from '../../src/types/step.js';
-import { successOutcome, failureOutcome } from '../../src/types/outcome.js';
-
-describe('Trajectory', () => {
-  const sampleTask = createTask({
-    id: 'task-1',
-    domain: 'code',
-    description: 'Write a hello world function',
-  });
-
-  const sampleSteps = [
-    createStep({
-      thought: 'I need to create a function',
-      action: 'write_code()',
-      observation: 'Function written',
-    }),
-    createStep({
-      action: 'run_tests()',
-      observation: 'Tests passed',
-    }),
-  ];
-
-  it('should validate a complete trajectory', () => {
-    const trajectory: Trajectory = {
-      id: 'traj-1',
-      task: sampleTask,
-      steps: sampleSteps,
-      outcome: successOutcome('function helloWorld() { return "hello"; }'),
-      agentId: 'claude-code',
-      timestamp: new Date(),
-      llmCalls: 5,
-      totalTokens: 1500,
-      wallTimeSeconds: 30,
-      metadata: { version: '1.0' },
-    };
-    const result = TrajectorySchema.parse(trajectory);
-    expect(result.id).toBe('traj-1');
-    expect(result.agentId).toBe('claude-code');
-    expect(result.llmCalls).toBe(5);
-    expect(result.totalTokens).toBe(1500);
-  });
-
-  it('should apply defaults for optional fields', () => {
-    const trajectory = TrajectorySchema.parse({
-      id: 'traj-2',
-      task: sampleTask,
-      steps: [],
-      outcome: { success: true },
-      agentId: 'test-agent',
-    });
-    expect(trajectory.llmCalls).toBe(0);
-    expect(trajectory.totalTokens).toBe(0);
-    expect(trajectory.wallTimeSeconds).toBe(0);
-    expect(trajectory.metadata).toEqual({});
-    expect(trajectory.timestamp).toBeInstanceOf(Date);
-  });
-
-  it('should allow empty steps array', () => {
-    const trajectory = TrajectorySchema.parse({
-      id: 'traj-3',
-      task: sampleTask,
-      steps: [],
-      outcome: failureOutcome('No steps taken'),
-      agentId: 'agent',
-    });
-    expect(trajectory.steps).toEqual([]);
-  });
-});
-
-describe('createTrajectory', () => {
-  const task = createTask({
-    domain: 'reasoning',
-    description: 'Solve a logic puzzle',
-  });
-
-  const steps = [
-    createStep({ action: 'analyze', observation: 'Found pattern' }),
-    createStep({ action: 'apply', observation: 'Applied rule' }),
-    createStep({ action: 'verify', observation: 'Correct' }),
-  ];
-
-  it('should create a trajectory with required fields', () => {
-    const trajectory = createTrajectory({
-      task,
-      steps,
-      outcome: successOutcome('solved'),
-      agentId: 'reasoning-agent',
-    });
-    expect(trajectory.id).toBeDefined();
-    expect(trajectory.id.length).toBeGreaterThan(0);
-    expect(trajectory.task).toEqual(task);
-    expect(trajectory.steps).toHaveLength(3);
-    expect(trajectory.agentId).toBe('reasoning-agent');
-  });
-
-  it('should create a trajectory with custom id', () => {
-    const trajectory = createTrajectory({
-      id: 'custom-traj-id',
-      task,
-      steps: [],
-      outcome: failureOutcome('failed'),
-      agentId: 'agent',
-    });
-    expect(trajectory.id).toBe('custom-traj-id');
-  });
-
-  it('should create a trajectory with metrics', () => {
-    const trajectory = createTrajectory({
-      task,
-      steps,
-      outcome: successOutcome(42),
-      agentId: 'agent',
-      llmCalls: 10,
-      totalTokens: 5000,
-      wallTimeSeconds: 120,
-    });
-    expect(trajectory.llmCalls).toBe(10);
-    expect(trajectory.totalTokens).toBe(5000);
-    expect(trajectory.wallTimeSeconds).toBe(120);
-  });
-
-  it('should create a trajectory with metadata', () => {
-    const trajectory = createTrajectory({
-      task,
-      steps,
-      outcome: successOutcome('done'),
-      agentId: 'agent',
-      metadata: { attempt: 2, model: 'gpt-4' },
-    });
-    expect(trajectory.metadata.attempt).toBe(2);
-    expect(trajectory.metadata.model).toBe('gpt-4');
-  });
-
-  it('should set timestamp to current time', () => {
-    const before = new Date();
-    const trajectory = createTrajectory({
-      task,
-      steps: [],
-      outcome: successOutcome('x'),
-      agentId: 'agent',
-    });
-    const after = new Date();
-    expect(trajectory.timestamp.getTime()).toBeGreaterThanOrEqual(before.getTime());
-    expect(trajectory.timestamp.getTime()).toBeLessThanOrEqual(after.getTime());
-  });
-});
-
-describe('isSuccessful', () => {
-  const task = createTask({ domain: 'test', description: 'test' });
-
-  it('should return true for successful trajectory', () => {
-    const trajectory = createTrajectory({
-      task,
-      steps: [],
-      outcome: successOutcome('done'),
-      agentId: 'agent',
-    });
-    expect(isSuccessful(trajectory)).toBe(true);
-  });
-
-  it('should return false for failed trajectory', () => {
-    const trajectory = createTrajectory({
-      task,
-      steps: [],
-      outcome: failureOutcome('error'),
-      agentId: 'agent',
-    });
-    expect(isSuccessful(trajectory)).toBe(false);
-  });
-});
-
-describe('getKeySteps', () => {
-  const task = createTask({ domain: 'test', description: 'test' });
-
-  it('should return steps above threshold', () => {
-    const steps = [
-      { ...createStep({ action: 'a', observation: 'o' }), attributionScore: 0.1 },
-      { ...createStep({ action: 'b', observation: 'o' }), attributionScore: 0.3 },
-      { ...createStep({ action: 'c', observation: 'o' }), attributionScore: 0.8 },
-      { ...createStep({ action: 'd', observation: 'o' }), attributionScore: 0.15 },
-    ];
-    const trajectory = createTrajectory({
-      task,
-      steps,
-      outcome: successOutcome('x'),
-      agentId: 'agent',
-    });
-
-    const keySteps = getKeySteps(trajectory);
-    expect(keySteps).toHaveLength(3);
-    expect(keySteps[0].action).toBe('b');
-    expect(keySteps[1].action).toBe('c');
-    expect(keySteps[2].action).toBe('d');
-  });
-
-  it('should use custom threshold', () => {
-    const steps = [
-      { ...createStep({ action: 'a', observation: 'o' }), attributionScore: 0.4 },
-      { ...createStep({ action: 'b', observation: 'o' }), attributionScore: 0.6 },
-    ];
-    const trajectory = createTrajectory({
-      task,
-      steps,
-      outcome: successOutcome('x'),
-      agentId: 'agent',
-    });
-
-    expect(getKeySteps(trajectory, 0.5)).toHaveLength(1);
-    expect(getKeySteps(trajectory, 0.3)).toHaveLength(2);
-    expect(getKeySteps(trajectory, 0.7)).toHaveLength(0);
-  });
-
-  it('should handle steps without attribution scores', () => {
-    const steps = [
-      createStep({ action: 'a', observation: 'o' }),
-      { ...createStep({ action: 'b', observation: 'o' }), attributionScore: 0.5 },
-    ];
-    const trajectory = createTrajectory({
-      task,
-      steps,
-      outcome: successOutcome('x'),
-      agentId: 'agent',
-    });
-
-    const keySteps = getKeySteps(trajectory);
-    expect(keySteps).toHaveLength(1);
-    expect(keySteps[0].action).toBe('b');
-  });
-
-  it('should return empty array for trajectory with no key steps', () => {
-    const steps = [
-      { ...createStep({ action: 'a', observation: 'o' }), attributionScore: 0.05 },
-      { ...createStep({ action: 'b', observation: 'o' }), attributionScore: 0.1 },
-    ];
-    const trajectory = createTrajectory({
-      task,
-      steps,
-      outcome: successOutcome('x'),
-      agentId: 'agent',
-    });
-
-    expect(getKeySteps(trajectory)).toHaveLength(0);
-  });
-});

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

@@ -1,149 +0,0 @@
-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/frontmatter.test.ts

@@ -1,208 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  parseKnowledgeFrontmatter,
-  serializeKnowledgeFrontmatter,
-  serializeKnowledgeNote,
-  parseKnowledgeNote,
-} from '../../src/utils/frontmatter.js';
-import type { KnowledgeNoteFrontmatter } from '../../src/types/knowledge.js';
-
-describe('frontmatter', () => {
-  const sampleFrontmatter: KnowledgeNoteFrontmatter = {
-    id: 'k-prisma-schema-push',
-    type: 'observation',
-    domain: ['database', 'orm'],
-    entities: ['prisma', 'postgresql'],
-    tags: ['migration', 'schema-drift'],
-    confidence: 0.85,
-    source: {
-      origin: 'extracted',
-      trajectories: ['t-2025-01-15-abc', 't-2025-01-18-def'],
-      playbooks: ['playbook-prisma-setup'],
-    },
-    links: [
-      { target: 'k-prisma-migration-workflow', relation: 'related-to' },
-      { target: 'k-ts-enum-export', relation: 'co-occurred', layer: 'temporal' },
-    ],
-    created: '2025-01-15T10:30:00.000Z',
-    updated: '2025-01-18T14:00:00.000Z',
-    supersedes: null,
-  };
-
-  const sampleBody = '# Prisma requires schema push\n\nSome content here.';
-
-  describe('parseKnowledgeFrontmatter', () => {
-    it('parses valid frontmatter with all fields', () => {
-      const content = `---
-id: k-prisma-schema-push
-type: observation
-domain: [database, orm]
-entities: [prisma, postgresql]
-tags: [migration, schema-drift]
-confidence: 0.85
-source:
-  origin: extracted
-  trajectories:
-    - t-2025-01-15-abc
-    - t-2025-01-18-def
-  playbooks:
-    - playbook-prisma-setup
-links:
-  - target: k-prisma-migration-workflow
-    relation: related-to
-  - target: k-ts-enum-export
-    relation: co-occurred
-    layer: temporal
-created: "2025-01-15T10:30:00.000Z"
-updated: "2025-01-18T14:00:00.000Z"
----
-
-# Prisma requires schema push
-
-Some content here.`;
-
-      const { frontmatter, body } = parseKnowledgeFrontmatter(content);
-
-      expect(frontmatter).not.toBeNull();
-      expect(frontmatter!.id).toBe('k-prisma-schema-push');
-      expect(frontmatter!.type).toBe('observation');
-      expect(frontmatter!.domain).toEqual(['database', 'orm']);
-      expect(frontmatter!.entities).toEqual(['prisma', 'postgresql']);
-      expect(frontmatter!.confidence).toBe(0.85);
-      expect(frontmatter!.source.origin).toBe('extracted');
-      expect(frontmatter!.source.trajectories).toHaveLength(2);
-      expect(frontmatter!.links).toHaveLength(2);
-      expect(frontmatter!.links[1].layer).toBe('temporal');
-      expect(body).toContain('# Prisma requires schema push');
-    });
-
-    it('returns null frontmatter for content without frontmatter', () => {
-      const { frontmatter, body } = parseKnowledgeFrontmatter(
-        '# Just a title\n\nSome content.'
-      );
-
-      expect(frontmatter).toBeNull();
-      expect(body).toBe('# Just a title\n\nSome content.');
-    });
-
-    it('returns null frontmatter for invalid YAML', () => {
-      const { frontmatter } = parseKnowledgeFrontmatter(
-        '---\n[invalid yaml\n---\nBody'
-      );
-
-      expect(frontmatter).toBeNull();
-    });
-
-    it('returns null frontmatter for missing required fields', () => {
-      const { frontmatter } = parseKnowledgeFrontmatter(
-        '---\ntitle: test\n---\nBody'
-      );
-
-      expect(frontmatter).toBeNull();
-    });
-
-    it('applies defaults for optional fields', () => {
-      const content = `---
-id: k-test
-type: observation
-confidence: 0.5
-source:
-  origin: agent-authored
-created: "2025-01-15T10:00:00.000Z"
-updated: "2025-01-15T10:00:00.000Z"
----
-
-Body`;
-
-      const { frontmatter } = parseKnowledgeFrontmatter(content);
-
-      expect(frontmatter).not.toBeNull();
-      expect(frontmatter!.domain).toEqual([]);
-      expect(frontmatter!.entities).toEqual([]);
-      expect(frontmatter!.tags).toEqual([]);
-      expect(frontmatter!.links).toEqual([]);
-    });
-  });
-
-  describe('serializeKnowledgeFrontmatter', () => {
-    it('produces valid YAML frontmatter block', () => {
-      const output = serializeKnowledgeFrontmatter(sampleFrontmatter);
-
-      expect(output).toMatch(/^---\n/);
-      expect(output).toMatch(/---\n$/);
-      expect(output).toContain('id: k-prisma-schema-push');
-      expect(output).toContain('type: observation');
-      expect(output).toContain('confidence: 0.85');
-    });
-
-    it('omits empty arrays', () => {
-      const fm: KnowledgeNoteFrontmatter = {
-        ...sampleFrontmatter,
-        domain: [],
-        entities: [],
-        tags: [],
-        links: [],
-      };
-
-      const output = serializeKnowledgeFrontmatter(fm);
-
-      expect(output).not.toContain('domain:');
-      expect(output).not.toContain('entities:');
-      expect(output).not.toContain('tags:');
-      expect(output).not.toContain('links:');
-    });
-  });
-
-  describe('round-trip', () => {
-    it('serialize then parse produces equivalent frontmatter', () => {
-      const serialized = serializeKnowledgeFrontmatter(sampleFrontmatter);
-      const fullContent = `${serialized}\n${sampleBody}\n`;
-
-      const { frontmatter, body } = parseKnowledgeFrontmatter(fullContent);
-
-      expect(frontmatter).not.toBeNull();
-      expect(frontmatter!.id).toBe(sampleFrontmatter.id);
-      expect(frontmatter!.type).toBe(sampleFrontmatter.type);
-      expect(frontmatter!.domain).toEqual(sampleFrontmatter.domain);
-      expect(frontmatter!.entities).toEqual(sampleFrontmatter.entities);
-      expect(frontmatter!.confidence).toBe(sampleFrontmatter.confidence);
-      expect(frontmatter!.source).toEqual(sampleFrontmatter.source);
-      expect(frontmatter!.links).toEqual(sampleFrontmatter.links);
-      expect(body).toContain(sampleBody);
-    });
-  });
-
-  describe('parseKnowledgeNote', () => {
-    it('returns a full KnowledgeNote with filePath', () => {
-      const content = `${serializeKnowledgeFrontmatter(sampleFrontmatter)}\n${sampleBody}\n`;
-
-      const note = parseKnowledgeNote(content, 'knowledge/observations/k-prisma-schema-push.md');
-
-      expect(note).not.toBeNull();
-      expect(note!.frontmatter.id).toBe('k-prisma-schema-push');
-      expect(note!.body).toContain(sampleBody);
-      expect(note!.filePath).toBe('knowledge/observations/k-prisma-schema-push.md');
-    });
-
-    it('returns null for content without valid frontmatter', () => {
-      const note = parseKnowledgeNote('No frontmatter here.', 'test.md');
-      expect(note).toBeNull();
-    });
-  });
-
-  describe('serializeKnowledgeNote', () => {
-    it('produces complete markdown with frontmatter + body', () => {
-      const note = {
-        frontmatter: sampleFrontmatter,
-        body: sampleBody,
-        filePath: 'test.md',
-      };
-
-      const output = serializeKnowledgeNote(note);
-
-      expect(output).toMatch(/^---\n/);
-      expect(output).toContain('id: k-prisma-schema-push');
-      expect(output).toContain(sampleBody);
-    });
-  });
-});