cognitive-core 0.1.0 → 0.2.0

package/tests/surfacing/skill-publisher.test.ts

@@ -0,0 +1,364 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { convertPlaybookToSkill, SkillPublisher } from '../../src/surfacing/skill-publisher.js';
+import { MemoryStorageAdapter } from 'skill-tree';
+import type { Skill, StorageAdapter } from 'skill-tree';
+import type { Playbook } from '../../src/types/playbook.js';
+
+describe('SkillPublisher', () => {
+  let storage: StorageAdapter;
+
+  beforeEach(async () => {
+    storage = new MemoryStorageAdapter();
+    await storage.initialize();
+  });
+
+  function createSamplePlaybook(overrides?: Partial<Playbook>): Playbook {
+    const now = new Date('2025-06-01T12:00:00Z');
+    return {
+      id: `playbook-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      name: 'fix-ts-import',
+      applicability: {
+        situations: ['TypeScript import fails with TS2307'],
+        triggers: ['TS2307', 'Cannot find module'],
+        antiPatterns: ['Module genuinely does not exist'],
+        domains: ['typescript', 'nodejs'],
+      },
+      guidance: {
+        strategy: 'Add .js extension to ES module imports',
+        tactics: [
+          'Check for imports without file extensions',
+          'Add .js extension to relative imports',
+        ],
+        steps: [
+          'Find the failing import',
+          'Add .js extension',
+          'Verify with tsc --noEmit',
+        ],
+        codeExample: 'import { helper } from "./utils.js";',
+      },
+      verification: {
+        successIndicators: ['Build passes', 'No TS2307 errors'],
+        failureIndicators: ['Same error persists'],
+        rollbackStrategy: 'Remove the .js extension',
+      },
+      evolution: {
+        version: '1.2.0',
+        createdFrom: ['session-abc'],
+        failures: [],
+        refinements: [
+          { context: 'monorepo', addition: 'Check workspace exports', source: 'failure', addedAt: now },
+        ],
+        successCount: 8,
+        failureCount: 2,
+        lastUsed: now,
+      },
+      confidence: 0.85,
+      complexity: 'simple',
+      estimatedEffort: 2,
+      createdAt: now,
+      updatedAt: now,
+      ...overrides,
+    };
+  }
+
+  describe('convertPlaybookToSkill', () => {
+    it('should produce a valid Skill with correct identity fields', () => {
+      const playbook = createSamplePlaybook({ id: 'pb-1', name: 'my-skill' });
+      const skill = convertPlaybookToSkill(playbook);
+
+      expect(skill.id).toBe('pb-1');
+      expect(skill.name).toBe('my-skill');
+      expect(skill.version).toBe('1.2.0');
+      expect(skill.author).toBe('cognitive-core');
+      expect(skill.status).toBe('active');
+    });
+
+    it('should map situations to description and instructions', () => {
+      const playbook = createSamplePlaybook();
+      const skill = convertPlaybookToSkill(playbook);
+
+      expect(skill.description).toBe('TypeScript import fails with TS2307');
+      expect(skill.instructions).toContain('TypeScript import fails with TS2307');
+    });
+
+    it('should build instructions from strategy, tactics, and steps', () => {
+      const playbook = createSamplePlaybook();
+      const skill = convertPlaybookToSkill(playbook);
+
+      expect(skill.instructions).toContain('Add .js extension to ES module imports');
+      expect(skill.instructions).toContain('Tactics:');
+      expect(skill.instructions).toContain('Check for imports without file extensions');
+      expect(skill.instructions).toContain('Steps:');
+      expect(skill.instructions).toContain('Verify with tsc --noEmit');
+    });
+
+    it('should include verification and notes in instructions', () => {
+      const playbook = createSamplePlaybook();
+      const skill = convertPlaybookToSkill(playbook);
+
+      expect(skill.instructions).toContain('Build passes');
+      expect(skill.instructions).toContain('Do NOT use when:');
+      expect(skill.instructions).toContain('Watch for:');
+      expect(skill.instructions).toContain('Refinements:');
+      expect(skill.instructions).toContain('Rollback:');
+    });
+
+    it('should compute metrics from evolution data', () => {
+      const playbook = createSamplePlaybook();
+      const skill = convertPlaybookToSkill(playbook);
+
+      expect(skill.metrics.usageCount).toBe(10); // 8 + 2
+      expect(skill.metrics.successRate).toBe(0.8); // 8/10
+      expect(skill.metrics.averageConfidence).toBe(0.85);
+      expect(skill.metrics.lastUsed).toBeDefined();
+    });
+
+    it('should include code example in instructions', () => {
+      const playbook = createSamplePlaybook();
+      const skill = convertPlaybookToSkill(playbook);
+
+      expect(skill.instructions).toContain('utils.js');
+      expect(skill.instructions).toContain('Example');
+    });
+
+    it('should omit example section when no codeExample', () => {
+      const playbook = createSamplePlaybook();
+      playbook.guidance.codeExample = undefined;
+      const skill = convertPlaybookToSkill(playbook);
+
+      expect(skill.instructions).not.toContain('## Example');
+    });
+
+    it('should set serving metadata with token estimate', () => {
+      const playbook = createSamplePlaybook();
+      const skill = convertPlaybookToSkill(playbook);
+
+      expect(skill.serving).toBeDefined();
+      expect(skill.serving!.tokenEstimate).toBeGreaterThan(0);
+      expect(skill.serving!.summary).toBeDefined();
+    });
+
+    it('should truncate long descriptions in serving summary', () => {
+      const playbook = createSamplePlaybook({
+        applicability: {
+          situations: ['A'.repeat(200)],
+          triggers: [],
+          antiPatterns: [],
+          domains: [],
+        },
+      });
+      const skill = convertPlaybookToSkill(playbook);
+
+      expect(skill.serving!.summary!.length).toBeLessThanOrEqual(150);
+      expect(skill.serving!.summary!).toMatch(/\.\.\.$/);
+    });
+
+    it('should handle minimal playbook with empty arrays', () => {
+      const playbook = createSamplePlaybook({
+        applicability: { situations: [], triggers: [], antiPatterns: [], domains: [] },
+        guidance: { strategy: 'simple fix', tactics: [] },
+        verification: { successIndicators: [], failureIndicators: [] },
+        evolution: {
+          version: '1.0.0', createdFrom: [], failures: [], refinements: [],
+          successCount: 0, failureCount: 0,
+        },
+      });
+      const skill = convertPlaybookToSkill(playbook);
+
+      expect(skill.tags.length).toBe(0);
+      expect(skill.instructions).toContain('Verify the approach worked');
+    });
+
+    it('should be type-compatible with skill-tree Skill', () => {
+      const playbook = createSamplePlaybook();
+      // This assignment verifies compile-time type compatibility
+      const skill: Skill = convertPlaybookToSkill(playbook);
+      expect(skill).toBeDefined();
+    });
+  });
+
+  describe('publish operations', () => {
+    it('should publish a playbook as a new skill', async () => {
+      const publisher = new SkillPublisher(storage);
+      const playbook = createSamplePlaybook({ id: 'pub-1' });
+
+      const result = await publisher.publishPlaybook(playbook);
+
+      expect(result.published).toBe(true);
+      expect(result.skillId).toBe('pub-1');
+      expect(result.version).toBe('1.2.0');
+      expect(result.isUpdate).toBe(false);
+    });
+
+    it('should store the skill in the StorageAdapter', async () => {
+      const publisher = new SkillPublisher(storage);
+      const playbook = createSamplePlaybook({ id: 'store-1' });
+
+      await publisher.publishPlaybook(playbook);
+
+      const skill = await storage.getSkill('store-1');
+      expect(skill).not.toBeNull();
+      expect(skill!.name).toBe('fix-ts-import');
+      expect(skill!.status).toBe('active');
+    });
+
+    it('should mark republish as an update', async () => {
+      const publisher = new SkillPublisher(storage);
+      const playbook = createSamplePlaybook({ id: 'update-1' });
+
+      const first = await publisher.publishPlaybook(playbook);
+      expect(first.isUpdate).toBe(false);
+
+      playbook.evolution.version = '2.0.0';
+      playbook.guidance.strategy = 'Updated approach';
+
+      const second = await publisher.publishPlaybook(playbook);
+      expect(second.published).toBe(true);
+      expect(second.isUpdate).toBe(true);
+      expect(second.version).toBe('2.0.0');
+
+      const skill = await storage.getSkill('update-1');
+      expect(skill!.version).toBe('2.0.0');
+      expect(skill!.instructions).toContain('Updated approach');
+    });
+
+    it('should track published IDs', async () => {
+      const publisher = new SkillPublisher(storage);
+
+      expect(publisher.isPublished('pub-1')).toBe(false);
+      expect(publisher.getPublishedCount()).toBe(0);
+
+      await publisher.publishPlaybook(createSamplePlaybook({ id: 'pub-1' }));
+
+      expect(publisher.isPublished('pub-1')).toBe(true);
+      expect(publisher.getPublishedCount()).toBe(1);
+    });
+
+    it('should publish multiple playbooks', async () => {
+      const publisher = new SkillPublisher(storage);
+
+      const results = await publisher.publishPlaybooks([
+        createSamplePlaybook({ id: 'multi-1' }),
+        createSamplePlaybook({ id: 'multi-2' }),
+        createSamplePlaybook({ id: 'multi-3' }),
+      ]);
+
+      expect(results.length).toBe(3);
+      expect(results.every(r => r.published)).toBe(true);
+      expect(publisher.getPublishedCount()).toBe(3);
+
+      const all = await storage.listSkills();
+      expect(all.length).toBe(3);
+    });
+  });
+
+  describe('deprecate operations', () => {
+    it('should deprecate an existing skill', async () => {
+      const publisher = new SkillPublisher(storage);
+      await publisher.publishPlaybook(createSamplePlaybook({ id: 'dep-1' }));
+
+      const result = await publisher.deprecateSkill('dep-1', 'Low performance');
+
+      expect(result.deprecated).toBe(true);
+      expect(result.skillId).toBe('dep-1');
+      expect(publisher.isPublished('dep-1')).toBe(false);
+
+      const skill = await storage.getSkill('dep-1');
+      expect(skill!.status).toBe('deprecated');
+      expect(skill!.description).toContain('Deprecated: Low performance');
+    });
+
+    it('should return error for non-existent skill', async () => {
+      const publisher = new SkillPublisher(storage);
+
+      const result = await publisher.deprecateSkill('nonexistent', 'reason');
+
+      expect(result.deprecated).toBe(false);
+      expect(result.error).toContain('not found');
+    });
+
+    it('should preserve existing notes when deprecating', async () => {
+      const publisher = new SkillPublisher(storage);
+      await publisher.publishPlaybook(createSamplePlaybook({ id: 'notes-1' }));
+
+      const before = await storage.getSkill('notes-1');
+      expect(before!.instructions).toContain('Do NOT use when:');
+
+      await publisher.deprecateSkill('notes-1', 'Superseded');
+
+      const after = await storage.getSkill('notes-1');
+      expect(after!.description).toContain('Deprecated: Superseded');
+    });
+  });
+
+  describe('end-to-end lifecycle', () => {
+    it('should support full publish → list → filter → deprecate workflow', async () => {
+      const publisher = new SkillPublisher(storage);
+
+      // Publish several skills
+      await publisher.publishPlaybook(createSamplePlaybook({
+        id: 'ts-fix',
+        name: 'ts-fix',
+        applicability: {
+          situations: ['TS error'], triggers: [], antiPatterns: [], domains: ['typescript'],
+        },
+      }));
+      await publisher.publishPlaybook(createSamplePlaybook({
+        id: 'react-fix',
+        name: 'react-fix',
+        applicability: {
+          situations: ['React error'], triggers: [], antiPatterns: [], domains: ['react'],
+        },
+      }));
+      await publisher.publishPlaybook(createSamplePlaybook({
+        id: 'node-fix',
+        name: 'node-fix',
+        applicability: {
+          situations: ['Node error'], triggers: [], antiPatterns: [], domains: ['nodejs'],
+        },
+      }));
+
+      // List all
+      const all = await storage.listSkills();
+      expect(all.length).toBe(3);
+
+      // Filter by tag
+      const tsSkills = await storage.listSkills({ tags: ['typescript'] });
+      expect(tsSkills.length).toBe(1);
+      expect(tsSkills[0].id).toBe('ts-fix');
+
+      // Deprecate one
+      await publisher.deprecateSkill('node-fix', 'Replaced');
+
+      const active = await storage.listSkills({ status: ['active'] });
+      expect(active.length).toBe(2);
+
+      const deprecated = await storage.listSkills({ status: ['deprecated'] });
+      expect(deprecated.length).toBe(1);
+      expect(deprecated[0].id).toBe('node-fix');
+    });
+
+    it('should handle version evolution through publish updates', async () => {
+      const publisher = new SkillPublisher(storage);
+      const playbook = createSamplePlaybook({ id: 'evolve-1' });
+
+      // v1
+      await publisher.publishPlaybook(playbook);
+      let skill = await storage.getSkill('evolve-1');
+      expect(skill!.version).toBe('1.2.0');
+
+      // Evolve
+      playbook.evolution.version = '2.0.0';
+      playbook.evolution.successCount = 20;
+      playbook.confidence = 0.95;
+
+      const result = await publisher.publishPlaybook(playbook);
+      expect(result.isUpdate).toBe(true);
+
+      skill = await storage.getSkill('evolve-1');
+      expect(skill!.version).toBe('2.0.0');
+      expect(skill!.metrics.usageCount).toBe(22);
+      expect(skill!.metrics.averageConfidence).toBe(0.95);
+    });
+  });
+});

package/tests/surfacing/sqlite-storage-adapter.test.ts

@@ -0,0 +1,206 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { SqliteStorageAdapter } from '../../src/surfacing/sqlite-storage-adapter.js';
+import type { Skill } from 'skill-tree';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+function createSampleSkill(overrides?: Partial<Skill>): Skill {
+  const now = new Date('2025-06-01T12:00:00Z');
+  return {
+    id: `skill-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    name: 'fix-ts-import',
+    version: '1.0.0',
+    description: 'Fix TypeScript import errors',
+    instructions: 'Add .js extension to ES module imports',
+    author: 'cognitive-core',
+    status: 'active',
+    tags: ['typescript', 'nodejs'],
+    metrics: {
+      usageCount: 8,
+      successRate: 0.9,
+      lastUsed: now,
+      feedbackScores: [],
+      averageConfidence: 0.85,
+    },
+    source: {
+      type: 'extracted',
+      sessionId: 'session-abc',
+      importedAt: now,
+    },
+    serving: {
+      summary: 'Fix TypeScript import errors by adding .js extension',
+      tokenEstimate: 150,
+    },
+    createdAt: now,
+    updatedAt: now,
+    ...overrides,
+  };
+}
+
+describe('SqliteStorageAdapter', () => {
+  let tempDir: string;
+  let adapter: SqliteStorageAdapter;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'atlas-adapter-'));
+    adapter = new SqliteStorageAdapter(join(tempDir, 'skills.db'));
+    await adapter.initialize();
+  });
+
+  afterEach(async () => {
+    adapter.close();
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('initialize() is idempotent', async () => {
+    // Calling initialize a second time should not throw
+    await adapter.initialize();
+    await adapter.initialize();
+  });
+
+  it('saveSkill() + getSkill() round-trip', async () => {
+    const skill = createSampleSkill({ id: 'skill-roundtrip' });
+    await adapter.saveSkill(skill);
+
+    const retrieved = await adapter.getSkill('skill-roundtrip');
+    expect(retrieved).not.toBeNull();
+    expect(retrieved!.id).toBe('skill-roundtrip');
+    expect(retrieved!.name).toBe('fix-ts-import');
+    expect(retrieved!.version).toBe('1.0.0');
+    expect(retrieved!.instructions).toBe('Add .js extension to ES module imports');
+    expect(retrieved!.status).toBe('active');
+  });
+
+  it('getSkill() returns null for missing ID', async () => {
+    const result = await adapter.getSkill('nonexistent');
+    expect(result).toBeNull();
+  });
+
+  it('saveSkill() overwrites existing skill', async () => {
+    const skill = createSampleSkill({ id: 'skill-update', version: '1.0.0' });
+    await adapter.saveSkill(skill);
+
+    const updated = createSampleSkill({ id: 'skill-update', version: '2.0.0', instructions: 'Updated solution' });
+    await adapter.saveSkill(updated);
+
+    const retrieved = await adapter.getSkill('skill-update');
+    expect(retrieved!.version).toBe('2.0.0');
+    expect(retrieved!.instructions).toBe('Updated solution');
+  });
+
+  it('listSkills() returns all skills', async () => {
+    await adapter.saveSkill(createSampleSkill({ id: 'skill-1' }));
+    await adapter.saveSkill(createSampleSkill({ id: 'skill-2' }));
+    await adapter.saveSkill(createSampleSkill({ id: 'skill-3' }));
+
+    const skills = await adapter.listSkills();
+    expect(skills).toHaveLength(3);
+  });
+
+  it('listSkills() filters by status', async () => {
+    await adapter.saveSkill(createSampleSkill({ id: 'skill-active', status: 'active' }));
+    await adapter.saveSkill(createSampleSkill({ id: 'skill-deprecated', status: 'deprecated' }));
+
+    const active = await adapter.listSkills({ status: ['active'] });
+    expect(active).toHaveLength(1);
+    expect(active[0].id).toBe('skill-active');
+
+    const deprecated = await adapter.listSkills({ status: ['deprecated'] });
+    expect(deprecated).toHaveLength(1);
+    expect(deprecated[0].id).toBe('skill-deprecated');
+  });
+
+  it('listSkills() filters by tags', async () => {
+    await adapter.saveSkill(createSampleSkill({ id: 'skill-ts', tags: ['typescript'] }));
+    await adapter.saveSkill(createSampleSkill({ id: 'skill-py', tags: ['python'] }));
+
+    const tsSkills = await adapter.listSkills({ tags: ['typescript'] });
+    expect(tsSkills).toHaveLength(1);
+    expect(tsSkills[0].id).toBe('skill-ts');
+  });
+
+  it('JSON fields survive round-trip', async () => {
+    const skill = createSampleSkill({ id: 'skill-json' });
+    await adapter.saveSkill(skill);
+
+    const retrieved = await adapter.getSkill('skill-json');
+    expect(retrieved!.tags).toEqual(['typescript', 'nodejs']);
+    expect(retrieved!.metrics.usageCount).toBe(8);
+    expect(retrieved!.metrics.successRate).toBe(0.9);
+    expect(retrieved!.source!.type).toBe('extracted');
+    expect(retrieved!.serving!.tokenEstimate).toBe(150);
+  });
+
+  it('Date fields survive round-trip', async () => {
+    const now = new Date('2025-06-01T12:00:00.000Z');
+    const skill = createSampleSkill({ id: 'skill-dates', createdAt: now, updatedAt: now });
+    await adapter.saveSkill(skill);
+
+    const retrieved = await adapter.getSkill('skill-dates');
+    expect(retrieved!.createdAt).toBeInstanceOf(Date);
+    expect(retrieved!.updatedAt).toBeInstanceOf(Date);
+    expect(retrieved!.createdAt.toISOString()).toBe('2025-06-01T12:00:00.000Z');
+  });
+
+  it('deleteSkill() removes the skill', async () => {
+    await adapter.saveSkill(createSampleSkill({ id: 'skill-delete' }));
+    expect(await adapter.getSkill('skill-delete')).not.toBeNull();
+
+    const deleted = await adapter.deleteSkill('skill-delete');
+    expect(deleted).toBe(true);
+    expect(await adapter.getSkill('skill-delete')).toBeNull();
+  });
+
+  it('deleteSkill() returns false for missing skill', async () => {
+    const deleted = await adapter.deleteSkill('nonexistent');
+    expect(deleted).toBe(false);
+  });
+
+  it('getVersionHistory() tracks versions', async () => {
+    const skill1 = createSampleSkill({ id: 'skill-versioned', version: '1.0.0' });
+    await adapter.saveSkill(skill1);
+
+    const skill2 = createSampleSkill({ id: 'skill-versioned', version: '2.0.0', instructions: 'Updated' });
+    await adapter.saveSkill(skill2);
+
+    const history = await adapter.getVersionHistory('skill-versioned');
+    expect(history).toHaveLength(2);
+    expect(history[0].version).toBe('1.0.0');
+    expect(history[1].version).toBe('2.0.0');
+  });
+
+  it('getLineage() returns version history', async () => {
+    await adapter.saveSkill(createSampleSkill({ id: 'skill-lineage', version: '1.0.0' }));
+
+    const lineage = await adapter.getLineage('skill-lineage');
+    expect(lineage).not.toBeNull();
+    expect(lineage!.rootId).toBe('skill-lineage');
+    expect(lineage!.versions).toHaveLength(1);
+  });
+
+  it('getLineage() returns null for missing skill', async () => {
+    const lineage = await adapter.getLineage('nonexistent');
+    expect(lineage).toBeNull();
+  });
+
+  it('searchSkills() finds by name', async () => {
+    await adapter.saveSkill(createSampleSkill({ id: 'skill-search', name: 'fix-import-error' }));
+    await adapter.saveSkill(createSampleSkill({ id: 'skill-other', name: 'refactor-tests', instructions: 'Reorganize test files' }));
+
+    const results = await adapter.searchSkills('refactor');
+    expect(results).toHaveLength(1);
+    expect(results[0].id).toBe('skill-other');
+  });
+
+  it('searchSkills() finds by instructions content', async () => {
+    await adapter.saveSkill(createSampleSkill({
+      id: 'skill-solution',
+      instructions: 'Use jest.mock() to mock dependencies',
+    }));
+
+    const results = await adapter.searchSkills('jest.mock');
+    expect(results).toHaveLength(1);
+    expect(results[0].id).toBe('skill-solution');
+  });
+});