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

claude_dev_cli/__init__.py

@@ -9,7 +9,7 @@ Features:
 - Interactive and single-shot modes
 """
 
-__version__ = "0.6.0"
+__version__ = "0.7.0"
 __author__ = "Julio"
 __license__ = "MIT"
 

claude_dev_cli/cli.py

@@ -447,12 +447,14 @@ def generate() -> None:
 @click.argument('file_path', type=click.Path(exists=True))
 @click.option('-o', '--output', type=click.Path(), help='Output file path')
 @click.option('-a', '--api', help='API config to use')
+@click.option('-i', '--interactive', is_flag=True, help='Interactive refinement mode')
 @click.pass_context
 def gen_tests(
     ctx: click.Context,
     file_path: str,
     output: Optional[str],
-    api: Optional[str]
+    api: Optional[str],
+    interactive: bool
 ) -> None:
     """Generate pytest tests for a Python file."""
     console = ctx.obj['console']
@@ -461,11 +463,48 @@ def gen_tests(
         with console.status("[bold blue]Generating tests..."):
             result = generate_tests(file_path, api_config_name=api)
         
+        if interactive:
+            # Show initial result
+            console.print("\n[bold]Initial Tests:[/bold]\n")
+            console.print(result)
+            
+            # Interactive refinement loop
+            client = ClaudeClient(api_config_name=api)
+            conversation_context = [result]
+            
+            while True:
+                console.print("\n[dim]Commands: 'save' to save and exit, 'exit' to discard, or ask for changes[/dim]")
+                user_input = console.input("[cyan]You:[/cyan] ").strip()
+                
+                if user_input.lower() == 'exit':
+                    console.print("[yellow]Discarded changes[/yellow]")
+                    return
+                
+                if user_input.lower() == 'save':
+                    result = conversation_context[-1]
+                    break
+                
+                if not user_input:
+                    continue
+                
+                # Get refinement
+                refinement_prompt = f"Previous tests:\n\n{conversation_context[-1]}\n\nUser request: {user_input}\n\nProvide the updated tests."
+                
+                console.print("\n[bold green]Claude:[/bold green] ", end='')
+                response_parts = []
+                for chunk in client.call_streaming(refinement_prompt):
+                    console.print(chunk, end='')
+                    response_parts.append(chunk)
+                console.print()
+                
+                result = ''.join(response_parts)
+                conversation_context.append(result)
+        
         if output:
             with open(output, 'w') as f:
                 f.write(result)
-            console.print(f"[green]✓[/green] Tests saved to: {output}")
-        else:
+            console.print(f"\n[green]✓[/green] Tests saved to: {output}")
+        elif not interactive:
             console.print(result)
     
     except Exception as e:
@@ -477,12 +516,14 @@ def gen_tests(
 @click.argument('file_path', type=click.Path(exists=True))
 @click.option('-o', '--output', type=click.Path(), help='Output file path')
 @click.option('-a', '--api', help='API config to use')
+@click.option('-i', '--interactive', is_flag=True, help='Interactive refinement mode')
 @click.pass_context
 def gen_docs(
     ctx: click.Context,
     file_path: str,
     output: Optional[str],
-    api: Optional[str]
+    api: Optional[str],
+    interactive: bool
 ) -> None:
     """Generate documentation for a Python file."""
     console = ctx.obj['console']
@@ -491,11 +532,46 @@ def gen_docs(
         with console.status("[bold blue]Generating documentation..."):
             result = generate_docs(file_path, api_config_name=api)
         
+        if interactive:
+            console.print("\n[bold]Initial Documentation:[/bold]\n")
+            md = Markdown(result)
+            console.print(md)
+            
+            client = ClaudeClient(api_config_name=api)
+            conversation_context = [result]
+            
+            while True:
+                console.print("\n[dim]Commands: 'save' to save and exit, 'exit' to discard, or ask for changes[/dim]")
+                user_input = console.input("[cyan]You:[/cyan] ").strip()
+                
+                if user_input.lower() == 'exit':
+                    console.print("[yellow]Discarded changes[/yellow]")
+                    return
+                
+                if user_input.lower() == 'save':
+                    result = conversation_context[-1]
+                    break
+                
+                if not user_input:
+                    continue
+                
+                refinement_prompt = f"Previous documentation:\n\n{conversation_context[-1]}\n\nUser request: {user_input}\n\nProvide the updated documentation."
+                
+                console.print("\n[bold green]Claude:[/bold green] ", end='')
+                response_parts = []
+                for chunk in client.call_streaming(refinement_prompt):
+                    console.print(chunk, end='')
+                    response_parts.append(chunk)
+                console.print()
+                
+                result = ''.join(response_parts)
+                conversation_context.append(result)
+        
         if output:
             with open(output, 'w') as f:
                 f.write(result)
-            console.print(f"[green]✓[/green] Documentation saved to: {output}")
-        else:
+            console.print(f"\n[green]✓[/green] Documentation saved to: {output}")
+        elif not interactive:
             md = Markdown(result)
             console.print(md)
     
@@ -507,11 +583,13 @@ def gen_docs(
 @main.command('review')
 @click.argument('file_path', type=click.Path(exists=True))
 @click.option('-a', '--api', help='API config to use')
+@click.option('-i', '--interactive', is_flag=True, help='Interactive follow-up questions')
 @click.pass_context
 def review(
     ctx: click.Context,
     file_path: str,
-    api: Optional[str]
+    api: Optional[str],
+    interactive: bool
 ) -> None:
     """Review code for bugs and improvements."""
     console = ctx.obj['console']
@@ -522,6 +600,29 @@ def review(
         
         md = Markdown(result)
         console.print(md)
+        
+        if interactive:
+            client = ClaudeClient(api_config_name=api)
+            with open(file_path, 'r') as f:
+                file_content = f.read()
+            
+            console.print("\n[dim]Ask follow-up questions about the review, or 'exit' to quit[/dim]")
+            
+            while True:
+                user_input = console.input("\n[cyan]You:[/cyan] ").strip()
+                
+                if user_input.lower() == 'exit':
+                    break
+                
+                if not user_input:
+                    continue
+                
+                follow_up_prompt = f"Code review:\n\n{result}\n\nOriginal code:\n\n{file_content}\n\nUser question: {user_input}"
+                
+                console.print("\n[bold green]Claude:[/bold green] ", end='')
+                for chunk in client.call_streaming(follow_up_prompt):
+                    console.print(chunk, end='')
+                console.print()
     
     except Exception as e:
         console.print(f"[red]Error: {e}[/red]")
@@ -567,12 +668,14 @@ def debug(
 @click.argument('file_path', type=click.Path(exists=True))
 @click.option('-o', '--output', type=click.Path(), help='Output file path')
 @click.option('-a', '--api', help='API config to use')
+@click.option('-i', '--interactive', is_flag=True, help='Interactive refinement mode')
 @click.pass_context
 def refactor(
     ctx: click.Context,
     file_path: str,
     output: Optional[str],
-    api: Optional[str]
+    api: Optional[str],
+    interactive: bool
 ) -> None:
     """Suggest refactoring improvements."""
     console = ctx.obj['console']
@@ -581,11 +684,46 @@ def refactor(
         with console.status("[bold blue]Analyzing code..."):
             result = refactor_code(file_path, api_config_name=api)
         
+        if interactive:
+            console.print("\n[bold]Initial Refactoring:[/bold]\n")
+            md = Markdown(result)
+            console.print(md)
+            
+            client = ClaudeClient(api_config_name=api)
+            conversation_context = [result]
+            
+            while True:
+                console.print("\n[dim]Commands: 'save' to save and exit, 'exit' to discard, or ask for changes[/dim]")
+                user_input = console.input("[cyan]You:[/cyan] ").strip()
+                
+                if user_input.lower() == 'exit':
+                    console.print("[yellow]Discarded changes[/yellow]")
+                    return
+                
+                if user_input.lower() == 'save':
+                    result = conversation_context[-1]
+                    break
+                
+                if not user_input:
+                    continue
+                
+                refinement_prompt = f"Previous refactoring:\n\n{conversation_context[-1]}\n\nUser request: {user_input}\n\nProvide the updated refactoring suggestions."
+                
+                console.print("\n[bold green]Claude:[/bold green] ", end='')
+                response_parts = []
+                for chunk in client.call_streaming(refinement_prompt):
+                    console.print(chunk, end='')
+                    response_parts.append(chunk)
+                console.print()
+                
+                result = ''.join(response_parts)
+                conversation_context.append(result)
+        
         if output:
             with open(output, 'w') as f:
                 f.write(result)
-            console.print(f"[green]✓[/green] Refactored code saved to: {output}")
-        else:
+            console.print(f"\n[green]✓[/green] Refactored code saved to: {output}")
+        elif not interactive:
             md = Markdown(result)
             console.print(md)
     
@@ -957,5 +1095,221 @@ def template_use(ctx: click.Context, name: str, api: Optional[str], model: Optio
         sys.exit(1)
 
 
+@main.group()
+def warp() -> None:
+    """Warp terminal integration."""
+    pass
+
+
+@warp.command('export-workflows')
+@click.option('-o', '--output', type=click.Path(), help='Output directory')
+@click.pass_context
+def warp_export_workflows(ctx: click.Context, output: Optional[str]) -> None:
+    """Export Warp workflows for claude-dev-cli commands."""
+    console = ctx.obj['console']
+    
+    try:
+        from claude_dev_cli.warp_integration import export_builtin_workflows
+        
+        config = Config()
+        output_dir = Path(output) if output else config.config_dir / "warp" / "workflows"
+        
+        created_files = export_builtin_workflows(output_dir)
+        
+        console.print(f"[green]✓[/green] Exported {len(created_files)} Warp workflows to:")
+        console.print(f"  {output_dir}")
+        console.print("\n[bold]Workflows:[/bold]")
+        for file in created_files:
+            console.print(f"  • {file.name}")
+    
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        sys.exit(1)
+
+
+@warp.command('export-launch-configs')
+@click.option('-o', '--output', type=click.Path(), help='Output file path')
+@click.pass_context
+def warp_export_launch_configs(ctx: click.Context, output: Optional[str]) -> None:
+    """Export Warp launch configurations."""
+    console = ctx.obj['console']
+    
+    try:
+        from claude_dev_cli.warp_integration import export_launch_configs
+        
+        config = Config()
+        output_path = Path(output) if output else config.config_dir / "warp" / "launch_configs.json"
+        
+        export_launch_configs(output_path)
+        
+        console.print(f"[green]✓[/green] Exported Warp launch configurations to:")
+        console.print(f"  {output_path}")
+    
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        sys.exit(1)
+
+
+@main.group()
+def workflow() -> None:
+    """Manage and run workflows."""
+    pass
+
+
+@workflow.command('run')
+@click.argument('workflow_file', type=click.Path(exists=True))
+@click.option('--var', '-v', multiple=True, help='Set variables (key=value)')
+@click.pass_context
+def workflow_run(
+    ctx: click.Context,
+    workflow_file: str,
+    var: tuple
+) -> None:
+    """Run a workflow from YAML file."""
+    console = ctx.obj['console']
+    
+    # Parse variables
+    variables = {}
+    for v in var:
+        if '=' in v:
+            key, value = v.split('=', 1)
+            variables[key] = value
+    
+    try:
+        from claude_dev_cli.workflows import WorkflowEngine
+        
+        engine = WorkflowEngine(console=console)
+        workflow_path = Path(workflow_file)
+        
+        context = engine.execute(workflow_path, initial_vars=variables)
+        
+        # Show summary
+        if context.step_results:
+            console.print("\n[bold]Results Summary:[/bold]")
+            for step_name, result in context.step_results.items():
+                status = "[green]✓[/green]" if result.success else "[red]✗[/red]"
+                console.print(f"{status} {step_name}")
+    
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        sys.exit(1)
+
+
+@workflow.command('list')
+@click.pass_context
+def workflow_list(ctx: click.Context) -> None:
+    """List available workflows."""
+    console = ctx.obj['console']
+    config = Config()
+    workflow_dir = config.config_dir / "workflows"
+    
+    from claude_dev_cli.workflows import list_workflows
+    workflows = list_workflows(workflow_dir)
+    
+    if not workflows:
+        console.print("[yellow]No workflows found.[/yellow]")
+        console.print(f"\nCreate workflows in: {workflow_dir}")
+        return
+    
+    from rich.table import Table
+    
+    table = Table(show_header=True, header_style="bold magenta")
+    table.add_column("Name", style="cyan")
+    table.add_column("Steps", style="yellow")
+    table.add_column("Description")
+    
+    for wf in workflows:
+        table.add_row(
+            wf['name'],
+            str(wf['steps']),
+            wf['description']
+        )
+    
+    console.print(table)
+    console.print(f"\n[dim]Workflow directory: {workflow_dir}[/dim]")
+
+
+@workflow.command('show')
+@click.argument('workflow_file', type=click.Path(exists=True))
+@click.pass_context
+def workflow_show(ctx: click.Context, workflow_file: str) -> None:
+    """Show workflow details."""
+    console = ctx.obj['console']
+    
+    try:
+        from claude_dev_cli.workflows import WorkflowEngine
+        
+        engine = WorkflowEngine(console=console)
+        workflow = engine.load_workflow(Path(workflow_file))
+        
+        console.print(Panel(
+            f"[bold]{workflow.get('name', 'Unnamed')}[/bold]\n\n"
+            f"[dim]{workflow.get('description', 'No description')}[/dim]\n\n"
+            f"Steps: [yellow]{len(workflow.get('steps', []))}[/yellow]",
+            title="Workflow Info",
+            border_style="blue"
+        ))
+        
+        # Show steps
+        steps = workflow.get('steps', [])
+        if steps:
+            console.print("\n[bold]Steps:[/bold]\n")
+            for i, step in enumerate(steps, 1):
+                step_name = step.get('name', f'step-{i}')
+                step_type = 'command' if 'command' in step else 'shell' if 'shell' in step else 'set'
+                console.print(f"  {i}. [cyan]{step_name}[/cyan] ({step_type})")
+                
+                if step.get('approval_required'):
+                    console.print(f"     [yellow]⚠ Requires approval[/yellow]")
+                if 'if' in step:
+                    console.print(f"     [dim]Condition: {step['if']}[/dim]")
+    
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        sys.exit(1)
+
+
+@workflow.command('validate')
+@click.argument('workflow_file', type=click.Path(exists=True))
+@click.pass_context
+def workflow_validate(ctx: click.Context, workflow_file: str) -> None:
+    """Validate workflow syntax."""
+    console = ctx.obj['console']
+    
+    try:
+        from claude_dev_cli.workflows import WorkflowEngine
+        
+        engine = WorkflowEngine(console=console)
+        workflow = engine.load_workflow(Path(workflow_file))
+        
+        # Basic validation
+        errors = []
+        
+        if 'name' not in workflow:
+            errors.append("Missing 'name' field")
+        
+        if 'steps' not in workflow:
+            errors.append("Missing 'steps' field")
+        elif not isinstance(workflow['steps'], list):
+            errors.append("'steps' must be a list")
+        else:
+            for i, step in enumerate(workflow['steps'], 1):
+                if not any(k in step for k in ['command', 'shell', 'set']):
+                    errors.append(f"Step {i}: Must have 'command', 'shell', or 'set'")
+        
+        if errors:
+            console.print("[red]✗ Validation failed:[/red]\n")
+            for error in errors:
+                console.print(f"  • {error}")
+            sys.exit(1)
+        else:
+            console.print(f"[green]✓[/green] Workflow is valid: {workflow.get('name')}")
+            console.print(f"  Steps: {len(workflow.get('steps', []))}")
+    
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        sys.exit(1)
+
+
 if __name__ == '__main__':
     main(obj={})

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.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-dev-cli
-Version: 0.6.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
@@ -145,18 +146,30 @@ 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

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

@@ -1,5 +1,5 @@
-claude_dev_cli/__init__.py,sha256=8WXldNvP94ff1oD0MSxSxb5h0bEF-eJZyVHPopW8gq8,469
-claude_dev_cli/cli.py,sha256=KJbUDQl_hA7jgLGxXQs01MW6inzevQk6d7_mUvvAAB8,31296
+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
@@ -9,14 +9,16 @@ claude_dev_cli/template_manager.py,sha256=ZFXOtRIoB6hpf8kLSF9TWJfvUPJt9b-PyEv3qT
 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.6.0.dist-info/licenses/LICENSE,sha256=DGueuJwMJtMwgLO5mWlS0TaeBrFwQuNpNZ22PU9J2bw,1062
-claude_dev_cli-0.6.0.dist-info/METADATA,sha256=d1aptyTDwcmtYPMrSgTk4j5pHCPgVriDnyjx--JjDCk,12984
-claude_dev_cli-0.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_dev_cli-0.6.0.dist-info/entry_points.txt,sha256=zymgUIIVpFTARkFmxAuW2A4BQsNITh_L0uU-XunytHg,85
-claude_dev_cli-0.6.0.dist-info/top_level.txt,sha256=m7MF6LOIuTe41IT5Fgt0lc-DK1EgM4gUU_IZwWxK0pg,15
-claude_dev_cli-0.6.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,,