@output.ai/cli 0.0.4 → 0.0.5

package/dist/commands/workflow/plan.spec.js

@@ -0,0 +1,339 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import WorkflowPlan from './plan.js';
+import { ensureOutputAIStructure, generatePlanName, writePlanFile, updateAgentTemplates } from '../../services/workflow_planner.js';
+import { invokePlanWorkflow, replyToClaude, ClaudeInvocationError } from '../../services/claude_client.js';
+import { input } from '@inquirer/prompts';
+vi.mock('../../services/workflow_planner.js');
+vi.mock('../../services/claude_client.js');
+vi.mock('@inquirer/prompts');
+describe('WorkflowPlan Command', () => {
+    const createCommand = () => {
+        const cmd = new WorkflowPlan([], {});
+        cmd.log = vi.fn();
+        cmd.warn = vi.fn();
+        cmd.error = vi.fn();
+        const mockedCmd = cmd;
+        mockedCmd.parse = vi.fn();
+        return mockedCmd;
+    };
+    const setupSuccessfulMocks = (description, planName, planContent) => {
+        // Mock input to return description first, then 'ACCEPT' to stop the modification loop
+        const state = { inputCallCount: 0 };
+        vi.mocked(input).mockImplementation((async () => {
+            state.inputCallCount++;
+            if (state.inputCallCount === 1) {
+                return description;
+            }
+            return 'ACCEPT'; // Always accept on second call to stop recursion
+        }));
+        vi.mocked(ensureOutputAIStructure).mockResolvedValue();
+        vi.mocked(generatePlanName).mockResolvedValue(planName);
+        vi.mocked(invokePlanWorkflow).mockResolvedValue(planContent);
+        vi.mocked(replyToClaude).mockResolvedValue(planContent);
+        vi.mocked(writePlanFile).mockResolvedValue(`/project/.outputai/plans/${planName}/PLAN.md`);
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('command metadata', () => {
+        it('should have correct description', () => {
+            expect(WorkflowPlan.description).toBeDefined();
+            expect(WorkflowPlan.description).toContain('workflow');
+            expect(WorkflowPlan.description).toContain('plan');
+        });
+        it('should have examples', () => {
+            expect(WorkflowPlan.examples).toBeDefined();
+            expect(Array.isArray(WorkflowPlan.examples)).toBe(true);
+            expect(WorkflowPlan.examples.length).toBeGreaterThan(0);
+        });
+        it('should define force-agent-file-write flag', () => {
+            expect(WorkflowPlan.flags).toBeDefined();
+            expect(WorkflowPlan.flags['force-agent-file-write']).toBeDefined();
+            expect(WorkflowPlan.flags['force-agent-file-write'].type).toBe('boolean');
+        });
+        it('should have force flag default to false', () => {
+            expect(WorkflowPlan.flags['force-agent-file-write'].default).toBe(false);
+        });
+    });
+    describe('successful execution flow', () => {
+        it('should execute complete workflow', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            setupSuccessfulMocks('Build a user authentication system', '2025_10_06_user_authentication', '# Workflow Plan\n\nPlan content here');
+            await command.run();
+            expect(ensureOutputAIStructure).toHaveBeenCalled();
+            expect(generatePlanName).toHaveBeenCalledWith('Build a user authentication system');
+            expect(invokePlanWorkflow).toHaveBeenCalledWith('Build a user authentication system');
+            expect(writePlanFile).toHaveBeenCalledWith('2025_10_06_user_authentication', '# Workflow Plan\n\nPlan content here', expect.any(String));
+        });
+        it('should update templates when force flag is true', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': true }
+            });
+            setupSuccessfulMocks('Test workflow description', '2025_10_06_test', '# Plan');
+            vi.mocked(updateAgentTemplates).mockResolvedValue();
+            await command.run();
+            expect(updateAgentTemplates).toHaveBeenCalled();
+        });
+    });
+    describe('user input validation', () => {
+        it('should validate description is at least 10 characters', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            const state = { callCount: 0 };
+            const inputMock = vi.fn().mockImplementation(async (config) => {
+                state.callCount++;
+                if (state.callCount === 1 && config.validate) {
+                    const shortResult = config.validate('short');
+                    expect(shortResult).toBe(false);
+                    const validResult = config.validate('This is a valid description');
+                    expect(validResult).toBe(true);
+                    return 'Valid description here';
+                }
+                return 'ACCEPT'; // Second call from modification loop
+            });
+            vi.mocked(input).mockImplementation(inputMock);
+            vi.mocked(ensureOutputAIStructure).mockResolvedValue();
+            vi.mocked(generatePlanName).mockResolvedValue('2025_10_06_test');
+            vi.mocked(invokePlanWorkflow).mockResolvedValue('# Plan');
+            vi.mocked(replyToClaude).mockResolvedValue('# Plan');
+            vi.mocked(writePlanFile).mockResolvedValue('/test/PLAN.md');
+            await command.run();
+            expect(inputMock).toHaveBeenCalled();
+        });
+    });
+    describe('error handling', () => {
+        it('should handle missing ANTHROPIC_API_KEY', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            vi.mocked(ensureOutputAIStructure).mockResolvedValue();
+            vi.mocked(input).mockResolvedValue('Test workflow');
+            vi.mocked(generatePlanName).mockResolvedValue('2025_10_06_test');
+            vi.mocked(invokePlanWorkflow).mockRejectedValue(new Error('ANTHROPIC_API_KEY environment variable is required'));
+            await expect(command.run()).rejects.toThrow(/ANTHROPIC_API_KEY/i);
+        });
+        it('should handle Claude SDK errors gracefully', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            vi.mocked(ensureOutputAIStructure).mockResolvedValue();
+            vi.mocked(input).mockResolvedValue('Test workflow');
+            vi.mocked(generatePlanName).mockResolvedValue('2025_10_06_test');
+            const claudeError = new ClaudeInvocationError('Failed to invoke claude-code: API error');
+            vi.mocked(invokePlanWorkflow).mockRejectedValue(claudeError);
+            try {
+                await command.run();
+                expect.fail('Should have thrown an error');
+            }
+            catch (error) {
+                expect(error).toBe(claudeError);
+            }
+        });
+        it('should handle file system errors', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            const state = { inputCallCount: 0 };
+            vi.mocked(input).mockImplementation((async () => {
+                state.inputCallCount++;
+                return state.inputCallCount === 1 ? 'Test workflow' : 'ACCEPT';
+            }));
+            vi.mocked(ensureOutputAIStructure).mockResolvedValue();
+            vi.mocked(generatePlanName).mockResolvedValue('2025_10_06_test');
+            vi.mocked(invokePlanWorkflow).mockResolvedValue('# Plan');
+            vi.mocked(replyToClaude).mockResolvedValue('# Plan');
+            const fsError = new Error('Permission denied');
+            fsError.code = 'EACCES';
+            vi.mocked(writePlanFile).mockRejectedValue(fsError);
+            await expect(command.run()).rejects.toThrow(/Permission denied/i);
+        });
+    });
+    describe('plan display', () => {
+        it('should display plan content to user', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            const planContent = '# Workflow Plan\n\nDetailed plan content';
+            setupSuccessfulMocks('Test workflow', '2025_10_06_test', planContent);
+            await command.run();
+            expect(command.log).toHaveBeenCalledWith(expect.stringContaining(planContent));
+        });
+    });
+    describe('E2E workflow execution', () => {
+        it('should execute complete workflow with template variable injection', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            const description = 'Build a user authentication workflow';
+            const planName = '2025_10_06_user_authentication';
+            const planContent = '# Workflow Plan: UserAuthentication\n\n' +
+                '> Generated: 2025_10_06_user_authentication\n' +
+                '> Description: Build a user authentication workflow';
+            setupSuccessfulMocks(description, planName, planContent);
+            await command.run();
+            // Verify workflow planner receives correct description
+            expect(invokePlanWorkflow).toHaveBeenCalledWith(description);
+            // Verify plan name generation
+            expect(generatePlanName).toHaveBeenCalledWith(description);
+            // Verify plan file creation with correct parameters
+            expect(writePlanFile).toHaveBeenCalledWith(planName, expect.stringContaining('2025_10_06_user_authentication'), expect.any(String));
+            // Verify user sees success message
+            expect(command.log).toHaveBeenCalledWith(expect.stringContaining('✅'));
+        });
+        it('should handle complex workflow descriptions', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            const complexDescription = 'Build a multi-step data processing workflow with validation, transformation, and error handling';
+            setupSuccessfulMocks(complexDescription, '2025_10_06_data_processing', '# Workflow Plan\n\nComplex plan content');
+            await command.run();
+            expect(invokePlanWorkflow).toHaveBeenCalledWith(complexDescription);
+            expect(generatePlanName).toHaveBeenCalledWith(complexDescription);
+        });
+        it('should verify plan output path matches expected format', async () => {
+            const command = createCommand();
+            const planName = '2025_10_06_test_workflow';
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            setupSuccessfulMocks('Test workflow', planName, '# Plan');
+            await command.run();
+            const writePlanFileCall = vi.mocked(writePlanFile).mock.calls[0];
+            expect(writePlanFileCall[0]).toBe(planName);
+            expect(writePlanFileCall[2]).toMatch(/\/.*$/); // Should be absolute path
+        });
+    });
+    describe('edge cases and error scenarios', () => {
+        it('should handle empty plan content gracefully', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            setupSuccessfulMocks('Test workflow', '2025_10_06_test', '');
+            await command.run();
+            expect(writePlanFile).toHaveBeenCalledWith('2025_10_06_test', '', expect.any(String));
+        });
+        it('should handle network timeout errors', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            vi.mocked(ensureOutputAIStructure).mockResolvedValue();
+            vi.mocked(input).mockResolvedValue('Test workflow');
+            vi.mocked(generatePlanName).mockResolvedValue('2025_10_06_test');
+            const timeoutError = new Error('Request timeout');
+            timeoutError.name = 'TimeoutError';
+            vi.mocked(invokePlanWorkflow).mockRejectedValue(timeoutError);
+            await expect(command.run()).rejects.toThrow(/timeout/i);
+        });
+        it('should handle rate limit errors', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            vi.mocked(ensureOutputAIStructure).mockResolvedValue();
+            vi.mocked(input).mockResolvedValue('Test workflow');
+            vi.mocked(generatePlanName).mockResolvedValue('2025_10_06_test');
+            const rateLimitError = new ClaudeInvocationError('Rate limit exceeded');
+            vi.mocked(invokePlanWorkflow).mockRejectedValue(rateLimitError);
+            await expect(command.run()).rejects.toThrow(ClaudeInvocationError);
+        });
+        it('should handle disk full errors when writing plan file', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            const state = { inputCallCount: 0 };
+            vi.mocked(input).mockImplementation((async () => {
+                state.inputCallCount++;
+                return state.inputCallCount === 1 ? 'Test workflow' : 'ACCEPT';
+            }));
+            vi.mocked(ensureOutputAIStructure).mockResolvedValue();
+            vi.mocked(generatePlanName).mockResolvedValue('2025_10_06_test');
+            vi.mocked(invokePlanWorkflow).mockResolvedValue('# Plan');
+            vi.mocked(replyToClaude).mockResolvedValue('# Plan');
+            const diskFullError = new Error('No space left on device');
+            diskFullError.code = 'ENOSPC';
+            vi.mocked(writePlanFile).mockRejectedValue(diskFullError);
+            await expect(command.run()).rejects.toThrow(/space/i);
+        });
+        it('should handle directory creation race conditions', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            // First call fails with ENOENT, second succeeds
+            vi.mocked(ensureOutputAIStructure).mockRejectedValueOnce(Object.assign(new Error('Directory does not exist'), { code: 'ENOENT' }));
+            await expect(command.run()).rejects.toThrow();
+        });
+        it('should handle malformed API responses', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            vi.mocked(ensureOutputAIStructure).mockResolvedValue();
+            vi.mocked(input).mockResolvedValue('Test workflow');
+            vi.mocked(generatePlanName).mockResolvedValue('2025_10_06_test');
+            const malformedError = new ClaudeInvocationError('Invalid JSON response');
+            vi.mocked(invokePlanWorkflow).mockRejectedValue(malformedError);
+            await expect(command.run()).rejects.toThrow(ClaudeInvocationError);
+        });
+    });
+    describe('template integration', () => {
+        it('should ensure agent templates are current when force flag is set', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': true }
+            });
+            setupSuccessfulMocks('Test workflow', '2025_10_06_test', '# Plan');
+            vi.mocked(updateAgentTemplates).mockResolvedValue();
+            await command.run();
+            // Verify templates are updated before plan generation
+            const ensureCall = vi.mocked(ensureOutputAIStructure).mock.invocationCallOrder[0];
+            const updateCall = vi.mocked(updateAgentTemplates).mock.invocationCallOrder[0];
+            expect(updateCall).toBeGreaterThan(ensureCall);
+        });
+        it('should not update templates when force flag is false', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            setupSuccessfulMocks('Test workflow', '2025_10_06_test', '# Plan');
+            await command.run();
+            expect(updateAgentTemplates).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/config.d.ts

@@ -17,3 +17,7 @@ export declare const config: {
      */
     requestTimeout: number;
 };
+/**
+ * Agent configuration directory name
+ */
+export declare const AGENT_CONFIG_DIR = ".outputai";

package/dist/config.js

@@ -17,3 +17,7 @@ export const config = {
      */
     requestTimeout: 30000
 };
+/**
+ * Agent configuration directory name
+ */
+export const AGENT_CONFIG_DIR = '.outputai';

package/dist/services/claude_client.d.ts

@@ -0,0 +1,13 @@
+export declare class ClaudeInvocationError extends Error {
+    cause?: Error | undefined;
+    constructor(message: string, cause?: Error | undefined);
+}
+export declare function replyToClaude(message: string): Promise<string>;
+/**
+ * Invoke claude-code with /plan_workflow slash command
+ * The SDK loads custom commands from .claude/commands/ when settingSources includes 'project'.
+ * ensureOutputAIStructure() scaffolds the command files to that location.
+ * @param description - Workflow description
+ * @returns Plan output from claude-code
+ */
+export declare function invokePlanWorkflow(description: string): Promise<string>;

package/dist/services/claude_client.integration.test.d.ts

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

package/dist/services/claude_client.integration.test.js

@@ -0,0 +1,43 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { invokePlanWorkflow } from './claude_client.js';
+import { query } from '@anthropic-ai/claude-agent-sdk';
+describe('invokePlanWorkflow - Integration Tests', () => {
+    beforeEach(() => {
+        // Ensure API key is set
+        if (!process.env.ANTHROPIC_API_KEY) {
+            throw new Error('ANTHROPIC_API_KEY must be set for integration tests');
+        }
+    });
+    it('should debug actual message format from Claude Agent SDK', async () => {
+        const description = 'Simple test workflow that takes a number and returns it doubled';
+        console.log('\n===== DEBUGGING ACTUAL MESSAGE FORMAT =====');
+        console.log('Description:', description);
+        const messages = [];
+        try {
+            for await (const message of query({
+                prompt: `/plan_workflow ${description}`,
+                options: { maxTurns: 1 }
+            })) {
+                console.log('\nReceived message:', JSON.stringify(message, null, 2));
+                messages.push(message);
+            }
+        }
+        catch (error) {
+            console.error('Error during query:', error);
+            throw error;
+        }
+        console.log(`\nTotal messages received: ${messages.length}`);
+        console.log('===== END DEBUG =====');
+        // This test is just for debugging - we expect messages
+        expect(messages.length).toBeGreaterThan(0);
+    }, 60000); // 60 second timeout
+    it('should successfully invoke /plan_workflow slash command and return content', async () => {
+        const description = 'Simple workflow that takes a number and doubles it';
+        const result = await invokePlanWorkflow(description);
+        console.log('\n===== PLAN RESULT =====');
+        console.log(result);
+        console.log('===== END RESULT =====');
+        expect(result).toBeTruthy();
+        expect(result.length).toBeGreaterThan(0);
+    }, 60000); // 60 second timeout
+});

package/dist/services/claude_client.js

@@ -0,0 +1,124 @@
+/**
+ * Claude Agent SDK client for workflow planning
+ */
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { ux } from '@oclif/core';
+import ora from 'ora';
+const ADDITIONAL_INSTRUCTIONS = `
+! IMPORTANT !
+1. Use TodoWrite to track your progress through plan creation.
+
+2. Please response with only the final version of the plan.
+
+3. Response in a markdown format with these metadata headers:
+
+---
+title: <plan-title>
+description: <plan-description>
+date: <plan-date>
+---
+
+<plan-content>
+
+4. After you mark all todos as complete, you must respond with the final version of the plan.
+`;
+const PLAN_COMMAND = 'plan_workflow';
+const GLOBAL_CLAUDE_OPTIONS = {
+    settingSources: ['user', 'project', 'local'],
+    allowedTools: [
+        'Read',
+        'Grep',
+        'WebSearch',
+        'WebFetch',
+        'TodoWrite'
+    ]
+};
+export class ClaudeInvocationError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = 'ClaudeInvocationError';
+    }
+}
+function validateEnvironment() {
+    if (!process.env.ANTHROPIC_API_KEY) {
+        throw new Error('ANTHROPIC_API_KEY environment variable is required');
+    }
+}
+function validateSystem(systemMessage) {
+    const requiredCommands = [PLAN_COMMAND];
+    const availableCommands = systemMessage.slash_commands;
+    const missingCommands = requiredCommands.filter(command => !availableCommands.includes(command));
+    for (const command of missingCommands) {
+        ux.warn(`Missing required claude-code slash command: /${command}`);
+    }
+    if (missingCommands.length > 0) {
+        ux.warn('Your claude-code agent is missing key configurations, it may not behave as expected.');
+        ux.warn('Please run "output-cli agents init" to fix this.');
+    }
+}
+function applyDefaultOptions(options) {
+    return {
+        ...GLOBAL_CLAUDE_OPTIONS,
+        ...options
+    };
+}
+function getTodoWriteMessage(message) {
+    if (message.type !== 'assistant') {
+        return null;
+    }
+    const todoWriteMessage = message.message.content.find((c) => c?.type === 'tool_use' && c.name === 'TodoWrite');
+    return todoWriteMessage ?? null;
+}
+function getInProgressTodo(message) {
+    const todoWriteMessage = getTodoWriteMessage(message);
+    if (!todoWriteMessage) {
+        return null;
+    }
+    const inProgressTodo = todoWriteMessage.input.todos.find(t => t.status === 'in_progress');
+    return inProgressTodo?.content ?? null;
+}
+function applyInstructions(initialMessage) {
+    return `${initialMessage}\n\n${ADDITIONAL_INSTRUCTIONS}`;
+}
+async function singleQuery(prompt, options = {}) {
+    validateEnvironment();
+    const spinner = ora('Thinking...').start();
+    try {
+        for await (const message of query({
+            prompt,
+            options: applyDefaultOptions(options)
+        })) {
+            if (message.type === 'system' && message.subtype === 'init') {
+                validateSystem(message);
+                spinner.text = 'Diving in...';
+            }
+            const inProgressTodo = getInProgressTodo(message);
+            if (inProgressTodo) {
+                spinner.text = `${inProgressTodo}...`;
+            }
+            if (message.type === 'result' && message.subtype === 'success') {
+                spinner.stop();
+                return message.result;
+            }
+        }
+        throw new Error('No output received from claude-code');
+    }
+    catch (error) {
+        throw new ClaudeInvocationError(`Failed to invoke claude-code: ${error.message}`, error);
+    }
+}
+export async function replyToClaude(message) {
+    return singleQuery(applyInstructions(message), { continue: true });
+}
+/**
+ * Invoke claude-code with /plan_workflow slash command
+ * The SDK loads custom commands from .claude/commands/ when settingSources includes 'project'.
+ * ensureOutputAIStructure() scaffolds the command files to that location.
+ * @param description - Workflow description
+ * @returns Plan output from claude-code
+ */
+export async function invokePlanWorkflow(description) {
+    return singleQuery(applyInstructions(`/${PLAN_COMMAND} ${description}`));
+}

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

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