swegen 0.1.0__py3-none-any.whl

swegen/create/diff_utils.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import logging
+import subprocess
+from pathlib import Path
+
+from .utils import _is_relevant_source, strip_tests_prefix
+
+
+def generate_diffs(
+    repo_path: Path,
+    base_sha: str,
+    head_sha: str,
+    test_file_paths: list[str],
+) -> tuple[str, str]:
+    """
+    Generate fix.patch and bug.patch from a repository.
+
+    Reversed Baseline Strategy:
+    - fix.patch: base→head, SOURCE files only (what oracle applies to fix)
+    - bug.patch: head→base, ALL files (reverts everything to BASE state)
+
+    Args:
+        repo_path: Path to the git repository
+        base_sha: Base commit SHA (pre-PR state)
+        head_sha: Head commit SHA (post-PR state with fix)
+        test_file_paths: List of test file paths (for logging only)
+
+    Returns:
+        Tuple of (solution_diff, bug_diff)
+    """
+    logger = logging.getLogger("swegen")
+
+    # Get all changed files
+    result = subprocess.run(
+        ["git", "diff", "--name-only", base_sha, head_sha],
+        cwd=str(repo_path),
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    all_changed = [f for f in result.stdout.strip().split("\n") if f]
+
+    # Filter for source files (exclude tests and CI; includes docs, examples, configs)
+    source_files = [f for f in all_changed if _is_relevant_source(f)]
+
+    logger.debug("Total changed files: %d", len(all_changed))
+    logger.debug("Relevant source files (for fix.patch): %d", len(source_files))
+    logger.debug("Test files (included in bug.patch): %s", test_file_paths)
+
+    # Generate fix.patch (base → head, source only)
+    # This is what the oracle applies to fix the bug
+    logger.debug("Generating fix.patch (base → head, source only)...")
+    if source_files:
+        result = subprocess.run(
+            ["git", "diff", base_sha, head_sha, "--"] + source_files,
+            cwd=str(repo_path),
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        solution_diff = result.stdout
+    else:
+        logger.warning("No source files changed! fix.patch will be empty.")
+        solution_diff = ""
+
+    # Generate bug.patch (head → base, ALL files)
+    # This reverts everything so agent sees BASE state
+    logger.debug("Generating bug.patch (head → base, ALL files)...")
+    result = subprocess.run(
+        ["git", "diff", head_sha, base_sha],
+        cwd=str(repo_path),
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    bug_diff = result.stdout
+
+    return solution_diff, bug_diff
+
+
+def extract_test_files(
+    repo_path: Path,
+    test_file_paths: list[str],
+    head_sha: str,
+    output_dir: Path,
+) -> list[str]:
+    """
+    Extract test files from HEAD commit to task/tests/ directory.
+
+    These files will be copied into the container at verification time,
+    overwriting the BASE state test files (after bug.patch is applied).
+
+    Args:
+        repo_path: Path to the git repository
+        test_file_paths: List of repo-relative test file paths
+        head_sha: Commit SHA to extract files from
+        output_dir: Task output directory (tests/ subdir will be used)
+
+    Returns:
+        List of successfully extracted test file paths (repo-relative)
+    """
+    logger = logging.getLogger("swegen")
+    logger.debug("Extracting test files from HEAD commit...")
+
+    # Create tests directory in task output
+    test_dir = output_dir / "tests"
+    test_dir.mkdir(exist_ok=True, parents=True)
+    test_dir = test_dir.resolve()
+
+    if not test_file_paths:
+        logger.warning("No test files found in PR!")
+        return []
+
+    extracted = []
+    for test_file_path in test_file_paths:
+        try:
+            # Extract file content directly from HEAD commit
+            content = subprocess.run(
+                ["git", "show", f"{head_sha}:{test_file_path}"],
+                cwd=str(repo_path),
+                check=True,
+                capture_output=True,
+            ).stdout
+
+            # Preserve directory structure under tests/
+            # Strip leading "tests/" since we're already putting in tests dir
+            relative_path = Path(strip_tests_prefix(test_file_path))
+
+            dest_path = test_dir / relative_path
+            dest_path.parent.mkdir(parents=True, exist_ok=True)
+            dest_path.write_bytes(content)
+
+            logger.debug("Extracted test file: %s -> %s", test_file_path, dest_path)
+            extracted.append(test_file_path)
+
+        except subprocess.CalledProcessError:
+            logger.warning("Test file not found in HEAD: %s", test_file_path)
+            continue
+
+    logger.debug("Extracted %d/%d test files to %s", len(extracted), len(test_file_paths), test_dir)
+    return extracted

swegen/create/orchestrator.py

@@ -0,0 +1,368 @@
+from __future__ import annotations
+
+import logging
+import shutil
+from pathlib import Path
+
+from harbor.models.task.paths import TaskPaths
+
+from .claude_code_runner import ClaudeCodeResult, run_claude_code_session
+from .diff_utils import extract_test_files, generate_diffs
+from .pr_fetcher import GitHubPRFetcher
+from .repo_cache import RepoCache
+from .task_instruction import evaluate_and_generate_task
+from .task_reference import TaskReference, TaskReferenceStore
+from .task_skeleton import (
+    SkeletonParams,
+    generate_instruction_md,
+    generate_task_toml,
+    generate_dockerfile,
+    generate_solve_sh,
+    generate_test_sh,
+)
+from .utils import check_multi_file_requirement, identify_test_files
+
+
+class TrivialPRError(Exception):
+    """Raised when a PR is too trivial to generate a task from."""
+
+    pass
+
+
+class MissingIssueError(Exception):
+    """Raised when a PR has no linked issue and require_issue is enabled."""
+
+    pass
+
+
+class PRToHarborPipeline:
+    """Orchestrates the conversion of a GitHub PR into a Harbor-compatible task."""
+
+    def __init__(self, repo: str, pr_number: int, github_token: str | None = None):
+        """
+        Initialize the pipeline.
+
+        Args:
+            repo: GitHub repo in format "owner/repo" or full URL
+            pr_number: PR number
+            github_token: Optional GitHub token for API access
+        """
+        self.pr_fetcher = GitHubPRFetcher(repo, pr_number, github_token)
+        self.repo = self.pr_fetcher.repo
+        self.pr_number = pr_number
+        # Lowercase repo name for task_id (used in Docker image names which must be lowercase)
+        # Format: owner__repo-number (SWEBench convention)
+        repo_slug = self.repo.lower().replace("/", "__")
+        self.task_id = f"{repo_slug}-{pr_number}"
+
+    def create_task_scaffold(self, tasks_root: Path, overwrite: bool = False) -> Path:
+        """
+        Create task directory structure.
+
+        Returns the task directory path.
+        """
+        logger = logging.getLogger("swegen")
+        logger.debug("Creating task scaffold...")
+
+        task_dir = tasks_root / self.task_id
+
+        # Check if task already exists
+        if task_dir.exists():
+            logger.debug(f"Task directory already exists: {task_dir}")
+            if overwrite:
+                logger.debug("Removing existing directory (forced)...")
+                shutil.rmtree(task_dir)
+            else:
+                raise FileExistsError(f"Task already exists: {task_dir}\nUse --force to overwrite.")
+
+        # Create the task directory
+        logger.debug(f"Creating directory: {task_dir}")
+        task_dir.mkdir(parents=True, exist_ok=True)
+
+        return task_dir
+
+    def generate_task(
+        self,
+        tasks_root: Path,
+        overwrite: bool = False,
+        cache_dir: Path | None = None,
+        repo_path: Path | None = None,
+        metadata: dict | None = None,
+        linked_issues: list | None = None,
+        run_cc: bool = True,
+        cc_timeout: int = 3200,
+        verbose: bool = True,
+        use_cache: bool = True,
+        state_dir: Path | None = None,
+        require_minimum_difficulty: bool = True,
+        min_source_files: int = 3,
+        max_source_files: int = 10,
+        environment: str = "docker",
+    ) -> tuple[Path, ClaudeCodeResult | None, list[str], TaskReference | None]:
+        """
+        Generate a Harbor task using skeleton + Claude Code.
+
+        This is the language-agnostic pipeline that works for any repository.
+        Claude Code analyzes the repo to detect language, runtime, build system,
+        and test framework, then fills in the skeleton accordingly.
+
+        Flow:
+        1. Clone/update repo to local cache
+        2. Generate skeleton (language-agnostic Dockerfile, test.sh)
+        3. Run Claude Code to detect language and fill in skeleton
+        4. Validate with Harbor NOP/Oracle agents
+
+        Args:
+            tasks_root: Output root directory (Harbor tasks go here)
+            overwrite: If True, remove existing task dir
+            cache_dir: Directory for repo cache (default: .cache/repos)
+            repo_path: Pre-cloned repo path (skips cloning if provided)
+            metadata: Pre-fetched PR metadata (skips API call if provided)
+            linked_issues: Pre-fetched linked issues (skips API call if provided)
+            run_cc: If True, run CC to complete skeleton (default: True)
+            cc_timeout: Timeout for CC session in seconds
+            verbose: If True, stream CC output
+            use_cache: If True, try to reuse cached artifacts from previous successful PRs
+            state_dir: State directory for task references (default: .state)
+            require_minimum_difficulty: If True, require 3+ source files modified
+            min_source_files: Minimum number of source files required (default: 3)
+            max_source_files: Maximum number of source files allowed to avoid large refactors (default: 10)
+
+        Returns:
+            Tuple of (task_dir, cc_result, extracted_test_files, task_reference)
+            cc_result is None if run_cc=False
+            task_reference is None if no cached reference exists or use_cache=False
+        """
+        logger = logging.getLogger("swegen")
+        logger.info("=" * 60)
+        logger.info("Task Generation")
+        logger.info("Repo: %s, PR: #%d", self.repo, self.pr_number)
+        logger.info("=" * 60)
+
+        # Initialize reference store with proper state directory
+        reference_store = None
+        if use_cache:
+            reference_file = (state_dir / "task_references.json") if state_dir else None
+            reference_store = TaskReferenceStore(reference_file=reference_file)
+
+        # Step 1: Fetch PR metadata (use provided or fetch)
+        if metadata is None:
+            metadata = self.pr_fetcher.fetch_pr_metadata(allow_unmerged=self.config.allow_unmerged)
+
+        # Fetch linked issues for better task descriptions (use provided or fetch)
+        if linked_issues is None:
+            linked_issues = []
+            try:
+                linked_issues = self.pr_fetcher.fetch_linked_issues()
+                if linked_issues:
+                    logger.info("Found %d linked issue(s)", len(linked_issues))
+            except Exception as e:
+                logger.debug("Could not fetch linked issues: %s", str(e))
+
+        files = self.pr_fetcher.fetch_pr_files()
+
+        # Step 2: Multi-file requirement check (fail fast before expensive operations)
+        # Use generic language detection - CC will figure out the actual language
+        if require_minimum_difficulty:
+            passes, reason, source_count = check_multi_file_requirement(
+                files, min_files=min_source_files, max_files=max_source_files
+            )
+            if not passes:
+                logger.warning("Skipping PR - source file count out of range: %s", reason)
+                raise TrivialPRError(f"PR #{self.pr_number}: {reason}")
+            logger.info(
+                "Multi-file check passed: %d source files (excluding tests, range: %d-%d)",
+                source_count,
+                min_source_files,
+                max_source_files,
+            )
+        else:
+            logger.info("Skipping minimum difficulty check (require_minimum_difficulty=False)")
+
+        # Step 3: Identify test files (language-agnostic patterns)
+        test_file_paths = identify_test_files(files)
+        logger.info("Identified %d test files", len(test_file_paths))
+
+        # Step 4: Clone/update repo to local cache (use provided or clone)
+        if repo_path is None:
+            repo_cache = RepoCache(cache_dir)
+            repo_path = repo_cache.get_or_clone(
+                repo=self.repo,
+                head_sha=metadata["head_sha"],
+                repo_url=metadata["repo_url"],
+            )
+        logger.info("Repo at: %s", repo_path)
+
+        # Step 5: Create task scaffold
+        task_dir = self.create_task_scaffold(tasks_root, overwrite=overwrite)
+        paths = TaskPaths(task_dir)
+        paths.environment_dir.mkdir(exist_ok=True)
+        paths.solution_dir.mkdir(exist_ok=True)
+        paths.tests_dir.mkdir(exist_ok=True)
+
+        try:
+            # Step 6: Try to get reference to previous successful task
+            task_reference = None
+            if reference_store:
+                task_reference = reference_store.get(
+                    repo=self.repo,
+                    max_age_days=180,
+                )
+                if task_reference:
+                    logger.info(
+                        f"Found task reference: {task_reference.task_id} "
+                        f"(from PR #{task_reference.pr_number}, created {task_reference.created_at[:10]})"
+                    )
+
+            # Step 7: Generate diffs from local repo (language-agnostic)
+            solution_diff, bug_diff = generate_diffs(
+                repo_path=repo_path,
+                base_sha=metadata["base_sha"],
+                head_sha=metadata["head_sha"],
+                test_file_paths=test_file_paths,
+            )
+
+            # Step 8: Extract test files
+            extracted_test_files = extract_test_files(
+                repo_path=repo_path,
+                test_file_paths=test_file_paths,
+                head_sha=metadata["head_sha"],
+                output_dir=task_dir,
+            )
+
+            # Step 8b: Read test file contents for instruction generation
+            test_contents = {}
+            test_dir = task_dir / "tests"
+            if test_dir.exists():
+                for test_file in test_dir.rglob("*"):
+                    if test_file.is_file():
+                        try:
+                            # Read as text, skip binary files
+                            content = test_file.read_text(encoding='utf-8', errors='ignore')
+                            # Store with relative path from tests/ dir
+                            rel_path = test_file.relative_to(test_dir)
+                            test_contents[str(rel_path)] = content
+                        except Exception as e:
+                            logger.debug(f"Could not read test file {test_file}: {e}")
+
+            # Step 9: Generate evaluation + instruction (uses LLM but not CC)
+            logger.info("Evaluating PR and generating instruction...")
+            try:
+                combined_result = evaluate_and_generate_task(
+                    metadata,
+                    files,
+                    self.repo,
+                    linked_issues=linked_issues,
+                    force_generate_instruction=(not require_minimum_difficulty),
+                    test_contents=test_contents,
+                )
+
+                if not combined_result.is_substantial:
+                    if require_minimum_difficulty:
+                        logger.warning("Skipping trivial PR: %s", combined_result.reason)
+                        shutil.rmtree(task_dir)
+                        raise TrivialPRError(
+                            f"PR #{self.pr_number} is too trivial: {combined_result.reason}"
+                        )
+                    else:
+                        logger.warning(
+                            "PR deemed trivial by LLM, but proceeding anyway: %s",
+                            combined_result.reason,
+                        )
+
+                instruction_data = {
+                    "instruction": combined_result.instruction,
+                    "difficulty": combined_result.difficulty,
+                    "category": combined_result.category,
+                    "tags": combined_result.tags,
+                }
+            except TrivialPRError:
+                raise
+            except Exception:
+                if task_dir.exists():
+                    shutil.rmtree(task_dir)
+                raise
+
+            # Step 10: Write skeleton files
+            logger.info("Writing skeleton task files...")
+
+            # Create skeleton params
+            skeleton_params = SkeletonParams(
+                repo_url=metadata["repo_url"],
+                head_sha=metadata["head_sha"],
+                base_sha=metadata["base_sha"],
+                pr_number=self.pr_number,
+            )
+
+            # bug.patch
+            (paths.environment_dir / "bug.patch").write_text(bug_diff)
+
+            # Dockerfile (with TODOs for CC)
+            dockerfile = generate_dockerfile(skeleton_params)
+            (paths.environment_dir / "Dockerfile").write_text(dockerfile)
+
+            # test.sh (with TODOs for CC)
+            test_sh_content = generate_test_sh(extracted_test_files)
+            paths.test_path.write_text(test_sh_content)
+            paths.test_path.chmod(0o755)
+
+            # instruction.md and task.toml
+            paths.instruction_path.write_text(generate_instruction_md(instruction_data))
+            paths.config_path.write_text(generate_task_toml(instruction_data))
+
+            # solution/fix.patch - the actual fix to apply
+            (paths.solution_dir / "fix.patch").write_text(solution_diff)
+
+            # solution/solve.sh - applies fix.patch (same for all languages)
+            paths.solve_path.write_text(generate_solve_sh())
+            paths.solve_path.chmod(0o755)
+
+            logger.info("Skeleton generated: %s", task_dir)
+
+            # Step 11: Run CC to complete skeleton and make harbor pass
+            cc_result = None
+            if run_cc:
+                if task_reference:
+                    logger.info(
+                        f"Running CC with reference task {task_reference.task_id} "
+                        f"from PR #{task_reference.pr_number} (should be much faster)..."
+                    )
+                else:
+                    logger.info(
+                        "Running CC session (will detect language automatically)..."
+                    )
+
+                cc_result = run_claude_code_session(
+                    repo=self.repo,
+                    pr_number=self.pr_number,
+                    repo_path=repo_path,
+                    task_dir=task_dir,
+                    task_id=self.task_id,
+                    dataset_path=tasks_root,
+                    test_files=extracted_test_files,
+                    timeout=cc_timeout,
+                    verbose=verbose,
+                    reference_task_id=task_reference.task_id if task_reference else None,
+                    reference_pr=task_reference.pr_number if task_reference else None,
+                    head_sha=metadata.get("head_sha"),
+                    environment=environment,
+                )
+
+                if cc_result.success:
+                    logger.info("✓ CC completed task successfully!")
+                    # Save reference to this successful task for future PRs
+                    if reference_store and not task_reference:
+                        reference_store.save(
+                            repo=self.repo,
+                            task_id=self.task_id,
+                            pr_number=self.pr_number,
+                        )
+                else:
+                    logger.warning("✗ CC did not complete task: %s", cc_result.error_message)
+
+            return task_dir, cc_result, extracted_test_files, task_reference
+
+        except Exception:
+            if task_dir.exists():
+                shutil.rmtree(task_dir)
+            raise

swegen/create/pr_fetcher.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+import logging
+import os
+import re
+from urllib.parse import urlparse
+
+import requests
+
+
+class GitHubPRFetcher:
+    """Fetches PR metadata from GitHub API."""
+
+    def __init__(self, repo: str, pr_number: int, github_token: str | None = None):
+        """
+        Initialize the PR fetcher.
+
+        Args:
+            repo: GitHub repo in format "owner/repo" or full URL
+            pr_number: PR number
+            github_token: Optional GitHub token for API access
+        """
+        self.repo = self._parse_repo(repo)
+        self.pr_number = pr_number
+        self.github_token = github_token or os.environ.get("GITHUB_TOKEN")
+
+        # API setup
+        self.api_base = "https://api.github.com"
+        self.headers = {"Accept": "application/vnd.github.v3+json"}
+        if self.github_token:
+            self.headers["Authorization"] = f"token {self.github_token}"
+
+    def _parse_repo(self, repo: str) -> str:
+        """Parse repo URL or owner/repo format to owner/repo."""
+        if repo.startswith("http"):
+            parsed = urlparse(repo)
+            # Extract owner/repo from path
+            path = parsed.path.strip("/")
+            if path.endswith(".git"):
+                path = path[:-4]
+            return path
+        return repo
+
+    def _api_get(self, endpoint: str) -> dict:
+        """Make a GET request to GitHub API."""
+        url = f"{self.api_base}{endpoint}"
+        response = requests.get(url, headers=self.headers)
+        response.raise_for_status()
+        return response.json()
+
+    def fetch_pr_metadata(self, allow_unmerged: bool = False) -> dict:
+        """Fetch PR metadata from GitHub API.
+        
+        Args:
+            allow_unmerged: If True, allow unmerged PRs (for testing/preview). Default False.
+        """
+        logger = logging.getLogger("swegen")
+        logger.debug("Fetching PR #%s metadata from %s...", self.pr_number, self.repo)
+        pr_data = self._api_get(f"/repos/{self.repo}/pulls/{self.pr_number}")
+
+        if not allow_unmerged and not pr_data.get("merged"):
+            raise ValueError(f"PR #{self.pr_number} is not merged yet!")
+
+        # Get the commits
+        base_sha = pr_data["base"]["sha"]
+        head_sha = pr_data["head"]["sha"]
+        merge_commit_sha = pr_data.get("merge_commit_sha")
+        logger.debug("Base SHA: %s", base_sha)
+        logger.debug("Head SHA: %s", head_sha)
+        logger.debug("Merge SHA: %s", merge_commit_sha)
+
+        return {
+            "title": pr_data["title"],
+            "body": pr_data.get("body", ""),
+            "base_sha": base_sha,
+            "head_sha": head_sha,
+            "merge_commit_sha": merge_commit_sha,
+            "base_ref": pr_data["base"]["ref"],
+            "head_ref": pr_data["head"]["ref"],
+            "repo_url": pr_data["base"]["repo"]["clone_url"],
+            "html_url": pr_data["html_url"],
+            "created_at": pr_data["created_at"],
+            "merged_at": pr_data["merged_at"],
+        }
+
+    def fetch_pr_files(self) -> list[dict]:
+        """Fetch list of files changed in the PR."""
+        logger = logging.getLogger("swegen")
+        logger.debug("Fetching changed files for PR #%s...", self.pr_number)
+        files_response = self._api_get(f"/repos/{self.repo}/pulls/{self.pr_number}/files")
+        # API may return dict with pagination info or list directly
+        files = (
+            files_response if isinstance(files_response, list) else files_response.get("files", [])
+        )
+        logger.debug("Found %d changed files", len(files))
+        for f in files:
+            logger.debug("  %s %s", f["status"], f["filename"])
+
+        return files
+
+    def fetch_linked_issues(self) -> list[dict]:
+        """Fetch issues linked/referenced in the PR.
+
+        Uses the BROADEST approach possible:
+        1. GitHub Timeline API (catches manual links and cross-references)
+        2. PR title parsing
+        3. PR body parsing
+
+        Returns a list of issue dictionaries with 'number', 'title', and 'body'.
+        """
+        logger = logging.getLogger("swegen")
+        logger.debug("Fetching linked issues for PR #%s...", self.pr_number)
+
+        issues = []
+        issue_numbers = set()
+
+        try:
+            # Method 1: Use timeline API to find closing references and manual links
+            timeline_url = f"/repos/{self.repo}/issues/{self.pr_number}/timeline"
+            headers = self.headers.copy()
+            headers["Accept"] = "application/vnd.github.mockingbird-preview+json"
+
+            url = f"{self.api_base}{timeline_url}"
+            response = requests.get(url, headers=headers)
+            response.raise_for_status()
+            timeline = response.json()
+
+            for event in timeline:
+                if event.get("event") == "cross-referenced":
+                    source = event.get("source", {})
+                    if source.get("type") == "issue":
+                        issue_data = source.get("issue", {})
+                        issue_num = issue_data.get("number")
+                        if issue_num and issue_num != self.pr_number:
+                            issue_numbers.add(issue_num)
+        except Exception as e:
+            logger.debug("Timeline API failed (may not have access): %s", str(e))
+
+        try:
+            # Method 2: Parse PR title and body for issue references
+            pr_data = self._api_get(f"/repos/{self.repo}/pulls/{self.pr_number}")
+            pr_title = pr_data.get("title", "") or ""
+            pr_body = pr_data.get("body", "") or ""
+
+            # Combine title and body
+            text = f"{pr_title}\n{pr_body}"
+
+            # Remove HTML comments before parsing (like SWE-smith does)
+            comments_pat = re.compile(r"(?s)<!--.*?-->")
+            text = comments_pat.sub("", text)
+
+            # Match patterns - BROADEST approach (keywords optional, standalone #123 also matches)
+            patterns = [
+                r"(?:fix(?:es|ed)?|close(?:s|d)?|resolve(?:s|d)?)\s+#(\d+)",  # With keywords
+                r"(?:fix(?:es|ed)?|close(?:s|d)?|resolve(?:s|d)?)\s+https?://github\.com/[^/]+/[^/]+/issues/(\d+)",  # Full URLs with keywords
+                r"#(\d+)",  # Standalone #123 (no keyword required - broadest)
+                r"https?://github\.com/[^/]+/[^/]+/issues/(\d+)",  # Full URLs without keywords
+            ]
+
+            for pattern in patterns:
+                matches = re.finditer(pattern, text, re.IGNORECASE)
+                for match in matches:
+                    issue_num = int(match.group(1))
+                    if issue_num != self.pr_number:  # Don't include the PR itself
+                        issue_numbers.add(issue_num)
+        except Exception as e:
+            logger.debug("Failed to parse PR title/body for issue refs: %s", str(e))
+
+        # Fetch full issue data for each linked issue
+        for issue_num in sorted(issue_numbers):
+            try:
+                issue_data = self._api_get(f"/repos/{self.repo}/issues/{issue_num}")
+                issues.append(
+                    {
+                        "number": issue_data["number"],
+                        "title": issue_data["title"],
+                        "body": issue_data.get("body", ""),
+                        "state": issue_data.get("state", ""),
+                        "html_url": issue_data.get("html_url", ""),
+                    }
+                )
+                logger.debug("  Found linked issue #%d: %s", issue_num, issue_data["title"])
+            except Exception as e:
+                logger.debug("  Failed to fetch issue #%d: %s", issue_num, str(e))
+
+        logger.debug("Collected %d linked issues", len(issues))
+        return issues