autopilot-code 0.8.0 → 0.10.0

package/README.md

@@ -15,6 +15,53 @@ A repo is considered autopilot-enabled when it contains:
 
 - `.autopilot/autopilot.json` with `enabled: true`
 
+## Quick Start
+
+### Choosing an Agent
+
+Autopilot supports multiple agent types:
+
+**opencode** (recommended): Full-featured agent with extensive code understanding
+```json
+{
+  "agent": "opencode"
+}
+```
+
+**claude**: Fast, targeted code changes
+```json
+{
+  "agent": "claude"
+}
+```
+
+### Enabling the New Runner
+
+The new runner provides enhanced progress tracking and session continuity:
+
+```json
+{
+  "useNewRunner": true,
+  "enablePlanningStep": true
+}
+```
+
+### Understanding Step Labels
+
+When using the new runner, issues progress through these labels:
+
+- `autopilot:planning` - Creating implementation plan
+- `autopilot:implementing` - Writing code
+- `autopilot:pr-created` - Pull request created
+- `autopilot:waiting-checks` - Waiting for CI
+- `autopilot:fixing-checks` - Fixing failing CI
+- `autopilot:merging` - Merging PR
+
+To create these labels in your repository:
+```bash
+autopilot setup-labels --repo owner/repo
+```
+
 Example:
 
 ```json
@@ -47,7 +94,8 @@ Example:
 
 Notes:
 - `repo` must be the GitHub `owner/name`.
-- `agent` (optional, default `"none"`): set to `"opencode"` to enable OpenCode integration after claiming issues.
+- `agent` (optional, default `"opencode"`): set to `"opencode"` or `"claude"` to choose which coding agent to use.
+- `useNewRunner` (optional, default `false`): enable the new runner with step labels and session continuity.
 - `autoMerge` (optional, default `true`): if `true`, autopilot will automatically merge PRs after checks pass.
 - `mergeMethod` (optional, default `"squash"`): merge strategy to use. Options: `"squash"`, `"merge"`, or `"rebase"`.
 - `allowedMergeUsers` (required when `autoMerge=true`): list of GitHub usernames allowed to auto-merge. The runner verifies the authenticated GitHub user is in this list before merging.
@@ -57,7 +105,8 @@ Notes:
 - `conflictResolutionMaxAttempts` (optional, default `3`): maximum number of attempts to resolve merge conflicts.
 - `autoFixChecks` (optional, default `true`): if `true`, autopilot will attempt to automatically fix failing CI checks.
 - `autoFixChecksMaxAttempts` (optional, default `3`): maximum number of attempts to fix failing checks.
-- `heartbeatMaxAgeSecs` controls how long an in-progress issue can go without a heartbeat before it's considered stale.
+- `enablePlanningStep` (optional, default `true`): if `true`, add an explicit planning phase before implementation (requires `useNewRunner: true`).
+- `agentPath` (optional): custom path to agent executable (defaults to searching PATH).
 
 ## Workflow (labels)
 Autopilot uses labels as a kanban state machine:

package/dist/cli.js

@@ -548,4 +548,63 @@ program
     .action(() => {
     logsSystemdService();
 });
+program
+    .command("setup-labels")
+    .description("Create required GitHub labels for autopilot workflow")
+    .option("--repo <owner/repo>", "Repository in owner/repo format")
+    .action((opts) => {
+    if (!opts.repo) {
+        const cwd = process.cwd();
+        const repoName = getRepoName(cwd);
+        if (!repoName) {
+            console.error("No --repo option provided and could not detect repo from current directory.");
+            console.error("Usage: autopilot setup-labels --repo owner/repo");
+            process.exit(1);
+        }
+        opts.repo = repoName;
+    }
+    const labels = [
+        { name: "autopilot:todo", color: "7057ff", description: "Ready to be picked up by autopilot" },
+        { name: "autopilot:in-progress", color: "0075ca", description: "Claimed by autopilot" },
+        { name: "autopilot:blocked", color: "d93f0b", description: "Needs human input or missing heartbeat" },
+        { name: "autopilot:done", color: "3fb950", description: "Completed" },
+        { name: "autopilot:backlog", color: "d4c5f9", description: "Captured, not ready" },
+        { name: "autopilot:planning", color: "5319e7", description: "Creating implementation plan" },
+        { name: "autopilot:implementing", color: "1f883d", description: "Writing code" },
+        { name: "autopilot:pr-created", color: "fbca04", description: "Pull request created" },
+        { name: "autopilot:waiting-checks", color: "0e8a16", description: "Waiting for CI checks" },
+        { name: "autopilot:fixing-checks", color: "cfd3d7", description: "Fixing failing CI checks" },
+        { name: "autopilot:merging", color: "bfd4f2", description: "Merging pull request" }
+    ];
+    console.log(`Creating labels for ${opts.repo}...`);
+    labels.forEach(label => {
+        const args = [
+            "api",
+            "--method",
+            "POST",
+            "-H",
+            "Accept: application/vnd.github+json",
+            "repos/${opts.repo}/labels",
+            "-f",
+            `name=${label.name}`,
+            "-f",
+            `color=${label.color}`,
+            "-f",
+            `description=${label.description}`
+        ];
+        const res = (0, node_child_process_1.spawnSync)("gh", args, { stdio: "pipe" });
+        if (res.status === 0) {
+            console.log(`✅ Created: ${label.name}`);
+        }
+        else if (res.stderr && res.stderr.toString().includes("Label already exists")) {
+            console.log(`ℹ️  Exists: ${label.name}`);
+        }
+        else {
+            console.error(`❌ Failed to create ${label.name}`);
+            if (res.stderr)
+                console.error(res.stderr.toString());
+        }
+    });
+    console.log("\n✅ Label setup complete!");
+});
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autopilot-code",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "private": false,
   "description": "Repo-issue–driven autopilot runner",
   "license": "MIT",

package/scripts/run_autopilot.py

@@ -25,6 +25,12 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 import shutil
+from sys import path as sys_path
+
+# Add scripts directory to path for imports
+script_dir = Path(__file__).parent
+sys_path.insert(0, str(script_dir))
+from issue_runner import IssueRunner
 
 STATE_DIR = ".autopilot"
 STATE_FILE = "state.json"
@@ -87,6 +93,8 @@ class RepoConfig:
     auto_fix_checks: bool
     auto_fix_checks_max_attempts: int
     auto_update: bool
+    use_new_runner: bool = False
+    config: dict[str, Any] = None
 
 
 def load_config(repo_root: Path) -> RepoConfig | None:
@@ -136,6 +144,8 @@ def load_config(repo_root: Path) -> RepoConfig | None:
         auto_fix_checks=auto_fix_checks,
         auto_fix_checks_max_attempts=auto_fix_checks_max_attempts,
         auto_update=data.get("autoUpdate", False),
+        use_new_runner=data.get("useNewRunner", False),
+        config=data,
     )
 
 
@@ -366,6 +376,18 @@ def claim_issue(cfg: RepoConfig, issue: dict[str, Any], note: str) -> None:
     touch_heartbeat(cfg, num)
 
 
+def clear_active_issue(cfg: RepoConfig, issue_number: int) -> None:
+    """Clear an issue from active issues state."""
+    state = load_state(cfg.root)
+    active_issues = state.get("activeIssues", {})
+    if isinstance(active_issues, dict):
+        issue_key = str(issue_number)
+        if issue_key in active_issues:
+            del active_issues[issue_key]
+            state["activeIssues"] = active_issues
+            write_state(cfg.root, state)
+
+
 def list_in_progress_issues(cfg: RepoConfig, limit: int = 20) -> list[dict[str, Any]]:
     cmd = [
         "gh",
@@ -736,6 +758,49 @@ def maybe_mark_blocked(cfg: RepoConfig, issue: dict[str, Any]) -> None:
     )
 
 
+def run_issue(cfg: RepoConfig, issue_number: int) -> bool:
+    """
+    Run the agent on an issue.
+    
+    Uses either the new Python runner or legacy bash script
+    based on configuration.
+    """
+    if cfg.use_new_runner:
+        return run_issue_new(cfg, issue_number)
+    else:
+        return run_issue_legacy(cfg, issue_number)
+
+
+def run_issue_new(cfg: RepoConfig, issue_number: int) -> bool:
+    """Run issue using new Python state machine runner."""
+    # Touch heartbeat before starting
+    touch_heartbeat(cfg, issue_number)
+    
+    runner = IssueRunner(
+        repo=cfg.repo,
+        repo_root=cfg.root,
+        config=cfg.config
+    )
+    
+    try:
+        success = runner.run(issue_number)
+    finally:
+        # Clear from active issues when done
+        clear_active_issue(cfg, issue_number)
+    
+    return success
+
+
+def run_issue_legacy(cfg: RepoConfig, issue_number: int) -> bool:
+    """Run issue using legacy bash script (existing behavior)."""
+    script_path = Path(__file__).parent / "run_opencode_issue.sh"
+    result = subprocess.run(
+        [str(script_path), str(cfg.root), str(issue_number)],
+        cwd=cfg.root
+    )
+    return result.returncode == 0
+
+
 def run_cycle(
     all_configs: list[RepoConfig],
     dry_run: bool = False,
@@ -816,18 +881,9 @@ def run_cycle(
             start_msg = f"🚀 Autopilot is now starting work on issue #{issue['number']}.\n\nI'll post regular progress updates as I work through the implementation."
             sh(["gh", "issue", "comment", str(issue["number"]), "--repo", cfg.repo, "--body", start_msg])
 
-            # If agent==opencode, delegate to bash script
+            # Run the issue using the appropriate runner
             if cfg.agent == "opencode":
-                # Script is in the same directory as this Python file
-                script_dir = Path(__file__).parent
-                script_path = script_dir / "run_opencode_issue.sh"
-                sh(
-                    [
-                        str(script_path),
-                        str(cfg.root),
-                        str(issue["number"]),
-                    ]
-                )
+                run_issue(cfg, issue["number"])
 
     # Check if autopilot needs to update
     if not dry_run and check_autopilot_needs_update():

package/templates/autopilot.json

@@ -1,18 +1,29 @@
 {
   "enabled": true,
-  "repo": "bakkensoftware/TicketToolbox",
+  "repo": "owner/repo",
   "agent": "opencode",
-  "allowedMergeUsers": ["github-username"],
+  "useNewRunner": false,
+  "autoMerge": true,
+  "mergeMethod": "squash",
+  "allowedMergeUsers": [],
   "issueLabels": {
     "queue": ["autopilot:todo"],
-    "blocked": "autopilot:blocked",
     "inProgress": "autopilot:in-progress",
+    "blocked": "autopilot:blocked",
     "done": "autopilot:done"
   },
+  "stepLabels": {
+    "planning": "autopilot:planning",
+    "implementing": "autopilot:implementing",
+    "prCreated": "autopilot:pr-created",
+    "waitingChecks": "autopilot:waiting-checks",
+    "fixingChecks": "autopilot:fixing-checks",
+    "merging": "autopilot:merging"
+  },
   "priorityLabels": ["p0", "p1", "p2"],
   "minPriority": null,
-  "maxParallel": 2,
   "ignoreIssueLabels": ["autopilot:backlog"],
+  "maxParallel": 2,
   "branchPrefix": "autopilot/",
   "allowedBaseBranch": "main",
   "autoResolveConflicts": true,
@@ -20,5 +31,6 @@
   "autoFixChecks": true,
   "autoFixChecksMaxAttempts": 3,
   "autoUpdate": true,
-  "enablePlanningStep": true
+  "enablePlanningStep": true,
+  "agentPath": ""
 }