claude-dev-cli 0.6.0__py3-none-any.whl → 0.8.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.8.0"
 __author__ = "Julio"
 __license__ = "MIT"
 

claude_dev_cli/cli.py

@@ -57,6 +57,7 @@ except Exception:
 @click.option('-a', '--api', help='API config to use')
 @click.option('-m', '--model', help='Claude model to use')
 @click.option('--stream/--no-stream', default=True, help='Stream response')
+@click.option('--auto-context', is_flag=True, help='Automatically include git, dependencies, and related files')
 @click.pass_context
 def ask(
     ctx: click.Context,
@@ -65,7 +66,8 @@ def ask(
     system: Optional[str],
     api: Optional[str],
     model: Optional[str],
-    stream: bool
+    stream: bool,
+    auto_context: bool
 ) -> None:
     """Ask Claude a question (single-shot mode)."""
     console = ctx.obj['console']
@@ -73,7 +75,18 @@ def ask(
     # Build prompt
     prompt_parts = []
     
-    if file:
+    # Gather context if requested
+    if auto_context and file:
+        from claude_dev_cli.context import ContextGatherer
+        
+        with console.status("[bold blue]Gathering context..."):
+            gatherer = ContextGatherer()
+            context = gatherer.gather_for_file(Path(file))
+            context_info = context.format_for_prompt()
+        
+        console.print("[dim]✓ Context gathered[/dim]")
+        prompt_parts.append(context_info)
+    elif file:
         with open(file, 'r') as f:
             file_content = f.read()
             prompt_parts.append(f"File: {file}\n\n{file_content}\n\n")
@@ -447,12 +460,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 +476,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 +529,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 +545,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,21 +596,69 @@ 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.option('--auto-context', is_flag=True, help='Automatically include git, dependencies, and related files')
 @click.pass_context
 def review(
     ctx: click.Context,
     file_path: str,
-    api: Optional[str]
+    api: Optional[str],
+    interactive: bool,
+    auto_context: bool
 ) -> None:
     """Review code for bugs and improvements."""
     console = ctx.obj['console']
     
     try:
+        # Gather context if requested
+        context_info = ""
+        if auto_context:
+            from claude_dev_cli.context import ContextGatherer
+            
+            with console.status("[bold blue]Gathering context..."):
+                gatherer = ContextGatherer()
+                context = gatherer.gather_for_review(Path(file_path))
+                context_info = context.format_for_prompt()
+            
+            console.print("[dim]✓ Context gathered (git, dependencies, tests)[/dim]")
+        
         with console.status("[bold blue]Reviewing code..."):
-            result = code_review(file_path, api_config_name=api)
+            # If we have context, prepend it to the file analysis
+            if context_info:
+                # Read file separately for context-aware review
+                result = code_review(file_path, api_config_name=api)
+                # The context module already includes the file, so we use it differently
+                client = ClaudeClient(api_config_name=api)
+                enhanced_prompt = f"{context_info}\n\nPlease review this code for bugs and improvements."
+                result = client.call(enhanced_prompt)
+            else:
+                result = code_review(file_path, api_config_name=api)
         
         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]")
@@ -532,12 +669,14 @@ def review(
 @click.option('-f', '--file', type=click.Path(exists=True), help='File to debug')
 @click.option('-e', '--error', help='Error message to analyze')
 @click.option('-a', '--api', help='API config to use')
+@click.option('--auto-context', is_flag=True, help='Automatically include git context and parse error details')
 @click.pass_context
 def debug(
     ctx: click.Context,
     file: Optional[str],
     error: Optional[str],
-    api: Optional[str]
+    api: Optional[str],
+    auto_context: bool
 ) -> None:
     """Debug code and analyze errors."""
     console = ctx.obj['console']
@@ -547,13 +686,33 @@ def debug(
     if not sys.stdin.isatty():
         stdin_content = sys.stdin.read().strip()
     
+    error_text = error or stdin_content
+    
     try:
-        with console.status("[bold blue]Analyzing error..."):
-            result = debug_code(
-                file_path=file,
-                error_message=error or stdin_content,
-                api_config_name=api
-            )
+        # Gather context if requested
+        if auto_context and error_text:
+            from claude_dev_cli.context import ContextGatherer
+            
+            with console.status("[bold blue]Gathering context..."):
+                gatherer = ContextGatherer()
+                file_path = Path(file) if file else None
+                context = gatherer.gather_for_error(error_text, file_path=file_path)
+                context_info = context.format_for_prompt()
+            
+            console.print("[dim]✓ Context gathered (error details, git context)[/dim]")
+            
+            # Use context-aware analysis
+            client = ClaudeClient(api_config_name=api)
+            enhanced_prompt = f"{context_info}\n\nPlease analyze this error and suggest fixes."
+            result = client.call(enhanced_prompt)
+        else:
+            # Original behavior
+            with console.status("[bold blue]Analyzing error..."):
+                result = debug_code(
+                    file_path=file,
+                    error_message=error_text,
+                    api_config_name=api
+                )
         
         md = Markdown(result)
         console.print(md)
@@ -567,25 +726,80 @@ 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.option('--auto-context', is_flag=True, help='Automatically include git, dependencies, and related files')
 @click.pass_context
 def refactor(
     ctx: click.Context,
     file_path: str,
     output: Optional[str],
-    api: Optional[str]
+    api: Optional[str],
+    interactive: bool,
+    auto_context: bool
 ) -> None:
     """Suggest refactoring improvements."""
     console = ctx.obj['console']
     
     try:
-        with console.status("[bold blue]Analyzing code..."):
-            result = refactor_code(file_path, api_config_name=api)
+        # Gather context if requested
+        if auto_context:
+            from claude_dev_cli.context import ContextGatherer
+            
+            with console.status("[bold blue]Gathering context..."):
+                gatherer = ContextGatherer()
+                context = gatherer.gather_for_file(Path(file_path))
+                context_info = context.format_for_prompt()
+            
+            console.print("[dim]✓ Context gathered[/dim]")
+            
+            # Use context-aware refactoring
+            client = ClaudeClient(api_config_name=api)
+            enhanced_prompt = f"{context_info}\n\nPlease suggest refactoring improvements for the main file."
+            result = client.call(enhanced_prompt)
+        else:
+            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 +1171,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/config.py

@@ -25,6 +25,12 @@ class ProjectProfile(BaseModel):
     api_config: str  # Name of the API config to use
     system_prompt: Optional[str] = None
     allowed_commands: List[str] = Field(default_factory=lambda: ["all"])
+    
+    # Project memory - preferences and patterns
+    auto_context: bool = False  # Default value for --auto-context flag
+    coding_style: Optional[str] = None  # Preferred coding style
+    test_framework: Optional[str] = None  # Preferred test framework
+    preferences: Dict[str, str] = Field(default_factory=dict)  # Custom preferences
 
 
 class Config: