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

janet/markdown/generator.py

@@ -44,8 +44,8 @@ class MarkdownGenerator:
         # 2. Metadata
         sections.append(self._generate_metadata(ticket, organization_members))
 
-        # 3. Description
-        sections.append(self._generate_description(ticket))
+        # 3. Description (pass attachments for inline image handling)
+        sections.append(self._generate_description(ticket, attachments))
 
         # 4. Comments
         if ticket.get("comments"):
@@ -84,6 +84,9 @@ class MarkdownGenerator:
         # Assignees
         assignees = ticket.get("assignees", [])
         if assignees:
+            # Handle case where assignees is a string instead of a list
+            if isinstance(assignees, str):
+                assignees = [assignees]
             assignee_names = [
                 self._resolve_user_name(email, organization_members) for email in assignees
             ]
@@ -96,39 +99,61 @@ class MarkdownGenerator:
         creator_name = self._resolve_user_name(creator, organization_members)
         lines.append(f"- **Creator:** {creator_name}")
 
+        # Tags/Labels
+        labels = ticket.get("labels", [])
+        if labels:
+            # Handle case where labels is a string instead of a list
+            if isinstance(labels, str):
+                labels = [labels]
+            lines.append(f"- **Tags:** {', '.join(labels)}")
+        else:
+            lines.append("- **Tags:** None")
+
         # 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'])}")
+        # Due Date (always shown)
+        due_date = ticket.get("due_date")
+        if due_date:
+            lines.append(f"- **Due Date:** {self._format_date(due_date)}")
+        else:
+            lines.append("- **Due Date:** None")
 
-        if ticket.get("sprint"):
-            lines.append(f"- **Sprint:** {ticket['sprint']}")
+        # Story Points (always shown)
+        story_points = ticket.get("story_points")
+        if story_points:
+            lines.append(f"- **Story Points:** {story_points}")
+        else:
+            lines.append("- **Story Points:** None")
 
-        if ticket.get("labels"):
-            labels = ticket["labels"]
-            if labels:
-                lines.append(f"- **Labels:** {', '.join(labels)}")
+        # Sprint (always shown)
+        sprint = ticket.get("sprint")
+        if sprint:
+            lines.append(f"- **Sprint:** {sprint}")
+        else:
+            lines.append("- **Sprint:** None")
 
         lines.append("")  # Empty line after metadata
         return "\n".join(lines)
 
-    def _generate_description(self, ticket: Dict) -> str:
+    def _generate_description(self, ticket: Dict, attachments: Optional[Dict] = None) -> 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)
+        # Combine all attachments for image matching
+        all_attachments = []
+        if attachments:
+            all_attachments.extend(attachments.get("direct_attachments", []))
+            all_attachments.extend(attachments.get("indirect_attachments", []))
+
+        # Convert Yjs binary to markdown with attachment info for images
+        markdown = self.yjs_converter.convert(yjs_binary, plain_text, all_attachments)
         lines.append(markdown)
 
         lines.append("")  # Empty line after description
@@ -170,6 +195,11 @@ class MarkdownGenerator:
 
             lines.append(f"- **Type:** {attachment.get('mime_type', 'Unknown')}")
 
+            # Format file size
+            file_size = attachment.get("file_size_bytes") or attachment.get("file_size")
+            if file_size:
+                lines.append(f"- **Size:** {self._format_file_size(file_size)}")
+
             uploader = attachment.get("uploaded_by", "Unknown")
             uploader_name = self._resolve_user_name(uploader, organization_members)
             lines.append(f"- **Uploaded by:** {uploader_name}")
@@ -245,13 +275,13 @@ class MarkdownGenerator:
 
     def _format_date(self, iso_string: str) -> str:
         """
-        Format ISO timestamp to human-readable date.
+        Format ISO timestamp to human-readable date with timezone.
 
         Args:
             iso_string: ISO 8601 timestamp
 
         Returns:
-            Formatted date string
+            Formatted date string with UTC timezone
         """
         if not iso_string:
             return "Unknown"
@@ -265,8 +295,31 @@ class MarkdownGenerator:
                 # 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")
+            # Format: Jan 15, 2024 10:30 AM UTC
+            return dt.strftime("%b %d, %Y %I:%M %p") + " UTC"
         except Exception:
             # Fallback: return as-is
             return iso_string
+
+    def _format_file_size(self, size_bytes) -> str:
+        """
+        Format file size in human-readable format.
+
+        Args:
+            size_bytes: File size in bytes
+
+        Returns:
+            Formatted size string (e.g., "1.5 MB")
+        """
+        try:
+            size = int(size_bytes)
+            if size < 1024:
+                return f"{size} B"
+            elif size < 1024 * 1024:
+                return f"{size / 1024:.1f} KB"
+            elif size < 1024 * 1024 * 1024:
+                return f"{size / (1024 * 1024):.1f} MB"
+            else:
+                return f"{size / (1024 * 1024 * 1024):.1f} GB"
+        except (ValueError, TypeError):
+            return "Unknown"

janet/markdown/yjs_converter.py

@@ -16,33 +16,38 @@ class YjsConverter:
     """
 
     def convert(
-        self, yjs_binary_base64: Optional[str], plain_text_fallback: Optional[str] = None
+        self,
+        yjs_binary_base64: Optional[str],
+        plain_text_fallback: Optional[str] = None,
+        attachments: Optional[List[dict]] = 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)
+            plain_text_fallback: Plain text description to use as fallback
+            attachments: List of attachment dicts with ai_description for inline image handling
 
         Returns:
             Markdown string
         """
-        # If no Yjs binary, show placeholder
-        if not yjs_binary_base64:
-            return "*No description provided*"
+        self._attachments = attachments or []
 
-        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}]*"
+        # If we have Yjs binary, try to convert it
+        if yjs_binary_base64:
+            try:
+                markdown = self._convert_with_pycrdt(yjs_binary_base64)
+                if markdown and markdown.strip():
+                    return markdown
+            except Exception as e:
+                logger.warning(f"Yjs conversion failed, falling back to plain text: {e}")
+
+        # Fall back to plain text if Yjs conversion failed or returned empty
+        if plain_text_fallback and plain_text_fallback.strip():
+            return plain_text_fallback.strip()
+
+        return "*No description provided*"
 
     def _convert_with_pycrdt(self, base64_str: str) -> str:
         """
@@ -190,17 +195,98 @@ class YjsConverter:
                         lines.append("```")
                         lines.append("")
 
+                    elif node_name == "image":
+                        # Handle image nodes - show placeholder with AI description if available
+                        url = node.attributes.get("url", "") or node.attributes.get("src", "")
+                        name = node.attributes.get("name", "")
+                        caption = node.attributes.get("caption", "")
+
+                        # Try to find matching attachment by URL
+                        ai_description = None
+                        filename = name or "image"
+
+                        for attachment in self._attachments:
+                            att_url = attachment.get("url", "") or attachment.get("file_url", "")
+                            att_filename = attachment.get("original_filename", "")
+                            # Match by URL or filename
+                            if (url and att_url and url in att_url) or \
+                               (name and att_filename and name in att_filename) or \
+                               (att_url and att_url in url):
+                                ai_description = attachment.get("ai_description")
+                                filename = att_filename or filename
+                                break
+
+                        lines.append(f"[Image: {filename}]")
+                        if ai_description:
+                            lines.append(f"*{ai_description}*")
+                        elif caption:
+                            lines.append(f"*{caption}*")
+                        lines.append("")
+
                     elif node_name == "hardBreak":
                         # Hard breaks are inline - ignore them as we add blank lines between blocks
                         pass
 
+                    elif node_name == "table":
+                        # Handle table - recurse into rows
+                        for child in children:
+                            process_node(child, indent, add_blank_line=False)
+                        lines.append("")
+
+                    elif node_name == "tableRow":
+                        # Collect cell contents for this row
+                        row_cells = []
+                        for child in children:
+                            if isinstance(child, XmlElement) and child.tag in ("tableCell", "tableHeader"):
+                                cell_text = "".join(
+                                    str(c) for c in child.children if isinstance(c, XmlText)
+                                ).strip()
+                                row_cells.append(cell_text or " ")
+                        if row_cells:
+                            lines.append("| " + " | ".join(row_cells) + " |")
+
+                    elif node_name in ("tableCell", "tableHeader"):
+                        # Handled by tableRow
+                        pass
+
+                    elif node_name == "file":
+                        # File attachment block
+                        filename = node.attributes.get("name", "file")
+                        lines.append(f"[File: {filename}]")
+                        lines.append("")
+
+                    elif node_name == "video":
+                        # Video block
+                        url = node.attributes.get("url", "")
+                        name = node.attributes.get("name", "video")
+                        lines.append(f"[Video: {name}]")
+                        lines.append("")
+
+                    elif node_name == "audio":
+                        # Audio block
+                        url = node.attributes.get("url", "")
+                        name = node.attributes.get("name", "audio")
+                        lines.append(f"[Audio: {name}]")
+                        lines.append("")
+
+                    elif node_name in ("divider", "horizontalRule"):
+                        lines.append("---")
+                        lines.append("")
+
+                    elif node_name == "alert":
+                        # Alert/callout block
+                        alert_type = node.attributes.get("type", "info")
+                        if text_content:
+                            lines.append(f"> **{alert_type.upper()}:** {text_content}")
+                            lines.append("")
+
                     # 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",):
+                    elif node_name not in ("hardBreak", "tableCell", "tableHeader"):
                         for child in children:
                             process_node(child, indent, add_blank_line=True)
 

janet/sync/readme_generator.py

@@ -2,7 +2,7 @@
 
 from datetime import datetime
 from pathlib import Path
-from typing import List, Dict
+from typing import List, Dict, Optional
 
 
 class ReadmeGenerator:
@@ -14,132 +14,226 @@ class ReadmeGenerator:
         projects: List[Dict],
         total_tickets: int,
         sync_time: datetime,
+        project_statuses: Optional[Dict[str, List[str]]] = None,
     ) -> str:
         """
         Generate README content for ticket directory.
+        Written as instructions FOR the AI coding agent.
 
         Args:
             org_name: Organization name
             projects: List of synced projects
             total_tickets: Total number of tickets synced
             sync_time: Timestamp of sync
+            project_statuses: Dict mapping project_identifier to list of valid statuses
 
         Returns:
             README markdown content
         """
         sections = []
 
-        # Header
-        sections.append(f"# Janet AI Tickets - {org_name}\n")
+        # Header - addressing the AI agent directly
+        sections.append(f"# Project 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"
+            "This directory contains project management tickets from Janet AI. "
+            "Use these tickets to understand requirements, track work, and stay aligned with project goals.\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")
+        # Context for the AI
+        sections.append("## Context\n")
         sections.append(f"- **Organization:** {org_name}")
-        sections.append(f"- **Projects Synced:** {len(projects)}")
+        sections.append(f"- **Projects:** {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
+        # Projects list with statuses
         if projects:
-            sections.append("### Projects\n")
+            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(f"### {key} - {name}\n")
+                sections.append(f"- **Tickets:** {count}")
+
+                # Show valid statuses for this project
+                if project_statuses and key in project_statuses:
+                    statuses = project_statuses[key]
+                    if statuses:
+                        sections.append(f"- **Valid Statuses:** {', '.join(statuses)}")
+                sections.append("")
+
+        # Ticket format explanation
+        sections.append("## Ticket Format\n")
+        sections.append("Each `.md` file represents a ticket with:")
+        sections.append("- **Title** - Ticket key and summary (e.g., `PROJ-123: Add login feature`)")
+        sections.append("- **Metadata** - Status, priority, type, assignees, dates, sprint, story points, labels")
+        sections.append("- **Description** - Full requirements and details")
+        sections.append("- **Comments** - Discussion and updates")
+        sections.append("- **Attachments** - Files attached to the ticket with type, size, and AI-generated descriptions")
+        sections.append("- **Child Tasks** - Sub-tasks if applicable\n")
+
+        # Instructions for the AI
+        sections.append("## How to Use These Tickets\n")
+        sections.append("When working on this codebase:")
+        sections.append("1. **Reference tickets** - Read relevant tickets before implementing features")
+        sections.append("2. **Check status** - Verify ticket status before starting work")
+        sections.append("3. **Follow requirements** - Use ticket descriptions as specifications")
+        sections.append("4. **Note priorities** - High/Critical tickets should be addressed first\n")
+
+        # CLI commands for the AI - comprehensive reference
+        sections.append("## CLI Commands Reference\n")
+        sections.append("Use the `janet` CLI to create and update tickets.\n")
+
+        # Get context
+        sections.append("### Get Project Context\n")
+        sections.append("```bash")
+        sections.append("janet context --json")
+        sections.append("```")
+        sections.append("Returns available projects with their keys. Use this to find valid project keys.\n")
+
+        # Create ticket
+        sections.append("### Create a Ticket\n")
+        sections.append("```bash")
+        sections.append('janet ticket create "Title" --project <PROJECT_KEY> [options]')
+        sections.append("```\n")
+        sections.append("**Required:**")
+        sections.append("- `--project`, `-p` - Project key (e.g., MAIN, BACK, FRONT)\n")
+        sections.append("**Optional:**")
+        sections.append("- `--description`, `-d` - Detailed description")
+        sections.append("- `--status`, `-s` - Status (see valid statuses per project above)")
+        sections.append("- `--priority` - Low, Medium, High, Critical")
+        sections.append("- `--type`, `-t` - Task, Bug, Story, Epic")
+        sections.append("- `--assignee`, `-a` - Assignee email (can use multiple times)")
+        sections.append("- `--tag` - Label/tag (can use multiple times)")
+        sections.append("- `--json` - Output as JSON\n")
+        sections.append("**Example:**")
+        sections.append("```bash")
+        sections.append('janet ticket create "Fix authentication bug" \\')
+        sections.append('  --project BACK \\')
+        sections.append('  --description "Users are getting logged out unexpectedly" \\')
+        sections.append('  --priority High \\')
+        sections.append('  --type Bug \\')
+        sections.append('  --tag backend \\')
+        sections.append('  --tag auth')
+        sections.append("```\n")
+
+        # Update ticket
+        sections.append("### Update a Ticket\n")
+        sections.append("```bash")
+        sections.append('janet ticket update <TICKET_KEY> [options]')
+        sections.append("```\n")
+        sections.append("**Options:**")
+        sections.append("- `--status`, `-s` - New status (see valid statuses per project above)")
+        sections.append("- `--title` - New title")
+        sections.append("- `--description`, `-d` - New description")
+        sections.append("- `--priority` - Low, Medium, High, Critical")
+        sections.append("- `--type`, `-t` - Task, Bug, Story, Epic")
+        sections.append("- `--assignee`, `-a` - New assignee(s)")
+        sections.append("- `--tag` - New tag(s)")
+        sections.append("- `--json` - Output as JSON\n")
+        sections.append("**Examples:**")
+        sections.append("```bash")
+        sections.append("# Starting work on a ticket")
+        sections.append('janet ticket update MAIN-123 --status "In Progress"')
+        sections.append("")
+        sections.append("# Marking ticket as complete")
+        sections.append('janet ticket update MAIN-123 --status "Done"')
+        sections.append("")
+        sections.append("# Ticket is blocked by external dependency")
+        sections.append('janet ticket update MAIN-123 --status "Blocked"')
+        sections.append("")
+        sections.append("# Update priority and add description")
+        sections.append('janet ticket update MAIN-123 --priority Critical --description "Causing production issues"')
+        sections.append("```\n")
+
+        # Project selection guidance
+        sections.append("### When to Ask User for Project\n")
+        sections.append("If the user doesn't specify which project to use:")
+        sections.append("1. Check if there's only one project - use it automatically")
+        sections.append("2. If multiple projects exist, ask the user which project to use")
+        sections.append("3. Show available projects from the list above\n")
+
+        # Valid field values - now dynamic per project
+        sections.append("### Valid Field Values\n")
+
+        # Show statuses per project
+        if project_statuses and projects:
+            sections.append("**Status (varies by project):**")
+            for project in projects:
+                key = project.get("project_identifier", "")
+                if key in project_statuses and project_statuses[key]:
+                    sections.append(f"- {key}: {', '.join(project_statuses[key])}")
             sections.append("")
+        else:
+            sections.append("**Status:** Run `janet context --json` to see valid statuses per project\n")
 
-        # 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("**Priority:** Low, Medium, High, Critical")
+        sections.append("**Type:** Task, Bug, Story, Epic\n")
+
+        # Common workflow examples
+        sections.append("## Common Workflow Examples\n")
+
+        sections.append("### Example 1: Bug Fix Workflow")
+        sections.append("When you identify and fix a bug:\n")
         sections.append("```bash")
-        sections.append("janet sync")
+        sections.append("# 1. Create a bug ticket")
+        sections.append('janet ticket create "Fix null pointer in user service" \\')
+        sections.append('  --project BACK \\')
+        sections.append('  --type Bug \\')
+        sections.append('  --priority High \\')
+        sections.append('  --description "getUserById throws NPE when user not found"')
+        sections.append("")
+        sections.append("# 2. Start working on it")
+        sections.append('janet ticket update BACK-42 --status "In Progress"')
+        sections.append("")
+        sections.append("# 3. Mark as done after fixing")
+        sections.append('janet ticket update BACK-42 --status "Done"')
         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")
+        sections.append("### Example 2: Feature Implementation")
+        sections.append("When implementing a new feature:\n")
+        sections.append("```bash")
+        sections.append("# Create a story for the feature")
+        sections.append('janet ticket create "Add dark mode support" \\')
+        sections.append('  --project FRONT \\')
+        sections.append('  --type Story \\')
+        sections.append('  --priority Medium \\')
+        sections.append('  --description "Implement dark mode toggle in settings" \\')
+        sections.append('  --tag ui \\')
+        sections.append('  --tag feature')
+        sections.append("```\n")
+
+        sections.append("### Example 3: Using JSON Output")
+        sections.append("When you need to parse the response programmatically:\n")
+        sections.append("```bash")
+        sections.append("# Get project info as JSON")
+        sections.append("janet context --json")
+        sections.append("")
+        sections.append("# Create ticket and capture the ticket key")
+        sections.append('janet ticket create "Automated task" --project MAIN --json')
+        sections.append("```\n")
+
+        # Directory structure
+        sections.append("## File Structure\n")
+        sections.append("```")
+        sections.append(f"{org_name}/")
+        for project in projects[:5]:  # Show first 5 projects
+            key = project.get("project_identifier", "")
+            name = project.get("project_name", "")
+            sections.append(f"└── {name}/")
+            sections.append(f"    ├── {key}-1.md")
+            sections.append(f"    └── ...")
+        if len(projects) > 5:
+            sections.append(f"└── ... ({len(projects) - 5} more projects)")
+        sections.append("```\n")
 
         # Footer
         sections.append("---\n")
         sections.append(
-            f"*Generated by [Janet CLI](https://github.com/janet-ai/janet-cli) v0.2.0 "
+            f"*Synced from [Janet AI](https://app.tryjanet.ai) "
             f"on {sync_time.strftime('%B %d, %Y at %I:%M %p')}*\n"
         )
 
@@ -151,6 +245,7 @@ class ReadmeGenerator:
         org_name: str,
         projects: List[Dict],
         total_tickets: int,
+        project_statuses: Optional[Dict[str, List[str]]] = None,
     ) -> Path:
         """
         Write README.md to sync directory.
@@ -160,12 +255,13 @@ class ReadmeGenerator:
             org_name: Organization name
             projects: List of synced projects
             total_tickets: Total number of tickets synced
+            project_statuses: Dict mapping project_identifier to list of valid statuses
 
         Returns:
             Path to created README
         """
         sync_time = datetime.utcnow()
-        readme_content = self.generate(org_name, projects, total_tickets, sync_time)
+        readme_content = self.generate(org_name, projects, total_tickets, sync_time, project_statuses)
 
         # Write to root of sync directory
         readme_path = sync_dir / "README.md"