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

claude_dev_cli/template_manager.py

@@ -0,0 +1,288 @@
+"""Template management for reusable prompts."""
+
+import json
+import re
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+
+
+class Template:
+    """Represents a reusable prompt template."""
+    
+    def __init__(
+        self,
+        name: str,
+        content: str,
+        description: Optional[str] = None,
+        variables: Optional[List[str]] = None,
+        category: Optional[str] = None,
+        builtin: bool = False
+    ):
+        self.name = name
+        self.content = content
+        self.description = description or ""
+        self.variables = variables or self._extract_variables(content)
+        self.category = category or "general"
+        self.builtin = builtin
+    
+    @staticmethod
+    def _extract_variables(content: str) -> List[str]:
+        """Extract {{variable}} placeholders from content."""
+        return list(set(re.findall(r'\{\{(\w+)\}\}', content)))
+    
+    def render(self, **kwargs: str) -> str:
+        """Render template with provided variables."""
+        result = self.content
+        for var, value in kwargs.items():
+            result = result.replace(f'{{{{{var}}}}}', value)
+        return result
+    
+    def get_missing_variables(self, **kwargs: str) -> List[str]:
+        """Get list of required variables not provided."""
+        return [var for var in self.variables if var not in kwargs]
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for storage."""
+        return {
+            "name": self.name,
+            "content": self.content,
+            "description": self.description,
+            "variables": self.variables,
+            "category": self.category,
+            "builtin": self.builtin
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Template":
+        """Create from dictionary."""
+        return cls(
+            name=data["name"],
+            content=data["content"],
+            description=data.get("description", ""),
+            variables=data.get("variables", []),
+            category=data.get("category", "general"),
+            builtin=data.get("builtin", False)
+        )
+
+
+class TemplateManager:
+    """Manages template storage and retrieval."""
+    
+    # Built-in templates
+    BUILTIN_TEMPLATES = [
+        Template(
+            name="code-review",
+            content="""Review this code for:
+- Security vulnerabilities
+- Performance issues  
+- Best practices
+- Potential bugs
+- Code clarity
+
+{{code}}
+
+Focus on: {{focus}}""",
+            description="Comprehensive code review with customizable focus",
+            category="review",
+            builtin=True
+        ),
+        Template(
+            name="code-review-security",
+            content="""Perform a security-focused code review of this code:
+
+{{code}}
+
+Check for:
+- SQL injection vulnerabilities
+- XSS vulnerabilities
+- Authentication/authorization issues
+- Data validation problems
+- Sensitive data exposure
+- CSRF vulnerabilities""",
+            description="Security-focused code review",
+            category="review",
+            builtin=True
+        ),
+        Template(
+            name="test-strategy",
+            content="""Generate a comprehensive test strategy for this {{language}} code:
+
+{{code}}
+
+Include:
+- Unit tests for core functionality
+- Edge cases and error handling
+- Integration test scenarios
+- Mock/stub suggestions
+- Test data examples""",
+            description="Generate testing strategy and test cases",
+            category="testing",
+            builtin=True
+        ),
+        Template(
+            name="debug-error",
+            content="""Help me debug this error:
+
+Error: {{error}}
+
+Code context:
+{{code}}
+
+Please:
+1. Explain what's causing the error
+2. Suggest fixes with code examples
+3. Explain how to prevent similar errors""",
+            description="Debug error with context",
+            category="debugging",
+            builtin=True
+        ),
+        Template(
+            name="optimize-performance",
+            content="""Analyze this code for performance optimization:
+
+{{code}}
+
+Consider:
+- Time complexity improvements
+- Memory usage optimization
+- Algorithm efficiency
+- Database query optimization (if applicable)
+- Caching opportunities
+
+Provide specific code improvements.""",
+            description="Performance optimization analysis",
+            category="optimization",
+            builtin=True
+        ),
+        Template(
+            name="refactor-clean",
+            content="""Refactor this code to improve:
+- Readability
+- Maintainability
+- Code organization
+- Naming conventions
+- {{language}} idioms
+
+{{code}}
+
+Provide the refactored version with explanations.""",
+            description="Clean code refactoring",
+            category="refactoring",
+            builtin=True
+        ),
+        Template(
+            name="explain-code",
+            content="""Explain this code in detail:
+
+{{code}}
+
+Include:
+- What it does (high-level)
+- How it works (step-by-step)
+- Why certain approaches were used
+- Potential improvements
+
+Audience level: {{level}}""",
+            description="Detailed code explanation",
+            category="documentation",
+            builtin=True
+        ),
+        Template(
+            name="api-design",
+            content="""Design a {{style}} API for:
+
+{{description}}
+
+Include:
+- Endpoint definitions
+- Request/response formats
+- Error handling
+- Authentication approach
+- Rate limiting considerations""",
+            description="API design assistance",
+            category="design",
+            builtin=True
+        ),
+    ]
+    
+    def __init__(self, templates_dir: Path):
+        self.templates_dir = templates_dir
+        self.templates_file = templates_dir / "templates.json"
+        self.templates_dir.mkdir(parents=True, exist_ok=True)
+        self._load_templates()
+    
+    def _load_templates(self) -> None:
+        """Load templates from disk."""
+        self.templates: Dict[str, Template] = {}
+        
+        # Load built-in templates
+        for template in self.BUILTIN_TEMPLATES:
+            self.templates[template.name] = template
+        
+        # Load user templates
+        if self.templates_file.exists():
+            try:
+                with open(self.templates_file, 'r') as f:
+                    data = json.load(f)
+                for template_data in data.get("templates", []):
+                    template = Template.from_dict(template_data)
+                    self.templates[template.name] = template
+            except Exception:
+                pass
+    
+    def _save_templates(self) -> None:
+        """Save user templates to disk."""
+        # Only save non-builtin templates
+        user_templates = [
+            t.to_dict() for t in self.templates.values() if not t.builtin
+        ]
+        
+        with open(self.templates_file, 'w') as f:
+            json.dump({"templates": user_templates}, f, indent=2)
+    
+    def add_template(self, template: Template) -> None:
+        """Add or update a template."""
+        if template.name in self.templates and self.templates[template.name].builtin:
+            raise ValueError(f"Cannot override builtin template: {template.name}")
+        
+        self.templates[template.name] = template
+        self._save_templates()
+    
+    def get_template(self, name: str) -> Optional[Template]:
+        """Get a template by name."""
+        return self.templates.get(name)
+    
+    def list_templates(
+        self,
+        category: Optional[str] = None,
+        builtin_only: bool = False,
+        user_only: bool = False
+    ) -> List[Template]:
+        """List templates with optional filters."""
+        templates = list(self.templates.values())
+        
+        if category:
+            templates = [t for t in templates if t.category == category]
+        
+        if builtin_only:
+            templates = [t for t in templates if t.builtin]
+        elif user_only:
+            templates = [t for t in templates if not t.builtin]
+        
+        return sorted(templates, key=lambda t: (t.category, t.name))
+    
+    def delete_template(self, name: str) -> bool:
+        """Delete a template (cannot delete builtins)."""
+        if name not in self.templates:
+            return False
+        
+        if self.templates[name].builtin:
+            raise ValueError(f"Cannot delete builtin template: {name}")
+        
+        del self.templates[name]
+        self._save_templates()
+        return True
+    
+    def get_categories(self) -> List[str]:
+        """Get list of all template categories."""
+        return sorted(set(t.category for t in self.templates.values()))

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)