@output.ai/cli 0.0.4 → 0.0.5

package/dist/services/claude_client.spec.js

@@ -0,0 +1,141 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { invokePlanWorkflow, ClaudeInvocationError } from './claude_client.js';
+// Mock Claude SDK
+vi.mock('@anthropic-ai/claude-agent-sdk', () => ({
+    query: vi.fn()
+}));
+describe('invokePlanWorkflow', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        // Clean up environment variables
+        delete process.env.ANTHROPIC_API_KEY;
+    });
+    it('should invoke /plan_workflow slash command with settingSources', async () => {
+        const { query } = await import('@anthropic-ai/claude-agent-sdk');
+        process.env.ANTHROPIC_API_KEY = 'test-key';
+        async function* mockIterator() {
+            yield { type: 'result', subtype: 'success', result: '# Test Plan\n\nTest plan content' };
+        }
+        vi.mocked(query).mockReturnValue(mockIterator());
+        await invokePlanWorkflow('Test workflow');
+        const calls = vi.mocked(query).mock.calls;
+        expect(calls[0]?.[0]?.prompt).toContain('/plan_workflow Test workflow');
+        expect(calls[0]?.[0]?.options?.settingSources).toEqual(['user', 'project', 'local']);
+        expect(calls[0]?.[0]?.options?.allowedTools).toEqual(['Read', 'Grep', 'WebSearch', 'WebFetch', 'TodoWrite']);
+    });
+    it('should pass workflow description to slash command', async () => {
+        const { query } = await import('@anthropic-ai/claude-agent-sdk');
+        process.env.ANTHROPIC_API_KEY = 'test-key';
+        async function* mockIterator() {
+            yield { type: 'result', subtype: 'success', result: '# Plan\n\nContent' };
+        }
+        vi.mocked(query).mockReturnValue(mockIterator());
+        const description = 'Build a user authentication system';
+        await invokePlanWorkflow(description);
+        const calls = vi.mocked(query).mock.calls;
+        expect(calls[0]?.[0]?.prompt).toContain(`/plan_workflow ${description}`);
+        expect(calls[0]?.[0]?.options?.settingSources).toEqual(['user', 'project', 'local']);
+    });
+    it('should return plan output from claude-code', async () => {
+        const { query } = await import('@anthropic-ai/claude-agent-sdk');
+        process.env.ANTHROPIC_API_KEY = 'test-key';
+        const expectedOutput = '# Workflow Plan\n\nDetailed plan content here';
+        async function* mockIterator() {
+            yield { type: 'result', subtype: 'success', result: expectedOutput };
+        }
+        vi.mocked(query).mockReturnValue(mockIterator());
+        const result = await invokePlanWorkflow('Test');
+        expect(result).toBe(expectedOutput);
+    });
+    it('should throw error if API key is missing', async () => {
+        delete process.env.ANTHROPIC_API_KEY;
+        await expect(invokePlanWorkflow('Test'))
+            .rejects.toThrow('ANTHROPIC_API_KEY');
+    });
+    describe('error handling', () => {
+        it('should throw ClaudeInvocationError on API failures', async () => {
+            const { query } = await import('@anthropic-ai/claude-agent-sdk');
+            process.env.ANTHROPIC_API_KEY = 'test-key';
+            const apiError = new Error('API connection failed');
+            vi.mocked(query).mockRejectedValue(apiError);
+            await expect(invokePlanWorkflow('Test'))
+                .rejects.toThrow(ClaudeInvocationError);
+        });
+        it('should preserve original error in cause property', async () => {
+            const { query } = await import('@anthropic-ai/claude-agent-sdk');
+            process.env.ANTHROPIC_API_KEY = 'test-key';
+            const originalError = new Error('Network timeout');
+            // Mock async iterator that throws
+            async function* mockIterator() {
+                throw originalError;
+            }
+            vi.mocked(query).mockReturnValue(mockIterator());
+            try {
+                await invokePlanWorkflow('Test');
+                // If we get here, the test should fail
+                expect.fail('Should have thrown an error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(ClaudeInvocationError);
+                expect(error.cause).toBe(originalError);
+            }
+        });
+        it('should handle rate limit errors', async () => {
+            const { query } = await import('@anthropic-ai/claude-agent-sdk');
+            process.env.ANTHROPIC_API_KEY = 'test-key';
+            const rateLimitError = new Error('Rate limit exceeded');
+            rateLimitError.status = 429;
+            vi.mocked(query).mockRejectedValue(rateLimitError);
+            await expect(invokePlanWorkflow('Test'))
+                .rejects.toThrow(ClaudeInvocationError);
+        });
+        it('should handle authentication errors', async () => {
+            const { query } = await import('@anthropic-ai/claude-agent-sdk');
+            process.env.ANTHROPIC_API_KEY = 'invalid-key';
+            const authError = new Error('Invalid API key');
+            authError.status = 401;
+            vi.mocked(query).mockRejectedValue(authError);
+            await expect(invokePlanWorkflow('Test'))
+                .rejects.toThrow(ClaudeInvocationError);
+        });
+        it('should provide user-friendly error messages', async () => {
+            const { query } = await import('@anthropic-ai/claude-agent-sdk');
+            process.env.ANTHROPIC_API_KEY = 'test-key';
+            vi.mocked(query).mockRejectedValue(new Error('API error'));
+            try {
+                await invokePlanWorkflow('Test');
+            }
+            catch (error) {
+                expect(error.message).toMatch(/Failed to invoke/i);
+            }
+        });
+        it('should throw error when no result received', async () => {
+            const { query } = await import('@anthropic-ai/claude-agent-sdk');
+            process.env.ANTHROPIC_API_KEY = 'test-key';
+            // Mock iterator that yields no result messages
+            async function* mockIterator() {
+                yield { type: 'assistant', message: { content: [] } };
+            }
+            vi.mocked(query).mockReturnValue(mockIterator());
+            await expect(invokePlanWorkflow('Test'))
+                .rejects.toThrow(ClaudeInvocationError);
+        });
+    });
+});
+describe('ClaudeInvocationError', () => {
+    it('should be instance of Error', () => {
+        const error = new ClaudeInvocationError('test message');
+        expect(error).toBeInstanceOf(Error);
+    });
+    it('should have correct name property', () => {
+        const error = new ClaudeInvocationError('test message');
+        expect(error.name).toBe('ClaudeInvocationError');
+    });
+    it('should store cause error', () => {
+        const causeError = new Error('original error');
+        const error = new ClaudeInvocationError('test message', causeError);
+        expect(error.cause).toBe(causeError);
+    });
+});

package/dist/services/coding_agents.d.ts

@@ -0,0 +1,43 @@
+export interface FileMapping {
+    from: string;
+    to: string;
+    type: 'template' | 'symlink' | 'copy';
+}
+export interface AgentSystemConfig {
+    id: string;
+    name: string;
+    mappings: FileMapping[];
+}
+export interface StructureCheckResult {
+    dirExists: boolean;
+    missingFiles: string[];
+    isComplete: boolean;
+}
+export interface InitOptions {
+    projectRoot: string;
+    force: boolean;
+    agentProvider: string;
+}
+/**
+ * Agent configuration mappings for different providers
+ */
+export declare const AGENT_CONFIGS: Record<string, AgentSystemConfig>;
+export declare function getRequiredFiles(): string[];
+/**
+ * Get the full path to the agent configuration directory
+ */
+export declare function getAgentConfigDir(projectRoot: string): string;
+/**
+ * Check if .outputai directory exists
+ */
+export declare function checkAgentConfigDirExists(projectRoot: string): Promise<boolean>;
+export declare function checkAgentStructure(projectRoot: string): Promise<StructureCheckResult>;
+/**
+ * Prepare template variables for file generation
+ */
+export declare function prepareTemplateVariables(): Record<string, string>;
+/**
+ * Initialize agent configuration files
+ * Main entry point for agent initialization logic
+ */
+export declare function initializeAgentConfig(options: InitOptions): Promise<void>;

package/dist/services/coding_agents.js

@@ -0,0 +1,230 @@
+/**
+ * Coding agent configuration service
+ * Handles initialization and validation of agent configuration files
+ */
+import fs from 'node:fs/promises';
+import { access } from 'node:fs/promises';
+import path from 'node:path';
+import { join } from 'node:path';
+import { ux } from '@oclif/core';
+import { AGENT_CONFIG_DIR } from '../config.js';
+import { getTemplateDir } from '../utils/paths.js';
+import { processTemplate } from '../utils/template.js';
+/**
+ * Agent configuration mappings for different providers
+ */
+export const AGENT_CONFIGS = {
+    outputai: {
+        id: 'outputai',
+        name: 'OutputAI Core Files',
+        mappings: [
+            {
+                type: 'template',
+                from: 'AGENTS.md.template',
+                to: `${AGENT_CONFIG_DIR}/AGENTS.md`
+            },
+            {
+                type: 'template',
+                from: 'agents/workflow_planner.md.template',
+                to: `${AGENT_CONFIG_DIR}/agents/workflow_planner.md`
+            },
+            {
+                type: 'template',
+                from: 'commands/plan_workflow.md.template',
+                to: `${AGENT_CONFIG_DIR}/commands/plan_workflow.md`
+            },
+            {
+                type: 'template',
+                from: 'meta/pre_flight.md.template',
+                to: '.outputai/meta/pre_flight.md'
+            },
+            {
+                type: 'template',
+                from: 'meta/post_flight.md.template',
+                to: '.outputai/meta/post_flight.md'
+            }
+        ]
+    },
+    'claude-code': {
+        id: 'claude-code',
+        name: 'Claude Code',
+        mappings: [
+            {
+                type: 'symlink',
+                from: `${AGENT_CONFIG_DIR}/AGENTS.md`,
+                to: 'CLAUDE.md'
+            },
+            {
+                type: 'symlink',
+                from: `${AGENT_CONFIG_DIR}/agents/workflow_planner.md`,
+                to: '.claude/agents/workflow_planner.md'
+            },
+            {
+                type: 'symlink',
+                from: `${AGENT_CONFIG_DIR}/commands/plan_workflow.md`,
+                to: '.claude/commands/plan_workflow.md'
+            }
+        ]
+    }
+};
+export function getRequiredFiles() {
+    const outputaiFiles = AGENT_CONFIGS.outputai.mappings.map(m => m.to);
+    const claudeCodeFiles = AGENT_CONFIGS['claude-code'].mappings.map(m => m.to);
+    return [...outputaiFiles, ...claudeCodeFiles];
+}
+/**
+ * Get the full path to the agent configuration directory
+ */
+export function getAgentConfigDir(projectRoot) {
+    return join(projectRoot, AGENT_CONFIG_DIR);
+}
+/**
+ * Check if .outputai directory exists
+ */
+export async function checkAgentConfigDirExists(projectRoot) {
+    const agentConfigDir = getAgentConfigDir(projectRoot);
+    try {
+        await access(agentConfigDir);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function checkAgentStructure(projectRoot) {
+    const requiredFiles = getRequiredFiles();
+    const dirExists = await checkAgentConfigDirExists(projectRoot);
+    if (!dirExists) {
+        return {
+            dirExists: false,
+            missingFiles: requiredFiles,
+            isComplete: false
+        };
+    }
+    const missingChecks = await Promise.all(requiredFiles.map(async (file) => ({
+        file,
+        exists: await fileExists(join(projectRoot, file))
+    })));
+    const missingFiles = missingChecks
+        .filter(check => !check.exists)
+        .map(check => check.file);
+    return {
+        dirExists: true,
+        missingFiles,
+        isComplete: missingFiles.length === 0
+    };
+}
+/**
+ * Prepare template variables for file generation
+ */
+export function prepareTemplateVariables() {
+    return {
+        date: new Date().toLocaleDateString('en-US', {
+            year: 'numeric',
+            month: 'long',
+            day: 'numeric'
+        })
+    };
+}
+/**
+ * Ensure a directory exists, creating it if necessary
+ */
+async function ensureDirectoryExists(dir) {
+    try {
+        await fs.mkdir(dir, { recursive: true });
+        ux.stdout(ux.colorize('gray', `Created directory: ${dir}`));
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST') {
+            throw error;
+        }
+    }
+}
+/**
+ * Create a file from a template
+ */
+async function createFromTemplate(template, output, variables) {
+    const templateDir = getTemplateDir('agent_instructions');
+    const templatePath = path.join(templateDir, template);
+    const content = await fs.readFile(templatePath, 'utf-8');
+    const processed = processTemplate(content, variables);
+    await fs.writeFile(output, processed, 'utf-8');
+    ux.stdout(ux.colorize('gray', `Created from template: ${output}`));
+}
+/**
+ * Create a symlink, falling back to copying if symlinks are not supported
+ */
+async function createSymlink(source, target) {
+    try {
+        if (await fileExists(target)) {
+            await fs.unlink(target);
+        }
+        const relativePath = path.relative(path.dirname(target), source);
+        await fs.symlink(relativePath, target);
+        ux.stdout(ux.colorize('gray', `Created symlink: ${target} -> ${source}`));
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOTSUP' || code === 'EPERM') {
+            ux.stdout(ux.colorize('gray', `Symlinks not supported, creating copy: ${target}`));
+            const content = await fs.readFile(source, 'utf-8');
+            await fs.writeFile(target, content, 'utf-8');
+            return;
+        }
+        throw error;
+    }
+}
+/**
+ * Copy a file from source to target
+ */
+async function copyFile(source, target) {
+    const content = await fs.readFile(source, 'utf-8');
+    await fs.writeFile(target, content, 'utf-8');
+    ux.stdout(ux.colorize('gray', `Copied file: ${source} -> ${target}`));
+}
+/**
+ * Process file mappings for a specific agent configuration
+ */
+async function processMappings(config, variables, force, projectRoot) {
+    for (const mapping of config.mappings) {
+        const fullPath = path.isAbsolute(mapping.to) ?
+            mapping.to :
+            path.join(projectRoot, mapping.to);
+        const dir = path.dirname(fullPath);
+        await ensureDirectoryExists(dir);
+        if (!force && await fileExists(fullPath)) {
+            ux.warn(`File already exists: ${mapping.to} (use --force to overwrite)`);
+            continue;
+        }
+        switch (mapping.type) {
+            case 'template':
+                await createFromTemplate(mapping.from, fullPath, variables);
+                break;
+            case 'symlink':
+                await createSymlink(mapping.from, fullPath);
+                break;
+            case 'copy':
+                await copyFile(mapping.from, fullPath);
+                break;
+        }
+    }
+}
+/**
+ * Initialize agent configuration files
+ * Main entry point for agent initialization logic
+ */
+export async function initializeAgentConfig(options) {
+    const { projectRoot, force, agentProvider } = options;
+    const variables = prepareTemplateVariables();
+    await processMappings(AGENT_CONFIGS.outputai, variables, force, projectRoot);
+    await processMappings(AGENT_CONFIGS[agentProvider], variables, force, projectRoot);
+}

package/dist/services/coding_agents.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/coding_agents.spec.js

@@ -0,0 +1,254 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { getRequiredFiles, checkAgentConfigDirExists, checkAgentStructure, getAgentConfigDir, prepareTemplateVariables, initializeAgentConfig, AGENT_CONFIGS } from './coding_agents.js';
+import { access } from 'node:fs/promises';
+import fs from 'node:fs/promises';
+vi.mock('node:fs/promises');
+vi.mock('../utils/paths.js', () => ({
+    getTemplateDir: vi.fn().mockReturnValue('/templates')
+}));
+vi.mock('../utils/template.js', () => ({
+    processTemplate: vi.fn().mockImplementation((content) => content)
+}));
+describe('coding_agents service', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('getRequiredFiles', () => {
+        it('should derive required files from both AGENT_CONFIGS', () => {
+            const files = getRequiredFiles();
+            expect(files).toContain('.outputai/AGENTS.md');
+            expect(files).toContain('.outputai/agents/workflow_planner.md');
+            expect(files).toContain('.outputai/commands/plan_workflow.md');
+            expect(files).toContain('CLAUDE.md');
+            expect(files).toContain('.claude/agents/workflow_planner.md');
+            expect(files).toContain('.claude/commands/plan_workflow.md');
+        });
+        it('should include both outputai and claude-code files', () => {
+            const files = getRequiredFiles();
+            const expectedCount = AGENT_CONFIGS.outputai.mappings.length +
+                AGENT_CONFIGS['claude-code'].mappings.length;
+            expect(files.length).toBe(expectedCount);
+            expect(files.length).toBe(8);
+        });
+        it('should have outputai files with .outputai prefix', () => {
+            const files = getRequiredFiles();
+            const outputaiFiles = files.slice(0, 5);
+            outputaiFiles.forEach(file => {
+                expect(file).toMatch(/^\.outputai\//);
+            });
+        });
+    });
+    describe('getAgentConfigDir', () => {
+        it('should return the correct path to .outputai directory', () => {
+            const result = getAgentConfigDir('/test/project');
+            expect(result).toBe('/test/project/.outputai');
+        });
+    });
+    describe('checkAgentConfigDirExists', () => {
+        it('should return true when .outputai directory exists', async () => {
+            vi.mocked(access).mockResolvedValue(undefined);
+            const result = await checkAgentConfigDirExists('/test/project');
+            expect(result).toBe(true);
+            expect(access).toHaveBeenCalledWith('/test/project/.outputai');
+        });
+        it('should return false when .outputai directory does not exist', async () => {
+            vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
+            const result = await checkAgentConfigDirExists('/test/project');
+            expect(result).toBe(false);
+        });
+    });
+    describe('checkAgentStructure', () => {
+        it('should return all files missing when directory does not exist', async () => {
+            vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
+            const result = await checkAgentStructure('/test/project');
+            expect(result).toEqual({
+                dirExists: false,
+                missingFiles: [
+                    '.outputai/AGENTS.md',
+                    '.outputai/agents/workflow_planner.md',
+                    '.outputai/commands/plan_workflow.md',
+                    '.outputai/meta/pre_flight.md',
+                    '.outputai/meta/post_flight.md',
+                    'CLAUDE.md',
+                    '.claude/agents/workflow_planner.md',
+                    '.claude/commands/plan_workflow.md'
+                ],
+                isComplete: false
+            });
+        });
+        it('should return complete when all files exist', async () => {
+            // Mock directory exists
+            vi.mocked(access).mockResolvedValue(undefined);
+            const result = await checkAgentStructure('/test/project');
+            expect(result).toEqual({
+                dirExists: true,
+                missingFiles: [],
+                isComplete: true
+            });
+            expect(access).toHaveBeenCalledTimes(9); // dir + 5 outputai + 3 claude-code
+        });
+        it('should return missing files when some files do not exist', async () => {
+            const calls = [];
+            vi.mocked(access).mockImplementation(async () => {
+                const callNum = calls.length + 1;
+                calls.push(callNum);
+                // Call 1: directory exists
+                if (callNum === 1) {
+                    return undefined;
+                }
+                // Call 2: .outputai/AGENTS.md exists
+                if (callNum === 2) {
+                    return undefined;
+                }
+                // Call 3: .outputai/agents/workflow_planner.md missing
+                if (callNum === 3) {
+                    throw { code: 'ENOENT' };
+                }
+                // Call 4: .outputai/commands/plan_workflow.md exists
+                if (callNum === 4) {
+                    return undefined;
+                }
+                // Call 5: .outputai/meta/pre_flight.md exists
+                if (callNum === 5) {
+                    return undefined;
+                }
+                // Call 6: .outputai/meta/post_flight.md exists
+                if (callNum === 6) {
+                    return undefined;
+                }
+                // Call 7: CLAUDE.md exists
+                if (callNum === 7) {
+                    return undefined;
+                }
+                // Call 8: .claude/agents/workflow_planner.md missing
+                if (callNum === 8) {
+                    throw { code: 'ENOENT' };
+                }
+                // Call 9: .claude/commands/plan_workflow.md exists
+                return undefined;
+            });
+            const result = await checkAgentStructure('/test/project');
+            expect(result).toEqual({
+                dirExists: true,
+                missingFiles: [
+                    '.outputai/agents/workflow_planner.md',
+                    '.claude/agents/workflow_planner.md'
+                ],
+                isComplete: false
+            });
+        });
+        it('should check all required files even when directory exists', async () => {
+            vi.mocked(access)
+                .mockResolvedValueOnce(undefined) // directory
+                .mockResolvedValueOnce(undefined) // .outputai/AGENTS.md
+                .mockRejectedValueOnce({ code: 'ENOENT' }) // .outputai/agents/workflow_planner.md
+                .mockRejectedValueOnce({ code: 'ENOENT' }) // .outputai/commands/plan_workflow.md
+                .mockResolvedValueOnce(undefined) // .outputai/meta/pre_flight.md
+                .mockResolvedValueOnce(undefined) // .outputai/meta/post_flight.md
+                .mockResolvedValueOnce(undefined) // CLAUDE.md
+                .mockResolvedValueOnce(undefined) // .claude/agents/workflow_planner.md
+                .mockRejectedValueOnce({ code: 'ENOENT' }); // .claude/commands/plan_workflow.md
+            const result = await checkAgentStructure('/test/project');
+            expect(result.dirExists).toBe(true);
+            expect(result.missingFiles).toEqual([
+                '.outputai/agents/workflow_planner.md',
+                '.outputai/commands/plan_workflow.md',
+                '.claude/commands/plan_workflow.md'
+            ]);
+            expect(result.isComplete).toBe(false);
+        });
+    });
+    describe('prepareTemplateVariables', () => {
+        it('should return template variables with formatted date', () => {
+            const variables = prepareTemplateVariables();
+            expect(variables).toHaveProperty('date');
+            expect(typeof variables.date).toBe('string');
+            // Should be in format like "January 1, 2025"
+            expect(variables.date).toMatch(/^[A-Z][a-z]+ \d{1,2}, \d{4}$/);
+        });
+    });
+    describe('initializeAgentConfig', () => {
+        beforeEach(() => {
+            // Mock fs operations
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(access).mockRejectedValue({ code: 'ENOENT' }); // Files don't exist
+            vi.mocked(fs.readFile).mockResolvedValue('template content');
+            vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+            vi.mocked(fs.symlink).mockResolvedValue(undefined);
+        });
+        it('should process both outputai and provider mappings', async () => {
+            await initializeAgentConfig({
+                projectRoot: '/test/project',
+                force: false,
+                agentProvider: 'claude-code'
+            });
+            // Should create outputai files (3 templates)
+            expect(fs.writeFile).toHaveBeenCalledWith(expect.stringContaining('AGENTS.md'), expect.any(String), 'utf-8');
+            // Should create symlinks (3 symlinks for claude-code)
+            expect(fs.symlink).toHaveBeenCalledTimes(3);
+        });
+        it('should skip existing files when force is false', async () => {
+            // Mock some files exist
+            vi.mocked(access).mockImplementation(async (path, _mode) => {
+                const pathStr = path.toString();
+                if (pathStr.includes('AGENTS.md')) {
+                    return; // File exists
+                }
+                throw { code: 'ENOENT' }; // File doesn't exist
+            });
+            await initializeAgentConfig({
+                projectRoot: '/test/project',
+                force: false,
+                agentProvider: 'claude-code'
+            });
+            // Should not create files that already exist
+            expect(fs.writeFile).toHaveBeenCalled();
+            const writeFileCalls = vi.mocked(fs.writeFile).mock.calls;
+            const agentsWriteCalls = writeFileCalls.filter(call => call[0].toString().includes('AGENTS.md'));
+            expect(agentsWriteCalls).toHaveLength(0);
+        });
+        it('should overwrite existing files when force is true', async () => {
+            // Mock all files exist
+            vi.mocked(access).mockResolvedValue(undefined);
+            await initializeAgentConfig({
+                projectRoot: '/test/project',
+                force: true,
+                agentProvider: 'claude-code'
+            });
+            // Should still write files
+            expect(fs.writeFile).toHaveBeenCalled();
+        });
+        it('should create files and output to stdout', async () => {
+            await initializeAgentConfig({
+                projectRoot: '/test/project',
+                force: false,
+                agentProvider: 'claude-code'
+            });
+            // Should create files
+            expect(fs.writeFile).toHaveBeenCalled();
+            expect(fs.symlink).toHaveBeenCalled();
+        });
+        it('should create directories for nested files', async () => {
+            await initializeAgentConfig({
+                projectRoot: '/test/project',
+                force: false,
+                agentProvider: 'claude-code'
+            });
+            // Should create directories like .outputai/agents, .outputai/commands
+            expect(fs.mkdir).toHaveBeenCalledWith(expect.stringContaining('agents'), expect.objectContaining({ recursive: true }));
+        });
+        it('should handle symlink errors by falling back to copy', async () => {
+            vi.mocked(fs.symlink).mockRejectedValue({ code: 'ENOTSUP' });
+            await initializeAgentConfig({
+                projectRoot: '/test/project',
+                force: false,
+                agentProvider: 'claude-code'
+            });
+            // Should fall back to copying via writeFile
+            expect(fs.writeFile).toHaveBeenCalled();
+            const writeFileCalls = vi.mocked(fs.writeFile).mock.calls;
+            const symlinkFallbackCalls = writeFileCalls.filter(call => call[0].toString().includes('CLAUDE.md') || call[0].toString().includes('.claude/'));
+            expect(symlinkFallbackCalls.length).toBeGreaterThan(0);
+        });
+    });
+});