claude-dev-cli 0.5.0__tar.gz → 0.6.0__tar.gz

{claude_dev_cli-0.5.0/src/claude_dev_cli.egg-info → claude_dev_cli-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-dev-cli
-Version: 0.5.0
+Version: 0.6.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
@@ -72,6 +72,12 @@ A powerful command-line tool for developers using Claude AI with multi-API routi
 - **Interactive**: Chat mode with conversation history
 - **Streaming**: Real-time responses
 
+### 📝 Custom Templates
+- **Built-in Templates**: 8 pre-built templates for common tasks (code review, testing, debugging, etc.)
+- **User Templates**: Create and manage your own reusable prompt templates
+- **Variable Substitution**: Use {{variable}} placeholders for dynamic content
+- **Categories**: Organize templates by category (review, testing, debugging, etc.)
+
 ### 🎒 TOON Format Support (Optional)
 - **Token Reduction**: 30-60% fewer tokens than JSON
 - **Cost Savings**: Reduce API costs significantly
@@ -156,7 +162,44 @@ git add .
 cdc git commit
 ```
 
-### 4. Usage Tracking
+### 5. Custom Templates
+
+```bash
+# List all templates (built-in and user)
+cdc template list
+
+# Show template details
+cdc template show code-review
+
+# Add a custom template
+cdc template add my-review -c "Review this code for {{focus}}: {{code}}" \
+  -d "Custom review template" --category review
+
+# Use a template (interactive variable input)
+cdc template use debug-error
+
+# Delete a user template
+cdc template delete my-review
+
+# Filter by category
+cdc template list --category review
+
+# Show only user templates
+cdc template list --user
+```
+
+#### Built-in Templates
+
+- **code-review**: Comprehensive code review with customizable focus
+- **code-review-security**: Security-focused code review
+- **test-strategy**: Generate testing strategy and test cases
+- **debug-error**: Debug error with context
+- **optimize-performance**: Performance optimization analysis
+- **refactor-clean**: Clean code refactoring
+- **explain-code**: Detailed code explanation
+- **api-design**: API design assistance
+
+### 6. Usage Tracking
 
 ```bash
 # View all usage
@@ -169,7 +212,7 @@ cdc usage --days 7
 cdc usage --api client
 ```
 
-### 5. TOON Format (Optional - Reduces Tokens by 30-60%)
+### 7. TOON Format (Optional - Reduces Tokens by 30-60%)
 
 ```bash
 # Check if TOON is installed
@@ -322,6 +365,16 @@ When using a client's Enterprise API:
 | `cdc debug -f <file> -e <error>` | Debug code |
 | `cdc refactor <file>` | Refactoring suggestions |
 
+### Templates
+
+| Command | Description |
+|---------|-------------|
+| `cdc template list` | List all templates |
+| `cdc template show <name>` | Show template details |
+| `cdc template add <name>` | Add new template |
+| `cdc template delete <name>` | Delete user template |
+| `cdc template use <name>` | Use template interactively |
+
 ### Git Helpers
 
 | Command | Description |

{claude_dev_cli-0.5.0 → claude_dev_cli-0.6.0}/README.md

@@ -29,6 +29,12 @@ A powerful command-line tool for developers using Claude AI with multi-API routi
 - **Interactive**: Chat mode with conversation history
 - **Streaming**: Real-time responses
 
+### 📝 Custom Templates
+- **Built-in Templates**: 8 pre-built templates for common tasks (code review, testing, debugging, etc.)
+- **User Templates**: Create and manage your own reusable prompt templates
+- **Variable Substitution**: Use {{variable}} placeholders for dynamic content
+- **Categories**: Organize templates by category (review, testing, debugging, etc.)
+
 ### 🎒 TOON Format Support (Optional)
 - **Token Reduction**: 30-60% fewer tokens than JSON
 - **Cost Savings**: Reduce API costs significantly
@@ -113,7 +119,44 @@ git add .
 cdc git commit
 ```
 
-### 4. Usage Tracking
+### 5. Custom Templates
+
+```bash
+# List all templates (built-in and user)
+cdc template list
+
+# Show template details
+cdc template show code-review
+
+# Add a custom template
+cdc template add my-review -c "Review this code for {{focus}}: {{code}}" \
+  -d "Custom review template" --category review
+
+# Use a template (interactive variable input)
+cdc template use debug-error
+
+# Delete a user template
+cdc template delete my-review
+
+# Filter by category
+cdc template list --category review
+
+# Show only user templates
+cdc template list --user
+```
+
+#### Built-in Templates
+
+- **code-review**: Comprehensive code review with customizable focus
+- **code-review-security**: Security-focused code review
+- **test-strategy**: Generate testing strategy and test cases
+- **debug-error**: Debug error with context
+- **optimize-performance**: Performance optimization analysis
+- **refactor-clean**: Clean code refactoring
+- **explain-code**: Detailed code explanation
+- **api-design**: API design assistance
+
+### 6. Usage Tracking
 
 ```bash
 # View all usage
@@ -126,7 +169,7 @@ cdc usage --days 7
 cdc usage --api client
 ```
 
-### 5. TOON Format (Optional - Reduces Tokens by 30-60%)
+### 7. TOON Format (Optional - Reduces Tokens by 30-60%)
 
 ```bash
 # Check if TOON is installed
@@ -279,6 +322,16 @@ When using a client's Enterprise API:
 | `cdc debug -f <file> -e <error>` | Debug code |
 | `cdc refactor <file>` | Refactoring suggestions |
 
+### Templates
+
+| Command | Description |
+|---------|-------------|
+| `cdc template list` | List all templates |
+| `cdc template show <name>` | Show template details |
+| `cdc template add <name>` | Add new template |
+| `cdc template delete <name>` | Delete user template |
+| `cdc template use <name>` | Use template interactively |
+
 ### Git Helpers
 
 | Command | Description |

{claude_dev_cli-0.5.0 → claude_dev_cli-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-dev-cli"
-version = "0.5.0"
+version = "0.6.0"
 description = "A powerful CLI tool for developers using Claude AI with multi-API routing, test generation, code review, and usage tracking"
 readme = "README.md"
 requires-python = ">=3.9"

{claude_dev_cli-0.5.0 → claude_dev_cli-0.6.0}/src/claude_dev_cli/__init__.py

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

{claude_dev_cli-0.5.0 → claude_dev_cli-0.6.0}/src/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()
 
@@ -753,5 +754,208 @@ 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)
+
+
 if __name__ == '__main__':
     main(obj={})

claude_dev_cli-0.6.0/src/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-0.5.0 → claude_dev_cli-0.6.0/src/claude_dev_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-dev-cli
-Version: 0.5.0
+Version: 0.6.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
@@ -72,6 +72,12 @@ A powerful command-line tool for developers using Claude AI with multi-API routi
 - **Interactive**: Chat mode with conversation history
 - **Streaming**: Real-time responses
 
+### 📝 Custom Templates
+- **Built-in Templates**: 8 pre-built templates for common tasks (code review, testing, debugging, etc.)
+- **User Templates**: Create and manage your own reusable prompt templates
+- **Variable Substitution**: Use {{variable}} placeholders for dynamic content
+- **Categories**: Organize templates by category (review, testing, debugging, etc.)
+
 ### 🎒 TOON Format Support (Optional)
 - **Token Reduction**: 30-60% fewer tokens than JSON
 - **Cost Savings**: Reduce API costs significantly
@@ -156,7 +162,44 @@ git add .
 cdc git commit
 ```
 
-### 4. Usage Tracking
+### 5. Custom Templates
+
+```bash
+# List all templates (built-in and user)
+cdc template list
+
+# Show template details
+cdc template show code-review
+
+# Add a custom template
+cdc template add my-review -c "Review this code for {{focus}}: {{code}}" \
+  -d "Custom review template" --category review
+
+# Use a template (interactive variable input)
+cdc template use debug-error
+
+# Delete a user template
+cdc template delete my-review
+
+# Filter by category
+cdc template list --category review
+
+# Show only user templates
+cdc template list --user
+```
+
+#### Built-in Templates
+
+- **code-review**: Comprehensive code review with customizable focus
+- **code-review-security**: Security-focused code review
+- **test-strategy**: Generate testing strategy and test cases
+- **debug-error**: Debug error with context
+- **optimize-performance**: Performance optimization analysis
+- **refactor-clean**: Clean code refactoring
+- **explain-code**: Detailed code explanation
+- **api-design**: API design assistance
+
+### 6. Usage Tracking
 
 ```bash
 # View all usage
@@ -169,7 +212,7 @@ cdc usage --days 7
 cdc usage --api client
 ```
 
-### 5. TOON Format (Optional - Reduces Tokens by 30-60%)
+### 7. TOON Format (Optional - Reduces Tokens by 30-60%)
 
 ```bash
 # Check if TOON is installed
@@ -322,6 +365,16 @@ When using a client's Enterprise API:
 | `cdc debug -f <file> -e <error>` | Debug code |
 | `cdc refactor <file>` | Refactoring suggestions |
 
+### Templates
+
+| Command | Description |
+|---------|-------------|
+| `cdc template list` | List all templates |
+| `cdc template show <name>` | Show template details |
+| `cdc template add <name>` | Add new template |
+| `cdc template delete <name>` | Delete user template |
+| `cdc template use <name>` | Use template interactively |
+
 ### Git Helpers
 
 | Command | Description |

{claude_dev_cli-0.5.0 → claude_dev_cli-0.6.0}/src/claude_dev_cli.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ src/claude_dev_cli/config.py
 src/claude_dev_cli/core.py
 src/claude_dev_cli/history.py
 src/claude_dev_cli/secure_storage.py
+src/claude_dev_cli/template_manager.py
 src/claude_dev_cli/templates.py
 src/claude_dev_cli/toon_utils.py
 src/claude_dev_cli/usage.py
@@ -29,5 +30,6 @@ tests/test_config.py
 tests/test_core.py
 tests/test_diff_editor.py
 tests/test_secure_storage.py
+tests/test_template_manager.py
 tests/test_toon_utils.py
 tests/test_usage.py

claude_dev_cli-0.6.0/tests/test_template_manager.py

@@ -0,0 +1,327 @@
+"""Tests for template manager."""
+
+import json
+import pytest
+from pathlib import Path
+from claude_dev_cli.template_manager import Template, TemplateManager
+
+
+class TestTemplate:
+    """Test Template class."""
+    
+    def test_template_creation(self):
+        """Test creating a basic template."""
+        tmpl = Template(
+            name="test",
+            content="Hello {{name}}",
+            description="Test template",
+            category="test"
+        )
+        
+        assert tmpl.name == "test"
+        assert tmpl.content == "Hello {{name}}"
+        assert tmpl.description == "Test template"
+        assert tmpl.category == "test"
+        assert tmpl.builtin is False
+    
+    def test_extract_variables(self):
+        """Test variable extraction from content."""
+        tmpl = Template(
+            name="test",
+            content="Hello {{name}}, you are {{age}} years old. {{name}} is cool."
+        )
+        
+        # Should extract unique variables
+        assert set(tmpl.variables) == {"name", "age"}
+    
+    def test_render_template(self):
+        """Test rendering template with variables."""
+        tmpl = Template(
+            name="test",
+            content="Hello {{name}}, you are {{age}} years old."
+        )
+        
+        result = tmpl.render(name="Alice", age="30")
+        assert result == "Hello Alice, you are 30 years old."
+    
+    def test_render_partial(self):
+        """Test rendering with missing variables."""
+        tmpl = Template(
+            name="test",
+            content="Hello {{name}}, you are {{age}} years old."
+        )
+        
+        result = tmpl.render(name="Bob")
+        # Missing variables remain as placeholders
+        assert result == "Hello Bob, you are {{age}} years old."
+    
+    def test_get_missing_variables(self):
+        """Test checking for missing variables."""
+        tmpl = Template(
+            name="test",
+            content="Hello {{name}}, you are {{age}} years old."
+        )
+        
+        assert tmpl.get_missing_variables(name="Alice") == ["age"]
+        assert tmpl.get_missing_variables(name="Alice", age="30") == []
+    
+    def test_to_dict(self):
+        """Test serialization to dict."""
+        tmpl = Template(
+            name="test",
+            content="Hello {{name}}",
+            description="Test template",
+            category="test",
+            builtin=True
+        )
+        
+        data = tmpl.to_dict()
+        assert data["name"] == "test"
+        assert data["content"] == "Hello {{name}}"
+        assert data["description"] == "Test template"
+        assert data["category"] == "test"
+        assert data["builtin"] is True
+        assert "name" in data["variables"]
+    
+    def test_from_dict(self):
+        """Test deserialization from dict."""
+        data = {
+            "name": "test",
+            "content": "Hello {{name}}",
+            "description": "Test template",
+            "category": "test",
+            "builtin": True,
+            "variables": ["name"]
+        }
+        
+        tmpl = Template.from_dict(data)
+        assert tmpl.name == "test"
+        assert tmpl.content == "Hello {{name}}"
+        assert tmpl.description == "Test template"
+        assert tmpl.category == "test"
+        assert tmpl.builtin is True
+        assert tmpl.variables == ["name"]
+
+
+class TestTemplateManager:
+    """Test TemplateManager class."""
+    
+    @pytest.fixture
+    def temp_dir(self, tmp_path: Path) -> Path:
+        """Create temporary directory for tests."""
+        return tmp_path / "templates"
+    
+    @pytest.fixture
+    def manager(self, temp_dir: Path) -> TemplateManager:
+        """Create template manager with temp directory."""
+        return TemplateManager(temp_dir)
+    
+    def test_manager_creation(self, temp_dir: Path, manager: TemplateManager):
+        """Test manager creates directory structure."""
+        assert temp_dir.exists()
+        assert manager.templates_file == temp_dir / "templates.json"
+    
+    def test_builtin_templates_loaded(self, manager: TemplateManager):
+        """Test built-in templates are loaded."""
+        # Should have 8 built-in templates
+        builtins = [t for t in manager.templates.values() if t.builtin]
+        assert len(builtins) == 8
+        
+        # Check specific templates exist
+        assert "code-review" in manager.templates
+        assert "test-strategy" in manager.templates
+        assert "debug-error" in manager.templates
+    
+    def test_add_user_template(self, manager: TemplateManager):
+        """Test adding a user template."""
+        tmpl = Template(
+            name="my-template",
+            content="Custom content {{var}}",
+            description="My template"
+        )
+        
+        manager.add_template(tmpl)
+        
+        # Should be in memory
+        assert "my-template" in manager.templates
+        
+        # Should be saved to disk
+        assert manager.templates_file.exists()
+        with open(manager.templates_file) as f:
+            data = json.load(f)
+        
+        assert len(data["templates"]) == 1
+        assert data["templates"][0]["name"] == "my-template"
+    
+    def test_cannot_override_builtin(self, manager: TemplateManager):
+        """Test cannot override built-in templates."""
+        tmpl = Template(
+            name="code-review",
+            content="Override attempt"
+        )
+        
+        with pytest.raises(ValueError, match="Cannot override builtin"):
+            manager.add_template(tmpl)
+    
+    def test_get_template(self, manager: TemplateManager):
+        """Test getting template by name."""
+        # Get built-in
+        tmpl = manager.get_template("code-review")
+        assert tmpl is not None
+        assert tmpl.name == "code-review"
+        
+        # Get non-existent
+        assert manager.get_template("nonexistent") is None
+    
+    def test_list_templates_all(self, manager: TemplateManager):
+        """Test listing all templates."""
+        templates = manager.list_templates()
+        
+        # Should have 8 built-ins
+        assert len(templates) >= 8
+        
+        # Should be sorted by category then name
+        categories = [t.category for t in templates]
+        assert categories == sorted(categories)
+    
+    def test_list_templates_by_category(self, manager: TemplateManager):
+        """Test filtering templates by category."""
+        review_templates = manager.list_templates(category="review")
+        
+        assert len(review_templates) >= 2  # code-review and code-review-security
+        assert all(t.category == "review" for t in review_templates)
+    
+    def test_list_templates_builtin_only(self, manager: TemplateManager):
+        """Test listing only built-in templates."""
+        # Add a user template
+        manager.add_template(Template(name="user-tmpl", content="test"))
+        
+        builtins = manager.list_templates(builtin_only=True)
+        assert len(builtins) == 8
+        assert all(t.builtin for t in builtins)
+    
+    def test_list_templates_user_only(self, manager: TemplateManager):
+        """Test listing only user templates."""
+        # Add user templates
+        manager.add_template(Template(name="user-1", content="test1"))
+        manager.add_template(Template(name="user-2", content="test2"))
+        
+        user_templates = manager.list_templates(user_only=True)
+        assert len(user_templates) == 2
+        assert all(not t.builtin for t in user_templates)
+    
+    def test_delete_user_template(self, manager: TemplateManager):
+        """Test deleting user template."""
+        # Add template
+        manager.add_template(Template(name="to-delete", content="test"))
+        assert "to-delete" in manager.templates
+        
+        # Delete it
+        result = manager.delete_template("to-delete")
+        assert result is True
+        assert "to-delete" not in manager.templates
+        
+        # Should be removed from disk
+        with open(manager.templates_file) as f:
+            data = json.load(f)
+        
+        assert not any(t["name"] == "to-delete" for t in data["templates"])
+    
+    def test_cannot_delete_builtin(self, manager: TemplateManager):
+        """Test cannot delete built-in templates."""
+        with pytest.raises(ValueError, match="Cannot delete builtin"):
+            manager.delete_template("code-review")
+    
+    def test_delete_nonexistent(self, manager: TemplateManager):
+        """Test deleting non-existent template."""
+        result = manager.delete_template("nonexistent")
+        assert result is False
+    
+    def test_get_categories(self, manager: TemplateManager):
+        """Test getting list of categories."""
+        categories = manager.get_categories()
+        
+        # Should include all built-in categories
+        assert "review" in categories
+        assert "testing" in categories
+        assert "debugging" in categories
+        assert "optimization" in categories
+        assert "refactoring" in categories
+        assert "documentation" in categories
+        assert "design" in categories
+        
+        # Should be sorted
+        assert categories == sorted(categories)
+    
+    def test_persistence(self, temp_dir: Path):
+        """Test templates persist across manager instances."""
+        # Create manager and add template
+        manager1 = TemplateManager(temp_dir)
+        manager1.add_template(Template(
+            name="persistent",
+            content="test {{var}}",
+            description="Test persistence"
+        ))
+        
+        # Create new manager instance
+        manager2 = TemplateManager(temp_dir)
+        
+        # Should load the saved template
+        tmpl = manager2.get_template("persistent")
+        assert tmpl is not None
+        assert tmpl.name == "persistent"
+        assert tmpl.content == "test {{var}}"
+    
+    def test_update_template(self, manager: TemplateManager):
+        """Test updating an existing user template."""
+        # Add initial template
+        manager.add_template(Template(
+            name="update-test",
+            content="Original {{var}}",
+            description="Original"
+        ))
+        
+        # Update it
+        manager.add_template(Template(
+            name="update-test",
+            content="Updated {{var}}",
+            description="Updated"
+        ))
+        
+        # Should be updated
+        tmpl = manager.get_template("update-test")
+        assert tmpl.content == "Updated {{var}}"
+        assert tmpl.description == "Updated"
+    
+    def test_multiple_categories(self, manager: TemplateManager):
+        """Test templates with different categories."""
+        manager.add_template(Template(
+            name="cat1",
+            content="test",
+            category="category1"
+        ))
+        manager.add_template(Template(
+            name="cat2",
+            content="test",
+            category="category2"
+        ))
+        
+        # Filter by each category
+        cat1_templates = manager.list_templates(category="category1")
+        cat2_templates = manager.list_templates(category="category2")
+        
+        assert len(cat1_templates) == 1
+        assert len(cat2_templates) == 1
+        assert cat1_templates[0].name == "cat1"
+        assert cat2_templates[0].name == "cat2"
+    
+    def test_template_with_no_variables(self, manager: TemplateManager):
+        """Test template with no variables."""
+        tmpl = Template(
+            name="no-vars",
+            content="Static content with no variables"
+        )
+        
+        assert tmpl.variables == []
+        result = tmpl.render()
+        assert result == "Static content with no variables"