janet-cli 0.2.2__py3-none-any.whl

janet/__init__.py

@@ -0,0 +1,3 @@
+"""Janet AI CLI - Sync tickets to local markdown files."""
+
+__version__ = "0.2.2"

janet/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for running janet as a module: python -m janet"""
+
+from janet.cli import app
+
+if __name__ == "__main__":
+    app()

janet/api/client.py

@@ -0,0 +1,128 @@
+"""Base API client with authentication headers."""
+
+from typing import Dict, Optional
+
+import httpx
+
+from janet.auth.token_manager import TokenManager
+from janet.config.manager import ConfigManager
+from janet.utils.errors import NetworkError, AuthenticationError, TokenExpiredError
+
+
+class APIClient:
+    """Base API client for Janet AI."""
+
+    def __init__(self, config_manager: ConfigManager):
+        """
+        Initialize API client.
+
+        Args:
+            config_manager: Configuration manager instance
+        """
+        self.config_manager = config_manager
+        self.token_manager = TokenManager(config_manager)
+        self.config = config_manager.get()
+        self.base_url = self.config.api.base_url
+        self.timeout = self.config.api.timeout
+
+    def _get_headers(self, include_org: bool = False) -> Dict[str, str]:
+        """
+        Get request headers with authentication.
+
+        Args:
+            include_org: Whether to include organization ID header
+
+        Returns:
+            Dictionary of headers
+        """
+        try:
+            access_token = self.token_manager.get_access_token()
+        except TokenExpiredError:
+            # Try to refresh token
+            from janet.auth.oauth_flow import OAuthFlow
+
+            oauth_flow = OAuthFlow(self.config_manager)
+            try:
+                oauth_flow.refresh_token()
+                access_token = self.token_manager.get_access_token()
+            except Exception:
+                raise AuthenticationError(
+                    "Token expired and refresh failed. Please log in again."
+                )
+
+        headers = {
+            "Authorization": f"Bearer {access_token}",
+            "Content-Type": "application/json",
+        }
+
+        if include_org and self.config.selected_organization:
+            headers["X-Organization-ID"] = self.config.selected_organization.id
+
+        return headers
+
+    def get(self, endpoint: str, include_org: bool = False, **kwargs) -> Dict:
+        """
+        Make GET request.
+
+        Args:
+            endpoint: API endpoint (relative to base_url)
+            include_org: Whether to include organization ID header
+            **kwargs: Additional arguments for httpx.get
+
+        Returns:
+            Response JSON
+
+        Raises:
+            NetworkError: If request fails
+        """
+        url = f"{self.base_url}{endpoint}"
+        headers = self._get_headers(include_org=include_org)
+
+        try:
+            response = httpx.get(url, headers=headers, timeout=self.timeout, **kwargs)
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 401:
+                raise AuthenticationError("Authentication failed. Please log in again.")
+            raise NetworkError(f"API request failed: {e.response.status_code} {e.response.text}")
+        except httpx.TimeoutException:
+            raise NetworkError(f"Request timeout after {self.timeout}s")
+        except Exception as e:
+            raise NetworkError(f"Network error: {e}")
+
+    def post(
+        self, endpoint: str, data: Optional[Dict] = None, include_org: bool = False, **kwargs
+    ) -> Dict:
+        """
+        Make POST request.
+
+        Args:
+            endpoint: API endpoint (relative to base_url)
+            data: Request body data
+            include_org: Whether to include organization ID header
+            **kwargs: Additional arguments for httpx.post
+
+        Returns:
+            Response JSON
+
+        Raises:
+            NetworkError: If request fails
+        """
+        url = f"{self.base_url}{endpoint}"
+        headers = self._get_headers(include_org=include_org)
+
+        try:
+            response = httpx.post(
+                url, headers=headers, json=data, timeout=self.timeout, **kwargs
+            )
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 401:
+                raise AuthenticationError("Authentication failed. Please log in again.")
+            raise NetworkError(f"API request failed: {e.response.status_code} {e.response.text}")
+        except httpx.TimeoutException:
+            raise NetworkError(f"Request timeout after {self.timeout}s")
+        except Exception as e:
+            raise NetworkError(f"Network error: {e}")

janet/api/models.py

@@ -0,0 +1,92 @@
+"""Pydantic models for API responses."""
+
+from typing import List, Optional
+from datetime import datetime
+from pydantic import BaseModel
+
+
+class Comment(BaseModel):
+    """Ticket comment model."""
+
+    id: str
+    content: str
+    created_by: str
+    created_at: str
+    updated_at: str
+
+
+class Attachment(BaseModel):
+    """Ticket attachment model."""
+
+    id: str
+    mapping_id: str
+    original_filename: str
+    mime_type: str
+    file_size_bytes: int
+    gcs_uri: str
+    signed_url: Optional[str] = None
+    ai_description: Optional[str] = None
+    ai_processing_status: str
+    uploaded_by: str
+    created_at: str
+    is_direct: bool
+
+
+class ChildTask(BaseModel):
+    """Child task model."""
+
+    id: str
+    childIdentifier: str
+    fullIdentifier: str
+    title: str
+    description: Optional[str] = None
+    status: Optional[str] = None
+    priority: Optional[str] = None
+    assignee: Optional[str] = None
+    displayOrder: str
+    createdBy: str
+    updatedBy: Optional[str] = None
+    createdAt: str
+    updatedAt: str
+
+
+class Ticket(BaseModel):
+    """Ticket model."""
+
+    id: str
+    ticket_identifier: str
+    ticket_key: str
+    title: str
+    description: Optional[str] = None
+    description_yjs_binary: Optional[str] = None
+    ai_summary: Optional[str] = None
+    ticket_evaluation: Optional[str] = None
+    status: str
+    priority: str
+    issue_type: str
+    assignees: List[str] = []
+    labels: List[str] = []
+    story_points: Optional[str] = None
+    due_date: Optional[str] = None
+    sprint: Optional[str] = None
+    creator: str
+    project_id: str
+    organization_id: str
+    created_at: str
+    updated_at: str
+    comments: List[Comment] = []
+    child_tasks: List[ChildTask] = []
+
+
+class OrganizationMember(BaseModel):
+    """Organization member model."""
+
+    id: str
+    userId: str
+    email: str
+    firstName: Optional[str] = None
+    lastName: Optional[str] = None
+    profilePictureUrl: Optional[str] = None
+    role: str
+    status: str
+    joinedAt: str

janet/api/organizations.py

@@ -0,0 +1,57 @@
+"""Organization API methods."""
+
+from typing import List, Dict
+
+from janet.api.client import APIClient
+from janet.config.manager import ConfigManager
+
+
+class OrganizationAPI(APIClient):
+    """API methods for organization management."""
+
+    def __init__(self, config_manager: ConfigManager):
+        """
+        Initialize organization API.
+
+        Args:
+            config_manager: Configuration manager instance
+        """
+        super().__init__(config_manager)
+
+    def list_organizations(self) -> List[Dict]:
+        """
+        List available organizations for the authenticated user.
+
+        Returns:
+            List of organization dictionaries
+
+        Raises:
+            NetworkError: If API request fails
+            AuthenticationError: If not authenticated
+        """
+        response = self.get("/api/v1/organizations/list")
+
+        if not response.get("success"):
+            raise Exception(response.get("error", "Failed to fetch organizations"))
+
+        return response.get("organizations", [])
+
+    def get_organization(self, org_id: str) -> Dict:
+        """
+        Get organization details.
+
+        Args:
+            org_id: Organization ID
+
+        Returns:
+            Organization dictionary
+
+        Raises:
+            NetworkError: If API request fails
+        """
+        response = self.get(f"/api/v1/organizations/{org_id}")
+
+        if not response.get("success"):
+            raise Exception(response.get("error", "Failed to fetch organization"))
+
+        return response.get("organization", {})

janet/api/projects.py

@@ -0,0 +1,57 @@
+"""Project API methods."""
+
+from typing import List, Dict
+
+from janet.api.client import APIClient
+from janet.config.manager import ConfigManager
+
+
+class ProjectAPI(APIClient):
+    """API methods for project management."""
+
+    def __init__(self, config_manager: ConfigManager):
+        """
+        Initialize project API.
+
+        Args:
+            config_manager: Configuration manager instance
+        """
+        super().__init__(config_manager)
+
+    def list_projects(self) -> List[Dict]:
+        """
+        List projects in the current organization.
+
+        Returns:
+            List of project dictionaries
+
+        Raises:
+            NetworkError: If API request fails
+            AuthenticationError: If not authenticated
+        """
+        response = self.get("/api/v1/projects", include_org=True)
+
+        if not response.get("success"):
+            raise Exception(response.get("error", "Failed to fetch projects"))
+
+        return response.get("projects", [])
+
+    def get_project(self, project_id: str) -> Dict:
+        """
+        Get project details.
+
+        Args:
+            project_id: Project ID
+
+        Returns:
+            Project dictionary
+
+        Raises:
+            NetworkError: If API request fails
+        """
+        response = self.get(f"/api/v1/projects/{project_id}", include_org=True)
+
+        if not response.get("success"):
+            raise Exception(response.get("error", "Failed to fetch project"))
+
+        return response.get("project", {})

janet/api/tickets.py

@@ -0,0 +1,125 @@
+"""Ticket API methods."""
+
+from typing import List, Dict, Optional
+
+from janet.api.client import APIClient
+from janet.config.manager import ConfigManager
+
+
+class TicketAPI(APIClient):
+    """API methods for ticket management."""
+
+    def __init__(self, config_manager: ConfigManager):
+        """
+        Initialize ticket API.
+
+        Args:
+            config_manager: Configuration manager instance
+        """
+        super().__init__(config_manager)
+
+    def list_tickets(
+        self,
+        project_id: str,
+        limit: int = 1000,
+        offset: int = 0,
+        show_resolved: bool = True,
+    ) -> Dict:
+        """
+        List tickets for a project.
+
+        Args:
+            project_id: Project ID
+            limit: Maximum tickets to return
+            offset: Pagination offset
+            show_resolved: Include resolved tickets older than 7 days
+
+        Returns:
+            Dictionary with tickets and metadata
+
+        Raises:
+            NetworkError: If API request fails
+        """
+        endpoint = f"/api/v1/projects/{project_id}/tickets/list"
+
+        data = {
+            "limit": limit,
+            "offset": offset,
+            "show_resolved_over_7_days": show_resolved,
+        }
+
+        response = self.post(endpoint, data=data, include_org=True)
+
+        if not response.get("success"):
+            raise Exception(response.get("error", "Failed to list tickets"))
+
+        return response
+
+    def get_ticket(self, ticket_id: str) -> Dict:
+        """
+        Get full ticket details.
+
+        Args:
+            ticket_id: Ticket ID
+
+        Returns:
+            Ticket dictionary with all fields
+
+        Raises:
+            NetworkError: If API request fails
+        """
+        response = self.get(f"/api/v1/tickets/{ticket_id}", include_org=True)
+
+        if not response.get("success"):
+            raise Exception(response.get("error", "Failed to fetch ticket"))
+
+        return response.get("ticket", {})
+
+    def batch_fetch(self, ticket_ids: List[str]) -> List[Dict]:
+        """
+        Fetch multiple tickets in one request.
+
+        Args:
+            ticket_ids: List of ticket IDs
+
+        Returns:
+            List of ticket dictionaries
+
+        Raises:
+            NetworkError: If API request fails
+        """
+        if not ticket_ids:
+            return []
+
+        data = {"ticket_ids": ticket_ids}
+        response = self.post("/api/v1/tickets/batch", data=data, include_org=True)
+
+        if not response.get("success"):
+            raise Exception(response.get("error", "Failed to batch fetch tickets"))
+
+        return response.get("tickets", [])
+
+    def get_ticket_attachments(self, ticket_id: str) -> Dict:
+        """
+        Get attachments for a ticket.
+
+        Args:
+            ticket_id: Ticket ID
+
+        Returns:
+            Dictionary with direct and indirect attachments
+
+        Raises:
+            NetworkError: If API request fails
+        """
+        response = self.get(
+            f"/api/v1/tickets/{ticket_id}/attachments", include_org=True
+        )
+
+        if not response.get("success"):
+            raise Exception(response.get("error", "Failed to fetch attachments"))
+
+        return {
+            "direct_attachments": response.get("direct_attachments", []),
+            "indirect_attachments": response.get("indirect_attachments", []),
+        }