galangal-orchestrate 0.13.0__py3-none-any.whl

galangal/github/images.py

@@ -0,0 +1,324 @@
+"""
+GitHub issue image extraction and download.
+
+Parses markdown content for image URLs and downloads them locally
+so Claude Code can view them during workflow execution.
+"""
+
+import hashlib
+import re
+import subprocess
+import urllib.request
+from pathlib import Path
+from urllib.parse import urlparse
+
+# Patterns for finding images in markdown
+MARKDOWN_IMAGE_PATTERN = re.compile(
+    r"!\[([^\]]*)\]\(([^)]+)\)",  # ![alt text](url)
+    re.MULTILINE,
+)
+HTML_IMG_PATTERN = re.compile(
+    r'<img[^>]+src=["\']([^"\']+)["\']',  # <img src="url">
+    re.IGNORECASE,
+)
+
+# GitHub domains that host user-uploaded images
+GITHUB_IMAGE_DOMAINS = {
+    "user-images.githubusercontent.com",
+    "github.com",
+    "raw.githubusercontent.com",
+    "camo.githubusercontent.com",
+    "private-user-images.githubusercontent.com",
+}
+
+# Supported image extensions
+IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg", ".bmp"}
+
+
+def extract_image_urls(markdown_text: str) -> list[dict]:
+    """
+    Extract image URLs from markdown text.
+
+    Finds both markdown-style images (![alt](url)) and HTML img tags.
+
+    Args:
+        markdown_text: Raw markdown content (e.g., GitHub issue body)
+
+    Returns:
+        List of dicts with keys: 'url', 'alt_text', 'source' ('markdown' or 'html')
+    """
+    images = []
+    seen_urls = set()
+
+    # Find markdown-style images: ![alt](url)
+    for match in MARKDOWN_IMAGE_PATTERN.finditer(markdown_text):
+        alt_text = match.group(1)
+        url = match.group(2).strip()
+
+        if url and url not in seen_urls and _is_image_url(url):
+            images.append(
+                {
+                    "url": url,
+                    "alt_text": alt_text,
+                    "source": "markdown",
+                }
+            )
+            seen_urls.add(url)
+
+    # Find HTML img tags: <img src="url">
+    for match in HTML_IMG_PATTERN.finditer(markdown_text):
+        url = match.group(1).strip()
+
+        if url and url not in seen_urls and _is_image_url(url):
+            images.append(
+                {
+                    "url": url,
+                    "alt_text": "",
+                    "source": "html",
+                }
+            )
+            seen_urls.add(url)
+
+    return images
+
+
+def _is_image_url(url: str) -> bool:
+    """Check if a URL appears to be an image."""
+    try:
+        parsed = urlparse(url)
+
+        # Check if it's a GitHub user content URL (these are always images)
+        if parsed.netloc in GITHUB_IMAGE_DOMAINS:
+            return True
+
+        # Check file extension
+        path_lower = parsed.path.lower()
+        for ext in IMAGE_EXTENSIONS:
+            if path_lower.endswith(ext):
+                return True
+
+        # GitHub blob URLs often contain images
+        if "blob" in parsed.path and any(ext in path_lower for ext in IMAGE_EXTENSIONS):
+            return True
+
+        return False
+    except Exception:
+        return False
+
+
+def _generate_filename(url: str, alt_text: str, index: int) -> str:
+    """Generate a filename for a downloaded image."""
+    parsed = urlparse(url)
+    path = parsed.path
+
+    # Try to get extension from URL
+    ext = ".png"  # Default
+    for e in IMAGE_EXTENSIONS:
+        if path.lower().endswith(e):
+            ext = e
+            break
+
+    # Create a descriptive name
+    if alt_text:
+        # Sanitize alt text for filename
+        safe_alt = re.sub(r"[^\w\s-]", "", alt_text)[:30].strip()
+        safe_alt = re.sub(r"[\s]+", "_", safe_alt).lower()
+        if safe_alt:
+            return f"screenshot_{index:02d}_{safe_alt}{ext}"
+
+    # Use hash of URL for uniqueness
+    url_hash = hashlib.md5(url.encode()).hexdigest()[:8]
+    return f"screenshot_{index:02d}_{url_hash}{ext}"
+
+
+def download_images(
+    images: list[dict],
+    output_dir: Path,
+    use_gh_auth: bool = True,
+) -> list[dict]:
+    """
+    Download images to a local directory.
+
+    Args:
+        images: List of image dicts from extract_image_urls()
+        output_dir: Directory to save images (e.g., task_dir/screenshots)
+        use_gh_auth: If True, use gh CLI for authenticated downloads
+
+    Returns:
+        List of dicts with 'local_path', 'url', 'alt_text', 'success', 'error'
+    """
+    output_dir.mkdir(parents=True, exist_ok=True)
+    results = []
+
+    for i, img in enumerate(images, 1):
+        url = img["url"]
+        alt_text = img.get("alt_text", "")
+        filename = _generate_filename(url, alt_text, i)
+        local_path = output_dir / filename
+
+        result = {
+            "url": url,
+            "alt_text": alt_text,
+            "local_path": str(local_path),
+            "success": False,
+            "error": None,
+        }
+
+        try:
+            parsed = urlparse(url)
+            is_github_url = parsed.netloc in GITHUB_IMAGE_DOMAINS
+
+            # Try gh CLI for GitHub URLs (handles auth)
+            if use_gh_auth and is_github_url:
+                success = _download_with_gh(url, local_path)
+                if success:
+                    result["success"] = True
+                    results.append(result)
+                    continue
+
+            # Fall back to direct download
+            _download_direct(url, local_path)
+            result["success"] = True
+
+        except Exception as e:
+            result["error"] = str(e)
+
+        results.append(result)
+
+    return results
+
+
+def _download_with_gh(url: str, output_path: Path) -> bool:
+    """
+    Download a URL using gh CLI (handles GitHub authentication).
+
+    Args:
+        url: URL to download
+        output_path: Path to save the file
+
+    Returns:
+        True if successful, False otherwise
+    """
+    from galangal.core.utils import debug_log
+
+    try:
+        parsed = urlparse(url)
+
+        # For private-user-images or user-attachments, use gh api
+        # These URLs require authenticated access for private repos
+        if parsed.netloc == "private-user-images.githubusercontent.com" or (
+            parsed.netloc == "github.com" and "/user-attachments/" in parsed.path
+        ):
+            debug_log("Downloading with gh api", url=url[:80])
+            # Use gh api to fetch with authentication
+            result = subprocess.run(
+                ["gh", "api", "-H", "Accept: application/octet-stream", url],
+                capture_output=True,
+                timeout=60,
+            )
+            if result.returncode == 0 and result.stdout:
+                output_path.write_bytes(result.stdout)
+                debug_log("gh api download successful", path=str(output_path))
+                return True
+            debug_log(
+                "gh api download failed",
+                returncode=result.returncode,
+                stderr=result.stderr.decode()[:200] if result.stderr else "",
+            )
+            return False
+
+        # For other GitHub URLs, use curl with gh auth token
+        debug_log("Downloading with auth token", url=url[:80])
+        result = subprocess.run(
+            ["gh", "auth", "token"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        if result.returncode != 0:
+            debug_log("Failed to get gh auth token")
+            return False
+
+        token = result.stdout.strip()
+        if not token:
+            debug_log("gh auth token is empty")
+            return False
+
+        # Download with auth header
+        headers = {"Authorization": f"token {token}"}
+        request = urllib.request.Request(url, headers=headers)
+
+        with urllib.request.urlopen(request, timeout=60) as response:
+            output_path.write_bytes(response.read())
+        debug_log("Auth token download successful", path=str(output_path))
+        return True
+
+    except Exception as e:
+        debug_log("Download with gh failed", error=str(e))
+        return False
+
+
+def _download_direct(url: str, output_path: Path) -> None:
+    """
+    Download a URL directly without authentication.
+
+    Args:
+        url: URL to download
+        output_path: Path to save the file
+
+    Raises:
+        Exception on download failure
+    """
+    headers = {"User-Agent": "Mozilla/5.0 (compatible; galangal-orchestrate/1.0)"}
+    request = urllib.request.Request(url, headers=headers)
+
+    with urllib.request.urlopen(request, timeout=60) as response:
+        output_path.write_bytes(response.read())
+
+
+def download_issue_images(
+    markdown_body: str,
+    task_dir: Path,
+    screenshots_subdir: str = "screenshots",
+) -> list[str]:
+    """
+    Extract and download all images from a GitHub issue body.
+
+    This is the main entry point for integrating with task creation.
+
+    Args:
+        markdown_body: The raw issue body markdown
+        task_dir: Base directory for the task (e.g., galangal-tasks/issue-42-fix-bug)
+        screenshots_subdir: Subdirectory name for screenshots (default: "screenshots")
+
+    Returns:
+        List of local file paths for successfully downloaded images
+    """
+    from galangal.core.utils import debug_log
+
+    images = extract_image_urls(markdown_body)
+    debug_log(
+        "Extracted image URLs from issue body",
+        count=len(images),
+        urls=[img["url"][:80] for img in images[:5]],  # First 5, truncated
+    )
+
+    if not images:
+        debug_log("No images found in issue body")
+        return []
+
+    output_dir = task_dir / screenshots_subdir
+    results = download_images(images, output_dir)
+
+    # Log results
+    successful = [r for r in results if r["success"]]
+    failed = [r for r in results if not r["success"]]
+    debug_log(
+        "Image download results",
+        successful=len(successful),
+        failed=len(failed),
+        errors=[r.get("error") for r in failed if r.get("error")],
+    )
+
+    # Return only successful downloads
+    return [r["local_path"] for r in results if r["success"]]

galangal/github/issues.py

@@ -0,0 +1,298 @@
+"""
+GitHub issue listing and parsing.
+"""
+
+from dataclasses import dataclass
+
+from galangal.github.client import GitHubClient, GitHubError
+
+# Default label for galangal-managed issues
+GALANGAL_LABEL = "galangal"
+
+
+@dataclass
+class GitHubIssue:
+    """Representation of a GitHub issue."""
+
+    number: int
+    title: str
+    body: str
+    labels: list[str]
+    state: str
+    url: str
+    author: str
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "GitHubIssue":
+        """Create from gh JSON output."""
+        return cls(
+            number=data["number"],
+            title=data["title"],
+            body=data.get("body") or "",
+            labels=[label["name"] for label in data.get("labels", [])],
+            state=data.get("state", "open").lower(),
+            url=data.get("url", ""),
+            author=data.get("author", {}).get("login", "unknown"),
+        )
+
+    def get_task_name_prefix(self) -> str:
+        """Generate a task name prefix from the issue number."""
+        return f"issue-{self.number}"
+
+    def get_task_type_hint(self) -> str | None:
+        """
+        Infer task type from issue labels using config-based mapping.
+
+        Returns:
+            Suggested task type or None if no match
+        """
+        from galangal.config.loader import get_config
+
+        label_lower = [lbl.lower() for lbl in self.labels]
+
+        # Get label mapping from config
+        try:
+            config = get_config()
+            mapping = config.github.label_mapping
+        except Exception:
+            # Fall back to defaults if config not available
+            mapping = None
+
+        if mapping:
+            # Check each task type's labels
+            for label in label_lower:
+                if label in [lbl.lower() for lbl in mapping.bug]:
+                    return "bug_fix"
+                if label in [lbl.lower() for lbl in mapping.feature]:
+                    return "feature"
+                if label in [lbl.lower() for lbl in mapping.docs]:
+                    return "docs"
+                if label in [lbl.lower() for lbl in mapping.refactor]:
+                    return "refactor"
+                if label in [lbl.lower() for lbl in mapping.chore]:
+                    return "chore"
+                if label in [lbl.lower() for lbl in mapping.hotfix]:
+                    return "hotfix"
+        else:
+            # Fallback to hardcoded defaults
+            if "bug" in label_lower or "bugfix" in label_lower:
+                return "bug_fix"
+            if "enhancement" in label_lower or "feature" in label_lower:
+                return "feature"
+            if "documentation" in label_lower or "docs" in label_lower:
+                return "docs"
+            if "refactor" in label_lower:
+                return "refactor"
+            if "chore" in label_lower or "maintenance" in label_lower:
+                return "chore"
+            if "hotfix" in label_lower or "critical" in label_lower:
+                return "hotfix"
+
+        return None
+
+
+def list_issues(
+    label: str = GALANGAL_LABEL,
+    state: str = "open",
+    limit: int = 50,
+) -> list[GitHubIssue]:
+    """
+    List issues from the current repository with the given label.
+
+    Args:
+        label: Label to filter by (default: "galangal")
+        state: Issue state filter ("open", "closed", "all")
+        limit: Maximum number of issues to return
+
+    Returns:
+        List of GitHubIssue objects
+
+    Raises:
+        GitHubError: If GitHub operations fail
+    """
+    client = GitHubClient()
+
+    data = client.run_json_command(
+        [
+            "issue",
+            "list",
+            "--label",
+            label,
+            "--state",
+            state,
+            "--limit",
+            str(limit),
+            "--json",
+            "number,title,body,labels,state,url,author",
+        ]
+    )
+
+    if not data:
+        return []
+
+    return [GitHubIssue.from_dict(item) for item in data]
+
+
+def get_issue(issue_number: int) -> GitHubIssue | None:
+    """
+    Get a single issue by number.
+
+    Args:
+        issue_number: The issue number
+
+    Returns:
+        GitHubIssue or None if not found
+    """
+    client = GitHubClient()
+
+    try:
+        data = client.run_json_command(
+            [
+                "issue",
+                "view",
+                str(issue_number),
+                "--json",
+                "number,title,body,labels,state,url,author",
+            ]
+        )
+
+        if data:
+            return GitHubIssue.from_dict(data)
+    except GitHubError:
+        pass
+
+    return None
+
+
+def is_issue_open(issue_number: int) -> bool | None:
+    """
+    Check if an issue is still open.
+
+    Args:
+        issue_number: The issue number
+
+    Returns:
+        True if open, False if closed, None if not found/error
+    """
+    client = GitHubClient()
+    state = client.get_issue_state(issue_number)
+    if state is None:
+        return None
+    return state == "open"
+
+
+def mark_issue_in_progress(issue_number: int) -> bool:
+    """
+    Mark an issue as being worked on by galangal.
+
+    Adds "in-progress" label and removes "galangal" label.
+
+    Args:
+        issue_number: The issue number
+
+    Returns:
+        True if successful
+    """
+    client = GitHubClient()
+    success1 = client.add_issue_label(issue_number, "in-progress")
+    success2 = client.remove_issue_label(issue_number, GALANGAL_LABEL)
+    return success1 and success2
+
+
+def mark_issue_pr_created(issue_number: int, pr_url: str) -> bool:
+    """
+    Mark an issue as having a PR created.
+
+    Adds a comment with the PR link.
+
+    Args:
+        issue_number: The issue number
+        pr_url: URL to the created PR
+
+    Returns:
+        True if successful
+    """
+    client = GitHubClient()
+    comment = f"Pull request created: {pr_url}"
+    return client.add_issue_comment(issue_number, comment)
+
+
+@dataclass
+class IssueTaskData:
+    """Data extracted from a GitHub issue for task creation."""
+
+    issue_number: int
+    description: str
+    task_type_hint: str | None
+    github_repo: str | None
+    screenshots: list[str]
+    issue_body: str  # Raw body for later screenshot download
+    task_name: str | None = None  # Generated task name (set after creation)
+
+
+def prepare_issue_for_task(
+    issue: GitHubIssue,
+    repo_name: str | None = None,
+) -> IssueTaskData:
+    """
+    Extract task creation data from a GitHub issue.
+
+    This consolidates all the issue-to-task conversion logic:
+    - Forms description from title + body
+    - Infers task type from labels
+    - Identifies screenshots for later download
+
+    Args:
+        issue: The GitHub issue to process
+        repo_name: Optional repo name (owner/repo), fetched if not provided
+
+    Returns:
+        IssueTaskData with all info needed for task creation
+
+    Note:
+        Screenshots are NOT downloaded here - the task directory needs to
+        exist first. Use download_issue_screenshots() after task creation.
+    """
+    # Get repo name if not provided
+    if not repo_name:
+        client = GitHubClient()
+        repo_name = client.get_repo_name()
+
+    # Form description from title and body
+    description = f"{issue.title}\n\n{issue.body}"
+
+    # Note: screenshots are extracted later via download_issue_screenshots()
+    # We just store the body for later processing
+
+    return IssueTaskData(
+        issue_number=issue.number,
+        description=description,
+        task_type_hint=issue.get_task_type_hint(),
+        github_repo=repo_name,
+        screenshots=[],  # Populated after task dir exists
+        issue_body=issue.body,
+    )
+
+
+def download_issue_screenshots(
+    issue_body: str,
+    task_dir,
+) -> list[str]:
+    """
+    Download screenshots from an issue body to the task directory.
+
+    Args:
+        issue_body: The raw issue body markdown
+        task_dir: Path to the task directory (will create screenshots/ subdir)
+
+    Returns:
+        List of local file paths to downloaded screenshots
+    """
+    from pathlib import Path
+
+    from galangal.github.images import download_issue_images
+
+    task_dir = Path(task_dir)
+    task_dir.mkdir(parents=True, exist_ok=True)
+
+    return download_issue_images(issue_body, task_dir)