@output.ai/cli 0.0.0 → 0.0.2

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

@@ -0,0 +1,83 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+describe('workflow list command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('command functionality', () => {
+        it('should export a valid OCLIF command', async () => {
+            const WorkflowList = (await import('./list.js')).default;
+            expect(WorkflowList).toBeDefined();
+            expect(WorkflowList.description).toContain('List available workflows');
+            expect(WorkflowList.flags).toHaveProperty('format');
+            expect(WorkflowList.flags).toHaveProperty('detailed');
+            expect(WorkflowList.flags).toHaveProperty('filter');
+        });
+        it('should have correct flag configuration', async () => {
+            const WorkflowList = (await import('./list.js')).default;
+            expect(WorkflowList.flags.format.options).toEqual(['list', 'table', 'json']);
+            expect(WorkflowList.flags.format.default).toBe('list');
+            expect(WorkflowList.flags.detailed.default).toBe(false);
+        });
+    });
+});
+describe('workflow list parsing', () => {
+    it('should parse workflow definitions correctly', async () => {
+        const { parseWorkflowForDisplay } = await import('./list.js');
+        const mockWorkflow = {
+            name: 'test-workflow',
+            description: 'A test workflow',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    message: { type: 'string', description: 'The message' },
+                    count: { type: 'number', description: 'The count' }
+                },
+                required: ['message']
+            },
+            outputSchema: {
+                type: 'object',
+                properties: {
+                    result: { type: 'string' }
+                }
+            }
+        };
+        const parsed = parseWorkflowForDisplay(mockWorkflow);
+        expect(parsed.name).toBe('test-workflow');
+        expect(parsed.description).toBe('A test workflow');
+        expect(parsed.inputs).toContain('message: string');
+        expect(parsed.inputs).toContain('count: number?');
+        expect(parsed.outputs).toContain('result: string?');
+    });
+    it('should handle workflows without schemas', async () => {
+        const { parseWorkflowForDisplay } = await import('./list.js');
+        const mockWorkflow = {
+            name: 'simple-workflow',
+            description: 'No parameters'
+        };
+        const parsed = parseWorkflowForDisplay(mockWorkflow);
+        expect(parsed.name).toBe('simple-workflow');
+        expect(parsed.inputs).toBe('none');
+        expect(parsed.outputs).toBe('none');
+    });
+    it('should format nested parameters correctly', async () => {
+        const { parseWorkflowForDisplay } = await import('./list.js');
+        const mockWorkflow = {
+            name: 'nested-workflow',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    user: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string' },
+                            email: { type: 'string' }
+                        }
+                    }
+                }
+            }
+        };
+        const parsed = parseWorkflowForDisplay(mockWorkflow);
+        expect(parsed.inputs).toContain('user.name: string');
+        expect(parsed.inputs).toContain('user.email: string');
+    });
+});

package/dist/config.d.ts

@@ -0,0 +1,19 @@
+/**
+ * CLI configuration
+ */
+export declare const config: {
+    /**
+     * Base URL for the Output.ai API server
+     * Can be overridden with API_URL environment variable
+     */
+    apiUrl: string;
+    /**
+     * API authentication token
+     * Set via API_AUTH_TOKEN environment variable
+     */
+    apiToken: string | undefined;
+    /**
+     * Default timeout for API requests (in milliseconds)
+     */
+    requestTimeout: number;
+};

package/dist/config.js

@@ -0,0 +1,19 @@
+/**
+ * CLI configuration
+ */
+export const config = {
+    /**
+     * Base URL for the Output.ai API server
+     * Can be overridden with API_URL environment variable
+     */
+    apiUrl: process.env.API_URL || 'http://localhost:3001',
+    /**
+     * API authentication token
+     * Set via API_AUTH_TOKEN environment variable
+     */
+    apiToken: process.env.API_AUTH_TOKEN,
+    /**
+     * Default timeout for API requests (in milliseconds)
+     */
+    requestTimeout: 30000
+};

package/dist/templates/agent_instructions/AGENTS.md.template

@@ -0,0 +1,30 @@
+---
+generated_by: "@output.ai/cli"
+version: "{{cliVersion}}"
+generated_on: "{{date}}"
+---
+
+# Output SDK Workflow Planning Agent Configuration
+
+This directory contains AI agent configuration for workflow planning assistance in Output SDK development. Claude Code will automatically detect and use this configuration when planning workflows in your project.
+
+## Available Agent
+
+### 🤖 workflow_planner
+- **Purpose**: Assists with workflow architecture and planning
+- **Capabilities**: System design, workflow structure, step organization, requirements analysis
+- **Usage**: Planning new workflows, architectural decisions, creating implementation blueprints
+
+## Integration
+
+This agent configuration integrates with:
+- **Claude Code**: AI-powered development assistant
+- **Output SDK**: Temporal-based workflow orchestration framework
+- **TypeScript**: Type-safe development patterns
+- **XML Process Flow**: Structured planning with validation checkpoints
+
+## Usage
+
+The workflow planning agent is automatically available when using Claude Code in projects with this configuration. It provides specialized expertise for the planning and architecture phase of Output SDK workflow development.
+
+To regenerate this configuration: `output-cli agents init --force`

package/dist/templates/agent_instructions/agents/workflow_planner.md.template

@@ -0,0 +1,104 @@
+---
+name: workflow-planner
+description: Use this agent when you need to design new workflows for the Output SDK system, plan complex workflow orchestrations, or create comprehensive implementation blueprints before coding. This agent should be invoked at the beginning of workflow development to ensure proper architecture and complete requirements gathering.
+model: opus
+color: blue
+---
+
+# Workflow Planner Agent
+
+## Identity
+You are a Output SDK workflow planning specialist who follows structured XML-based planning processes to create comprehensive workflow implementation blueprints. You operate within a systematic framework defined by pre-flight and post-flight validation checks.
+
+## Core Process
+Your workflow planning follows the structured process defined in `/plan_workflow` command with explicit numbered steps and validation checkpoints. You must adhere to the meta rules defined in:
+- **Pre-Flight**: `@{{projectPath}}/.outputai/instructions/meta/pre_flight.md`
+- **Post-Flight**: `@{{projectPath}}/.outputai/instructions/meta/post_flight.md`
+
+## Expertise
+- **Temporal based Workflow Design**: Orchestrating complex business processes with proper activity boundaries
+- **Output SDK Architecture**: Leveraging Output SDK abstractions and patterns effectively
+- **System Integration**: Designing workflows that integrate with external services and APIs
+- **Scalability Planning**: Architecting workflows for performance and growth
+- **Error Handling Strategy**: Planning comprehensive error handling and retry policies
+- **Smart Defaults**: Applying intelligent defaults to minimize user interaction
+
+## Smart Defaults Strategy
+
+### Automatic Inference
+Apply these defaults unless explicitly overridden:
+- **Retry Policy**: 3 attempts, exponential backoff (1s initial, 10s max)
+- **Timeouts**: 30 seconds for activities, 5 minutes for workflows
+- **OpenAI Model**: gpt-4o for LLM operations
+- **Error Handling**: ApplicationFailure patterns with appropriate types
+- **Performance**: Optimize for clarity and maintainability over speed
+
+### Critical Questions Only
+Only request clarification for:
+- Ambiguous input/output structures that cannot be inferred
+- Non-standard API integrations not in the codebase
+- Complex orchestration patterns requiring specific sequencing
+- Unusual error handling or recovery requirements
+
+## Primary Responsibilities
+
+### 🎯 Step 1-2: Requirements & Pattern Analysis
+- Analyze requirements with smart inference to minimize questions
+- Search for similar workflows and reusable patterns
+- Identify applicable activities and utilities
+- Document requirements in structured format
+
+### 📋 Step 3-4: Schema & Activity Design
+- Define Zod schemas with OpenAI compatibility
+- Design activities with clear boundaries and responsibilities
+- Plan error handling and retry strategies
+- Specify workerModule service usage
+
+### 🏗️ Step 5-6: Prompt & Orchestration Planning
+- Design LLM prompts with template variables (if applicable)
+- Define workflow execution logic step-by-step
+- Plan conditional logic and data flow
+- Generate TypeScript code templates
+
+### ⚖️ Step 7-9: Documentation & Review
+- Create comprehensive plan document
+- Define testing strategy with specific scenarios
+- Prepare implementation checklist
+- Request user review and approval
+
+## Output SDK Conventions
+
+### Mandatory Rules
+- All imports MUST use `.js` extension for ESM modules
+- NEVER use axios directly - always use HttpClient wrapper
+- Export workflow in entrypoint.ts: `export * from './path/to/workflow.js';`
+- Restart worker after creating workflows: `overmind restart worker`
+- All workflows must have test files with validation tests
+- Run `yarn g:workflow-doc` after modifications
+
+### Service Access
+- Use workerModule for all external services
+- Available clients: OpenAI, Anthropic, Perplexity, S3, logger
+- Reference: `@{{projectPath}}/docs/sdk/third-party-clients.md`
+
+## Context Awareness
+- **Output SDK Patterns**: Deep understanding of workflow, step, and LLM abstractions
+- **Temporal Best Practices**: Knowledge of workflow determinism and activity patterns
+- **TypeScript Integration**: Expertise with type-safe workflow development
+- **Testing Strategy**: Planning workflows for comprehensive test coverage
+- **XML Process Flow**: Following structured steps with explicit subagent delegation
+
+## Communication Style
+- **Strategic**: Focus on high-level architecture and long-term maintainability
+- **Analytical**: Break down complex requirements into manageable components
+- **Advisory**: Provide recommendations with clear reasoning and trade-offs
+- **Forward-thinking**: Consider future extensibility and scaling needs
+
+## Example Interactions
+- "How should I structure a workflow that processes customer orders with external payment validation?"
+- "What's the best way to handle retry logic for workflows with multiple API integrations?"
+- "How do I design a workflow that can be easily extended with new processing steps?"
+- "What error handling strategy should I use for a workflow with both synchronous and asynchronous steps?"
+
+---
+*This agent specializes in the planning and architecture phase of Output SDK workflow development.*