claude-dev-cli 0.5.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.2.0"
+__version__ = "0.7.0"
 __author__ = "Julio"
 __license__ = "MIT"
 

claude_dev_cli/cli.py

@@ -25,6 +25,7 @@ from claude_dev_cli.usage import UsageTracker
 from claude_dev_cli import toon_utils
 from claude_dev_cli.plugins import load_plugins
 from claude_dev_cli.history import ConversationHistory, Conversation
+from claude_dev_cli.template_manager import TemplateManager, Template
 
 console = Console()
 
@@ -446,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']
@@ -460,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:
@@ -476,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']
@@ -490,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)
     
@@ -506,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']
@@ -521,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]")
@@ -566,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']
@@ -580,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)
     
@@ -753,5 +892,424 @@ def toon_info(ctx: click.Context) -> None:
         console.print("• Same data, fewer tokens")
 
 
+@main.group()
+def template() -> None:
+    """Manage custom prompt templates."""
+    pass
+
+
+@template.command('list')
+@click.option('-c', '--category', help='Filter by category')
+@click.option('--builtin', is_flag=True, help='Show only built-in templates')
+@click.option('--user', is_flag=True, help='Show only user templates')
+@click.pass_context
+def template_list(
+    ctx: click.Context,
+    category: Optional[str],
+    builtin: bool,
+    user: bool
+) -> None:
+    """List available templates."""
+    console = ctx.obj['console']
+    config = Config()
+    manager = TemplateManager(config.config_dir)
+    
+    templates = manager.list_templates(
+        category=category,
+        builtin_only=builtin,
+        user_only=user
+    )
+    
+    if not templates:
+        console.print("[yellow]No templates found.[/yellow]")
+        return
+    
+    from rich.table import Table
+    
+    table = Table(show_header=True, header_style="bold magenta")
+    table.add_column("Name", style="cyan")
+    table.add_column("Category", style="green")
+    table.add_column("Variables", style="yellow")
+    table.add_column("Type", style="blue")
+    table.add_column("Description")
+    
+    for tmpl in templates:
+        vars_display = ", ".join(tmpl.variables) if tmpl.variables else "-"
+        type_display = "🔒 Built-in" if tmpl.builtin else "📝 User"
+        table.add_row(
+            tmpl.name,
+            tmpl.category,
+            vars_display,
+            type_display,
+            tmpl.description
+        )
+    
+    console.print(table)
+    
+    # Show categories
+    categories = manager.get_categories()
+    console.print(f"\n[dim]Categories: {', '.join(categories)}[/dim]")
+
+
+@template.command('show')
+@click.argument('name')
+@click.pass_context
+def template_show(ctx: click.Context, name: str) -> None:
+    """Show template details."""
+    console = ctx.obj['console']
+    config = Config()
+    manager = TemplateManager(config.config_dir)
+    
+    tmpl = manager.get_template(name)
+    if not tmpl:
+        console.print(f"[red]Template not found: {name}[/red]")
+        sys.exit(1)
+    
+    console.print(Panel(
+        f"[bold]{tmpl.name}[/bold]\n\n"
+        f"[dim]{tmpl.description}[/dim]\n\n"
+        f"Category: [green]{tmpl.category}[/green]\n"
+        f"Type: {'🔒 Built-in' if tmpl.builtin else '📝 User'}\n"
+        f"Variables: [yellow]{', '.join(tmpl.variables) if tmpl.variables else 'None'}[/yellow]",
+        title="Template Info",
+        border_style="blue"
+    ))
+    
+    console.print("\n[bold]Content:[/bold]\n")
+    console.print(Panel(tmpl.content, border_style="dim"))
+
+
+@template.command('add')
+@click.argument('name')
+@click.option('-c', '--content', help='Template content (or use stdin)')
+@click.option('-d', '--description', help='Template description')
+@click.option('--category', default='general', help='Template category')
+@click.pass_context
+def template_add(
+    ctx: click.Context,
+    name: str,
+    content: Optional[str],
+    description: Optional[str],
+    category: str
+) -> None:
+    """Add a new template."""
+    console = ctx.obj['console']
+    config = Config()
+    manager = TemplateManager(config.config_dir)
+    
+    # Get content from stdin if not provided
+    if not content:
+        if sys.stdin.isatty():
+            console.print("[yellow]Enter template content (Ctrl+D to finish):[/yellow]")
+        content = sys.stdin.read().strip()
+    
+    if not content:
+        console.print("[red]Error: No content provided[/red]")
+        sys.exit(1)
+    
+    try:
+        tmpl = Template(
+            name=name,
+            content=content,
+            description=description,
+            category=category
+        )
+        manager.add_template(tmpl)
+        
+        console.print(f"[green]✓[/green] Template added: {name}")
+        if tmpl.variables:
+            console.print(f"[dim]Variables: {', '.join(tmpl.variables)}[/dim]")
+    
+    except ValueError as e:
+        console.print(f"[red]Error: {e}[/red]")
+        sys.exit(1)
+
+
+@template.command('delete')
+@click.argument('name')
+@click.pass_context
+def template_delete(ctx: click.Context, name: str) -> None:
+    """Delete a user template."""
+    console = ctx.obj['console']
+    config = Config()
+    manager = TemplateManager(config.config_dir)
+    
+    try:
+        if manager.delete_template(name):
+            console.print(f"[green]✓[/green] Template deleted: {name}")
+        else:
+            console.print(f"[red]Template not found: {name}[/red]")
+            sys.exit(1)
+    
+    except ValueError as e:
+        console.print(f"[red]Error: {e}[/red]")
+        sys.exit(1)
+
+
+@template.command('use')
+@click.argument('name')
+@click.option('-a', '--api', help='API config to use')
+@click.option('-m', '--model', help='Claude model to use')
+@click.pass_context
+def template_use(ctx: click.Context, name: str, api: Optional[str], model: Optional[str]) -> None:
+    """Use a template with interactive variable input."""
+    console = ctx.obj['console']
+    config = Config()
+    manager = TemplateManager(config.config_dir)
+    
+    tmpl = manager.get_template(name)
+    if not tmpl:
+        console.print(f"[red]Template not found: {name}[/red]")
+        sys.exit(1)
+    
+    # Get variable values
+    variables = {}
+    if tmpl.variables:
+        console.print(f"\n[bold]Template: {name}[/bold]")
+        console.print(f"[dim]{tmpl.description}[/dim]\n")
+        
+        for var in tmpl.variables:
+            value = console.input(f"[cyan]{var}:[/cyan] ").strip()
+            variables[var] = value
+    
+    # Check for missing variables
+    missing = tmpl.get_missing_variables(**variables)
+    if missing:
+        console.print(f"[red]Missing required variables: {', '.join(missing)}[/red]")
+        sys.exit(1)
+    
+    # Render template
+    prompt = tmpl.render(**variables)
+    
+    # Call Claude
+    try:
+        client = ClaudeClient(api_config_name=api)
+        
+        console.print("\n[bold green]Claude:[/bold green] ", end='')
+        for chunk in client.call_streaming(prompt, model=model):
+            console.print(chunk, end='')
+        console.print()
+    
+    except Exception as e:
+        console.print(f"\n[red]Error: {e}[/red]")
+        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={})