xtrm-cli 0.5.0

package/test/install-pi.test.ts

@@ -0,0 +1,185 @@
+import { describe, it, expect } from 'vitest';
+import { createInstallPiCommand } from '../src/commands/install-pi.js';
+
+describe('createInstallPiCommand', () => {
+    it('exports a createInstallPiCommand function', () => {
+        expect(typeof createInstallPiCommand).toBe('function');
+    });
+
+    it('returns a Command named "pi"', () => {
+        const cmd = createInstallPiCommand();
+        expect((cmd as any).name()).toBe('pi');
+    });
+
+    it('fillTemplate replaces {{PLACEHOLDERS}} with values', async () => {
+        const { fillTemplate } = await import('../src/commands/install-pi.js');
+        expect(fillTemplate('{"k":"{{MY_KEY}}"}' , { MY_KEY: 'abc' })).toBe('{"k":"abc"}');
+    });
+
+    it('fillTemplate leaves missing placeholders empty', async () => {
+        const { fillTemplate } = await import('../src/commands/install-pi.js');
+        expect(fillTemplate('{"k":"{{MISSING}}"}', {})).toBe('{"k":""}');
+    });
+
+    it('models.json.template contains {{DASHSCOPE_API_KEY}}', () => {
+        const fs = require('node:fs');
+        const p = require('node:path');
+        const content = fs.readFileSync(p.resolve(__dirname, '..', '..', 'config', 'pi', 'models.json.template'), 'utf8');
+        expect(content).toContain('{{DASHSCOPE_API_KEY}}');
+    });
+
+    it('auth.json.template contains {{DASHSCOPE_API_KEY}} and {{ZAI_API_KEY}}', () => {
+        const fs = require('node:fs');
+        const p = require('node:path');
+        const content = fs.readFileSync(p.resolve(__dirname, '..', '..', 'config', 'pi', 'auth.json.template'), 'utf8');
+        expect(content).toContain('{{DASHSCOPE_API_KEY}}');
+        expect(content).toContain('{{ZAI_API_KEY}}');
+    });
+
+    it('auth.json.template contains no real API keys or tokens', () => {
+        const fs = require('node:fs');
+        const p = require('node:path');
+        const content = fs.readFileSync(p.resolve(__dirname, '..', '..', 'config', 'pi', 'auth.json.template'), 'utf8');
+        expect(content).not.toMatch(/sk-[a-zA-Z0-9]{20,}/);
+        expect(content).not.toMatch(/ya29\.[a-zA-Z0-9_-]{20,}/);
+    });
+
+    it('settings.json.template includes pi-serena-tools package', () => {
+        const fs = require('node:fs');
+        const p = require('node:path');
+        const settings = JSON.parse(fs.readFileSync(p.resolve(__dirname, '..', '..', 'config', 'pi', 'settings.json.template'), 'utf8'));
+        expect(settings.packages).toContain('npm:pi-serena-tools');
+    });
+
+    it('settings.json.template includes @zenobius/pi-worktrees package', () => {
+        const fs = require('node:fs');
+        const p = require('node:path');
+        const settings = JSON.parse(fs.readFileSync(p.resolve(__dirname, '..', '..', 'config', 'pi', 'settings.json.template'), 'utf8'));
+        expect(settings.packages).toContain('npm:@zenobius/pi-worktrees');
+    });
+
+    it('copyExtraConfigs copies missing files and skips existing ones', async () => {
+        const { copyExtraConfigs, EXTRA_PI_CONFIGS } = await import('../src/commands/install-pi.js?t=copy' + Date.now());
+        const os = require('node:os');
+        const nodePath = require('node:path');
+        const nodeFs = require('node:fs');
+        const srcDir = nodeFs.mkdtempSync(nodePath.join(os.tmpdir(), 'pi-src-'));
+        const destDir = nodeFs.mkdtempSync(nodePath.join(os.tmpdir(), 'pi-dest-'));
+        // Create src file
+        nodeFs.writeFileSync(nodePath.join(srcDir, 'pi-worktrees-settings.json'), '{"worktree":{}}');
+        await copyExtraConfigs(srcDir, destDir);
+        // Should have been copied
+        expect(nodeFs.existsSync(nodePath.join(destDir, 'pi-worktrees-settings.json'))).toBe(true);
+        // Second call should skip (not throw)
+        await copyExtraConfigs(srcDir, destDir);
+        nodeFs.rmSync(srcDir, { recursive: true });
+        nodeFs.rmSync(destDir, { recursive: true });
+    });
+
+    it('EXTRA_PI_CONFIGS includes pi-worktrees-settings.json', async () => {
+        const { EXTRA_PI_CONFIGS } = await import('../src/commands/install-pi.js?t=extra' + Date.now());
+        expect(EXTRA_PI_CONFIGS).toContain('pi-worktrees-settings.json');
+    });
+
+    it('pi-worktrees-settings.json exists in config/pi with worktree.parentDir defined', () => {
+        const fs = require('node:fs');
+        const p = require('node:path');
+        const cfg = JSON.parse(fs.readFileSync(p.resolve(__dirname, '..', '..', 'config', 'pi', 'pi-worktrees-settings.json'), 'utf8'));
+        expect(cfg.worktree).toBeDefined();
+        expect(cfg.worktree.parentDir).toBeDefined();
+    });
+
+    it('install-schema.json defines DASHSCOPE_API_KEY and ZAI_API_KEY fields', () => {
+        const fs = require('node:fs');
+        const p = require('node:path');
+        const schema = JSON.parse(fs.readFileSync(p.resolve(__dirname, '..', '..', 'config', 'pi', 'install-schema.json'), 'utf8'));
+        const keys = schema.fields.map((f) => f.key);
+        expect(keys).toContain('DASHSCOPE_API_KEY');
+        expect(keys).toContain('ZAI_API_KEY');
+    });
+
+    it('install-schema.json lists anthropic and qwen-cli as oauth_providers', () => {
+        const fs = require('node:fs');
+        const p = require('node:path');
+        const schema = JSON.parse(fs.readFileSync(p.resolve(__dirname, '..', '..', 'config', 'pi', 'install-schema.json'), 'utf8'));
+        const keys = schema.oauth_providers.map((o) => o.key);
+        expect(keys).toContain('anthropic');
+        expect(keys).toContain('qwen-cli');
+    });
+
+    it('extensions directory contains all expected .ts files', () => {
+        const fs = require('node:fs');
+        const p = require('node:path');
+        const extDir = p.resolve(__dirname, '..', '..', 'config', 'pi', 'extensions');
+        const files = ['auto-session-name.ts','auto-update.ts','bg-process.ts','compact-header.ts','custom-footer.ts','git-checkpoint.ts','todo.ts'];
+        for (const f of files) expect(fs.existsSync(p.join(extDir, f))).toBe(true);
+    });
+
+    it('custom-provider-qwen-cli extension has index.ts and package.json', () => {
+        const fs = require('node:fs');
+        const p = require('node:path');
+        const base = p.resolve(__dirname, '..', '..', 'config', 'pi', 'extensions', 'custom-provider-qwen-cli');
+        expect(fs.existsSync(p.join(base, 'index.ts'))).toBe(true);
+        expect(fs.existsSync(p.join(base, 'package.json'))).toBe(true);
+    });
+
+    it('readExistingPiValues extracts DASHSCOPE_API_KEY from existing auth.json', async () => {
+        const { readExistingPiValues } = await import('../src/commands/install-pi.js?t=' + Date.now());
+        const tmpDir = require('node:fs').mkdtempSync(require('node:path').join(require('node:os').tmpdir(), 'pi-test-'));
+        require('node:fs').writeFileSync(require('node:path').join(tmpDir, 'auth.json'), JSON.stringify({ dashscope: { type: 'api_key', key: 'sk-existing-123' } }));
+        const result = readExistingPiValues(tmpDir);
+        require('node:fs').rmSync(tmpDir, { recursive: true });
+        expect(result['DASHSCOPE_API_KEY']).toBe('sk-existing-123');
+    });
+
+    it('readExistingPiValues extracts ZAI_API_KEY from existing auth.json', async () => {
+        const { readExistingPiValues } = await import('../src/commands/install-pi.js?t=' + Date.now());
+        const tmpDir = require('node:fs').mkdtempSync(require('node:path').join(require('node:os').tmpdir(), 'pi-test-'));
+        require('node:fs').writeFileSync(require('node:path').join(tmpDir, 'auth.json'), JSON.stringify({ zai: { type: 'api_key', key: 'zai-existing-456' } }));
+        const result = readExistingPiValues(tmpDir);
+        require('node:fs').rmSync(tmpDir, { recursive: true });
+        expect(result['ZAI_API_KEY']).toBe('zai-existing-456');
+    });
+
+    it('readExistingPiValues returns empty object when auth.json missing', async () => {
+        const { readExistingPiValues } = await import('../src/commands/install-pi.js?t=' + Date.now());
+        expect(readExistingPiValues('/nonexistent/path')).toEqual({});
+    });
+
+    it('readExistingPiValues extracts DASHSCOPE_API_KEY from models.json when auth.json missing', async () => {
+        const { readExistingPiValues } = await import('../src/commands/install-pi.js?t=models' + Date.now());
+        const tmpDir = require('node:fs').mkdtempSync(require('node:path').join(require('node:os').tmpdir(), 'pi-test-'));
+        require('node:fs').writeFileSync(require('node:path').join(tmpDir, 'models.json'), JSON.stringify({ providers: { dashscope: { apiKey: 'sk-from-models-789' } } }));
+        const result = readExistingPiValues(tmpDir);
+        require('node:fs').rmSync(tmpDir, { recursive: true });
+        expect(result['DASHSCOPE_API_KEY']).toBe('sk-from-models-789');
+    });
+
+    it('diffPiExtensions reports missing and stale files', async () => {
+        const { diffPiExtensions } = await import('../src/commands/install-pi.js?t=diff' + Date.now());
+        const nodeFs = require('node:fs');
+        const nodePath = require('node:path');
+        const os = require('node:os');
+
+        const srcDir = nodeFs.mkdtempSync(nodePath.join(os.tmpdir(), 'pi-ext-src-'));
+        const dstDir = nodeFs.mkdtempSync(nodePath.join(os.tmpdir(), 'pi-ext-dst-'));
+
+        nodeFs.writeFileSync(nodePath.join(srcDir, 'a.ts'), 'export const a = 1;');
+        nodeFs.writeFileSync(nodePath.join(srcDir, 'b.ts'), 'export const b = 1;');
+        nodeFs.writeFileSync(nodePath.join(dstDir, 'a.ts'), 'export const a = 2;');
+
+        const diff = await diffPiExtensions(srcDir, dstDir);
+
+        expect(diff.missing).toContain('b.ts');
+        expect(diff.stale).toContain('a.ts');
+
+        nodeFs.rmSync(srcDir, { recursive: true });
+        nodeFs.rmSync(dstDir, { recursive: true });
+    });
+
+    it('createInstallPiCommand supports --check flag', () => {
+        const cmd = createInstallPiCommand();
+        const hasCheck = (cmd as any).options.some((opt: any) => opt.long === '--check');
+        expect(hasCheck).toBe(true);
+    });
+});

package/test/install-project.test.ts

@@ -0,0 +1,378 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { spawnSync } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import fsExtra from 'fs-extra';
+import {
+    buildProjectInitGuide,
+    createProjectCommand,
+    deepMergeHooks,
+    detectProjectFeatures,
+    ensureServiceRegistry,
+    extractReadmeDescription,
+    getAvailableProjectSkills,
+    installAllProjectSkills,
+    installProjectSkill,
+    upsertManagedBlock,
+} from '../src/commands/install-project.js';
+
+describe('buildProjectInitGuide', () => {
+    it('includes complete onboarding guidance (quality gates, beads workflow, and git workflow)', () => {
+        const guide = buildProjectInitGuide();
+        expect(guide).toContain('quality-gates');
+        expect(guide).toContain('tdd-guard');
+        expect(guide).toContain('service-skills-set');
+        expect(guide.toLowerCase()).toContain('beads workflow');
+        expect(guide).toContain('bd ready --json');
+        expect(guide).toContain('gh pr create --fill');
+        expect(guide.toLowerCase()).toContain('service-skills-set');
+    });
+});
+
+describe('createProjectCommand', () => {
+    it('exposes init/list/install subcommands', () => {
+        const cmd = createProjectCommand();
+        const names = cmd.commands.map(c => c.name());
+        expect(names).toEqual(expect.arrayContaining(['init', 'list', 'install']));
+    });
+});
+
+describe('detectProjectFeatures / ensureServiceRegistry', () => {
+    let tmpDir: string;
+
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(path.join(tmpdir(), 'xtrm-init-detect-'));
+    });
+
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+
+    it('detects TypeScript, Python, and Docker compose services', async () => {
+        await fsExtra.writeFile(path.join(tmpDir, 'tsconfig.json'), '{}');
+        await fsExtra.writeFile(path.join(tmpDir, 'pyproject.toml'), '[project]\nname = "demo"\n');
+        await fsExtra.writeFile(
+            path.join(tmpDir, 'docker-compose.yml'),
+            [
+                'services:',
+                '  api:',
+                '    image: api:latest',
+                '  worker:',
+                '    image: worker:latest',
+            ].join('\n'),
+        );
+
+        const detected = await detectProjectFeatures(tmpDir);
+
+        expect(detected.hasTypeScript).toBe(true);
+        expect(detected.hasPython).toBe(true);
+        expect(detected.dockerServices.sort()).toEqual(['api', 'worker']);
+    });
+
+    it('scaffolds service-registry.json with detected service entries', async () => {
+        const { generated, registryPath } = await ensureServiceRegistry(tmpDir, ['api-service']);
+
+        expect(generated).toBe(true);
+        expect(await fsExtra.pathExists(registryPath)).toBe(true);
+
+        const registry = await fsExtra.readJson(registryPath);
+        expect(registry.services['api-service']).toBeDefined();
+        expect(registry.services['api-service'].name).toBe('api-service');
+        expect(registry.services['api-service'].skill_path).toContain('.claude/skills/api-service/SKILL.md');
+    });
+
+    it('does not mutate registry when all detected services already exist', async () => {
+        const registryPath = path.join(tmpDir, 'service-registry.json');
+        await fsExtra.writeJson(registryPath, {
+            version: '1.0.0',
+            services: {
+                api: {
+                    name: 'api',
+                    description: 'existing',
+                    territory: [],
+                    skill_path: '.claude/skills/api/SKILL.md',
+                    last_sync: '2026-01-01T00:00:00Z',
+                },
+            },
+        }, { spaces: 2 });
+
+        const { generated } = await ensureServiceRegistry(tmpDir, ['api']);
+
+        expect(generated).toBe(false);
+        const registry = await fsExtra.readJson(registryPath);
+        expect(Object.keys(registry.services)).toEqual(['api']);
+        expect(registry.services.api.description).toBe('existing');
+    });
+});
+
+describe('deepMergeHooks', () => {
+    it('appends new hook entries without overwriting existing events', () => {
+        const existing = {
+            hooks: {
+                PreToolUse: [{ command: 'echo existing-pre' }],
+                CustomEvent: [{ command: 'echo keep-me' }],
+            },
+        };
+
+        const incoming = {
+            hooks: {
+                PreToolUse: [{ command: 'echo new-pre' }],
+                PostToolUse: [{ command: 'echo new-post' }],
+            },
+        };
+
+        const merged = deepMergeHooks(existing, incoming);
+
+        expect(merged.hooks.PreToolUse).toEqual([
+            { command: 'echo existing-pre' },
+            { command: 'echo new-pre' },
+        ]);
+        expect(merged.hooks.CustomEvent).toEqual([{ command: 'echo keep-me' }]);
+        expect(merged.hooks.PostToolUse).toEqual([{ command: 'echo new-post' }]);
+    });
+
+    it('upgrades existing same-command matcher to include incoming Serena tools', () => {
+        const existing = {
+            hooks: {
+                PostToolUse: [{
+                    matcher: 'Write|Edit|MultiEdit',
+                    hooks: [{ command: 'node "$CLAUDE_PROJECT_DIR/.claude/hooks/quality-check.cjs"' }],
+                }],
+            },
+        };
+
+        const incoming = {
+            hooks: {
+                PostToolUse: [{
+                    matcher: 'Write|Edit|MultiEdit|mcp__serena__rename_symbol|mcp__serena__replace_symbol_body|mcp__serena__insert_after_symbol|mcp__serena__insert_before_symbol',
+                    hooks: [{ command: 'node "$CLAUDE_PROJECT_DIR/.claude/hooks/quality-check.cjs"' }],
+                }],
+            },
+        };
+
+        const merged = deepMergeHooks(existing, incoming);
+        const matcher = merged.hooks.PostToolUse[0].matcher as string;
+        expect(matcher).toContain('mcp__serena__rename_symbol');
+        expect(matcher).toContain('mcp__serena__replace_symbol_body');
+        expect(matcher).toContain('mcp__serena__insert_after_symbol');
+        expect(matcher).toContain('mcp__serena__insert_before_symbol');
+    });
+
+    it('upgrades matcher when command path differs but hook script is the same', () => {
+        const existing = {
+            hooks: {
+                PostToolUse: [{
+                    matcher: 'Write|Edit|MultiEdit',
+                    hooks: [{ command: 'python3 "$CLAUDE_PROJECT_DIR/hooks/quality-check.py"' }],
+                }],
+            },
+        };
+
+        const incoming = {
+            hooks: {
+                PostToolUse: [{
+                    matcher: 'Write|Edit|MultiEdit|mcp__serena__rename_symbol|mcp__serena__replace_symbol_body|mcp__serena__insert_after_symbol|mcp__serena__insert_before_symbol',
+                    hooks: [{ command: 'python3 "$CLAUDE_PROJECT_DIR/.claude/hooks/quality-check.py"' }],
+                }],
+            },
+        };
+
+        const merged = deepMergeHooks(existing, incoming);
+        expect(merged.hooks.PostToolUse).toHaveLength(1);
+        const matcher = merged.hooks.PostToolUse[0].matcher as string;
+        expect(matcher).toContain('mcp__serena__rename_symbol');
+        expect(matcher).toContain('mcp__serena__replace_symbol_body');
+        expect(matcher).toContain('mcp__serena__insert_after_symbol');
+        expect(matcher).toContain('mcp__serena__insert_before_symbol');
+    });
+});
+
+
+describe('upsertManagedBlock', () => {
+    it('prepends managed block when no block exists', () => {
+        const input = `# Existing
+
+content`;
+        const result = upsertManagedBlock(input, '# Header');
+
+        expect(result).toContain('<!-- xtrm:start -->');
+        expect(result).toContain('# Header');
+        expect(result).toContain('<!-- xtrm:end -->');
+        expect(result.endsWith('content')).toBe(true);
+    });
+
+    it('replaces existing managed block in place', () => {
+        const input = [
+            '<!-- xtrm:start -->',
+            'old',
+            '<!-- xtrm:end -->',
+            '',
+            '# Existing',
+        ].join('\n');
+
+        const result = upsertManagedBlock(input, '# New Header');
+
+        expect(result).toContain('# New Header');
+        expect(result).not.toContain('\nold\n');
+        expect(result).toContain('# Existing');
+        expect((result.match(/<!-- xtrm:start -->/g) || []).length).toBe(1);
+    });
+
+    it('is idempotent for identical content', () => {
+        const input = '# Existing\n';
+        const first = upsertManagedBlock(input, '# Header');
+        const second = upsertManagedBlock(first, '# Header');
+        expect(second).toBe(first);
+    });
+});
+
+describe('extractReadmeDescription', () => {
+    it('extracts the first prose line after the title', async () => {
+        const readme = await fsExtra.readFile(
+            path.join(__dirname, '../../project-skills/quality-gates/README.md'),
+            'utf8',
+        );
+
+        const description = extractReadmeDescription(readme);
+        expect(description).toBeTruthy();
+        expect(description).not.toBe('No description available');
+    });
+
+    it('skips badge blocks and finds the first actual description line', async () => {
+        const readme = await fsExtra.readFile(
+            path.join(__dirname, '../../project-skills/tdd-guard/README.md'),
+            'utf8',
+        );
+
+        expect(extractReadmeDescription(readme)).toBe(
+            'Automated Test-Driven Development enforcement for Claude Code.',
+        );
+    });
+});
+
+describe('installProjectSkill', () => {
+    let tmpDir: string;
+
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(path.join(tmpdir(), 'xtrm-project-skill-'));
+        await fsExtra.ensureDir(path.join(tmpDir, '.claude'));
+    });
+
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+
+    it('copies hook assets required by the installed project skill', async () => {
+        await installProjectSkill('tdd-guard', tmpDir);
+
+        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'hooks', 'tdd-guard-pretool-bridge.cjs'))).toBe(true);
+        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'skills', 'using-tdd-guard', 'SKILL.md'))).toBe(true);
+        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'docs', 'tdd-guard-readme.md'))).toBe(true);
+    });
+
+    it('merges settings without dropping existing project hooks', async () => {
+        await fsExtra.writeJson(
+            path.join(tmpDir, '.claude', 'settings.json'),
+            {
+                hooks: {
+                    PreToolUse: [{ command: 'echo existing-pre' }],
+                    CustomEvent: [{ command: 'echo keep-me' }],
+                },
+            },
+            { spaces: 2 },
+        );
+
+        await installProjectSkill('tdd-guard', tmpDir);
+
+        const settings = await fsExtra.readJson(path.join(tmpDir, '.claude', 'settings.json'));
+        expect(settings.hooks.PreToolUse).toHaveLength(2);
+        expect(settings.hooks.CustomEvent).toEqual([{ command: 'echo keep-me' }]);
+        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'hooks', 'tdd-guard-pretool-bridge.cjs'))).toBe(true);
+    });
+
+    it('installs Node hook files that execute inside type-module projects', async () => {
+        await fsExtra.writeJson(path.join(tmpDir, 'package.json'), {
+            name: 'esm-target',
+            type: 'module',
+        }, { spaces: 2 });
+
+        await installProjectSkill('tdd-guard', tmpDir);
+
+        const guardRun = spawnSync(
+            'node',
+            [path.join(tmpDir, '.claude', 'hooks', 'tdd-guard-pretool-bridge.cjs')],
+            {
+                cwd: tmpDir,
+                input: '{"tool_name":"Edit","tool_input":{"file_path":"/tmp/does-not-exist.ts"}}',
+                encoding: 'utf8',
+            },
+        );
+        expect(guardRun.status).toBe(0);
+
+        const settings = await fsExtra.readJson(path.join(tmpDir, '.claude', 'settings.json'));
+        const preToolUseCommand = settings.hooks.PreToolUse[0].hooks[0].command;
+        expect(preToolUseCommand).toContain('tdd-guard-pretool-bridge.cjs');
+    });
+
+    it('installs service-skills git hooks when service-skills-set is installed', async () => {
+        await fsExtra.ensureDir(path.join(tmpDir, '.git', 'hooks'));
+        await installProjectSkill('service-skills-set', tmpDir);
+
+        expect(await fsExtra.pathExists(path.join(tmpDir, '.githooks', 'pre-commit'))).toBe(true);
+        expect(await fsExtra.pathExists(path.join(tmpDir, '.githooks', 'pre-push'))).toBe(true);
+        expect(await fsExtra.pathExists(path.join(tmpDir, '.git', 'hooks', 'pre-commit'))).toBe(true);
+        expect(await fsExtra.pathExists(path.join(tmpDir, '.git', 'hooks', 'pre-push'))).toBe(true);
+    });
+});
+
+describe('installAllProjectSkills', () => {
+    let tmpDir: string;
+
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(path.join(tmpdir(), 'xtrm-project-skill-all-'));
+        await fsExtra.ensureDir(path.join(tmpDir, '.claude'));
+    });
+
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+
+    it('getAvailableProjectSkills only returns skills with a .claude directory', async () => {
+        const availableSkills = await getAvailableProjectSkills();
+        // All returned skills must have a .claude dir (eval-only dirs are excluded)
+        for (const skill of availableSkills) {
+            expect(availableSkills).toContain(skill);
+        }
+        expect(availableSkills).toContain('tdd-guard');
+        expect(availableSkills).toContain('service-skills-set');
+        expect(availableSkills).toContain('quality-gates');
+    });
+
+    it('installs every available project skill with merged hooks and copied assets', async () => {
+        const availableSkills = await getAvailableProjectSkills();
+        expect(availableSkills).toEqual([
+            'quality-gates',
+            'service-skills-set',
+            'tdd-guard',
+        ]);
+
+        await installAllProjectSkills(tmpDir);
+
+        const settings = await fsExtra.readJson(path.join(tmpDir, '.claude', 'settings.json'));
+        // Both tdd-guard and service-skills PreToolUse hooks should coexist.
+        expect(settings.hooks.PreToolUse).toHaveLength(2);
+
+        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'hooks', 'quality-check.cjs'))).toBe(true);
+        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'git-hooks', 'doc_reminder.py'))).toBe(true);
+        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'service-registry.json'))).toBe(true);
+
+        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'skills', 'using-tdd-guard', 'SKILL.md'))).toBe(true);
+        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'skills', 'using-service-skills', 'SKILL.md'))).toBe(true);
+        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'skills', 'using-quality-gates', 'SKILL.md'))).toBe(true);
+
+        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'docs', 'tdd-guard-readme.md'))).toBe(true);
+        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'docs', 'service-skills-set-readme.md'))).toBe(true);
+        expect(await fsExtra.pathExists(path.join(tmpDir, '.claude', 'docs', 'quality-gates-readme.md'))).toBe(true);
+    });
+});