janet-cli 0.2.2__py3-none-any.whl

janet/config/manager.py

@@ -0,0 +1,116 @@
+"""Configuration file management."""
+
+import json
+from pathlib import Path
+from typing import Optional
+
+from janet.config.models import Config
+from janet.utils.errors import ConfigurationError
+from janet.utils.paths import get_config_file
+
+
+class ConfigManager:
+    """Manages configuration file read/write operations."""
+
+    def __init__(self, config_path: Optional[Path] = None):
+        """
+        Initialize configuration manager.
+
+        Args:
+            config_path: Optional custom config file path
+        """
+        self.config_path = config_path or get_config_file()
+        self._config: Optional[Config] = None
+
+    def load(self) -> Config:
+        """
+        Load configuration from file.
+
+        Returns:
+            Configuration object
+
+        Raises:
+            ConfigurationError: If config file is invalid
+        """
+        if not self.config_path.exists():
+            # Create default configuration
+            self._config = Config()
+            self.save()
+            return self._config
+
+        try:
+            with open(self.config_path, "r") as f:
+                data = json.load(f)
+            self._config = Config(**data)
+            return self._config
+        except Exception as e:
+            raise ConfigurationError(f"Failed to load configuration: {e}")
+
+    def save(self) -> None:
+        """
+        Save configuration to file.
+
+        Raises:
+            ConfigurationError: If unable to save config
+        """
+        if self._config is None:
+            raise ConfigurationError("No configuration loaded")
+
+        try:
+            # Ensure parent directory exists
+            self.config_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Write config with indentation for readability
+            with open(self.config_path, "w") as f:
+                json.dump(self._config.model_dump(mode="json"), f, indent=2, default=str)
+
+            # Set restrictive permissions (user read/write only)
+            self.config_path.chmod(0o600)
+        except Exception as e:
+            raise ConfigurationError(f"Failed to save configuration: {e}")
+
+    def get(self) -> Config:
+        """
+        Get current configuration.
+
+        Returns:
+            Configuration object
+        """
+        if self._config is None:
+            self._config = self.load()
+        return self._config
+
+    def update(self, config: Config) -> None:
+        """
+        Update configuration and save to file.
+
+        Args:
+            config: Updated configuration object
+        """
+        self._config = config
+        self.save()
+
+    def reset(self) -> None:
+        """Reset configuration to defaults."""
+        self._config = Config()
+        self.save()
+
+    def is_authenticated(self) -> bool:
+        """
+        Check if user is authenticated.
+
+        Returns:
+            True if valid access token exists
+        """
+        config = self.get()
+        return config.auth.access_token is not None
+
+    def has_organization(self) -> bool:
+        """
+        Check if organization is selected.
+
+        Returns:
+            True if organization is selected
+        """
+        config = self.get()
+        return config.selected_organization is not None

janet/config/models.py

@@ -0,0 +1,66 @@
+"""Pydantic models for configuration."""
+
+import os
+from datetime import datetime
+from typing import Dict, Optional
+from pydantic import BaseModel, Field
+
+
+class AuthConfig(BaseModel):
+    """Authentication configuration."""
+
+    access_token: Optional[str] = None
+    refresh_token: Optional[str] = None
+    expires_at: Optional[datetime] = None
+    user_id: Optional[str] = None
+    user_email: Optional[str] = None
+
+
+class OrganizationInfo(BaseModel):
+    """Organization information."""
+
+    id: str
+    name: str
+    uuid: str
+
+
+class APIConfig(BaseModel):
+    """API configuration."""
+
+    # Production URL by default, override with env var for development
+    base_url: str = Field(
+        default_factory=lambda: os.getenv(
+            "JANET_API_BASE_URL",
+            "https://janet-ai-backend-prod-service-11399-85b8d46f-d4i7j6xw.onporter.run"
+        )
+    )
+    timeout: int = 30
+
+
+class SyncConfig(BaseModel):
+    """Sync configuration."""
+
+    root_directory: str = "~/janet-tickets"
+    last_sync_times: Dict[str, str] = Field(default_factory=dict)
+    sync_on_init: bool = False
+    batch_size: int = 50
+
+
+class MarkdownConfig(BaseModel):
+    """Markdown generation configuration."""
+
+    include_comments: bool = True
+    include_attachments: bool = True
+    include_metadata: bool = True
+    yjs_fallback_mode: str = "plain_text"
+
+
+class Config(BaseModel):
+    """Complete configuration model."""
+
+    version: str = "1.0"
+    auth: AuthConfig = Field(default_factory=AuthConfig)
+    selected_organization: Optional[OrganizationInfo] = None
+    api: APIConfig = Field(default_factory=APIConfig)
+    sync: SyncConfig = Field(default_factory=SyncConfig)
+    markdown: MarkdownConfig = Field(default_factory=MarkdownConfig)

janet/markdown/generator.py

@@ -0,0 +1,272 @@
+"""Generate markdown from ticket data."""
+
+from datetime import datetime
+from typing import Dict, List, Optional
+
+from janet.markdown.yjs_converter import YjsConverter
+
+
+class MarkdownGenerator:
+    """
+    Generate markdown documents from ticket data.
+
+    Based on TypeScript implementation in copyTicketAsMarkdown.ts
+    """
+
+    def __init__(self):
+        """Initialize markdown generator."""
+        self.yjs_converter = YjsConverter()
+
+    def generate(
+        self,
+        ticket: Dict,
+        organization_members: Optional[List[Dict]] = None,
+        attachments: Optional[Dict] = None,
+    ) -> str:
+        """
+        Generate complete markdown document from ticket data.
+
+        Args:
+            ticket: Ticket dictionary
+            organization_members: List of organization members (for name resolution)
+            attachments: Dictionary with direct_attachments and indirect_attachments
+
+        Returns:
+            Complete markdown string
+        """
+        sections = []
+
+        # 1. Title
+        ticket_key = ticket.get("ticket_key", "UNKNOWN")
+        title = ticket.get("title", "Untitled")
+        sections.append(f"# {ticket_key}: {title}\n")
+
+        # 2. Metadata
+        sections.append(self._generate_metadata(ticket, organization_members))
+
+        # 3. Description
+        sections.append(self._generate_description(ticket))
+
+        # 4. Comments
+        if ticket.get("comments"):
+            sections.append(
+                self._generate_comments(ticket["comments"], organization_members)
+            )
+
+        # 5. Attachments
+        if attachments:
+            sections.append(self._generate_attachments(attachments, organization_members))
+
+        # 6. Child Tasks
+        if ticket.get("child_tasks"):
+            sections.append(self._generate_child_tasks(ticket["child_tasks"]))
+
+        # 7. Footer
+        sections.append(self._generate_footer(ticket_key))
+
+        return "\n".join(sections)
+
+    def _generate_metadata(
+        self, ticket: Dict, organization_members: Optional[List[Dict]] = None
+    ) -> str:
+        """Generate metadata section."""
+        lines = ["## Metadata\n"]
+
+        # Status
+        lines.append(f"- **Status:** {ticket.get('status', 'Unknown')}")
+
+        # Priority
+        lines.append(f"- **Priority:** {ticket.get('priority', 'Unknown')}")
+
+        # Type
+        lines.append(f"- **Type:** {ticket.get('issue_type', 'Unknown')}")
+
+        # Assignees
+        assignees = ticket.get("assignees", [])
+        if assignees:
+            assignee_names = [
+                self._resolve_user_name(email, organization_members) for email in assignees
+            ]
+            lines.append(f"- **Assignees:** {', '.join(assignee_names)}")
+        else:
+            lines.append("- **Assignees:** Unassigned")
+
+        # Creator
+        creator = ticket.get("creator", "Unknown")
+        creator_name = self._resolve_user_name(creator, organization_members)
+        lines.append(f"- **Creator:** {creator_name}")
+
+        # Dates
+        created_at = ticket.get("created_at", "")
+        updated_at = ticket.get("updated_at", "")
+        lines.append(f"- **Created:** {self._format_date(created_at)}")
+        lines.append(f"- **Updated:** {self._format_date(updated_at)}")
+
+        # Optional fields
+        if ticket.get("story_points"):
+            lines.append(f"- **Story Points:** {ticket['story_points']}")
+
+        if ticket.get("due_date"):
+            lines.append(f"- **Due Date:** {self._format_date(ticket['due_date'])}")
+
+        if ticket.get("sprint"):
+            lines.append(f"- **Sprint:** {ticket['sprint']}")
+
+        if ticket.get("labels"):
+            labels = ticket["labels"]
+            if labels:
+                lines.append(f"- **Labels:** {', '.join(labels)}")
+
+        lines.append("")  # Empty line after metadata
+        return "\n".join(lines)
+
+    def _generate_description(self, ticket: Dict) -> str:
+        """Generate description section."""
+        lines = ["## Description\n"]
+
+        yjs_binary = ticket.get("description_yjs_binary")
+        plain_text = ticket.get("description")
+
+        # Convert Yjs binary to markdown
+        markdown = self.yjs_converter.convert(yjs_binary, plain_text)
+        lines.append(markdown)
+
+        lines.append("")  # Empty line after description
+        return "\n".join(lines)
+
+    def _generate_comments(
+        self, comments: List[Dict], organization_members: Optional[List[Dict]] = None
+    ) -> str:
+        """Generate comments section."""
+        lines = [f"## Comments ({len(comments)})\n"]
+
+        for comment in comments:
+            author = comment.get("created_by", "Unknown")
+            author_name = self._resolve_user_name(author, organization_members)
+            timestamp = self._format_date(comment.get("created_at", ""))
+
+            lines.append(f"### {author_name} - {timestamp}\n")
+            lines.append(comment.get("content", ""))
+            lines.append("")  # Empty line between comments
+
+        return "\n".join(lines)
+
+    def _generate_attachments(
+        self, attachments: Dict, organization_members: Optional[List[Dict]] = None
+    ) -> str:
+        """Generate attachments section."""
+        direct = attachments.get("direct_attachments", [])
+        indirect = attachments.get("indirect_attachments", [])
+        all_attachments = direct + indirect
+
+        if not all_attachments:
+            return ""
+
+        lines = [f"## Attachments ({len(all_attachments)})\n"]
+
+        for attachment in all_attachments:
+            filename = attachment.get("original_filename", "Unknown")
+            lines.append(f"### {filename}")
+
+            lines.append(f"- **Type:** {attachment.get('mime_type', 'Unknown')}")
+
+            uploader = attachment.get("uploaded_by", "Unknown")
+            uploader_name = self._resolve_user_name(uploader, organization_members)
+            lines.append(f"- **Uploaded by:** {uploader_name}")
+
+            created_at = attachment.get("created_at", "")
+            lines.append(f"- **Uploaded:** {self._format_date(created_at)}")
+
+            if attachment.get("ai_description"):
+                lines.append(f"- **AI Description:** {attachment['ai_description']}")
+
+            lines.append("")  # Empty line between attachments
+
+        return "\n".join(lines)
+
+    def _generate_child_tasks(self, child_tasks: List[Dict]) -> str:
+        """Generate child tasks section."""
+        if not child_tasks:
+            return ""
+
+        lines = [f"## Child Tasks ({len(child_tasks)})\n"]
+
+        for task in child_tasks:
+            identifier = task.get("fullIdentifier", task.get("childIdentifier", ""))
+            title = task.get("title", "Untitled")
+            status = task.get("status", "")
+            priority = task.get("priority", "")
+
+            # Format: - [STATUS] IDENTIFIER: Title (Priority)
+            status_badge = f"[{status}]" if status else ""
+            priority_info = f"({priority})" if priority else ""
+
+            line = f"- {status_badge} **{identifier}**: {title}"
+            if priority_info:
+                line += f" {priority_info}"
+
+            lines.append(line)
+
+        lines.append("")  # Empty line after child tasks
+        return "\n".join(lines)
+
+    def _generate_footer(self, ticket_key: str) -> str:
+        """Generate footer section."""
+        export_date = self._format_date(datetime.utcnow().isoformat())
+        return f"---\n*Exported from {ticket_key} on {export_date}*"
+
+    def _resolve_user_name(
+        self, email: str, organization_members: Optional[List[Dict]] = None
+    ) -> str:
+        """
+        Resolve user email to display name.
+
+        Args:
+            email: User email
+            organization_members: List of organization members
+
+        Returns:
+            Display name or email if not found
+        """
+        if not organization_members:
+            return email
+
+        for member in organization_members:
+            if member.get("email") == email:
+                first_name = member.get("firstName", "")
+                last_name = member.get("lastName", "")
+                if first_name and last_name:
+                    return f"{first_name} {last_name}"
+                elif first_name:
+                    return first_name
+                break
+
+        return email
+
+    def _format_date(self, iso_string: str) -> str:
+        """
+        Format ISO timestamp to human-readable date.
+
+        Args:
+            iso_string: ISO 8601 timestamp
+
+        Returns:
+            Formatted date string
+        """
+        if not iso_string:
+            return "Unknown"
+
+        try:
+            # Parse ISO string (handle both with and without microseconds)
+            if "." in iso_string:
+                # Has microseconds
+                dt = datetime.fromisoformat(iso_string.replace("Z", "+00:00"))
+            else:
+                # No microseconds
+                dt = datetime.fromisoformat(iso_string.replace("Z", "+00:00"))
+
+            # Format: Jan 15, 2024 10:30 AM
+            return dt.strftime("%b %d, %Y %I:%M %p")
+        except Exception:
+            # Fallback: return as-is
+            return iso_string

janet/markdown/yjs_converter.py

@@ -0,0 +1,225 @@
+"""Convert Yjs binary to markdown using pycrdt."""
+
+import base64
+import logging
+from typing import Optional, List
+
+logger = logging.getLogger(__name__)
+
+
+class YjsConverter:
+    """
+    Convert Yjs binary to markdown.
+
+    Uses pycrdt (actively maintained, replaces abandoned y-py).
+    Based on TypeScript implementation in copyTicketAsMarkdown.ts
+    """
+
+    def convert(
+        self, yjs_binary_base64: Optional[str], plain_text_fallback: Optional[str] = None
+    ) -> str:
+        """
+        Convert Yjs binary to markdown.
+
+        Args:
+            yjs_binary_base64: Base64-encoded Yjs binary
+            plain_text_fallback: Plain text description (NOT USED - only for compatibility)
+
+        Returns:
+            Markdown string
+        """
+        # If no Yjs binary, show placeholder
+        if not yjs_binary_base64:
+            return "*No description provided*"
+
+        try:
+            # Try pycrdt conversion
+            markdown = self._convert_with_pycrdt(yjs_binary_base64)
+            if markdown and markdown.strip():
+                return markdown
+            else:
+                return "*[Empty description]*"
+        except Exception as e:
+            # Show error instead of falling back
+            logger.error(f"Yjs conversion failed: {e}")
+            return f"*[Yjs conversion failed: {e}]*"
+
+    def _convert_with_pycrdt(self, base64_str: str) -> str:
+        """
+        Use pycrdt library to parse Yjs binary and extract text.
+
+        Args:
+            base64_str: Base64-encoded Yjs binary
+
+        Returns:
+            Markdown string
+
+        Raises:
+            Exception: If conversion fails
+        """
+        try:
+            from pycrdt import Doc, XmlElement, XmlText, XmlFragment
+        except ImportError:
+            raise Exception("pycrdt library not installed. Run: pip install pycrdt")
+
+        # Decode base64
+        binary_data = self._base64_to_bytes(base64_str)
+        if not binary_data:
+            raise Exception("Failed to decode base64")
+
+        # Create Doc and apply update
+        doc = Doc()
+        doc.apply_update(binary_data)
+
+        # Get the BlockNote editor fragment
+        try:
+            # pycrdt uses get() with type= parameter
+            fragment = doc.get("blocknote-editor", type=XmlFragment)
+        except Exception as e:
+            raise Exception(f"Failed to get blocknote-editor fragment: {e}")
+
+        if fragment is None:
+            raise Exception("blocknote-editor fragment is None")
+
+        # Extract text from fragment
+        return self._extract_text_from_fragment(fragment)
+
+    def _base64_to_bytes(self, base64_str: str) -> Optional[bytes]:
+        """Convert base64 string to bytes."""
+        try:
+            if not base64_str or not isinstance(base64_str, str):
+                return None
+
+            cleaned = base64_str.strip()
+
+            # Validate base64 format
+            import re
+            if not re.match(r'^[A-Za-z0-9+/]*={0,2}$', cleaned):
+                logger.warning("Invalid base64 format detected")
+                return None
+
+            return base64.b64decode(cleaned)
+        except Exception as e:
+            logger.warning(f"Failed to decode base64: {e}")
+            return None
+
+    def _extract_text_from_fragment(self, fragment) -> str:
+        """
+        Extract markdown text from XmlFragment.
+
+        This mimics the TypeScript extractTextFromYDoc function.
+
+        Args:
+            fragment: XmlFragment containing BlockNote content
+
+        Returns:
+            Markdown string
+        """
+        from pycrdt import XmlElement, XmlText
+
+        lines: List[str] = []
+
+        def process_node(node, indent: int = 0, add_blank_line: bool = True):
+            """Process a single XML node recursively."""
+            try:
+                if isinstance(node, XmlText):
+                    # Handle text nodes - these are inline, no blank line
+                    text = str(node).strip()
+                    if text:
+                        lines.append("  " * indent + text)
+
+                elif isinstance(node, XmlElement):
+                    # Handle element nodes
+                    node_name = node.tag
+                    children = list(node.children) if hasattr(node, "children") else []
+
+                    # Collect text content from XmlText children
+                    text_content = "".join(
+                        str(child) for child in children if isinstance(child, XmlText)
+                    ).strip()
+
+                    # Node processing (debug removed)
+
+                    # Process based on node type (matching BlockNote structure)
+
+                    # BlockNote wrapper elements - just recurse into children
+                    if node_name in ("blockGroup", "blockContainer"):
+                        for child in children:
+                            process_node(child, indent, add_blank_line)
+
+                    # Actual content blocks
+                    elif node_name == "heading" and text_content:
+                        level = int(node.attributes.get("level", 1))
+                        lines.append("#" * level + " " + text_content)
+                        lines.append("")  # Blank line after heading
+
+                    elif node_name == "paragraph" and text_content:
+                        lines.append(text_content)
+                        lines.append("")  # Blank line after paragraph
+
+                    elif node_name == "quote" and text_content:
+                        # BlockNote quote becomes markdown blockquote
+                        lines.append("> " + text_content)
+                        lines.append("")  # Blank line after quote
+
+                    elif node_name == "bulletListItem" and text_content:
+                        lines.append("  " * indent + "- " + text_content)
+                        # Process nested lists
+                        for child in children:
+                            if isinstance(child, XmlElement):
+                                process_node(child, indent + 1, add_blank_line=False)
+
+                    elif node_name == "numberedListItem" and text_content:
+                        lines.append("  " * indent + "1. " + text_content)
+                        # Process nested lists
+                        for child in children:
+                            if isinstance(child, XmlElement):
+                                process_node(child, indent + 1, add_blank_line=False)
+
+                    elif node_name == "checkListItem":
+                        checked = node.attributes.get("checked", "false") == "true"
+                        checkbox = "[x]" if checked else "[ ]"
+                        if text_content:
+                            lines.append("  " * indent + f"- {checkbox} " + text_content)
+
+                    elif node_name == "codeBlock":
+                        language = node.attributes.get("language", "")
+                        lines.append(f"```{language}")
+                        if text_content:
+                            lines.append(text_content)
+                        lines.append("```")
+                        lines.append("")
+
+                    elif node_name == "hardBreak":
+                        # Hard breaks are inline - ignore them as we add blank lines between blocks
+                        pass
+
+                    # Handle empty paragraphs or unknown blocks
+                    elif text_content:
+                        lines.append(text_content)
+                        lines.append("")
+
+                    # Always process children for unknown types
+                    elif node_name not in ("hardBreak",):
+                        for child in children:
+                            process_node(child, indent, add_blank_line=True)
+
+            except Exception as e:
+                logger.debug(f"Error processing node: {e}")
+
+        # Process all top-level children
+        try:
+            if hasattr(fragment, "children"):
+                children_list = list(fragment.children)
+                for child in children_list:
+                    process_node(child)
+            else:
+                # Try iterating directly
+                for child in fragment:
+                    process_node(child)
+        except Exception as e:
+            logger.warning(f"Failed to iterate fragment: {e}")
+            raise Exception(f"Could not iterate fragment children")
+
+        result = "\n".join(lines).strip()
+        return result if result else ""