autopilot-code 0.0.4 → 0.0.5

package/README.md

@@ -39,6 +39,7 @@ Example:
 Notes:
 - `repo` must be the GitHub `owner/name`.
 - `agent` (optional, default `"none"`): set to `"opencode"` to enable OpenCode integration after claiming issues.
+- `ignoreIssueLabels` (optional, default `["autopilot:backlog"]`): issues with any of these labels will be ignored by the runner.
 - `heartbeatMaxAgeSecs` controls how long an in-progress issue can go without a heartbeat before it's considered stale.
 
 ## Workflow (labels)
@@ -86,7 +87,11 @@ On each loop:
 ## Running locally
 ### Python runner
 ```bash
+# Run a single scan/claim/act cycle
 python3 scripts/run_autopilot.py --root /mnt/f/Source
+
+# Run in foreground loop mode (dev-friendly)
+python3 scripts/run_autopilot.py --root /mnt/f/Source --interval-seconds 60
 ```
 
 ### Node CLI wrapper
@@ -104,8 +109,13 @@ node dist/cli.js scan --root /mnt/f/Source
 
 # claim exactly one issue + comment
 node dist/cli.js run-once --root /mnt/f/Source
+
+# run service in foreground mode (dev-friendly)
+node dist/cli.js service --foreground --interval-seconds 60 --root /mnt/f/Source
 ```
 
+The foreground service mode runs continuously with the specified interval and logs to stdout. Press Ctrl+C to shut down cleanly.
+
 ## Roadmap
 - Spawn a coding agent (Claude Code / OpenCode) in a worktree per issue
 - Create PRs linked to issues; wait for checks to go green

package/dist/cli.js

@@ -6,7 +6,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
+const node_readline_1 = require("node:readline");
+const repoRoot = node_path_1.default.resolve(__dirname, "..");
+const packageJson = JSON.parse((0, node_fs_1.readFileSync)(node_path_1.default.join(repoRoot, "package.json"), "utf8"));
+const version = packageJson.version;
+const GLOBAL_CONFIG_DIR = node_path_1.default.join(process.env.HOME || "", ".config", "autopilot");
+const GLOBAL_CONFIG_FILE = node_path_1.default.join(GLOBAL_CONFIG_DIR, "config.json");
 function run(cmd, args) {
     const res = (0, node_child_process_1.spawnSync)(cmd, args, { stdio: "inherit" });
     if (res.error)
@@ -22,16 +29,126 @@ function check(cmd, args, label) {
     }
     if (typeof res.status === "number" && res.status !== 0) {
         console.error(`\n${label}: returned exit code ${res.status}`);
-        process.exit(res.status);
+        process.exit(1);
     }
 }
-const repoRoot = node_path_1.default.resolve(__dirname, "..");
+function loadGlobalConfig() {
+    if (!(0, node_fs_1.existsSync)(GLOBAL_CONFIG_FILE)) {
+        return null;
+    }
+    try {
+        const data = (0, node_fs_1.readFileSync)(GLOBAL_CONFIG_FILE, "utf8");
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+function saveGlobalConfig(config) {
+    (0, node_fs_1.mkdirSync)(GLOBAL_CONFIG_DIR, { recursive: true });
+    (0, node_fs_1.writeFileSync)(GLOBAL_CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf8");
+}
+function isGitRepo(dirPath) {
+    return (0, node_fs_1.existsSync)(node_path_1.default.join(dirPath, ".git"));
+}
+function prompt(question) {
+    const rl = (0, node_readline_1.createInterface)({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+function validatePath(pathStr) {
+    const resolvedPath = node_path_1.default.resolve(pathStr);
+    if (!(0, node_fs_1.existsSync)(resolvedPath)) {
+        return { valid: false, error: `Path does not exist: ${pathStr}` };
+    }
+    if (!isGitRepo(resolvedPath)) {
+        return { valid: true, isGit: false };
+    }
+    return { valid: true, isGit: true };
+}
+async function collectSourceFolders() {
+    const folders = [];
+    console.log("\n📁 Source Folder Selection");
+    console.log("Enter one or more directories containing git repos to scan.");
+    console.log("Leave empty when done.\n");
+    while (true) {
+        const input = await prompt(`Source folder #${folders.length + 1} (or press Enter to finish): `);
+        if (input === "") {
+            if (folders.length === 0) {
+                console.log("At least one source folder is required.");
+                continue;
+            }
+            break;
+        }
+        const validation = validatePath(input);
+        if (!validation.valid) {
+            console.error(`❌ ${validation.error}`);
+            continue;
+        }
+        const resolvedPath = node_path_1.default.resolve(input);
+        if (folders.includes(resolvedPath)) {
+            console.log("⚠️  This folder is already in the list.");
+            continue;
+        }
+        if (validation.isGit) {
+            console.log(`✅ Added git repo: ${resolvedPath}`);
+        }
+        else {
+            console.log(`✅ Added folder: ${resolvedPath} (will scan for git repos recursively)`);
+        }
+        folders.push(resolvedPath);
+    }
+    return folders;
+}
+async function initCommand() {
+    console.log("🚀 Autopilot Setup\n");
+    const existingConfig = loadGlobalConfig();
+    if (existingConfig && existingConfig.sourceFolders.length > 0) {
+        console.log("Existing configuration found:");
+        console.log("Current source folders:");
+        existingConfig.sourceFolders.forEach((folder, idx) => {
+            const isGit = isGitRepo(folder);
+            console.log(`  ${idx + 1}. ${folder}${isGit ? " (git repo)" : ""}`);
+        });
+        console.log();
+        const overwrite = await prompt("Do you want to replace this configuration? (y/N): ");
+        if (overwrite.toLowerCase() !== "y") {
+            console.log("Configuration unchanged.");
+            return;
+        }
+    }
+    const sourceFolders = await collectSourceFolders();
+    const config = {
+        sourceFolders,
+    };
+    saveGlobalConfig(config);
+    console.log("\n✅ Configuration saved to:", GLOBAL_CONFIG_FILE);
+    console.log("\nYou can now run:");
+    console.log("  autopilot scan      # Scan repos without claiming issues");
+    console.log("  autopilot run-once  # Claim and work on one issue");
+}
 const runnerPath = node_path_1.default.join(repoRoot, "scripts", "run_autopilot.py");
 const program = new commander_1.Command();
 program
     .name("autopilot")
     .description("Repo-issue–driven autopilot runner (CLI wrapper)")
-    .version("0.0.0");
+    .version(version);
+program
+    .command("init")
+    .description("Initialize autopilot configuration (select source folders)")
+    .action(() => {
+    initCommand().catch((err) => {
+        console.error("Error:", err);
+        process.exit(1);
+    });
+});
 program
     .command("doctor")
     .description("Check local prerequisites (gh auth, python3)")
@@ -44,15 +161,75 @@ program
 program
     .command("scan")
     .description("Discover autopilot-enabled repos + show next issue candidate (dry-run)")
-    .requiredOption("--root <path>", "Root folder that contains git repos")
+    .option("--root <paths...>", "Root folder(s) that contain git repos (space-separated)")
+    .option("--max-depth <number>", "Maximum depth for recursive repo discovery", "5")
     .action((opts) => {
-    run("python3", [runnerPath, "--root", opts.root, "--dry-run"]);
+    let rootPaths = opts.root;
+    if (!rootPaths || rootPaths.length === 0) {
+        const config = loadGlobalConfig();
+        if (!config || config.sourceFolders.length === 0) {
+            console.error("No source folders configured. Run 'autopilot init' first.");
+            process.exit(1);
+        }
+        rootPaths = config.sourceFolders;
+    }
+    const args = [runnerPath, "--root", ...rootPaths];
+    if (opts.maxDepth)
+        args.push("--max-depth", opts.maxDepth);
+    args.push("--dry-run");
+    run("python3", args);
 });
 program
     .command("run-once")
     .description("Claim exactly one issue and post a progress comment")
-    .requiredOption("--root <path>", "Root folder that contains git repos")
+    .option("--root <paths...>", "Root folder(s) that contain git repos (space-separated)")
+    .option("--max-depth <number>", "Maximum depth for recursive repo discovery", "5")
     .action((opts) => {
-    run("python3", [runnerPath, "--root", opts.root]);
+    let rootPaths = opts.root;
+    if (!rootPaths || rootPaths.length === 0) {
+        const config = loadGlobalConfig();
+        if (!config || config.sourceFolders.length === 0) {
+            console.error("No source folders configured. Run 'autopilot init' first.");
+            process.exit(1);
+        }
+        rootPaths = config.sourceFolders;
+    }
+    const args = [runnerPath, "--root", ...rootPaths];
+    if (opts.maxDepth)
+        args.push("--max-depth", opts.maxDepth);
+    run("python3", args);
+});
+program
+    .command("service")
+    .description("Run the autopilot service (foreground mode with loop)")
+    .option("--foreground", "Run in foreground mode (log to stdout)")
+    .option("--interval-seconds <number>", "Interval between cycles in seconds", "60")
+    .option("--root <paths...>", "Root folder(s) that contain git repos (space-separated)")
+    .option("--max-depth <number>", "Maximum depth for recursive repo discovery", "5")
+    .action((opts) => {
+    let rootPaths = opts.root;
+    if (!rootPaths || rootPaths.length === 0) {
+        const config = loadGlobalConfig();
+        if (!config || config.sourceFolders.length === 0) {
+            console.error("No source folders configured. Run 'autopilot init' first.");
+            process.exit(1);
+        }
+        rootPaths = config.sourceFolders;
+    }
+    const args = [runnerPath, "--root", ...rootPaths];
+    if (opts.maxDepth)
+        args.push("--max-depth", opts.maxDepth);
+    if (opts.foreground) {
+        const interval = opts.intervalSeconds || "60";
+        args.push("--interval-seconds", interval);
+        console.log(`Starting autopilot service in foreground mode (interval: ${interval}s)`);
+        console.log("Press Ctrl+C to shut down cleanly\n");
+        run("python3", args);
+    }
+    else {
+        console.error("Only --foreground mode is supported currently.");
+        console.error("For background service mode, use systemd integration (coming soon).");
+        process.exit(1);
+    }
 });
 program.parse();

package/package.json

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

package/scripts/run_autopilot.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 import argparse
 import json
 import os
+import signal
 import subprocess
 import sys
 import time
@@ -27,12 +28,37 @@ from typing import Any
 STATE_DIR = ".autopilot"
 STATE_FILE = "state.json"
 DEFAULT_HEARTBEAT_MAX_AGE_SECS = 60 * 60  # 1h
+DEFAULT_MAX_DEPTH = 5
+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)
+    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}")
+        raise RuntimeError(
+            f"command failed ({p.returncode}): {' '.join(cmd)}\n{p.stdout}"
+        )
     return p.stdout
 
 
@@ -49,6 +75,7 @@ class RepoConfig:
     max_parallel: int
     heartbeat_max_age_secs: int
     agent: str
+    ignore_issue_labels: list[str]
 
 
 def load_config(repo_root: Path) -> RepoConfig | None:
@@ -72,26 +99,60 @@ def load_config(repo_root: Path) -> RepoConfig | None:
         label_done=labels.get("done", "autopilot:done"),
         priority_labels=data.get("priorityLabels", ["p0", "p1", "p2"]),
         max_parallel=int(data.get("maxParallel", 2)),
-        heartbeat_max_age_secs=int(data.get("heartbeatMaxAgeSecs", DEFAULT_HEARTBEAT_MAX_AGE_SECS)),
+        heartbeat_max_age_secs=int(
+            data.get("heartbeatMaxAgeSecs", DEFAULT_HEARTBEAT_MAX_AGE_SECS)
+        ),
         agent=data.get("agent", "none"),
+        ignore_issue_labels=list(data.get("ignoreIssueLabels", ["autopilot:backlog"])),
     )
 
 
-def discover_repos(root: Path) -> list[RepoConfig]:
+def discover_repos(root: Path, max_depth: int = DEFAULT_MAX_DEPTH) -> list[RepoConfig]:
     out: list[RepoConfig] = []
-    for child in root.iterdir():
-        if not child.is_dir():
-            continue
-        if (child / ".git").exists() and (child / ".autopilot" / "autopilot.json").exists():
-            cfg = load_config(child)
-            if cfg:
-                out.append(cfg)
+    _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[RepoConfig]
+) -> None:
+    if current_depth > max_depth:
+        return
+
+    # Check if current directory is a git repo with autopilot config
+    if (current_dir / ".git").exists() and (
+        current_dir / ".autopilot" / "autopilot.json"
+    ).exists():
+        cfg = load_config(current_dir)
+        if cfg:
+            out.append(cfg)
+        return
+
+    # Recursively search subdirectories (depth-first)
+    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:
+                continue
+            _discover_repos_recursive(child, current_depth + 1, max_depth, out)
+    except PermissionError:
+        pass
+    except OSError:
+        pass
+
+
 def list_candidate_issues(cfg: RepoConfig, limit: int = 10) -> list[dict[str, Any]]:
+    """List candidate issues in the queue.
+
+    We exclude issues containing cfg.ignore_issue_labels (e.g. autopilot:backlog).
+    """
+
     # Sort by created date asc; prioritize p0/p1/p2 by label presence.
     q = " ".join([f"label:{l}" for l in cfg.queue_labels])
+    excludes = " ".join([f"-label:{l}" for l in cfg.ignore_issue_labels if l])
+    search = f"is:open {q} {excludes}".strip()
+
     cmd = [
         "gh",
         "issue",
@@ -101,13 +162,21 @@ def list_candidate_issues(cfg: RepoConfig, limit: int = 10) -> list[dict[str, An
         "--limit",
         str(limit),
         "--search",
-        f"is:open {q}",
+        search,
         "--json",
         "number,title,labels,updatedAt,createdAt,url",
     ]
     raw = sh(cmd)
     issues = json.loads(raw)
 
+    # Defense in depth in case GitHub search syntax changes.
+    ignore_set = set(cfg.ignore_issue_labels)
+    issues = [
+        it
+        for it in issues
+        if not ({l["name"] for l in it.get("labels", [])} & ignore_set)
+    ]
+
     def pri_rank(it: dict[str, Any]) -> int:
         labs = {l["name"] for l in it.get("labels", [])}
         for i, p in enumerate(cfg.priority_labels):
@@ -234,25 +303,22 @@ def maybe_mark_blocked(cfg: RepoConfig, issue: dict[str, Any]) -> None:
     )
 
 
-def main() -> int:
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--root", default="/mnt/f/Source")
-    ap.add_argument("--max-parallel", type=int, default=2)
-    ap.add_argument("--dry-run", action="store_true")
-    args = ap.parse_args()
+def run_cycle(
+    all_configs: list[RepoConfig],
+    dry_run: bool = False,
+) -> int:
+    """Run a single scan/claim/act cycle.
 
-    root = Path(args.root)
-    configs = discover_repos(root)
-    if not configs:
-        print("No autopilot-enabled repos found.")
-        return 0
+    Returns the number of issues claimed.
+    """
+    claimed_count = 0
 
-    for cfg in configs:
+    for cfg in all_configs:
         # 1) First, check any in-progress issues and mark blocked if stale.
         inprog = list_in_progress_issues(cfg)
         for it in inprog:
             # This is conservative: only mark blocked if we have no fresh local heartbeat.
-            if not args.dry_run:
+            if not dry_run:
                 maybe_mark_blocked(cfg, it)
 
         # 2) If nothing is currently in progress, claim one from the queue.
@@ -272,9 +338,10 @@ def main() -> int:
             "the runner does not inspect processes.)"
         )
         print(f"[{cfg.repo}] next issue: #{issue['number']} {issue['title']}")
-        if args.dry_run:
+        if dry_run:
             continue
         claim_issue(cfg, issue, msg)
+        claimed_count += 1
 
         # If agent==opencode, delegate to bash script
         if cfg.agent == "opencode":
@@ -286,6 +353,94 @@ def main() -> int:
                 ]
             )
 
+    return claimed_count
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument(
+        "--root",
+        nargs="+",
+        default=["/mnt/f/Source"],
+        help="One or more root folders to scan for git repos (space-separated)",
+    )
+    ap.add_argument("--max-parallel", type=int, default=2)
+    ap.add_argument(
+        "--max-depth",
+        type=int,
+        default=DEFAULT_MAX_DEPTH,
+        help=f"Maximum depth for recursive repo discovery (default: {DEFAULT_MAX_DEPTH})",
+    )
+    ap.add_argument("--dry-run", action="store_true")
+    ap.add_argument(
+        "--interval-seconds",
+        type=int,
+        default=None,
+        help="Run in loop mode with this interval between cycles (for foreground service mode)",
+    )
+    args = ap.parse_args()
+
+    all_configs: list[RepoConfig] = []
+    for root_str in args.root:
+        root = Path(root_str).resolve()
+        if not root.exists():
+            print(f"Warning: root path {root} does not exist, skipping")
+            continue
+        if not root.is_dir():
+            print(f"Warning: root path {root} is not a directory, skipping")
+            continue
+        configs = discover_repos(root, max_depth=args.max_depth)
+        all_configs.extend(configs)
+
+    if not all_configs:
+        print("No autopilot-enabled repos found.")
+        return 0
+
+    print(f"Found {len(all_configs)} autopilot-enabled repo(s)")
+    for cfg in all_configs:
+        print(f"  - {cfg.repo} at {cfg.root}")
+
+    # Loop mode (for foreground service)
+    if args.interval_seconds is not None:
+        shutdown_requested = False
+
+        def signal_handler(signum: int, frame: Any) -> None:
+            nonlocal shutdown_requested
+            print("\nShutdown requested (Ctrl+C), finishing current cycle...")
+            shutdown_requested = True
+
+        signal.signal(signal.SIGINT, signal_handler)
+        signal.signal(signal.SIGTERM, signal_handler)
+
+        print(f"Running in foreground mode with {args.interval_seconds}s interval")
+        print("Press Ctrl+C to shut down cleanly\n")
+
+        cycle_num = 0
+        while not shutdown_requested:
+            cycle_num += 1
+            timestamp = time.strftime("%Y-%m-%d %H:%M:%S %Z")
+            print(f"\n=== Cycle {cycle_num} at {timestamp} ===")
+
+            try:
+                claimed = run_cycle(all_configs, dry_run=args.dry_run)
+                if claimed == 0:
+                    print("No issues claimed in this cycle")
+                else:
+                    print(f"Claimed {claimed} issue(s) in this cycle")
+            except Exception as e:
+                print(f"Error in cycle {cycle_num}: {e}")
+
+            if shutdown_requested:
+                break
+
+            print(f"Sleeping for {args.interval_seconds}s...")
+            time.sleep(args.interval_seconds)
+
+        print("\nShutdown complete")
+        return 0
+
+    # Single-shot mode (run-once)
+    run_cycle(all_configs, dry_run=args.dry_run)
     return 0
 
 

package/templates/autopilot.json

@@ -9,6 +9,7 @@
   },
   "priorityLabels": ["p0", "p1", "p2"],
   "maxParallel": 2,
+  "ignoreIssueLabels": ["autopilot:backlog"],
   "branchPrefix": "autopilot/",
   "allowedBaseBranch": "main"
 }