@booklib/core 2.0.0

package/tests/engine/query-expander.test.js

@@ -0,0 +1,36 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { expandQuery, extractKeywords } from '../../lib/engine/query-expander.js';
+
+describe('expandQuery', () => {
+  it('returns original query in result', () => {
+    assert.strictEqual(expandQuery('null safety kotlin').original, 'null safety kotlin');
+  });
+
+  it('returns at least one expanded query variant', () => {
+    const result = expandQuery('null safety kotlin');
+    assert.ok(result.expanded.length >= 1);
+  });
+
+  it('keywords strips stopwords', () => {
+    const result = expandQuery('how to handle null values in Kotlin');
+    assert.ok(!result.keywords.includes('how'));
+    assert.ok(!result.keywords.includes('to'));
+    assert.ok(!result.keywords.includes('in'));
+    assert.ok(result.keywords.includes('handle'));
+    assert.ok(result.keywords.includes('null'));
+    assert.ok(result.keywords.includes('values'));
+    assert.ok(result.keywords.includes('kotlin'));
+  });
+
+  it('handles single-word query without error', () => {
+    const result = expandQuery('kotlin');
+    assert.strictEqual(result.original, 'kotlin');
+    assert.ok(result.expanded.length >= 1);
+  });
+
+  it('expanded variants do not include the original query verbatim', () => {
+    const result = expandQuery('null safety kotlin');
+    assert.ok(!result.expanded.includes('null safety kotlin'));
+  });
+});

package/tests/engine/reranker.test.js

@@ -0,0 +1,51 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { Reranker } from '../../lib/engine/reranker.js';
+
+const CANDIDATES = [
+  { score: 0.5, text: 'kotlin null safety avoid exceptions', metadata: { name: 'effective-kotlin' } },
+  { score: 0.6, text: 'java null pointer best practices', metadata: { name: 'effective-java' } },
+  { score: 0.4, text: 'typescript undefined checking', metadata: { name: 'effective-typescript' } },
+];
+
+function makeRerankerWithMock(scoreFn) {
+  const reranker = new Reranker();
+  let callIndex = 0;
+  reranker._pipeline = async (inputs) => {
+    return inputs.map(() => [{ label: 'LABEL_1', score: scoreFn(callIndex++) }]);
+  };
+  return reranker;
+}
+
+describe('Reranker', () => {
+  it('returns same number of candidates', async () => {
+    const reranker = makeRerankerWithMock(() => 0.5);
+    const result = await reranker.rerank('null safety', CANDIDATES);
+    assert.strictEqual(result.length, CANDIDATES.length);
+  });
+
+  it('sorts results by reranker score descending', async () => {
+    const scores = [0.9, 0.3, 0.6];
+    const reranker = makeRerankerWithMock((i) => scores[i]);
+    const result = await reranker.rerank('null safety', CANDIDATES);
+    for (let i = 1; i < result.length; i++) {
+      assert.ok(result[i - 1].score >= result[i].score);
+    }
+  });
+
+  it('preserves text and metadata on each result', async () => {
+    const reranker = makeRerankerWithMock(() => 0.5);
+    const result = await reranker.rerank('null safety', CANDIDATES);
+    const names = result.map(r => r.metadata.name);
+    assert.ok(names.includes('effective-kotlin'));
+    assert.ok(names.includes('effective-java'));
+    assert.ok(names.includes('effective-typescript'));
+  });
+
+  it('returns empty array for empty candidates without loading model', async () => {
+    const reranker = new Reranker();
+    // No _pipeline set — would throw if accessed
+    const result = await reranker.rerank('query', []);
+    assert.deepEqual(result, []);
+  });
+});

package/tests/engine/rrf.test.js

@@ -0,0 +1,49 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { reciprocalRankFusion } from '../../lib/engine/rrf.js';
+
+const makeList = (...names) => names.map((name, i) => ({
+  score: 1 - i * 0.1,
+  text: `text for ${name}`,
+  metadata: { name },
+}));
+
+describe('reciprocalRankFusion', () => {
+  it('merges two lists and returns items from both', () => {
+    const result = reciprocalRankFusion([makeList('a','b','c'), makeList('b','c','d')]);
+    const names = result.map(r => r.metadata.name);
+    assert.ok(names.includes('a') && names.includes('b') && names.includes('c') && names.includes('d'));
+  });
+
+  it('items appearing in multiple lists score higher than single-list items', () => {
+    const listA = makeList('shared', 'unique-a');
+    const listB = makeList('shared', 'unique-b');
+    const result = reciprocalRankFusion([listA, listB]);
+    const sharedScore = result.find(r => r.metadata.name === 'shared').score;
+    const uniqueAScore = result.find(r => r.metadata.name === 'unique-a').score;
+    const uniqueBScore = result.find(r => r.metadata.name === 'unique-b').score;
+    assert.ok(sharedScore > uniqueAScore && sharedScore > uniqueBScore);
+  });
+
+  it('respects weights — higher weight list contributes more', () => {
+    const result = reciprocalRankFusion([makeList('only-in-a'), makeList('only-in-b')], { weights: [2, 1] });
+    const scoreA = result.find(r => r.metadata.name === 'only-in-a').score;
+    const scoreB = result.find(r => r.metadata.name === 'only-in-b').score;
+    assert.ok(scoreA > scoreB);
+  });
+
+  it('deduplicates items that appear in multiple lists', () => {
+    const result = reciprocalRankFusion([makeList('dup','x'), makeList('dup','y')]);
+    assert.strictEqual(result.filter(r => r.metadata.name === 'dup').length, 1);
+  });
+
+  it('returns results sorted by score descending', () => {
+    const result = reciprocalRankFusion([makeList('a','b','c'), makeList('c','b','a')]);
+    for (let i = 1; i < result.length; i++) assert.ok(result[i-1].score >= result[i].score);
+  });
+
+  it('handles empty input lists', () => {
+    assert.deepEqual(reciprocalRankFusion([]), []);
+    assert.deepEqual(reciprocalRankFusion([[]]), []);
+  });
+});

package/tests/engine/srag-prefix.test.js

@@ -0,0 +1,47 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { buildMetadataPrefix } from '../../lib/engine/indexer.js';
+
+describe('buildMetadataPrefix', () => {
+  test('returns prefix with skill name, type, and tags', () => {
+    const prefix = buildMetadataPrefix({
+      name: 'effective-kotlin',
+      type: 'anti_patterns',
+      tags: ['kotlin', 'jvm'],
+    });
+    assert.strictEqual(prefix, '[skill:effective-kotlin] [type:anti_patterns] [tags:kotlin,jvm] ');
+  });
+
+  test('returns prefix with name only when type and tags are missing', () => {
+    const prefix = buildMetadataPrefix({ name: 'clean-code-reviewer' });
+    assert.strictEqual(prefix, '[skill:clean-code-reviewer] ');
+  });
+
+  test('returns empty string when metadata has no relevant fields', () => {
+    const prefix = buildMetadataPrefix({ filePath: 'some/path.md' });
+    assert.strictEqual(prefix, '');
+  });
+
+  test('omits tags bracket when tags array is empty', () => {
+    const prefix = buildMetadataPrefix({ name: 'effective-java', type: 'summary', tags: [] });
+    assert.strictEqual(prefix, '[skill:effective-java] [type:summary] ');
+  });
+
+  test('handles knowledge node metadata (title instead of name)', () => {
+    const prefix = buildMetadataPrefix({
+      title: 'Null Object Pattern',
+      type: 'insight',
+      tags: ['kotlin', 'patterns'],
+    });
+    assert.strictEqual(prefix, '[skill:Null Object Pattern] [type:insight] [tags:kotlin,patterns] ');
+  });
+
+  test('prefers name over title when both present', () => {
+    const prefix = buildMetadataPrefix({
+      name: 'effective-kotlin',
+      title: 'Some Title',
+      type: 'summary',
+    });
+    assert.strictEqual(prefix, '[skill:effective-kotlin] [type:summary] ');
+  });
+});

package/tests/instinct-block.test.js

@@ -0,0 +1,23 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { renderInstinctBlock } from '../lib/instinct-block.js';
+
+test('MCP-capable tool gets MCP tool names', () => {
+  const block = renderInstinctBlock('claude');
+  assert.ok(block.includes('search_skills'), 'should reference MCP tool name');
+  assert.ok(block.includes('create_note'), 'should reference create_note');
+  assert.ok(!block.includes('booklib search'), 'should not reference CLI command');
+});
+
+test('non-MCP tool gets CLI commands', () => {
+  const block = renderInstinctBlock('junie');
+  assert.ok(block.includes('booklib search'), 'should reference CLI command');
+  assert.ok(!block.includes('search_skills'), 'should not reference MCP tool name');
+});
+
+test('all MCP tools get MCP version', () => {
+  for (const tool of ['claude', 'cursor', 'copilot', 'gemini', 'codex', 'windsurf', 'roo-code', 'goose']) {
+    const block = renderInstinctBlock(tool);
+    assert.ok(block.includes('search_skills'), `${tool} should get MCP version`);
+  }
+});

package/tests/mcp-config-writer.test.js

@@ -0,0 +1,60 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { writeMCPConfig, MCP_CAPABLE } from '../lib/mcp-config-writer.js';
+
+function tmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'booklib-mcp-test-'));
+}
+
+test('writes claude MCP config with mcpServers key', () => {
+  const cwd = tmpDir();
+  writeMCPConfig('claude', cwd);
+  const config = JSON.parse(fs.readFileSync(path.join(cwd, '.claude', 'settings.json'), 'utf8'));
+  assert.ok(config.mcpServers.booklib);
+  assert.strictEqual(config.mcpServers.booklib.command, 'booklib-mcp');
+  fs.rmSync(cwd, { recursive: true });
+});
+
+test('writes copilot MCP config with servers key', () => {
+  const cwd = tmpDir();
+  writeMCPConfig('copilot', cwd);
+  const config = JSON.parse(fs.readFileSync(path.join(cwd, '.vscode', 'mcp.json'), 'utf8'));
+  assert.ok(config.servers.booklib, 'copilot should use "servers" root key');
+  assert.ok(!config.mcpServers, 'copilot should NOT have mcpServers');
+  fs.rmSync(cwd, { recursive: true });
+});
+
+test('writes roo-code MCP config', () => {
+  const cwd = tmpDir();
+  writeMCPConfig('roo-code', cwd);
+  const config = JSON.parse(fs.readFileSync(path.join(cwd, '.roo', 'mcp.json'), 'utf8'));
+  assert.ok(config.mcpServers.booklib);
+  fs.rmSync(cwd, { recursive: true });
+});
+
+test('merges with existing JSON config', () => {
+  const cwd = tmpDir();
+  const configDir = path.join(cwd, '.cursor');
+  fs.mkdirSync(configDir, { recursive: true });
+  fs.writeFileSync(path.join(configDir, 'mcp.json'), JSON.stringify({ mcpServers: { other: { command: 'other' } } }));
+  writeMCPConfig('cursor', cwd);
+  const config = JSON.parse(fs.readFileSync(path.join(configDir, 'mcp.json'), 'utf8'));
+  assert.ok(config.mcpServers.booklib, 'booklib should be added');
+  assert.ok(config.mcpServers.other, 'existing server should be preserved');
+  fs.rmSync(cwd, { recursive: true });
+});
+
+test('returns null for non-MCP tool', () => {
+  const result = writeMCPConfig('junie', '/tmp');
+  assert.strictEqual(result, null);
+});
+
+test('MCP_CAPABLE includes 10 tools', () => {
+  assert.strictEqual(MCP_CAPABLE.size, 10);
+  assert.ok(MCP_CAPABLE.has('copilot'));
+  assert.ok(MCP_CAPABLE.has('roo-code'));
+  assert.ok(!MCP_CAPABLE.has('junie'));
+});

package/tests/project-initializer-new-agents.test.js

@@ -0,0 +1,48 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, existsSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { ProjectInitializer } from '../lib/project-initializer.js';
+
+function tmpDir() {
+  return mkdtempSync(path.join(tmpdir(), 'booklib-init-test-'));
+}
+
+const NEW_AGENTS = [
+  { target: 'roo-code',   file: '.roo/rules/booklib-standards.md' },
+  { target: 'openhands',  file: '.openhands/instructions.md' },
+  { target: 'junie',      file: '.junie/guidelines.md' },
+  { target: 'goose',      file: '.goose/context.md' },
+  { target: 'opencode',   file: '.opencode/instructions.md' },
+  { target: 'letta',      file: '.letta/skills/booklib.md' },
+];
+
+for (const { target, file } of NEW_AGENTS) {
+  test(`${target}: writes to ${file}`, async () => {
+    const cwd = tmpDir();
+    const init = new ProjectInitializer({ projectCwd: cwd });
+    await init.init({ skills: ['effective-kotlin'], target });
+    assert.ok(existsSync(path.join(cwd, file)), `Missing ${file}`);
+    rmSync(cwd, { recursive: true });
+  });
+
+  test(`${target}: written file contains booklib marker`, async () => {
+    const cwd = tmpDir();
+    const init = new ProjectInitializer({ projectCwd: cwd });
+    await init.init({ skills: ['effective-kotlin'], target });
+    const content = readFileSync(path.join(cwd, file), 'utf8');
+    assert.ok(content.includes('booklib-standards-start'), `Missing marker in ${file}`);
+    rmSync(cwd, { recursive: true });
+  });
+}
+
+test('ALL_TARGETS includes all new agents', async () => {
+  const cwd = tmpDir();
+  const init = new ProjectInitializer({ projectCwd: cwd });
+  const written = await init.init({ skills: ['effective-kotlin'], target: 'all' });
+  for (const { file } of NEW_AGENTS) {
+    assert.ok(written.includes(file), `all target missed ${file}`);
+  }
+  rmSync(cwd, { recursive: true });
+});

package/tests/rules/rules-manager.test.js

@@ -0,0 +1,230 @@
+// tests/rules/rules-manager.test.js
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  mkdtempSync, rmSync, mkdirSync, writeFileSync,
+  existsSync, readFileSync,
+} from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { listAvailable, installRule, status } from '../../lib/rules/rules-manager.js';
+
+function tmp() { return mkdtempSync(join(tmpdir(), 'booklib-rules-')); }
+
+// ─── listAvailable ───────────────────────────────────────────────────────────
+
+test('listAvailable returns entries for each language directory', () => {
+  const result = listAvailable();
+  assert.ok(Array.isArray(result));
+  assert.ok(result.length > 0);
+  const langs = result.map(r => r.lang);
+  assert.ok(langs.includes('python'));
+  assert.ok(langs.includes('common'));
+});
+
+test('listAvailable includes files array for each lang', () => {
+  const result = listAvailable();
+  for (const item of result) {
+    assert.ok(Array.isArray(item.files));
+    assert.ok(item.files.every(f => f.endsWith('.md')));
+  }
+});
+
+test('listAvailable sets installedProject false when no .cursor/rules', () => {
+  const cwd = tmp();
+  const home = tmp();
+  const result = listAvailable(cwd, home);
+  for (const item of result) {
+    assert.equal(item.installedProject, false);
+  }
+  rmSync(cwd, { recursive: true });
+  rmSync(home, { recursive: true });
+});
+
+test('listAvailable sets installedProject true when mdc file found', () => {
+  const cwd = tmp();
+  const home = tmp();
+  mkdirSync(join(cwd, '.cursor', 'rules'), { recursive: true });
+  writeFileSync(join(cwd, '.cursor', 'rules', 'python-effective-python.mdc'), '# test');
+  const result = listAvailable(cwd, home);
+  const py = result.find(r => r.lang === 'python');
+  assert.ok(py);
+  assert.equal(py.installedProject, true);
+  rmSync(cwd, { recursive: true });
+  rmSync(home, { recursive: true });
+});
+
+test('listAvailable sets installedGlobal true when marker found in CLAUDE.md', () => {
+  const cwd = tmp();
+  const home = tmp();
+  mkdirSync(join(home, '.claude'), { recursive: true });
+  writeFileSync(
+    join(home, '.claude', 'CLAUDE.md'),
+    '<!-- booklib-rules-python-start -->\nsome content\n<!-- booklib-rules-python-end -->\n',
+  );
+  const result = listAvailable(cwd, home);
+  const py = result.find(r => r.lang === 'python');
+  assert.ok(py);
+  assert.equal(py.installedGlobal, true);
+  rmSync(cwd, { recursive: true });
+  rmSync(home, { recursive: true });
+});
+
+// ─── installRule (project) ───────────────────────────────────────────────────
+
+test('installRule writes mdc file to .cursor/rules/', () => {
+  const cwd = tmp();
+  const home = tmp();
+  const written = installRule('python', { cwd, home });
+  assert.ok(written.length > 0);
+  const destFile = join(cwd, '.cursor', 'rules', 'python-effective-python.mdc');
+  assert.ok(existsSync(destFile));
+  rmSync(cwd, { recursive: true });
+  rmSync(home, { recursive: true });
+});
+
+test('installRule adds MDC frontmatter when absent', () => {
+  const cwd = tmp();
+  const home = tmp();
+  installRule('python', { cwd, home });
+  const destFile = join(cwd, '.cursor', 'rules', 'python-effective-python.mdc');
+  const content = readFileSync(destFile, 'utf8');
+  assert.ok(content.startsWith('---'));
+  assert.ok(content.includes('alwaysApply: false'));
+  rmSync(cwd, { recursive: true });
+  rmSync(home, { recursive: true });
+});
+
+test('installRule preserves existing frontmatter', () => {
+  const cwd = tmp();
+  const home = tmp();
+  installRule('python', { cwd, home });
+  const destFile = join(cwd, '.cursor', 'rules', 'python-effective-python.mdc');
+  const content = readFileSync(destFile, 'utf8');
+  const frontmatterCount = (content.match(/^---/gm) || []).length;
+  assert.ok(frontmatterCount <= 2, `Too many frontmatter markers: ${frontmatterCount}`);
+  rmSync(cwd, { recursive: true });
+  rmSync(home, { recursive: true });
+});
+
+test('installRule throws for unknown lang', () => {
+  const cwd = tmp();
+  const home = tmp();
+  assert.throws(
+    () => installRule('scala', { cwd, home }),
+    /Unknown language/,
+  );
+  rmSync(cwd, { recursive: true });
+  rmSync(home, { recursive: true });
+});
+
+// ─── installRule (global) ────────────────────────────────────────────────────
+
+test('installRule global appends section to CLAUDE.md', () => {
+  const cwd = tmp();
+  const home = tmp();
+  mkdirSync(join(home, '.claude'), { recursive: true });
+  installRule('python', { cwd, home, global: true });
+  const content = readFileSync(join(home, '.claude', 'CLAUDE.md'), 'utf8');
+  assert.ok(content.includes('<!-- booklib-rules-python-start -->'));
+  assert.ok(content.includes('<!-- booklib-rules-python-end -->'));
+  rmSync(cwd, { recursive: true });
+  rmSync(home, { recursive: true });
+});
+
+test('installRule global is idempotent — replaces existing section', () => {
+  const cwd = tmp();
+  const home = tmp();
+  mkdirSync(join(home, '.claude'), { recursive: true });
+  installRule('python', { cwd, home, global: true });
+  installRule('python', { cwd, home, global: true });
+  const content = readFileSync(join(home, '.claude', 'CLAUDE.md'), 'utf8');
+  const startCount = (content.match(/<!-- booklib-rules-python-start -->/g) || []).length;
+  assert.equal(startCount, 1);
+  rmSync(cwd, { recursive: true });
+  rmSync(home, { recursive: true });
+});
+
+test('installRule global creates CLAUDE.md if absent', () => {
+  const cwd = tmp();
+  const home = tmp();
+  mkdirSync(join(home, '.claude'), { recursive: true });
+  installRule('python', { cwd, home, global: true });
+  assert.ok(existsSync(join(home, '.claude', 'CLAUDE.md')));
+  rmSync(cwd, { recursive: true });
+  rmSync(home, { recursive: true });
+});
+
+test('installRule global preserves existing CLAUDE.md content', () => {
+  const cwd = tmp();
+  const home = tmp();
+  mkdirSync(join(home, '.claude'), { recursive: true });
+  writeFileSync(join(home, '.claude', 'CLAUDE.md'), '# My existing rules\n\nDo not delete me.\n');
+  installRule('python', { cwd, home, global: true });
+  const content = readFileSync(join(home, '.claude', 'CLAUDE.md'), 'utf8');
+  assert.ok(content.includes('# My existing rules'));
+  assert.ok(content.includes('Do not delete me.'));
+  assert.ok(content.includes('<!-- booklib-rules-python-start -->'));
+  rmSync(cwd, { recursive: true });
+  rmSync(home, { recursive: true });
+});
+
+// ─── status ──────────────────────────────────────────────────────────────────
+
+test('status returns empty when no rules installed', () => {
+  const cwd = tmp();
+  const home = tmp();
+  const result = status(cwd, home);
+  assert.deepEqual(result.cursor, []);
+  assert.deepEqual(result.global, []);
+  assert.equal(result.totalBytes, 0);
+  rmSync(cwd, { recursive: true });
+  rmSync(home, { recursive: true });
+});
+
+test('status lists cursor mdc files with sizes', () => {
+  const cwd = tmp();
+  const home = tmp();
+  mkdirSync(join(cwd, '.cursor', 'rules'), { recursive: true });
+  writeFileSync(join(cwd, '.cursor', 'rules', 'python-effective-python.mdc'), 'hello world');
+  const result = status(cwd, home);
+  assert.equal(result.cursor.length, 1);
+  assert.ok(result.cursor[0].path.endsWith('python-effective-python.mdc'));
+  assert.ok(result.cursor[0].sizeBytes > 0);
+  rmSync(cwd, { recursive: true });
+  rmSync(home, { recursive: true });
+});
+
+test('status lists global sections with sizes', () => {
+  const cwd = tmp();
+  const home = tmp();
+  mkdirSync(join(home, '.claude'), { recursive: true });
+  writeFileSync(
+    join(home, '.claude', 'CLAUDE.md'),
+    '<!-- booklib-rules-python-start -->\npython rules here\n<!-- booklib-rules-python-end -->\n',
+  );
+  const result = status(cwd, home);
+  assert.equal(result.global.length, 1);
+  assert.equal(result.global[0].lang, 'python');
+  assert.ok(result.global[0].sizeBytes > 0);
+  rmSync(cwd, { recursive: true });
+  rmSync(home, { recursive: true });
+});
+
+test('status totalBytes is sum of cursor and global', () => {
+  const cwd = tmp();
+  const home = tmp();
+  mkdirSync(join(cwd, '.cursor', 'rules'), { recursive: true });
+  writeFileSync(join(cwd, '.cursor', 'rules', 'python-effective-python.mdc'), 'aaa');
+  mkdirSync(join(home, '.claude'), { recursive: true });
+  writeFileSync(
+    join(home, '.claude', 'CLAUDE.md'),
+    '<!-- booklib-rules-common-start -->\nbbb\n<!-- booklib-rules-common-end -->\n',
+  );
+  const result = status(cwd, home);
+  const expected = result.cursor.reduce((s, c) => s + c.sizeBytes, 0) +
+    result.global.reduce((s, g) => s + g.sizeBytes, 0);
+  assert.equal(result.totalBytes, expected);
+  rmSync(cwd, { recursive: true });
+  rmSync(home, { recursive: true });
+});

package/tests/well-known-builder.test.js

@@ -0,0 +1,40 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, readFileSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { WellKnownBuilder } from '../lib/well-known-builder.js';
+
+function tmpDir() {
+  return mkdtempSync(path.join(tmpdir(), 'booklib-wk-test-'));
+}
+
+test('generates skill.md at correct path', async () => {
+  const outDir = tmpDir();
+  const builder = new WellKnownBuilder({ outDir });
+  const outPath = await builder.build();
+  assert.ok(existsSync(outPath), `Expected file at ${outPath}`);
+  rmSync(outDir, { recursive: true });
+});
+
+test('generated skill.md has valid frontmatter', async () => {
+  const outDir = tmpDir();
+  const builder = new WellKnownBuilder({ outDir });
+  const outPath = await builder.build();
+  const content = readFileSync(outPath, 'utf8');
+  assert.ok(content.startsWith('---'), 'Missing frontmatter opening');
+  assert.ok(content.includes('name: booklib-skills'), 'Missing name field');
+  assert.ok(content.includes('description:'), 'Missing description field');
+  rmSync(outDir, { recursive: true });
+});
+
+test('generated skill.md lists all bundled skills', async () => {
+  const outDir = tmpDir();
+  const builder = new WellKnownBuilder({ outDir });
+  const outPath = await builder.build();
+  const content = readFileSync(outPath, 'utf8');
+  assert.ok(content.includes('effective-kotlin'), 'Missing effective-kotlin entry');
+  assert.ok(content.includes('effective-python'), 'Missing effective-python entry');
+  assert.ok(content.includes('clean-code-reviewer'), 'Missing clean-code-reviewer entry');
+  rmSync(outDir, { recursive: true });
+});

package/tests/wizard/integration-detector.test.js

@@ -0,0 +1,31 @@
+// tests/wizard/integration-detector.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 { detectIntegrations } from '../../lib/wizard/integration-detector.js';
+
+test('detects ruflo from config file in cwd', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'booklib-int-'));
+  writeFileSync(join(dir, 'ruflo.config.json'), '{}');
+  const result = detectIntegrations({ cwd: dir, home: dir });
+  assert.equal(result.ruflo, true);
+  rmSync(dir, { recursive: true });
+});
+
+test('detects superpowers from plugins dir', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'booklib-int-'));
+  mkdirSync(join(dir, '.claude', 'plugins', 'superpowers'), { recursive: true });
+  const result = detectIntegrations({ cwd: dir, home: dir });
+  assert.equal(result.superpowers, true);
+  rmSync(dir, { recursive: true });
+});
+
+test('returns false for empty dir', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'booklib-int-'));
+  const result = detectIntegrations({ cwd: dir, home: dir });
+  assert.equal(result.superpowers, false);
+  assert.equal(result.ruflo, false);
+  rmSync(dir, { recursive: true });
+});

package/tests/wizard/project-detector.test.js

@@ -0,0 +1,51 @@
+// tests/wizard/project-detector.test.js
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { detect } from '../../lib/wizard/project-detector.js';
+
+function tmp() { return mkdtempSync(join(tmpdir(), 'booklib-detect-')); }
+
+test('detects python from pyproject.toml', () => {
+  const dir = tmp();
+  writeFileSync(join(dir, 'pyproject.toml'), '[tool.poetry]\nname = "app"');
+  const result = detect(dir);
+  assert.ok(result.languages.includes('python'));
+  rmSync(dir, { recursive: true });
+});
+
+test('detects kotlin from .kt file', () => {
+  const dir = tmp();
+  writeFileSync(join(dir, 'Main.kt'), 'fun main() {}');
+  const result = detect(dir);
+  assert.ok(result.languages.includes('kotlin'));
+  rmSync(dir, { recursive: true });
+});
+
+test('detects typescript from package.json dep', () => {
+  const dir = tmp();
+  writeFileSync(join(dir, 'package.json'), JSON.stringify({
+    dependencies: { typescript: '^5' }
+  }));
+  writeFileSync(join(dir, 'index.ts'), '');
+  const result = detect(dir);
+  assert.ok(result.languages.includes('typescript'));
+  rmSync(dir, { recursive: true });
+});
+
+test('detects fastapi framework', () => {
+  const dir = tmp();
+  writeFileSync(join(dir, 'requirements.txt'), 'fastapi==0.100\nuvicorn');
+  const result = detect(dir);
+  assert.ok(result.frameworks.includes('FastAPI'));
+  rmSync(dir, { recursive: true });
+});
+
+test('returns empty for empty dir', () => {
+  const dir = tmp();
+  const result = detect(dir);
+  assert.deepEqual(result.languages, []);
+  rmSync(dir, { recursive: true });
+});