@output.ai/cli 0.0.5 → 0.0.7

package/dist/services/coding_agents.js

@@ -7,9 +7,10 @@ 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';
+import { confirm } from '@inquirer/prompts';
+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
  */
@@ -33,6 +34,11 @@ export const AGENT_CONFIGS = {
                 from: 'commands/plan_workflow.md.template',
                 to: `${AGENT_CONFIG_DIR}/commands/plan_workflow.md`
             },
+            {
+                type: 'template',
+                from: 'commands/build_workflow.md.template',
+                to: `${AGENT_CONFIG_DIR}/commands/build_workflow.md`
+            },
             {
                 type: 'template',
                 from: 'meta/pre_flight.md.template',
@@ -63,6 +69,11 @@ export const AGENT_CONFIGS = {
                 type: 'symlink',
                 from: `${AGENT_CONFIG_DIR}/commands/plan_workflow.md`,
                 to: '.claude/commands/plan_workflow.md'
+            },
+            {
+                type: 'symlink',
+                from: `${AGENT_CONFIG_DIR}/commands/build_workflow.md`,
+                to: '.claude/commands/build_workflow.md'
             }
         ]
     }
@@ -100,6 +111,15 @@ async function fileExists(filePath) {
         return false;
     }
 }
+async function findMissingFiles(files, projectRoot) {
+    const checks = await Promise.all(files.map(async (file) => ({
+        file,
+        missing: !await fileExists(join(projectRoot, file))
+    })));
+    return checks
+        .filter(check => check.missing)
+        .map(check => check.file);
+}
 export async function checkAgentStructure(projectRoot) {
     const requiredFiles = getRequiredFiles();
     const dirExists = await checkAgentConfigDirExists(projectRoot);
@@ -110,13 +130,7 @@ export async function checkAgentStructure(projectRoot) {
             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);
+    const missingFiles = await findMissingFiles(requiredFiles, projectRoot);
     return {
         dirExists: true,
         missingFiles,
@@ -228,3 +242,46 @@ export async function initializeAgentConfig(options) {
     await processMappings(AGENT_CONFIGS.outputai, variables, force, projectRoot);
     await processMappings(AGENT_CONFIGS[agentProvider], variables, force, projectRoot);
 }
+function formatMissingFilesList(files) {
+    return files.map(f => `  • ${f}`).join('\n');
+}
+async function promptForReinitialize() {
+    return confirm({
+        message: 'Would you like to run "agents init --force" to recreate missing files?',
+        default: true
+    });
+}
+async function initializeAgentStructure(projectRoot, force) {
+    await initializeAgentConfig({
+        projectRoot,
+        force,
+        agentProvider: 'claude-code'
+    });
+}
+function createIncompleteConfigError(missingFiles) {
+    return new Error(`Agent configuration incomplete. Missing files:\n${missingFiles.join('\n')}\n\n` +
+        'Run "output-cli agents init --force" to recreate them.');
+}
+/**
+ * Ensure .outputai directory structure exists by invoking agents init if needed
+ * Displays warnings for missing files and prompts for reinitialization
+ * @param projectRoot - Root directory of the project
+ * @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 initializeAgentStructure(projectRoot, false);
+        return;
+    }
+    const missingList = formatMissingFilesList(structureCheck.missingFiles);
+    ux.warn(`\n⚠️  Agent configuration is incomplete. Missing files:\n${missingList}\n`);
+    const shouldReinit = await promptForReinitialize();
+    if (!shouldReinit) {
+        throw createIncompleteConfigError(structureCheck.missingFiles);
+    }
+    await initializeAgentStructure(projectRoot, true);
+}

package/dist/services/coding_agents.spec.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { getRequiredFiles, checkAgentConfigDirExists, checkAgentStructure, getAgentConfigDir, prepareTemplateVariables, initializeAgentConfig, AGENT_CONFIGS } from './coding_agents.js';
+import { getRequiredFiles, checkAgentConfigDirExists, checkAgentStructure, getAgentConfigDir, prepareTemplateVariables, initializeAgentConfig, ensureOutputAIStructure, AGENT_CONFIGS } from './coding_agents.js';
 import { access } from 'node:fs/promises';
 import fs from 'node:fs/promises';
 vi.mock('node:fs/promises');
@@ -9,6 +9,16 @@ vi.mock('../utils/paths.js', () => ({
 vi.mock('../utils/template.js', () => ({
     processTemplate: vi.fn().mockImplementation((content) => content)
 }));
+vi.mock('@inquirer/prompts', () => ({
+    confirm: vi.fn()
+}));
+vi.mock('@oclif/core', () => ({
+    ux: {
+        warn: vi.fn(),
+        stdout: vi.fn(),
+        colorize: vi.fn().mockImplementation((_color, text) => text)
+    }
+}));
 describe('coding_agents service', () => {
     beforeEach(() => {
         vi.clearAllMocks();
@@ -28,11 +38,11 @@ describe('coding_agents service', () => {
             const expectedCount = AGENT_CONFIGS.outputai.mappings.length +
                 AGENT_CONFIGS['claude-code'].mappings.length;
             expect(files.length).toBe(expectedCount);
-            expect(files.length).toBe(8);
+            expect(files.length).toBe(10);
         });
         it('should have outputai files with .outputai prefix', () => {
             const files = getRequiredFiles();
-            const outputaiFiles = files.slice(0, 5);
+            const outputaiFiles = files.slice(0, 6);
             outputaiFiles.forEach(file => {
                 expect(file).toMatch(/^\.outputai\//);
             });
@@ -67,11 +77,13 @@ describe('coding_agents service', () => {
                     '.outputai/AGENTS.md',
                     '.outputai/agents/workflow_planner.md',
                     '.outputai/commands/plan_workflow.md',
+                    '.outputai/commands/build_workflow.md',
                     '.outputai/meta/pre_flight.md',
                     '.outputai/meta/post_flight.md',
                     'CLAUDE.md',
                     '.claude/agents/workflow_planner.md',
-                    '.claude/commands/plan_workflow.md'
+                    '.claude/commands/plan_workflow.md',
+                    '.claude/commands/build_workflow.md'
                 ],
                 isComplete: false
             });
@@ -85,7 +97,7 @@ describe('coding_agents service', () => {
                 missingFiles: [],
                 isComplete: true
             });
-            expect(access).toHaveBeenCalledTimes(9); // dir + 5 outputai + 3 claude-code
+            expect(access).toHaveBeenCalledTimes(11); // dir + 6 outputai + 4 claude-code
         });
         it('should return missing files when some files do not exist', async () => {
             const calls = [];
@@ -108,23 +120,31 @@ describe('coding_agents service', () => {
                 if (callNum === 4) {
                     return undefined;
                 }
-                // Call 5: .outputai/meta/pre_flight.md exists
+                // Call 5: .outputai/commands/build_workflow.md exists
                 if (callNum === 5) {
                     return undefined;
                 }
-                // Call 6: .outputai/meta/post_flight.md exists
+                // Call 6: .outputai/meta/pre_flight.md exists
                 if (callNum === 6) {
                     return undefined;
                 }
-                // Call 7: CLAUDE.md exists
+                // Call 7: .outputai/meta/post_flight.md exists
                 if (callNum === 7) {
                     return undefined;
                 }
-                // Call 8: .claude/agents/workflow_planner.md missing
+                // Call 8: CLAUDE.md exists
                 if (callNum === 8) {
+                    return undefined;
+                }
+                // Call 9: .claude/agents/workflow_planner.md missing
+                if (callNum === 9) {
                     throw { code: 'ENOENT' };
                 }
-                // Call 9: .claude/commands/plan_workflow.md exists
+                // Call 10: .claude/commands/plan_workflow.md exists
+                if (callNum === 10) {
+                    return undefined;
+                }
+                // Call 11: .claude/commands/build_workflow.md exists
                 return undefined;
             });
             const result = await checkAgentStructure('/test/project');
@@ -143,11 +163,13 @@ describe('coding_agents service', () => {
                 .mockResolvedValueOnce(undefined) // .outputai/AGENTS.md
                 .mockRejectedValueOnce({ code: 'ENOENT' }) // .outputai/agents/workflow_planner.md
                 .mockRejectedValueOnce({ code: 'ENOENT' }) // .outputai/commands/plan_workflow.md
+                .mockResolvedValueOnce(undefined) // .outputai/commands/build_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
+                .mockRejectedValueOnce({ code: 'ENOENT' }) // .claude/commands/plan_workflow.md
+                .mockResolvedValueOnce(undefined); // .claude/commands/build_workflow.md
             const result = await checkAgentStructure('/test/project');
             expect(result.dirExists).toBe(true);
             expect(result.missingFiles).toEqual([
@@ -182,10 +204,10 @@ describe('coding_agents service', () => {
                 force: false,
                 agentProvider: 'claude-code'
             });
-            // Should create outputai files (3 templates)
+            // Should create outputai files (6 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);
+            // Should create symlinks (4 symlinks for claude-code)
+            expect(fs.symlink).toHaveBeenCalledTimes(4);
         });
         it('should skip existing files when force is false', async () => {
             // Mock some files exist
@@ -251,4 +273,123 @@ describe('coding_agents service', () => {
             expect(symlinkFallbackCalls.length).toBeGreaterThan(0);
         });
     });
+    describe('ensureOutputAIStructure', () => {
+        beforeEach(() => {
+            // Mock fs operations
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
+            vi.mocked(fs.readFile).mockResolvedValue('template content');
+            vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+            vi.mocked(fs.symlink).mockResolvedValue(undefined);
+        });
+        it('should return immediately when agent structure is complete', async () => {
+            // Mock complete structure
+            vi.mocked(access).mockResolvedValue(undefined);
+            await ensureOutputAIStructure('/test/project');
+            // Should not call init functions
+            expect(fs.mkdir).not.toHaveBeenCalled();
+            expect(fs.writeFile).not.toHaveBeenCalled();
+        });
+        it('should auto-initialize when directory does not exist', async () => {
+            // Mock directory doesn't exist
+            vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
+            await ensureOutputAIStructure('/test/project');
+            // Should call init functions to create structure
+            expect(fs.mkdir).toHaveBeenCalled();
+            expect(fs.writeFile).toHaveBeenCalled();
+        });
+        it('should prompt user when some files are missing', async () => {
+            const { confirm } = await import('@inquirer/prompts');
+            const { ux } = await import('@oclif/core');
+            // Mock directory exists but some files missing
+            const calls = [];
+            vi.mocked(access).mockImplementation(async () => {
+                const callNum = calls.length + 1;
+                calls.push(callNum);
+                if (callNum === 1) {
+                    return undefined; // Directory exists
+                }
+                if (callNum === 2) {
+                    return undefined; // First file exists
+                }
+                throw { code: 'ENOENT' }; // Rest are missing
+            });
+            vi.mocked(confirm).mockResolvedValue(true);
+            await ensureOutputAIStructure('/test/project');
+            // Should warn about missing files
+            expect(ux.warn).toHaveBeenCalledWith(expect.stringContaining('Agent configuration is incomplete'));
+            // Should prompt user
+            expect(confirm).toHaveBeenCalledWith({
+                message: 'Would you like to run "agents init --force" to recreate missing files?',
+                default: true
+            });
+            // Should reinitialize with force=true
+            expect(fs.writeFile).toHaveBeenCalled();
+        });
+        it('should throw error when user declines to reinitialize', async () => {
+            const { confirm } = await import('@inquirer/prompts');
+            // Mock directory exists but files missing
+            const calls = [];
+            vi.mocked(access).mockImplementation(async () => {
+                const callNum = calls.length + 1;
+                calls.push(callNum);
+                if (callNum === 1) {
+                    return undefined; // Directory exists
+                }
+                throw { code: 'ENOENT' }; // Files are missing
+            });
+            vi.mocked(confirm).mockResolvedValue(false);
+            await expect(ensureOutputAIStructure('/test/project')).rejects.toThrow('Agent configuration incomplete');
+            // Should not call init functions
+            expect(fs.mkdir).not.toHaveBeenCalled();
+            expect(fs.writeFile).not.toHaveBeenCalled();
+        });
+        it('should list all missing files in error message when user declines', async () => {
+            const { confirm } = await import('@inquirer/prompts');
+            // Mock directory exists but all files missing
+            const calls = [];
+            vi.mocked(access).mockImplementation(async () => {
+                const callNum = calls.length + 1;
+                calls.push(callNum);
+                if (callNum === 1) {
+                    return undefined; // Directory exists
+                }
+                throw { code: 'ENOENT' }; // All files missing
+            });
+            vi.mocked(confirm).mockResolvedValue(false);
+            try {
+                await ensureOutputAIStructure('/test/project');
+                expect.fail('Should have thrown an error');
+            }
+            catch (error) {
+                const message = error.message;
+                expect(message).toContain('.outputai/AGENTS.md');
+                expect(message).toContain('.outputai/agents/workflow_planner.md');
+                expect(message).toContain('Run "output-cli agents init --force"');
+            }
+        });
+        it('should call initializeAgentConfig with force=false when dir does not exist', async () => {
+            vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
+            await ensureOutputAIStructure('/test/project');
+            // Should have called mkdir (part of init with force=false)
+            expect(fs.mkdir).toHaveBeenCalled();
+        });
+        it('should call initializeAgentConfig with force=true after user confirmation', async () => {
+            const { confirm } = await import('@inquirer/prompts');
+            // Mock directory exists but files missing
+            const calls = [];
+            vi.mocked(access).mockImplementation(async () => {
+                const callNum = calls.length + 1;
+                calls.push(callNum);
+                if (callNum === 1) {
+                    return undefined; // Directory exists
+                }
+                throw { code: 'ENOENT' }; // Files missing
+            });
+            vi.mocked(confirm).mockResolvedValue(true);
+            await ensureOutputAIStructure('/test/project');
+            // Should have called writeFile (part of init with force=true)
+            expect(fs.writeFile).toHaveBeenCalled();
+        });
+    });
 });

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_builder.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Build a workflow from a plan file using the /build_workflow slash command
+ * @param planFilePath - Absolute path to the plan file
+ * @param workflowDir - Absolute path to the workflow directory
+ * @param workflowName - Name of the workflow
+ * @param additionalInstructions - Optional additional instructions
+ * @returns Implementation output from claude-code
+ */
+export declare function buildWorkflow(planFilePath: string, workflowDir: string, workflowName: string, additionalInstructions?: string): Promise<string>;
+/**
+ * Interactive loop for refining workflow implementation
+ * Similar to the plan modification loop pattern
+ * @param originalOutput - Initial implementation output from claude-code
+ * @returns Final accepted output
+ */
+export declare function buildWorkflowInteractiveLoop(originalOutput: string): Promise<string>;

package/dist/services/workflow_builder.js

@@ -0,0 +1,85 @@
+/**
+ * Workflow builder service for implementing workflows from plan files
+ */
+import { BUILD_COMMAND_OPTIONS, invokeBuildWorkflow as invokeBuildWorkflowFromClient, replyToClaude } from './claude_client.js';
+import { input } from '@inquirer/prompts';
+import { ux } from '@oclif/core';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+const ACCEPT_KEY = 'ACCEPT';
+const SEPARATOR_LINE = '─'.repeat(80);
+function displayImplementationOutput(output, message) {
+    ux.stdout('\n');
+    ux.stdout(ux.colorize('green', message));
+    ux.stdout('\n');
+    ux.stdout(ux.colorize('dim', SEPARATOR_LINE));
+    ux.stdout(output);
+    ux.stdout(ux.colorize('dim', SEPARATOR_LINE));
+    ux.stdout('\n');
+}
+async function promptForModification() {
+    return input({
+        message: `Review the implementation. Type "${ACCEPT_KEY}" to accept, or describe modifications:`,
+        default: ACCEPT_KEY
+    });
+}
+function isAcceptCommand(modification) {
+    return modification.trim().toUpperCase() === ACCEPT_KEY;
+}
+function isEmpty(modification) {
+    return modification.trim() === '';
+}
+/**
+ * Build a workflow from a plan file using the /build_workflow slash command
+ * @param planFilePath - Absolute path to the plan file
+ * @param workflowDir - Absolute path to the workflow directory
+ * @param workflowName - Name of the workflow
+ * @param additionalInstructions - Optional additional instructions
+ * @returns Implementation output from claude-code
+ */
+export async function buildWorkflow(planFilePath, workflowDir, workflowName, additionalInstructions) {
+    try {
+        await fs.access(planFilePath);
+    }
+    catch {
+        throw new Error(`Plan file not found: ${planFilePath}`);
+    }
+    await fs.mkdir(workflowDir, { recursive: true });
+    const absolutePlanPath = path.resolve(planFilePath);
+    const absoluteWorkflowDir = path.resolve(workflowDir);
+    return invokeBuildWorkflowFromClient(absolutePlanPath, absoluteWorkflowDir, workflowName, additionalInstructions);
+}
+async function processModification(modification, currentOutput) {
+    if (isEmpty(modification)) {
+        ux.stdout(ux.colorize('yellow', 'Please provide modification instructions or type ACCEPT to continue.'));
+        return currentOutput;
+    }
+    try {
+        const updatedOutput = await replyToClaude(modification, BUILD_COMMAND_OPTIONS);
+        displayImplementationOutput(updatedOutput, '✓ Implementation updated!');
+        return updatedOutput;
+    }
+    catch (error) {
+        ux.error(`Failed to apply modifications: ${error.message}`);
+        ux.stdout('Continuing with previous version...\n');
+        return currentOutput;
+    }
+}
+async function interactiveRefinementLoop(currentOutput) {
+    const modification = await promptForModification();
+    if (isAcceptCommand(modification)) {
+        return currentOutput;
+    }
+    const updatedOutput = await processModification(modification, currentOutput);
+    return interactiveRefinementLoop(updatedOutput);
+}
+/**
+ * Interactive loop for refining workflow implementation
+ * Similar to the plan modification loop pattern
+ * @param originalOutput - Initial implementation output from claude-code
+ * @returns Final accepted output
+ */
+export async function buildWorkflowInteractiveLoop(originalOutput) {
+    displayImplementationOutput(originalOutput, '✓ Workflow implementation complete!');
+    return interactiveRefinementLoop(originalOutput);
+}

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

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

package/dist/services/workflow_builder.spec.js

@@ -0,0 +1,165 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { buildWorkflow, buildWorkflowInteractiveLoop } from './workflow_builder.js';
+import { BUILD_COMMAND_OPTIONS, invokeBuildWorkflow, replyToClaude } from './claude_client.js';
+import { input } from '@inquirer/prompts';
+import { ux } from '@oclif/core';
+import fs from 'node:fs/promises';
+vi.mock('./claude_client.js');
+vi.mock('@inquirer/prompts');
+vi.mock('@oclif/core', () => ({
+    ux: {
+        stdout: vi.fn(),
+        error: vi.fn(),
+        colorize: vi.fn((_color, text) => text)
+    }
+}));
+vi.mock('node:fs/promises');
+describe('workflow-builder service', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('buildWorkflow', () => {
+        it('should build workflow from plan file', async () => {
+            vi.mocked(fs.access).mockResolvedValue(undefined);
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(invokeBuildWorkflow).mockResolvedValue('Implementation complete!');
+            const result = await buildWorkflow('/path/to/plan.md', '/path/to/workflows/test_workflow', 'test_workflow');
+            expect(fs.access).toHaveBeenCalledWith('/path/to/plan.md');
+            expect(fs.mkdir).toHaveBeenCalledWith(expect.stringContaining('test_workflow'), { recursive: true });
+            expect(invokeBuildWorkflow).toHaveBeenCalledWith(expect.stringContaining('plan.md'), expect.stringContaining('test_workflow'), 'test_workflow', undefined);
+            expect(result).toBe('Implementation complete!');
+        });
+        it('should pass additional instructions to claude-code', async () => {
+            vi.mocked(fs.access).mockResolvedValue(undefined);
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(invokeBuildWorkflow).mockResolvedValue('Done!');
+            await buildWorkflow('/plan.md', '/workflows', 'test', 'Use TypeScript only');
+            expect(invokeBuildWorkflow).toHaveBeenCalledWith(expect.any(String), expect.any(String), 'test', 'Use TypeScript only');
+        });
+        it('should throw error if plan file does not exist', async () => {
+            vi.mocked(fs.access).mockRejectedValue(new Error('ENOENT'));
+            await expect(buildWorkflow('/nonexistent/plan.md', '/workflows', 'test')).rejects.toThrow('Plan file not found: /nonexistent/plan.md');
+            expect(fs.mkdir).not.toHaveBeenCalled();
+            expect(invokeBuildWorkflow).not.toHaveBeenCalled();
+        });
+        it('should create workflow directory if it does not exist', async () => {
+            vi.mocked(fs.access).mockResolvedValue(undefined);
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(invokeBuildWorkflow).mockResolvedValue('Done');
+            await buildWorkflow('/plan.md', '/new/workflows/test', 'test');
+            expect(fs.mkdir).toHaveBeenCalledWith(expect.stringContaining('test'), { recursive: true });
+        });
+        it('should resolve paths to absolute paths', async () => {
+            vi.mocked(fs.access).mockResolvedValue(undefined);
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(invokeBuildWorkflow).mockResolvedValue('Done');
+            await buildWorkflow('relative/plan.md', 'relative/workflows', 'test');
+            // Should call with absolute paths
+            const calls = vi.mocked(invokeBuildWorkflow).mock.calls[0];
+            expect(calls[0]).toMatch(/^[/\\]/); // Absolute path starts with / or \
+            expect(calls[1]).toMatch(/^[/\\]/); // Absolute path starts with / or \
+        });
+        it('should propagate errors from claude-code invocation', async () => {
+            vi.mocked(fs.access).mockResolvedValue(undefined);
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(invokeBuildWorkflow).mockRejectedValue(new Error('Claude API timeout'));
+            await expect(buildWorkflow('/plan.md', '/workflows', 'test')).rejects.toThrow('Claude API timeout');
+        });
+        it('should handle directory creation failures', async () => {
+            vi.mocked(fs.access).mockResolvedValue(undefined);
+            vi.mocked(fs.mkdir).mockRejectedValue(new Error('Permission denied'));
+            await expect(buildWorkflow('/plan.md', '/workflows', 'test')).rejects.toThrow('Permission denied');
+        });
+    });
+    describe('buildWorkflowInteractiveLoop', () => {
+        it('should accept implementation immediately when user types ACCEPT', async () => {
+            vi.mocked(input).mockResolvedValue('ACCEPT');
+            const result = await buildWorkflowInteractiveLoop('Initial implementation');
+            expect(result).toBe('Initial implementation');
+            expect(input).toHaveBeenCalledOnce();
+            expect(replyToClaude).not.toHaveBeenCalled();
+        });
+        it('should accept implementation when user types lowercase accept', async () => {
+            vi.mocked(input).mockResolvedValue('accept');
+            const result = await buildWorkflowInteractiveLoop('Initial implementation');
+            expect(result).toBe('Initial implementation');
+            expect(replyToClaude).not.toHaveBeenCalled();
+        });
+        it('should accept implementation with extra whitespace', async () => {
+            vi.mocked(input).mockResolvedValue('  ACCEPT  ');
+            const result = await buildWorkflowInteractiveLoop('Initial implementation');
+            expect(result).toBe('Initial implementation');
+            expect(replyToClaude).not.toHaveBeenCalled();
+        });
+        it('should apply modifications and return updated implementation', async () => {
+            vi.mocked(input)
+                .mockResolvedValueOnce('Add error handling')
+                .mockResolvedValueOnce('ACCEPT');
+            vi.mocked(replyToClaude).mockResolvedValue('Updated implementation with error handling');
+            const result = await buildWorkflowInteractiveLoop('Initial implementation');
+            expect(replyToClaude).toHaveBeenCalledWith('Add error handling', BUILD_COMMAND_OPTIONS);
+            expect(result).toBe('Updated implementation with error handling');
+            expect(input).toHaveBeenCalledTimes(2);
+        });
+        it('should handle multiple modification rounds', async () => {
+            vi.mocked(input)
+                .mockResolvedValueOnce('Add logging')
+                .mockResolvedValueOnce('Add validation')
+                .mockResolvedValueOnce('ACCEPT');
+            vi.mocked(replyToClaude)
+                .mockResolvedValueOnce('Implementation with logging')
+                .mockResolvedValueOnce('Implementation with logging and validation');
+            const result = await buildWorkflowInteractiveLoop('Initial implementation');
+            expect(replyToClaude).toHaveBeenCalledTimes(2);
+            expect(replyToClaude).toHaveBeenNthCalledWith(1, 'Add logging', BUILD_COMMAND_OPTIONS);
+            expect(replyToClaude).toHaveBeenNthCalledWith(2, 'Add validation', BUILD_COMMAND_OPTIONS);
+            expect(result).toBe('Implementation with logging and validation');
+        });
+        it('should prompt again when user provides empty input', async () => {
+            vi.mocked(input)
+                .mockResolvedValueOnce('')
+                .mockResolvedValueOnce('  ')
+                .mockResolvedValueOnce('ACCEPT');
+            const result = await buildWorkflowInteractiveLoop('Initial implementation');
+            expect(result).toBe('Initial implementation');
+            expect(input).toHaveBeenCalledTimes(3);
+            expect(ux.stdout).toHaveBeenCalledWith(expect.stringContaining('provide modification instructions'));
+        });
+        it('should display implementation output to user', async () => {
+            vi.mocked(input).mockResolvedValue('ACCEPT');
+            await buildWorkflowInteractiveLoop('Implementation summary');
+            expect(ux.stdout).toHaveBeenCalledWith(expect.stringContaining('Implementation summary'));
+        });
+        it('should display updated implementation after modifications', async () => {
+            vi.mocked(input)
+                .mockResolvedValueOnce('Improve performance')
+                .mockResolvedValueOnce('ACCEPT');
+            vi.mocked(replyToClaude).mockResolvedValue('Optimized implementation');
+            await buildWorkflowInteractiveLoop('Initial');
+            expect(ux.stdout).toHaveBeenCalledWith(expect.stringContaining('Optimized implementation'));
+        });
+        it('should handle errors from replyToClaude gracefully', async () => {
+            vi.mocked(input)
+                .mockResolvedValueOnce('Invalid modification')
+                .mockResolvedValueOnce('ACCEPT');
+            vi.mocked(replyToClaude).mockRejectedValue(new Error('API error'));
+            const result = await buildWorkflowInteractiveLoop('Original implementation');
+            // Should return original implementation after error
+            expect(result).toBe('Original implementation');
+            expect(ux.error).toHaveBeenCalledWith(expect.stringContaining('Failed to apply modifications'));
+            expect(ux.stdout).toHaveBeenCalledWith(expect.stringContaining('Continuing with previous version'));
+        });
+        it('should continue looping after handling error', async () => {
+            vi.mocked(input)
+                .mockResolvedValueOnce('Bad request')
+                .mockResolvedValueOnce('Good request')
+                .mockResolvedValueOnce('ACCEPT');
+            vi.mocked(replyToClaude)
+                .mockRejectedValueOnce(new Error('API error'))
+                .mockResolvedValueOnce('Fixed implementation');
+            const result = await buildWorkflowInteractiveLoop('Initial');
+            expect(result).toBe('Fixed implementation');
+            expect(replyToClaude).toHaveBeenCalledTimes(2);
+        });
+    });
+});

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
  */