claude-dev-cli 0.16.2__py3-none-any.whl → 0.18.0__py3-none-any.whl

claude_dev_cli/tickets/markdown.py

@@ -0,0 +1,309 @@
+"""Markdown-based fallback ticket backend.
+
+Simple file-based ticket system when external backends aren't available.
+"""
+
+import json
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+from datetime import datetime
+import uuid
+
+from claude_dev_cli.tickets.backend import TicketBackend, Ticket, Epic, Story
+
+
+class MarkdownBackend(TicketBackend):
+    """Simple markdown-based ticket system.
+    
+    Stores tickets as JSON files in .cdc-tickets/ directory.
+    Provides fallback when repo-tickets or other systems aren't available.
+    """
+    
+    def __init__(self, base_dir: Optional[Path] = None):
+        """Initialize markdown backend.
+        
+        Args:
+            base_dir: Base directory for tickets (default: current directory)
+        """
+        self.base_dir = base_dir or Path.cwd()
+        self.tickets_dir = self.base_dir / ".cdc-tickets"
+        self.epics_dir = self.tickets_dir / "epics"
+        self.stories_dir = self.tickets_dir / "stories"
+        self.tasks_dir = self.tickets_dir / "tasks"
+    
+    def connect(self) -> bool:
+        """Initialize ticket directories if needed."""
+        try:
+            self.tickets_dir.mkdir(exist_ok=True)
+            self.epics_dir.mkdir(exist_ok=True)
+            self.stories_dir.mkdir(exist_ok=True)
+            self.tasks_dir.mkdir(exist_ok=True)
+            return True
+        except OSError:
+            return False
+    
+    def fetch_ticket(self, ticket_id: str) -> Optional[Ticket]:
+        """Fetch ticket from JSON file."""
+        ticket_file = self.tasks_dir / f"{ticket_id}.json"
+        
+        if not ticket_file.exists():
+            return None
+        
+        try:
+            with open(ticket_file, 'r') as f:
+                data = json.load(f)
+            
+            return self._dict_to_ticket(data)
+        except (json.JSONDecodeError, OSError):
+            return None
+    
+    def create_epic(self, title: str, description: str = "", **kwargs) -> Epic:
+        """Create epic as JSON file."""
+        epic_id = f"EPIC-{self._generate_id()}"
+        
+        epic = Epic(
+            id=epic_id,
+            title=title,
+            description=description,
+            status=kwargs.get("status", "draft"),
+            priority=kwargs.get("priority", "medium"),
+            owner=kwargs.get("owner"),
+            created_at=datetime.now()
+        )
+        
+        # Save to file
+        epic_file = self.epics_dir / f"{epic_id}.json"
+        with open(epic_file, 'w') as f:
+            json.dump(self._epic_to_dict(epic), f, indent=2, default=str)
+        
+        return epic
+    
+    def create_story(self, epic_id: str, title: str, description: str = "", **kwargs) -> Story:
+        """Create story as JSON file."""
+        story_id = f"STORY-{self._generate_id()}"
+        
+        story = Story(
+            id=story_id,
+            title=title,
+            description=description,
+            epic_id=epic_id,
+            status=kwargs.get("status", "draft"),
+            priority=kwargs.get("priority", "medium"),
+            story_points=kwargs.get("story_points")
+        )
+        
+        # Save to file
+        story_file = self.stories_dir / f"{story_id}.json"
+        with open(story_file, 'w') as f:
+            json.dump(self._story_to_dict(story), f, indent=2, default=str)
+        
+        # Link to epic
+        epic_file = self.epics_dir / f"{epic_id}.json"
+        if epic_file.exists():
+            with open(epic_file, 'r') as f:
+                epic_data = json.load(f)
+            
+            if story_id not in epic_data.get('ticket_ids', []):
+                epic_data.setdefault('ticket_ids', []).append(story_id)
+                
+                with open(epic_file, 'w') as f:
+                    json.dump(epic_data, f, indent=2, default=str)
+        
+        return story
+    
+    def create_task(self, story_id: Optional[str], title: str, description: str = "", **kwargs) -> Ticket:
+        """Create task as JSON file."""
+        task_id = f"TASK-{self._generate_id()}"
+        
+        ticket = Ticket(
+            id=task_id,
+            title=title,
+            description=description,
+            status=kwargs.get("status", "open"),
+            priority=kwargs.get("priority", "medium"),
+            ticket_type=kwargs.get("ticket_type", "feature"),
+            assignee=kwargs.get("assignee"),
+            labels=kwargs.get("labels", []),
+            story_id=story_id,
+            created_at=datetime.now()
+        )
+        
+        # Save to file
+        task_file = self.tasks_dir / f"{task_id}.json"
+        with open(task_file, 'w') as f:
+            json.dump(self._ticket_to_dict(ticket), f, indent=2, default=str)
+        
+        return ticket
+    
+    def update_ticket(self, ticket_id: str, **kwargs) -> Ticket:
+        """Update ticket fields."""
+        ticket = self.fetch_ticket(ticket_id)
+        if not ticket:
+            raise ValueError(f"Ticket {ticket_id} not found")
+        
+        # Update fields
+        for key, value in kwargs.items():
+            if hasattr(ticket, key):
+                setattr(ticket, key, value)
+        
+        ticket.updated_at = datetime.now()
+        
+        # Save updated ticket
+        task_file = self.tasks_dir / f"{ticket_id}.json"
+        with open(task_file, 'w') as f:
+            json.dump(self._ticket_to_dict(ticket), f, indent=2, default=str)
+        
+        return ticket
+    
+    def list_tickets(self, status: Optional[str] = None, epic_id: Optional[str] = None,
+                     **filters) -> List[Ticket]:
+        """List all tickets with filters."""
+        tickets = []
+        
+        for ticket_file in self.tasks_dir.glob("*.json"):
+            try:
+                with open(ticket_file, 'r') as f:
+                    data = json.load(f)
+                
+                ticket = self._dict_to_ticket(data)
+                if not ticket:
+                    continue
+                
+                # Apply filters
+                if status and ticket.status != status:
+                    continue
+                
+                if epic_id and ticket.epic_id != epic_id:
+                    continue
+                
+                tickets.append(ticket)
+            
+            except (json.JSONDecodeError, OSError):
+                continue
+        
+        return tickets
+    
+    def add_comment(self, ticket_id: str, comment: str, author: str = "") -> bool:
+        """Add comment to ticket metadata."""
+        ticket = self.fetch_ticket(ticket_id)
+        if not ticket:
+            return False
+        
+        if not ticket.metadata:
+            ticket.metadata = {}
+        
+        if 'comments' not in ticket.metadata:
+            ticket.metadata['comments'] = []
+        
+        ticket.metadata['comments'].append({
+            'author': author or 'unknown',
+            'text': comment,
+            'timestamp': datetime.now().isoformat()
+        })
+        
+        # Save updated ticket
+        task_file = self.tasks_dir / f"{ticket_id}.json"
+        with open(task_file, 'w') as f:
+            json.dump(self._ticket_to_dict(ticket), f, indent=2, default=str)
+        
+        return True
+    
+    def attach_file(self, ticket_id: str, file_path: str) -> bool:
+        """Attach file reference to ticket."""
+        ticket = self.fetch_ticket(ticket_id)
+        if not ticket:
+            return False
+        
+        if file_path not in ticket.files:
+            ticket.files.append(file_path)
+        
+        # Save updated ticket
+        task_file = self.tasks_dir / f"{ticket_id}.json"
+        with open(task_file, 'w') as f:
+            json.dump(self._ticket_to_dict(ticket), f, indent=2, default=str)
+        
+        return True
+    
+    def _generate_id(self) -> str:
+        """Generate unique ID."""
+        return str(uuid.uuid4())[:8].upper()
+    
+    def _ticket_to_dict(self, ticket: Ticket) -> Dict[str, Any]:
+        """Convert Ticket to dict for JSON serialization."""
+        return {
+            'id': ticket.id,
+            'title': ticket.title,
+            'description': ticket.description,
+            'status': ticket.status,
+            'priority': ticket.priority,
+            'ticket_type': ticket.ticket_type,
+            'assignee': ticket.assignee,
+            'labels': ticket.labels,
+            'epic_id': ticket.epic_id,
+            'story_id': ticket.story_id,
+            'parent_id': ticket.parent_id,
+            'requirements': ticket.requirements,
+            'acceptance_criteria': ticket.acceptance_criteria,
+            'user_stories': ticket.user_stories,
+            'files': ticket.files,
+            'metadata': ticket.metadata,
+            'created_at': ticket.created_at.isoformat() if ticket.created_at else None,
+            'updated_at': ticket.updated_at.isoformat() if ticket.updated_at else None
+        }
+    
+    def _dict_to_ticket(self, data: Dict[str, Any]) -> Optional[Ticket]:
+        """Convert dict to Ticket object."""
+        try:
+            return Ticket(
+                id=data['id'],
+                title=data['title'],
+                description=data.get('description', ''),
+                status=data.get('status', 'open'),
+                priority=data.get('priority', 'medium'),
+                ticket_type=data.get('ticket_type', 'feature'),
+                assignee=data.get('assignee'),
+                labels=data.get('labels', []),
+                epic_id=data.get('epic_id'),
+                story_id=data.get('story_id'),
+                parent_id=data.get('parent_id'),
+                requirements=data.get('requirements', []),
+                acceptance_criteria=data.get('acceptance_criteria', []),
+                user_stories=data.get('user_stories', []),
+                files=data.get('files', []),
+                metadata=data.get('metadata', {}),
+                created_at=datetime.fromisoformat(data['created_at']) if data.get('created_at') else None,
+                updated_at=datetime.fromisoformat(data['updated_at']) if data.get('updated_at') else None
+            )
+        except (KeyError, ValueError):
+            return None
+    
+    def _epic_to_dict(self, epic: Epic) -> Dict[str, Any]:
+        """Convert Epic to dict."""
+        return {
+            'id': epic.id,
+            'title': epic.title,
+            'description': epic.description,
+            'status': epic.status,
+            'priority': epic.priority,
+            'owner': epic.owner,
+            'ticket_ids': epic.ticket_ids,
+            'goals': epic.goals,
+            'created_at': epic.created_at.isoformat() if epic.created_at else None
+        }
+    
+    def _story_to_dict(self, story: Story) -> Dict[str, Any]:
+        """Convert Story to dict."""
+        return {
+            'id': story.id,
+            'title': story.title,
+            'description': story.description,
+            'epic_id': story.epic_id,
+            'status': story.status,
+            'priority': story.priority,
+            'story_points': story.story_points,
+            'acceptance_criteria': story.acceptance_criteria
+        }
+    
+    def get_backend_name(self) -> str:
+        """Return backend name."""
+        return "markdown"

claude_dev_cli/tickets/repo_tickets.py

@@ -0,0 +1,361 @@
+"""repo-tickets backend implementation for claude-dev-cli.
+
+Integrates with repo-tickets CLI to manage tickets in VCS repositories.
+"""
+
+import subprocess
+import json
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+from datetime import datetime
+
+from claude_dev_cli.tickets.backend import TicketBackend, Ticket, Epic, Story
+
+
+class RepoTicketsBackend(TicketBackend):
+    """Backend for repo-tickets integration.
+    
+    Uses subprocess to call 'tickets' CLI commands.
+    Assumes repo-tickets is installed and initialized in current repository.
+    """
+    
+    def __init__(self, repo_path: Optional[Path] = None):
+        """Initialize repo-tickets backend.
+        
+        Args:
+            repo_path: Path to repository (default: current directory)
+        """
+        self.repo_path = repo_path or Path.cwd()
+        self._tickets_dir = self.repo_path / ".tickets"
+    
+    def connect(self) -> bool:
+        """Verify repo-tickets is initialized and accessible."""
+        try:
+            # Check if .tickets directory exists
+            if not self._tickets_dir.exists():
+                return False
+            
+            # Try to list tickets (will fail if not properly initialized)
+            result = subprocess.run(
+                ["tickets", "list", "--format", "json"],
+                cwd=self.repo_path,
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            return result.returncode == 0
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            return False
+    
+    def fetch_ticket(self, ticket_id: str) -> Optional[Ticket]:
+        """Fetch a ticket from repo-tickets."""
+        try:
+            result = subprocess.run(
+                ["tickets", "show", ticket_id, "--format", "json"],
+                cwd=self.repo_path,
+                capture_output=True,
+                text=True,
+                timeout=10
+            )
+            
+            if result.returncode != 0:
+                return None
+            
+            data = json.loads(result.stdout)
+            return self._convert_to_ticket(data)
+        
+        except (subprocess.TimeoutExpired, json.JSONDecodeError, FileNotFoundError):
+            return None
+    
+    def create_epic(self, title: str, description: str = "", **kwargs) -> Epic:
+        """Create an epic in repo-tickets."""
+        cmd = ["tickets", "epic", "create", title]
+        
+        if description:
+            cmd.extend(["--description", description])
+        
+        if "priority" in kwargs:
+            cmd.extend(["--priority", kwargs["priority"]])
+        
+        if "owner" in kwargs:
+            cmd.extend(["--owner", kwargs["owner"]])
+        
+        result = subprocess.run(
+            cmd,
+            cwd=self.repo_path,
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        
+        if result.returncode != 0:
+            raise RuntimeError(f"Failed to create epic: {result.stderr}")
+        
+        # Extract epic ID from output
+        epic_id = self._extract_id_from_output(result.stdout)
+        
+        return Epic(
+            id=epic_id,
+            title=title,
+            description=description,
+            status=kwargs.get("status", "draft"),
+            priority=kwargs.get("priority", "medium"),
+            owner=kwargs.get("owner"),
+            created_at=datetime.now()
+        )
+    
+    def create_story(self, epic_id: str, title: str, description: str = "", **kwargs) -> Story:
+        """Create a user story within an epic."""
+        # repo-tickets uses backlog items for stories
+        cmd = ["tickets", "backlog", "add", title]
+        
+        if description:
+            cmd.extend(["--description", description])
+        
+        if "priority" in kwargs:
+            cmd.extend(["--priority", kwargs["priority"]])
+        
+        if "story_points" in kwargs:
+            cmd.extend(["--effort", str(kwargs["story_points"])])
+        
+        result = subprocess.run(
+            cmd,
+            cwd=self.repo_path,
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        
+        if result.returncode != 0:
+            raise RuntimeError(f"Failed to create story: {result.stderr}")
+        
+        story_id = self._extract_id_from_output(result.stdout)
+        
+        # Link story to epic
+        subprocess.run(
+            ["tickets", "epic", "add-ticket", epic_id, story_id],
+            cwd=self.repo_path,
+            timeout=10
+        )
+        
+        return Story(
+            id=story_id,
+            title=title,
+            description=description,
+            epic_id=epic_id,
+            status=kwargs.get("status", "draft"),
+            priority=kwargs.get("priority", "medium"),
+            story_points=kwargs.get("story_points")
+        )
+    
+    def create_task(self, story_id: Optional[str], title: str, description: str = "", **kwargs) -> Ticket:
+        """Create a task ticket."""
+        cmd = ["tickets", "create", title]
+        
+        if description:
+            cmd.extend(["--description", description])
+        
+        if "priority" in kwargs:
+            cmd.extend(["--priority", kwargs["priority"]])
+        
+        if "assignee" in kwargs:
+            cmd.extend(["--assignee", kwargs["assignee"]])
+        
+        if "labels" in kwargs and kwargs["labels"]:
+            for label in kwargs["labels"]:
+                cmd.extend(["--label", label])
+        
+        result = subprocess.run(
+            cmd,
+            cwd=self.repo_path,
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        
+        if result.returncode != 0:
+            raise RuntimeError(f"Failed to create task: {result.stderr}")
+        
+        task_id = self._extract_id_from_output(result.stdout)
+        
+        # Link to story if provided
+        if story_id:
+            # In repo-tickets, we add the task to the epic that contains the story
+            # This is a simplification - could be enhanced
+            pass
+        
+        return Ticket(
+            id=task_id,
+            title=title,
+            description=description,
+            status=kwargs.get("status", "open"),
+            priority=kwargs.get("priority", "medium"),
+            ticket_type=kwargs.get("ticket_type", "feature"),
+            assignee=kwargs.get("assignee"),
+            labels=kwargs.get("labels", []),
+            story_id=story_id,
+            created_at=datetime.now()
+        )
+    
+    def update_ticket(self, ticket_id: str, **kwargs) -> Ticket:
+        """Update a ticket's fields."""
+        cmd = ["tickets", "update", ticket_id]
+        
+        if "status" in kwargs:
+            cmd.extend(["--status", kwargs["status"]])
+        
+        if "priority" in kwargs:
+            cmd.extend(["--priority", kwargs["priority"]])
+        
+        if "assignee" in kwargs:
+            cmd.extend(["--assignee", kwargs["assignee"]])
+        
+        if "description" in kwargs:
+            cmd.extend(["--description", kwargs["description"]])
+        
+        result = subprocess.run(
+            cmd,
+            cwd=self.repo_path,
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        
+        if result.returncode != 0:
+            raise RuntimeError(f"Failed to update ticket: {result.stderr}")
+        
+        # Fetch updated ticket
+        updated = self.fetch_ticket(ticket_id)
+        if not updated:
+            raise RuntimeError(f"Ticket {ticket_id} not found after update")
+        
+        return updated
+    
+    def list_tickets(self, status: Optional[str] = None, epic_id: Optional[str] = None,
+                     **filters) -> List[Ticket]:
+        """List tickets with filters."""
+        cmd = ["tickets", "list", "--format", "json"]
+        
+        if status:
+            cmd.extend(["--status", status])
+        
+        if epic_id:
+            cmd.extend(["--epic", epic_id])
+        
+        result = subprocess.run(
+            cmd,
+            cwd=self.repo_path,
+            capture_output=True,
+            text=True,
+            timeout=15
+        )
+        
+        if result.returncode != 0:
+            return []
+        
+        try:
+            data = json.loads(result.stdout)
+            tickets = []
+            
+            if isinstance(data, list):
+                for item in data:
+                    ticket = self._convert_to_ticket(item)
+                    if ticket:
+                        tickets.append(ticket)
+            
+            return tickets
+        except json.JSONDecodeError:
+            return []
+    
+    def add_comment(self, ticket_id: str, comment: str, author: str = "") -> bool:
+        """Add a comment to a ticket."""
+        try:
+            cmd = ["tickets", "comment", ticket_id, comment]
+            
+            if author:
+                cmd.extend(["--author", author])
+            
+            result = subprocess.run(
+                cmd,
+                cwd=self.repo_path,
+                capture_output=True,
+                text=True,
+                timeout=10
+            )
+            
+            return result.returncode == 0
+        except subprocess.TimeoutExpired:
+            return False
+    
+    def attach_file(self, ticket_id: str, file_path: str) -> bool:
+        """Attach a file reference to a ticket.
+        
+        repo-tickets doesn't support file attachments directly,
+        so we add a comment with the file path.
+        """
+        comment = f"📎 File attached: {file_path}"
+        return self.add_comment(ticket_id, comment, "claude-dev-cli")
+    
+    def _extract_id_from_output(self, output: str) -> str:
+        """Extract ticket/epic/story ID from command output.
+        
+        Looks for patterns like "TICKET-123" or "EPIC-1"
+        """
+        import re
+        
+        # Common patterns in repo-tickets
+        patterns = [
+            r'(TICKET-\d+)',
+            r'(EPIC-\d+)',
+            r'(BACKLOG-\d+)',
+            r'(STORY-\d+)',
+            r'(TASK-\d+)'
+        ]
+        
+        for pattern in patterns:
+            match = re.search(pattern, output)
+            if match:
+                return match.group(1)
+        
+        raise ValueError(f"Could not extract ID from output: {output}")
+    
+    def _convert_to_ticket(self, data: Dict[str, Any]) -> Optional[Ticket]:
+        """Convert repo-tickets JSON to unified Ticket object."""
+        try:
+            return Ticket(
+                id=data.get("id", ""),
+                title=data.get("title", ""),
+                description=data.get("description", ""),
+                status=data.get("status", "open"),
+                priority=data.get("priority", "medium"),
+                ticket_type=data.get("type", "feature"),
+                assignee=data.get("assignee"),
+                labels=data.get("labels", []),
+                epic_id=data.get("epic_id"),
+                story_id=data.get("story_id"),
+                requirements=data.get("requirements", []),
+                acceptance_criteria=data.get("acceptance_criteria", []),
+                files=data.get("files", []),
+                metadata=data.get("metadata", {}),
+                created_at=self._parse_datetime(data.get("created_at")),
+                updated_at=self._parse_datetime(data.get("updated_at"))
+            )
+        except (KeyError, ValueError):
+            return None
+    
+    def _parse_datetime(self, value: Any) -> Optional[datetime]:
+        """Parse datetime from various formats."""
+        if not value:
+            return None
+        
+        if isinstance(value, datetime):
+            return value
+        
+        try:
+            return datetime.fromisoformat(str(value))
+        except (ValueError, AttributeError):
+            return None
+    
+    def get_backend_name(self) -> str:
+        """Return backend name."""
+        return "repo-tickets"

claude_dev_cli/vcs/__init__.py

@@ -0,0 +1,6 @@
+"""Version control system integration for claude-dev-cli."""
+
+from claude_dev_cli.vcs.manager import VCSManager
+from claude_dev_cli.vcs.git import GitManager
+
+__all__ = ["VCSManager", "GitManager"]