@output.ai/cli 0.0.1 → 0.0.3

package/README.md

@@ -1,6 +1,6 @@
 # @output.ai/cli
 
-CLI tool for generating Output.ai workflows.
+CLI tool for generating Output workflows.
 
 ## Installation
 
@@ -18,25 +18,25 @@ npx @output.ai/cli
 
 ```bash
 # List all available workflows (simple list, default)
-output-cli workflow list
+output workflow list
 
 # List workflows with custom API URL
-API_URL=http://localhost:3001 output-cli workflow list
+API_URL=http://localhost:3001 output workflow list
 
 # List workflows with authentication
-API_AUTH_TOKEN=your-token output-cli workflow list
+API_AUTH_TOKEN=your-token output workflow list
 
 # Show detailed table view with all information
-output-cli workflow list --format table
+output workflow list --format table
 
 # Show detailed table with expanded parameter info
-output-cli workflow list --format table --detailed
+output workflow list --format table --detailed
 
 # List workflows in JSON format
-output-cli workflow list --format json
+output workflow list --format json
 
 # Filter workflows by name (partial match)
-output-cli workflow list --filter simple
+output workflow list --filter simple
 ```
 
 #### Command Options
@@ -51,16 +51,16 @@ The list command connects to the API server and retrieves all available workflow
 
 ```bash
 # Generate a complete workflow with example steps
-output-cli workflow generate my-workflow --description "My awesome workflow"
+output workflow generate my-workflow --description "My awesome workflow"
 
 # Generate a minimal skeleton workflow
-output-cli workflow generate my-workflow --skeleton
+output workflow generate my-workflow --skeleton
 
 # Generate in a specific directory
-output-cli workflow generate my-workflow --output-dir ./src/workflows
+output workflow generate my-workflow --output-dir ./src/workflows
 
 # Force overwrite existing workflow
-output-cli workflow generate my-workflow --force
+output workflow generate my-workflow --force
 ```
 
 #### Command Options
@@ -83,6 +83,38 @@ my-workflow/
 └── README.md         # Workflow documentation
 ```
 
+### Initialize Agent Configuration
+
+```bash
+# Initialize agent configuration for your coding agent
+output-cli agents init
+
+# Specify your agent provider (default: claude-code)
+output-cli agents init --agent-provider claude-code
+
+# Force overwrite existing configuration
+output-cli agents init --force
+```
+
+#### What It Does
+
+Sets up your coding agent of choice with context files, sub-agents, and slash commands for working with the Output SDK effectively. It creates a `.outputai/` directory and wires up your coding agent to the context files.
+
+**Note:** Currently this only works for [Claude Code](https://claude.ai/code), but we plan to add support for other coding agents over time.
+
+#### Command Options
+
+- `--agent-provider` - Specify the coding agent provider (default: `claude-code`)
+- `--force, -f` - Overwrite existing agent configuration files
+
+#### Output Agent Commands
+
+**`/plan_workflow`** - Guides you through structured workflow planning to create comprehensive implementation blueprints before writing code.
+
+#### Output Sub-Agents
+
+**`workflow_planner`** - A specialized AI agent that helps with workflow architecture and planning, including requirements analysis, schema design, and testing strategy definition.
+
 ## About
 
 Built with [OCLIF](https://oclif.io) - see their documentation for advanced CLI features, plugins, and configuration options.

package/dist/api/generated/api.d.ts

@@ -35,7 +35,7 @@ export type PostWorkflowRunBody = {
 export type PostWorkflowRun200 = {
     /** The workflow execution id */
     workflowId?: string;
-    /** The output of the the workflow */
+    /** The output of the workflow */
     output?: unknown;
 };
 export type PostWorkflowStartBody = {
@@ -156,8 +156,8 @@ export type getWorkflowIdStatusResponseError = (getWorkflowIdStatusResponse404)
     headers: Headers;
 };
 export type getWorkflowIdStatusResponse = (getWorkflowIdStatusResponseSuccess | getWorkflowIdStatusResponseError);
-export declare const getGetWorkflowIdStatusUrl: (id: unknown) => string;
-export declare const getWorkflowIdStatus: (id: unknown, options?: RequestInit) => Promise<getWorkflowIdStatusResponse>;
+export declare const getGetWorkflowIdStatusUrl: (id: string) => string;
+export declare const getWorkflowIdStatus: (id: string, options?: RequestInit) => Promise<getWorkflowIdStatusResponse>;
 /**
  * @summary Stop a workflow execution
  */
@@ -176,8 +176,8 @@ export type patchWorkflowIdStopResponseError = (patchWorkflowIdStopResponse404)
     headers: Headers;
 };
 export type patchWorkflowIdStopResponse = (patchWorkflowIdStopResponseSuccess | patchWorkflowIdStopResponseError);
-export declare const getPatchWorkflowIdStopUrl: (id: unknown) => string;
-export declare const patchWorkflowIdStop: (id: unknown, options?: RequestInit) => Promise<patchWorkflowIdStopResponse>;
+export declare const getPatchWorkflowIdStopUrl: (id: string) => string;
+export declare const patchWorkflowIdStop: (id: string, options?: RequestInit) => Promise<patchWorkflowIdStopResponse>;
 /**
  * @summary Return the output of a workflow
  */
@@ -196,8 +196,8 @@ export type getWorkflowIdOutputResponseError = (getWorkflowIdOutputResponse404)
     headers: Headers;
 };
 export type getWorkflowIdOutputResponse = (getWorkflowIdOutputResponseSuccess | getWorkflowIdOutputResponseError);
-export declare const getGetWorkflowIdOutputUrl: (id: unknown) => string;
-export declare const getWorkflowIdOutput: (id: unknown, options?: RequestInit) => Promise<getWorkflowIdOutputResponse>;
+export declare const getGetWorkflowIdOutputUrl: (id: string) => string;
+export declare const getWorkflowIdOutput: (id: string, options?: RequestInit) => Promise<getWorkflowIdOutputResponse>;
 /**
  * @summary Return the trace of a workflow execution
  */
@@ -216,8 +216,8 @@ export type getWorkflowIdTraceResponseError = (getWorkflowIdTraceResponse404) &
     headers: Headers;
 };
 export type getWorkflowIdTraceResponse = (getWorkflowIdTraceResponseSuccess | getWorkflowIdTraceResponseError);
-export declare const getGetWorkflowIdTraceUrl: (id: unknown) => string;
-export declare const getWorkflowIdTrace: (id: unknown, options?: RequestInit) => Promise<getWorkflowIdTraceResponse>;
+export declare const getGetWorkflowIdTraceUrl: (id: string) => string;
+export declare const getWorkflowIdTrace: (id: string, options?: RequestInit) => Promise<getWorkflowIdTraceResponse>;
 /**
  * @summary Get a specific workflow catalog by ID
  */
@@ -229,8 +229,8 @@ export type getWorkflowCatalogIdResponseSuccess = (getWorkflowCatalogIdResponse2
     headers: Headers;
 };
 export type getWorkflowCatalogIdResponse = (getWorkflowCatalogIdResponseSuccess);
-export declare const getGetWorkflowCatalogIdUrl: (id: unknown) => string;
-export declare const getWorkflowCatalogId: (id: unknown, options?: RequestInit) => Promise<getWorkflowCatalogIdResponse>;
+export declare const getGetWorkflowCatalogIdUrl: (id: string) => string;
+export declare const getWorkflowCatalogId: (id: string, options?: RequestInit) => Promise<getWorkflowCatalogIdResponse>;
 /**
  * @summary Get the default workflow catalog
  */
@@ -255,8 +255,8 @@ export type postWorkflowIdFeedbackResponseSuccess = (postWorkflowIdFeedbackRespo
     headers: Headers;
 };
 export type postWorkflowIdFeedbackResponse = (postWorkflowIdFeedbackResponseSuccess);
-export declare const getPostWorkflowIdFeedbackUrl: (id: unknown) => string;
-export declare const postWorkflowIdFeedback: (id: unknown, postWorkflowIdFeedbackBody: PostWorkflowIdFeedbackBody, options?: RequestInit) => Promise<postWorkflowIdFeedbackResponse>;
+export declare const getPostWorkflowIdFeedbackUrl: (id: string) => string;
+export declare const postWorkflowIdFeedback: (id: string, postWorkflowIdFeedbackBody: PostWorkflowIdFeedbackBody, options?: RequestInit) => Promise<postWorkflowIdFeedbackResponse>;
 /**
  * @summary A dummy post endpoint for test only
  */

package/dist/api/generated/api.js

@@ -2,7 +2,7 @@
  * Generated by orval v7.13.0 🍺
  * Do not edit manually.
  * Output.ai SDK API
- * API for managing and executing Temporal workflows through Flow SDK
+ * API for managing and executing Temporal workflows through Output SDK
  * OpenAPI spec version: 1.0.0
  */
 import { customFetchInstance } from '../http_client.js';

package/dist/commands/agents/init.d.ts

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+export default class Init extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {};
+    static flags: {
+        'agent-provider': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        force: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private prepareTemplateVariables;
+    private processMappings;
+    private ensureDirectoryExists;
+    private fileExists;
+    private createFromTemplate;
+    private createSymlink;
+    private copyFile;
+}

package/dist/commands/agents/init.js

@@ -0,0 +1,175 @@
+import { Command, Flags } from '@oclif/core';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getTemplateDir } from '../../utils/paths.js';
+import { processTemplate } from '../../utils/template.js';
+const AGENT_CONFIGS = {
+    outputai: {
+        id: 'outputai',
+        name: 'OutputAI Core Files',
+        mappings: [
+            {
+                type: 'template',
+                from: 'AGENTS.md.template',
+                to: '.outputai/AGENTS.md'
+            },
+            {
+                type: 'template',
+                from: 'agents/workflow_planner.md.template',
+                to: '.outputai/agents/workflow_planner.md'
+            },
+            {
+                type: 'template',
+                from: 'commands/plan_workflow.md.template',
+                to: '.outputai/commands/plan_workflow.md'
+            }
+        ]
+    },
+    'claude-code': {
+        id: 'claude-code',
+        name: 'Claude Code',
+        mappings: [
+            {
+                type: 'symlink',
+                from: '.outputai/AGENTS.md',
+                to: 'CLAUDE.md'
+            },
+            {
+                type: 'symlink',
+                from: '.outputai/agents/workflow_planner.md',
+                to: '.claude/agents/workflow_planner.md'
+            },
+            {
+                type: 'symlink',
+                from: '.outputai/commands/plan_workflow.md',
+                to: '.claude/commands/plan_workflow.md'
+            }
+        ]
+    }
+};
+export default class Init extends Command {
+    static description = 'Initialize agent configuration files for AI assistant integration';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --agent-provider claude-code',
+        '<%= config.bin %> <%= command.id %> --force'
+    ];
+    static args = {};
+    static flags = {
+        'agent-provider': Flags.string({
+            description: 'Specify the coding agent provider',
+            default: AGENT_CONFIGS['claude-code'].id,
+            options: [AGENT_CONFIGS['claude-code'].id]
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Overwrite existing files',
+            default: false
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(Init);
+        this.log('Initializing agent configuration for Claude Code...');
+        try {
+            const variables = this.prepareTemplateVariables();
+            await this.processMappings(AGENT_CONFIGS.outputai, variables, flags.force);
+            await this.processMappings(AGENT_CONFIGS[flags['agent-provider']], variables, flags.force);
+            this.log('✅ Agent configuration initialized successfully!');
+            this.log('');
+            this.log('Created:');
+            this.log('  • .outputai/ directory with agent and command configurations');
+            this.log('  • .claude/ directory with symlinks for Claude Code integration');
+            this.log('');
+            this.log('Claude Code will automatically detect and use these configurations.');
+        }
+        catch (error) {
+            if (error.code === 'EACCES') {
+                this.error('Permission denied. Please check file permissions and try again.');
+            }
+            this.error(`Failed to initialize agent configuration: ${error.message}`);
+        }
+    }
+    prepareTemplateVariables() {
+        return {
+            date: new Date().toLocaleDateString('en-US', {
+                year: 'numeric',
+                month: 'long',
+                day: 'numeric'
+            })
+        };
+    }
+    async processMappings(config, variables, force) {
+        for (const mapping of config.mappings) {
+            const dir = path.dirname(mapping.to);
+            await this.ensureDirectoryExists(dir);
+            if (!force && await this.fileExists(mapping.to)) {
+                this.warn(`File already exists: ${mapping.to} (use --force to overwrite)`);
+                continue;
+            }
+            switch (mapping.type) {
+                case 'template':
+                    await this.createFromTemplate(mapping.from, mapping.to, variables);
+                    break;
+                case 'symlink':
+                    await this.createSymlink(mapping.from, mapping.to);
+                    break;
+                case 'copy':
+                    await this.copyFile(mapping.from, mapping.to);
+                    break;
+            }
+        }
+    }
+    async ensureDirectoryExists(dir) {
+        try {
+            await fs.mkdir(dir, { recursive: true });
+            this.debug(`Created directory: ${dir}`);
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST') {
+                throw error;
+            }
+        }
+    }
+    async fileExists(filePath) {
+        try {
+            await fs.stat(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async createFromTemplate(template, output, variables) {
+        const templateDir = getTemplateDir('agent_instructions');
+        const templatePath = path.join(templateDir, template);
+        const content = await fs.readFile(templatePath, 'utf-8');
+        const processed = processTemplate(content, variables);
+        await fs.writeFile(output, processed, 'utf-8');
+        this.debug(`Created from template: ${output}`);
+    }
+    async createSymlink(source, target) {
+        try {
+            if (await this.fileExists(target)) {
+                await fs.unlink(target);
+            }
+            const relativePath = path.relative(path.dirname(target), source);
+            await fs.symlink(relativePath, target);
+            this.debug(`Created symlink: ${target} -> ${source}`);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 'ENOTSUP' || code === 'EPERM') {
+                this.debug(`Symlinks not supported, creating copy: ${target}`);
+                const content = await fs.readFile(source, 'utf-8');
+                await fs.writeFile(target, content, 'utf-8');
+                return;
+            }
+            throw error;
+        }
+    }
+    async copyFile(source, target) {
+        const content = await fs.readFile(source, 'utf-8');
+        await fs.writeFile(target, content, 'utf-8');
+        this.debug(`Copied file: ${source} -> ${target}`);
+    }
+}

package/dist/commands/agents/init.spec.d.ts

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

package/dist/commands/agents/init.spec.js

@@ -0,0 +1,227 @@
+/* eslint-disable no-restricted-syntax, @typescript-eslint/no-explicit-any, init-declarations */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import Init from './init.js';
+import { getTemplateDir } from '../../utils/paths.js';
+import { processTemplate } from '../../utils/template.js';
+vi.mock('node:fs/promises');
+vi.mock('node:path', async () => {
+    const actual = await vi.importActual('node:path');
+    return {
+        ...actual,
+        join: vi.fn((...args) => args.join('/')),
+        dirname: vi.fn(p => p.split('/').slice(0, -1).join('/') || '.'),
+        relative: vi.fn((from, to) => {
+            if (to === 'CLAUDE.md' && from === '.') {
+                return '.outputai/AGENTS.md';
+            }
+            if (to.includes('.outputai/agents')) {
+                return `../../.outputai/agents/${path.basename(to)}`;
+            }
+            if (to.includes('.outputai/commands')) {
+                return `../../.outputai/commands/${path.basename(to)}`;
+            }
+            return to;
+        })
+    };
+});
+vi.mock('../../utils/paths.js');
+vi.mock('../../utils/template.js');
+describe('agents init', () => {
+    let mockGetTemplateDir;
+    let mockProcessTemplate;
+    const createTestCommand = (args = []) => {
+        const cmd = new Init(args, {});
+        cmd.log = vi.fn();
+        cmd.warn = vi.fn();
+        cmd.error = vi.fn();
+        cmd.debug = vi.fn();
+        cmd.parse = vi.fn();
+        return cmd;
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+        vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+        vi.mocked(fs.symlink).mockResolvedValue(undefined);
+        vi.mocked(fs.stat).mockRejectedValue({ code: 'ENOENT' });
+        vi.mocked(fs.unlink).mockResolvedValue(undefined);
+        vi.mocked(fs.readFile).mockResolvedValue('Template content with {{date}}');
+        mockGetTemplateDir = vi.mocked(getTemplateDir);
+        mockGetTemplateDir.mockReturnValue('/templates/agent_instructions');
+        mockProcessTemplate = vi.mocked(processTemplate);
+        mockProcessTemplate.mockImplementation((content, variables) => {
+            return content.replace(/\{\{(\w+)\}\}/g, (_match, key) => variables[key] || _match);
+        });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('command structure', () => {
+        it('should have correct description', () => {
+            expect(Init.description).toBeDefined();
+            expect(Init.description).toContain('agent configuration');
+        });
+        it('should have correct examples', () => {
+            expect(Init.examples).toBeDefined();
+            expect(Array.isArray(Init.examples)).toBe(true);
+        });
+        it('should have no required arguments', () => {
+            expect(Init.args).toBeDefined();
+            expect(Object.keys(Init.args)).toHaveLength(0);
+        });
+        it('should have appropriate flags', () => {
+            expect(Init.flags).toBeDefined();
+            expect(Init.flags.force).toBeDefined();
+        });
+    });
+    describe('directory creation', () => {
+        it('should create .outputai directory structure', async () => {
+            const mockMkdir = vi.mocked(fs.mkdir);
+            mockMkdir.mockResolvedValue(undefined);
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.outputai'), expect.objectContaining({ recursive: true }));
+            expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.outputai/agents'), expect.objectContaining({ recursive: true }));
+            expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.outputai/commands'), expect.objectContaining({ recursive: true }));
+        });
+        it('should create .claude directory structure', async () => {
+            const mockMkdir = vi.mocked(fs.mkdir);
+            mockMkdir.mockResolvedValue(undefined);
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.claude'), expect.objectContaining({ recursive: true }));
+            expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.claude/agents'), expect.objectContaining({ recursive: true }));
+            expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.claude/commands'), expect.objectContaining({ recursive: true }));
+        });
+    });
+    describe('file creation from templates', () => {
+        it('should create AGENTS.md file from template', async () => {
+            const mockWriteFile = vi.mocked(fs.writeFile);
+            const mockReadFile = vi.mocked(fs.readFile);
+            mockReadFile.mockResolvedValue('Agent instructions {{date}}');
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(mockReadFile).toHaveBeenCalledWith(expect.stringContaining('AGENTS.md.template'), 'utf-8');
+            expect(mockWriteFile).toHaveBeenCalledWith('.outputai/AGENTS.md', expect.stringContaining('Agent instructions'), 'utf-8');
+        });
+        it('should create all agent configuration files', async () => {
+            const mockWriteFile = vi.mocked(fs.writeFile);
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            const agentFiles = [
+                '.outputai/agents/workflow_planner.md'
+            ];
+            for (const file of agentFiles) {
+                expect(mockWriteFile).toHaveBeenCalledWith(file, expect.any(String), 'utf-8');
+            }
+        });
+        it('should create all command configuration files', async () => {
+            const mockWriteFile = vi.mocked(fs.writeFile);
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            const commandFiles = [
+                '.outputai/commands/plan_workflow.md'
+            ];
+            for (const file of commandFiles) {
+                expect(mockWriteFile).toHaveBeenCalledWith(file, expect.any(String), 'utf-8');
+            }
+        });
+    });
+    describe('symlink creation', () => {
+        it('should create symlink from CLAUDE.md to .outputai/AGENTS.md', async () => {
+            const mockSymlink = vi.mocked(fs.symlink);
+            const mockStat = vi.mocked(fs.stat);
+            mockStat.mockImplementation(async (path) => {
+                if (typeof path === 'string' && path.startsWith('.outputai')) {
+                    return { isFile: () => true };
+                }
+                throw { code: 'ENOENT' };
+            });
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(mockSymlink).toHaveBeenCalledWith('.outputai/AGENTS.md', 'CLAUDE.md');
+        });
+        it('should create symlinks for all agent files', async () => {
+            const mockSymlink = vi.mocked(fs.symlink);
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(mockSymlink).toHaveBeenCalledWith(expect.stringContaining('.outputai/agents/workflow_planner.md'), '.claude/agents/workflow_planner.md');
+        });
+        it('should create symlinks for all command files', async () => {
+            const mockSymlink = vi.mocked(fs.symlink);
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(mockSymlink).toHaveBeenCalledWith(expect.stringContaining('.outputai/commands/plan_workflow.md'), '.claude/commands/plan_workflow.md');
+        });
+        it('should handle Windows by copying files when symlinks are not supported', async () => {
+            const mockSymlink = vi.mocked(fs.symlink);
+            const mockWriteFile = vi.mocked(fs.writeFile);
+            const mockReadFile = vi.mocked(fs.readFile);
+            mockSymlink.mockRejectedValue({ code: 'ENOTSUP' });
+            mockReadFile.mockResolvedValue('File content');
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(mockReadFile).toHaveBeenCalledWith('.outputai/AGENTS.md', 'utf-8');
+            expect(mockWriteFile).toHaveBeenCalledWith('CLAUDE.md', 'File content', 'utf-8');
+        });
+    });
+    describe('error handling', () => {
+        it('should handle existing directory gracefully', async () => {
+            const mockMkdir = vi.mocked(fs.mkdir);
+            mockMkdir.mockRejectedValue({ code: 'EEXIST' });
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(cmd.error).not.toHaveBeenCalled();
+        });
+        it('should handle permission errors', async () => {
+            const mockMkdir = vi.mocked(fs.mkdir);
+            mockMkdir.mockRejectedValue({ code: 'EACCES' });
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(cmd.error).toHaveBeenCalledWith(expect.stringContaining('Permission denied'));
+        });
+        it('should be idempotent (safe to run multiple times)', async () => {
+            const mockWriteFile = vi.mocked(fs.writeFile);
+            mockWriteFile.mockResolvedValue(undefined);
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            await cmd.run();
+            expect(cmd.error).not.toHaveBeenCalled();
+        });
+    });
+    describe('force flag', () => {
+        it('should overwrite existing files when force flag is set', async () => {
+            const mockWriteFile = vi.mocked(fs.writeFile);
+            const mockStat = vi.mocked(fs.stat);
+            mockStat.mockResolvedValue({ isFile: () => true });
+            mockWriteFile.mockResolvedValue(undefined);
+            const cmd = createTestCommand(['--force']);
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: true }, args: {} });
+            await cmd.run();
+            expect(mockWriteFile).toHaveBeenCalled();
+            expect(cmd.warn).not.toHaveBeenCalled();
+        });
+        it('should warn about existing files without force flag', async () => {
+            const mockStat = vi.mocked(fs.stat);
+            mockStat.mockResolvedValue({ isFile: () => true });
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(cmd.warn).toHaveBeenCalledWith(expect.stringContaining('already exists'));
+        });
+    });
+});

package/dist/commands/workflow/generate.js

@@ -2,7 +2,7 @@ import { Args, Command, Flags } from '@oclif/core';
 import { generateWorkflow } from '../../services/workflow_generator.js';
 import { DEFAULT_OUTPUT_DIRS } from '../../utils/paths.js';
 export default class Generate extends Command {
-    static description = 'Generate a new Flow SDK workflow';
+    static description = 'Generate a new Output SDK workflow';
     static examples = [
         '<%= config.bin %> <%= command.id %> my-workflow',
         '<%= config.bin %> <%= command.id %> my-workflow --skeleton',
@@ -38,7 +38,6 @@ export default class Generate extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(Generate);
-        // Check if skeleton flag is required
         if (!flags.skeleton) {
             this.error('Full workflow generation not implemented yet. Please use --skeleton flag');
         }

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

@@ -3,32 +3,27 @@ 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';
-// Mock the generateWorkflow function
 vi.mock('../../services/workflow_generator.js');
 describe('Generate Command', () => {
     let mockGenerateWorkflow;
     let logSpy;
     const createCommand = () => {
         const cmd = new Generate([], {});
-        // Mock OCLIF methods
         cmd.log = vi.fn();
         cmd.error = vi.fn((message) => {
             throw new Error(message);
         });
-        // Mock parse method
         cmd.parse = vi.fn();
         logSpy = cmd.log;
         return cmd;
     };
     beforeEach(() => {
         vi.clearAllMocks();
-        // Mock generateWorkflow function
         mockGenerateWorkflow = vi.mocked(generateWorkflow);
     });
     describe('successful workflow generation', () => {
         it('should generate workflow with skeleton flag', async () => {
             const cmd = createCommand();
-            // Mock parse return
             cmd.parse.mockResolvedValue({
                 args: { name: 'test-workflow' },
                 flags: {
@@ -38,7 +33,6 @@ describe('Generate Command', () => {
                     force: false
                 }
             });
-            // Mock successful generation
             mockGenerateWorkflow.mockResolvedValue({
                 workflowName: 'test-workflow',
                 targetDir: '/tmp/test-workflow',