@outputai/cli 0.1.3 → 0.1.4-dev.0

package/dist/templates/workflow/README.md.template

@@ -0,0 +1,216 @@
+# {{WorkflowName}} Workflow
+
+{{description}}
+
+## Overview
+
+This was generated using the Output.ai CLI. It provides a starting point for building AI applications with production-ready LLM integration, built-in prompt management, evaluation, and observability.
+
+## Files
+
+- `workflow.ts` - Main workflow definition with input/output schemas
+- `steps.ts` - Activity/step definitions with input/output schemas
+- `evaluators.ts` - Quality evaluators for workflow outputs
+- `types.ts` - Shared Zod schemas and TypeScript types
+- `prompts/` - LLM prompt templates
+- `scenarios/` - Test input scenarios
+
+## File Organization
+
+You can organize your workflow files in two ways:
+
+**Flat files:**
+```
+workflow/
+├── workflow.ts
+├── steps.ts
+├── evaluators.ts
+├── types.ts
+└── utils.ts
+```
+
+**Folder-based:**
+```
+workflow/
+├── workflow.ts
+├── steps/
+│   ├── fetch_data.ts
+│   └── process_data.ts
+├── evaluators/
+│   └── quality.ts
+└── utils/
+    └── helpers.ts
+```
+
+## Import Rules
+
+**Important:** Steps and evaluators are isolated execution units that cannot call each other.
+
+**Steps can import from:**
+- Local utilities (`./utils.ts`, `./utils/*.ts`)
+- Shared utilities (`../../shared/utils/*.ts`)
+- Clients (`../../clients/*.ts`)
+
+**Steps cannot import from:**
+- Other steps or evaluators (activity isolation)
+- Workflow files
+
+**Workflows can import from:**
+- Steps, evaluators, and utilities (local and shared)
+
+## Setup
+
+### Environment Variables
+
+Before running the workflow, configure your API keys in the `.env` file:
+
+```bash
+# Required for LLM functionality
+OPENAI_API_KEY=your_openai_api_key_here
+ANTHROPIC_API_KEY=your_anthropic_api_key_here
+```
+
+## Usage
+
+### Workflow Input
+
+The workflow expects input matching the input schema defined in `types.ts`.
+
+Example:
+```json
+{
+  "text": "Your input text"
+}
+```
+
+### Workflow Output
+
+The workflow returns output matching the output schema defined in `types.ts`.
+
+Example:
+```json
+{
+  "result": "The processed result"
+}
+```
+
+## Development
+
+### Workflow Structure
+
+The workflow follows the Output.ai conventions:
+
+```typescript
+import { workflow } from '@outputai/core';
+import { myStep } from './steps.js';
+import { workflowInputSchema, workflowOutputSchema } from './types.js';
+
+export default workflow( {
+  name: 'workflowName',
+  description: 'Workflow description',
+  inputSchema: workflowInputSchema,
+  outputSchema: workflowOutputSchema,
+  fn: async ( input ) => {
+    const result = await myStep( input );
+    return { result };
+  }
+} );
+```
+
+### Adding New Steps
+
+Define steps in `steps.ts` with schemas:
+
+```typescript
+import { step, z } from '@outputai/core';
+import { generateText, Output } from '@outputai/llm';
+
+export const myStep = step( {
+  name: 'my_step',
+  description: 'Description of what this step does',
+  inputSchema: z.object( {
+    text: z.string()
+  } ),
+  outputSchema: z.object( {
+    result: z.string()
+  } ),
+  fn: async ( { text } ) => {
+    const { output } = await generateText( {
+      prompt: 'my_prompt@v1',
+      variables: { text },
+      output: Output.object( {
+        schema: z.object( { result: z.string() } )
+      } )
+    } );
+    return output;
+  }
+} );
+```
+
+### Adding Evaluators
+
+Define evaluators in `evaluators.ts`:
+
+```typescript
+import { evaluator, z, EvaluationVerdictResult } from '@outputai/core';
+import { generateText, Output } from '@outputai/llm';
+
+export const evaluateQuality = evaluator( {
+  name: 'evaluate_quality',
+  description: 'Evaluate output quality',
+  inputSchema: z.object( {
+    input: z.string(),
+    output: z.string()
+  } ),
+  fn: async ( { input, output } ) => {
+    const { output: evaluation } = await generateText( {
+      prompt: 'evaluate@v1',
+      variables: { input, output },
+      output: Output.object( { schema: EvaluationVerdictResult.schema } )
+    } );
+
+    return new EvaluationVerdictResult( evaluation );
+  }
+} );
+```
+
+### Creating Prompt Templates
+
+Create prompt files in `prompts/` following the pattern:
+- File naming: `promptName@v1.prompt`
+- Include YAML frontmatter with provider, model, temperature, and maxTokens
+- Use LiquidJS syntax for variables: `{{ variableName }}`
+
+Example prompt file:
+```
+---
+provider: anthropic
+model: claude-haiku-4-5
+temperature: 0.3
+maxTokens: 1024
+---
+
+<system>
+You are an expert analyst.
+</system>
+
+<user>
+{{ text }}
+</user>
+```
+
+## Testing
+
+To test your workflow:
+
+1. Start development services with `npx output dev`
+2. Execute the workflow in a new terminal:
+
+```bash
+npx output workflow run {{workflowName}} test_input
+```
+
+## Resources
+
+- [Output.ai Documentation](https://docs.output.ai)
+- [Temporal Documentation](https://docs.temporal.io)

package/dist/templates/workflow/evaluators.ts.template

@@ -0,0 +1,21 @@
+import { evaluator, z, EvaluationVerdictResult } from '@outputai/core';
+import { generateText, Output } from '@outputai/llm';
+
+// TODO: Update the evaluator to assess your workflow's output quality
+export const evaluate{{WorkflowName}} = evaluator( {
+  name: 'evaluate_{{workflowName}}',
+  description: 'Evaluate the quality of {{workflowName}} output',
+  inputSchema: z.object( {
+    input: z.string(),
+    output: z.string()
+  } ),
+  fn: async ( { input, output } ) => {
+    const { output: evaluation } = await generateText( {
+      prompt: 'example@v1',
+      variables: { text: `Input: ${input}\nOutput: ${output}\n\nDoes the output adequately address the input?` },
+      output: Output.object( { schema: EvaluationVerdictResult.schema } )
+    } );
+
+    return new EvaluationVerdictResult( evaluation );
+  }
+} );

package/dist/templates/workflow/prompts/example@v1.prompt.template

@@ -0,0 +1,15 @@
+---
+provider: anthropic
+model: claude-haiku-4-5
+temperature: 0.3
+maxTokens: 4096
+---
+
+<system>
+You are a helpful assistant for the {{workflowName}} workflow.
+</system>
+
+<!-- TODO: Update this prompt to fit your use case -->
+<user>
+\{{ text }}
+</user>

package/dist/templates/workflow/scenarios/test_input.json.template

@@ -0,0 +1,3 @@
+{
+  "text": "Artificial intelligence has transformed industries from healthcare to finance. Machine learning models now diagnose diseases, predict market trends, and automate complex decision-making processes. However, challenges remain around bias, interpretability, and the ethical implications of automated systems."
+}

package/dist/templates/workflow/steps.ts.template

@@ -0,0 +1,20 @@
+import { step, z } from '@outputai/core';
+import { generateText } from '@outputai/llm';
+
+export const processText = step( {
+  name: 'process_text',
+  description: 'Process text using an LLM',
+  inputSchema: z.object( {
+    text: z.string()
+  } ),
+  outputSchema: z.string(),
+  // TODO: Update or replace the generateText call to fit your use case
+  fn: async ( { text } ) => {
+    const { result } = await generateText( {
+      prompt: 'example@v1',
+      variables: { text }
+    } );
+
+    return result;
+  }
+} );

package/dist/templates/workflow/types.ts.template

@@ -0,0 +1,13 @@
+import { z } from '@outputai/core';
+
+// TODO: Define schemas that match your workflow's input and output
+export const workflowInputSchema = z.object( {
+  text: z.string().describe( 'The input text to process' )
+} );
+
+export const workflowOutputSchema = z.object( {
+  result: z.string().describe( 'The processed result' )
+} );
+
+export type WorkflowInput = z.infer<typeof workflowInputSchema>;
+export type WorkflowOutput = z.infer<typeof workflowOutputSchema>;

package/dist/templates/workflow/workflow.ts.template

@@ -0,0 +1,23 @@
+import { workflow } from '@outputai/core';
+import { processText } from './steps.js';
+import { workflowInputSchema, workflowOutputSchema } from './types.js';
+
+export default workflow( {
+  name: '{{workflowName}}',
+  description: '{{description}}',
+  inputSchema: workflowInputSchema,
+  outputSchema: workflowOutputSchema,
+  // TODO: Update the workflow function to match your use case
+  fn: async ( { text } ) => {
+    const result = await processText( { text } );
+
+    return { result };
+  },
+  options: {
+    activityOptions: {
+      retry: {
+        maximumAttempts: 3
+      }
+    }
+  }
+} );

package/dist/test_helpers/mocks.d.ts

@@ -0,0 +1,38 @@
+import type { Mock } from 'vitest';
+/**
+ * Mock for @anthropic-ai/claude-agent-sdk
+ */
+export declare const mockClaudeAgentSDK: {
+    Agent: Mock;
+};
+/**
+ * Mock for @outputai/llm
+ */
+export declare const mockLLM: {
+    generateText: Mock;
+};
+/**
+ * Mock for child_process spawn (for agent commands)
+ */
+export declare const mockSpawn: Mock;
+/**
+ * Mock for fs/promises
+ */
+export declare const mockFS: {
+    access: Mock;
+    mkdir: Mock;
+    writeFile: Mock;
+    readFile: Mock;
+    stat: Mock;
+};
+/**
+ * Mock for @inquirer/prompts
+ */
+export declare const mockInquirer: {
+    input: Mock;
+    confirm: Mock;
+};
+/**
+ * Reset all mocks
+ */
+export declare function resetAllMocks(): void;

package/dist/test_helpers/mocks.js

@@ -0,0 +1,77 @@
+/**
+ * Shared test mocks for workflow plan command
+ */
+import { vi } from 'vitest';
+/**
+ * Mock for @anthropic-ai/claude-agent-sdk
+ */
+export const mockClaudeAgentSDK = {
+    Agent: vi.fn().mockImplementation(() => ({
+        execute: vi.fn().mockResolvedValue({
+            output: 'Mock plan output from claude-code'
+        })
+    }))
+};
+/**
+ * Mock for @outputai/llm
+ */
+export const mockLLM = {
+    generateText: vi.fn().mockResolvedValue({
+        text: 'workflow_plan_name',
+        sources: [],
+        usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+        finishReason: 'stop'
+    })
+};
+/**
+ * Mock for child_process spawn (for agent commands)
+ */
+export const mockSpawn = vi.fn().mockImplementation(() => {
+    const mockChild = {
+        on: vi.fn((event, callback) => {
+            if (event === 'close') {
+                // Simulate successful process exit
+                setTimeout(() => callback(0), 0);
+            }
+            return mockChild;
+        })
+    };
+    return mockChild;
+});
+/**
+ * Mock for fs/promises
+ */
+export const mockFS = {
+    access: vi.fn().mockRejectedValue({ code: 'ENOENT' }), // Default: file doesn't exist
+    mkdir: vi.fn().mockResolvedValue(undefined),
+    writeFile: vi.fn().mockResolvedValue(undefined),
+    readFile: vi.fn().mockResolvedValue('template content'),
+    stat: vi.fn().mockRejectedValue({ code: 'ENOENT' })
+};
+/**
+ * Mock for @inquirer/prompts
+ */
+export const mockInquirer = {
+    input: vi.fn().mockResolvedValue('Mock workflow description'),
+    confirm: vi.fn().mockResolvedValue(true)
+};
+/**
+ * Reset all mocks
+ */
+export function resetAllMocks() {
+    vi.clearAllMocks();
+    // Reset mock implementations to defaults
+    mockFS.access.mockRejectedValue({ code: 'ENOENT' });
+    mockFS.mkdir.mockResolvedValue(undefined);
+    mockFS.writeFile.mockResolvedValue(undefined);
+    mockFS.readFile.mockResolvedValue('template content');
+    mockFS.stat.mockRejectedValue({ code: 'ENOENT' });
+    mockLLM.generateText.mockResolvedValue({
+        text: 'workflow_plan_name',
+        sources: [],
+        usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+        finishReason: 'stop'
+    });
+    mockInquirer.input.mockResolvedValue('Mock workflow description');
+    mockInquirer.confirm.mockResolvedValue(true);
+}

package/dist/types/cost.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Cost Calculator Types
+ *
+ * TypeScript interfaces for trace parsing, pricing configuration, and cost reports.
+ */
+export interface TokenUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    cachedInputTokens?: number;
+    reasoningTokens?: number;
+}
+export interface TraceNode {
+    id?: string;
+    kind: string;
+    name?: string;
+    startedAt?: number;
+    endedAt?: number;
+    children?: TraceNode[];
+    input?: Record<string, unknown>;
+    output?: Record<string, unknown> & {
+        usage?: TokenUsage;
+    };
+}
+export interface LLMCall {
+    stepName: string;
+    llmName: string;
+    model: string;
+    usage: TokenUsage;
+}
+export interface HTTPCall {
+    stepName: string;
+    url: string;
+    method: string;
+    input: Record<string, unknown>;
+    output: Record<string, unknown>;
+    status?: number;
+}
+export interface ModelPricing {
+    provider: string;
+    input: number;
+    output: number;
+    cached_input?: number;
+    reasoning?: number;
+}
+export interface EndpointConfig {
+    pattern: string;
+    units_per_request?: number;
+    units_per_line?: number;
+    price?: number;
+    price_per_item?: number;
+    items_path?: string;
+}
+export interface ServiceConfig {
+    type: 'token' | 'unit' | 'request' | 'response_cost';
+    url_pattern: string;
+    usage_path?: string;
+    per_million?: number;
+    input_field?: string;
+    output_field?: string;
+    input_per_million?: number;
+    output_per_million?: number;
+    price_per_unit?: number;
+    endpoints?: Record<string, EndpointConfig>;
+    model_path?: string;
+    models?: Record<string, number>;
+    default_price?: number;
+    cost_path?: string;
+    billable_method?: string;
+    fallback_models?: Record<string, number>;
+    default_fallback?: number;
+}
+export interface PricingConfig {
+    models: Record<string, ModelPricing>;
+    services: Record<string, ServiceConfig>;
+}
+export interface LLMCostResult {
+    step: string;
+    model: string;
+    input: number;
+    output: number;
+    cached: number;
+    reasoning: number;
+    cost: number;
+    warning?: string;
+}
+export interface ServiceCostResult {
+    step: string;
+    cost: number;
+    usage: string;
+    model?: string;
+    endpoint?: string;
+    warning?: string;
+    details?: Record<string, unknown>;
+}
+export interface ServiceCostSummary {
+    serviceName: string;
+    calls: ServiceCostResult[];
+    totalCost: number;
+}
+export interface CostReport {
+    traceFile: string;
+    workflowName: string;
+    durationMs: number | null;
+    llmCalls: LLMCostResult[];
+    llmTotalCost: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalCachedTokens: number;
+    totalReasoningTokens: number;
+    unknownModels: string[];
+    services: ServiceCostSummary[];
+    serviceTotalCost: number;
+    totalCost: number;
+}
+export interface LLMModelSummary {
+    model: string;
+    count: number;
+    cost: number;
+}
+export interface ServiceSummary {
+    serviceName: string;
+    callCount: number;
+    cost: number;
+}
+export interface VerboseFlags {
+    hasReasoning: boolean;
+    hasCached: boolean;
+}
+export interface ParsedCostData {
+    traceFile: string;
+    workflowName: string;
+    duration: string;
+    llmModels: LLMModelSummary[];
+    llmTotalCalls: number;
+    llmTotalCost: number;
+    services: ServiceSummary[];
+    serviceTotalCalls: number;
+    serviceTotalCost: number;
+    verbose: VerboseFlags;
+    llmCalls: LLMCostResult[];
+    serviceDetails: ServiceCostSummary[];
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalCachedTokens: number;
+    totalReasoningTokens: number;
+    totalCost: number;
+    unknownModels: string[];
+    isEmpty: boolean;
+}

package/dist/types/cost.js

@@ -0,0 +1,6 @@
+/**
+ * Cost Calculator Types
+ *
+ * TypeScript interfaces for trace parsing, pricing configuration, and cost reports.
+ */
+export {};

package/dist/types/domain.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Domain-specific types for improved type safety
+ */
+export type TodoStatus = 'pending' | 'in_progress' | 'completed';
+export type FileMappingType = 'template' | 'symlink' | 'copy';
+export type InstructionsType = 'plan' | 'build';
+export interface Todo {
+    content: string;
+    activeForm: string;
+    status: TodoStatus;
+}
+export interface ValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+export interface SystemValidation {
+    missingCommands: string[];
+    hasIssues: boolean;
+}

package/dist/types/domain.js

@@ -0,0 +1,4 @@
+/**
+ * Domain-specific types for improved type safety
+ */
+export {};

package/dist/types/errors.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Error thrown when a workflow already exists
+ */
+export declare class WorkflowExistsError extends Error {
+    constructor(workflowName: string, targetPath: string);
+}
+/**
+ * Error thrown when workflow name is invalid
+ */
+export declare class InvalidNameError extends Error {
+    constructor(name: string);
+}
+/**
+ * Error thrown when template file is not found
+ */
+export declare class TemplateNotFoundError extends Error {
+    constructor(templateFile: string);
+}
+/**
+ * Error thrown when output directory is invalid or inaccessible
+ */
+export declare class InvalidOutputDirectoryError extends Error {
+    constructor(outputDir: string, reason?: string);
+}
+/**
+ * Error thrown when folder already exists during initialization
+ */
+export declare class FolderAlreadyExistsError extends Error {
+    folderPath: string;
+    constructor(folderPath: string);
+}
+/**
+ * Error thrown when user cancels initialization
+ */
+export declare class UserCancelledError extends Error {
+    constructor();
+}
+/**
+ * Type-safe error wrapper that preserves original error with context
+ */
+export declare class ProjectInitError extends Error {
+    readonly originalError: Error;
+    readonly projectPath: string | null;
+    constructor(message: string, originalError: Error, projectPath?: string | null);
+}
+/**
+ * Error thrown when directory creation fails with project context
+ */
+export declare class DirectoryCreationError extends Error {
+    readonly projectPath: string;
+    /**
+     * @param message - The error message
+     * @param projectPath - The path where directory creation failed
+     */
+    constructor(message: string, projectPath: string);
+}
+/**
+ * Error thrown when a Claude CLI plugin command fails
+ */
+export declare class ClaudePluginError extends Error {
+    readonly commandName: string;
+    readonly originalError?: Error | undefined;
+    /**
+     * @param commandName - The Claude command that failed (e.g., 'plugin update outputai')
+     * @param originalError - The underlying error from the command execution
+     */
+    constructor(commandName: string, originalError?: Error | undefined);
+}