janet-cli 0.2.2__py3-none-any.whl

janet/sync/file_manager.py

@@ -0,0 +1,199 @@
+"""File manager for writing ticket markdown files."""
+
+from pathlib import Path
+from typing import Optional
+
+from janet.utils.paths import sanitize_filename, expand_path
+
+
+class FileManager:
+    """Manages writing ticket markdown files to filesystem."""
+
+    def __init__(self, root_directory: str = "~/janet-tickets"):
+        """
+        Initialize file manager.
+
+        Args:
+            root_directory: Root directory for ticket files
+        """
+        self.root_directory = expand_path(root_directory)
+
+    def write_ticket(
+        self,
+        org_name: str,
+        project_name: str,
+        ticket_key: str,
+        content: str,
+    ) -> Path:
+        """
+        Write ticket markdown to file.
+
+        Args:
+            org_name: Organization name
+            project_name: Project name
+            ticket_key: Ticket key (e.g., "PROJ-1")
+            content: Markdown content
+
+        Returns:
+            Path to created file
+        """
+        # Sanitize names for filesystem
+        safe_org = sanitize_filename(org_name)
+        safe_project = sanitize_filename(project_name)
+        safe_key = sanitize_filename(ticket_key)
+
+        # Create directory structure: root/org/project/
+        project_dir = self.root_directory / safe_org / safe_project
+        project_dir.mkdir(parents=True, exist_ok=True)
+
+        # Create file path: root/org/project/TICKET-KEY.md
+        file_path = project_dir / f"{safe_key}.md"
+
+        # Write markdown content
+        file_path.write_text(content, encoding="utf-8")
+
+        return file_path
+
+    def get_ticket_path(
+        self, org_name: str, project_name: str, ticket_key: str
+    ) -> Path:
+        """
+        Get path for a ticket file (without writing).
+
+        Args:
+            org_name: Organization name
+            project_name: Project name
+            ticket_key: Ticket key
+
+        Returns:
+            Path to ticket file
+        """
+        safe_org = sanitize_filename(org_name)
+        safe_project = sanitize_filename(project_name)
+        safe_key = sanitize_filename(ticket_key)
+
+        return self.root_directory / safe_org / safe_project / f"{safe_key}.md"
+
+    def ticket_exists(self, org_name: str, project_name: str, ticket_key: str) -> bool:
+        """
+        Check if ticket file exists.
+
+        Args:
+            org_name: Organization name
+            project_name: Project name
+            ticket_key: Ticket key
+
+        Returns:
+            True if file exists
+        """
+        file_path = self.get_ticket_path(org_name, project_name, ticket_key)
+        return file_path.exists()
+
+    def list_tickets(self, org_name: Optional[str] = None, project_name: Optional[str] = None) -> list[Path]:
+        """
+        List all ticket markdown files.
+
+        Args:
+            org_name: Optional organization name to filter
+            project_name: Optional project name to filter
+
+        Returns:
+            List of ticket file paths
+        """
+        if org_name and project_name:
+            # List tickets in specific project
+            safe_org = sanitize_filename(org_name)
+            safe_project = sanitize_filename(project_name)
+            search_path = self.root_directory / safe_org / safe_project
+        elif org_name:
+            # List tickets in organization
+            safe_org = sanitize_filename(org_name)
+            search_path = self.root_directory / safe_org
+        else:
+            # List all tickets
+            search_path = self.root_directory
+
+        if not search_path.exists():
+            return []
+
+        # Find all .md files
+        return list(search_path.rglob("*.md"))
+
+    def archive_ticket(
+        self, org_name: str, project_name: str, ticket_key: str
+    ) -> Optional[Path]:
+        """
+        Move ticket to .archived folder.
+
+        Args:
+            org_name: Organization name
+            project_name: Project name
+            ticket_key: Ticket key
+
+        Returns:
+            New path if archived, None if file didn't exist
+        """
+        file_path = self.get_ticket_path(org_name, project_name, ticket_key)
+
+        if not file_path.exists():
+            return None
+
+        # Create .archived directory
+        archived_dir = file_path.parent / ".archived"
+        archived_dir.mkdir(exist_ok=True)
+
+        # Move file
+        new_path = archived_dir / file_path.name
+        file_path.rename(new_path)
+
+        return new_path
+
+    def delete_ticket(self, org_name: str, project_name: str, ticket_key: str) -> bool:
+        """
+        Delete ticket file.
+
+        Args:
+            org_name: Organization name
+            project_name: Project name
+            ticket_key: Ticket key
+
+        Returns:
+            True if deleted, False if didn't exist
+        """
+        file_path = self.get_ticket_path(org_name, project_name, ticket_key)
+
+        if not file_path.exists():
+            return False
+
+        file_path.unlink()
+        return True
+
+    def get_project_directory(self, org_name: str, project_name: str) -> Path:
+        """
+        Get project directory path.
+
+        Args:
+            org_name: Organization name
+            project_name: Project name
+
+        Returns:
+            Path to project directory
+        """
+        safe_org = sanitize_filename(org_name)
+        safe_project = sanitize_filename(project_name)
+        return self.root_directory / safe_org / safe_project
+
+    def ensure_project_directory(self, org_name: str, project_name: str) -> Path:
+        """
+        Ensure project directory exists.
+
+        Args:
+            org_name: Organization name
+            project_name: Project name
+
+        Returns:
+            Path to project directory
+        """
+        project_dir = self.get_project_directory(org_name, project_name)
+        project_dir.mkdir(parents=True, exist_ok=True)
+        return project_dir

janet/sync/readme_generator.py

@@ -0,0 +1,174 @@
+"""Generate README for synced ticket directory."""
+
+from datetime import datetime
+from pathlib import Path
+from typing import List, Dict
+
+
+class ReadmeGenerator:
+    """Generate README.md for synced ticket directory."""
+
+    def generate(
+        self,
+        org_name: str,
+        projects: List[Dict],
+        total_tickets: int,
+        sync_time: datetime,
+    ) -> str:
+        """
+        Generate README content for ticket directory.
+
+        Args:
+            org_name: Organization name
+            projects: List of synced projects
+            total_tickets: Total number of tickets synced
+            sync_time: Timestamp of sync
+
+        Returns:
+            README markdown content
+        """
+        sections = []
+
+        # Header
+        sections.append(f"# Janet AI Tickets - {org_name}\n")
+        sections.append(
+            "This directory contains your Janet AI tickets synced as markdown files "
+            "for use with AI coding agents like Claude Code, Cursor, and GitHub Copilot.\n"
+        )
+
+        # What is this?
+        sections.append("## What is this?\n")
+        sections.append(
+            "These markdown files are a local mirror of your tickets from "
+            "[Janet AI](https://tryjanet.ai), an AI-native project management platform. "
+            "Each ticket has been exported as a markdown file containing:\n"
+        )
+        sections.append("- **Metadata** - Status, priority, assignees, dates, labels")
+        sections.append("- **Description** - Full ticket description")
+        sections.append("- **Comments** - All comments with timestamps")
+        sections.append("- **Attachments** - Attachment metadata and descriptions")
+        sections.append("- **Child Tasks** - Sub-tasks if applicable\n")
+
+        # Why is this here?
+        sections.append("## Why is this here?\n")
+        sections.append(
+            "AI coding assistants work best when they have full context about your project. "
+            "By having your tickets in your workspace, AI agents can:\n"
+        )
+        sections.append("- Reference specific tickets while writing code")
+        sections.append("- Understand requirements and acceptance criteria")
+        sections.append("- Answer questions about project priorities and status")
+        sections.append("- Suggest implementations based on ticket descriptions")
+        sections.append("- Link code changes to relevant tickets\n")
+
+        # Directory structure
+        sections.append("## Directory Structure\n")
+        sections.append("```")
+        sections.append(f"{org_name}/")
+        for project in projects[:10]:  # Show first 10 projects
+            key = project.get("project_identifier", "")
+            name = project.get("project_name", "")
+            count = project.get("ticket_count", 0)
+            sections.append(f"├── {name}/")
+            sections.append(f"│   ├── {key}-1.md")
+            sections.append(f"│   ├── {key}-2.md")
+            sections.append(f"│   └── ... ({count} tickets)")
+
+        if len(projects) > 10:
+            sections.append(f"└── ... ({len(projects) - 10} more projects)")
+        sections.append("```\n")
+
+        # Sync info
+        sections.append("## Sync Information\n")
+        sections.append(f"- **Organization:** {org_name}")
+        sections.append(f"- **Projects Synced:** {len(projects)}")
+        sections.append(f"- **Total Tickets:** {total_tickets}")
+        sections.append(
+            f"- **Last Synced:** {sync_time.strftime('%B %d, %Y at %I:%M %p')}\n"
+        )
+
+        # Projects summary
+        if projects:
+            sections.append("### Projects\n")
+            for project in projects:
+                key = project.get("project_identifier", "")
+                name = project.get("project_name", "")
+                count = project.get("ticket_count", 0)
+                sections.append(f"- **{key}** - {name} ({count} tickets)")
+            sections.append("")
+
+        # How to use
+        sections.append("## How to Use with AI Coding Agents\n")
+        sections.append(
+            "When working with AI assistants (Claude Code, Cursor, etc.), "
+            "you can reference these tickets:\n"
+        )
+        sections.append('```bash')
+        sections.append('# Example prompts:')
+        sections.append('"Look at ticket CS-42 and implement the authentication flow"')
+        sections.append('"What are the high priority tickets in the Software project?"')
+        sections.append('"Which tickets are assigned to me?"')
+        sections.append('"Implement the feature described in HL-15"')
+        sections.append('```\n')
+
+        # Keeping in sync
+        sections.append("## Keeping Tickets in Sync\n")
+        sections.append("To update tickets with latest changes from Janet AI:\n")
+        sections.append("```bash")
+        sections.append("janet sync")
+        sections.append("```\n")
+        sections.append(
+            "This will update all changed tickets and add new ones. "
+            "Run this regularly to keep your local tickets up to date.\n"
+        )
+
+        # About Janet AI
+        sections.append("## About Janet AI\n")
+        sections.append(
+            "[Janet AI](https://tryjanet.ai) is an AI-native project management platform "
+            "designed for modern software teams. It provides:\n"
+        )
+        sections.append("- AI-powered ticket creation and updates")
+        sections.append("- Intelligent ticket prioritization")
+        sections.append("- Automated ticket summaries and evaluations")
+        sections.append("- Real-time collaboration")
+        sections.append("- GitHub integration")
+        sections.append("- Discord/Slack integration")
+        sections.append("- Meeting and document context linking\n")
+
+        # Footer
+        sections.append("---\n")
+        sections.append(
+            f"*Generated by [Janet CLI](https://github.com/janet-ai/janet-cli) v0.2.0 "
+            f"on {sync_time.strftime('%B %d, %Y at %I:%M %p')}*\n"
+        )
+
+        return "\n".join(sections)
+
+    def write_readme(
+        self,
+        sync_dir: Path,
+        org_name: str,
+        projects: List[Dict],
+        total_tickets: int,
+    ) -> Path:
+        """
+        Write README.md to sync directory.
+
+        Args:
+            sync_dir: Root sync directory
+            org_name: Organization name
+            projects: List of synced projects
+            total_tickets: Total number of tickets synced
+
+        Returns:
+            Path to created README
+        """
+        sync_time = datetime.utcnow()
+        readme_content = self.generate(org_name, projects, total_tickets, sync_time)
+
+        # Write to root of sync directory
+        readme_path = sync_dir / "README.md"
+        readme_path.write_text(readme_content, encoding="utf-8")
+
+        return readme_path

janet/sync/sync_engine.py

@@ -0,0 +1,271 @@
+"""Main sync orchestration engine."""
+
+import asyncio
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import List, Dict, Optional
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn
+
+from janet.api.organizations import OrganizationAPI
+from janet.api.projects import ProjectAPI
+from janet.api.tickets import TicketAPI
+from janet.config.manager import ConfigManager
+from janet.markdown.generator import MarkdownGenerator
+from janet.sync.file_manager import FileManager
+from janet.utils.console import console, print_success, print_error, print_info
+from janet.utils.errors import SyncError
+
+
+class SyncEngine:
+    """Main sync orchestration engine."""
+
+    def __init__(self, config_manager: ConfigManager):
+        """
+        Initialize sync engine.
+
+        Args:
+            config_manager: Configuration manager instance
+        """
+        self.config_manager = config_manager
+        self.config = config_manager.get()
+
+        # Initialize APIs
+        self.org_api = OrganizationAPI(config_manager)
+        self.project_api = ProjectAPI(config_manager)
+        self.ticket_api = TicketAPI(config_manager)
+
+        # Initialize sync components
+        self.markdown_generator = MarkdownGenerator()
+        self.file_manager = FileManager(self.config.sync.root_directory)
+
+    def sync_all_projects(self) -> Dict:
+        """
+        Sync all projects in the current organization.
+
+        Returns:
+            Summary dictionary with sync statistics
+        """
+        if not self.config.selected_organization:
+            raise SyncError("No organization selected")
+
+        org_name = self.config.selected_organization.name
+
+        # Fetch all projects
+        print_info(f"Fetching projects for {org_name}...")
+        projects = self.project_api.list_projects()
+
+        if not projects:
+            print_info("No projects found")
+            return {"projects_synced": 0, "tickets_synced": 0}
+
+        console.print(f"\nFound {len(projects)} project(s)")
+
+        # Sync projects in parallel
+        total_tickets = 0
+        projects_with_tickets = [p for p in projects if p.get("ticket_count", 0) > 0]
+
+        # Show projects with no tickets
+        for project in projects:
+            if project.get("ticket_count", 0) == 0:
+                console.print(f"  [dim]↳ {project.get('project_identifier', '')} - No tickets[/dim]")
+
+        # Use ThreadPoolExecutor to sync projects in parallel
+        max_workers = min(5, len(projects_with_tickets))  # Max 5 concurrent projects
+
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            # Submit all sync tasks
+            future_to_project = {
+                executor.submit(
+                    self.sync_project,
+                    project["id"],
+                    project.get("project_identifier", ""),
+                    project.get("project_name", ""),
+                ): project
+                for project in projects_with_tickets
+            }
+
+            # Wait for completion
+            for future in as_completed(future_to_project):
+                try:
+                    synced = future.result()
+                    total_tickets += synced
+                except Exception as e:
+                    project = future_to_project[future]
+                    project_key = project.get("project_identifier", "unknown")
+                    console.print(f"[red]✗ Failed to sync {project_key}: {e}[/red]")
+
+        return {
+            "projects_synced": len(projects),
+            "tickets_synced": total_tickets,
+        }
+
+    def sync_project(
+        self, project_id: str, project_key: str, project_name: str
+    ) -> int:
+        """
+        Sync a single project.
+
+        Args:
+            project_id: Project ID
+            project_key: Project key (e.g., "PROJ")
+            project_name: Project name
+
+        Returns:
+            Number of tickets synced
+        """
+        org_name = self.config.selected_organization.name
+
+        # Fetch all tickets with pagination
+        tickets = []
+        offset = 0
+        limit = 200  # API limit per request
+
+        while True:
+            response = self.ticket_api.list_tickets(project_id, limit=limit, offset=offset)
+
+            # Extract tickets from current page
+            page_tickets = []
+            if "items" in response:
+                page_tickets = response["items"]
+            elif "kanban_data" in response:
+                kanban_data = response["kanban_data"]
+                for column in kanban_data.get("columns", []):
+                    column_tickets = column.get("tickets", [])
+                    page_tickets.extend(column_tickets)
+            elif "tickets" in response:
+                page_tickets = response["tickets"]
+
+            if not page_tickets:
+                break  # No more tickets
+
+            tickets.extend(page_tickets)
+
+            # Check if there are more tickets
+            if response.get("has_more"):
+                offset = response.get("next_offset", offset + limit)
+            else:
+                break  # No more pages
+
+        if not tickets:
+            console.print(f"  [dim]↳ {project_key} - No tickets found[/dim]")
+            return 0
+
+        console.print(f"\n[bold]{project_key}[/bold] - Syncing {len(tickets)} ticket(s)...")
+
+        # Fetch organization members for name resolution (once per project)
+        org_members = self._fetch_org_members()
+
+        # Batch fetch all full ticket details at once
+        ticket_ids = [t.get("id") for t in tickets if t.get("id")]
+
+        console.print(f"  Fetching full details for {len(ticket_ids)} tickets...")
+        full_tickets_list = self.ticket_api.batch_fetch(ticket_ids)
+
+        # Create lookup map by ticket ID
+        full_tickets_map = {t.get("id"): t for t in full_tickets_list}
+
+        # Sync each ticket with progress bar
+        synced_count = 0
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TaskProgressColumn(),
+            console=console,
+        ) as progress:
+            task = progress.add_task(
+                f"Syncing {project_key}...",
+                total=len(tickets),
+            )
+
+            for ticket in tickets:
+                try:
+                    # Merge list ticket with full details
+                    ticket_id = ticket.get("id")
+                    full_ticket = full_tickets_map.get(ticket_id, {})
+                    merged_ticket = {**full_ticket, **ticket}
+
+                    self._sync_single_ticket_fast(
+                        merged_ticket, org_name, project_name, org_members
+                    )
+                    synced_count += 1
+                except Exception as e:
+                    ticket_key = ticket.get("ticket_key") or ticket.get("ticket_identifier") or ticket.get("id", "unknown")
+                    console.print(f"  [red]✗ Failed to sync {ticket_key}: {e}[/red]")
+
+                progress.advance(task)
+
+        print_success(f"Synced {synced_count}/{len(tickets)} tickets for {project_key}")
+        return synced_count
+
+    def _sync_single_ticket_fast(
+        self,
+        ticket: Dict,
+        org_name: str,
+        project_name: str,
+        org_members: Optional[List[Dict]] = None,
+    ) -> None:
+        """
+        Sync a single ticket (optimized - no individual API calls).
+
+        Args:
+            ticket: Merged ticket dictionary (already has full details)
+            org_name: Organization name
+            project_name: Project name
+            org_members: Organization members for name resolution
+        """
+        ticket_id = ticket.get("id")
+
+        # Get ticket_key - try multiple fields
+        ticket_key = ticket.get("ticket_key")
+        if not ticket_key:
+            # Fallback: construct from project_identifier and ticket_identifier
+            project_identifier = ticket.get("project_identifier") or project_name
+            ticket_identifier = ticket.get("ticket_identifier")
+            if project_identifier and ticket_identifier:
+                ticket_key = f"{project_identifier}-{ticket_identifier}"
+            else:
+                ticket_key = ticket.get("ticket_identifier")
+
+        # Validate required fields
+        if not ticket_id:
+            raise Exception("Ticket missing 'id' field")
+        if not ticket_key:
+            raise Exception(f"Ticket {ticket_id} missing 'ticket_key' field")
+
+        # Ensure ticket has ticket_key for markdown generation
+        if "ticket_key" not in ticket:
+            ticket["ticket_key"] = ticket_key
+
+        # Skip attachment fetching to reduce API calls
+        # Attachments info is usually in the ticket data already
+        attachments = None
+
+        # Generate markdown
+        markdown = self.markdown_generator.generate(
+            ticket, org_members, attachments
+        )
+
+        # Write to file
+        self.file_manager.write_ticket(
+            org_name=org_name,
+            project_name=project_name,
+            ticket_key=ticket_key,
+            content=markdown,
+        )
+
+    def _fetch_org_members(self) -> Optional[List[Dict]]:
+        """
+        Fetch organization members for name resolution.
+
+        Returns:
+            List of organization members or None if fetch fails
+        """
+        try:
+            org_id = self.config.selected_organization.id
+            response = self.org_api.get(
+                f"/api/v1/organizations/{org_id}/members", include_org=False
+            )
+            return response.get("members", [])
+        except Exception as e:
+            console.print(f"[yellow]Warning: Could not fetch organization members: {e}[/yellow]")
+            return None

janet/utils/console.py

@@ -0,0 +1,39 @@
+"""Rich console utilities for beautiful terminal output."""
+
+from rich.console import Console
+from rich.theme import Theme
+
+# Custom theme for Janet CLI
+janet_theme = Theme(
+    {
+        "info": "cyan",
+        "success": "bold green",
+        "warning": "yellow",
+        "error": "bold red",
+        "highlight": "bold magenta",
+        "dim": "dim",
+    }
+)
+
+# Global console instance
+console = Console(theme=janet_theme)
+
+
+def print_success(message: str) -> None:
+    """Print success message."""
+    console.print(f"✓ {message}", style="success")
+
+
+def print_error(message: str) -> None:
+    """Print error message."""
+    console.print(f"✗ {message}", style="error")
+
+
+def print_warning(message: str) -> None:
+    """Print warning message."""
+    console.print(f"⚠ {message}", style="warning")
+
+
+def print_info(message: str) -> None:
+    """Print info message."""
+    console.print(f"ℹ {message}", style="info")