claude-dev-cli 0.6.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

claude_dev_cli/warp_integration.py

@@ -0,0 +1,243 @@
+"""Warp terminal integration for enhanced output formatting."""
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import yaml
+
+
+def format_as_warp_block(
+    content: str,
+    title: Optional[str] = None,
+    language: Optional[str] = None,
+    actions: Optional[List[Dict[str, str]]] = None
+) -> str:
+    """Format content as a Warp block with optional actions.
+    
+    Warp blocks support special formatting and click-to-run actions.
+    """
+    block_parts = []
+    
+    if title:
+        block_parts.append(f"### {title}")
+        block_parts.append("")
+    
+    # Add content with language if code block
+    if language:
+        block_parts.append(f"```{language}")
+        block_parts.append(content)
+        block_parts.append("```")
+    else:
+        block_parts.append(content)
+    
+    # Add actions if provided
+    if actions:
+        block_parts.append("")
+        block_parts.append("**Actions:**")
+        for action in actions:
+            label = action.get('label', 'Run')
+            command = action.get('command', '')
+            block_parts.append(f"- [{label}](`{command}`)")
+    
+    return "\n".join(block_parts)
+
+
+def generate_warp_workflow(
+    workflow_name: str,
+    commands: List[Dict[str, str]],
+    output_path: Optional[Path] = None
+) -> str:
+    """Generate a Warp workflow file from command list.
+    
+    Warp workflows allow users to execute predefined command sequences.
+    """
+    workflow = {
+        "name": workflow_name,
+        "command": "://" + workflow_name.lower().replace(" ", "-"),
+        "tags": ["claude-dev-cli"],
+        "description": f"Generated from claude-dev-cli",
+        "arguments": [],
+        "source_specs": [
+            {
+                "type": "command",
+                "command": cmd.get('command', ''),
+                "description": cmd.get('description', '')
+            }
+            for cmd in commands
+        ]
+    }
+    
+    workflow_yaml = yaml.dump(workflow, default_flow_style=False, sort_keys=False)
+    
+    if output_path:
+        output_path.write_text(workflow_yaml)
+    
+    return workflow_yaml
+
+
+def export_builtin_workflows(output_dir: Path) -> List[Path]:
+    """Export built-in Warp workflows for common claude-dev-cli tasks."""
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    workflows = [
+        {
+            "name": "Code Review Workflow",
+            "commands": [
+                {
+                    "command": "cdc review {{file}}",
+                    "description": "Review code for issues"
+                },
+                {
+                    "command": "cdc review {{file}} --interactive",
+                    "description": "Review with follow-up questions"
+                }
+            ]
+        },
+        {
+            "name": "Test Generation Workflow",
+            "commands": [
+                {
+                    "command": "cdc generate tests {{file}} -o tests/test_{{file}}",
+                    "description": "Generate tests"
+                },
+                {
+                    "command": "pytest tests/test_{{file}}",
+                    "description": "Run tests"
+                }
+            ]
+        },
+        {
+            "name": "Refactor Workflow",
+            "commands": [
+                {
+                    "command": "cdc refactor {{file}} --interactive",
+                    "description": "Get refactoring suggestions"
+                },
+                {
+                    "command": "cdc review {{file}}",
+                    "description": "Review changes"
+                },
+                {
+                    "command": "git add {{file}} && cdc git commit",
+                    "description": "Commit changes"
+                }
+            ]
+        },
+        {
+            "name": "Debug Workflow",
+            "commands": [
+                {
+                    "command": "python {{file}} 2>&1 | cdc debug",
+                    "description": "Run and debug errors"
+                },
+                {
+                    "command": "cdc debug -f {{file}} -e \"{{error}}\"",
+                    "description": "Debug specific error"
+                }
+            ]
+        }
+    ]
+    
+    created_files = []
+    for workflow in workflows:
+        filename = workflow['name'].lower().replace(' ', '-') + '.yaml'
+        filepath = output_dir / filename
+        generate_warp_workflow(
+            workflow['name'],
+            workflow['commands'],
+            filepath
+        )
+        created_files.append(filepath)
+    
+    return created_files
+
+
+def format_code_review_for_warp(review_output: str, file_path: str) -> str:
+    """Format code review output as Warp block with actions."""
+    actions = [
+        {
+            "label": "Review with follow-up",
+            "command": f"cdc review {file_path} --interactive"
+        },
+        {
+            "label": "Refactor",
+            "command": f"cdc refactor {file_path} --interactive"
+        }
+    ]
+    
+    return format_as_warp_block(
+        content=review_output,
+        title="Code Review",
+        actions=actions
+    )
+
+
+def format_test_generation_for_warp(test_output: str, file_path: str) -> str:
+    """Format test generation output as Warp block with actions."""
+    test_file = f"tests/test_{Path(file_path).name}"
+    
+    actions = [
+        {
+            "label": "Save tests",
+            "command": f"cdc generate tests {file_path} -o {test_file}"
+        },
+        {
+            "label": "Run tests",
+            "command": f"pytest {test_file}"
+        }
+    ]
+    
+    return format_as_warp_block(
+        content=test_output,
+        title="Generated Tests",
+        language="python",
+        actions=actions
+    )
+
+
+def create_warp_launch_config(
+    name: str,
+    command: str,
+    cwd: Optional[str] = None,
+    env: Optional[Dict[str, str]] = None
+) -> Dict[str, Any]:
+    """Create a Warp launch configuration.
+    
+    Launch configs allow quick environment setup in Warp.
+    """
+    config = {
+        "name": name,
+        "command": command,
+        "type": "terminal"
+    }
+    
+    if cwd:
+        config["cwd"] = cwd
+    
+    if env:
+        config["env"] = env
+    
+    return config
+
+
+def export_launch_configs(output_path: Path) -> None:
+    """Export Warp launch configurations for claude-dev-cli."""
+    configs = [
+        create_warp_launch_config(
+            name="Claude Dev CLI - Interactive",
+            command="cdc interactive"
+        ),
+        create_warp_launch_config(
+            name="Claude Dev CLI - Review Mode",
+            command="cdc review"
+        ),
+        create_warp_launch_config(
+            name="Claude Dev CLI - Test Generation",
+            command="cdc generate tests"
+        )
+    ]
+    
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(output_path, 'w') as f:
+        json.dump({"launch_configurations": configs}, f, indent=2)

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.6.0.dist-info → claude_dev_cli-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-dev-cli
-Version: 0.6.0
+Version: 0.8.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
@@ -78,6 +79,13 @@ A powerful command-line tool for developers using Claude AI with multi-API routi
 - **Variable Substitution**: Use {{variable}} placeholders for dynamic content
 - **Categories**: Organize templates by category (review, testing, debugging, etc.)
 
+### 🧠 Context Intelligence (NEW in v0.8.0)
+- **Auto-Context**: `--auto-context` flag for intelligent context gathering
+- **Git Integration**: Automatically include branch, commits, modified files
+- **Dependency Analysis**: Parse imports and include related files
+- **Error Parsing**: Structured Python traceback parsing
+- **Project Memory**: Remember preferences per project
+
 ### 🎒 TOON Format Support (Optional)
 - **Token Reduction**: 30-60% fewer tokens than JSON
 - **Cost Savings**: Reduce API costs significantly
@@ -145,23 +153,60 @@ 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
 
-# Debug errors
-python script.py 2>&1 | cdc debug
+# Code review with auto-context (includes git, dependencies, tests)
+cdc review mymodule.py --auto-context
+
+# Code review with interactive follow-up questions
+cdc review mymodule.py --interactive
+
+# Debug errors with intelligent error parsing
+python script.py 2>&1 | cdc debug --auto-context
 
 # Generate documentation
 cdc generate docs mymodule.py
 
-# Refactor suggestions
-cdc refactor legacy_code.py
+# Generate docs with interactive refinement
+cdc generate docs mymodule.py --interactive
+
+# Refactor with context (includes related files)
+cdc refactor legacy_code.py --auto-context
+
+# Refactor with interactive refinement
+cdc refactor legacy_code.py --interactive
 
 # Git commit message
 git add .
 cdc git commit
 ```
 
+### 4. Context-Aware Operations (NEW in v0.8.0)
+
+```bash
+# Auto-context includes: git info, dependencies, related files
+
+# Review with full project context
+cdc review mymodule.py --auto-context
+# ✓ Context gathered (git, dependencies, tests)
+
+# Debug with parsed error details
+python broken.py 2>&1 | cdc debug -f broken.py --auto-context
+# ✓ Context gathered (error details, git context)
+
+# Ask questions with file context
+cdc ask -f mycode.py --auto-context "how can I improve this?"
+# ✓ Context gathered
+
+# Refactor with related files
+cdc refactor app.py --auto-context
+# Automatically includes imported modules and dependencies
+```
+
 ### 5. Custom Templates
 
 ```bash