@mindfoldhq/trellis 0.4.0 → 0.5.0-beta.1

package/dist/templates/trellis/scripts/multi_agent/create_pr.py

@@ -1,620 +0,0 @@
-#!/usr/bin/env python3
-"""
-Multi-Agent Pipeline: Create PR.
-
-Usage:
-    python3 create_pr.py [task-dir] [--dry-run]
-
-This script:
-1. Handles submodule changes (commit, push, PR) if any submodules are configured
-2. Stages and commits all main-repo changes (excluding workspace/)
-3. Pushes to origin
-4. Creates a Draft PR using `gh pr create`
-5. Updates task.json with status="completed", pr_url, submodule_prs, and current_phase
-
-Note: This is the only action that performs git commit, as it's the final
-step after all implementation and checks are complete.
-"""
-
-from __future__ import annotations
-
-import argparse
-import subprocess
-import sys
-from pathlib import Path
-
-import _bootstrap  # noqa: F401 — adds parent scripts/ dir to sys.path
-
-from common.config import get_submodule_packages
-from common.git import run_git
-from common.io import read_json, write_json
-from common.log import Colors
-from common.paths import (
-    DIR_WORKFLOW,
-    FILE_TASK_JSON,
-    get_current_task,
-    get_repo_root,
-)
-from common.phase import get_phase_for_action
-
-# Colors, read_json, write_json
-# are now imported from common.log and common.io above.
-
-
-# =============================================================================
-# Submodule PR Helpers
-# =============================================================================
-
-# Warning message prepended to main PR body when submodule PRs exist
-_SUBMODULE_SQUASH_WARNING_MARKER = (
-    "Merge submodule PR(s) first. If squash-merged, update submodule ref after merge."
-)
-
-
-def _get_submodule_default_branch(submodule_abs: Path) -> str:
-    """Get the default branch of a submodule repository.
-
-    Uses `git symbolic-ref refs/remotes/origin/HEAD` for portability
-    (no grep, no English-dependent output).
-
-    Returns:
-        Default branch name (e.g. "main"), falls back to "main" on failure.
-    """
-    ret, out, _ = run_git(
-        ["symbolic-ref", "refs/remotes/origin/HEAD"], cwd=submodule_abs
-    )
-    if ret == 0 and out.strip():
-        # Output: "refs/remotes/origin/main" -> "main"
-        ref = out.strip()
-        prefix = "refs/remotes/origin/"
-        if ref.startswith(prefix):
-            return ref[len(prefix):]
-    return "main"
-
-
-def _process_submodule_changes(
-    repo_root: Path,
-    current_branch: str,
-    commit_prefix: str,
-    scope: str,
-    task_name: str,
-    task_data: dict,
-    task_json: Path,
-    dry_run: bool,
-) -> tuple[dict[str, str], list[str], bool]:
-    """Process submodule changes: commit, push, create PRs.
-
-    Returns:
-        Tuple of (submodule_prs dict, changed_submodule_paths list, success bool).
-        On failure, submodule_prs contains URLs persisted so far.
-    """
-    submodule_packages = get_submodule_packages(repo_root)
-    if not submodule_packages:
-        return {}, [], True
-
-    # Load existing submodule_prs for incremental merge
-    raw_prs = task_data.get("submodule_prs")
-    submodule_prs: dict[str, str] = dict(raw_prs) if isinstance(raw_prs, dict) else {}
-
-    # Detect which submodules have changes
-    changed: list[tuple[str, str]] = []  # (name, path)
-    for pkg_name, pkg_path in submodule_packages.items():
-        sub_abs = repo_root / pkg_path
-        if not sub_abs.is_dir():
-            continue
-
-        ret, status_out, _ = run_git(
-            ["status", "--porcelain"], cwd=sub_abs
-        )
-        if ret != 0:
-            continue
-        if status_out.strip():
-            changed.append((pkg_name, pkg_path))
-
-    if not changed:
-        return submodule_prs, [], True
-
-    # Determine submodule branch name: <repo-dir-name>/<main-branch>
-    repo_dir_name = repo_root.name
-    sub_branch = f"{repo_dir_name}/{current_branch}"
-
-    print(f"\n{Colors.BLUE}=== Submodule Changes Detected ==={Colors.NC}")
-    for pkg_name, pkg_path in changed:
-        print(f"  - {pkg_name} ({pkg_path})")
-    print()
-
-    changed_paths: list[str] = []
-
-    for pkg_name, pkg_path in changed:
-        sub_abs = repo_root / pkg_path
-        sub_base = _get_submodule_default_branch(sub_abs)
-        sub_commit_msg = f"{commit_prefix}({scope}): {task_name}"
-
-        print(f"{Colors.YELLOW}Processing submodule: {pkg_name} ({pkg_path}){Colors.NC}")
-        print(f"  Submodule base branch: {sub_base}")
-        print(f"  Submodule branch: {sub_branch}")
-
-        if dry_run:
-            print(f"  [DRY-RUN] Would checkout branch: {sub_branch}")
-            print(f"  [DRY-RUN] Would commit: {sub_commit_msg}")
-            print(f"  [DRY-RUN] Would push to: origin/{sub_branch}")
-            print(f"  [DRY-RUN] Would create PR: {sub_branch} -> {sub_base}")
-            submodule_prs[pkg_name] = "https://github.com/example/repo/pull/DRY-RUN"
-            changed_paths.append(pkg_path)
-            continue
-
-        # --- Checkout or create branch in submodule ---
-        ret, _, _ = run_git(
-            ["show-ref", "--verify", "--quiet", f"refs/heads/{sub_branch}"],
-            cwd=sub_abs,
-        )
-        if ret == 0:
-            # Branch exists, checkout
-            ret, _, err = run_git(
-                ["checkout", sub_branch], cwd=sub_abs
-            )
-            if ret != 0:
-                print(f"{Colors.RED}Failed to checkout branch in {pkg_name}: {err}{Colors.NC}")
-                return submodule_prs, changed_paths, False
-
-            # Check for divergence (reuse risk)
-            ret_anc, _, _ = run_git(
-                ["merge-base", "--is-ancestor", sub_base, sub_branch],
-                cwd=sub_abs,
-            )
-            if ret_anc != 0:
-                print(
-                    f"  {Colors.YELLOW}[WARN] submodule branch has diverged history, "
-                    f"consider recreating{Colors.NC}"
-                )
-        else:
-            # Create new branch
-            ret, _, err = run_git(
-                ["checkout", "-b", sub_branch], cwd=sub_abs
-            )
-            if ret != 0:
-                print(f"{Colors.RED}Failed to create branch in {pkg_name}: {err}{Colors.NC}")
-                return submodule_prs, changed_paths, False
-
-        # --- Stage and commit ---
-        run_git(["add", "-A"], cwd=sub_abs)
-
-        ret, _, _ = run_git(["diff", "--cached", "--quiet"], cwd=sub_abs)
-        if ret != 0:
-            # Has staged changes
-            ret, _, err = run_git(
-                ["commit", "-m", sub_commit_msg], cwd=sub_abs
-            )
-            if ret != 0:
-                print(f"{Colors.RED}Failed to commit in {pkg_name}: {err}{Colors.NC}")
-                return submodule_prs, changed_paths, False
-            print(f"  {Colors.GREEN}Committed in {pkg_name}{Colors.NC}")
-        else:
-            print(f"  No staged changes in {pkg_name}, skipping commit")
-
-        # --- Push ---
-        ret, _, err = run_git(
-            ["push", "-u", "origin", sub_branch], cwd=sub_abs
-        )
-        if ret != 0:
-            print(f"{Colors.RED}Failed to push {pkg_name}: {err}{Colors.NC}")
-            return submodule_prs, changed_paths, False
-        print(f"  {Colors.GREEN}Pushed {pkg_name} to origin/{sub_branch}{Colors.NC}")
-
-        # --- Create or reuse PR ---
-        result = subprocess.run(
-            [
-                "gh", "pr", "list",
-                "--head", sub_branch,
-                "--base", sub_base,
-                "--json", "url",
-                "--jq", ".[0].url",
-            ],
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-            cwd=str(sub_abs),
-        )
-        existing_sub_pr = result.stdout.strip()
-
-        if existing_sub_pr:
-            print(f"  {Colors.YELLOW}PR already exists: {existing_sub_pr}{Colors.NC}")
-            sub_pr_url = existing_sub_pr
-        else:
-            result = subprocess.run(
-                [
-                    "gh", "pr", "create",
-                    "--draft",
-                    "--base", sub_base,
-                    "--title", f"{commit_prefix}({scope}): {task_name} [{pkg_name}]",
-                    "--body", f"Submodule changes for {task_name}",
-                ],
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-                errors="replace",
-                cwd=str(sub_abs),
-            )
-            if result.returncode != 0:
-                print(
-                    f"{Colors.RED}Failed to create PR for {pkg_name}: "
-                    f"{result.stderr}{Colors.NC}"
-                )
-                return submodule_prs, changed_paths, False
-
-            sub_pr_url = result.stdout.strip()
-            print(f"  {Colors.GREEN}PR created for {pkg_name}: {sub_pr_url}{Colors.NC}")
-
-        # Persist immediately (incremental, supports re-entry)
-        submodule_prs[pkg_name] = sub_pr_url
-        task_data["submodule_prs"] = submodule_prs
-        write_json(task_json, task_data)
-
-        changed_paths.append(pkg_path)
-
-    return submodule_prs, changed_paths, True
-
-
-def _build_submodule_warning(submodule_prs: dict[str, str]) -> str:
-    """Build the squash-merge warning block for the main PR body."""
-    pr_lines = "\n".join(f"> - {name}: {url}" for name, url in submodule_prs.items())
-    return (
-        f"> {_SUBMODULE_SQUASH_WARNING_MARKER}\n"
-        f">\n"
-        f"> Submodule PRs:\n"
-        f"{pr_lines}\n"
-        f"\n---\n\n"
-    )
-
-
-def _ensure_submodule_warning_on_existing_pr(
-    submodule_prs: dict[str, str],
-    dry_run: bool,
-) -> None:
-    """Read-modify-write: add squash warning to existing PR if missing."""
-    if dry_run:
-        print("[DRY-RUN] Would check/add submodule warning to existing PR")
-        return
-
-    # Read current PR body
-    result = subprocess.run(
-        [
-            "gh", "pr", "view",
-            "--json", "body",
-            "--jq", ".body",
-        ],
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
-    )
-    if result.returncode != 0:
-        return
-
-    current_body = result.stdout.strip()
-    if _SUBMODULE_SQUASH_WARNING_MARKER in current_body:
-        return  # Warning already present
-
-    # Prepend warning to existing body
-    warning = _build_submodule_warning(submodule_prs)
-    new_body = warning + current_body
-
-    subprocess.run(
-        ["gh", "pr", "edit", "--body", new_body],
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
-    )
-    print(f"  {Colors.GREEN}Added submodule merge warning to existing PR{Colors.NC}")
-
-
-# =============================================================================
-# Main
-# =============================================================================
-
-
-def main() -> int:
-    """Main entry point."""
-    parser = argparse.ArgumentParser(description="Multi-Agent Pipeline: Create PR")
-    parser.add_argument("dir", nargs="?", help="Task directory")
-    parser.add_argument(
-        "--dry-run", action="store_true", help="Show what would be done"
-    )
-
-    args = parser.parse_args()
-    repo_root = get_repo_root()
-
-    # =============================================================================
-    # Get Task Directory
-    # =============================================================================
-    target_dir = args.dir
-    if not target_dir:
-        # Try to get from .current-task
-        current_task = get_current_task(repo_root)
-        if current_task:
-            target_dir = current_task
-
-    if not target_dir:
-        print(
-            f"{Colors.RED}Error: No task directory specified and no current task set{Colors.NC}"
-        )
-        print("Usage: python3 create_pr.py [task-dir] [--dry-run]")
-        return 1
-
-    # Support relative paths
-    if not target_dir.startswith("/"):
-        target_dir_path = repo_root / target_dir
-    else:
-        target_dir_path = Path(target_dir)
-
-    task_json = target_dir_path / FILE_TASK_JSON
-    if not task_json.is_file():
-        print(f"{Colors.RED}Error: task.json not found at {target_dir_path}{Colors.NC}")
-        return 1
-
-    # =============================================================================
-    # Main
-    # =============================================================================
-    print(f"{Colors.BLUE}=== Create PR ==={Colors.NC}")
-    if args.dry_run:
-        print(
-            f"{Colors.YELLOW}[DRY-RUN MODE] No actual changes will be made{Colors.NC}"
-        )
-    print()
-
-    # Read task config
-    task_data = read_json(task_json)
-    if not task_data:
-        print(f"{Colors.RED}Error: Failed to read task.json{Colors.NC}")
-        return 1
-
-    task_name = task_data.get("name", "")
-    base_branch = task_data.get("base_branch", "main")
-    scope = task_data.get("scope", "core")
-    dev_type = task_data.get("dev_type", "feature")
-
-    # Map dev_type to commit prefix
-    prefix_map = {
-        "feature": "feat",
-        "frontend": "feat",
-        "backend": "feat",
-        "fullstack": "feat",
-        "bugfix": "fix",
-        "fix": "fix",
-        "refactor": "refactor",
-        "docs": "docs",
-        "test": "test",
-    }
-    commit_prefix = prefix_map.get(dev_type, "feat")
-
-    print(f"Task: {task_name}")
-    print(f"Base branch: {base_branch}")
-    print(f"Scope: {scope}")
-    print(f"Commit prefix: {commit_prefix}")
-    print()
-
-    # Get current branch
-    _, branch_out, _ = run_git(["branch", "--show-current"])
-    current_branch = branch_out.strip()
-    print(f"Current branch: {current_branch}")
-
-    # =============================================================================
-    # Submodule PR Flow (runs BEFORE main repo staging)
-    # =============================================================================
-    submodule_prs, changed_submodule_paths, sub_success = _process_submodule_changes(
-        repo_root=repo_root,
-        current_branch=current_branch,
-        commit_prefix=commit_prefix,
-        scope=scope,
-        task_name=task_name,
-        task_data=task_data,
-        task_json=task_json,
-        dry_run=args.dry_run,
-    )
-
-    if not sub_success:
-        print(
-            f"\n{Colors.RED}Submodule PR flow failed. "
-            f"Skipping main repo commit/PR.{Colors.NC}"
-        )
-        print("Already-created submodule PRs have been saved to task.json.")
-        return 1
-
-    # =============================================================================
-    # Main Repo: Stage, Commit, Push, PR
-    # =============================================================================
-
-    # Check for changes
-    print(f"{Colors.YELLOW}Checking for changes...{Colors.NC}")
-
-    # Stage changes
-    run_git(["add", "-A"])
-
-    # Exclude workspace and temp files
-    run_git(["reset", f"{DIR_WORKFLOW}/workspace/"])
-    run_git(["reset", ".agent-log", ".session-id"])
-
-    # If submodules changed, ensure their ref updates are staged
-    for sub_path in changed_submodule_paths:
-        run_git(["add", sub_path])
-
-    # Check if there are staged changes
-    ret, _, _ = run_git(["diff", "--cached", "--quiet"])
-    has_staged_changes = ret != 0
-
-    if not has_staged_changes:
-        print(f"{Colors.YELLOW}No staged changes to commit{Colors.NC}")
-
-        # Check for unpushed commits
-        ret, log_out, _ = run_git(
-            ["log", f"origin/{current_branch}..HEAD", "--oneline"]
-        )
-        unpushed = len([line for line in log_out.splitlines() if line.strip()])
-
-        if unpushed == 0:
-            if args.dry_run:
-                run_git(["reset", "HEAD"])
-            print(f"{Colors.RED}No changes to create PR{Colors.NC}")
-            return 1
-
-        print(f"Found {unpushed} unpushed commit(s)")
-    else:
-        # Commit changes
-        print(f"{Colors.YELLOW}Committing changes...{Colors.NC}")
-        commit_msg = f"{commit_prefix}({scope}): {task_name}"
-
-        if args.dry_run:
-            print(f"[DRY-RUN] Would commit with message: {commit_msg}")
-            print("[DRY-RUN] Staged files:")
-            _, staged_out, _ = run_git(["diff", "--cached", "--name-only"])
-            for line in staged_out.splitlines():
-                print(f"  - {line}")
-        else:
-            run_git(["commit", "-m", commit_msg])
-            print(f"{Colors.GREEN}Committed: {commit_msg}{Colors.NC}")
-
-    # Push to remote
-    print(f"{Colors.YELLOW}Pushing to remote...{Colors.NC}")
-    if args.dry_run:
-        print(f"[DRY-RUN] Would push to: origin/{current_branch}")
-    else:
-        ret, _, err = run_git(["push", "-u", "origin", current_branch])
-        if ret != 0:
-            print(f"{Colors.RED}Failed to push: {err}{Colors.NC}")
-            return 1
-        print(f"{Colors.GREEN}Pushed to origin/{current_branch}{Colors.NC}")
-
-    # Create PR
-    print(f"{Colors.YELLOW}Creating PR...{Colors.NC}")
-    pr_title = f"{commit_prefix}({scope}): {task_name}"
-    pr_url = ""
-
-    # Build PR body with optional submodule warning
-    has_submodule_prs = bool(submodule_prs)
-
-    if args.dry_run:
-        print("[DRY-RUN] Would create PR:")
-        print(f"  Title: {pr_title}")
-        print(f"  Base:  {base_branch}")
-        print(f"  Head:  {current_branch}")
-        prd_file = target_dir_path / "prd.md"
-        if prd_file.is_file():
-            print("  Body:  (from prd.md)")
-        if has_submodule_prs:
-            print("  Body includes submodule merge warning")
-        pr_url = "https://github.com/example/repo/pull/DRY-RUN"
-    else:
-        # Check if PR already exists
-        result = subprocess.run(
-            [
-                "gh",
-                "pr",
-                "list",
-                "--head",
-                current_branch,
-                "--base",
-                base_branch,
-                "--json",
-                "url",
-                "--jq",
-                ".[0].url",
-            ],
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-        )
-        existing_pr = result.stdout.strip()
-
-        if existing_pr:
-            print(f"{Colors.YELLOW}PR already exists: {existing_pr}{Colors.NC}")
-            pr_url = existing_pr
-
-            # Read-modify-write: add submodule warning if missing
-            if has_submodule_prs:
-                _ensure_submodule_warning_on_existing_pr(
-                    submodule_prs, args.dry_run
-                )
-        else:
-            # Read PRD as PR body
-            pr_body = ""
-            prd_file = target_dir_path / "prd.md"
-            if prd_file.is_file():
-                pr_body = prd_file.read_text(encoding="utf-8")
-
-            # Prepend submodule warning if applicable
-            if has_submodule_prs:
-                pr_body = _build_submodule_warning(submodule_prs) + pr_body
-
-            # Create PR
-            result = subprocess.run(
-                [
-                    "gh",
-                    "pr",
-                    "create",
-                    "--draft",
-                    "--base",
-                    base_branch,
-                    "--title",
-                    pr_title,
-                    "--body",
-                    pr_body,
-                ],
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-                errors="replace",
-            )
-
-            if result.returncode != 0:
-                print(f"{Colors.RED}Failed to create PR: {result.stderr}{Colors.NC}")
-                return 1
-
-            pr_url = result.stdout.strip()
-            print(f"{Colors.GREEN}PR created: {pr_url}{Colors.NC}")
-
-    # Update task.json
-    print(f"{Colors.YELLOW}Updating task status...{Colors.NC}")
-    if args.dry_run:
-        print("[DRY-RUN] Would update task.json:")
-        print("  status: completed")
-        print(f"  pr_url: {pr_url}")
-        if has_submodule_prs:
-            print(f"  submodule_prs: {submodule_prs}")
-        print("  current_phase: (set to create-pr phase)")
-    else:
-        # Get the phase number for create-pr action
-        create_pr_phase = get_phase_for_action(task_json, "create-pr")
-        if not create_pr_phase:
-            create_pr_phase = 4  # Default fallback
-
-        task_data["status"] = "completed"
-        task_data["pr_url"] = pr_url
-        task_data["current_phase"] = create_pr_phase
-        if has_submodule_prs:
-            task_data["submodule_prs"] = submodule_prs
-
-        write_json(task_json, task_data)
-        print(
-            f"{Colors.GREEN}Task status updated to 'completed', phase {create_pr_phase}{Colors.NC}"
-        )
-
-    # In dry-run, reset the staging area
-    if args.dry_run:
-        run_git(["reset", "HEAD"])
-
-    print()
-    print(f"{Colors.GREEN}=== PR Created Successfully ==={Colors.NC}")
-    print(f"PR URL: {pr_url}")
-    if has_submodule_prs:
-        print("Submodule PRs:")
-        for name, url in submodule_prs.items():
-            print(f"  - {name}: {url}")
-
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())