Pm Architect

# PM Architect Default Preferences
# Generated from claude-trace log analysis (2025-11-22)
# Source: 1,205 user messages from 15 recent sessions
# Confidence: High (>100 observations per pattern)

# Core User Profile
user_profile:
  name: "Ryan"
  work_style: "complete_and_thorough"
  autonomy_preference: "high_with_checkpoints"
  quality_emphasis: "always"
  communication_style: "polite_but_firm"

# Scope Preferences
scope:
  # Default scope selection (255:1 ratio observed)
  default_preference: "complete"

  # When to propose complete scope
  complete_triggers:
    - "new feature implementation"
    - "refactoring"
    - "bug fixes with root cause"
    - "documentation updates"
    - "default_when_ambiguous"

  # When to propose minimal scope (rare - only 4 instances)
  minimal_triggers:
    - "explicit_user_instruction: 'only', 'just'"
    - "explicit_rework_in_progress"
    - "user_explicitly_states_minimal"

  # Red flag: User correction observed
  never_propose_incomplete:
    trigger_phrase: "I'm not going to merge incomplete work"
    observed_count: 124
    severity: "critical_boundary"
    action: "always_complete_or_decline"

# Autonomy Settings
autonomy:
  # Default to autonomous execution (2.2:1 ratio)
  default_mode: "autonomous"

  # Checkpoint triggers (when to ask vs. proceed)
  checkpoint_required:
    architectural_decision:
      enabled: true
      examples:
        - "choosing between major design patterns"
        - "selecting core technologies"
        - "defining system boundaries"

    scope_ambiguity:
      enabled: true
      examples:
        - "unclear requirements"
        - "multiple interpretation possible"
        - "missing critical information"

    workflow_deviation:
      enabled: true
      examples:
        - "need to skip workflow step"
        - "workflow doesn't fit scenario"
        - "custom process needed"

    phase_boundary:
      enabled: true
      examples:
        - "completing one phase before next"
        - "phase separation decision"
        - "multi-PR strategy"

    high_risk_operation:
      enabled: true
      examples:
        - "destructive git operations"
        - "production deployments"
        - "major refactoring"

  # Proceed autonomously for
  autonomous_operations:
    - "well_defined_tasks"
    - "within_workflow"
    - "reversible_operations"
    - "single_phase_work"
    - "quality_verification"
    - "status_reporting"

# Quality Settings
quality:
  # Always verify quality (888 instances observed)
  verification_mode: "always_on"

  # Don't ask permission to verify
  ask_permission_to_verify: false

  # Required quality gates
  required_gates:
    - name: "tests"
      command: "pytest"
      blocking: true

    - name: "linting"
      command: "ruff check"
      blocking: true

    - name: "type_checking"
      command: "mypy"
      blocking: false

    - name: "ci_checks"
      command: "gh pr checks"
      blocking: true

    - name: "build_verification"
      command: "make build"
      blocking: true

  # Reporting strategy
  report_format: "summary_unless_failure"
  report_timing: "after_completion"
  failure_action: "report_and_checkpoint"

# Work Organization
work_organization:
  # Maintain separate PRs for (6 instances of "keep separate")
  separate_prs_for:
    - "different_phases"
    - "different_features"
    - "rework_vs_new_work"
    - "unrelated_concerns"

  # Phase management
  phase_management:
    strategy: "one_pr_per_phase"
    naming: "feat/issue-{issue_number}-{phase_name}"
    checkpoint_between_phases: true

  # Combine work only if
  combine_conditions:
    - "user_explicitly_requests"
    - "logically_coupled_changes"
    - "same_phase_same_feature"

  # Red flag: User correction observed
  separation_boundary:
    trigger_phrase: "keep the phase 1 pr separate"
    observed_count: 6
    severity: "high_priority"
    action: "never_combine_phases"

# Merge Strategy
merge:
  # Await explicit permission (56 instances observed)
  require_permission: true

  # Support conditional delegation
  conditional_merge:
    enabled: true
    trigger_phrases:
      - "when mergeable you can merge it"
      - "when this pr is mergeable please merge"
      - "merge when ci passes"

  # Pre-merge verification
  pre_merge_checks:
    ci_status: "must_pass"
    tests: "must_pass"
    reviews: "optional"
    scope_complete: "required"
    quality_gates: "all_passed"

  # Merge execution
  execution:
    strategy: "wait_for_ci"
    auto_merge_if_conditions_met: true
    report_before_merge: true
    confirm_after_merge: true

# Communication Style
communication:
  # Match user's polite but firm tone (550 polite instances)
  tone: "polite_but_firm"

  # Always acknowledge boundaries
  acknowledge_boundaries: true

  # Be specific with references
  reference_specifics:
    pr_numbers: true
    file_names: true
    phase_names: true
    issue_numbers: true

  # Status reporting
  status_reports:
    frequency: "milestone_completion"
    detail_level: "summary_with_links"
    include_next_steps: true

  # Example phrases to use
  preferred_phrases:
    starting: "I'll proceed with complete implementation of {feature}"
    checkpoint: "Before proceeding to {next_step}, confirming {decision}"
    completion: "✅ {feature} complete - all checks passing"
    permission: "When PR is mergeable, I can merge it if you approve"

  # Example phrases to avoid
  avoid_phrases:
    - "I've implemented part of..." # User expects complete
    - "Should I continue?" # Proceed autonomously unless checkpoint
    - "This might take a while" # User expects thoroughness

# Workflow Adherence
workflow:
  # Strict adherence required (1 explicit correction observed)
  adherence_level: "strict"

  # Default workflow
  default_workflow: ".claude/workflow/DEFAULT_WORKFLOW.md"

  # Workflow deviation handling
  deviation_handling:
    allowed: false
    checkpoint_required: true
    document_reason: true

  # Red flag: User correction observed
  workflow_boundary:
    trigger_phrase: "always supposed to follow the workflow"
    observed_count: 1
    severity: "critical_boundary"
    action: "never_deviate_without_permission"

# Learning System
learning:
  # Track corrections for pattern refinement
  track_corrections: true

  # Correction types to monitor
  correction_types:
    incomplete_work: "critical"
    workflow_deviation: "critical"
    phase_mixing: "high"
    premature_merge: "medium"

  # Learning signals
  strong_signals:
    - pattern: "I'm not going to merge incomplete work"
      interpretation: "complete_scope_required"
      confidence: "critical"

    - pattern: "keep the phase 1 pr separate"
      interpretation: "phase_separation_required"
      confidence: "high"

    - pattern: "always supposed to follow"
      interpretation: "workflow_adherence_required"
      confidence: "critical"

# Task Distribution (observed patterns)
task_priorities:
  # Primary focus areas (>70% of requests)
  primary:
    - git_operations: 91.0
    - ci_cd: 78.4
    - documentation: 75.0
    - implementation: 74.8
    - analysis: 74.8

  # Common action verbs
  common_verbs:
    - run: 77.0
    - implement: 74.4
    - create: 74.4
    - check: 73.9
    - update: 73.8

# Confidence Levels
confidence:
  # High confidence patterns (>100 observations)
  high:
    - complete_scope_preference
    - quality_emphasis
    - git_workflow_focus
    - polite_but_firm_communication

  # Medium confidence patterns (20-100 observations)
  medium:
    - autonomy_checkpoint_balance
    - merge_delegation_patterns
    - phase_separation_rules

  # Low confidence patterns (<20 observations)
  low:
    - minimal_scope_triggers
    - error_recovery_preferences
    - debug_methodology

# Version and Metadata
metadata:
  version: "1.0"
  generated: "2025-11-22"
  source: "claude-trace-logs"
  samples: 1205
  confidence: "high"
  validation_status: "pending_user_review"
  next_review: "2025-12-22"

#!/usr/bin/env python3
"""Batch process backlog items with resumable state tracking.

Pattern: Amplifier P2 - Iterative Status Tracking for Batch Operations
Handles 100+ items with state persistence and resume capability.

This is a library module providing the BatchProcessor class.
Import and use in your own scripts with a real processor function.

Library Usage:
    from batch_process import BatchProcessor

    def my_processor(item):
        # Your actual processing logic here
        return {"result": process(item)}

    processor = BatchProcessor(Path.cwd(), "my_processor")
    results = processor.process_items(items, my_processor, batch_size=10)

CLI Usage (status/reset only):
    python batch_process.py --status [--processor NAME]
    python batch_process.py --reset --processor NAME
"""

import argparse
import json
import sys
from collections.abc import Callable
from datetime import UTC, datetime
from pathlib import Path
from typing import Any

import yaml


def load_yaml(path: Path) -> dict[str, Any]:
    """Load YAML file safely."""
    if not path.exists():
        return {}
    with open(path) as f:
        return yaml.safe_load(f) or {}


def save_yaml(path: Path, data: dict[str, Any]) -> None:
    """Save YAML file."""
    path.parent.mkdir(parents=True, exist_ok=True)
    with open(path, "w") as f:
        yaml.dump(data, f, default_flow_style=False, sort_keys=False)


def get_timestamp() -> str:
    """Get current UTC timestamp."""
    return datetime.now(UTC).isoformat().replace("+00:00", "Z")


class BatchProcessor:
    """Process large collections with state tracking and resumption."""

    def __init__(self, project_root: Path, processor_name: str):
        """Initialize batch processor.

        Args:
            project_root: Project root directory
            processor_name: Name of processing script (e.g., "analyze_backlog")
        """
        self.project_root = project_root
        self.pm_dir = project_root / ".pm"
        self.processor_name = processor_name
        self.status_file = self.pm_dir / f"batch_status_{processor_name}.yaml"
        self.state = self.load_state()

    def load_state(self) -> dict:
        """Load batch processing state."""
        if self.status_file.exists():
            return load_yaml(self.status_file)

        return {
            "processor": self.processor_name,
            "started_at": get_timestamp(),
            "last_run": None,
            "processed": [],
            "failed": [],
            "last_id": None,
            "total_processed": 0,
            "total_failed": 0,
            "completed": False,
        }

    def save_state(self):
        """Persist state after each item (critical for resumption)."""
        self.state["last_run"] = get_timestamp()
        save_yaml(self.status_file, self.state)

    def is_processed(self, item_id: str) -> bool:
        """Check if item already processed."""
        return item_id in self.state["processed"] or item_id in [
            f["id"] for f in self.state["failed"]
        ]

    def mark_processed(self, item_id: str, result: dict = None):
        """Mark item as successfully processed."""
        if item_id not in self.state["processed"]:
            self.state["processed"].append(item_id)
            self.state["last_id"] = item_id
            self.state["total_processed"] += 1
            self.save_state()  # Save after EACH item

    def mark_failed(self, item_id: str, error: str):
        """Mark item as failed with error details."""
        failure = {"id": item_id, "error": error, "timestamp": get_timestamp()}

        # Update or add failure
        existing = next((f for f in self.state["failed"] if f["id"] == item_id), None)
        if existing:
            existing["error"] = error
            existing["timestamp"] = failure["timestamp"]
        else:
            self.state["failed"].append(failure)

        self.state["last_id"] = item_id
        self.state["total_failed"] += 1
        self.save_state()  # Save after EACH failure

    def process_items(
        self, items: list[dict], processor_func: Callable[[dict], dict], batch_size: int = 10
    ) -> dict:
        """Process items in batches with state tracking.

        Args:
            items: List of items to process
            processor_func: Function that processes single item
            batch_size: Number of items per progress report

        Returns:
            Summary of processing results
        """
        results = {"succeeded": [], "failed": [], "skipped": []}

        total = len(items)
        processed_count = 0

        for i, item in enumerate(items):
            item_id = item.get("id", f"item-{i}")

            # Skip already processed
            if self.is_processed(item_id):
                results["skipped"].append(item_id)
                continue

            try:
                # Process single item
                result = processor_func(item)
                self.mark_processed(item_id, result)
                results["succeeded"].append({"id": item_id, "result": result})

                processed_count += 1

                # Progress report every batch_size items
                if processed_count % batch_size == 0:
                    progress = (i + 1) / total * 100
                    print(
                        f"Progress: {i + 1}/{total} ({progress:.1f}%) - "
                        f"{processed_count} processed, {len(results['failed'])} failed",
                        file=sys.stderr,
                    )

            except Exception as e:
                error_msg = str(e)
                self.mark_failed(item_id, error_msg)
                results["failed"].append({"id": item_id, "error": error_msg})

        # Mark as completed
        self.state["completed"] = True
        self.save_state()

        return {
            "total_items": total,
            "processed": len(results["succeeded"]),
            "failed": len(results["failed"]),
            "skipped": len(results["skipped"]),
            "results": results,
            "state_file": str(self.status_file),
        }

    def reset_state(self):
        """Reset batch processing state (for retry)."""
        if self.status_file.exists():
            self.status_file.unlink()
        self.state = self.load_state()

    def get_progress(self) -> dict:
        """Get current progress information."""
        return {
            "processor": self.processor_name,
            "started_at": self.state.get("started_at"),
            "last_run": self.state.get("last_run"),
            "total_processed": self.state["total_processed"],
            "total_failed": self.state["total_failed"],
            "completed": self.state.get("completed", False),
            "last_id": self.state.get("last_id"),
        }


def main():
    """Main entry point for CLI usage."""
    parser = argparse.ArgumentParser(
        description="Batch process items with resumable state tracking"
    )
    parser.add_argument(
        "--project-root", type=Path, default=Path.cwd(), help="Project root directory"
    )
    parser.add_argument(
        "--processor", required=True, help="Processor name (e.g., 'analyze_backlog')"
    )
    parser.add_argument("--batch-size", type=int, default=10, help="Progress report interval")
    parser.add_argument("--reset", action="store_true", help="Reset state and start fresh")
    parser.add_argument("--status", action="store_true", help="Show current progress")

    args = parser.parse_args()

    try:
        processor = BatchProcessor(args.project_root, args.processor)

        if args.reset:
            processor.reset_state()
            print(json.dumps({"status": "reset", "processor": args.processor}))
            return 0

        if args.status:
            progress = processor.get_progress()
            print(json.dumps(progress, indent=2))
            return 0

        # This script provides the BatchProcessor class for use by other scripts
        # It is not meant to be run directly - import BatchProcessor and provide
        # your own processor function that implements real business logic
        print(
            json.dumps(
                {
                    "error": "batch_process.py is a library module, not a standalone script",
                    "usage": "Import BatchProcessor class and provide your own processor function",
                    "example": "from batch_process import BatchProcessor; processor = BatchProcessor(...)",
                }
            ),
            file=sys.stderr,
        )
        return 1

    except Exception as e:
        print(json.dumps({"error": str(e)}), file=sys.stderr)
        return 1


if __name__ == "__main__":
    sys.exit(main())

#!/usr/bin/env python3
"""
PM Architect - Label-Triggered Delegation.

Handles pm:delegate label by preparing context and spawning auto mode
to generate response for issues or PRs.
"""

import argparse
import json
import os
import subprocess
import sys
from pathlib import Path


def get_issue_pr_details(project_root: Path, number: int, item_type: str) -> dict | None:
    """Get issue or PR details using gh CLI.

    Args:
        project_root: Project root directory
        number: Issue or PR number
        item_type: Either 'issue' or 'pr'

    Returns:
        Dictionary with details, or None if retrieval fails
    """
    try:
        cmd = ["gh", item_type, "view", str(number), "--json", "number,title,author,body,comments"]

        result = subprocess.run(cmd, cwd=project_root, capture_output=True, text=True, timeout=15)

        if result.returncode == 0:
            return json.loads(result.stdout)

        print(f"Error: gh {item_type} view failed: {result.stderr}", file=sys.stderr)
        return None

    except Exception as e:
        print(f"Error retrieving {item_type} details: {e}", file=sys.stderr)
        return None


def prepare_delegation_prompt(details: dict, number: int, item_type: str) -> str:
    """Prepare delegation prompt from issue/PR details.

    Args:
        details: Issue/PR details from GitHub
        number: Issue/PR number
        item_type: 'issue' or 'pr'

    Returns:
        Formatted delegation prompt
    """
    title = details.get("title", "")
    body = details.get("body", "") or "(No description provided)"
    comments = details.get("comments", [])
    latest_comment = comments[-1]["body"] if comments else None

    prompt = f"""PM Architect Delegation Request

**Context**: {item_type.upper()} #{number}
**Title**: {title}

**Description**:
{body}
"""

    if latest_comment:
        prompt += f"""
**Latest Comment**:
{latest_comment}
"""

    prompt += """
**Task**: Analyze this request and provide a comprehensive response. Consider:
1. What is being requested?
2. What information or action is needed?
3. What is the best approach to address this?
4. Are there any blockers or dependencies?
5. What are the next steps?

Provide a clear, actionable response that addresses the request.
"""

    return prompt


def run_auto_mode_delegation(
    prompt: str, project_root: Path, max_turns: int = 5
) -> tuple[bool, str]:
    """Run amplihack auto mode with delegation prompt.

    Args:
        prompt: Delegation prompt to execute
        project_root: Project root directory
        max_turns: Maximum auto mode turns

    Returns:
        Tuple of (success: bool, output: str)
    """
    try:
        # Run amplihack auto mode with the active agent binary
        agent_binary = os.environ.get("AMPLIHACK_AGENT_BINARY") or "claude"
        cmd = ["amplihack", agent_binary, "--auto", "--max-turns", str(max_turns), "--", "-p", prompt]

        result = subprocess.run(
            cmd,
            cwd=project_root,
            capture_output=True,
            text=True,
            timeout=600,  # 10 min timeout
        )

        # Auto mode may return non-zero but still produce output
        output = result.stdout + result.stderr

        # Check if output looks reasonable
        if len(output) > 100:  # At least some content
            return True, output
        return False, f"Auto mode produced insufficient output:\n{output}"

    except subprocess.TimeoutExpired:
        return False, "Auto mode execution timed out (10 minutes)"
    except Exception as e:
        return False, f"Auto mode execution failed: {e}"


def format_response_for_github(output: str) -> str:
    """Format auto mode output for GitHub comment.

    Args:
        output: Raw auto mode output

    Returns:
        Formatted markdown for GitHub comment
    """
    # Add header
    formatted = """## 🤖 PM Architect Delegation Response

*This response was generated automatically by PM Architect via the `pm:delegate` label.*

---

"""

    # Add the output (take last reasonable portion to avoid noise)
    lines = output.split("\n")

    # Try to find the start of meaningful content (skip initialization)
    start_idx = 0
    for i, line in enumerate(lines):
        if "AUTONOMOUS MODE" in line or "Auto mode" in line:
            start_idx = i
            break

    # Take from meaningful start, limit to last 200 lines max
    meaningful_lines = lines[start_idx:]
    if len(meaningful_lines) > 200:
        meaningful_lines = meaningful_lines[-200:]

    formatted += "\n".join(meaningful_lines)

    # Add footer
    formatted += """

---

*To continue the conversation or provide feedback, reply to this comment or use the `pm:delegate` label again.*
"""

    return formatted


def main():
    """Main execution."""
    parser = argparse.ArgumentParser(description="PM Architect Label-Triggered Delegation")
    parser.add_argument("number", type=int, help="Issue or PR number")
    parser.add_argument("type", choices=["issue", "pr"], help="Type: issue or pr")
    parser.add_argument("--project-root", type=Path, default=Path.cwd(), help="Project root")
    parser.add_argument("--output", type=Path, required=True, help="Output file for response")
    parser.add_argument("--max-turns", type=int, default=5, help="Max auto mode turns")

    args = parser.parse_args()

    # Get issue/PR details
    print(f"Fetching {args.type} #{args.number} details...")
    details = get_issue_pr_details(args.project_root, args.number, args.type)

    if not details:
        print(f"Error: Could not fetch {args.type} details", file=sys.stderr)
        sys.exit(1)

    # Prepare delegation prompt
    print("Preparing delegation prompt...")
    prompt = prepare_delegation_prompt(details, args.number, args.type)

    # Run auto mode
    print(f"Running auto mode delegation (max {args.max_turns} turns)...")
    success, output = run_auto_mode_delegation(prompt, args.project_root, args.max_turns)

    if not success:
        print(f"Error: Auto mode failed: {output}", file=sys.stderr)
        # Write error response
        error_response = f"""## ❌ PM Architect Delegation Failed

The PM Architect delegation encountered an error:

```
{output}
```

Please check the workflow logs for more details or try again.
"""
        args.output.write_text(error_response)
        sys.exit(1)

    # Format and save response
    print("Formatting response for GitHub...")
    formatted_response = format_response_for_github(output)
    args.output.write_text(formatted_response)

    print(f"Delegation response written to {args.output}")
    print("Success!")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
PM Architect - Daily Status Report Generation using Claude Agent SDK.

Uses Claude Agent SDK to analyze project state and generate comprehensive
daily status reports with insights, blockers, and recommendations.
"""

import asyncio
import json
import os
import sys
from pathlib import Path

# Unset CLAUDECODE to prevent nested session errors when spawning Claude CLI subprocesses
os.environ.pop("CLAUDECODE", None)

# Try to import Claude SDK
try:
    from claude_agent_sdk import ClaudeAgentOptions, query

    CLAUDE_SDK_AVAILABLE = True
except ImportError:
    CLAUDE_SDK_AVAILABLE = False


def load_project_state(project_root: Path) -> dict | None:
    """Load PM state files for analysis.

    Args:
        project_root: Project root directory

    Returns:
        Dictionary with backlog, workstreams, and metrics, or None if not found
    """
    pm_state_dir = project_root / ".claude" / "pm_state"

    if not pm_state_dir.exists():
        return None

    state = {}

    # Load backlog
    backlog_file = pm_state_dir / "backlog.yaml"
    if backlog_file.exists():
        import yaml

        with open(backlog_file) as f:
            state["backlog"] = yaml.safe_load(f)

    # Load workstreams
    workstreams_file = pm_state_dir / "workstreams.yaml"
    if workstreams_file.exists():
        import yaml

        with open(workstreams_file) as f:
            state["workstreams"] = yaml.safe_load(f)

    # Load project config
    config_file = pm_state_dir / "project_config.yaml"
    if config_file.exists():
        import yaml

        with open(config_file) as f:
            state["config"] = yaml.safe_load(f)

    return state if state else None


def get_recent_git_activity(project_root: Path) -> str:
    """Get recent git commits and branch activity.

    Args:
        project_root: Project root directory

    Returns:
        Formatted string with recent git activity
    """
    import subprocess

    try:
        # Get recent commits (last 24 hours)
        result = subprocess.run(
            [
                "git",
                "log",
                "--oneline",
                "--since=24 hours ago",
                "--all",
                "--decorate",
                "--max-count=20",
            ],
            cwd=project_root,
            capture_output=True,
            text=True,
            timeout=10,
        )

        if result.returncode == 0 and result.stdout.strip():
            commits = result.stdout.strip()
            return f"""
## Recent Git Activity (Last 24 Hours)

```
{commits}
```
"""

        return "\n## Recent Git Activity\n\nNo commits in the last 24 hours.\n"

    except Exception as e:
        return f"\n## Recent Git Activity\n\nUnable to retrieve: {e}\n"


def get_open_prs_and_issues(project_root: Path) -> str:
    """Get count of open PRs and issues.

    Args:
        project_root: Project root directory

    Returns:
        Formatted string with PR/issue counts
    """
    import subprocess

    try:
        # Try to use gh CLI
        result = subprocess.run(
            ["gh", "pr", "list", "--json", "number,title,state"],
            cwd=project_root,
            capture_output=True,
            text=True,
            timeout=10,
        )

        prs = []
        if result.returncode == 0:
            prs = json.loads(result.stdout)

        result = subprocess.run(
            ["gh", "issue", "list", "--json", "number,title,state"],
            cwd=project_root,
            capture_output=True,
            text=True,
            timeout=10,
        )

        issues = []
        if result.returncode == 0:
            issues = json.loads(result.stdout)

        return f"""
## Open PRs and Issues

- **Open PRs**: {len(prs)}
- **Open Issues**: {len(issues)}
"""

    except Exception:
        return "\n## Open PRs and Issues\n\nUnable to retrieve (gh CLI not available)\n"


async def generate_status_report(project_root: Path, state: dict | None = None) -> str | None:
    """Generate daily status report using Claude Agent SDK.

    Args:
        project_root: Project root directory
        state: Optional pre-loaded project state

    Returns:
        Markdown status report, or None if generation fails
    """
    if not CLAUDE_SDK_AVAILABLE:
        print("Error: Claude SDK not available", file=sys.stderr)
        return None

    # Load state if not provided
    if state is None:
        state = load_project_state(project_root)

    # Gather context
    git_activity = get_recent_git_activity(project_root)
    prs_issues = get_open_prs_and_issues(project_root)

    # Format state for analysis
    state_context = ""
    if state:
        state_context = f"""
## Current Project State

### Backlog Summary
{json.dumps(state.get("backlog", {}), indent=2)}

### Active Workstreams
{json.dumps(state.get("workstreams", {}), indent=2)}

### Project Configuration
{json.dumps(state.get("config", {}), indent=2)}
"""
    else:
        state_context = "\n## Current Project State\n\nNo PM state files found. This may be a new project or PM Architect has not been initialized.\n"

    # Build comprehensive prompt
    prompt = f"""You are the PM Architect analyzing project status for a daily status report.

{state_context}

{git_activity}

{prs_issues}

## Task

Generate a comprehensive daily status report in markdown format with the following sections:

1. **Executive Summary** (2-3 sentences)
   - Overall project health
   - Key accomplishments in last 24 hours
   - Critical issues requiring attention

2. **Workstream Status**
   - List each active workstream with status (RUNNING/BLOCKED/COMPLETED)
   - Progress indicators
   - Blockers or risks

3. **Backlog Health**
   - Number of items by priority (HIGH/MEDIUM/LOW)
   - Items marked as READY vs BLOCKED
   - Recommended focus areas

4. **Velocity and Metrics**
   - Items completed in last 24 hours
   - Items added to backlog
   - Trend analysis (velocity increasing/stable/declining)

5. **Blockers and Risks**
   - Critical blockers requiring immediate attention
   - Risk items that could impact delivery
   - Dependencies waiting on external factors

6. **Recommendations**
   - Top 3 priorities for the next 24 hours
   - Suggested actions for PM or team
   - Items that should be escalated

7. **Next Review**
   - Key milestones to track
   - Expected deliverables in next 24 hours

Use markdown formatting with clear headers, bullet points, and emphasis where appropriate.
Be concise but informative. Use emojis sparingly for visual clarity (✅, ⚠️, 🚫, 📊).

Generate the report now:
"""

    try:
        # Configure SDK
        options = ClaudeAgentOptions(
            cwd=str(project_root),
            permission_mode="bypassPermissions",
        )

        # Collect response
        response_parts = []
        async for message in query(prompt=prompt, options=options):
            if hasattr(message, "text"):
                response_parts.append(message.text)
            elif hasattr(message, "content"):
                response_parts.append(str(message.content))

        # Join all parts
        report = "".join(response_parts)
        return report if report.strip() else None

    except Exception as e:
        print(f"Error generating status report: {e}", file=sys.stderr)
        return None


def main():
    """Main entry point for daily status generation."""
    import argparse

    parser = argparse.ArgumentParser(
        description="Generate daily PM status report using Claude Agent SDK"
    )
    parser.add_argument(
        "--project-root",
        type=Path,
        default=Path.cwd(),
        help="Project root directory (default: current directory)",
    )
    parser.add_argument(
        "--output",
        type=Path,
        help="Output file path (default: stdout)",
    )

    args = parser.parse_args()

    if not CLAUDE_SDK_AVAILABLE:
        print("Error: claude-agent-sdk not installed", file=sys.stderr)
        print("Install with: pip install claude-agent-sdk", file=sys.stderr)
        sys.exit(1)

    # Generate report
    report = asyncio.run(generate_status_report(args.project_root))

    if not report:
        print("Error: Failed to generate status report", file=sys.stderr)
        sys.exit(1)

    # Output report
    if args.output:
        args.output.write_text(report)
        print(f"Status report written to {args.output}", file=sys.stderr)
    else:
        print(report)

    sys.exit(0)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
PM Architect - Weekly Roadmap Review using Claude Agent SDK.

Uses Claude Agent SDK to analyze roadmap alignment, goal progress, and
generate strategic recommendations for project direction.
"""

import asyncio
import json
import os
import sys
from pathlib import Path

# Unset CLAUDECODE to prevent nested session errors when spawning Claude CLI subprocesses
os.environ.pop("CLAUDECODE", None)

# Try to import Claude SDK
try:
    from claude_agent_sdk import ClaudeAgentOptions, query

    CLAUDE_SDK_AVAILABLE = True
except ImportError:
    CLAUDE_SDK_AVAILABLE = False


def load_project_state(project_root: Path) -> dict | None:
    """Load PM state files for analysis.

    Args:
        project_root: Project root directory

    Returns:
        Dictionary with backlog, workstreams, and metrics, or None if not found
    """
    pm_state_dir = project_root / ".claude" / "pm_state"

    if not pm_state_dir.exists():
        return None

    state = {}

    # Load backlog
    backlog_file = pm_state_dir / "backlog.yaml"
    if backlog_file.exists():
        import yaml

        with open(backlog_file) as f:
            state["backlog"] = yaml.safe_load(f)

    # Load workstreams
    workstreams_file = pm_state_dir / "workstreams.yaml"
    if workstreams_file.exists():
        import yaml

        with open(workstreams_file) as f:
            state["workstreams"] = yaml.safe_load(f)

    # Load project config
    config_file = pm_state_dir / "project_config.yaml"
    if config_file.exists():
        import yaml

        with open(config_file) as f:
            state["config"] = yaml.safe_load(f)

    return state if state else None


def get_git_velocity_metrics(project_root: Path) -> str:
    """Get git-based velocity metrics (commits, PRs merged).

    Args:
        project_root: Project root directory

    Returns:
        Formatted string with velocity metrics
    """
    import subprocess
    from datetime import datetime, timedelta

    try:
        # Get commits in last 7 days
        week_ago = (datetime.now() - timedelta(days=7)).strftime("%Y-%m-%d")
        result = subprocess.run(
            [
                "git",
                "log",
                "--oneline",
                f"--since={week_ago}",
                "--all",
            ],
            cwd=project_root,
            capture_output=True,
            text=True,
            timeout=10,
        )

        commit_count = 0
        if result.returncode == 0:
            commit_count = len(result.stdout.strip().split("\n")) if result.stdout.strip() else 0

        # Get merged PRs in last 7 days using gh CLI
        pr_count = 0
        try:
            pr_result = subprocess.run(
                [
                    "gh",
                    "pr",
                    "list",
                    "--state",
                    "merged",
                    "--json",
                    "number,mergedAt",
                    "--limit",
                    "100",
                ],
                cwd=project_root,
                capture_output=True,
                text=True,
                timeout=10,
            )

            if pr_result.returncode == 0:
                prs = json.loads(pr_result.stdout)
                # Count PRs merged in last 7 days
                week_ago_dt = datetime.now() - timedelta(days=7)
                pr_count = sum(
                    1
                    for pr in prs
                    if pr.get("mergedAt")
                    and datetime.fromisoformat(pr["mergedAt"].replace("Z", "+00:00")) > week_ago_dt
                )
        except Exception:
            pass

        return f"""
## Velocity Metrics (Last 7 Days)

- **Commits**: {commit_count}
- **PRs Merged**: {pr_count}
- **Daily Average**: {commit_count / 7:.1f} commits/day
"""

    except Exception as e:
        return f"\n## Velocity Metrics\n\nUnable to retrieve: {e}\n"


def get_milestone_progress(project_root: Path) -> str:
    """Get milestone and project progress.

    Args:
        project_root: Project root directory

    Returns:
        Formatted string with milestone progress
    """
    import subprocess

    try:
        # Get milestones using gh CLI
        result = subprocess.run(
            ["gh", "api", "repos/:owner/:repo/milestones", "--jq", "."],
            cwd=project_root,
            capture_output=True,
            text=True,
            timeout=10,
        )

        if result.returncode == 0:
            milestones = json.loads(result.stdout)
            if milestones:
                milestone_info = []
                for milestone in milestones[:5]:  # Limit to 5 most recent
                    title = milestone.get("title", "Unknown")
                    open_issues = milestone.get("open_issues", 0)
                    closed_issues = milestone.get("closed_issues", 0)
                    total = open_issues + closed_issues
                    progress = (closed_issues / total * 100) if total > 0 else 0
                    milestone_info.append(
                        f"- **{title}**: {closed_issues}/{total} ({progress:.0f}%)"
                    )

                return f"""
## Milestone Progress

{chr(10).join(milestone_info)}
"""

        return "\n## Milestone Progress\n\nNo active milestones found.\n"

    except Exception:
        return "\n## Milestone Progress\n\nUnable to retrieve (gh CLI not available)\n"


async def generate_roadmap_review(project_root: Path, state: dict | None = None) -> str | None:
    """Generate weekly roadmap review using Claude Agent SDK.

    Args:
        project_root: Project root directory
        state: Optional pre-loaded project state

    Returns:
        Markdown roadmap review, or None if generation fails
    """
    if not CLAUDE_SDK_AVAILABLE:
        print("Error: Claude SDK not available", file=sys.stderr)
        return None

    # Load state if not provided
    if state is None:
        state = load_project_state(project_root)

    # Gather context
    velocity_metrics = get_git_velocity_metrics(project_root)
    milestone_progress = get_milestone_progress(project_root)

    # Format state for analysis
    state_context = ""
    if state:
        config = state.get("config", {})
        goals = config.get("goals", [])

        state_context = f"""
## Project Configuration

**Project Name**: {config.get("name", "Unknown")}
**Project Type**: {config.get("type", "Unknown")}
**Quality Bar**: {config.get("quality_bar", "Unknown")}

**Project Goals**:
{chr(10).join(f"- {goal}" for goal in goals) if goals else "- No goals defined"}

## Current Project State

### Backlog Summary
{json.dumps(state.get("backlog", {}), indent=2)}

### Active Workstreams
{json.dumps(state.get("workstreams", {}), indent=2)}
"""
    else:
        state_context = "\n## Current Project State\n\nNo PM state files found. This may be a new project or PM Architect has not been initialized.\n"

    # Build comprehensive prompt
    from datetime import datetime

    week_num = datetime.now().strftime("%Y-W%V")

    prompt = f"""You are the PM Architect performing a strategic weekly roadmap review.

{state_context}

{velocity_metrics}

{milestone_progress}

## Task

Generate a comprehensive weekly roadmap review in markdown format for **Week {week_num}** with the following sections:

1. **Executive Summary** (3-4 sentences)
   - Overall strategic health of the project
   - Alignment with project goals
   - Key achievements this week
   - Critical strategic concerns

2. **Goal Progress Analysis**
   - For each project goal, assess:
     - Current status (On Track / At Risk / Blocked)
     - Progress made this week
     - Remaining work estimate
     - Blockers or dependencies
   - If no goals defined, recommend creating strategic goals

3. **Velocity and Capacity Analysis**
   - Analyze velocity trends (improving/stable/declining)
   - Compare actual vs planned velocity
   - Team capacity assessment
   - Bottleneck identification
   - Recommendations for velocity improvement

4. **Roadmap Alignment**
   - Are current workstreams aligned with project goals?
   - Are we working on the right things?
   - Should priorities be adjusted?
   - Recommended focus shifts

5. **Strategic Risks and Opportunities**
   - Technical debt accumulation
   - Dependencies on external factors
   - Market or competitive considerations
   - Opportunities to accelerate delivery
   - Resource constraints

6. **Milestone and Release Planning**
   - Progress toward next milestone/release
   - Are we on track for commitments?
   - Should milestone dates be adjusted?
   - Recommended scope adjustments

7. **Recommendations for Next Week**
   - Top 3-5 strategic priorities
   - Backlog grooming needs
   - Team focus areas
   - Process improvements
   - Items requiring stakeholder decisions

8. **Long-term Outlook** (2-4 weeks ahead)
   - Upcoming challenges or opportunities
   - Planning needs
   - Resource requirements

Use markdown formatting with clear headers, bullet points, and emphasis where appropriate.
Be strategic and forward-looking. Use emojis sparingly for visual clarity (✅, ⚠️, 🚫, 📊, 🎯, 🚀).

Generate the roadmap review now:
"""

    try:
        # Configure SDK
        options = ClaudeAgentOptions(
            cwd=str(project_root),
            permission_mode="bypassPermissions",
        )

        # Collect response
        response_parts = []
        async for message in query(prompt=prompt, options=options):
            if hasattr(message, "text"):
                response_parts.append(message.text)
            elif hasattr(message, "content"):
                response_parts.append(str(message.content))

        # Join all parts
        review = "".join(response_parts)
        return review if review.strip() else None

    except Exception as e:
        print(f"Error generating roadmap review: {e}", file=sys.stderr)
        return None


def main():
    """Main entry point for roadmap review generation."""
    import argparse

    parser = argparse.ArgumentParser(
        description="Generate weekly roadmap review using Claude Agent SDK"
    )
    parser.add_argument(
        "--project-root",
        type=Path,
        default=Path.cwd(),
        help="Project root directory (default: current directory)",
    )
    parser.add_argument(
        "--output",
        type=Path,
        help="Output file path (default: stdout)",
    )

    args = parser.parse_args()

    if not CLAUDE_SDK_AVAILABLE:
        print("Error: claude-agent-sdk not installed", file=sys.stderr)
        print("Install with: pip install claude-agent-sdk", file=sys.stderr)
        sys.exit(1)

    # Generate review
    review = asyncio.run(generate_roadmap_review(args.project_root))

    if not review:
        print("Error: Failed to generate roadmap review", file=sys.stderr)
        sys.exit(1)

    # Output review
    if args.output:
        args.output.write_text(review)
        print(f"Roadmap review written to {args.output}", file=sys.stderr)
    else:
        print(review)

    sys.exit(0)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Aggregate priorities across GitHub accounts into a strict Top 5 ranked list.

Queries GitHub issues and PRs across configured accounts/repos, scores them
by priority labels, staleness, blocking status, and roadmap alignment.

Falls back to .pm/ YAML state if GitHub is unavailable or for enrichment.

Usage:
    python generate_top5.py [--project-root PATH] [--sources PATH]

Returns JSON with top 5 priorities.
"""

import argparse
import json
import subprocess
import sys
from datetime import UTC, datetime
from pathlib import Path
from typing import Any

import yaml


# Aggregation weights
WEIGHT_ISSUES = 0.40
WEIGHT_PRS = 0.30
WEIGHT_ROADMAP = 0.20
WEIGHT_LOCAL = 0.10  # .pm/ overrides

TOP_N = 5

# Label-to-priority mapping
PRIORITY_LABELS = {
    "critical": 1.0,
    "priority:critical": 1.0,
    "high": 0.9,
    "priority:high": 0.9,
    "bug": 0.8,
    "medium": 0.6,
    "priority:medium": 0.6,
    "enhancement": 0.5,
    "feature": 0.5,
    "low": 0.3,
    "priority:low": 0.3,
}


def load_yaml(path: Path) -> dict[str, Any]:
    """Load YAML file safely."""
    if not path.exists():
        return {}
    with open(path) as f:
        return yaml.safe_load(f) or {}


def load_sources(sources_path: Path) -> list[dict]:
    """Load GitHub source configuration."""
    data = load_yaml(sources_path)
    return data.get("github", [])


def run_gh(args: list[str], account: str | None = None) -> str | None:
    """Run a gh CLI command, optionally switching account first.

    Returns stdout on success, None on failure.
    """
    if account:
        switch = subprocess.run(
            ["gh", "auth", "switch", "--user", account],
            capture_output=True, text=True, timeout=10,
        )
        if switch.returncode != 0:
            return None

    try:
        result = subprocess.run(
            ["gh"] + args,
            capture_output=True, text=True, timeout=30,
        )
        if result.returncode != 0:
            return None
        return result.stdout.strip()
    except (subprocess.TimeoutExpired, FileNotFoundError):
        return None


def get_current_gh_account() -> str | None:
    """Get the currently active gh account."""
    try:
        result = subprocess.run(
            ["gh", "api", "user", "--jq", ".login"],
            capture_output=True, text=True, timeout=10,
        )
        if result.returncode == 0 and result.stdout.strip():
            return result.stdout.strip()
    except (subprocess.TimeoutExpired, FileNotFoundError):
        pass
    return None


def fetch_github_issues(account: str, repos: list[str]) -> list[dict]:
    """Fetch open issues for an account's repos from GitHub."""
    candidates = []

    # Use search API to get all issues at once
    repo_qualifiers = " ".join(f"repo:{r}" if "/" in r else f"repo:{account}/{r}" for r in repos)
    query = f"is:open is:issue {repo_qualifiers}"

    jq_filter = (
        '.items[] | {'
        'repo: (.repository_url | split("/") | .[-2:] | join("/")),'
        'title: .title,'
        'labels: [.labels[].name],'
        'created: .created_at,'
        'updated: .updated_at,'
        'number: .number,'
        'comments: .comments'
        '}'
    )

    output = run_gh(
        ["api", "search/issues", "--method", "GET",
         "-f", f"q={query}", "-f", "per_page=50",
         "--jq", jq_filter],
        account=account,
    )

    if not output:
        return []

    now = datetime.now(UTC)

    for line in output.strip().splitlines():
        try:
            item = json.loads(line)
        except json.JSONDecodeError:
            continue

        # Score by labels
        labels = [lbl.lower() for lbl in item.get("labels", [])]
        priority_score = 0.5  # default
        for label in labels:
            if label in PRIORITY_LABELS:
                priority_score = max(priority_score, PRIORITY_LABELS[label])

        # Staleness boost: older updated = needs attention
        try:
            updated = datetime.fromisoformat(item["updated"].replace("Z", "+00:00"))
            days_stale = (now - updated).total_seconds() / 86400
        except (ValueError, KeyError):
            days_stale = 0

        staleness_score = min(days_stale / 14.0, 1.0)  # Max at 2 weeks

        # Comment activity: more comments = more discussion = potentially blocked
        comments = item.get("comments", 0)
        activity_score = min(comments / 10.0, 1.0)

        raw_score = (priority_score * 0.50 + staleness_score * 0.30 + activity_score * 0.20) * 100

        # Rationale
        reasons = []
        if priority_score >= 0.8:
            reasons.append(f"labeled {', '.join(lbl for lbl in labels if lbl in PRIORITY_LABELS)}")
        if days_stale > 7:
            reasons.append(f"stale {days_stale:.0f}d")
        if comments > 3:
            reasons.append(f"{comments} comments")
        if not reasons:
            reasons.append("open issue")

        repo = item.get("repo", "")
        candidates.append({
            "title": item["title"],
            "source": "github_issue",
            "raw_score": round(raw_score, 1),
            "score_breakdown": {
                "label_priority": round(priority_score, 2),
                "staleness": round(staleness_score, 2),
                "activity": round(activity_score, 2),
            },
            "rationale": ", ".join(reasons),
            "item_id": f"{repo}#{item['number']}",
            "priority": "HIGH" if priority_score >= 0.8 else "MEDIUM" if priority_score >= 0.5 else "LOW",
            "repo": repo,
            "account": account,
            "url": f"https://github.com/{repo}/issues/{item['number']}",
            "labels": item.get("labels", []),
            "created": item.get("created", ""),
            "updated": item.get("updated", ""),
            "days_stale": round(days_stale, 1),
            "comments": comments,
        })

    return candidates


def fetch_github_prs(account: str, repos: list[str]) -> list[dict]:
    """Fetch open PRs for an account's repos from GitHub."""
    candidates = []

    repo_qualifiers = " ".join(f"repo:{r}" if "/" in r else f"repo:{account}/{r}" for r in repos)
    query = f"is:open is:pr {repo_qualifiers}"

    jq_filter = (
        '.items[] | {'
        'repo: (.repository_url | split("/") | .[-2:] | join("/")),'
        'title: .title,'
        'labels: [.labels[].name],'
        'created: .created_at,'
        'updated: .updated_at,'
        'number: .number,'
        'draft: .draft,'
        'comments: .comments'
        '}'
    )

    output = run_gh(
        ["api", "search/issues", "--method", "GET",
         "-f", f"q={query}", "-f", "per_page=50",
         "--jq", jq_filter],
        account=account,
    )

    if not output:
        return []

    now = datetime.now(UTC)

    for line in output.strip().splitlines():
        try:
            item = json.loads(line)
        except json.JSONDecodeError:
            continue

        is_draft = item.get("draft", False)

        # PRs waiting for review are higher priority than drafts
        base_score = 0.4 if is_draft else 0.7

        # Labels boost
        labels = [lbl.lower() for lbl in item.get("labels", [])]
        for label in labels:
            if label in PRIORITY_LABELS:
                base_score = max(base_score, PRIORITY_LABELS[label])

        # Staleness: PRs waiting for review get more urgent over time
        try:
            updated = datetime.fromisoformat(item["updated"].replace("Z", "+00:00"))
            days_stale = (now - updated).total_seconds() / 86400
        except (ValueError, KeyError):
            days_stale = 0

        staleness_score = min(days_stale / 7.0, 1.0)  # PRs stale faster (1 week max)

        raw_score = (base_score * 0.60 + staleness_score * 0.40) * 100

        reasons = []
        if is_draft:
            reasons.append("draft PR")
        else:
            reasons.append("awaiting review")
        if days_stale > 3:
            reasons.append(f"stale {days_stale:.0f}d")
        if labels:
            relevant = [lbl for lbl in labels if lbl in PRIORITY_LABELS]
            if relevant:
                reasons.append(f"labeled {', '.join(relevant)}")

        repo = item.get("repo", "")
        candidates.append({
            "title": item["title"],
            "source": "github_pr",
            "raw_score": round(raw_score, 1),
            "score_breakdown": {
                "base_priority": round(base_score, 2),
                "staleness": round(staleness_score, 2),
            },
            "rationale": ", ".join(reasons),
            "item_id": f"{repo}#{item['number']}",
            "priority": "HIGH" if base_score >= 0.8 else "MEDIUM",
            "repo": repo,
            "account": account,
            "url": f"https://github.com/{repo}/pull/{item['number']}",
            "labels": item.get("labels", []),
            "created": item.get("created", ""),
            "updated": item.get("updated", ""),
            "days_stale": round(days_stale, 1),
            "is_draft": is_draft,
        })

    return candidates


def load_local_overrides(pm_dir: Path) -> list[dict]:
    """Load manually-added items from .pm/backlog for local enrichment."""
    backlog_data = load_yaml(pm_dir / "backlog" / "items.yaml")
    items = backlog_data.get("items", [])
    ready_items = [item for item in items if item.get("status") == "READY"]

    candidates = []
    priority_map = {"HIGH": 1.0, "MEDIUM": 0.6, "LOW": 0.3}

    for item in ready_items:
        priority = item.get("priority", "MEDIUM")
        priority_score = priority_map.get(priority, 0.5)
        hours = item.get("estimated_hours", 4)
        ease_score = 1.0 if hours < 2 else 0.6 if hours <= 6 else 0.3

        raw_score = (priority_score * 0.60 + ease_score * 0.40) * 100

        reasons = []
        if priority == "HIGH":
            reasons.append("HIGH priority")
        if hours < 2:
            reasons.append("quick win")
        if not reasons:
            reasons.append("local backlog item")

        candidates.append({
            "title": item.get("title", item["id"]),
            "source": "local",
            "raw_score": round(raw_score, 1),
            "rationale": ", ".join(reasons),
            "item_id": item["id"],
            "priority": priority,
        })

    return candidates


def extract_roadmap_goals(pm_dir: Path) -> list[str]:
    """Extract strategic goals from roadmap markdown."""
    roadmap_path = pm_dir / "roadmap.md"
    if not roadmap_path.exists():
        return []

    text = roadmap_path.read_text()
    goals = []

    for line in text.splitlines():
        line = line.strip()
        if line.startswith("## ") or line.startswith("### "):
            goals.append(line.lstrip("#").strip())
        elif line.startswith("- "):
            goals.append(line.removeprefix("- ").strip())
        elif line.startswith("* "):
            goals.append(line.removeprefix("* ").strip())

    return goals


def score_roadmap_alignment(candidate: dict, goals: list[str]) -> float:
    """Score how well a candidate aligns with roadmap goals. Returns 0.0-1.0."""
    if not goals:
        return 0.5

    title_lower = candidate["title"].lower()
    max_alignment = 0.0

    for goal in goals:
        goal_words = set(goal.lower().split())
        goal_words -= {"the", "a", "an", "and", "or", "to", "for", "in", "of", "is", "with"}
        if not goal_words:
            continue

        matching = sum(1 for word in goal_words if word in title_lower)
        alignment = matching / len(goal_words) if goal_words else 0.0
        max_alignment = max(max_alignment, alignment)

    return min(max_alignment, 1.0)


def suggest_action(candidate: dict) -> str:
    """Suggest a concrete next action for a candidate."""
    source = candidate["source"]
    days_stale = candidate.get("days_stale", 0)
    labels = candidate.get("labels", [])

    if source == "github_pr":
        if candidate.get("is_draft"):
            return "Finish draft or close if abandoned"
        if days_stale > 14:
            return "Merge, close, or rebase — stale >2 weeks"
        if days_stale > 7:
            return "Review and merge or request changes"
        return "Review PR"
    elif source == "github_issue":
        if any(lbl in ("critical", "priority:critical") for lbl in labels):
            return "Fix immediately — critical severity"
        if any(lbl in ("bug",) for lbl in labels):
            return "Investigate and fix bug"
        if days_stale > 30:
            return "Triage: still relevant? Close or reprioritize"
        return "Work on issue or delegate"
    elif source == "local":
        return "Pick up from local backlog"
    return "Review"


def aggregate_and_rank(
    issues: list[dict],
    prs: list[dict],
    local: list[dict],
    goals: list[str],
    top_n: int = TOP_N,
) -> tuple[list[dict], list[dict]]:
    """Aggregate candidates from all sources and rank by weighted score.

    Returns (top_n items, next 5 near-misses).
    """
    scored = []

    source_weights = {
        "github_issue": WEIGHT_ISSUES,
        "github_pr": WEIGHT_PRS,
        "local": WEIGHT_LOCAL,
    }

    all_candidates = issues + prs + local

    for candidate in all_candidates:
        source = candidate["source"]
        source_weight = source_weights.get(source, 0.25)
        raw = candidate["raw_score"]

        alignment = score_roadmap_alignment(candidate, goals)
        final_score = (source_weight * raw) + (WEIGHT_ROADMAP * alignment * 100)

        entry = {
            "title": candidate["title"],
            "source": candidate["source"],
            "score": round(final_score, 1),
            "raw_score": candidate["raw_score"],
            "source_weight": source_weight,
            "rationale": candidate["rationale"],
            "item_id": candidate.get("item_id", ""),
            "priority": candidate.get("priority", "MEDIUM"),
            "alignment": round(alignment, 2),
            "action": suggest_action(candidate),
        }
        # Preserve all metadata from the candidate
        for key in ("url", "repo", "account", "labels", "created", "updated",
                     "days_stale", "comments", "is_draft", "score_breakdown"):
            if key in candidate:
                entry[key] = candidate[key]

        scored.append(entry)

    priority_order = {"HIGH": 0, "MEDIUM": 1, "LOW": 2}
    scored.sort(key=lambda x: (-x["score"], priority_order.get(x["priority"], 1)))

    top = scored[:top_n]
    for i, item in enumerate(top):
        item["rank"] = i + 1

    near_misses = scored[top_n:top_n + 5]
    for i, item in enumerate(near_misses):
        item["rank"] = top_n + i + 1

    return top, near_misses


def build_repo_summary(all_candidates: list[dict]) -> dict:
    """Build a per-repo, per-account summary of open work."""
    repos: dict[str, dict] = {}
    accounts: dict[str, dict] = {}

    for c in all_candidates:
        repo = c.get("repo", "local")
        account = c.get("account", "local")

        if repo not in repos:
            repos[repo] = {"issues": 0, "prs": 0, "high_priority": 0}
        if account not in accounts:
            accounts[account] = {"issues": 0, "prs": 0, "repos": set()}

        if c["source"] == "github_issue":
            repos[repo]["issues"] += 1
            accounts[account]["issues"] += 1
        elif c["source"] == "github_pr":
            repos[repo]["prs"] += 1
            accounts[account]["prs"] += 1

        if c.get("priority") == "HIGH":
            repos[repo]["high_priority"] += 1

        accounts[account]["repos"].add(repo)

    # Convert sets to lists for JSON serialization
    for a in accounts.values():
        a["repos"] = sorted(a["repos"])

    # Sort repos by total open items descending
    sorted_repos = dict(sorted(repos.items(), key=lambda x: -(x[1]["issues"] + x[1]["prs"])))

    return {"by_repo": sorted_repos, "by_account": accounts}


def generate_top5(project_root: Path, sources_path: Path | None = None) -> dict:
    """Generate the Top 5 priority list from GitHub + local state."""
    pm_dir = project_root / ".pm"

    if sources_path is None:
        sources_path = pm_dir / "sources.yaml"

    # Load GitHub sources config
    sources = load_sources(sources_path)

    # Remember original account to restore after
    original_account = get_current_gh_account()

    # Fetch from GitHub
    all_issues = []
    all_prs = []
    accounts_queried = []

    for source in sources:
        account = source.get("account", "")
        repos = source.get("repos", [])
        if not account or not repos:
            continue

        accounts_queried.append(account)
        all_issues.extend(fetch_github_issues(account, repos))
        all_prs.extend(fetch_github_prs(account, repos))

    # Restore original account
    if original_account and accounts_queried:
        run_gh(["auth", "switch", "--user", original_account])

    # Load local overrides
    local = []
    if pm_dir.exists():
        local = load_local_overrides(pm_dir)

    # Load roadmap goals
    goals = extract_roadmap_goals(pm_dir) if pm_dir.exists() else []

    # Aggregate and rank
    all_candidates = all_issues + all_prs + local
    top5, near_misses = aggregate_and_rank(all_issues, all_prs, local, goals)
    summary = build_repo_summary(all_candidates)

    return {
        "top5": top5,
        "near_misses": near_misses,
        "summary": summary,
        "sources": {
            "github_issues": len(all_issues),
            "github_prs": len(all_prs),
            "local_items": len(local),
            "roadmap_goals": len(goals),
            "accounts": accounts_queried,
        },
        "total_candidates": len(all_candidates),
    }


def main():
    """Main entry point."""
    parser = argparse.ArgumentParser(description="Generate Top 5 priorities from GitHub + local state")
    parser.add_argument(
        "--project-root", type=Path, default=Path.cwd(), help="Project root directory"
    )
    parser.add_argument(
        "--sources", type=Path, default=None, help="Path to sources.yaml (default: .pm/sources.yaml)"
    )

    args = parser.parse_args()

    try:
        result = generate_top5(args.project_root, args.sources)
        print(json.dumps(result, indent=2))
        return 0
    except Exception as e:
        print(json.dumps({"error": str(e)}), file=sys.stderr)
        return 1


if __name__ == "__main__":
    sys.exit(main())