@outputai/cli 0.1.3 → 0.1.4-dev.0

package/dist/commands/workflow/dataset/list.js

@@ -0,0 +1,87 @@
+import { Args, Command, Flags } from '@oclif/core';
+import Table from 'cli-table3';
+import { listDatasets } from '#services/datasets.js';
+const OutputFormat = {
+    TABLE: 'table',
+    JSON: 'json',
+    TEXT: 'text'
+};
+function createDatasetsTable(datasets) {
+    const table = new Table({
+        head: ['Name', 'Output Date', 'Eval Date', 'Has Output', 'Path'],
+        colWidths: [25, 22, 22, 16, 50],
+        wordWrap: true,
+        style: {
+            head: ['cyan']
+        }
+    });
+    datasets.forEach(dataset => {
+        table.push([
+            dataset.name,
+            dataset.lastOutputDate ?? '-',
+            dataset.lastEvalDate ?? '-',
+            dataset.hasLastOutput ? 'Yes' : 'No',
+            dataset.path
+        ]);
+    });
+    return table.toString();
+}
+function formatDatasetsAsText(datasets) {
+    if (datasets.length === 0) {
+        return 'No datasets found.';
+    }
+    return datasets.map(dataset => {
+        const cached = dataset.hasLastOutput ? '(cached)' : '(no output)';
+        const outputDate = dataset.lastOutputDate ? ` [output: ${dataset.lastOutputDate}]` : '';
+        const evalDate = dataset.lastEvalDate ? ` [eval: ${dataset.lastEvalDate}]` : '';
+        return `${dataset.name} ${cached}${outputDate}${evalDate}`;
+    }).join('\n');
+}
+function formatDatasetsAsJson(datasets) {
+    return JSON.stringify(datasets, null, 2);
+}
+function formatDatasets(datasets, format) {
+    if (format === OutputFormat.JSON) {
+        return formatDatasetsAsJson(datasets);
+    }
+    if (format === OutputFormat.TABLE) {
+        return createDatasetsTable(datasets);
+    }
+    return formatDatasetsAsText(datasets);
+}
+export default class DatasetList extends Command {
+    static description = 'List datasets for a workflow';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> simple',
+        '<%= config.bin %> <%= command.id %> simple --format json',
+        '<%= config.bin %> <%= command.id %> simple --format table'
+    ];
+    static args = {
+        workflowName: Args.string({
+            description: 'Workflow name to list datasets for',
+            required: true
+        })
+    };
+    static flags = {
+        format: Flags.string({
+            char: 'f',
+            description: 'Output format',
+            options: [OutputFormat.TABLE, OutputFormat.JSON, OutputFormat.TEXT],
+            default: OutputFormat.TABLE
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(DatasetList);
+        const datasets = await listDatasets(args.workflowName);
+        if (datasets.length === 0) {
+            this.log(`No datasets found for workflow "${args.workflowName}".`);
+            this.log('Generate datasets with: output workflow dataset generate');
+            return;
+        }
+        const output = formatDatasets(datasets, flags.format);
+        this.log(output);
+        if (flags.format !== OutputFormat.JSON) {
+            this.log(`\nFound ${datasets.length} dataset(s) for "${args.workflowName}"`);
+        }
+    }
+}

package/dist/commands/workflow/debug.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+export default class WorkflowDebug extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        workflowId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private conditionalLog;
+    private outputJson;
+    private displayTextTrace;
+    catch(error: Error): Promise<void>;
+}

package/dist/commands/workflow/debug.js

@@ -0,0 +1,60 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { OUTPUT_FORMAT } from '#utils/constants.js';
+import { displayDebugTree } from '#utils/trace_formatter.js';
+import { getTrace } from '#services/trace_reader.js';
+import { handleApiError } from '#utils/error_handler.js';
+export default class WorkflowDebug extends Command {
+    static description = 'Get and display workflow execution trace for debugging';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> wf-12345',
+        '<%= config.bin %> <%= command.id %> wf-12345 --format json',
+        '<%= config.bin %> <%= command.id %> wf-12345 --format text'
+    ];
+    static args = {
+        workflowId: Args.string({
+            description: 'The workflow ID to debug',
+            required: true
+        })
+    };
+    static flags = {
+        format: Flags.string({
+            char: 'f',
+            description: 'Output format',
+            options: [OUTPUT_FORMAT.JSON, OUTPUT_FORMAT.TEXT],
+            default: OUTPUT_FORMAT.TEXT
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowDebug);
+        const isJsonFormat = flags.format === OUTPUT_FORMAT.JSON;
+        this.conditionalLog(`Fetching debug information for workflow: ${args.workflowId}...`, isJsonFormat);
+        const { data: traceData, location } = await getTrace(args.workflowId);
+        const source = location.isRemote ? 'remote' : 'local';
+        this.conditionalLog(`Trace source: ${source}${!location.isRemote ? ` (${location.path})` : ''}`, isJsonFormat);
+        if (isJsonFormat) {
+            this.outputJson(traceData);
+            return;
+        }
+        this.displayTextTrace(traceData);
+    }
+    conditionalLog(message, disabled) {
+        if (!disabled) {
+            this.log(message);
+        }
+    }
+    outputJson(data) {
+        this.log(JSON.stringify(data, null, 2));
+    }
+    displayTextTrace(traceData) {
+        this.log('\nTrace Log:');
+        this.log('─'.repeat(80));
+        this.log(displayDebugTree(traceData));
+        this.log('\n' + '─'.repeat(80));
+        this.log('Tip: Use --format json for the full untruncated trace');
+    }
+    async catch(error) {
+        return handleApiError(error, (...args) => this.error(...args), {
+            404: 'Workflow not found or trace not available. Check the workflow ID.'
+        });
+    }
+}

package/dist/commands/workflow/debug.spec.d.ts

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

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

@@ -0,0 +1,34 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// Mock the TraceReader service
+vi.mock('../../services/trace_reader.js', () => ({
+    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.d.ts

@@ -0,0 +1,17 @@
+import { Command } from '@oclif/core';
+export default class Generate extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        skeleton: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'output-dir': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'plan-file': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    private displaySuccess;
+}

package/dist/commands/workflow/generate.js

@@ -0,0 +1,85 @@
+import { Args, Command, Flags, ux } from '@oclif/core';
+import { generateWorkflow } from '#services/workflow_generator.js';
+import { buildWorkflow, buildWorkflowInteractiveLoop } from '#services/workflow_builder.js';
+import { ensureOutputAISystem } 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 {
+    static description = 'Generate a new Output workflow from a skeleton or plan file';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-workflow --skeleton',
+        '<%= config.bin %> <%= command.id %> my-workflow --skeleton --description "Process and transform data"',
+        '<%= config.bin %> <%= command.id %> my-workflow --plan-file .outputai/plans/2025_10_09_my_workflow/PLAN.md',
+        '<%= config.bin %> <%= command.id %> my-workflow --skeleton --output-dir ./custom/path'
+    ];
+    static flags = {
+        skeleton: Flags.boolean({
+            char: 's',
+            description: 'Generate minimal skeleton workflow without example steps',
+            default: false
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Description of the workflow',
+            required: false
+        }),
+        'output-dir': Flags.string({
+            char: 'o',
+            description: 'Output directory for the workflow',
+            default: DEFAULT_OUTPUT_DIRS.workflows
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Overwrite existing directory',
+            default: false
+        }),
+        'plan-file': Flags.string({
+            char: 'p',
+            description: 'Path to plan file for AI-assisted workflow implementation',
+            required: false
+        })
+    };
+    static args = {
+        name: Args.string({
+            required: true,
+            description: 'Name of the workflow to generate'
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(Generate);
+        const planFile = flags['plan-file'];
+        if (!flags.skeleton && !planFile) {
+            this.error('Full workflow generation not implemented yet. Please use --skeleton flag or --plan-file');
+        }
+        try {
+            const result = await generateWorkflow({
+                name: args.name,
+                description: flags.description,
+                outputDir: flags['output-dir'],
+                skeleton: flags.skeleton,
+                force: flags.force
+            });
+            if (planFile) {
+                this.log('\nStarting AI-assisted workflow implementation...\n');
+                const projectRoot = process.cwd();
+                await ensureOutputAISystem(projectRoot);
+                const absolutePlanPath = path.resolve(projectRoot, planFile);
+                const buildOutput = await buildWorkflow(absolutePlanPath, result.targetDir, args.name);
+                await buildWorkflowInteractiveLoop(buildOutput);
+                this.log(ux.colorize('green', '\nWorkflow implementation complete!\n'));
+            }
+            this.displaySuccess(result);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(error.message);
+            }
+            throw error;
+        }
+    }
+    displaySuccess(result) {
+        const message = getWorkflowGenerateSuccessMessage(result.workflowName, result.targetDir, result.filesCreated);
+        this.log(message);
+    }
+}

package/dist/commands/workflow/generate.spec.d.ts

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

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

@@ -0,0 +1,115 @@
+/* eslint-disable no-restricted-syntax, @typescript-eslint/no-explicit-any, init-declarations */
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import Generate from './generate.js';
+import { generateWorkflow } from '#services/workflow_generator.js';
+import { InvalidNameError, WorkflowExistsError } from '#types/errors.js';
+vi.mock('../../services/workflow_generator.js');
+describe('Generate Command', () => {
+    let mockGenerateWorkflow;
+    let logSpy;
+    const createCommand = () => {
+        const cmd = new Generate([], {});
+        cmd.log = vi.fn();
+        cmd.error = vi.fn((message) => {
+            throw new Error(message);
+        });
+        cmd.parse = vi.fn();
+        logSpy = cmd.log;
+        return cmd;
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockGenerateWorkflow = vi.mocked(generateWorkflow);
+    });
+    describe('successful workflow generation', () => {
+        it('should generate workflow with skeleton flag', async () => {
+            const cmd = createCommand();
+            cmd.parse.mockResolvedValue({
+                args: { name: 'test-workflow' },
+                flags: {
+                    skeleton: true,
+                    description: 'Test description',
+                    'output-dir': '/tmp',
+                    force: false
+                }
+            });
+            mockGenerateWorkflow.mockResolvedValue({
+                workflowName: 'test-workflow',
+                targetDir: '/tmp/test-workflow',
+                filesCreated: ['index.ts', 'steps.ts', 'types.ts']
+            });
+            await cmd.run();
+            expect(mockGenerateWorkflow).toHaveBeenCalledWith({
+                name: 'test-workflow',
+                description: 'Test description',
+                outputDir: '/tmp',
+                skeleton: true,
+                force: false
+            });
+            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();
+            cmd.parse.mockResolvedValue({
+                args: { name: 'test-workflow' },
+                flags: {
+                    skeleton: false,
+                    'output-dir': '/tmp',
+                    force: false
+                }
+            });
+            await expect(cmd.run()).rejects.toThrow('Full workflow generation not implemented yet. Please use --skeleton flag');
+            expect(mockGenerateWorkflow).not.toHaveBeenCalled();
+        });
+    });
+    describe('error handling', () => {
+        it('should handle invalid name error', async () => {
+            const cmd = createCommand();
+            cmd.parse.mockResolvedValue({
+                args: { name: 'invalid name' },
+                flags: { 'output-dir': '/tmp', skeleton: true, force: false }
+            });
+            mockGenerateWorkflow.mockRejectedValue(new InvalidNameError('invalid name'));
+            await expect(cmd.run()).rejects.toThrow(/Invalid workflow name/i);
+        });
+        it('should handle workflow exists error', async () => {
+            const cmd = createCommand();
+            cmd.parse.mockResolvedValue({
+                args: { name: 'existing-workflow' },
+                flags: { 'output-dir': '/tmp', skeleton: true, force: false }
+            });
+            mockGenerateWorkflow.mockRejectedValue(new WorkflowExistsError('existing-workflow', '/tmp/existing-workflow'));
+            await expect(cmd.run()).rejects.toThrow(/already exists/i);
+        });
+        it('should re-throw non-CLI errors', async () => {
+            const cmd = createCommand();
+            cmd.parse.mockResolvedValue({
+                args: { name: 'test-workflow' },
+                flags: { 'output-dir': '/tmp', skeleton: true, force: false }
+            });
+            const systemError = new Error('System error');
+            mockGenerateWorkflow.mockRejectedValue(systemError);
+            await expect(cmd.run()).rejects.toThrow(systemError);
+        });
+    });
+    describe('success display', () => {
+        it('should display correct success message and next steps', async () => {
+            const cmd = createCommand();
+            cmd.parse.mockResolvedValue({
+                args: { name: 'my-workflow' },
+                flags: { 'output-dir': '/custom/path', skeleton: true, force: false }
+            });
+            mockGenerateWorkflow.mockResolvedValue({
+                workflowName: 'my-workflow',
+                targetDir: '/custom/path/my-workflow',
+                filesCreated: ['index.ts', 'steps.ts', 'types.ts']
+            });
+            await cmd.run();
+            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/list.d.ts

@@ -0,0 +1,22 @@
+import { Command } from '@oclif/core';
+import { type Workflow } from '#api/generated/api.js';
+interface WorkflowDisplay {
+    name: string;
+    description: string;
+    inputs: string;
+    outputs: string;
+    scenarios: string;
+}
+export declare function parseWorkflowForDisplay(workflow: Workflow): WorkflowDisplay;
+export default class WorkflowList extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        detailed: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        filter: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    catch(error: Error): Promise<void>;
+}
+export {};

package/dist/commands/workflow/list.js

@@ -0,0 +1,152 @@
+import { Command, Flags } from '@oclif/core';
+import Table from 'cli-table3';
+import { getWorkflowCatalog } from '#api/generated/api.js';
+import { parseWorkflowDefinition, formatParameters } from '#api/parser.js';
+import { handleApiError } from '#utils/error_handler.js';
+import { listScenariosForWorkflow } from '#utils/scenario_resolver.js';
+const OUTPUT_FORMAT = {
+    LIST: 'list',
+    TABLE: 'table',
+    JSON: 'json'
+};
+export function parseWorkflowForDisplay(workflow) {
+    const parsed = parseWorkflowDefinition(workflow);
+    const scenarioNames = listScenariosForWorkflow(workflow.name, workflow.path);
+    return {
+        name: parsed.name,
+        description: parsed.description || 'No description',
+        inputs: formatParameters(parsed.inputs),
+        outputs: formatParameters(parsed.outputs),
+        scenarios: scenarioNames.length > 0 ? scenarioNames.join(', ') : 'none'
+    };
+}
+function caseInsensitiveIncludes(str, filter) {
+    return str.toLowerCase().includes(filter.toLowerCase());
+}
+function matchName(filterString) {
+    return workflow => {
+        const name = workflow.name || '';
+        return caseInsensitiveIncludes(name, filterString);
+    };
+}
+function sortWorkflowsByName(workflows) {
+    return [...workflows].sort((a, b) => {
+        const nameA = (a.name || '').toLowerCase();
+        const nameB = (b.name || '').toLowerCase();
+        return nameA.localeCompare(nameB);
+    });
+}
+function createWorkflowTable(workflows, detailed) {
+    const table = new Table({
+        head: ['Name', 'Description', 'Inputs', 'Outputs', 'Scenarios'],
+        colWidths: detailed ? [30, 42, 42, 42, 60] : [24, 30, 24, 24, 48],
+        wordWrap: true,
+        style: {
+            head: ['cyan']
+        }
+    });
+    const sortedWorkflows = sortWorkflowsByName(workflows);
+    sortedWorkflows.forEach(workflow => {
+        const display = parseWorkflowForDisplay(workflow);
+        if (detailed) {
+            const inputs = display.inputs.split(', ').join('\n');
+            const outputs = display.outputs.split(', ').join('\n');
+            const scenarios = display.scenarios.split(', ').join('\n');
+            table.push([display.name, display.description, inputs, outputs, scenarios]);
+        }
+        else {
+            table.push([display.name, display.description, display.inputs, display.outputs, display.scenarios]);
+        }
+    });
+    return table.toString();
+}
+function formatWorkflowsAsList(workflows) {
+    const sortedWorkflows = sortWorkflowsByName(workflows);
+    const names = sortedWorkflows.map(w => parseWorkflowForDisplay(w).name);
+    return `\nWorkflows:\n\n${names.map(name => `- ${name}`).join('\n')}`;
+}
+function formatWorkflowsAsJson(workflows) {
+    const output = {
+        workflows: workflows.map(w => {
+            const display = parseWorkflowForDisplay(w);
+            return {
+                name: display.name,
+                description: display.description,
+                inputs: display.inputs.split(', '),
+                outputs: display.outputs.split(', '),
+                scenarios: display.scenarios === 'none' ? [] : display.scenarios.split(', '),
+                raw: w
+            };
+        })
+    };
+    return JSON.stringify(output, null, 2);
+}
+function formatWorkflows(workflows, format, detailed) {
+    if (format === OUTPUT_FORMAT.JSON) {
+        return formatWorkflowsAsJson(workflows);
+    }
+    if (format === OUTPUT_FORMAT.TABLE) {
+        return createWorkflowTable(workflows, detailed);
+    }
+    return formatWorkflowsAsList(workflows);
+}
+export default class WorkflowList extends Command {
+    static description = 'List available workflows from the catalog';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --format table',
+        '<%= config.bin %> <%= command.id %> --format json',
+        '<%= config.bin %> <%= command.id %> --detailed',
+        '<%= config.bin %> <%= command.id %> --filter simple'
+    ];
+    static flags = {
+        format: Flags.string({
+            char: 'f',
+            description: 'Output format',
+            options: [OUTPUT_FORMAT.LIST, OUTPUT_FORMAT.TABLE, OUTPUT_FORMAT.JSON],
+            default: OUTPUT_FORMAT.LIST
+        }),
+        detailed: Flags.boolean({
+            char: 'd',
+            description: 'Show detailed parameter information',
+            default: false
+        }),
+        filter: Flags.string({
+            description: 'Filter workflows by name'
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(WorkflowList);
+        this.log('Fetching workflow catalog...');
+        const response = await getWorkflowCatalog();
+        if (!response) {
+            this.error('Failed to connect to API server. Is it running?', { exit: 1 });
+        }
+        if (!response.data) {
+            this.error('API returned invalid response (missing data)', { exit: 1 });
+        }
+        const data = response.data;
+        if (!data.workflows) {
+            this.error('API returned invalid response (missing workflows)', { exit: 1 });
+        }
+        if (data.workflows.length === 0) {
+            this.log('No workflows found in catalog.');
+            return;
+        }
+        const workflows = flags.filter ?
+            data.workflows.filter(matchName(flags.filter)) :
+            data.workflows;
+        if (workflows.length === 0 && flags.filter) {
+            this.log(`No workflows matching filter: ${flags.filter}`);
+            return;
+        }
+        const output = formatWorkflows(workflows, flags.format, flags.detailed);
+        this.log(output);
+        this.log(`\nFound ${workflows.length} workflow(s)`);
+    }
+    async catch(error) {
+        return handleApiError(error, (...args) => this.error(...args), {
+            404: 'Catalog not found.'
+        });
+    }
+}

package/dist/commands/workflow/list.spec.d.ts

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