@booklib/core 2.0.0

package/tests/wizard/prompt-session.test.js

@@ -0,0 +1,61 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createSession } from '../../lib/wizard/prompt.js';
+import { Readable } from 'node:stream';
+
+function fakeStdin(lines) {
+  const pending = [...lines];
+  return new Readable({
+    read() {
+      if (pending.length > 0) {
+        const line = pending.shift();
+        // Delay push so readline's question listener is ready before data arrives
+        setTimeout(() => this.push(line + '\n'), 5);
+      }
+    },
+  });
+}
+
+test('createSession confirm returns true for "y"', async () => {
+  const stdin = fakeStdin(['y']);
+  const session = createSession({ input: stdin, output: process.stdout });
+  const result = await session.confirm('Continue?', false);
+  assert.strictEqual(result, true);
+  session.close();
+});
+
+test('createSession confirm returns default on empty input', async () => {
+  const stdin = fakeStdin(['']);
+  const session = createSession({ input: stdin, output: process.stdout });
+  const result = await session.confirm('Continue?', true);
+  assert.strictEqual(result, true);
+  session.close();
+});
+
+test('createSession sequential calls do not race', async () => {
+  const stdin = fakeStdin(['y', 'hello', 'n']);
+  const session = createSession({ input: stdin, output: process.stdout });
+  const r1 = await session.confirm('First?', false);
+  const r2 = await session.readText('Name: ');
+  const r3 = await session.confirm('Third?', true);
+  assert.strictEqual(r1, true);
+  assert.strictEqual(r2, 'hello');
+  assert.strictEqual(r3, false);
+  session.close();
+});
+
+test('createSession numberedInput parses comma-separated numbers', async () => {
+  const stdin = fakeStdin(['1,3,5']);
+  const session = createSession({ input: stdin, output: process.stdout });
+  const result = await session.numberedInput('Pick: ', 6);
+  assert.deepStrictEqual(result, [0, 2, 4]);
+  session.close();
+});
+
+test('createSession numberedInput returns empty for Enter', async () => {
+  const stdin = fakeStdin(['']);
+  const session = createSession({ input: stdin, output: process.stdout });
+  const result = await session.numberedInput('Pick: ', 5);
+  assert.deepStrictEqual(result, []);
+  session.close();
+});

package/tests/wizard/prompt.test.js

@@ -0,0 +1,16 @@
+// tests/wizard/prompt.test.js
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { sep, formatProgress } from '../../lib/wizard/prompt.js';
+
+test('sep returns correct length string', () => {
+  assert.equal(sep('─', 10).length, 10);
+  assert.equal(sep('─', 10), '──────────');
+});
+
+test('formatProgress renders bar', () => {
+  const s = formatProgress(15, 30, 20);
+  assert.ok(s.includes('15/30'));
+  assert.ok(s.includes('█'));
+  assert.ok(s.includes('░'));
+});

package/tests/wizard/registry-embeddings.test.js

@@ -0,0 +1,35 @@
+// tests/wizard/registry-embeddings.test.js
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { loadSkillCatalog, extractDescription } from '../../lib/wizard/registry-embeddings.js';
+
+test('loadSkillCatalog returns non-empty array', () => {
+  const catalog = loadSkillCatalog();
+  assert.ok(catalog.length > 0, 'catalog should have skills');
+});
+
+test('catalog entries have name and description', () => {
+  const catalog = loadSkillCatalog();
+  for (const s of catalog) {
+    assert.ok(typeof s.name === 'string' && s.name.length > 0, `${s.name}: missing name`);
+    assert.ok(typeof s.description === 'string' && s.description.length > 0, `${s.name}: missing description`);
+    assert.ok(['bundled', 'registry'].includes(s.source), `${s.name}: invalid source`);
+  }
+});
+
+test('no duplicate names in catalog', () => {
+  const catalog = loadSkillCatalog();
+  const names = catalog.map(s => s.name);
+  const unique = new Set(names);
+  assert.equal(unique.size, names.length, 'duplicate skill names found');
+});
+
+test('extractDescription parses SKILL.md frontmatter', () => {
+  const md = '---\nname: foo\ndescription: A useful skill for bar.\n---\n\n# Content';
+  assert.equal(extractDescription(md), 'A useful skill for bar.');
+});
+
+test('extractDescription returns null when missing', () => {
+  const md = '---\nname: foo\n---\n\n# Content';
+  assert.equal(extractDescription(md), null);
+});

package/tests/wizard/skill-recommender.test.js

@@ -0,0 +1,34 @@
+// tests/wizard/skill-recommender.test.js
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { cosine, filterAndRank } from '../../lib/wizard/skill-recommender.js';
+
+test('cosine of identical vectors is 1', () => {
+  const v = [0.5, 0.3, 0.8];
+  assert.ok(Math.abs(cosine(v, v) - 1) < 0.001);
+});
+
+test('cosine of orthogonal vectors is 0', () => {
+  assert.ok(Math.abs(cosine([1, 0], [0, 1])) < 0.001);
+});
+
+test('filterAndRank excludes installed skills', () => {
+  const catalog = [
+    { name: 'a', description: 'alpha', score: 0.9 },
+    { name: 'b', description: 'beta',  score: 0.8 },
+    { name: 'c', description: 'gamma', score: 0.7 },
+  ];
+  const result = filterAndRank(catalog, { installedNames: ['b'], available: 10 });
+  assert.ok(!result.find(s => s.name === 'b'));
+  assert.equal(result[0].name, 'a');
+});
+
+test('filterAndRank respects available slot count', () => {
+  const catalog = [
+    { name: 'a', score: 0.9 },
+    { name: 'b', score: 0.8 },
+    { name: 'c', score: 0.7 },
+  ];
+  const result = filterAndRank(catalog, { installedNames: [], available: 2 });
+  assert.equal(result.length, 2);
+});

package/tests/wizard/slot-count.test.js

@@ -0,0 +1,25 @@
+// tests/wizard/slot-count.test.js
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { countInstalledSlots, installBundledSkill } from '../../lib/skill-fetcher.js';
+
+test('countInstalledSlots counts only .booklib-marked dirs', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'booklib-slots-'));
+  // marked dir
+  mkdirSync(join(dir, 'skill-a'), { recursive: true });
+  writeFileSync(join(dir, 'skill-a', '.booklib'), '');
+  // unmarked dir (user-managed)
+  mkdirSync(join(dir, 'skill-b'), { recursive: true });
+
+  assert.equal(countInstalledSlots(dir), 1);
+  rmSync(dir, { recursive: true });
+});
+
+test('countInstalledSlots returns 0 for empty dir', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'booklib-slots-'));
+  assert.equal(countInstalledSlots(dir), 0);
+  rmSync(dir, { recursive: true });
+});

package/vercel.json

@@ -0,0 +1,21 @@
+{
+  "framework": null,
+  "outputDirectory": "docs",
+  "cleanUrls": true,
+  "trailingSlash": false,
+  "headers": [
+    {
+      "source": "/assets/(.*)",
+      "headers": [
+        { "key": "Cache-Control", "value": "public, max-age=31536000, immutable" }
+      ]
+    },
+    {
+      "source": "/(.*)",
+      "headers": [
+        { "key": "Cache-Control", "value": "public, max-age=3600, stale-while-revalidate=86400" },
+        { "key": "X-Content-Type-Options", "value": "nosniff" }
+      ]
+    }
+  ]
+}