autopilot-code 2.1.1 → 2.2.1

package/dist/cli.js

@@ -538,9 +538,16 @@ program
 });
 program
     .command("status")
-    .description("Show the status of the autopilot systemd service")
-    .action(() => {
-    statusSystemdService();
+    .description("Show active issues and their current state")
+    .option("--service", "Show systemd service status instead of issues")
+    .action((opts) => {
+    if (opts.service) {
+        statusSystemdService();
+    }
+    else {
+        const statusScriptPath = node_path_1.default.join(repoRoot, "scripts", "issue_status.py");
+        run("python3", [statusScriptPath]);
+    }
 });
 program
     .command("logs")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autopilot-code",
-  "version": "2.1.1",
+  "version": "2.2.1",
   "private": false,
   "description": "Repo-issue–driven autopilot runner",
   "license": "MIT",
@@ -28,7 +28,7 @@
   },
   "devDependencies": {
     "@changesets/cli": "^2.29.8",
-    "@types/node": "^22.10.2",
+    "@types/node": "^22.19.7",
     "typescript": "^5.7.2"
   }
 }

package/scripts/issue_status.py

@@ -0,0 +1,367 @@
+#!/usr/bin/env python3
+"""Show autopilot status for active issues."""
+
+import argparse
+import json
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Any, Optional
+
+STATE_DIR = ".autopilot"
+STATE_FILE = "state.json"
+DEFAULT_MAX_DEPTH = 3
+IGNORED_DIRS = {
+    "node_modules",
+    ".venv",
+    "venv",
+    ".env",
+    "env",
+    ".git",
+    ".idea",
+    ".vscode",
+    "dist",
+    "build",
+    "target",
+    "bin",
+    "obj",
+    "__pycache__",
+}
+
+
+def sh(cmd: list[str], cwd: Path | None = None, check: bool = True) -> str:
+    p = subprocess.run(
+        cmd,
+        cwd=str(cwd) if cwd else None,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+    )
+    if check and p.returncode != 0:
+        raise RuntimeError(
+            f"command failed ({p.returncode}): {' '.join(cmd)}\n{p.stdout}"
+        )
+    return p.stdout
+
+
+def is_git_repo(dir_path: Path) -> bool:
+    return (dir_path / ".git").exists()
+
+
+def get_repo_name(dir: Path) -> Optional[str]:
+    try:
+        res = subprocess.run(
+            ["git", "remote", "get-url", "origin"],
+            cwd=str(dir),
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        url = res.stdout.strip()
+
+        if "@github.com:" in url:
+            return url.split("@github.com:")[1].replace(".git", "")
+
+        if "github.com/" in url:
+            return url.split("github.com/")[1].replace(".git", "")
+
+        return None
+    except Exception:
+        return None
+
+
+def load_config(repo_root: Path) -> Optional[dict[str, Any]]:
+    cfg_path = repo_root / ".autopilot" / "autopilot.json"
+    if not cfg_path.exists():
+        return None
+    data = json.loads(cfg_path.read_text(encoding="utf8"))
+    if not data.get("enabled", False):
+        return None
+    return data
+
+
+def discover_repos(
+    root: Path, max_depth: int = DEFAULT_MAX_DEPTH
+) -> list[dict[str, Any]]:
+    out: list[dict[str, Any]] = []
+    _discover_repos_recursive(root, 0, max_depth, out)
+    return out
+
+
+def _discover_repos_recursive(
+    current_dir: Path, current_depth: int, max_depth: int, out: list[dict[str, Any]]
+) -> None:
+    if current_depth > max_depth:
+        return
+
+    if (current_dir / ".git").exists():
+        if (current_dir / ".autopilot" / "autopilot.json").exists():
+            try:
+                cfg = load_config(current_dir)
+                if cfg:
+                    out.append(
+                        {"root": current_dir, "repo": cfg["repo"], "config": cfg}
+                    )
+            except Exception as e:
+                print(f"Error loading config in {current_dir}: {e}", file=sys.stderr)
+        return
+
+    try:
+        for child in sorted(current_dir.iterdir(), key=lambda p: p.name.lower()):
+            if not child.is_dir():
+                continue
+            if child.name in IGNORED_DIRS or child.name.startswith("."):
+                continue
+            _discover_repos_recursive(child, current_depth + 1, max_depth, out)
+    except (PermissionError, OSError):
+        pass
+
+
+def get_state_comment(repo: str, issue_number: int) -> Optional[dict[str, Any]]:
+    try:
+        result = sh(
+            [
+                "gh",
+                "issue",
+                "view",
+                str(issue_number),
+                "--repo",
+                repo,
+                "--json",
+                "comments",
+                "--jq",
+                '.comments[] | select(.body | contains("<!-- autopilot-state"))',
+            ]
+        )
+
+        if not result.strip():
+            return None
+
+        comments = json.loads("[" + result + "]")
+        for comment in comments:
+            body = comment.get("body", "")
+            if "<!-- autopilot-state" in body:
+                import re
+
+                match = re.search(
+                    r"<!-- autopilot-state\s*\n({.*?})\s*\n-->", body, re.DOTALL
+                )
+                if match:
+                    return json.loads(match.group(1))
+    except Exception:
+        pass
+    return None
+
+
+def get_pr_info(repo: str, branch: str) -> Optional[dict[str, Any]]:
+    try:
+        cmd = [
+            "gh",
+            "pr",
+            "list",
+            "--repo",
+            repo,
+            "--head",
+            branch,
+            "--json",
+            "number,state,mergeable,mergeStateStatus,statusCheckRollup",
+            "--limit",
+            "1",
+        ]
+        raw = sh(cmd, check=False)
+        prs = json.loads(raw)
+        if prs:
+            return prs[0]
+    except Exception:
+        pass
+    return None
+
+
+def format_duration(seconds: int) -> str:
+    hours = seconds // 3600
+    minutes = (seconds % 3600) // 60
+    secs = seconds % 60
+
+    if hours > 0:
+        return f"{hours}h {minutes}m {secs}s"
+    if minutes > 0:
+        return f"{minutes}m {secs}s"
+    return f"{secs}s"
+
+
+def get_step_from_label(labels: list[str]) -> Optional[str]:
+    for label in labels:
+        if label.startswith("autopilot:") and label != "autopilot:in-progress":
+            return label
+    return None
+
+
+def display_status(repo_statuses: dict[str, list[dict[str, Any]]]) -> None:
+    if not repo_statuses:
+        print("No active issues found.")
+        return
+
+    for repo, issues in repo_statuses.items():
+        print(f"\nStatus for {repo}")
+
+        if not issues:
+            print("  No active issues")
+            continue
+
+        for issue in issues:
+            print(f"\n#{issue['number']} - {issue['title']}")
+            print(f"  State: {issue.get('state', 'unknown')}")
+
+            step_label = issue.get("step_label")
+            if step_label:
+                step_name = step_label.replace("autopilot:", "")
+                step_name = step_name.replace("-", " ").title()
+                print(f"  Step: {step_name}")
+
+            duration = issue.get("duration", 0)
+            if duration > 0:
+                print(f"  Duration: {format_duration(duration)}")
+
+            branch = issue.get("branch")
+            if branch:
+                print(f"  Branch: {branch}")
+
+            pr_info = issue.get("pr_info")
+            if pr_info:
+                pr_num = pr_info.get("number")
+                state = pr_info.get("state", "unknown")
+                mergeable = pr_info.get("mergeable", "unknown")
+
+                if mergeable == "CONFLICTING":
+                    mergeable = "conflicts"
+                elif mergeable == "MERGEABLE":
+                    mergeable = "ready"
+
+                checks = pr_info.get("statusCheckRollup", [])
+                if isinstance(checks, dict):
+                    check_status = checks.get("state", "unknown")
+                elif checks:
+                    passing = sum(1 for c in checks if c.get("conclusion") == "SUCCESS")
+                    failing = sum(1 for c in checks if c.get("conclusion") == "FAILURE")
+                    pending = sum(
+                        1
+                        for c in checks
+                        if c.get("conclusion") in ("PENDING", "QUEUED", None)
+                    )
+
+                    if failing > 0:
+                        check_status = f"{passing} passing, {failing} failing"
+                    elif pending > 0:
+                        check_status = f"{passing} passing, {pending} pending"
+                    else:
+                        check_status = f"{passing} passing"
+                else:
+                    check_status = "none"
+
+                print(
+                    f"  PR: #{pr_num} (state: {state}, mergeable: {mergeable}, checks: {check_status})"
+                )
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--root", nargs="+", default=None, help="Root folders to scan")
+    args = ap.parse_args()
+
+    cwd = Path.cwd()
+    repo_configs = []
+
+    if is_git_repo(cwd):
+        repo_name = get_repo_name(cwd)
+        if repo_name:
+            cfg = load_config(cwd)
+            if cfg:
+                repo_configs.append({"root": cwd, "repo": repo_name, "config": cfg})
+                print(f"Showing status for current repo: {repo_name}")
+    else:
+        root_paths = args.root if args.root else [Path.home()]
+        for root_str in root_paths:
+            root = Path(root_str).resolve()
+            if root.exists() and root.is_dir():
+                repo_configs.extend(discover_repos(root))
+
+    if not repo_configs:
+        print("No autopilot-enabled repos found.")
+        return 0
+
+    repo_statuses: dict[str, list[dict[str, Any]]] = {}
+    now = int(time.time())
+
+    for repo_cfg in repo_configs:
+        repo = repo_cfg["repo"]
+        repo_root = repo_cfg["root"]
+        config = repo_cfg.get("config", {})
+
+        labels_config = config.get("issueLabels", {})
+        in_progress_label = labels_config.get("inProgress", "autopilot:in-progress")
+
+        try:
+            cmd = [
+                "gh",
+                "issue",
+                "list",
+                "--repo",
+                repo,
+                "--limit",
+                "50",
+                "--search",
+                f"is:open label:{in_progress_label}",
+                "--json",
+                "number,title,labels,updatedAt,createdAt",
+            ]
+            raw = sh(cmd)
+            issues = json.loads(raw)
+
+            repo_issues = []
+            for issue in issues:
+                issue_num = issue["number"]
+
+                labels = [l["name"] for l in issue.get("labels", [])]
+                step_label = get_step_from_label(labels)
+
+                state_comment = get_state_comment(repo, issue_num)
+                branch = None
+                if state_comment:
+                    branch = state_comment.get("branch")
+
+                pr_info = None
+                if branch:
+                    pr_info = get_pr_info(repo, branch)
+
+                updated_at = issue.get("updatedAt", "")
+                if updated_at:
+                    from datetime import datetime
+
+                    dt = datetime.fromisoformat(updated_at.replace("Z", "+00:00"))
+                    duration = now - int(dt.timestamp())
+                else:
+                    duration = 0
+
+                repo_issues.append(
+                    {
+                        "number": issue_num,
+                        "title": issue["title"],
+                        "state": step_label or in_progress_label,
+                        "step_label": step_label,
+                        "duration": duration,
+                        "branch": branch,
+                        "pr_info": pr_info,
+                    }
+                )
+
+            repo_statuses[repo] = repo_issues
+        except Exception as e:
+            print(f"Error fetching status for {repo}: {e}", file=sys.stderr)
+
+    display_status(repo_statuses)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())