implement.py

"""Implement task — implement the approved plan, open PR, assign reviewer.

After implementation, assigns the issue author as PR reviewer and sets
status to ``pr_open`` for review monitoring.
"""

import logging
import subprocess
from pathlib import Path

from clayde.claude import InvocationTimeoutError, UsageLimitError, format_cost_line, invoke_claude
from clayde.config import DATA_DIR, get_github_client, get_settings
from clayde.git import ensure_repo
from clayde.prompts import collect_comments_after, render_template
from clayde.github import (
    add_pr_reviewer,
    create_pull_request,
    fetch_comment,
    fetch_issue,
    fetch_issue_comments,
    find_open_pr,
    get_default_branch,
    get_issue_author,
    get_pr_title,
    issue_ref,
    parse_issue_url,
    parse_pr_url,
    post_comment,
)
from clayde.responses import ImplementResponse, parse_response
from clayde.safety import filter_comments
from clayde.state import IssueStatus, accumulate_cost, get_issue_state, pop_accumulated_cost, update_issue_state
from clayde.telemetry import get_tracer

log = logging.getLogger("clayde.tasks.implement")


def _delete_conversation_file(owner: str, repo: str, number: int) -> None:
    """Remove the conversation file for an issue so stale sessions don't persist."""
    path = DATA_DIR / "conversations" / f"{owner}__{repo}__issue-{number}.json"
    if path.exists():
        path.unlink()
        log.info("Deleted conversation file %s", path)


def run(issue_url: str) -> None:
    tracer = get_tracer()
    with tracer.start_as_current_span("clayde.task.implement") as span:
        g = get_github_client()
        owner, repo, number = parse_issue_url(issue_url)
        issue_state = get_issue_state(issue_url)
        span.set_attribute("issue.number", number)
        span.set_attribute("issue.owner", owner)
        span.set_attribute("issue.repo", repo)

        resumed = issue_state.get("status") == IssueStatus.INTERRUPTED
        span.set_attribute("implement.resumed_from_interrupted", resumed)

        if resumed and _try_resume_from_existing_pr(g, owner, repo, number, issue_url, issue_state, span):
            return

        if not resumed:
            _delete_conversation_file(owner, repo, number)

        update_issue_state(issue_url, {"status": IssueStatus.IMPLEMENTING})

        issue, default_branch, repo_path, branch_name, prompt, conversation_path = (
            _prepare_implementation_context(g, owner, repo, number, issue_url, issue_state, resumed)
        )

        log.info("[%s: %s] Invoking Claude for implementation", issue_ref(owner, repo, number), issue.title)
        try:
            result = invoke_claude(
                prompt,
                repo_path,
                branch_name=branch_name,
                conversation_path=conversation_path,
            )
        except UsageLimitError as e:
            log.warning("[%s: %s] Usage limit hit during implementation — will retry next cycle", issue_ref(owner, repo, number), issue.title)
            accumulate_cost(issue_url, e.cost_eur)
            span.set_attribute("implement.status", "limit")
            update_issue_state(issue_url, {
                "status": IssueStatus.INTERRUPTED,
                "interrupted_phase": IssueStatus.IMPLEMENTING,
            })
            return
        except InvocationTimeoutError as e:
            log.warning("[%s: %s] Timed out during implementation — will resume next cycle", issue_ref(owner, repo, number), issue.title)
            accumulate_cost(issue_url, e.cost_eur)
            span.set_attribute("implement.status", "timeout")
            update_issue_state(issue_url, {
                "status": IssueStatus.INTERRUPTED,
                "interrupted_phase": IssueStatus.IMPLEMENTING,
            })
            return

        total_cost = pop_accumulated_cost(issue_url) + result.cost_eur

        # Parse JSON response to extract summary
        summary = None
        try:
            parsed = parse_response(result.output, ImplementResponse)
            summary = parsed.summary
        except ValueError as e:
            log.warning("[%s: %s] Failed to parse implement response JSON: %s", issue_ref(owner, repo, number), issue.title, e)

        pr_url = _find_or_create_pr(g, owner, repo, number, branch_name, default_branch, total_cost, issue,
                                     repo_path=repo_path, summary=summary)

        if pr_url:
            _assign_reviewer_and_finish(g, owner, repo, number, issue_url, pr_url, span, cost_eur=total_cost)
        else:
            log.error("[%s: %s] Implementation produced no PR", issue_ref(owner, repo, number), issue.title)
            log.error("Claude output (last 2000 chars): %s", (result.output or "")[-2000:])
            _handle_no_pr(g, owner, repo, number, issue_url, issue_state, span)


def _try_resume_from_existing_pr(g, owner, repo, number, issue_url, issue_state, span) -> bool:
    """If a PR already exists for the WIP branch, finish without re-running Claude.

    Returns True if we found an existing PR and finished; False otherwise.
    """
    branch_name = issue_state.get("branch_name", f"clayde/issue-{number}")
    existing_pr = find_open_pr(g, owner, repo, branch_name)
    if not existing_pr:
        return False

    log.info("Resuming interrupted #%d — found existing PR %s", number, existing_pr)
    accumulated = pop_accumulated_cost(issue_url)
    _assign_reviewer_and_finish(
        g, owner, repo, number, issue_url, existing_pr, span,
        cost_eur=accumulated if accumulated > 0 else None,
    )
    return True


def _prepare_implementation_context(g, owner, repo, number, issue_url, issue_state, resumed):
    """Fetch all resources needed to run Claude and return them as a tuple."""
    plan_comment_id = issue_state.get("plan_comment_id") or issue_state["preliminary_comment_id"]
    issue = fetch_issue(g, owner, repo, number)
    default_branch = get_default_branch(g, owner, repo)
    repo_path = ensure_repo(owner, repo, default_branch)

    plan_comment = fetch_comment(g, owner, repo, number, plan_comment_id)
    plan_text = plan_comment.body

    branch_name = issue_state.get("branch_name") or f"clayde/issue-{number}"
    update_issue_state(issue_url, {"branch_name": branch_name})

    if resumed:
        _checkout_wip_branch(repo_path, branch_name)

    all_comments = fetch_issue_comments(g, owner, repo, number)
    visible_comments = filter_comments(all_comments)
    discussion_text = collect_comments_after(visible_comments, plan_comment_id)

    prompt = _build_prompt(issue, plan_text, discussion_text, owner, repo, number, repo_path, branch_name)

    conversation_path = DATA_DIR / "conversations" / f"{owner}__{repo}__issue-{number}.json"
    return issue, default_branch, repo_path, branch_name, prompt, conversation_path


def _ensure_branch_pushed(repo_path: Path, branch_name: str) -> bool:
    """Check if branch exists on remote; if not, try to push it.

    Returns True if the branch is on the remote after this call.
    """
    result = subprocess.run(
        ["git", "ls-remote", "--heads", "origin", branch_name],
        cwd=str(repo_path), capture_output=True, text=True,
    )
    if result.stdout.strip():
        return True

    # Branch not on remote — check if it exists locally and push it
    result = subprocess.run(
        ["git", "branch", "--list", branch_name],
        cwd=str(repo_path), capture_output=True, text=True,
    )
    if not result.stdout.strip():
        log.error("Branch %s does not exist locally or on remote", branch_name)
        return False

    log.info("Branch %s exists locally but not on remote — pushing", branch_name)
    result = subprocess.run(
        ["git", "push", "origin", branch_name],
        cwd=str(repo_path), capture_output=True, text=True,
    )
    if result.returncode != 0:
        log.error("Failed to push branch %s: %s", branch_name, result.stderr)
        return False

    return True


def _find_or_create_pr(g, owner, repo, number, branch_name, default_branch, total_cost, issue,
                       repo_path: Path | None = None, summary: str | None = None) -> str | None:
    """Return the PR URL for branch_name, creating it if necessary."""
    pr_url = find_open_pr(g, owner, repo, branch_name)
    if pr_url:
        return pr_url

    if repo_path and not _ensure_branch_pushed(repo_path, branch_name):
        log.error("Cannot create PR for #%d: branch %s not available on remote", number, branch_name)
        return None

    try:
        if summary:
            pr_body = f"Closes #{number}\n\n{summary}{format_cost_line(total_cost)}"
        else:
            pr_body = f"Closes #{number}{format_cost_line(total_cost)}"
        pr_url = create_pull_request(
            g, owner, repo,
            title=f"Fix #{number}: {issue.title}",
            body=pr_body,
            head=branch_name,
            base=default_branch,
        )
        log.info("Created PR: %s", pr_url)
        return pr_url
    except Exception as e:
        log.error("Failed to create PR for #%d: %s", number, e)
        return None


def _handle_no_pr(g, owner, repo, number, issue_url, issue_state, span) -> None:
    """Handle the case where implementation produced no PR — retry or give up."""
    max_retries = get_settings().implement_max_retries
    retry_count = issue_state.get("retry_count", 0) + 1
    if retry_count >= max_retries:
        log.error("Issue #%d failed after %d retries — giving up", number, retry_count)
        _delete_conversation_file(owner, repo, number)
        post_comment(g, owner, repo, number,
                     "Implementation failed to produce a PR after multiple retries. "
                     "Marking as failed — manual intervention needed.")
        span.set_attribute("implement.status", "failed")
        update_issue_state(issue_url, {"status": IssueStatus.FAILED, "retry_count": retry_count})
    else:
        post_comment(g, owner, repo, number,
                     f"Implementation ran but no PR was created "
                     f"(attempt {retry_count}/{max_retries}). "
                     "I'll retry on the next cycle.")
        span.set_attribute("implement.status", "no_pr")
        span.set_attribute("implement.retry_count", retry_count)
        update_issue_state(issue_url, {
            "status": IssueStatus.INTERRUPTED,
            "interrupted_phase": IssueStatus.IMPLEMENTING,
            "retry_count": retry_count,
        })


def _assign_reviewer_and_finish(g, owner, repo, number, issue_url, pr_url, span,
                                cost_eur=None):
    """Post result, assign reviewer, set status to pr_open."""
    _post_result(g, owner, repo, number, pr_url, cost_eur=cost_eur)

    _, _, pr_number = parse_pr_url(pr_url)

    pr_title = None
    try:
        pr_title = get_pr_title(g, owner, repo, pr_number)
    except Exception as e:
        log.warning("Failed to fetch PR title for PR %s: %s", pr_url, e)

    try:
        issue_author = get_issue_author(g, owner, repo, number)
        settings = get_settings()
        if issue_author.lower() == settings.github_username.lower():
            log.info("Issue author is %s (self) — skipping reviewer assignment", issue_author)
        else:
            add_pr_reviewer(g, owner, repo, pr_number, issue_author)
    except Exception as e:
        log.warning("Failed to assign reviewer for PR %s: %s", pr_url, e)

    state_update = {
        "status": IssueStatus.PR_OPEN,
        "pr_url": pr_url,
        "last_seen_review_id": 0,
    }
    if pr_title:
        state_update["pr_title"] = pr_title

    update_issue_state(issue_url, state_update)
    span.set_attribute("implement.status", "pr_open")
    span.set_attribute("implement.pr_url", pr_url)
    ref = issue_ref(owner, repo, number)
    label = f"{ref}: {pr_title}" if pr_title else ref
    log.info("[%s] PR open — monitoring for reviews: %s", label, pr_url)


def _checkout_wip_branch(repo_path, branch_name: str) -> None:
    """Checkout an existing WIP branch if it exists (locally or on remote)."""
    cwd = str(repo_path)

    result = subprocess.run(
        ["git", "branch", "--list", branch_name],
        cwd=cwd, capture_output=True, text=True,
    )
    if result.stdout.strip():
        subprocess.run(["git", "checkout", branch_name], cwd=cwd, capture_output=True)
        subprocess.run(["git", "pull", "origin", branch_name], cwd=cwd, capture_output=True)
        log.info("Resumed WIP branch %s (local)", branch_name)
        return

    result = subprocess.run(
        ["git", "ls-remote", "--heads", "origin", branch_name],
        cwd=cwd, capture_output=True, text=True,
    )
    if result.stdout.strip():
        subprocess.run(
            ["git", "checkout", "-b", branch_name, f"origin/{branch_name}"],
            cwd=cwd, capture_output=True,
        )
        log.info("Resumed WIP branch %s (remote)", branch_name)
        return

    log.info("No existing WIP branch %s found — starting fresh", branch_name)


def _build_prompt(issue, plan_text: str, discussion_text: str, owner: str, repo: str,
                  number: int, repo_path: str, branch_name: str) -> str:
    return render_template(
        "implement.j2",
        number=number,
        title=issue.title,
        owner=owner,
        repo=repo,
        body=issue.body or "(empty)",
        plan_text=plan_text,
        discussion_text=discussion_text,
        repo_path=repo_path,
        branch_name=branch_name,
    )


def _post_result(g, owner: str, repo: str, number: int, pr_url: str,
                 cost_eur: float | None = None) -> None:
    body = f"Implementation complete — PR opened: {pr_url}"
    if cost_eur is not None:
        body += format_cost_line(cost_eur)
    post_comment(g, owner, repo, number, body)