@output.ai/cli 0.3.1-dev.pr156.0 → 0.4.1

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

@@ -0,0 +1,36 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// Mock the TraceReader service
+vi.mock('../../services/trace_reader.js', () => ({
+    findTraceFile: vi.fn(),
+    readTraceFile: vi.fn(),
+    getTrace: vi.fn()
+}));
+// Mock the utilities
+vi.mock('../../utils/trace_formatter.js', () => ({
+    displayDebugTree: vi.fn()
+}));
+describe('workflow debug command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('command definition', () => {
+        it('should export a valid OCLIF command', async () => {
+            const WorkflowDebug = (await import('./debug.js')).default;
+            expect(WorkflowDebug).toBeDefined();
+            expect(WorkflowDebug.description).toContain('Get and display workflow execution trace for debugging');
+            expect(WorkflowDebug.args).toHaveProperty('workflowId');
+            expect(WorkflowDebug.flags).toHaveProperty('format');
+        });
+        it('should have correct flag configuration', async () => {
+            const WorkflowDebug = (await import('./debug.js')).default;
+            // Format flag
+            expect(WorkflowDebug.flags.format.options).toEqual(['json', 'text']);
+            expect(WorkflowDebug.flags.format.default).toBe('text');
+        });
+        it('should have correct examples', async () => {
+            const WorkflowDebug = (await import('./debug.js')).default;
+            expect(WorkflowDebug.examples).toBeDefined();
+            expect(WorkflowDebug.examples.length).toBeGreaterThan(0);
+        });
+    });
+});

package/dist/commands/workflow/generate.js

@@ -2,6 +2,7 @@ import { Args, Command, Flags, ux } from '@oclif/core';
 import { generateWorkflow } from '#services/workflow_generator.js';
 import { buildWorkflow, buildWorkflowInteractiveLoop } from '#services/workflow_builder.js';
 import { ensureOutputAIStructure } from '#services/coding_agents.js';
+import { getWorkflowGenerateSuccessMessage } from '#services/messages.js';
 import { DEFAULT_OUTPUT_DIRS } from '#utils/paths.js';
 import path from 'node:path';
 export default class Generate extends Command {
@@ -78,15 +79,7 @@ export default class Generate extends Command {
         }
     }
     displaySuccess(result) {
-        this.log(`\n[SUCCESS] Workflow "${result.workflowName}" created successfully!`);
-        this.log(`\nLocation: ${result.targetDir}`);
-        this.log('\n-- Next steps --');
-        this.log(`   1. cd ${result.targetDir}`);
-        this.log('   2. Edit the workflow files to customize your implementation');
-        this.log('   3. If using @output.ai/llm, configure your .env file with LLM provider credentials:');
-        this.log('      - ANTHROPIC_API_KEY for Claude');
-        this.log('      - OPENAI_API_KEY for OpenAI');
-        this.log('   4. Build and run with the worker');
-        this.log('\nCheck the README.md for workflow-specific documentation.');
+        const message = getWorkflowGenerateSuccessMessage(result.workflowName, result.targetDir, result.filesCreated);
+        this.log(message);
     }
 }

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

@@ -46,7 +46,8 @@ describe('Generate Command', () => {
                 skeleton: true,
                 force: false
             });
-            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('[SUCCESS] Workflow "test-workflow" created successfully!'));
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('SUCCESS!'));
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('test-workflow'));
         });
         it('should require skeleton flag and reject without it', async () => {
             const cmd = createCommand();
@@ -105,9 +106,10 @@ describe('Generate Command', () => {
                 filesCreated: ['index.ts', 'steps.ts', 'types.ts']
             });
             await cmd.run();
-            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('[SUCCESS] Workflow "my-workflow" created successfully!'));
-            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Location: /custom/path/my-workflow'));
-            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('-- Next steps --'));
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('SUCCESS!'));
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('my-workflow'));
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('/custom/path/my-workflow'));
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('NEXT STEPS'));
         });
     });
 });

package/dist/commands/workflow/{output.d.ts → result.d.ts}

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-export default class WorkflowOutput extends Command {
+export default class WorkflowResult extends Command {
     static description: string;
     static examples: string[];
     static args: {

package/dist/commands/workflow/{output.js → result.js}

@@ -1,17 +1,17 @@
 import { Args, Command, Flags } from '@oclif/core';
-import { getWorkflowIdOutput } from '#api/generated/api.js';
+import { getWorkflowIdResult } from '#api/generated/api.js';
 import { OUTPUT_FORMAT } from '#utils/constants.js';
 import { formatOutput } from '#utils/output_formatter.js';
 import { handleApiError } from '#utils/error_handler.js';
-export default class WorkflowOutput extends Command {
-    static description = 'Get workflow execution output';
+export default class WorkflowResult extends Command {
+    static description = 'Get workflow execution result';
     static examples = [
         '<%= config.bin %> <%= command.id %> wf-12345',
         '<%= config.bin %> <%= command.id %> wf-12345 --format json'
     ];
     static args = {
         workflowId: Args.string({
-            description: 'The workflow ID to get output for',
+            description: 'The workflow ID to get result for',
             required: true
         })
     };
@@ -24,9 +24,9 @@ export default class WorkflowOutput extends Command {
         })
     };
     async run() {
-        const { args, flags } = await this.parse(WorkflowOutput);
-        this.log(`Fetching output for workflow: ${args.workflowId}...`);
-        const response = await getWorkflowIdOutput(args.workflowId);
+        const { args, flags } = await this.parse(WorkflowResult);
+        this.log(`Fetching result for workflow: ${args.workflowId}...`);
+        const response = await getWorkflowIdResult(args.workflowId);
         if (!response || !response.data) {
             this.error('API returned invalid response', { exit: 1 });
         }
@@ -34,7 +34,7 @@ export default class WorkflowOutput extends Command {
             const lines = [
                 `Workflow ID: ${result.workflowId || 'unknown'}`,
                 '',
-                'Output:',
+                'Result:',
                 JSON.stringify(result.output, null, 2)
             ];
             return lines.join('\n');

package/dist/commands/workflow/result.test.js

@@ -0,0 +1,23 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('../../api/generated/api.js', () => ({
+    getWorkflowIdResult: vi.fn()
+}));
+describe('workflow result command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('command definition', () => {
+        it('should export a valid OCLIF command', async () => {
+            const WorkflowResult = (await import('./result.js')).default;
+            expect(WorkflowResult).toBeDefined();
+            expect(WorkflowResult.description).toContain('Get workflow execution result');
+            expect(WorkflowResult.args).toHaveProperty('workflowId');
+            expect(WorkflowResult.flags).toHaveProperty('format');
+        });
+        it('should have correct flag configuration', async () => {
+            const WorkflowResult = (await import('./result.js')).default;
+            expect(WorkflowResult.flags.format.options).toEqual(['json', 'text']);
+            expect(WorkflowResult.flags.format.default).toBe('text');
+        });
+    });
+});

package/dist/commands/workflow/start.js

@@ -45,7 +45,7 @@ export default class WorkflowStart extends Command {
             `Workflow ID: ${result.workflowId || 'unknown'}`,
             '',
             `Use "workflow status ${result.workflowId || '<workflow-id>'}" to check the workflow status`,
-            `Use "workflow output ${result.workflowId || '<workflow-id>'}" to get the workflow output when complete`
+            `Use "workflow result ${result.workflowId || '<workflow-id>'}" to get the workflow result when complete`
         ].join('\n');
         this.log(`\n${output}`);
     }

package/dist/services/coding_agents.js

@@ -29,6 +29,21 @@ export const AGENT_CONFIGS = {
                 from: 'agents/workflow_planner.md.template',
                 to: `${AGENT_CONFIG_DIR}/agents/workflow_planner.md`
             },
+            {
+                type: 'template',
+                from: 'agents/workflow_quality.md.template',
+                to: `${AGENT_CONFIG_DIR}/agents/workflow_quality.md`
+            },
+            {
+                type: 'template',
+                from: 'agents/context_fetcher.md.template',
+                to: `${AGENT_CONFIG_DIR}/agents/context_fetcher.md`
+            },
+            {
+                type: 'template',
+                from: 'agents/prompt_writer.md.template',
+                to: `${AGENT_CONFIG_DIR}/agents/prompt_writer.md`
+            },
             {
                 type: 'template',
                 from: 'commands/plan_workflow.md.template',
@@ -65,6 +80,21 @@ export const AGENT_CONFIGS = {
                 from: `${AGENT_CONFIG_DIR}/agents/workflow_planner.md`,
                 to: '.claude/agents/workflow_planner.md'
             },
+            {
+                type: 'symlink',
+                from: `${AGENT_CONFIG_DIR}/agents/workflow_quality.md`,
+                to: '.claude/agents/workflow_quality.md'
+            },
+            {
+                type: 'symlink',
+                from: `${AGENT_CONFIG_DIR}/agents/context_fetcher.md`,
+                to: '.claude/agents/context_fetcher.md'
+            },
+            {
+                type: 'symlink',
+                from: `${AGENT_CONFIG_DIR}/agents/prompt_writer.md`,
+                to: '.claude/agents/prompt_writer.md'
+            },
             {
                 type: 'symlink',
                 from: `${AGENT_CONFIG_DIR}/commands/plan_workflow.md`,

package/dist/services/coding_agents.spec.js

@@ -39,11 +39,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(10);
+            expect(files.length).toBe(16);
         });
         it('should have outputai files with .outputai prefix', () => {
             const files = getRequiredFiles();
-            const outputaiFiles = files.slice(0, 6);
+            const outputaiFiles = files.slice(0, 9);
             outputaiFiles.forEach(file => {
                 expect(file).toMatch(/^\.outputai\//);
             });
@@ -77,12 +77,18 @@ describe('coding_agents service', () => {
                 missingFiles: [
                     '.outputai/AGENTS.md',
                     '.outputai/agents/workflow_planner.md',
+                    '.outputai/agents/workflow_quality.md',
+                    '.outputai/agents/context_fetcher.md',
+                    '.outputai/agents/prompt_writer.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/agents/workflow_quality.md',
+                    '.claude/agents/context_fetcher.md',
+                    '.claude/agents/prompt_writer.md',
                     '.claude/commands/plan_workflow.md',
                     '.claude/commands/build_workflow.md'
                 ],
@@ -98,54 +104,21 @@ describe('coding_agents service', () => {
                 missingFiles: [],
                 isComplete: true
             });
-            expect(access).toHaveBeenCalledTimes(11); // dir + 6 outputai + 4 claude-code
+            expect(access).toHaveBeenCalledTimes(17); // dir + 9 outputai + 7 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/commands/build_workflow.md exists
-                if (callNum === 5) {
-                    return undefined;
-                }
-                // Call 6: .outputai/meta/pre_flight.md exists
-                if (callNum === 6) {
-                    return undefined;
-                }
-                // Call 7: .outputai/meta/post_flight.md exists
-                if (callNum === 7) {
-                    return undefined;
-                }
-                // 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 10: .claude/commands/plan_workflow.md exists
-                if (callNum === 10) {
-                    return undefined;
+            const missingFiles = new Set([
+                '.outputai/agents/workflow_planner.md',
+                '.claude/agents/workflow_planner.md'
+            ]);
+            vi.mocked(access).mockImplementation(async (path) => {
+                const pathStr = path.toString();
+                // Check if this path ends with any of the missing files
+                for (const missing of missingFiles) {
+                    if (pathStr.endsWith(missing)) {
+                        throw { code: 'ENOENT' };
+                    }
                 }
-                // Call 11: .claude/commands/build_workflow.md exists
                 return undefined;
             });
             const result = await checkAgentStructure('/test/project');
@@ -159,18 +132,20 @@ describe('coding_agents service', () => {
             });
         });
         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/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
-                .mockResolvedValueOnce(undefined); // .claude/commands/build_workflow.md
+            const missingFiles = new Set([
+                '.outputai/agents/workflow_planner.md',
+                '.outputai/commands/plan_workflow.md',
+                '.claude/commands/plan_workflow.md'
+            ]);
+            vi.mocked(access).mockImplementation(async (path) => {
+                const pathStr = path.toString();
+                for (const missing of missingFiles) {
+                    if (pathStr.endsWith(missing)) {
+                        throw { code: 'ENOENT' };
+                    }
+                }
+                return undefined;
+            });
             const result = await checkAgentStructure('/test/project');
             expect(result.dirExists).toBe(true);
             expect(result.missingFiles).toEqual([
@@ -207,8 +182,8 @@ describe('coding_agents service', () => {
             });
             // Should create outputai files (6 templates)
             expect(fs.writeFile).toHaveBeenCalledWith(expect.stringContaining('AGENTS.md'), expect.any(String), 'utf-8');
-            // Should create symlinks (4 symlinks for claude-code)
-            expect(fs.symlink).toHaveBeenCalledTimes(4);
+            // Should create symlinks (7 symlinks for claude-code)
+            expect(fs.symlink).toHaveBeenCalledTimes(7);
         });
         it('should skip existing files when force is false', async () => {
             // Mock some files exist

package/dist/services/messages.d.ts

@@ -3,3 +3,4 @@
  */
 export declare const getEjectSuccessMessage: (destPath: string, outputFile: string, binName: string) => string;
 export declare const getProjectSuccessMessage: (folderName: string, installSuccess: boolean, envConfigured?: boolean) => string;
+export declare const getWorkflowGenerateSuccessMessage: (workflowName: string, targetDir: string, filesCreated: string[]) => string;

package/dist/services/messages.js

@@ -176,7 +176,7 @@ export const getProjectSuccessMessage = (folderName, installSuccess, envConfigur
         note: 'Launches Temporal, Redis, PostgreSQL, API, Worker, and UI'
     }, {
         step: 'Run example workflow',
-        command: 'output workflow run simple --input \'{"question": "who really is ada lovelace?"}\'',
+        command: 'output workflow run simple --input src/simple/scenarios/question_ada_lovelace.json',
         note: 'Execute in a new terminal after services are running'
     }, {
         step: 'Monitor workflows',
@@ -231,3 +231,67 @@ ${ux.colorize('dim', '         with AI assistance.')}
 ${ux.colorize('green', ux.colorize('bold', 'Happy building with Output SDK! 🚀'))}
 `;
 };
+export const getWorkflowGenerateSuccessMessage = (workflowName, targetDir, filesCreated) => {
+    const divider = ux.colorize('dim', '─'.repeat(80));
+    const bulletPoint = ux.colorize('green', '▸');
+    const formattedFiles = filesCreated.map(file => {
+        return `  ${bulletPoint} ${formatPath(file)}`;
+    }).join('\n');
+    const steps = [
+        {
+            step: 'Navigate to workflow directory',
+            command: `cd ${targetDir}`
+        },
+        {
+            step: 'Edit workflow files',
+            note: 'Customize workflow.ts, steps.ts, and prompts to match your requirements'
+        },
+        {
+            step: 'Configure environment',
+            command: 'Edit .env file',
+            note: 'Add your LLM provider credentials (ANTHROPIC_API_KEY or OPENAI_API_KEY)'
+        },
+        {
+            step: 'Test with example scenario',
+            command: `output workflow run ${workflowName} --input ${targetDir}/scenarios/test_input.json`,
+            note: 'Run after starting services with "output dev"'
+        }
+    ];
+    const formattedSteps = steps.map((item, index) => {
+        const stepNumber = ux.colorize('dim', `${index + 1}.`);
+        const stepText = ux.colorize('white', item.step);
+        const command = item.command ? `\n     ${bulletPoint} ${formatCommand(item.command)}` : '';
+        const note = item.note ? `\n     ${ux.colorize('dim', `  ${item.note}`)}` : '';
+        return `  ${stepNumber} ${stepText}${command}${note}`;
+    }).join('\n\n');
+    return `
+${divider}
+
+${ux.colorize('bold', ux.colorize('green', '✅ SUCCESS!'))} ${ux.colorize('bold', `Workflow "${workflowName}" created`)}
+
+${divider}
+
+${createSectionHeader('WORKFLOW DETAILS', '📁')}
+
+  ${bulletPoint} ${ux.colorize('white', 'Name:')} ${formatPath(workflowName)}
+  ${bulletPoint} ${ux.colorize('white', 'Location:')} ${formatPath(targetDir)}
+
+${divider}
+
+${createSectionHeader('FILES CREATED', '📄')}
+
+${formattedFiles}
+
+${divider}
+
+${createSectionHeader('NEXT STEPS', '🚀')}
+
+${formattedSteps}
+
+${divider}
+
+${ux.colorize('dim', '💡 Tip: Check the README.md in your workflow directory for detailed documentation.')}
+
+${ux.colorize('green', ux.colorize('bold', 'Happy building! 🛠️'))}
+`;
+};

package/dist/services/trace_reader.d.ts

@@ -0,0 +1,14 @@
+import type { TraceData } from '#types/trace.js';
+export type { TraceData };
+/**
+ * Find trace file from workflow metadata
+ */
+export declare function findTraceFile(workflowId: string): Promise<string>;
+/**
+ * Read and parse trace file
+ */
+export declare function readTraceFile(path: string): Promise<TraceData>;
+/**
+ * Get trace data from workflow ID
+ */
+export declare function getTrace(workflowId: string): Promise<TraceData>;

package/dist/services/trace_reader.js

@@ -0,0 +1,67 @@
+import { readFile, stat } from 'node:fs/promises';
+import { getWorkflowIdResult } from '#api/generated/api.js';
+import { getErrorCode } from '#utils/error_utils.js';
+/**
+ * Check if a file exists with detailed error information
+ */
+async function fileExists(path) {
+    try {
+        await stat(path);
+        return { exists: true };
+    }
+    catch (error) {
+        const code = getErrorCode(error);
+        if (code === 'ENOENT') {
+            return { exists: false };
+        }
+        if (code === 'EACCES') {
+            return { exists: false, error: `Permission denied: ${path}` };
+        }
+        return { exists: false, error: `Cannot access file: ${path}` };
+    }
+}
+/**
+ * Find trace file from workflow metadata
+ */
+export async function findTraceFile(workflowId) {
+    const response = await getWorkflowIdResult(workflowId);
+    // Check if we got a successful response
+    if (response.status !== 200) {
+        throw new Error(`Failed to get workflow result for ${workflowId}`);
+    }
+    const tracePath = response.data.trace?.destinations?.local;
+    if (!tracePath) {
+        throw new Error(`No trace file path found for workflow ${workflowId}`);
+    }
+    const fileCheck = await fileExists(tracePath);
+    if (!fileCheck.exists) {
+        const errorDetail = fileCheck.error || `Trace file not found at path: ${tracePath}`;
+        throw new Error(errorDetail);
+    }
+    return tracePath;
+}
+/**
+ * Read and parse trace file
+ */
+export async function readTraceFile(path) {
+    try {
+        const content = await readFile(path, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        if (getErrorCode(error) === 'ENOENT') {
+            throw new Error(`Trace file not found at path: ${path}`);
+        }
+        if (error instanceof SyntaxError) {
+            throw new Error(`Invalid JSON in trace file: ${path}`);
+        }
+        throw error;
+    }
+}
+/**
+ * Get trace data from workflow ID
+ */
+export async function getTrace(workflowId) {
+    const tracePath = await findTraceFile(workflowId);
+    return readTraceFile(tracePath);
+}

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

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