@output.ai/cli 0.0.4 → 0.0.6

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);
+        });
+    });
+});

package/dist/services/generate_plan_name@v1.prompt

@@ -0,0 +1,24 @@
+---
+provider: anthropic
+model: claude-sonnet-4-20250514
+temperature: 0.3
+---
+
+<assistant>
+You are a semantic naming assistant. Generate concise, descriptive slugs for workflow plans.
+</assistant>
+
+<user>
+Convert this workflow description into a short, semantic slug (2-6 words max):
+
+"{{ description }}"
+
+Requirements:
+- Use snake_case format
+- Be descriptive but concise
+- Focus on the core action/purpose
+- Use common technical terms
+- Maximum 50 characters
+
+Return ONLY the slug, no quotes, no explanation.
+</user>

package/dist/services/template_processor.d.ts

@@ -1,4 +1,4 @@
-import type { TemplateFile } from '../types/generator.js';
+import type { TemplateFile } from '#types/generator.js';
 /**
  * Get list of template files from a directory
  * Automatically discovers all .template files and derives output names

package/dist/services/template_processor.js

@@ -1,6 +1,6 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import { processTemplate } from '../utils/template.js';
+import { processTemplate } from '#utils/template.js';
 const TEMPLATE_EXTENSION = '.template';
 function isTemplateFile(file) {
     return file.endsWith(TEMPLATE_EXTENSION);

package/dist/services/workflow_generator.d.ts

@@ -1,4 +1,4 @@
-import type { WorkflowGenerationConfig, WorkflowGenerationResult } from '../types/generator.js';
+import type { WorkflowGenerationConfig, WorkflowGenerationResult } from '#types/generator.js';
 /**
  * Generate a new workflow
  */

package/dist/services/workflow_generator.js

@@ -1,8 +1,8 @@
 import * as fs from 'node:fs/promises';
-import { WorkflowExistsError } from '../types/errors.js';
-import { createTargetDir, getTemplateDir } from '../utils/paths.js';
-import { validateWorkflowName, validateOutputDirectory } from '../utils/validation.js';
-import { prepareTemplateVariables } from '../utils/template.js';
+import { WorkflowExistsError } from '#types/errors.js';
+import { createTargetDir, getTemplateDir } from '#utils/paths.js';
+import { validateWorkflowName, validateOutputDirectory } from '#utils/validation.js';
+import { prepareTemplateVariables } from '#utils/template.js';
 import { getTemplateFiles, processAllTemplates } from './template_processor.js';
 /**
  * Validate the generation configuration

package/dist/services/workflow_planner.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Ensure .outputai directory structure exists by invoking agents init if needed
+ * @throws Error if user declines to initialize or if initialization fails
+ */
+export declare function ensureOutputAIStructure(projectRoot: string): Promise<void>;
+export declare function generatePlanName(description: string, date?: Date): Promise<string>;
+/**
+ * Write plan content to PLAN.md file in the plans directory
+ * @param planName - Name of the plan (e.g., "2025_10_06_customer_order_processing")
+ * @param content - Plan content to write
+ * @param projectRoot - Root directory of the project
+ * @returns Full path to the created PLAN.md file
+ */
+export declare function writePlanFile(planName: string, content: string, projectRoot: string): Promise<string>;
+/**
+ * Update agent templates by invoking agents init with force flag
+ * This recreates all agent configuration files, overwriting existing ones
+ * @param projectRoot - Root directory of the project
+ */
+export declare function updateAgentTemplates(projectRoot: string): Promise<void>;

package/dist/services/workflow_planner.js

@@ -0,0 +1,83 @@
+import { checkAgentStructure, initializeAgentConfig } from './coding_agents.js';
+import { confirm } from '@inquirer/prompts';
+import { generateText } from 'local_llm';
+import { loadPrompt } from 'local_prompt';
+import { format } from 'date-fns';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { ux } from '@oclif/core';
+import { AGENT_CONFIG_DIR } from '#config.js';
+/**
+ * Invoke agents init programmatically
+ */
+async function invokeAgentsInit(projectRoot, force) {
+    await initializeAgentConfig({
+        projectRoot,
+        force,
+        agentProvider: 'claude-code'
+    });
+}
+/**
+ * Ensure .outputai directory structure exists by invoking agents init if needed
+ * @throws Error if user declines to initialize or if initialization fails
+ */
+export async function ensureOutputAIStructure(projectRoot) {
+    const structureCheck = await checkAgentStructure(projectRoot);
+    if (structureCheck.isComplete) {
+        return;
+    }
+    if (!structureCheck.dirExists) {
+        await invokeAgentsInit(projectRoot, false);
+        return;
+    }
+    const missingList = structureCheck.missingFiles.map(f => `  • ${f}`).join('\n');
+    ux.warn(`\n⚠️  Agent configuration is incomplete. Missing files:\n${missingList}\n`);
+    const shouldReinit = await confirm({
+        message: 'Would you like to run "agents init --force" to recreate missing files?',
+        default: true
+    });
+    if (!shouldReinit) {
+        throw new Error(`Agent configuration incomplete. Missing files:\n${structureCheck.missingFiles.join('\n')}\n\n` +
+            'Run "output-cli agents init --force" to recreate them.');
+    }
+    await invokeAgentsInit(projectRoot, true);
+}
+export async function generatePlanName(description, date = new Date()) {
+    const datePrefix = format(date, 'yyyy_MM_dd');
+    const prompt = loadPrompt('generate_plan_name@v1', { description });
+    const planNameSlug = await generateText({ prompt });
+    const cleanedName = planNameSlug
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9_]+/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_|_$/g, '')
+        .slice(0, 50);
+    return `${datePrefix}_${cleanedName}`;
+}
+/**
+ * Write plan content to PLAN.md file in the plans directory
+ * @param planName - Name of the plan (e.g., "2025_10_06_customer_order_processing")
+ * @param content - Plan content to write
+ * @param projectRoot - Root directory of the project
+ * @returns Full path to the created PLAN.md file
+ */
+export async function writePlanFile(planName, content, projectRoot) {
+    const planDir = path.join(projectRoot, AGENT_CONFIG_DIR, 'plans', planName);
+    const planFilePath = path.join(planDir, 'PLAN.md');
+    await fs.mkdir(planDir, { recursive: true });
+    await fs.writeFile(planFilePath, content, 'utf-8');
+    return planFilePath;
+}
+/**
+ * Update agent templates by invoking agents init with force flag
+ * This recreates all agent configuration files, overwriting existing ones
+ * @param projectRoot - Root directory of the project
+ */
+export async function updateAgentTemplates(projectRoot) {
+    await initializeAgentConfig({
+        projectRoot,
+        force: true,
+        agentProvider: 'claude-code'
+    });
+}

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

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

package/dist/services/workflow_planner.spec.js

@@ -0,0 +1,208 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { ensureOutputAIStructure, generatePlanName, writePlanFile, updateAgentTemplates } from './workflow_planner.js';
+import { checkAgentStructure, initializeAgentConfig } from './coding_agents.js';
+import { generateText } from 'local_llm';
+import { loadPrompt } from 'local_prompt';
+import { confirm } from '@inquirer/prompts';
+import fs from 'node:fs/promises';
+vi.mock('./coding_agents.js');
+vi.mock('local_llm');
+vi.mock('local_prompt');
+vi.mock('@inquirer/prompts');
+vi.mock('node:fs/promises');
+describe('workflow-planner service', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('ensureOutputAIStructure', () => {
+        it('should call agents init when .outputai does not exist', async () => {
+            vi.mocked(checkAgentStructure).mockResolvedValue({
+                dirExists: false,
+                missingFiles: [
+                    '.outputai/AGENTS.md',
+                    '.outputai/agents/workflow_planner.md',
+                    '.outputai/commands/plan_workflow.md',
+                    'CLAUDE.md',
+                    '.claude/agents/workflow_planner.md',
+                    '.claude/commands/plan_workflow.md'
+                ],
+                isComplete: false
+            });
+            vi.mocked(initializeAgentConfig).mockResolvedValue();
+            await ensureOutputAIStructure('/test/project');
+            expect(checkAgentStructure).toHaveBeenCalledWith('/test/project');
+            expect(initializeAgentConfig).toHaveBeenCalledWith(expect.objectContaining({
+                projectRoot: expect.any(String),
+                force: false,
+                agentProvider: 'claude-code'
+            }));
+        });
+        it('should skip initialization if .outputai exists', async () => {
+            vi.mocked(checkAgentStructure).mockResolvedValue({
+                dirExists: true,
+                missingFiles: [],
+                isComplete: true
+            });
+            await ensureOutputAIStructure('/test/project');
+            expect(checkAgentStructure).toHaveBeenCalledWith('/test/project');
+            expect(initializeAgentConfig).not.toHaveBeenCalled();
+        });
+        it('should throw error if agents init fails', async () => {
+            vi.mocked(checkAgentStructure).mockResolvedValue({
+                dirExists: false,
+                missingFiles: [
+                    '.outputai/AGENTS.md',
+                    '.outputai/agents/workflow_planner.md',
+                    '.outputai/commands/plan_workflow.md',
+                    'CLAUDE.md',
+                    '.claude/agents/workflow_planner.md',
+                    '.claude/commands/plan_workflow.md'
+                ],
+                isComplete: false
+            });
+            vi.mocked(initializeAgentConfig).mockRejectedValue(new Error('Init command failed'));
+            await expect(ensureOutputAIStructure('/test/project')).rejects.toThrow('Init command failed');
+        });
+        it('should prompt user when some files are missing', async () => {
+            vi.mocked(checkAgentStructure).mockResolvedValue({
+                dirExists: true,
+                missingFiles: ['.outputai/agents/workflow_planner.md'],
+                isComplete: false
+            });
+            vi.mocked(confirm).mockResolvedValue(true);
+            vi.mocked(initializeAgentConfig).mockResolvedValue();
+            await ensureOutputAIStructure('/test/project');
+            expect(confirm).toHaveBeenCalled();
+            expect(initializeAgentConfig).toHaveBeenCalledWith(expect.objectContaining({
+                force: true
+            }));
+        });
+        it('should throw error when user declines partial init', async () => {
+            vi.mocked(checkAgentStructure).mockResolvedValue({
+                dirExists: true,
+                missingFiles: ['.outputai/agents/workflow_planner.md'],
+                isComplete: false
+            });
+            vi.mocked(confirm).mockResolvedValue(false);
+            await expect(ensureOutputAIStructure('/test/project')).rejects.toThrow('Agent configuration incomplete');
+        });
+    });
+    describe('generatePlanName', () => {
+        it('should generate plan name with date prefix using LLM', async () => {
+            const mockPrompt = {
+                config: { model: 'claude-sonnet-4-20250514', provider: 'anthropic' },
+                messages: [
+                    { role: 'system', content: 'You are a technical writing assistant...' },
+                    { role: 'user', content: 'Generate a snake_case plan name...' }
+                ]
+            };
+            vi.mocked(loadPrompt).mockReturnValue(mockPrompt);
+            vi.mocked(generateText).mockResolvedValue('customer_order_processing');
+            const testDate = new Date(2025, 9, 6);
+            const planName = await generatePlanName('A workflow that processes customer orders', testDate);
+            expect(planName).toMatch(/^2025_10_06_/);
+            expect(planName).toBe('2025_10_06_customer_order_processing');
+            expect(loadPrompt).toHaveBeenCalledWith('generate_plan_name@v1', { description: 'A workflow that processes customer orders' });
+            expect(generateText).toHaveBeenCalledWith({ prompt: mockPrompt });
+        });
+        it('should clean and validate LLM response', async () => {
+            const mockPrompt = { config: { provider: 'anthropic', model: 'claude-sonnet-4-20250514' }, messages: [] };
+            vi.mocked(loadPrompt).mockReturnValue(mockPrompt);
+            vi.mocked(generateText).mockResolvedValue('  User-Auth & Security!@#  ');
+            const testDate = new Date(2025, 9, 6);
+            const planName = await generatePlanName('User authentication workflow', testDate);
+            expect(planName).toBe('2025_10_06_user_auth_security');
+            expect(planName).toMatch(/^[0-9_a-z]+$/);
+        });
+        it('should handle LLM errors gracefully', async () => {
+            const mockPrompt = { config: { provider: 'anthropic', model: 'claude-sonnet-4-20250514' }, messages: [] };
+            vi.mocked(loadPrompt).mockReturnValue(mockPrompt);
+            vi.mocked(generateText).mockRejectedValue(new Error('API rate limit exceeded'));
+            await expect(generatePlanName('Test workflow')).rejects.toThrow('API rate limit exceeded');
+        });
+        it('should limit plan name length to 50 characters', async () => {
+            const mockPrompt = { config: { provider: 'anthropic', model: 'claude-sonnet-4-20250514' }, messages: [] };
+            vi.mocked(loadPrompt).mockReturnValue(mockPrompt);
+            vi.mocked(generateText).mockResolvedValue('this_is_an_extremely_long_plan_name_that_exceeds_the_maximum_allowed_length_for_file_names');
+            const testDate = new Date(2025, 9, 6);
+            const planName = await generatePlanName('Long workflow description', testDate);
+            const namePart = planName.replace(/^2025_10_06_/, '');
+            expect(namePart.length).toBeLessThanOrEqual(50);
+        });
+        it('should handle multiple underscores correctly', async () => {
+            const mockPrompt = { config: { provider: 'anthropic', model: 'claude-sonnet-4-20250514' }, messages: [] };
+            vi.mocked(loadPrompt).mockReturnValue(mockPrompt);
+            vi.mocked(generateText).mockResolvedValue('user___auth___workflow');
+            const testDate = new Date(2025, 9, 6);
+            const planName = await generatePlanName('Test', testDate);
+            expect(planName).toBe('2025_10_06_user_auth_workflow');
+            expect(planName).not.toContain('__');
+        });
+    });
+    describe('writePlanFile', () => {
+        it('should create plan directory and write PLAN.md', async () => {
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+            const planName = '2025_10_06_test_plan';
+            const content = '# Test Plan\n\nThis is a test plan.';
+            const projectRoot = '/test/project';
+            const planPath = await writePlanFile(planName, content, projectRoot);
+            expect(fs.mkdir).toHaveBeenCalledWith('/test/project/.outputai/plans/2025_10_06_test_plan', { recursive: true });
+            expect(fs.writeFile).toHaveBeenCalledWith('/test/project/.outputai/plans/2025_10_06_test_plan/PLAN.md', content, 'utf-8');
+            expect(planPath).toBe('/test/project/.outputai/plans/2025_10_06_test_plan/PLAN.md');
+        });
+        it('should return the plan file path', async () => {
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+            const planPath = await writePlanFile('test_plan', 'content', '/root');
+            expect(planPath).toBe('/root/.outputai/plans/test_plan/PLAN.md');
+        });
+        it('should handle nested directory creation', async () => {
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+            await writePlanFile('2025_10_06_nested_plan', 'content', '/deep/nested/path');
+            expect(fs.mkdir).toHaveBeenCalledWith('/deep/nested/path/.outputai/plans/2025_10_06_nested_plan', { recursive: true });
+        });
+        it('should handle UTF-8 content with special characters', async () => {
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+            const content = '# Plan 🎯\n\n中文 • Español • العربية\n\n"Smart quotes" and—dashes';
+            await writePlanFile('unicode_test', content, '/test');
+            expect(fs.writeFile).toHaveBeenCalledWith(expect.any(String), content, 'utf-8');
+        });
+        it('should throw error when directory creation fails', async () => {
+            vi.mocked(fs.mkdir).mockRejectedValue(new Error('Permission denied'));
+            await expect(writePlanFile('test', 'content', '/root'))
+                .rejects.toThrow('Permission denied');
+        });
+        it('should throw error when file writing fails', async () => {
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(fs.writeFile).mockRejectedValue(new Error('Disk full'));
+            await expect(writePlanFile('test', 'content', '/root'))
+                .rejects.toThrow('Disk full');
+        });
+    });
+    describe('updateAgentTemplates', () => {
+        it('should invoke agents init with force flag', async () => {
+            vi.mocked(initializeAgentConfig).mockResolvedValue();
+            await updateAgentTemplates('/test/project');
+            expect(initializeAgentConfig).toHaveBeenCalledWith(expect.objectContaining({
+                projectRoot: '/test/project',
+                force: true,
+                agentProvider: 'claude-code'
+            }));
+        });
+        it('should propagate errors from agents init', async () => {
+            vi.mocked(initializeAgentConfig).mockRejectedValue(new Error('Failed to write templates'));
+            await expect(updateAgentTemplates('/test/project'))
+                .rejects.toThrow('Failed to write templates');
+        });
+        it('should work with different project roots', async () => {
+            vi.mocked(initializeAgentConfig).mockResolvedValue();
+            await updateAgentTemplates('/different/path');
+            expect(initializeAgentConfig).toHaveBeenCalledWith(expect.objectContaining({
+                projectRoot: '/different/path'
+            }));
+        });
+    });
+});