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

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 {};

package/dist/services/trace_reader.spec.js

@@ -0,0 +1,164 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { findTraceFile, readTraceFile } from './trace_reader.js';
+// Mock file system operations
+vi.mock('node:fs/promises', () => ({
+    readFile: vi.fn(),
+    stat: vi.fn()
+}));
+// Mock API
+vi.mock('../api/generated/api.js', () => ({
+    getWorkflowIdResult: vi.fn()
+}));
+describe('TraceReader', () => {
+    const getMocks = async () => {
+        const fsModule = await import('node:fs/promises');
+        const apiModule = await import('../api/generated/api.js');
+        return {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            mockReadFile: fsModule.readFile,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            mockStat: fsModule.stat,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            mockGetWorkflowIdResult: apiModule.getWorkflowIdResult
+        };
+    };
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('findTraceFile', () => {
+        it('should find trace file from workflow output metadata', async () => {
+            const { mockGetWorkflowIdResult, mockStat } = await getMocks();
+            const workflowId = 'test-workflow-123';
+            const expectedPath = '/app/logs/runs/test/2024-01-01_test-workflow-123.json';
+            mockGetWorkflowIdResult.mockResolvedValue({
+                status: 200,
+                data: {
+                    workflowId,
+                    output: { result: 'test result' },
+                    trace: {
+                        destinations: {
+                            local: expectedPath,
+                            remote: null
+                        }
+                    }
+                }
+            });
+            mockStat.mockResolvedValue({ isFile: () => true });
+            const result = await findTraceFile(workflowId);
+            expect(result).toBe(expectedPath);
+            expect(mockGetWorkflowIdResult).toHaveBeenCalledWith(workflowId);
+            expect(mockStat).toHaveBeenCalledWith(expectedPath);
+        });
+        it('should throw error when no trace path in metadata', async () => {
+            const { mockGetWorkflowIdResult } = await getMocks();
+            const workflowId = 'test-workflow-456';
+            mockGetWorkflowIdResult.mockResolvedValue({
+                status: 200,
+                data: {
+                    workflowId,
+                    output: { result: 'test result' },
+                    trace: {
+                        destinations: {
+                            local: null,
+                            remote: null
+                        }
+                    }
+                }
+            });
+            await expect(findTraceFile(workflowId))
+                .rejects.toThrow(`No trace file path found for workflow ${workflowId}`);
+        });
+        it('should throw error when trace file not on disk', async () => {
+            const { mockGetWorkflowIdResult, mockStat } = await getMocks();
+            const workflowId = 'test-workflow-789';
+            const expectedPath = '/app/logs/runs/test/2024-01-01_test-workflow-789.json';
+            mockGetWorkflowIdResult.mockResolvedValue({
+                status: 200,
+                data: {
+                    workflowId,
+                    output: { result: 'test result' },
+                    trace: {
+                        destinations: {
+                            local: expectedPath,
+                            remote: null
+                        }
+                    }
+                }
+            });
+            const enoentError = Object.assign(new Error('ENOENT: no such file or directory'), { code: 'ENOENT' });
+            mockStat.mockRejectedValue(enoentError);
+            await expect(findTraceFile(workflowId))
+                .rejects.toThrow(`Trace file not found at path: ${expectedPath}`);
+        });
+        it('should throw error when API call fails', async () => {
+            const { mockGetWorkflowIdResult } = await getMocks();
+            const workflowId = 'non-existent';
+            mockGetWorkflowIdResult.mockRejectedValue(new Error('Workflow not found'));
+            await expect(findTraceFile(workflowId))
+                .rejects.toThrow('Workflow not found');
+        });
+        it('should handle missing trace property gracefully', async () => {
+            const { mockGetWorkflowIdResult } = await getMocks();
+            const workflowId = 'test-workflow-no-trace';
+            mockGetWorkflowIdResult.mockResolvedValue({
+                status: 200,
+                data: {
+                    workflowId,
+                    output: { result: 'test result' }
+                    // No trace property at all
+                }
+            });
+            await expect(findTraceFile(workflowId))
+                .rejects.toThrow(`No trace file path found for workflow ${workflowId}`);
+        });
+        it('should throw error when workflow not found (404)', async () => {
+            const { mockGetWorkflowIdResult } = await getMocks();
+            const workflowId = 'non-existent-workflow';
+            mockGetWorkflowIdResult.mockResolvedValue({
+                status: 404,
+                data: void 0
+            });
+            await expect(findTraceFile(workflowId))
+                .rejects.toThrow(`Failed to get workflow result for ${workflowId}`);
+        });
+    });
+    describe('readTraceFile', () => {
+        it('should read and parse JSON file successfully', async () => {
+            const { mockReadFile } = await getMocks();
+            const path = '/logs/test.json';
+            const traceData = {
+                root: { workflowName: 'test' },
+                events: []
+            };
+            mockReadFile.mockResolvedValue(JSON.stringify(traceData));
+            const result = await readTraceFile(path);
+            expect(result).toEqual(traceData);
+            expect(mockReadFile).toHaveBeenCalledWith(path, 'utf-8');
+        });
+        it('should throw error for non-existent file', async () => {
+            const { mockReadFile } = await getMocks();
+            const path = '/logs/missing.json';
+            const error = new Error('ENOENT');
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            error.code = 'ENOENT';
+            mockReadFile.mockRejectedValue(error);
+            await expect(readTraceFile(path))
+                .rejects.toThrow(`Trace file not found at path: ${path}`);
+        });
+        it('should throw error for invalid JSON', async () => {
+            const { mockReadFile } = await getMocks();
+            const path = '/logs/invalid.json';
+            mockReadFile.mockResolvedValue('invalid json {');
+            await expect(readTraceFile(path))
+                .rejects.toThrow(`Invalid JSON in trace file: ${path}`);
+        });
+        it('should rethrow other errors', async () => {
+            const { mockReadFile } = await getMocks();
+            const path = '/logs/test.json';
+            const error = new Error('Permission denied');
+            mockReadFile.mockRejectedValue(error);
+            await expect(readTraceFile(path))
+                .rejects.toThrow('Permission denied');
+        });
+    });
+});

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

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

package/dist/services/workflow_generator.spec.js

@@ -0,0 +1,77 @@
+/* eslint-disable no-restricted-syntax, init-declarations */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { generateWorkflow } from './workflow_generator.js';
+describe('Workflow Generator', () => {
+    let tempDir;
+    beforeEach(async () => {
+        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'workflow-gen-test-'));
+    });
+    afterEach(async () => {
+        await fs.rm(tempDir, { recursive: true, force: true });
+    });
+    describe('skeleton generation', () => {
+        it('should create prompts folder with prompt template', async () => {
+            const result = await generateWorkflow({
+                name: 'testWorkflow',
+                description: 'Test workflow',
+                outputDir: tempDir,
+                skeleton: true,
+                force: false
+            });
+            const promptPath = path.join(result.targetDir, 'prompts', 'prompt@v1.prompt');
+            const promptExists = await fs.access(promptPath).then(() => true).catch(() => false);
+            expect(promptExists).toBe(true);
+            expect(result.filesCreated).toContain('prompts/prompt@v1.prompt');
+        });
+        it('should create scenarios folder with test_input.json', async () => {
+            const result = await generateWorkflow({
+                name: 'testWorkflow',
+                description: 'Test workflow',
+                outputDir: tempDir,
+                skeleton: true,
+                force: false
+            });
+            const scenarioPath = path.join(result.targetDir, 'scenarios', 'test_input.json');
+            const scenarioExists = await fs.access(scenarioPath).then(() => true).catch(() => false);
+            expect(scenarioExists).toBe(true);
+            expect(result.filesCreated).toContain('scenarios/test_input.json');
+        });
+        it('should create valid JSON in scenario file', async () => {
+            const result = await generateWorkflow({
+                name: 'testWorkflow',
+                description: 'Test workflow',
+                outputDir: tempDir,
+                skeleton: true,
+                force: false
+            });
+            const scenarioPath = path.join(result.targetDir, 'scenarios', 'test_input.json');
+            const content = await fs.readFile(scenarioPath, 'utf-8');
+            const parsed = JSON.parse(content);
+            expect(parsed).toHaveProperty('prompt');
+            expect(parsed).toHaveProperty('data');
+        });
+        it('should create all expected skeleton files', async () => {
+            const result = await generateWorkflow({
+                name: 'testWorkflow',
+                description: 'Test workflow',
+                outputDir: tempDir,
+                skeleton: true,
+                force: false
+            });
+            const expectedFiles = [
+                'workflow.ts',
+                'steps.ts',
+                'README.md',
+                '.env',
+                'prompts/prompt@v1.prompt',
+                'scenarios/test_input.json'
+            ];
+            for (const file of expectedFiles) {
+                expect(result.filesCreated).toContain(file);
+            }
+        });
+    });
+});