claude-dev-cli 0.5.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

claude_dev_cli/workflows.py

@@ -0,0 +1,340 @@
+"""Workflow execution engine for chaining AI operations."""
+
+import re
+import subprocess
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+from dataclasses import dataclass, field
+
+import yaml
+from rich.console import Console
+
+
+@dataclass
+class StepResult:
+    """Result from executing a workflow step."""
+    success: bool
+    output: str
+    error: Optional[str] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class WorkflowContext:
+    """Context passed between workflow steps."""
+    variables: Dict[str, Any] = field(default_factory=dict)
+    step_results: Dict[str, StepResult] = field(default_factory=dict)
+
+
+class WorkflowEngine:
+    """Execute workflow definitions with step chaining."""
+    
+    def __init__(self, console: Optional[Console] = None):
+        self.console = console or Console()
+    
+    def load_workflow(self, path: Path) -> Dict[str, Any]:
+        """Load workflow from YAML file."""
+        with open(path, 'r') as f:
+            return yaml.safe_load(f)
+    
+    def execute(
+        self,
+        workflow: Union[Dict[str, Any], Path],
+        initial_vars: Optional[Dict[str, Any]] = None
+    ) -> WorkflowContext:
+        """Execute a workflow definition."""
+        # Load from file if path provided
+        if isinstance(workflow, Path):
+            workflow = self.load_workflow(workflow)
+        
+        # Initialize context
+        context = WorkflowContext(variables=initial_vars or {})
+        
+        # Extract workflow metadata
+        name = workflow.get('name', 'Unnamed Workflow')
+        description = workflow.get('description', '')
+        steps = workflow.get('steps', [])
+        
+        self.console.print(f"\n[bold cyan]Running workflow:[/bold cyan] {name}")
+        if description:
+            self.console.print(f"[dim]{description}[/dim]")
+        
+        # Execute steps
+        for i, step in enumerate(steps, 1):
+            step_name = step.get('name', f'step-{i}')
+            
+            # Check conditional
+            if 'if' in step:
+                condition = self._evaluate_condition(step['if'], context)
+                if not condition:
+                    self.console.print(f"[yellow]↷[/yellow] Skipping step {i}: {step_name} (condition false)")
+                    continue
+            
+            self.console.print(f"\n[bold]Step {i}:[/bold] {step_name}")
+            
+            # Check for approval gate
+            if step.get('approval_required', False):
+                if not self._request_approval(step_name):
+                    self.console.print("[yellow]Workflow stopped by user[/yellow]")
+                    break
+            
+            # Execute step
+            try:
+                result = self._execute_step(step, context)
+                context.step_results[step_name] = result
+                
+                if result.success:
+                    self.console.print(f"[green]✓[/green] {step_name} completed")
+                else:
+                    self.console.print(f"[red]✗[/red] {step_name} failed: {result.error}")
+                    
+                    # Check if workflow should continue on error
+                    if not step.get('continue_on_error', False):
+                        self.console.print("[red]Workflow stopped due to error[/red]")
+                        break
+            
+            except Exception as e:
+                self.console.print(f"[red]Error in step {step_name}: {e}[/red]")
+                if not step.get('continue_on_error', False):
+                    break
+        
+        self.console.print("\n[bold green]Workflow completed[/bold green]")
+        return context
+    
+    def _execute_step(self, step: Dict[str, Any], context: WorkflowContext) -> StepResult:
+        """Execute a single workflow step."""
+        # Determine step type
+        if 'command' in step:
+            return self._execute_command_step(step, context)
+        elif 'shell' in step:
+            return self._execute_shell_step(step, context)
+        elif 'set' in step:
+            return self._execute_set_step(step, context)
+        else:
+            return StepResult(
+                success=False,
+                output="",
+                error="Unknown step type"
+            )
+    
+    def _execute_command_step(self, step: Dict[str, Any], context: WorkflowContext) -> StepResult:
+        """Execute a cdc command step."""
+        command = step['command']
+        args = step.get('args', {})
+        
+        # Interpolate variables in args
+        interpolated_args = self._interpolate_variables(args, context)
+        
+        # Import here to avoid circular dependency
+        from claude_dev_cli.commands import (
+            generate_tests, code_review, debug_code, 
+            generate_docs, refactor_code, git_commit_message
+        )
+        
+        # Map commands to functions
+        command_map = {
+            'generate tests': generate_tests,
+            'review': code_review,
+            'debug': debug_code,
+            'generate docs': generate_docs,
+            'refactor': refactor_code,
+            'git commit': git_commit_message,
+        }
+        
+        if command not in command_map:
+            return StepResult(
+                success=False,
+                output="",
+                error=f"Unknown command: {command}"
+            )
+        
+        try:
+            func = command_map[command]
+            
+            # Build function arguments
+            func_args = {}
+            if 'file' in interpolated_args:
+                func_args['file_path'] = interpolated_args['file']
+            if 'error' in interpolated_args:
+                func_args['error_message'] = interpolated_args['error']
+            if 'api' in interpolated_args:
+                func_args['api_config_name'] = interpolated_args['api']
+            
+            # Execute
+            result = func(**func_args)
+            
+            # Store output in context for next steps
+            if 'output_var' in step:
+                context.variables[step['output_var']] = result
+            
+            return StepResult(
+                success=True,
+                output=result,
+                metadata={'command': command}
+            )
+        
+        except Exception as e:
+            return StepResult(
+                success=False,
+                output="",
+                error=str(e)
+            )
+    
+    def _execute_shell_step(self, step: Dict[str, Any], context: WorkflowContext) -> StepResult:
+        """Execute a shell command step."""
+        command = step['shell']
+        
+        # Interpolate variables
+        command = self._interpolate_string(command, context)
+        
+        try:
+            result = subprocess.run(
+                command,
+                shell=True,
+                capture_output=True,
+                text=True,
+                check=False
+            )
+            
+            success = result.returncode == 0
+            output = result.stdout or result.stderr
+            
+            # Store output in context
+            if 'output_var' in step:
+                context.variables[step['output_var']] = output.strip()
+            
+            return StepResult(
+                success=success,
+                output=output,
+                error=result.stderr if not success else None,
+                metadata={'returncode': result.returncode}
+            )
+        
+        except Exception as e:
+            return StepResult(
+                success=False,
+                output="",
+                error=str(e)
+            )
+    
+    def _execute_set_step(self, step: Dict[str, Any], context: WorkflowContext) -> StepResult:
+        """Execute a variable assignment step."""
+        var_name = step['set']
+        value = step.get('value', '')
+        
+        # Interpolate value
+        value = self._interpolate_value(value, context)
+        
+        context.variables[var_name] = value
+        
+        return StepResult(
+            success=True,
+            output=str(value),
+            metadata={'variable': var_name}
+        )
+    
+    def _interpolate_variables(
+        self,
+        data: Union[Dict, List, str, Any],
+        context: WorkflowContext
+    ) -> Any:
+        """Recursively interpolate variables in data structures."""
+        if isinstance(data, dict):
+            return {k: self._interpolate_variables(v, context) for k, v in data.items()}
+        elif isinstance(data, list):
+            return [self._interpolate_variables(item, context) for item in data]
+        elif isinstance(data, str):
+            return self._interpolate_string(data, context)
+        else:
+            return data
+    
+    def _interpolate_string(self, text: str, context: WorkflowContext) -> str:
+        """Interpolate {{variable}} placeholders in string."""
+        def replace(match: re.Match) -> str:
+            var_path = match.group(1)
+            return str(self._resolve_variable(var_path, context))
+        
+        return re.sub(r'\{\{([^}]+)\}\}', replace, text)
+    
+    def _interpolate_value(self, value: Any, context: WorkflowContext) -> Any:
+        """Interpolate a single value."""
+        if isinstance(value, str):
+            return self._interpolate_string(value, context)
+        return value
+    
+    def _resolve_variable(self, var_path: str, context: WorkflowContext) -> Any:
+        """Resolve a variable path like 'step1.output' or 'vars.filename'."""
+        parts = var_path.strip().split('.')
+        
+        # Check step results first
+        if len(parts) >= 2 and parts[0] in context.step_results:
+            step_result = context.step_results[parts[0]]
+            if parts[1] == 'output':
+                return step_result.output
+            elif parts[1] == 'success':
+                return step_result.success
+            elif parts[1] == 'error':
+                return step_result.error or ''
+        
+        # Check variables
+        if parts[0] in context.variables:
+            value = context.variables[parts[0]]
+            # Support nested access for dicts
+            for part in parts[1:]:
+                if isinstance(value, dict):
+                    value = value.get(part, '')
+                else:
+                    return ''
+            return value
+        
+        return f'{{{{{var_path}}}}}'  # Return placeholder if not found
+    
+    def _evaluate_condition(self, condition: str, context: WorkflowContext) -> bool:
+        """Evaluate a simple condition expression."""
+        # Interpolate variables
+        evaluated = self._interpolate_string(condition, context)
+        
+        # Simple boolean evaluation
+        if evaluated.lower() in ('true', '1', 'yes'):
+            return True
+        if evaluated.lower() in ('false', '0', 'no', ''):
+            return False
+        
+        # Try to evaluate as Python expression (limited to safe operations)
+        try:
+            # Only allow simple comparisons
+            if any(op in evaluated for op in ['==', '!=', '>', '<', '>=', '<=']):
+                return eval(evaluated, {"__builtins__": {}}, {})
+        except Exception:
+            pass
+        
+        return bool(evaluated)
+    
+    def _request_approval(self, step_name: str) -> bool:
+        """Request user approval to proceed."""
+        self.console.print(f"\n[yellow]⚠ Approval required for:[/yellow] {step_name}")
+        response = self.console.input("[cyan]Proceed? (y/n):[/cyan] ").strip().lower()
+        return response in ('y', 'yes')
+
+
+def list_workflows(workflow_dir: Path) -> List[Dict[str, str]]:
+    """List available workflows in a directory."""
+    if not workflow_dir.exists():
+        return []
+    
+    workflows = []
+    for file in workflow_dir.glob('*.yaml'):
+        try:
+            with open(file, 'r') as f:
+                data = yaml.safe_load(f)
+            
+            workflows.append({
+                'name': data.get('name', file.stem),
+                'description': data.get('description', ''),
+                'file': str(file),
+                'steps': len(data.get('steps', []))
+            })
+        except Exception:
+            continue
+    
+    return workflows

{claude_dev_cli-0.5.0.dist-info → claude_dev_cli-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-dev-cli
-Version: 0.5.0
+Version: 0.7.0
 Summary: A powerful CLI tool for developers using Claude AI with multi-API routing, test generation, code review, and usage tracking
 Author-email: Julio <thinmanj@users.noreply.github.com>
 License: MIT
@@ -28,6 +28,7 @@ Requires-Dist: rich>=13.0.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: keyring>=24.0.0
 Requires-Dist: cryptography>=41.0.0
+Requires-Dist: pyyaml>=6.0.0
 Provides-Extra: toon
 Requires-Dist: toon-format>=0.9.0; extra == "toon"
 Provides-Extra: plugins
@@ -72,6 +73,12 @@ A powerful command-line tool for developers using Claude AI with multi-API routi
 - **Interactive**: Chat mode with conversation history
 - **Streaming**: Real-time responses
 
+### 📝 Custom Templates
+- **Built-in Templates**: 8 pre-built templates for common tasks (code review, testing, debugging, etc.)
+- **User Templates**: Create and manage your own reusable prompt templates
+- **Variable Substitution**: Use {{variable}} placeholders for dynamic content
+- **Categories**: Organize templates by category (review, testing, debugging, etc.)
+
 ### 🎒 TOON Format Support (Optional)
 - **Token Reduction**: 30-60% fewer tokens than JSON
 - **Cost Savings**: Reduce API costs significantly
@@ -139,24 +146,73 @@ cdc ask -a client "generate tests for this function"
 # Generate tests
 cdc generate tests mymodule.py -o tests/test_mymodule.py
 
+# Generate tests with interactive refinement
+cdc generate tests mymodule.py --interactive
+
 # Code review
 cdc review mymodule.py
 
+# Code review with interactive follow-up questions
+cdc review mymodule.py --interactive
+
 # Debug errors
 python script.py 2>&1 | cdc debug
 
 # Generate documentation
 cdc generate docs mymodule.py
 
+# Generate docs with interactive refinement
+cdc generate docs mymodule.py --interactive
+
 # Refactor suggestions
 cdc refactor legacy_code.py
 
+# Refactor with interactive refinement
+cdc refactor legacy_code.py --interactive
+
 # Git commit message
 git add .
 cdc git commit
 ```
 
-### 4. Usage Tracking
+### 5. Custom Templates
+
+```bash
+# List all templates (built-in and user)
+cdc template list
+
+# Show template details
+cdc template show code-review
+
+# Add a custom template
+cdc template add my-review -c "Review this code for {{focus}}: {{code}}" \
+  -d "Custom review template" --category review
+
+# Use a template (interactive variable input)
+cdc template use debug-error
+
+# Delete a user template
+cdc template delete my-review
+
+# Filter by category
+cdc template list --category review
+
+# Show only user templates
+cdc template list --user
+```
+
+#### Built-in Templates
+
+- **code-review**: Comprehensive code review with customizable focus
+- **code-review-security**: Security-focused code review
+- **test-strategy**: Generate testing strategy and test cases
+- **debug-error**: Debug error with context
+- **optimize-performance**: Performance optimization analysis
+- **refactor-clean**: Clean code refactoring
+- **explain-code**: Detailed code explanation
+- **api-design**: API design assistance
+
+### 6. Usage Tracking
 
 ```bash
 # View all usage
@@ -169,7 +225,7 @@ cdc usage --days 7
 cdc usage --api client
 ```
 
-### 5. TOON Format (Optional - Reduces Tokens by 30-60%)
+### 7. TOON Format (Optional - Reduces Tokens by 30-60%)
 
 ```bash
 # Check if TOON is installed
@@ -322,6 +378,16 @@ When using a client's Enterprise API:
 | `cdc debug -f <file> -e <error>` | Debug code |
 | `cdc refactor <file>` | Refactoring suggestions |
 
+### Templates
+
+| Command | Description |
+|---------|-------------|
+| `cdc template list` | List all templates |
+| `cdc template show <name>` | Show template details |
+| `cdc template add <name>` | Add new template |
+| `cdc template delete <name>` | Delete user template |
+| `cdc template use <name>` | Use template interactively |
+
 ### Git Helpers
 
 | Command | Description |

{claude_dev_cli-0.5.0.dist-info → claude_dev_cli-0.7.0.dist-info}/RECORD

@@ -1,21 +1,24 @@
-claude_dev_cli/__init__.py,sha256=2ulyIQ3E-s6wBTKyeXAlqHMVA73zUGdaaNUsFiJ-nqs,469
-claude_dev_cli/cli.py,sha256=WBJdA1KKA0scT-gOE5Sd39HhtJr7uyc3qfn_-rYXTGc,25019
+claude_dev_cli/__init__.py,sha256=sRGmW8jYKXWyBKqr2_-3AornNC32eNj4sESrXfoTUoQ,469
+claude_dev_cli/cli.py,sha256=feTRI1fQoDPJiB7JM45ZU2I1jEjXX643191H_U0rMio,44612
 claude_dev_cli/commands.py,sha256=RKGx2rv56PM6eErvA2uoQ20hY8babuI5jav8nCUyUOk,3964
 claude_dev_cli/config.py,sha256=RGX0sKplHUsrJJmU-4FuWWjoTbQVgWaMT8DgRUofrR4,8134
 claude_dev_cli/core.py,sha256=yaLjEixDvPzvUy4fJ2UB7nMpPPLyKACjR-RuM-1OQBY,4780
 claude_dev_cli/history.py,sha256=iQlqgTnXCsyCq5q-XaDl7V5MyPKQ3bx7o_k76-xWSAA,6863
 claude_dev_cli/secure_storage.py,sha256=TK3WOaU7a0yTOtzdP_t_28fDRp2lovANNAC6MBdm4nQ,7096
+claude_dev_cli/template_manager.py,sha256=ZFXOtRIoB6hpf8kLSF9TWJfvUPJt9b-PyEv3qTBK7Zs,8600
 claude_dev_cli/templates.py,sha256=lKxH943ySfUKgyHaWa4W3LVv91SgznKgajRtSRp_4UY,2260
 claude_dev_cli/toon_utils.py,sha256=S3px2UvmNEaltmTa5K-h21n2c0CPvYjZc9mc7kHGqNQ,2828
 claude_dev_cli/usage.py,sha256=32rs0_dUn6ihha3vCfT3rwnvel_-sED7jvLpO7gu-KQ,7446
+claude_dev_cli/warp_integration.py,sha256=PDufAJecl7uN0DGz6XW4uDSEeu7Ssg53DOIFKm-AXVg,6909
+claude_dev_cli/workflows.py,sha256=WpLq9I_0MmDsJIbCi9-f662JVyn8iKTs1KZ50w-GlZU,12202
 claude_dev_cli/plugins/__init__.py,sha256=BdiZlylBzEgnwK2tuEdn8cITxhAZRVbTnDbWhdDhgqs,1340
 claude_dev_cli/plugins/base.py,sha256=H4HQet1I-a3WLCfE9F06Lp8NuFvVoIlou7sIgyJFK-c,1417
 claude_dev_cli/plugins/diff_editor/__init__.py,sha256=gqR5S2TyIVuq-sK107fegsutQ7Z-sgAIEbtc71FhXIM,101
 claude_dev_cli/plugins/diff_editor/plugin.py,sha256=M1bUoqpasD3ZNQo36Fu_8g92uySPZyG_ujMbj5UplsU,3073
 claude_dev_cli/plugins/diff_editor/viewer.py,sha256=1IOXIKw_01ppJx5C1dQt9Kr6U1TdAHT8_iUT5r_q0NM,17169
-claude_dev_cli-0.5.0.dist-info/licenses/LICENSE,sha256=DGueuJwMJtMwgLO5mWlS0TaeBrFwQuNpNZ22PU9J2bw,1062
-claude_dev_cli-0.5.0.dist-info/METADATA,sha256=GCboIRGV9N6gFFiwotWuCFMqMbhJZs4Gk6pyztZX984,11288
-claude_dev_cli-0.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_dev_cli-0.5.0.dist-info/entry_points.txt,sha256=zymgUIIVpFTARkFmxAuW2A4BQsNITh_L0uU-XunytHg,85
-claude_dev_cli-0.5.0.dist-info/top_level.txt,sha256=m7MF6LOIuTe41IT5Fgt0lc-DK1EgM4gUU_IZwWxK0pg,15
-claude_dev_cli-0.5.0.dist-info/RECORD,,
+claude_dev_cli-0.7.0.dist-info/licenses/LICENSE,sha256=DGueuJwMJtMwgLO5mWlS0TaeBrFwQuNpNZ22PU9J2bw,1062
+claude_dev_cli-0.7.0.dist-info/METADATA,sha256=YIN5U4urelKIEFjhd-s2EyHsPb-qEvhhqDwOek2hjPw,13364
+claude_dev_cli-0.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+claude_dev_cli-0.7.0.dist-info/entry_points.txt,sha256=zymgUIIVpFTARkFmxAuW2A4BQsNITh_L0uU-XunytHg,85
+claude_dev_cli-0.7.0.dist-info/top_level.txt,sha256=m7MF6LOIuTe41IT5Fgt0lc-DK1EgM4gUU_IZwWxK0pg,15
+claude_dev_cli-0.7.0.dist-info/RECORD,,