moving

packages/core/tests/skill-hashes.test.ts

@@ -0,0 +1,115 @@
+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 { MindDB } from '@waggle/hive-mind-core';
+import { SkillHashStore, computeSkillHash } from '../src/skill-hashes.js';
+
+describe('SkillHashStore', () => {
+  let tmpDir: string;
+  let db: MindDB;
+  let store: SkillHashStore;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'waggle-skill-hash-'));
+    db = new MindDB(path.join(tmpDir, 'test.mind'));
+    store = new SkillHashStore(db);
+  });
+
+  afterEach(() => {
+    db.close();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('setHash + getHash round-trips correctly', () => {
+    const hash = computeSkillHash('# My Skill\nDo something useful');
+    store.setHash('my-skill', hash);
+
+    const stored = store.getHash('my-skill');
+    expect(stored).toBeDefined();
+    expect(stored!.name).toBe('my-skill');
+    expect(stored!.hash).toBe(hash);
+    expect(stored!.verified_at).toBeTruthy();
+  });
+
+  it('computeSkillHash produces consistent SHA-256', () => {
+    const content = '# Draft Memo\nHelp the user draft professional memos.';
+    const hash1 = computeSkillHash(content);
+    const hash2 = computeSkillHash(content);
+
+    expect(hash1).toBe(hash2);
+    // SHA-256 hex is 64 characters
+    expect(hash1).toHaveLength(64);
+    // Should be hex string
+    expect(hash1).toMatch(/^[0-9a-f]{64}$/);
+  });
+
+  it('checkAll detects changed skill', () => {
+    const originalContent = '# Skill v1\nOriginal content';
+    store.verify('changed-skill', originalContent);
+
+    const result = store.checkAll([
+      { name: 'changed-skill', content: '# Skill v2\nModified content' },
+    ]);
+
+    expect(result.changed).toEqual(['changed-skill']);
+    expect(result.added).toEqual([]);
+    expect(result.removed).toEqual([]);
+  });
+
+  it('checkAll detects new (added) skill', () => {
+    const result = store.checkAll([
+      { name: 'brand-new-skill', content: '# New Skill\nFresh content' },
+    ]);
+
+    expect(result.added).toEqual(['brand-new-skill']);
+    expect(result.changed).toEqual([]);
+    expect(result.removed).toEqual([]);
+  });
+
+  it('checkAll detects removed skill', () => {
+    store.verify('old-skill', '# Old Skill\nGone now');
+
+    const result = store.checkAll([]);
+
+    expect(result.removed).toEqual(['old-skill']);
+    expect(result.changed).toEqual([]);
+    expect(result.added).toEqual([]);
+  });
+
+  it('checkAll returns empty when nothing changed', () => {
+    const content = '# Stable Skill\nNothing changed here';
+    store.verify('stable-skill', content);
+
+    const result = store.checkAll([
+      { name: 'stable-skill', content },
+    ]);
+
+    expect(result.changed).toEqual([]);
+    expect(result.added).toEqual([]);
+    expect(result.removed).toEqual([]);
+  });
+
+  it('verify updates hash to current content', () => {
+    const v1 = '# Skill v1';
+    const v2 = '# Skill v2';
+    store.verify('evolving-skill', v1);
+
+    const hashBefore = store.getHash('evolving-skill')!.hash;
+    expect(hashBefore).toBe(computeSkillHash(v1));
+
+    store.verify('evolving-skill', v2);
+
+    const hashAfter = store.getHash('evolving-skill')!.hash;
+    expect(hashAfter).toBe(computeSkillHash(v2));
+    expect(hashAfter).not.toBe(hashBefore);
+  });
+
+  it('removeHash cleans up', () => {
+    store.verify('doomed-skill', '# Doomed');
+    expect(store.getHash('doomed-skill')).toBeDefined();
+
+    store.removeHash('doomed-skill');
+    expect(store.getHash('doomed-skill')).toBeUndefined();
+  });
+});