janet-cli 0.2.7__py3-none-any.whl → 0.2.33__py3-none-any.whl

janet/sync/sse_watcher.py

@@ -0,0 +1,264 @@
+"""Server-Sent Events (SSE) watcher for real-time ticket updates."""
+
+import json
+import signal
+import sys
+from typing import Dict, List, Optional, Callable
+
+import httpx
+
+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
+
+
+class SSEWatcher:
+    """Watch for ticket changes via Server-Sent Events."""
+
+    def __init__(
+        self,
+        config_manager: ConfigManager,
+        projects: List[Dict],
+        org_name: str,
+        sync_dir: str,
+        org_members: Optional[List[Dict]] = None,
+        on_update: Optional[Callable[[str, str], None]] = None,
+        project_statuses: Optional[Dict[str, List[str]]] = None,
+    ):
+        """
+        Initialize SSE watcher.
+
+        Args:
+            config_manager: Configuration manager instance
+            projects: List of project dictionaries to watch
+            org_name: Organization name
+            sync_dir: Sync directory path
+            org_members: Organization members for name resolution
+            on_update: Optional callback when ticket is updated (ticket_key, action)
+            project_statuses: Dict mapping project_identifier to list of valid statuses
+        """
+        self.config_manager = config_manager
+        self.config = config_manager.get()
+        self.projects = {p["id"]: p for p in projects}
+        self.projects_list = projects  # Keep list for README generation
+        self.org_name = org_name
+        self.sync_dir = sync_dir
+        self.file_manager = FileManager(sync_dir)
+        self.markdown_generator = MarkdownGenerator()
+        self.org_members = org_members
+        self.on_update = on_update
+        self.project_statuses = project_statuses or {}
+        self._running = False
+
+        # Build SSE URL
+        self.sse_url = f"{self.config.api.base_url}/api/v1/cli/events"
+
+    def _get_headers(self) -> Dict[str, str]:
+        """Get headers for SSE connection."""
+        from janet.auth.token_manager import TokenManager
+
+        token_manager = TokenManager(self.config_manager)
+        access_token = token_manager.get_access_token()
+
+        return {
+            "Authorization": f"Bearer {access_token}",
+            "X-Organization-ID": self.config.selected_organization.id,
+            "Accept": "text/event-stream",
+        }
+
+    def _handle_event(self, event: Dict) -> None:
+        """
+        Handle incoming SSE event.
+
+        Args:
+            event: Event dictionary
+        """
+        event_type = event.get("type")
+        project_id = event.get("projectId")
+        ticket_id = event.get("ticketId")
+        ticket_data = event.get("ticketData", {})
+
+        # Skip if not for a project we're watching
+        if project_id and project_id not in self.projects:
+            return
+
+        # Get project info
+        project = self.projects.get(project_id, {})
+        project_name = project.get("project_name", "Unknown")
+
+        if event_type == "connected":
+            project_count = len(self.projects)
+            project_names = ", ".join([p.get("project_name", p.get("project_identifier", "")) for p in self.projects.values()][:3])
+            if project_count > 3:
+                project_names += f" +{project_count - 3} more"
+            console.print(f"[green]Watching {project_count} project(s) in {self.org_name}[/green] ({project_names})")
+            return
+
+        if event_type in ("ticket-change", "ticket-created"):
+            ticket_key = ticket_data.get("ticket_key", "")
+            if not ticket_key:
+                return
+
+            # Generate markdown and write to file
+            try:
+                # Extract attachments from event data if present
+                attachments = None
+                if ticket_data.get("attachments"):
+                    attachments = {
+                        "direct_attachments": ticket_data.get("attachments", []),
+                        "indirect_attachments": []
+                    }
+                markdown = self.markdown_generator.generate(ticket_data, self.org_members, attachments)
+                self.file_manager.write_ticket(
+                    org_name=self.org_name,
+                    project_name=project_name,
+                    ticket_key=ticket_key,
+                    content=markdown,
+                )
+
+                action = "Created" if event_type == "ticket-created" else "Updated"
+                updated_fields = ticket_data.get("updated_fields", [])
+                # Transform field names for display (backend uses "labels", CLI uses "tags")
+                display_fields = ["tags" if f == "labels" else f for f in updated_fields]
+                if display_fields and event_type == "ticket-change":
+                    console.print(f"[green]   {ticket_key}[/green] ({', '.join(display_fields)})")
+                else:
+                    console.print(f"[green]   {ticket_key}[/green] ({action.lower()})")
+
+                if self.on_update:
+                    self.on_update(ticket_key, action.lower())
+
+            except Exception as e:
+                console.print(f"[red]   Failed to update {ticket_key}: {e}[/red]")
+
+        elif event_type == "ticket-deleted":
+            ticket_key = event.get("ticketKey", "")
+            if not ticket_key:
+                return
+
+            # Delete or archive local file
+            try:
+                deleted = self.file_manager.delete_ticket(
+                    org_name=self.org_name,
+                    project_name=project_name,
+                    ticket_key=ticket_key,
+                )
+                if deleted:
+                    console.print(f"[yellow]   {ticket_key}[/yellow] (deleted)")
+                    if self.on_update:
+                        self.on_update(ticket_key, "deleted")
+
+            except Exception as e:
+                console.print(f"[red]   Failed to delete {ticket_key}: {e}[/red]")
+
+        elif event_type == "column-change":
+            # Update project statuses and regenerate README
+            project_identifier = event.get("projectIdentifier", "")
+            columns = event.get("columns", [])
+
+            if project_identifier and columns:
+                # Extract status values in order
+                statuses = [col.get("status_value", "") for col in sorted(columns, key=lambda x: x.get("column_order", 0))]
+                self.project_statuses[project_identifier] = statuses
+
+                # Regenerate README with updated statuses
+                try:
+                    from janet.sync.readme_generator import ReadmeGenerator
+                    from pathlib import Path
+
+                    # Calculate total tickets from projects
+                    total_tickets = sum(p.get("ticket_count", 0) for p in self.projects_list)
+
+                    readme_gen = ReadmeGenerator()
+                    readme_gen.write_readme(
+                        sync_dir=Path(self.sync_dir),
+                        org_name=self.org_name,
+                        projects=self.projects_list,
+                        total_tickets=total_tickets,
+                        project_statuses=self.project_statuses,
+                    )
+                    console.print(f"[cyan]   README updated[/cyan] ({project_identifier} statuses changed)")
+                except Exception as e:
+                    console.print(f"[red]   Failed to update README: {e}[/red]")
+
+    def watch(self) -> None:
+        """
+        Start watching for events.
+
+        This method blocks until interrupted (Ctrl+C).
+        """
+        self._running = True
+
+        # Setup signal handler for graceful shutdown
+        def signal_handler(sig, frame):
+            console.print("\n[yellow]Stopping watch...[/yellow]")
+            self._running = False
+            sys.exit(0)
+
+        signal.signal(signal.SIGINT, signal_handler)
+        signal.signal(signal.SIGTERM, signal_handler)
+
+        console.print("[cyan]Watching for changes... (Ctrl+C to stop)[/cyan]")
+        console.print("[dim]Ticket updates from the platform will sync to your local markdown files in real-time.[/dim]\n")
+
+        while self._running:
+            try:
+                self._connect_and_stream()
+            except httpx.ConnectError as e:
+                console.print(f"[red]Connection error: {e}[/red]")
+                console.print("[yellow]Reconnecting in 5 seconds...[/yellow]")
+                import time
+                time.sleep(5)
+            except Exception as e:
+                error_str = str(e)
+                # Check if this is an auth error that requires re-login
+                if "401" in error_str or "Unauthorized" in error_str:
+                    console.print("[red]Authentication failed. Attempting to refresh token...[/red]")
+                    try:
+                        from janet.auth.token_manager import TokenManager
+                        token_manager = TokenManager(self.config_manager)
+                        token_manager.refresh_access_token()
+                        console.print("[green]Token refreshed successfully.[/green]")
+                    except Exception as refresh_error:
+                        console.print(f"[red]Token refresh failed: {refresh_error}[/red]")
+                        console.print("[yellow]Please run 'janet login' to re-authenticate.[/yellow]")
+                        self._running = False
+                        break
+                # Expected disconnection from load balancer timeout - reconnect silently
+                elif "incomplete chunked read" in error_str or "closed" in error_str.lower():
+                    console.print("[dim]Connection closed, reconnecting...[/dim]")
+                else:
+                    console.print(f"[yellow]Connection interrupted: {e}[/yellow]")
+                import time
+                time.sleep(2)  # Shorter delay for expected disconnections
+
+    def _connect_and_stream(self) -> None:
+        """Connect to SSE endpoint and process stream."""
+        headers = self._get_headers()
+
+        with httpx.Client(timeout=None) as client:
+            with client.stream("GET", self.sse_url, headers=headers) as response:
+                if response.status_code == 401:
+                    raise Exception("401 Unauthorized - token may have expired")
+                if response.status_code != 200:
+                    raise Exception(f"SSE connection failed: {response.status_code}")
+
+                for line in response.iter_lines():
+                    if not self._running:
+                        break
+
+                    if not line:
+                        continue
+
+                    # SSE format: "data: {...json...}"
+                    if line.startswith("data: "):
+                        try:
+                            event_data = json.loads(line[6:])
+                            self._handle_event(event_data)
+                        except json.JSONDecodeError:
+                            pass  # Ignore malformed events
+
+                    # Ignore comments (keepalive pings)
+                    elif line.startswith(":"):
+                        pass

janet/sync/sync_engine.py

@@ -127,15 +127,23 @@ class SyncEngine:
         # Fetch organization members for name resolution (once per project)
         org_members = self._fetch_org_members()
 
-        # Batch fetch all full ticket details at once
+        # Batch fetch all full ticket details using unlimited CLI endpoint
         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)
+        full_tickets_list = self.ticket_api.cli_batch_fetch(ticket_ids)
 
         # Create lookup map by ticket ID
         full_tickets_map = {t.get("id"): t for t in full_tickets_list}
 
+        # Batch fetch all attachments in one call
+        console.print(f"  Fetching attachments...")
+        attachments_map = {}
+        try:
+            attachments_map = self.ticket_api.batch_fetch_attachments(ticket_ids)
+        except Exception as e:
+            console.print(f"  [yellow]Warning: Could not batch fetch attachments: {e}[/yellow]")
+
         # Sync each ticket with progress bar
         synced_count = 0
         with Progress(
@@ -157,8 +165,11 @@ class SyncEngine:
                     full_ticket = full_tickets_map.get(ticket_id, {})
                     merged_ticket = {**full_ticket, **ticket}
 
+                    # Get pre-fetched attachments for this ticket
+                    ticket_attachments = attachments_map.get(ticket_id)
+
                     self._sync_single_ticket_fast(
-                        merged_ticket, org_name, project_name, org_members
+                        merged_ticket, org_name, project_name, org_members, ticket_attachments
                     )
                     synced_count += 1
                 except Exception as e:
@@ -176,6 +187,7 @@ class SyncEngine:
         org_name: str,
         project_name: str,
         org_members: Optional[List[Dict]] = None,
+        attachments: Optional[Dict] = None,
     ) -> None:
         """
         Sync a single ticket (optimized - no individual API calls).
@@ -185,6 +197,7 @@ class SyncEngine:
             org_name: Organization name
             project_name: Project name
             org_members: Organization members for name resolution
+            attachments: Pre-fetched attachments dict (from batch fetch)
         """
         ticket_id = ticket.get("id")
 
@@ -209,10 +222,6 @@ class SyncEngine:
         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

janet_cli-0.2.33.dist-info/METADATA

@@ -0,0 +1,356 @@
+Metadata-Version: 2.4
+Name: janet-cli
+Version: 0.2.33
+Summary: CLI tool to sync Janet AI tickets to local markdown files
+Author-email: Janet AI <support@janet-ai.com>
+License: MIT
+Project-URL: Homepage, https://github.com/janet-ai/janet-cli
+Project-URL: Repository, https://github.com/janet-ai/janet-cli
+Project-URL: Issues, https://github.com/janet-ai/janet-cli/issues
+Keywords: cli,janet,tickets,markdown,sync
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer>=0.12.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: platformdirs>=4.0.0
+Requires-Dist: keyring>=25.0.0
+Requires-Dist: python-dateutil>=2.8.0
+Requires-Dist: pycrdt>=0.9.0
+Requires-Dist: InquirerPy>=0.3.4
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Requires-Dist: httpx-mock>=0.15.0; extra == "dev"
+Requires-Dist: black>=24.0.0; extra == "dev"
+Requires-Dist: mypy>=1.8.0; extra == "dev"
+Requires-Dist: ruff>=0.2.0; extra == "dev"
+Dynamic: license-file
+
+# Janet AI CLI
+
+> Sync your Janet AI tickets to local markdown files and enable AI coding agents to create and manage tickets.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+
+## What is Janet AI?
+
+[Janet AI](https://tryjanet.ai) is an AI-native project management platform for modern software teams. The Janet CLI allows developers to:
+
+- **Sync tickets** to local markdown files with real-time updates as changes are made on the platform
+- **Create tickets** directly from the command line or via AI agents
+- **Update tickets** without leaving your terminal
+
+## Why Use the CLI?
+
+AI coding assistants work better when they understand your project's tickets, requirements, and priorities. With Janet CLI, AI agents like Claude Code and Cursor can:
+
+- Reference specific tickets while writing code
+- Create new tickets when discovering bugs or needed features
+- Update ticket status as work progresses
+- Understand requirements and acceptance criteria
+- Answer questions about project priorities
+
+## Installation
+
+```bash
+pip install janet-cli
+```
+
+## Quick Start
+
+```bash
+# 1. Authenticate
+janet login
+
+# 2. Sync tickets and watch for real-time updates
+janet sync
+```
+
+## Using with AI Coding Agents
+
+### Claude Code
+
+Add Janet CLI to your Claude Code workflow:
+
+```bash
+# In your project directory
+janet sync
+```
+
+Claude Code can now reference, create, and update tickets. Example natural language prompts:
+
+**Referencing tickets:**
+- "Look at ticket BACK-42 and implement the authentication flow"
+- "What are the high priority tickets in the Backend project?"
+- "Show me all tickets assigned to me"
+
+**Creating tickets:**
+- "Create a high-priority bug ticket in BACK for the null pointer exception we just found in auth.py"
+- "Make a new feature ticket in FRONT for dark mode support with the description from design-doc.md"
+- "Create a ticket to add unit tests for the payment service, assign it to dev@example.com"
+
+**Updating tickets:**
+- "Update BACK-42 status to In Progress since I'm working on it now"
+- "Mark FRONT-15 as Done and add a comment that it's deployed to staging"
+- "Change the priority of BACK-38 to Critical"
+
+Claude Code can run these commands directly:
+
+```bash
+janet context --json                    # Discover available projects
+janet ticket create "Bug: null pointer in auth" -p BACK --json
+janet ticket update BACK-42 --status "In Progress"
+```
+
+### Cursor
+
+1. Sync tickets to your workspace:
+```bash
+janet sync
+```
+
+2. Add to `.cursorrules` or system prompt:
+```
+Project tickets are in ./janet-tickets/ as markdown files.
+Use `janet ticket create` to create new tickets.
+Use `janet ticket update` to update ticket status.
+Use `janet context --json` to see available projects.
+```
+
+3. Use natural language prompts:
+
+**Referencing tickets:**
+- "Read ticket BACK-42 and help me implement the OAuth flow"
+- "What bugs are currently open in the Frontend project?"
+
+**Creating tickets:**
+- "Create a ticket in BACK for refactoring the database layer, high priority"
+- "Make a bug ticket for the memory leak we found, include the stack trace"
+
+**Updating tickets:**
+- "Update ticket FRONT-28 to In Review status"
+- "Mark BACK-51 as complete"
+
+### GitHub Copilot / Other Agents
+
+Any AI agent with terminal access can use the CLI:
+
+```bash
+# Get context about the workspace
+janet context --json
+
+# Create tickets programmatically
+janet ticket create "Title" -p PROJECT --json
+
+# Update tickets
+janet ticket update PROJ-123 --status "Done" --json
+```
+
+## Real-Time Sync
+
+After syncing, the CLI stays connected to receive real-time updates:
+
+```bash
+janet sync
+```
+
+Output:
+```
+✓ Sync complete!
+  Projects: 2
+  Tickets: 42
+
+Tickets saved to: ./janet-tickets
+
+Watching for changes... (Ctrl+C to stop)
+
+Watching 2 project(s) in My Org (Backend, Frontend)
+
+   BACK-123 (status)
+   BACK-124 (created)
+   FRONT-45 (title, description)
+```
+
+Real-time updates sync changes whenever tickets are created, updated, or deleted—whether from the web UI, API, or other CLI sessions. Press Ctrl+C to stop watching.
+
+## File Organization
+
+Tickets are organized in a clear hierarchy:
+
+```
+janet-tickets/
+├── README.md                    # Context for AI agents
+└── My Organization/
+    ├── Backend/
+    │   ├── BACK-1.md
+    │   ├── BACK-2.md
+    │   └── BACK-42.md
+    └── Frontend/
+        ├── FRONT-1.md
+        └── FRONT-15.md
+```
+
+## Markdown Format
+
+Each ticket is exported with complete information:
+
+```markdown
+# PROJ-42: Add user authentication
+
+## Metadata
+- **Status:** In Progress
+- **Priority:** High
+- **Type:** Feature
+- **Assignees:** John Doe, Jane Smith
+- **Created:** Jan 07, 2026 10:30 AM
+- **Updated:** Jan 07, 2026 02:45 PM
+- **Labels:** backend, security
+
+## Description
+
+We need to implement OAuth authentication...
+
+### Requirements
+- Support multiple auth providers
+- Handle token refresh
+- Secure token storage
+
+## Comments (2)
+
+### John Doe - Jan 07, 2026 11:00 AM
+
+Started working on the OAuth flow.
+
+### Jane Smith - Jan 07, 2026 01:30 PM
+
+Looks good! Add tests when done.
+```
+
+## Commands
+
+### Authentication
+
+```bash
+janet login                     # Authenticate with Janet AI
+janet logout                    # Clear credentials
+janet auth status               # Show authentication status
+```
+
+### Syncing Tickets
+
+```bash
+janet sync                      # Sync and watch for real-time updates
+janet sync --all                # Sync all projects and watch
+janet sync --dir ./tickets      # Specify custom directory
+janet sync --no-watch           # Sync once and exit (no real-time updates)
+```
+
+### Creating Tickets
+
+```bash
+janet ticket create "Title" --project PROJ           # Basic creation
+janet ticket create "Title" -p PROJ --priority High  # With priority
+janet ticket create "Title" -p PROJ --status "To Do" # With status
+janet ticket create "Title" -p PROJ --type Bug       # With type
+janet ticket create "Title" -p PROJ --assignee dev@example.com
+janet ticket create "Title" -p PROJ --tag backend --tag urgent
+janet ticket create "Title" -p PROJ --json           # JSON output for AI agents
+cat desc.md | janet ticket create "Title" -p PROJ    # Pipe description
+
+# Full ticket with all fields
+janet ticket create "Implement OAuth2 authentication" \
+  --project BACK \
+  --description "Add Google and GitHub OAuth providers with token refresh" \
+  --status "To Do" \
+  --priority High \
+  --type Feature \
+  --assignee dev@example.com \
+  --tag backend \
+  --tag security \
+  --tag authentication
+```
+
+### Updating Tickets
+
+```bash
+janet ticket update PROJ-123 --status "In Progress"  # Update status
+janet ticket update PROJ-123 --priority Critical     # Update priority
+janet ticket update PROJ-123 --title "New title"     # Update title
+janet ticket update PROJ-123 --assignee dev@example.com
+janet ticket update PROJ-123 --json                  # JSON output
+
+# Update multiple fields at once
+janet ticket update BACK-42 \
+  --title "Fixed: OAuth authentication flow" \
+  --description "Implemented token refresh and error handling" \
+  --status "In Review" \
+  --priority High \
+  --assignee reviewer@example.com
+```
+
+### Context (for AI Agents)
+
+```bash
+janet context                   # Human-readable context
+janet context --json            # JSON output for AI agents/scripts
+```
+
+### Organization Management
+
+```bash
+janet org list                  # List your organizations
+janet org select <org-id>       # Switch organization
+janet org current               # Show current organization
+```
+
+### Project Management
+
+```bash
+janet project list              # List projects in current org
+```
+
+### Status & Configuration
+
+```bash
+janet status                    # Show overall status
+janet config show               # Display configuration
+janet config path               # Show config file location
+janet config reset              # Reset to defaults
+janet --version                 # Show CLI version
+```
+
+## Configuration
+
+The CLI stores configuration at:
+- **macOS:** `~/Library/Application Support/janet-cli/config.json`
+- **Linux:** `~/.config/janet-cli/config.json`
+- **Windows:** `%APPDATA%\janet-cli\config.json`
+
+## Requirements
+
+- Python 3.8 or higher
+- Janet AI account ([sign up](https://tryjanet.ai))
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file for details.
+
+## Links
+
+- [Janet AI](https://tryjanet.ai) - AI-native project management
+- [Documentation](https://docs.tryjanet.ai)