@skillsmith/cli 0.7.2 → 0.7.4

package/dist/tests/e2e/author.e2e.test.js

@@ -1,666 +0,0 @@
-/**
- * E2E Test: skillsmith init, validate, publish commands
- *
- * Tests skill authoring commands in a clean Codespace environment.
- *
- * User Journey: Create and publish custom skills
- */
-import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
-import { spawn } from 'child_process';
-import { existsSync, rmSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { tmpdir } from 'os';
-import { fileURLToPath } from 'url';
-import { scanCommandOutput } from './utils/hardcoded-detector.js';
-import { recordTiming } from './utils/baseline-collector.js';
-import { queueIssue } from './utils/linear-reporter.js';
-// ESM compatibility for __dirname
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-// Test configuration
-const TEST_DIR = join(tmpdir(), 'skillsmith-e2e-author');
-const CLI_PATH = join(__dirname, '../../dist/src/index.js');
-// Valid SKILL.md content for validation tests
-const VALID_SKILL_MD = `---
-name: test-skill
-version: 1.0.0
-description: A test skill for E2E testing
-author: test-author
-triggers:
-  - test trigger
-  - run test
----
-
-# test-skill
-
-A test skill for E2E testing purposes.
-
-## Usage
-
-Use this skill to test things.
-
-## Examples
-
-\`\`\`
-test example
-\`\`\`
-`;
-// Invalid SKILL.md for error testing
-const INVALID_SKILL_MD = `
-# Missing Frontmatter
-
-This skill has no frontmatter and should fail validation.
-`;
-/**
- * Execute CLI command
- */
-async function runCommand(args, cwd, timeoutMs = 30000) {
-    return new Promise((resolve, reject) => {
-        const startTime = Date.now();
-        let stdout = '';
-        let stderr = '';
-        const proc = spawn('node', [CLI_PATH, ...args], {
-            cwd: cwd || TEST_DIR,
-            env: {
-                ...process.env,
-                NODE_ENV: 'test',
-                SKILLSMITH_E2E: 'true',
-            },
-        });
-        const timeout = setTimeout(() => {
-            proc.kill('SIGTERM');
-            reject(new Error(`Command timed out after ${timeoutMs}ms`));
-        }, timeoutMs);
-        proc.stdout.on('data', (data) => {
-            stdout += data.toString();
-        });
-        proc.stderr.on('data', (data) => {
-            stderr += data.toString();
-        });
-        proc.on('close', (code) => {
-            clearTimeout(timeout);
-            resolve({
-                exitCode: code ?? 1,
-                stdout,
-                stderr,
-                durationMs: Date.now() - startTime,
-            });
-        });
-        proc.on('error', (error) => {
-            clearTimeout(timeout);
-            reject(error);
-        });
-    });
-}
-/**
- * Assert no hardcoded values in command output
- */
-function assertNoHardcoded(result, command, testName, testFile) {
-    const detection = scanCommandOutput(result.stdout, result.stderr, command);
-    if (!detection.passed) {
-        const failure = {
-            testName,
-            testFile,
-            command,
-            error: `Hardcoded values detected`,
-            stdout: result.stdout,
-            stderr: result.stderr,
-            hardcodedIssues: detection.issues,
-            duration: result.durationMs,
-            timestamp: new Date().toISOString(),
-        };
-        queueIssue(failure);
-        const errorDetails = detection.issues
-            .filter((i) => i.severity === 'error')
-            .map((i) => `  - ${i.type}: ${i.value}`)
-            .join('\n');
-        expect.fail(`Hardcoded values detected:\n${errorDetails}`);
-    }
-}
-describe('E2E: skillsmith init', () => {
-    beforeEach(() => {
-        // Reset test directory for each test
-        if (existsSync(TEST_DIR)) {
-            rmSync(TEST_DIR, { recursive: true, force: true });
-        }
-        mkdirSync(TEST_DIR, { recursive: true });
-    });
-    afterAll(() => {
-        if (existsSync(TEST_DIR)) {
-            rmSync(TEST_DIR, { recursive: true, force: true });
-        }
-    });
-    describe('Init Command', () => {
-        it('should display help without errors', async () => {
-            const result = await runCommand(['init', '--help']);
-            expect(result.exitCode).toBe(0);
-            expect(result.stdout).toContain('Initialize');
-            assertNoHardcoded(result, 'skillsmith init --help', 'init: help', __filename);
-        });
-        // SMI-1473: Using non-interactive flags for E2E testing
-        it('should create skill scaffold with name', async () => {
-            const result = await runCommand([
-                'init',
-                'my-new-skill',
-                '-d',
-                'Test skill description',
-                '-a',
-                'test-author',
-                '-c',
-                'development',
-            ]);
-            recordTiming('init:named', 'skillsmith init name', result.durationMs);
-            expect(result.exitCode).toBe(0);
-            // Verify created files
-            const skillDir = join(TEST_DIR, 'my-new-skill');
-            expect(existsSync(skillDir)).toBe(true);
-            expect(existsSync(join(skillDir, 'SKILL.md'))).toBe(true);
-            expect(existsSync(join(skillDir, 'README.md'))).toBe(true);
-            assertNoHardcoded(result, 'skillsmith init name', 'init: create skill', __filename);
-        });
-        // SMI-1473: Using non-interactive flags for E2E testing
-        it('should create skill scaffold with custom path', async () => {
-            const customPath = join(TEST_DIR, 'custom-skills');
-            mkdirSync(customPath, { recursive: true });
-            const result = await runCommand([
-                'init',
-                'path-skill',
-                '-p',
-                customPath,
-                '-d',
-                'Test skill',
-                '-a',
-                'test',
-                '-c',
-                'development',
-            ]);
-            expect(result.exitCode).toBe(0);
-            // Verify created at custom path
-            expect(existsSync(join(customPath, 'path-skill', 'SKILL.md'))).toBe(true);
-            assertNoHardcoded(result, 'skillsmith init -p custom', 'init: custom path', __filename);
-        });
-        // SMI-1473: Using non-interactive flags for E2E testing
-        it('should create resources directory', async () => {
-            const result = await runCommand([
-                'init',
-                'resource-skill',
-                '-d',
-                'Test skill',
-                '-a',
-                'test',
-                '-c',
-                'development',
-            ]);
-            expect(result.exitCode).toBe(0);
-            const resourceDir = join(TEST_DIR, 'resource-skill', 'resources');
-            expect(existsSync(resourceDir)).toBe(true);
-            assertNoHardcoded(result, 'skillsmith init resources', 'init: resources dir', __filename);
-        });
-        // SMI-1473: Using non-interactive flags for E2E testing
-        it('should create scripts directory with example', async () => {
-            const result = await runCommand([
-                'init',
-                'script-skill',
-                '-d',
-                'Test skill',
-                '-a',
-                'test',
-                '-c',
-                'development',
-            ]);
-            expect(result.exitCode).toBe(0);
-            const scriptsDir = join(TEST_DIR, 'script-skill', 'scripts');
-            expect(existsSync(scriptsDir)).toBe(true);
-            expect(existsSync(join(scriptsDir, 'example.js'))).toBe(true);
-            assertNoHardcoded(result, 'skillsmith init scripts', 'init: scripts dir', __filename);
-        });
-        // SMI-1473: Using non-interactive flags for E2E testing
-        it('should handle existing directory gracefully', async () => {
-            // Create skill first
-            await runCommand([
-                'init',
-                'existing-skill',
-                '-d',
-                'Test skill',
-                '-a',
-                'test',
-                '-c',
-                'development',
-            ]);
-            // Try to create again with --yes to auto-confirm overwrite
-            const result = await runCommand([
-                'init',
-                'existing-skill',
-                '-d',
-                'Test skill updated',
-                '-a',
-                'test',
-                '-c',
-                'development',
-                '-y',
-            ]);
-            // Should succeed with --yes flag
-            expect(result.exitCode).toBe(0);
-            assertNoHardcoded(result, 'skillsmith init existing', 'init: existing dir', __filename);
-        });
-        // SMI-1473: Using non-interactive flags for E2E testing
-        it('should not contain hardcoded paths in generated files', async () => {
-            const result = await runCommand([
-                'init',
-                'path-check-skill',
-                '-d',
-                'Test skill',
-                '-a',
-                'test',
-                '-c',
-                'development',
-            ]);
-            expect(result.exitCode).toBe(0);
-            // Read generated SKILL.md
-            const skillMd = readFileSync(join(TEST_DIR, 'path-check-skill', 'SKILL.md'), 'utf-8');
-            // Should not contain hardcoded paths
-            expect(skillMd).not.toMatch(/\/Users\/[a-zA-Z0-9_-]+\//);
-            expect(skillMd).not.toMatch(/\/home\/[a-zA-Z0-9_-]+\//);
-        });
-    });
-});
-describe('E2E: skillsmith validate', () => {
-    beforeAll(() => {
-        if (existsSync(TEST_DIR)) {
-            rmSync(TEST_DIR, { recursive: true, force: true });
-        }
-        mkdirSync(TEST_DIR, { recursive: true });
-    });
-    afterAll(() => {
-        if (existsSync(TEST_DIR)) {
-            rmSync(TEST_DIR, { recursive: true, force: true });
-        }
-    });
-    describe('Validate Command', () => {
-        it('should display help without errors', async () => {
-            const result = await runCommand(['validate', '--help']);
-            expect(result.exitCode).toBe(0);
-            expect(result.stdout).toContain('Validate');
-            assertNoHardcoded(result, 'skillsmith validate --help', 'validate: help', __filename);
-        });
-        it('should validate valid SKILL.md', async () => {
-            // Create valid skill
-            const skillDir = join(TEST_DIR, 'valid-skill');
-            mkdirSync(skillDir, { recursive: true });
-            writeFileSync(join(skillDir, 'SKILL.md'), VALID_SKILL_MD);
-            const result = await runCommand(['validate', skillDir]);
-            recordTiming('validate:valid', 'skillsmith validate valid', result.durationMs);
-            expect(result.exitCode).toBe(0);
-            assertNoHardcoded(result, 'skillsmith validate valid', 'validate: valid skill', __filename);
-        });
-        it('should reject invalid SKILL.md', async () => {
-            // Create invalid skill
-            const skillDir = join(TEST_DIR, 'invalid-skill');
-            mkdirSync(skillDir, { recursive: true });
-            writeFileSync(join(skillDir, 'SKILL.md'), INVALID_SKILL_MD);
-            const result = await runCommand(['validate', skillDir]);
-            recordTiming('validate:invalid', 'skillsmith validate invalid', result.durationMs);
-            // Should fail
-            expect(result.exitCode).not.toBe(0);
-            assertNoHardcoded(result, 'skillsmith validate invalid', 'validate: invalid skill', __filename);
-        });
-        it('should handle missing SKILL.md', async () => {
-            const emptyDir = join(TEST_DIR, 'empty-dir');
-            mkdirSync(emptyDir, { recursive: true });
-            const result = await runCommand(['validate', emptyDir]);
-            // Should fail with appropriate error
-            expect(result.exitCode).not.toBe(0);
-            assertNoHardcoded(result, 'skillsmith validate missing', 'validate: missing file', __filename);
-        });
-        it('should validate current directory by default', async () => {
-            // Create skill in test dir root
-            writeFileSync(join(TEST_DIR, 'SKILL.md'), VALID_SKILL_MD);
-            const result = await runCommand(['validate'], TEST_DIR);
-            expect(result.exitCode).toBe(0);
-            assertNoHardcoded(result, 'skillsmith validate .', 'validate: current dir', __filename);
-        });
-        it('should output parsed metadata', async () => {
-            const skillDir = join(TEST_DIR, 'metadata-skill');
-            mkdirSync(skillDir, { recursive: true });
-            writeFileSync(join(skillDir, 'SKILL.md'), VALID_SKILL_MD);
-            const result = await runCommand(['validate', skillDir]);
-            expect(result.exitCode).toBe(0);
-            // Should show parsed metadata
-            const output = result.stdout;
-            expect(output).toContain('test-skill');
-            assertNoHardcoded(result, 'skillsmith validate metadata', 'validate: metadata output', __filename);
-        });
-    });
-});
-describe('E2E: skillsmith publish', () => {
-    beforeEach(() => {
-        if (existsSync(TEST_DIR)) {
-            rmSync(TEST_DIR, { recursive: true, force: true });
-        }
-        mkdirSync(TEST_DIR, { recursive: true });
-    });
-    afterAll(() => {
-        if (existsSync(TEST_DIR)) {
-            rmSync(TEST_DIR, { recursive: true, force: true });
-        }
-    });
-    describe('Publish Command', () => {
-        it('should display help without errors', async () => {
-            const result = await runCommand(['publish', '--help']);
-            expect(result.exitCode).toBe(0);
-            expect(result.stdout).toContain('Prepare');
-            assertNoHardcoded(result, 'skillsmith publish --help', 'publish: help', __filename);
-        });
-        it('should prepare valid skill for publishing', async () => {
-            // Create valid skill
-            const skillDir = join(TEST_DIR, 'publish-skill');
-            mkdirSync(skillDir, { recursive: true });
-            writeFileSync(join(skillDir, 'SKILL.md'), VALID_SKILL_MD);
-            const result = await runCommand(['publish', skillDir]);
-            recordTiming('publish:prepare', 'skillsmith publish', result.durationMs);
-            expect(result.exitCode).toBe(0);
-            // Should create publish manifest
-            expect(existsSync(join(skillDir, '.skillsmith-publish.json'))).toBe(true);
-            assertNoHardcoded(result, 'skillsmith publish', 'publish: prepare skill', __filename);
-        });
-        it('should generate checksum', async () => {
-            const skillDir = join(TEST_DIR, 'checksum-skill');
-            mkdirSync(skillDir, { recursive: true });
-            writeFileSync(join(skillDir, 'SKILL.md'), VALID_SKILL_MD);
-            const result = await runCommand(['publish', skillDir]);
-            expect(result.exitCode).toBe(0);
-            // Read manifest
-            const manifest = JSON.parse(readFileSync(join(skillDir, '.skillsmith-publish.json'), 'utf-8'));
-            expect(manifest.checksum).toBeDefined();
-            expect(typeof manifest.checksum).toBe('string');
-            assertNoHardcoded(result, 'skillsmith publish checksum', 'publish: checksum', __filename);
-        });
-        it('should reject invalid skill', async () => {
-            const skillDir = join(TEST_DIR, 'invalid-publish');
-            mkdirSync(skillDir, { recursive: true });
-            writeFileSync(join(skillDir, 'SKILL.md'), INVALID_SKILL_MD);
-            const result = await runCommand(['publish', skillDir]);
-            // Should fail validation before publishing
-            expect(result.exitCode).not.toBe(0);
-            assertNoHardcoded(result, 'skillsmith publish invalid', 'publish: invalid skill', __filename);
-        });
-        it('should include publishing instructions', async () => {
-            const skillDir = join(TEST_DIR, 'instructions-skill');
-            mkdirSync(skillDir, { recursive: true });
-            writeFileSync(join(skillDir, 'SKILL.md'), VALID_SKILL_MD);
-            const result = await runCommand(['publish', skillDir]);
-            expect(result.exitCode).toBe(0);
-            // Output should contain publishing instructions
-            const output = result.stdout;
-            expect(output).toMatch(/github|manual|archive/i);
-            assertNoHardcoded(result, 'skillsmith publish instructions', 'publish: instructions', __filename);
-        });
-        it('should not expose local paths in manifest', async () => {
-            const skillDir = join(TEST_DIR, 'path-manifest');
-            mkdirSync(skillDir, { recursive: true });
-            writeFileSync(join(skillDir, 'SKILL.md'), VALID_SKILL_MD);
-            const result = await runCommand(['publish', skillDir]);
-            expect(result.exitCode).toBe(0);
-            // Read manifest
-            const manifest = readFileSync(join(skillDir, '.skillsmith-publish.json'), 'utf-8');
-            // Should not contain local paths
-            expect(manifest).not.toMatch(/\/Users\/[a-zA-Z0-9_-]+\//);
-            expect(manifest).not.toMatch(/\/home\/[a-zA-Z0-9_-]+\//);
-            expect(manifest).not.toContain(TEST_DIR);
-        });
-    });
-});
-// SMI-1389: E2E tests for author subagent command
-describe('E2E: skillsmith author subagent', () => {
-    beforeEach(() => {
-        if (existsSync(TEST_DIR)) {
-            rmSync(TEST_DIR, { recursive: true, force: true });
-        }
-        mkdirSync(TEST_DIR, { recursive: true });
-    });
-    afterAll(() => {
-        if (existsSync(TEST_DIR)) {
-            rmSync(TEST_DIR, { recursive: true, force: true });
-        }
-    });
-    describe('Author Subagent Command', () => {
-        it('should display help without errors', async () => {
-            const result = await runCommand(['author', 'subagent', '--help']);
-            expect(result.exitCode).toBe(0);
-            expect(result.stdout).toContain('Generate');
-            expect(result.stdout).toContain('subagent');
-            assertNoHardcoded(result, 'skillsmith author subagent --help', 'author subagent: help', __filename);
-        });
-        it('should generate subagent from valid skill', async () => {
-            // Create valid skill
-            const skillDir = join(TEST_DIR, 'subagent-skill');
-            mkdirSync(skillDir, { recursive: true });
-            writeFileSync(join(skillDir, 'SKILL.md'), VALID_SKILL_MD);
-            // Create output directory
-            const outputDir = join(TEST_DIR, 'agents');
-            const result = await runCommand(['author', 'subagent', skillDir, '-o', outputDir]);
-            recordTiming('author:subagent', 'skillsmith author subagent', result.durationMs);
-            expect(result.exitCode).toBe(0);
-            expect(existsSync(join(outputDir, 'test-skill-specialist.md'))).toBe(true);
-            assertNoHardcoded(result, 'skillsmith author subagent', 'author subagent: generate', __filename);
-        });
-        it('should include CLAUDE.md snippet in output', async () => {
-            const skillDir = join(TEST_DIR, 'claude-md-skill');
-            mkdirSync(skillDir, { recursive: true });
-            writeFileSync(join(skillDir, 'SKILL.md'), VALID_SKILL_MD);
-            const outputDir = join(TEST_DIR, 'agents-claude');
-            const result = await runCommand(['author', 'subagent', skillDir, '-o', outputDir]);
-            expect(result.exitCode).toBe(0);
-            expect(result.stdout).toContain('CLAUDE.md');
-            expect(result.stdout).toContain('Delegation');
-            assertNoHardcoded(result, 'skillsmith author subagent claude', 'author subagent: claude.md', __filename);
-        });
-        it('should skip CLAUDE.md snippet with --skip-claude-md', async () => {
-            const skillDir = join(TEST_DIR, 'skip-claude-skill');
-            mkdirSync(skillDir, { recursive: true });
-            writeFileSync(join(skillDir, 'SKILL.md'), VALID_SKILL_MD);
-            const outputDir = join(TEST_DIR, 'agents-skip');
-            const result = await runCommand([
-                'author',
-                'subagent',
-                skillDir,
-                '-o',
-                outputDir,
-                '--skip-claude-md',
-            ]);
-            expect(result.exitCode).toBe(0);
-            expect(result.stdout).not.toContain('Add to your CLAUDE.md');
-            assertNoHardcoded(result, 'skillsmith author subagent skip', 'author subagent: skip claude', __filename);
-        });
-        it('should use custom tools when provided', async () => {
-            const skillDir = join(TEST_DIR, 'custom-tools-skill');
-            mkdirSync(skillDir, { recursive: true });
-            writeFileSync(join(skillDir, 'SKILL.md'), VALID_SKILL_MD);
-            const outputDir = join(TEST_DIR, 'agents-tools');
-            const result = await runCommand([
-                'author',
-                'subagent',
-                skillDir,
-                '-o',
-                outputDir,
-                '--tools',
-                'Read,Write,Bash',
-            ]);
-            expect(result.exitCode).toBe(0);
-            expect(result.stdout).toContain('Read, Write, Bash');
-            assertNoHardcoded(result, 'skillsmith author subagent tools', 'author subagent: custom tools', __filename);
-        });
-        it('should handle missing SKILL.md gracefully', async () => {
-            const emptyDir = join(TEST_DIR, 'empty-subagent');
-            mkdirSync(emptyDir, { recursive: true });
-            const result = await runCommand(['author', 'subagent', emptyDir]);
-            expect(result.exitCode).not.toBe(0);
-            assertNoHardcoded(result, 'skillsmith author subagent missing', 'author subagent: missing', __filename);
-        });
-        // SMI-1397: Test for --model option
-        it('should use specified model in subagent output', async () => {
-            const skillDir = join(TEST_DIR, 'model-test-skill');
-            mkdirSync(skillDir, { recursive: true });
-            writeFileSync(join(skillDir, 'SKILL.md'), VALID_SKILL_MD);
-            const outputDir = join(TEST_DIR, 'agents-model');
-            const result = await runCommand([
-                'author',
-                'subagent',
-                skillDir,
-                '-o',
-                outputDir,
-                '--model',
-                'opus',
-            ]);
-            expect(result.exitCode).toBe(0);
-            expect(result.stdout).toContain('opus');
-            // Verify the generated file contains the model
-            const generatedContent = readFileSync(join(outputDir, 'test-skill-specialist.md'), 'utf-8');
-            expect(generatedContent).toContain('model: opus');
-            assertNoHardcoded(result, 'skillsmith author subagent model', 'author subagent: model option', __filename);
-        });
-        it('should use haiku model when specified', async () => {
-            const skillDir = join(TEST_DIR, 'haiku-test-skill');
-            mkdirSync(skillDir, { recursive: true });
-            writeFileSync(join(skillDir, 'SKILL.md'), VALID_SKILL_MD);
-            const outputDir = join(TEST_DIR, 'agents-haiku');
-            const result = await runCommand([
-                'author',
-                'subagent',
-                skillDir,
-                '-o',
-                outputDir,
-                '--model',
-                'haiku',
-            ]);
-            expect(result.exitCode).toBe(0);
-            const generatedContent = readFileSync(join(outputDir, 'test-skill-specialist.md'), 'utf-8');
-            expect(generatedContent).toContain('model: haiku');
-            assertNoHardcoded(result, 'skillsmith author subagent haiku', 'author subagent: haiku model', __filename);
-        });
-    });
-});
-// SMI-1390: E2E tests for author transform command
-describe('E2E: skillsmith author transform', () => {
-    beforeEach(() => {
-        if (existsSync(TEST_DIR)) {
-            rmSync(TEST_DIR, { recursive: true, force: true });
-        }
-        mkdirSync(TEST_DIR, { recursive: true });
-    });
-    afterAll(() => {
-        if (existsSync(TEST_DIR)) {
-            rmSync(TEST_DIR, { recursive: true, force: true });
-        }
-    });
-    describe('Author Transform Command', () => {
-        it('should display help without errors', async () => {
-            const result = await runCommand(['author', 'transform', '--help']);
-            expect(result.exitCode).toBe(0);
-            expect(result.stdout).toContain('Upgrade');
-            expect(result.stdout).toContain('transform');
-            assertNoHardcoded(result, 'skillsmith author transform --help', 'author transform: help', __filename);
-        });
-        it('should show dry-run preview without creating files', async () => {
-            const skillDir = join(TEST_DIR, 'dry-run-skill');
-            mkdirSync(skillDir, { recursive: true });
-            writeFileSync(join(skillDir, 'SKILL.md'), VALID_SKILL_MD);
-            const result = await runCommand(['author', 'transform', skillDir, '--dry-run']);
-            recordTiming('author:transform:dry-run', 'skillsmith author transform --dry-run', result.durationMs);
-            expect(result.exitCode).toBe(0);
-            expect(result.stdout).toContain('Dry run');
-            expect(result.stdout).toContain('test-skill');
-            expect(result.stdout).toContain('Required Tools');
-            assertNoHardcoded(result, 'skillsmith author transform dry-run', 'author transform: dry-run', __filename);
-        });
-        it('should transform skill and generate subagent', async () => {
-            const skillDir = join(TEST_DIR, 'transform-skill');
-            mkdirSync(skillDir, { recursive: true });
-            writeFileSync(join(skillDir, 'SKILL.md'), VALID_SKILL_MD);
-            // Note: This will write to ~/.claude/agents by default
-            // In real E2E we'd want to mock this or use --output
-            const result = await runCommand(['author', 'transform', skillDir, '--dry-run']);
-            expect(result.exitCode).toBe(0);
-            assertNoHardcoded(result, 'skillsmith author transform', 'author transform: transform', __filename);
-        });
-        it('should handle missing SKILL.md gracefully', async () => {
-            const emptyDir = join(TEST_DIR, 'empty-transform');
-            mkdirSync(emptyDir, { recursive: true });
-            const result = await runCommand(['author', 'transform', emptyDir]);
-            expect(result.exitCode).not.toBe(0);
-            assertNoHardcoded(result, 'skillsmith author transform missing', 'author transform: missing', __filename);
-        });
-        it('should detect and display required tools', async () => {
-            // Skill with specific tool requirements
-            const toolSkillMd = `---
-name: tool-test-skill
-version: 1.0.0
-description: A skill that uses bash commands and file editing
-author: test
----
-
-# tool-test-skill
-
-This skill runs npm commands via bash and writes files.
-
-## Usage
-
-Run \`npm install\` and edit configuration files.
-`;
-            const skillDir = join(TEST_DIR, 'tool-detect-skill');
-            mkdirSync(skillDir, { recursive: true });
-            writeFileSync(join(skillDir, 'SKILL.md'), toolSkillMd);
-            const result = await runCommand(['author', 'transform', skillDir, '--dry-run']);
-            expect(result.exitCode).toBe(0);
-            expect(result.stdout).toContain('Required Tools');
-            // Should detect Bash from "npm commands via bash"
-            // Should detect Write/Edit from "writes files" and "edit"
-            assertNoHardcoded(result, 'skillsmith author transform tools', 'author transform: detect tools', __filename);
-        });
-        // SMI-1397: Test for --batch option
-        it('should batch transform multiple skills', async () => {
-            // Create first skill
-            const skillDir1 = join(TEST_DIR, 'batch-skill-1');
-            mkdirSync(skillDir1, { recursive: true });
-            writeFileSync(join(skillDir1, 'SKILL.md'), `---
-name: batch-skill-one
-version: 1.0.0
-description: First batch skill for testing
-author: test
----
-
-# batch-skill-one
-
-First skill in batch processing test.
-`);
-            // Create second skill
-            const skillDir2 = join(TEST_DIR, 'batch-skill-2');
-            mkdirSync(skillDir2, { recursive: true });
-            writeFileSync(join(skillDir2, 'SKILL.md'), `---
-name: batch-skill-two
-version: 1.0.0
-description: Second batch skill for testing
-author: test
----
-
-# batch-skill-two
-
-Second skill in batch processing test.
-`);
-            const result = await runCommand([
-                'author',
-                'transform',
-                '--batch',
-                `${skillDir1},${skillDir2}`,
-                '--dry-run',
-            ]);
-            recordTiming('author:transform:batch', 'skillsmith author transform --batch', result.durationMs);
-            expect(result.exitCode).toBe(0);
-            expect(result.stdout).toContain('Batch processing 2 skills');
-            expect(result.stdout).toContain('batch-skill-one');
-            expect(result.stdout).toContain('batch-skill-two');
-            assertNoHardcoded(result, 'skillsmith author transform batch', 'author transform: batch', __filename);
-        });
-    });
-});
-//# sourceMappingURL=author.e2e.test.js.map