@output.ai/cli 0.5.6 → 0.7.0

package/dist/templates/agent_instructions/{AGENTS.md.template → dotoutputai/AGENTS.md.template}

@@ -205,21 +205,23 @@ throw new FatalError('Critical failure - do not retry');
 throw new ValidationError('Invalid input format');
 ```
 
-## Sub-Agents
+## Claude Code Sub-Agents
 
 For workflow planning and implementation:
-- workflow-planner: `.claude/agents/workflow_planner.md` - Workflow architecture specialist
-- workflow-quality: `.claude/agents/workflow_quality.md` - Workflow quality and best practices specialist
-- workflow-prompt-writer: `.claude/agents/workflow_prompt_writer.md` - Prompt file creation and review specialist
-- workflow-context-fetcher: `.claude/agents/workflow_context_fetcher.md` - Efficient context retrieval (used by other agents)
-- workflow-debugger: `.claude/agents/workflow_debugger.md` - Workflow debugging specialist
 
-## Commands
+- workflow-planner: Workflow architecture specialist
+- workflow-quality: Workflow quality and best practices specialist
+- workflow-prompt-writer: Prompt file creation and review specialist
+- workflow-context-fetcher: Efficient context retrieval (used by other agents)
+- workflow-debugger: Workflow debugging specialist
+
+## Claude Code Commands
 
 For workflow planning and implementation:
-- /plan_workflow: `.claude/commands/plan_workflow.md` - Planning command
-- /build_workflow: `.claude/commands/build_workflow.md` - Implementation command
-- /debug_workflow: `.claude/commands/debug_workflow.md` - Debugging command
+
+- /outputai:plan_workflow: Workflow Planning command
+- /outputai:build_workflow: Workflow Implementation command
+- /outputai:debug_workflow: Workflow Debugging command
 
 ## Configuration
 

package/dist/utils/claude.d.ts

@@ -0,0 +1,5 @@
+export interface ExecuteClaudeCommandOptions {
+    ignoreFailure?: boolean;
+}
+export declare function isClaudeCliAvailable(): boolean;
+export declare function executeClaudeCommand(args: string[], cwd: string, options?: ExecuteClaudeCommandOptions): Promise<void>;

package/dist/utils/claude.js

@@ -0,0 +1,19 @@
+import { spawnSync } from 'node:child_process';
+import { executeCommand } from './process.js';
+export function isClaudeCliAvailable() {
+    const result = spawnSync('claude', ['--version'], { encoding: 'utf8' });
+    return result.status === 0;
+}
+export async function executeClaudeCommand(args, cwd, options) {
+    if (!isClaudeCliAvailable()) {
+        throw new Error('Claude CLI not found. Please install Claude Code CLI and ensure \'claude\' is in your PATH.');
+    }
+    try {
+        await executeCommand('claude', args, cwd);
+    }
+    catch (error) {
+        if (!options?.ignoreFailure) {
+            throw error;
+        }
+    }
+}

package/dist/utils/claude.spec.d.ts

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

package/dist/utils/claude.spec.js

@@ -0,0 +1,119 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { isClaudeCliAvailable, executeClaudeCommand } from './claude.js';
+import { spawnSync } from 'node:child_process';
+import * as processModule from './process.js';
+vi.mock('node:child_process', () => ({
+    spawnSync: vi.fn()
+}));
+vi.mock('./process.js', () => ({
+    executeCommand: vi.fn()
+}));
+describe('claude utilities', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('isClaudeCliAvailable', () => {
+        it('should return true when claude CLI is available', () => {
+            vi.mocked(spawnSync).mockReturnValue({
+                status: 0,
+                stdout: 'claude 1.0.0',
+                stderr: '',
+                pid: 1234,
+                output: [],
+                signal: null
+            });
+            const result = isClaudeCliAvailable();
+            expect(result).toBe(true);
+            expect(spawnSync).toHaveBeenCalledWith('claude', ['--version'], { encoding: 'utf8' });
+        });
+        it('should return false when claude CLI is not found', () => {
+            vi.mocked(spawnSync).mockReturnValue({
+                status: 1,
+                stdout: '',
+                stderr: 'command not found',
+                pid: 1234,
+                output: [],
+                signal: null
+            });
+            const result = isClaudeCliAvailable();
+            expect(result).toBe(false);
+        });
+        it('should return false when status is null', () => {
+            vi.mocked(spawnSync).mockReturnValue({
+                status: null,
+                stdout: '',
+                stderr: '',
+                pid: 1234,
+                output: [],
+                signal: 'SIGTERM'
+            });
+            const result = isClaudeCliAvailable();
+            expect(result).toBe(false);
+        });
+    });
+    describe('executeClaudeCommand', () => {
+        it('should throw error when Claude CLI is not available', async () => {
+            vi.mocked(spawnSync).mockReturnValue({
+                status: 1,
+                stdout: '',
+                stderr: '',
+                pid: 1234,
+                output: [],
+                signal: null
+            });
+            await expect(executeClaudeCommand(['plugin', 'list'], '/test'))
+                .rejects.toThrow('Claude CLI not found');
+            expect(processModule.executeCommand).not.toHaveBeenCalled();
+        });
+        it('should call executeCommand with correct arguments when CLI is available', async () => {
+            vi.mocked(spawnSync).mockReturnValue({
+                status: 0,
+                stdout: '',
+                stderr: '',
+                pid: 1234,
+                output: [],
+                signal: null
+            });
+            vi.mocked(processModule.executeCommand).mockResolvedValue({ stderr: [] });
+            await executeClaudeCommand(['plugin', 'install', 'test'], '/project');
+            expect(processModule.executeCommand).toHaveBeenCalledWith('claude', ['plugin', 'install', 'test'], '/project');
+        });
+        it('should propagate errors when ignoreFailure is not set', async () => {
+            vi.mocked(spawnSync).mockReturnValue({
+                status: 0,
+                stdout: '',
+                stderr: '',
+                pid: 1234,
+                output: [],
+                signal: null
+            });
+            vi.mocked(processModule.executeCommand).mockRejectedValue(new Error('Command failed'));
+            await expect(executeClaudeCommand(['plugin', 'list'], '/test'))
+                .rejects.toThrow('Command failed');
+        });
+        it('should suppress errors when ignoreFailure is true', async () => {
+            vi.mocked(spawnSync).mockReturnValue({
+                status: 0,
+                stdout: '',
+                stderr: '',
+                pid: 1234,
+                output: [],
+                signal: null
+            });
+            vi.mocked(processModule.executeCommand).mockRejectedValue(new Error('Command failed'));
+            await expect(executeClaudeCommand(['plugin', 'list'], '/test', { ignoreFailure: true })).resolves.toBeUndefined();
+        });
+        it('should not suppress errors when ignoreFailure is false', async () => {
+            vi.mocked(spawnSync).mockReturnValue({
+                status: 0,
+                stdout: '',
+                stderr: '',
+                pid: 1234,
+                output: [],
+                signal: null
+            });
+            vi.mocked(processModule.executeCommand).mockRejectedValue(new Error('Command failed'));
+            await expect(executeClaudeCommand(['plugin', 'list'], '/test', { ignoreFailure: false })).rejects.toThrow('Command failed');
+        });
+    });
+});

package/dist/utils/paths.d.ts

@@ -23,7 +23,3 @@ export declare function createTargetDir(outputDir: string, workflowName: string)
  * Get the template directory for a specific template type
  */
 export declare function getTemplateDir(templateType: keyof typeof TEMPLATE_DIRS): string;
-/**
- * Get the agent instruction directory for a specific category
- */
-export declare function getAgentInstructionDir(category: 'agents' | 'commands'): string;

package/dist/utils/paths.js

@@ -34,9 +34,3 @@ export function createTargetDir(outputDir, workflowName) {
 export function getTemplateDir(templateType) {
     return TEMPLATE_DIRS[templateType];
 }
-/**
- * Get the agent instruction directory for a specific category
- */
-export function getAgentInstructionDir(category) {
-    return path.join(TEMPLATE_DIRS.agent_instructions, category);
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/cli",
-  "version": "0.5.6",
+  "version": "0.7.0",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",
@@ -21,13 +21,13 @@
     "prebuild": "npm run generate:api"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "0.1.19",
+    "@anthropic-ai/claude-agent-sdk": "0.1.71",
     "@inquirer/prompts": "7.9.0",
     "@oclif/core": "4.5.6",
     "@oclif/plugin-help": "6.2.33",
     "@oclif/plugin-plugins": "5.4.50",
-    "@output.ai/llm": ">=0.0.1",
     "@output.ai/http": ">=0.0.1",
+    "@output.ai/llm": ">=0.0.1",
     "change-case": "5.4.4",
     "cli-progress": "3.12.0",
     "cli-table3": "0.6.5",

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

@@ -1,82 +0,0 @@
----
-name: workflow-context-fetcher
-description: Use proactively to retrieve and extract relevant information from Output SDK project documentation files. Checks if content is already in context before returning.
-tools: Read, Grep, Glob
-model: haiku
-color: blue
----
-
-# Output SDK Context Fetcher Agent
-
-You are a specialized information retrieval agent for Output SDK workflows. Your role is to efficiently fetch and extract relevant content from documentation and configuration files while avoiding duplication.
-
-## Core Responsibilities
-
-1. **Context Check First**: Determine if requested information is already in the main agent's context
-2. **Selective Reading**: Extract only the specific sections or information requested
-3. **Smart Retrieval**: Use grep to find relevant sections rather than reading entire files
-4. **Return Efficiently**: Provide only new information not already in context
-
-## Supported File Types
-
-### Configuration & Meta
-- `.outputai/meta/pre_flight.md` - Pre-execution validation rules
-- `.outputai/meta/post_flight.md` - Post-execution validation checks
-- `.outputai/AGENTS.md` - Main project context (CLAUDE.md)
-
-### Agent Instructions
-- `.outputai/agents/*.md` - Specialist agent definitions
-- `.outputai/commands/*.md` - Command definitions
-
-### Workflow Files
-- `src/workflows/*/workflow.ts` - Workflow definitions
-- `src/workflows/*/steps.ts` - Step implementations
-- `src/workflows/*/evaluators.ts` - Evaluator definitions
-- `src/workflows/*/prompts/*.prompt` - LLM prompt templates
-- `src/workflows/*/scenarios/*.json` - Test scenarios
-
-## Workflow
-
-1. Check if the requested information appears to be in context already
-2. If not in context, locate the requested file(s)
-3. Extract only the relevant sections
-4. Return the specific information needed
-
-## Output Format
-
-For new information:
-```
-📄 Retrieved from [file-path]
-
-[Extracted content]
-```
-
-For already-in-context information:
-```
-✓ Already in context: [brief description of what was requested]
-```
-
-## Smart Extraction Examples
-
-Request: "Get the pre-flight rules"
-→ Extract only `.outputai/meta/pre_flight.md`, not other meta files
-
-Request: "Find existing workflow patterns"
-→ Scan `src/workflows/*/workflow.ts` for patterns
-
-Request: "Get retry policy defaults"
-→ Use grep to find retry-related sections in pre_flight.md or AGENTS.md
-
-Request: "Find how existing steps use httpClient"
-→ Search `src/workflows/*/steps.ts` for httpClient patterns
-
-## Important Constraints
-
-- Never return information already visible in current context
-- Extract minimal necessary content
-- Use grep for targeted searches
-- Never modify any files
-- Keep responses concise
-
----
-*This agent specializes in efficient context retrieval for Output SDK projects.*

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

@@ -1,98 +0,0 @@
----
-name: workflow-debugger
-description: Use this agent when you need to debug Output SDK workflows in local development. Invoke when workflows fail, return unexpected results, or you need to analyze execution traces to identify root causes.
-model: opus
-color: yellow
----
-
-# Output SDK Workflow Debugger Agent
-
-## Identity
-
-You are an Output SDK debugging expert who specializes in diagnosing and resolving workflow execution issues in local development environments. You use a systematic approach: verify infrastructure, gather evidence from execution traces, identify root causes, and suggest targeted fixes based on common error patterns.
-
-## Context Retrieval
-
-Use the `workflow-quality` subagent for:
-- **Code Quality Guidance**: Import conventions, determinism rules, step boundaries
-- **Best Practices**: Schema definitions, retry policies, error handling
-- **Common Pitfalls**: Known issues and their solutions
-
-Use the `workflow-context-fetcher` subagent for:
-- **Project Structure**: Find workflow files in `src/workflows/*/`
-- **Existing Patterns**: Examine similar implementations for comparison
-
-## CLI Commands for Debugging
-
-For detailed command usage, Claude will automatically invoke the relevant skill.
-
-### Quick Reference
-
-| Command | Purpose |
-|---------|---------|
-| `npx output dev` | Start development services |
-| `npx output workflow list` | List available workflows |
-| `npx output workflow runs list` | List execution history |
-| `npx output workflow run` | Execute synchronously |
-| `npx output workflow start` | Start asynchronously |
-| `npx output workflow status` | Check execution status |
-| `npx output workflow result` | Get execution result |
-| `npx output workflow stop` | Stop running workflow |
-| `npx output workflow debug` | Analyze execution trace |
-
-## Temporal UI
-
-For visual workflow inspection and detailed execution timelines, access the Temporal Web UI at:
-
-**http://localhost:8080**
-
-The Temporal UI provides real-time visibility into workflow executions, event history, and task queues.
-
-## Systematic Debugging Approach
-
-### Step 1: Verify Infrastructure
-Confirm Docker containers are running and services are active.
-- **Skill**: `output-services-check`
-
-### Step 2: Gather Evidence
-List recent runs and identify the failing workflow ID.
-- **Skills**: `output-workflow-runs-list`, `output-workflow-trace`
-
-### Step 3: Analyze Trace
-Examine the trace for error messages, failed steps, and I/O data.
-- **Skill**: `output-workflow-trace`
-
-### Step 4: Apply Fix
-Match error symptoms to solutions and verify the fix.
-- **Skills**: `output-error-*` (matched by symptoms)
-
-## Example Interaction
-
-**User**: "My workflow is failing but I don't know why. The run ID is abc123."
-
-**Agent**: Let me help you debug this workflow. First, let's get the execution trace:
-
-```bash
-npx output workflow debug abc123 --format json
-```
-
-This will show us exactly where the workflow failed and what error occurred. While I analyze the trace, you can also check the Temporal UI at http://localhost:8080 for a visual timeline of the execution.
-
-**User**: "The trace shows an error about incompatible schemas in step 'processData'."
-
-**Agent**: This is likely the Zod import source issue. Check your step file - you're probably importing `z` from `zod` instead of `@output.ai/core`. These create different schema instances that aren't compatible.
-
-Change:
-```typescript
-import { z } from 'zod';
-```
-
-To:
-```typescript
-import { z } from '@output.ai/core';
-```
-
-After making this change, run the workflow again with `npx output workflow run <workflowName>` to verify the fix.
-
----
-*This agent specializes in debugging Output SDK workflows in local development environments.*

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

@@ -1,113 +0,0 @@
----
-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.
-
-### Context Retrieval
-Use the `workflow-context-fetcher` subagent to retrieve documentation only if not already in context:
-- **Pre-Flight**: `.outputai/meta/pre_flight.md` - validation rules and smart defaults
-- **Post-Flight**: `.outputai/meta/post_flight.md` - completion checklist
-- **Existing Patterns**: `src/workflows/*/workflow.ts` - similar workflow patterns
-
-Use the `workflow-prompt-writer` subagent for:
-- Creating and reviewing `.prompt` files
-- Liquid.js template syntax guidance
-- Provider/model configuration
-
-## 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 (delegate to `workflow-prompt-writer` subagent for implementation)
-- 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.*