@output.ai/cli 0.0.6 → 0.0.8

package/dist/services/workflow_planner.spec.js

@@ -1,113 +1,28 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { ensureOutputAIStructure, generatePlanName, writePlanFile, updateAgentTemplates } from './workflow_planner.js';
-import { checkAgentStructure, initializeAgentConfig } from './coding_agents.js';
-import { generateText } from 'local_llm';
-import { loadPrompt } from 'local_prompt';
-import { confirm } from '@inquirer/prompts';
+import { generatePlanName, writePlanFile, updateAgentTemplates } from './workflow_planner.js';
+import { initializeAgentConfig } from './coding_agents.js';
+import { generateText } from '@output.ai/llm';
 import fs from 'node:fs/promises';
 vi.mock('./coding_agents.js');
-vi.mock('local_llm');
-vi.mock('local_prompt');
-vi.mock('@inquirer/prompts');
+vi.mock('@output.ai/llm');
 vi.mock('node:fs/promises');
 describe('workflow-planner service', () => {
     beforeEach(() => {
         vi.clearAllMocks();
     });
-    describe('ensureOutputAIStructure', () => {
-        it('should call agents init when .outputai does not exist', async () => {
-            vi.mocked(checkAgentStructure).mockResolvedValue({
-                dirExists: false,
-                missingFiles: [
-                    '.outputai/AGENTS.md',
-                    '.outputai/agents/workflow_planner.md',
-                    '.outputai/commands/plan_workflow.md',
-                    'CLAUDE.md',
-                    '.claude/agents/workflow_planner.md',
-                    '.claude/commands/plan_workflow.md'
-                ],
-                isComplete: false
-            });
-            vi.mocked(initializeAgentConfig).mockResolvedValue();
-            await ensureOutputAIStructure('/test/project');
-            expect(checkAgentStructure).toHaveBeenCalledWith('/test/project');
-            expect(initializeAgentConfig).toHaveBeenCalledWith(expect.objectContaining({
-                projectRoot: expect.any(String),
-                force: false,
-                agentProvider: 'claude-code'
-            }));
-        });
-        it('should skip initialization if .outputai exists', async () => {
-            vi.mocked(checkAgentStructure).mockResolvedValue({
-                dirExists: true,
-                missingFiles: [],
-                isComplete: true
-            });
-            await ensureOutputAIStructure('/test/project');
-            expect(checkAgentStructure).toHaveBeenCalledWith('/test/project');
-            expect(initializeAgentConfig).not.toHaveBeenCalled();
-        });
-        it('should throw error if agents init fails', async () => {
-            vi.mocked(checkAgentStructure).mockResolvedValue({
-                dirExists: false,
-                missingFiles: [
-                    '.outputai/AGENTS.md',
-                    '.outputai/agents/workflow_planner.md',
-                    '.outputai/commands/plan_workflow.md',
-                    'CLAUDE.md',
-                    '.claude/agents/workflow_planner.md',
-                    '.claude/commands/plan_workflow.md'
-                ],
-                isComplete: false
-            });
-            vi.mocked(initializeAgentConfig).mockRejectedValue(new Error('Init command failed'));
-            await expect(ensureOutputAIStructure('/test/project')).rejects.toThrow('Init command failed');
-        });
-        it('should prompt user when some files are missing', async () => {
-            vi.mocked(checkAgentStructure).mockResolvedValue({
-                dirExists: true,
-                missingFiles: ['.outputai/agents/workflow_planner.md'],
-                isComplete: false
-            });
-            vi.mocked(confirm).mockResolvedValue(true);
-            vi.mocked(initializeAgentConfig).mockResolvedValue();
-            await ensureOutputAIStructure('/test/project');
-            expect(confirm).toHaveBeenCalled();
-            expect(initializeAgentConfig).toHaveBeenCalledWith(expect.objectContaining({
-                force: true
-            }));
-        });
-        it('should throw error when user declines partial init', async () => {
-            vi.mocked(checkAgentStructure).mockResolvedValue({
-                dirExists: true,
-                missingFiles: ['.outputai/agents/workflow_planner.md'],
-                isComplete: false
-            });
-            vi.mocked(confirm).mockResolvedValue(false);
-            await expect(ensureOutputAIStructure('/test/project')).rejects.toThrow('Agent configuration incomplete');
-        });
-    });
     describe('generatePlanName', () => {
         it('should generate plan name with date prefix using LLM', async () => {
-            const mockPrompt = {
-                config: { model: 'claude-sonnet-4-20250514', provider: 'anthropic' },
-                messages: [
-                    { role: 'system', content: 'You are a technical writing assistant...' },
-                    { role: 'user', content: 'Generate a snake_case plan name...' }
-                ]
-            };
-            vi.mocked(loadPrompt).mockReturnValue(mockPrompt);
             vi.mocked(generateText).mockResolvedValue('customer_order_processing');
             const testDate = new Date(2025, 9, 6);
             const planName = await generatePlanName('A workflow that processes customer orders', testDate);
             expect(planName).toMatch(/^2025_10_06_/);
             expect(planName).toBe('2025_10_06_customer_order_processing');
-            expect(loadPrompt).toHaveBeenCalledWith('generate_plan_name@v1', { description: 'A workflow that processes customer orders' });
-            expect(generateText).toHaveBeenCalledWith({ prompt: mockPrompt });
+            expect(generateText).toHaveBeenCalledWith({
+                prompt: 'generate_plan_name@v1',
+                variables: { description: 'A workflow that processes customer orders' }
+            });
         });
         it('should clean and validate LLM response', async () => {
-            const mockPrompt = { config: { provider: 'anthropic', model: 'claude-sonnet-4-20250514' }, messages: [] };
-            vi.mocked(loadPrompt).mockReturnValue(mockPrompt);
             vi.mocked(generateText).mockResolvedValue('  User-Auth & Security!@#  ');
             const testDate = new Date(2025, 9, 6);
             const planName = await generatePlanName('User authentication workflow', testDate);
@@ -115,14 +30,10 @@ describe('workflow-planner service', () => {
             expect(planName).toMatch(/^[0-9_a-z]+$/);
         });
         it('should handle LLM errors gracefully', async () => {
-            const mockPrompt = { config: { provider: 'anthropic', model: 'claude-sonnet-4-20250514' }, messages: [] };
-            vi.mocked(loadPrompt).mockReturnValue(mockPrompt);
             vi.mocked(generateText).mockRejectedValue(new Error('API rate limit exceeded'));
             await expect(generatePlanName('Test workflow')).rejects.toThrow('API rate limit exceeded');
         });
         it('should limit plan name length to 50 characters', async () => {
-            const mockPrompt = { config: { provider: 'anthropic', model: 'claude-sonnet-4-20250514' }, messages: [] };
-            vi.mocked(loadPrompt).mockReturnValue(mockPrompt);
             vi.mocked(generateText).mockResolvedValue('this_is_an_extremely_long_plan_name_that_exceeds_the_maximum_allowed_length_for_file_names');
             const testDate = new Date(2025, 9, 6);
             const planName = await generatePlanName('Long workflow description', testDate);
@@ -130,8 +41,6 @@ describe('workflow-planner service', () => {
             expect(namePart.length).toBeLessThanOrEqual(50);
         });
         it('should handle multiple underscores correctly', async () => {
-            const mockPrompt = { config: { provider: 'anthropic', model: 'claude-sonnet-4-20250514' }, messages: [] };
-            vi.mocked(loadPrompt).mockReturnValue(mockPrompt);
             vi.mocked(generateText).mockResolvedValue('user___auth___workflow');
             const testDate = new Date(2025, 9, 6);
             const planName = await generatePlanName('Test', testDate);

package/dist/templates/agent_instructions/commands/build_workflow.md.template

@@ -0,0 +1,247 @@
+---
+argument-hint: [workflow-plan-file-path] [workflow-name] [workflow-directory]
+description: Workflow Implementation Command for Output SDK
+version: 0.0.1
+model: claude-opus-4-1
+---
+
+Your task is to implement an Output.ai workflow based on a provided plan document.
+
+The workflow skeleton has already been created at: `$3` (if not it should be)
+
+Please read the plan file and implement the workflow according to its specifications.
+
+Use the todo tool to track your progress through the implementation process.
+
+# Implementation Rules
+
+## Overview
+
+Implement the workflow described in the plan document, following Output SDK patterns and best practices.
+
+<pre_flight_check>
+  EXECUTE: @.outputai/instructions/meta/pre_flight.md
+</pre_flight_check>
+
+<process_flow>
+
+<step number="1" name="plan_analysis">
+
+### Step 1: Plan Analysis
+
+Read and understand the plan document.
+
+1. Read the plan file from: `$1`
+2. Identify the workflow name, description, and purpose
+3. Extract input and output schema definitions
+4. List all required steps and their relationships
+5. Note any LLM-based steps that require prompt templates
+6. Understand error handling and retry requirements
+
+</step>
+
+<step number="2" name="workflow_implementation">
+
+### Step 2: Workflow Implementation
+
+Update `$3/workflow.ts` with the workflow definition.
+
+<implementation_checklist>
+  - Import required dependencies (workflow, z from '@output.ai/core')
+  - Define inputSchema based on plan specifications
+  - Define outputSchema based on plan specifications
+  - Import step functions from steps.ts
+  - Implement workflow function with proper orchestration
+  - Handle conditional logic if specified in plan
+  - Add proper error handling
+</implementation_checklist>
+
+<workflow_template>
+```typescript
+import { workflow, z } from '@output.ai/core';
+import { stepName } from './steps.js';
+
+const inputSchema = z.object( {
+  // Define based on plan
+} );
+
+const outputSchema = z.object( {
+  // Define based on plan
+} );
+
+export default workflow( {
+  name: '$2',
+  description: 'Description from plan',
+  inputSchema,
+  outputSchema,
+  fn: async input => {
+    // Implement orchestration logic from plan
+    const result = await stepName( input );
+    return { result };
+  }
+} );
+```
+</workflow_template>
+
+</step>
+
+<step number="3" name="steps_implementation">
+
+### Step 3: Steps Implementation
+
+Update `$3/steps.ts` with all step definitions from the plan.
+
+<implementation_checklist>
+  - Import required dependencies (step, z from '@output.ai/core')
+  - Implement each step with proper schema validation
+  - Add error handling and retry logic as specified
+  - Ensure step names match plan specifications
+  - Add descriptive comments for complex logic
+</implementation_checklist>
+
+<step_template>
+```typescript
+import { step, z } from '@output.ai/core';
+
+export const stepName = step( {
+  name: 'stepName',
+  description: 'Description from plan',
+  inputSchema: z.object( {
+    // Define based on plan
+  } ),
+  outputSchema: z.object( {
+    // Define based on plan
+  } ),
+  fn: async input => {
+    // Implement step logic from plan
+    return output;
+  }
+} );
+```
+</step_template>
+
+</step>
+
+<step number="4" name="prompt_templates">
+
+### Step 4: Prompt Templates (if needed)
+
+If the plan includes LLM-based steps, create prompt templates in `$3/prompts/`.
+
+<decision_tree>
+  IF plan_includes_llm_steps:
+    CREATE prompt_templates
+    UPDATE steps.ts to use loadPrompt and generateText
+  ELSE:
+    SKIP to step 5
+</decision_tree>
+
+<llm_step_template>
+```typescript
+import { step, z } from '@output.ai/core';
+import { generateText } from '@output.ai/llm';
+
+export const llmStep = step( {
+  name: 'llmStep',
+  description: 'LLM-based step',
+  inputSchema: z.object( {
+    param: z.string()
+  } ),
+  outputSchema: z.string(),
+  fn: async ( { param } ) => {
+    const response = await generateText( {
+      prompt: 'prompt_name@v1',
+      variables: { param }
+    } );
+    return response;
+  }
+} );
+```
+</llm_step_template>
+
+<prompt_file_template>
+```
+---
+provider: anthropic
+model: claude-sonnet-4-20250514
+temperature: 0.7
+---
+
+<assistant>
+You are a helpful assistant.
+</assistant>
+
+<user>
+{{ instructions }}
+</user>
+```
+</prompt_file_template>
+
+</step>
+
+<step number="5" name="readme_update">
+
+### Step 5: README Update
+
+Update `$3/README.md` with workflow-specific documentation.
+
+<documentation_requirements>
+  - Update workflow name and description
+  - Document input schema with examples
+  - Document output schema with examples
+  - Explain each step's purpose
+  - Provide usage examples
+  - Document any prerequisites or setup requirements
+  - Include testing instructions
+</documentation_requirements>
+
+</step>
+
+<step number="6" name="validation">
+
+### Step 6: Implementation Validation
+
+Verify the implementation is complete and correct.
+
+<validation_checklist>
+  - All steps from plan are implemented
+  - Input/output schemas match plan specifications
+  - Workflow orchestration logic is correct
+  - Error handling is in place
+  - LLM prompts are created (if needed)
+  - README is updated with accurate information
+  - Code follows Output SDK patterns
+  - TypeScript types are properly defined
+</validation_checklist>
+
+</step>
+
+<step number="7" name="post_flight_check">
+
+### Step 7: Post-Flight Check
+
+Verify the implementation is ready for use.
+
+<post_flight_check>
+  EXECUTE: @.outputai/instructions/meta/post_flight.md
+</post_flight_check>
+
+</step>
+
+</process_flow>
+
+<post_flight_check>
+  EXECUTE: @.outputai/instructions/meta/post_flight.md
+</post_flight_check>
+
+---- START ----
+
+Workflow Name: $2
+
+Workflow Directory: $3
+
+Plan File Path: $1
+
+Additional Instructions:
+
+$ARGUMENTS

package/dist/templates/agent_instructions/commands/plan_workflow.md.template

@@ -85,7 +85,7 @@ Design the workflow with clear single purpose steps and sound orchestration logi
 
 <workflow_template>
 ```typescript
-import { workflow, z } from 'output.ai/core';
+import { workflow, z } from '@output.ai/core';
 import { sumValues } from './steps.js';
 
 const inputSchema = z.object( {
@@ -116,7 +116,7 @@ Design the steps with clear boundaries.
 
 <step_template>
 ```typescript
-import { step, z } from 'output.ai/core';
+import { step, z } from '@output.ai/core';
 
 export const sumValues = step( {
   name: 'sumValues',
@@ -145,9 +145,8 @@ If any of the steps use an LLM, design the prompts for the steps.
 
 <prompt_step_template>
 ```typescript
-import { step, z } from 'output.ai/core';
-import { loadPrompt } from 'output.ai/prompt';
-import { generateText } from 'output.ai/llm';
+import { step, z } from '@output.ai/core';
+import { generateText } from '@output.ai/llm';
 
 export const aiSdkPrompt = step( {
   name: 'aiSdkPrompt',
@@ -157,8 +156,10 @@ export const aiSdkPrompt = step( {
   } ),
   outputSchema: z.string(),
   fn: async ( { topic } ) => {
-    const prompt = loadPrompt( 'prompt@v1', { topic } );
-    const response = await generateText( { prompt } );
+    const response = await generateText( {
+      prompt: 'prompt@v1',
+      variables: { topic }
+    } );
     return response;
   }
 } );

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

@@ -144,9 +144,7 @@ const result = await myStep( { value: 42 } );
 The template includes an example of using LLM with prompts:
 
 ```typescript
-import { loadPrompt } from '@output.ai/prompt';
 import { generateText } from '@output.ai/llm';
-import type { Prompt } from '@output.ai/llm';
 
 export const llmStep = step( {
   name: 'llmStep',
@@ -159,10 +157,10 @@ export const llmStep = step( {
   },
   outputSchema: { type: 'string' },
   fn: async ( input: { userInput: string } ) => {
-    const prompt = loadPrompt( 'prompt@v1', {
-      userInput: input.userInput
+    const response = await generateText( {
+      prompt: 'prompt@v1',
+      variables: { userInput: input.userInput }
     } );
-    const response = await generateText( prompt as Prompt );
     return response;
   }
 } );

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

@@ -1,75 +1,47 @@
-import { step } from '@output.ai/core';
-import { loadPrompt } from '@output.ai/prompt';
+import { step, z } from '@output.ai/core';
 import { generateText } from '@output.ai/llm';
-import type { Prompt } from '@output.ai/llm';
-
-// Define input/output schemas for the LLM step
-const llmInputSchema = {
-  type: 'object',
-  properties: {
-    userInput: { type: 'string' }
-  },
-  required: ['userInput']
-};
-
-const llmOutputSchema = {
-  type: 'string'
-};
 
 // Example step using LLM
 export const exampleLLMStep = step( {
   name: 'exampleLLMStep',
-  description: 'Example step that uses LLM',
-  inputSchema: llmInputSchema,
-  outputSchema: llmOutputSchema,
-  fn: async ( input: { userInput: string } ): Promise<string> => {
-    // Load the prompt template
-    const prompt = loadPrompt( 'prompt@v1', {
-      userInput: input.userInput
+  description: 'Example step that uses LLM to generate text',
+  inputSchema: z.object( {
+    userInput: z.string()
+  } ),
+  outputSchema: z.string(),
+  fn: async ( { userInput } ) => {
+    const response = await generateText( {
+      prompt: 'prompt@v1',
+      variables: { userInput }
     } );
-
-    // Generate text using LLM
-    const response = await generateText( prompt as Prompt );
-
     return response;
   }
 } );
 
-// Define schemas for data processing step
-const processDataInputSchema = {
-  type: 'object',
-  properties: {
-    value: { type: 'number' },
-    type: { type: 'string' }
-  },
-  required: ['value', 'type']
-};
-
-const processDataOutputSchema = {
-  type: 'object',
-  properties: {
-    processed: { type: 'boolean' },
-    timestamp: { type: 'string' },
-    data: { type: 'object' }
-  },
-  required: ['processed', 'timestamp', 'data']
-};
-
 // Example data processing step
 export const processDataStep = step( {
   name: 'processDataStep',
-  description: 'Process input data',
-  inputSchema: processDataInputSchema,
-  outputSchema: processDataOutputSchema,
-  fn: async ( input: { value: number; type: string } ) => {
+  description: 'Process input data and return structured result',
+  inputSchema: z.object( {
+    value: z.number(),
+    type: z.string()
+  } ),
+  outputSchema: z.object( {
+    processed: z.boolean(),
+    timestamp: z.string(),
+    data: z.object( {
+      value: z.number(),
+      type: z.string()
+    } )
+  } ).strict(),
+  fn: async ( { value, type } ) => {
     // TODO: Implement your step logic here
-    console.log( 'Processing data:', input );
+    console.log( 'Processing data:', { value, type } );
 
-    // Example processing
     return {
       processed: true,
       timestamp: new Date().toISOString(),
-      data: input
+      data: { value, type }
     };
   }
 } );

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

@@ -1,67 +1,41 @@
-import { workflow } from '@output.ai/core';
+import { workflow, z } from '@output.ai/core';
 import { exampleLLMStep, processDataStep } from './steps.js';
 
-// Define the input schema for the workflow
-const inputSchema = {
-  type: 'object',
-  properties: {
-    prompt: {
-      type: 'string',
-      description: 'The prompt to send to the LLM'
-    },
-    data: {
-      type: 'object',
-      properties: {
-        value: { type: 'number' },
-        type: { type: 'string' }
-      },
-      required: ['value', 'type']
-    }
-  },
-  required: ['prompt']
-};
-
-// Define the output schema for the workflow
-const outputSchema = {
-  type: 'object',
-  properties: {
-    llmResponse: { type: 'string' },
-    processedData: {
-      type: 'object',
-      properties: {
-        processed: { type: 'boolean' },
-        timestamp: { type: 'string' },
-        data: { type: 'object' }
-      }
-    },
-    message: { type: 'string' }
-  },
-  required: ['llmResponse', 'processedData', 'message']
-};
+const inputSchema = z.object( {
+  prompt: z.string().describe( 'The prompt to send to the LLM' ),
+  data: z.object( {
+    value: z.number(),
+    type: z.string()
+  } ).optional()
+} );
 
-// Define the input type based on the schema
-interface WorkflowInput {
-  prompt: string;
-  data?: {
-    value: number;
-    type: string;
-  };
-}
+const outputSchema = z.object( {
+  llmResponse: z.string(),
+  processedData: z.object( {
+    processed: z.boolean(),
+    timestamp: z.string(),
+    data: z.object( {
+      value: z.number(),
+      type: z.string()
+    } )
+  } ),
+  message: z.string()
+} ).strict();
 
 export default workflow( {
   name: '{{workflowName}}',
   description: '{{description}}',
   inputSchema,
   outputSchema,
-  fn: async ( input: WorkflowInput ) => {
+  fn: async ( { prompt, data } ) => {
     // Call the LLM step with input from workflow
     const llmResponse = await exampleLLMStep( {
-      userInput: input.prompt
+      userInput: prompt
     } );
 
     // Process data if provided, otherwise use defaults
     const processedData = await processDataStep(
-      input.data || { value: 42, type: 'default' }
+      data || { value: 42, type: 'default' }
     );
 
     return {

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/utils/paths.d.ts

@@ -9,7 +9,7 @@ export declare const TEMPLATE_DIRS: {
  * Default output directories
  */
 export declare const DEFAULT_OUTPUT_DIRS: {
-    readonly workflows: "output-workflows/src";
+    readonly workflows: "src";
 };
 /**
  * Resolve the output directory path