@haposoft/cafekit 0.16.0-rc.8 → 0.16.0

package/bin/__tests__/optional-skill-inventory.test.js

@@ -0,0 +1,249 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const test = require('node:test');
+const { spawnSync } = require('node:child_process');
+
+const {
+  loadClaudeMigrationManifest,
+  parseInstallerArgs,
+  PLATFORMS
+} = require('../lib/context');
+const manifestLib = require('../lib/manifest');
+const { selectDocumentSkills } = require('../phases/select-skill-bundles');
+const { reconcileSkillInventory } = require('../phases/skill-inventory');
+const installerPath = path.resolve(__dirname, '..', 'install.js');
+
+function withTempProject(run) {
+  const previous = process.cwd();
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-optional-skills-'));
+  process.chdir(root);
+  try {
+    return run(root);
+  } finally {
+    process.chdir(previous);
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+async function withTempProjectAsync(run) {
+  const previous = process.cwd();
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-optional-skills-'));
+  process.chdir(root);
+  try {
+    return await run(root);
+  } finally {
+    process.chdir(previous);
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+function silentUi() {
+  return {
+    confirm: async (_options, fallback) => fallback,
+    isCancel: () => false,
+    warn: () => {},
+    detail: () => {}
+  };
+}
+
+test('manifest separates core, optional documents, and retired skills', () => {
+  const manifest = loadClaudeMigrationManifest();
+  assert.equal(manifest.skills.required.includes('route'), true);
+  assert.deepEqual(manifest.skills.bundles.documentSkills, [
+    'ai-multimodal', 'docs', 'docx', 'pdf', 'pptx', 'xlsx'
+  ]);
+  for (const skill of manifest.skills.bundles.documentSkills) {
+    assert.equal(manifest.skills.required.includes(skill), false);
+  }
+  assert.deepEqual(manifest.obsolete.skills, [
+    'backend-development', 'frontend-development', 'frontend-design',
+    'mobile-development', 'devops', 'react-best-practices'
+  ]);
+});
+
+test('document skill flags are mutually exclusive', () => {
+  assert.throws(
+    () => parseInstallerArgs(['node', 'install', '--with-document-skills', '--without-document-skills']),
+    /cannot be used together/
+  );
+});
+
+test('selection defaults fresh non-interactive OFF and preserves legacy upgrade ON', async () => {
+  await withTempProjectAsync(async () => {
+    const base = {
+      platforms: ['claude', 'codex'],
+      options: {},
+      documentSkills: {},
+      interactive: false,
+      ui: silentUi(),
+      t: (key) => key
+    };
+    fs.mkdirSync('.codex', { recursive: true });
+    fs.writeFileSync('.codex/cafekit.json', '{"schemaVersion":1,"platform":"codex"}\n');
+
+    await selectDocumentSkills(base);
+    assert.deepEqual(base.documentSkills.claude, {
+      enabled: false,
+      selectionSource: 'default-fresh'
+    });
+    assert.deepEqual(base.documentSkills.codex, {
+      enabled: true,
+      selectionSource: 'legacy-upgrade'
+    });
+  });
+});
+
+test('interactive cancellation stops before selecting a fresh bundle', async () => {
+  await withTempProjectAsync(async () => {
+    const ctx = {
+      platforms: ['claude'],
+      options: {},
+      documentSkills: {},
+      interactive: true,
+      cancelled: false,
+      ui: {
+        confirm: async () => 'cancel',
+        isCancel: (value) => value === 'cancel'
+      },
+      t: (key) => key
+    };
+    await selectDocumentSkills(ctx);
+    assert.equal(ctx.cancelled, true);
+    assert.equal(ctx.documentSkills.claude, undefined);
+  });
+});
+
+for (const platformKey of ['claude', 'codex']) {
+  test(`${platformKey} prunes pristine optional skills and preserves modified skills`, () => {
+    withTempProject(() => {
+      const platform = PLATFORMS[platformKey];
+      const docsFile = path.join(platform.skillsDir, 'docs', 'SKILL.md');
+      const pdfFile = path.join(platform.skillsDir, 'pdf', 'SKILL.md');
+      fs.mkdirSync(path.dirname(docsFile), { recursive: true });
+      fs.mkdirSync(path.dirname(pdfFile), { recursive: true });
+      fs.writeFileSync(docsFile, 'owned\n');
+      fs.writeFileSync(pdfFile, 'owned then edited\n');
+
+      const ownership = {
+        schemaVersion: 1,
+        version: 'old',
+        files: {}
+      };
+      const recordRoot = platform.ownership?.recordRoot || platform.folder;
+      const key = (file) => path.relative(recordRoot, file).replace(/\\/g, '/');
+      ownership.files[key(docsFile)] = { sha256: manifestLib.hashFile(docsFile), version: 'old' };
+      ownership.files[key(pdfFile)] = { sha256: manifestLib.sha256('before edit\n'), version: 'old' };
+
+      const ctx = {
+        manifest: { obsolete: { skills: [] }, skills: { bundles: { documentSkills: ['docs', 'pdf'] } } },
+        documentSkills: { [platformKey]: { enabled: false, selectionSource: 'cli-opt-out' } },
+        ownership: { [platform.folder]: ownership },
+        trackers: {
+          [platformKey]: manifestLib.createTracker(platform.folder, 'next', platform.ownership)
+        },
+        dryRun: false,
+        ui: silentUi(),
+        results: { updated: 0, preserved: 0, preservedFiles: [] }
+      };
+
+      reconcileSkillInventory(ctx, platformKey);
+      assert.equal(fs.existsSync(path.dirname(docsFile)), false);
+      assert.equal(fs.existsSync(path.dirname(pdfFile)), true);
+      assert.equal(ctx.results.updated, 1);
+      assert.equal(ctx.results.preserved, 1);
+    });
+  });
+}
+
+test('fresh combined install defaults optional bundle OFF', () => {
+  withTempProject((root) => {
+    const result = spawnSync(process.execPath, [
+      installerPath, '--platform', 'claude,codex', '--yes'
+    ], { cwd: root, encoding: 'utf8' });
+    assert.equal(result.status, 0, result.stderr || result.stdout);
+
+    for (const platformKey of ['claude', 'codex']) {
+      const platform = PLATFORMS[platformKey];
+      assert.equal(fs.existsSync(path.join(platform.skillsDir, 'docs')), false);
+      assert.equal(fs.existsSync(path.join(platform.skillsDir, 'route', 'SKILL.md')), true);
+      const metadata = JSON.parse(fs.readFileSync(path.join(platform.folder, 'cafekit.json'), 'utf8'));
+      assert.equal(metadata.schemaVersion, 2);
+      assert.equal(metadata.documentSkills.enabled, false);
+    }
+  });
+});
+
+test('explicit opt-in installs all six optional skills on both runtimes', () => {
+  withTempProject((root) => {
+    const result = spawnSync(process.execPath, [
+      installerPath, '--platform', 'claude,codex', '--yes', '--with-document-skills'
+    ], { cwd: root, encoding: 'utf8' });
+    assert.equal(result.status, 0, result.stderr || result.stdout);
+
+    const optional = loadClaudeMigrationManifest().skills.bundles.documentSkills;
+    for (const platformKey of ['claude', 'codex']) {
+      const platform = PLATFORMS[platformKey];
+      for (const skill of optional) {
+        assert.equal(fs.existsSync(path.join(platform.skillsDir, skill, 'SKILL.md')), true, `${platformKey}:${skill}`);
+      }
+      const catalog = spawnSync(process.execPath, [
+        path.join(platform.folder, 'scripts', 'generate-skill-catalog.cjs'), '--json'
+      ], { cwd: root, encoding: 'utf8' });
+      assert.equal(catalog.status, 0, catalog.stderr);
+      const catalogData = JSON.parse(catalog.stdout);
+      assert.equal(catalogData.skills.some((skill) => skill.public_id === 'cf:route'), true);
+      assert.equal(catalogData.skills.some((skill) => skill.public_id === 'cf:docs'), true);
+      const metadata = JSON.parse(fs.readFileSync(path.join(platform.folder, 'cafekit.json'), 'utf8'));
+      assert.deepEqual(metadata.documentSkills, {
+        enabled: true,
+        selectionSource: 'cli-opt-in'
+      });
+    }
+  });
+});
+
+test('corrupt metadata preserves an installed document bundle', () => {
+  withTempProject((root) => {
+    const install = (...args) => spawnSync(process.execPath, [
+      installerPath, '--platform', 'claude', '--yes', ...args
+    ], { cwd: root, encoding: 'utf8' });
+    assert.equal(install('--with-document-skills').status, 0);
+    fs.writeFileSync(path.join(root, '.claude', 'cafekit.json'), '{broken\n');
+
+    const recovered = install();
+    assert.equal(recovered.status, 0, recovered.stderr || recovered.stdout);
+    assert.equal(fs.existsSync(path.join(root, '.claude', 'skills', 'docs', 'SKILL.md')), true);
+    const metadata = JSON.parse(fs.readFileSync(path.join(root, '.claude', 'cafekit.json'), 'utf8'));
+    assert.deepEqual(metadata.documentSkills, {
+      enabled: true,
+      selectionSource: 'metadata-recovery'
+    });
+  });
+});
+
+test('modified retired skill is preserved but excluded from automatic routing', () => {
+  withTempProject((root) => {
+    const retiredRoot = path.join(root, '.claude', 'skills', 'backend-development');
+    fs.mkdirSync(retiredRoot, { recursive: true });
+    fs.writeFileSync(path.join(retiredRoot, 'SKILL.md'), [
+      '---', 'name: cf:backend-development',
+      'description: "User-modified retired skill."', '---', '# Preserved', '',
+    ].join('\n'));
+    const result = spawnSync(process.execPath, [
+      installerPath, '--platform', 'claude', '--yes'
+    ], { cwd: root, encoding: 'utf8' });
+    assert.equal(result.status, 0, result.stderr || result.stdout);
+    assert.equal(fs.existsSync(path.join(retiredRoot, 'SKILL.md')), true);
+
+    const catalog = spawnSync(process.execPath, [
+      path.join(root, '.claude', 'scripts', 'generate-skill-catalog.cjs'), '--json'
+    ], { cwd: root, encoding: 'utf8' });
+    assert.equal(catalog.status, 0, catalog.stderr);
+    const parsed = JSON.parse(catalog.stdout);
+    assert.equal(parsed.skills.some((skill) => skill.directory === 'backend-development'), false);
+    assert.ok(parsed.diagnostics.some((item) =>
+      item.directory === 'backend-development' && item.code === 'retired_skill'));
+  });
+});

package/bin/__tests__/output-styles.test.js

@@ -0,0 +1,214 @@
+'use strict';
+
+// Output styles are a Claude Code surface: Claude Code discovers .claude/output-styles/
+// alongside agents, skills and rules, and Codex CLI has no equivalent. These tests pin
+// what installs where, and that every style stays loadable — a style with broken
+// frontmatter is silently unavailable rather than loudly wrong.
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { test } = require('node:test');
+
+const PACKAGE_ROOT = path.join(__dirname, '../..');
+const INSTALLER = path.join(PACKAGE_ROOT, 'bin/install.js');
+const SOURCE_DIR = path.join(PACKAGE_ROOT, 'src/claude/output-styles');
+const EXPECTED = [
+  'coding-level-0-eli5.md',
+  'coding-level-1-junior.md',
+  'coding-level-2-mid.md',
+  'coding-level-3-senior.md',
+  'coding-level-4-lead.md',
+  'coding-level-5-god.md',
+];
+
+function inTempProject(run) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-output-styles-'));
+  try {
+    return run(root);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+function install(root, platform) {
+  return spawnSync(
+    process.execPath,
+    [INSTALLER, '--platform', platform, '--yes'],
+    { cwd: root, encoding: 'utf8', env: { ...process.env, PATH: '/usr/bin:/bin' } }
+  );
+}
+
+/** Parse the leading `---` frontmatter block into a flat key/value map. */
+function frontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n/);
+  if (!match) return null;
+  const fields = {};
+  for (const line of match[1].split('\n')) {
+    const pair = line.match(/^([a-z][a-z0-9-]*):\s*(.*)$/i);
+    if (pair) fields[pair[1]] = pair[2].trim();
+  }
+  return fields;
+}
+
+test('the source ships exactly the six coding levels', () => {
+  const found = fs.readdirSync(SOURCE_DIR).filter((name) => name.endsWith('.md')).sort();
+  assert.deepEqual(found, EXPECTED);
+});
+
+test('every style carries the frontmatter Claude Code reads', () => {
+  for (const name of EXPECTED) {
+    const fields = frontmatter(fs.readFileSync(path.join(SOURCE_DIR, name), 'utf8'));
+    assert.ok(fields, `${name} has no frontmatter block, so it cannot load`);
+    assert.ok(fields.name, `${name} has no name`);
+    assert.ok(fields.description, `${name} has no description`);
+    // These styles change how answers are written, not what the agent is allowed to do.
+    assert.equal(
+      fields['keep-coding-instructions'], 'true',
+      `${name} must keep the base coding instructions, or the style would replace them`
+    );
+  }
+});
+
+test('each level declares a distinct name and description', () => {
+  const names = new Set();
+  const descriptions = new Set();
+  for (const file of EXPECTED) {
+    const fields = frontmatter(fs.readFileSync(path.join(SOURCE_DIR, file), 'utf8'));
+    names.add(fields.name);
+    descriptions.add(fields.description);
+  }
+  assert.equal(names.size, EXPECTED.length, 'two styles share a name and would be indistinguishable');
+  assert.equal(descriptions.size, EXPECTED.length, 'two styles share a description');
+});
+
+test('a Claude install places every style where Claude Code discovers them', () => {
+  inTempProject((root) => {
+    const result = install(root, 'claude');
+    assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
+    const installed = path.join(root, '.claude', 'output-styles');
+    for (const name of EXPECTED) {
+      assert.equal(fs.existsSync(path.join(installed, name)), true, `missing ${name}`);
+      assert.equal(
+        fs.readFileSync(path.join(installed, name), 'utf8'),
+        fs.readFileSync(path.join(SOURCE_DIR, name), 'utf8'),
+        `${name} was altered on the way in`
+      );
+    }
+  });
+});
+
+test('a Codex install ships the same styles, since its rules hook injects them', () => {
+  inTempProject((root) => {
+    const result = install(root, 'codex');
+    assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
+    const installed = path.join(root, '.codex', 'output-styles');
+    for (const name of EXPECTED) {
+      assert.equal(
+        fs.readFileSync(path.join(installed, name), 'utf8'),
+        fs.readFileSync(path.join(SOURCE_DIR, name), 'utf8'),
+        `${name} differs from the one canonical source`
+      );
+    }
+    assert.equal(JSON.parse(fs.readFileSync(path.join(root, '.codex', 'runtime.json'), 'utf8')).codingLevel, 1);
+  });
+});
+
+/** Run the installed Codex rules hook and return what it injects. */
+function runRulesHook(root, sessionId) {
+  const result = spawnSync(process.execPath, [path.join(root, '.codex', 'hooks', 'rules.cjs')], {
+    cwd: root,
+    input: JSON.stringify({ session_id: sessionId, cwd: root }),
+    encoding: 'utf8',
+  });
+  assert.equal(result.status, 0, result.stderr);
+  return result.stdout;
+}
+
+function setCodingLevel(root, level) {
+  const file = path.join(root, '.codex', 'runtime.json');
+  const runtime = JSON.parse(fs.readFileSync(file, 'utf8'));
+  runtime.codingLevel = level;
+  fs.writeFileSync(file, `${JSON.stringify(runtime, null, 2)}\n`);
+}
+
+test('the Codex rules hook injects the style the coding level names', () => {
+  inTempProject((root) => {
+    assert.equal(install(root, 'codex').status, 0);
+
+    const junior = runRulesHook(root, 'session-junior');
+    assert.match(junior, /## Communication style/);
+    assert.match(junior, /Junior Developer Communication Mode/);
+    // The body uses `---` as a horizontal rule, so check a frontmatter-only marker.
+    assert.doesNotMatch(junior, /keep-coding-instructions/, 'the frontmatter must be stripped, not injected');
+    assert.doesNotMatch(junior, /^description:/m, 'the frontmatter must be stripped, not injected');
+    assert.match(junior, /## Rules/, 'the existing rules injection must survive');
+
+    setCodingLevel(root, 5);
+    const expert = runRulesHook(root, 'session-expert');
+    assert.match(expert, /God Mode Communication/);
+    assert.doesNotMatch(expert, /Junior Developer Communication Mode/);
+  });
+});
+
+test('the Codex style is injected once per session, not once per turn', () => {
+  inTempProject((root) => {
+    assert.equal(install(root, 'codex').status, 0);
+    const first = runRulesHook(root, 'one-session');
+    assert.match(first, /## Communication style/);
+    assert.equal(runRulesHook(root, 'one-session'), '', 'a second turn in the same session must inject nothing');
+    assert.match(runRulesHook(root, 'another-session'), /## Communication style/);
+  });
+});
+
+test('an absent or out-of-range coding level injects no style but keeps the rules', () => {
+  inTempProject((root) => {
+    assert.equal(install(root, 'codex').status, 0);
+    for (const [level, label] of [[null, 'null'], [9, 'out of range'], ['1', 'a string']]) {
+      setCodingLevel(root, level);
+      const out = runRulesHook(root, `session-${label.replace(/\s/g, '-')}`);
+      assert.doesNotMatch(out, /## Communication style/, `${label} must not select a style`);
+      assert.match(out, /## Rules/, `${label} must not break the existing rules injection`);
+    }
+  });
+});
+
+test('a Claude install seeds the default style but never overwrites the user choice', () => {
+  inTempProject((root) => {
+    assert.equal(install(root, 'claude').status, 0);
+    const settingsPath = path.join(root, '.claude', 'settings.json');
+    const seeded = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    assert.equal(seeded.outputStyle, 'Junior Developer Mode (Level 1)');
+
+    seeded.outputStyle = 'God Mode (Level 5)';
+    fs.writeFileSync(settingsPath, `${JSON.stringify(seeded, null, 2)}\n`);
+
+    assert.equal(install(root, 'claude').status, 0);
+    assert.equal(
+      JSON.parse(fs.readFileSync(settingsPath, 'utf8')).outputStyle, 'God Mode (Level 5)',
+      'a reinstall reset a preference the user had chosen'
+    );
+
+    const forced = spawnSync(process.execPath, [INSTALLER, '--platform', 'claude', '--force-overwrite', '--yes'],
+      { cwd: root, encoding: 'utf8', env: { ...process.env, PATH: '/usr/bin:/bin' } });
+    assert.equal(forced.status, 0, `${forced.stdout}\n${forced.stderr}`);
+    assert.equal(
+      JSON.parse(fs.readFileSync(settingsPath, 'utf8')).outputStyle, 'God Mode (Level 5)',
+      '--force-overwrite repairs managed files; it must not reset taste'
+    );
+  });
+});
+
+test('a style edited by the user survives a reinstall', () => {
+  inTempProject((root) => {
+    assert.equal(install(root, 'claude').status, 0);
+    const target = path.join(root, '.claude', 'output-styles', 'coding-level-5-god.md');
+    const edited = `${fs.readFileSync(target, 'utf8')}\n\nAlways answer in Vietnamese.\n`;
+    fs.writeFileSync(target, edited);
+
+    assert.equal(install(root, 'claude').status, 0);
+    assert.equal(fs.readFileSync(target, 'utf8'), edited, 'the reinstall discarded a user edit');
+  });
+});