@gethmy/agent 1.7.0 → 1.7.2

package/dist/worktree-gc.js

@@ -1,245 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { readdirSync, statSync } from "node:fs";
-import { resolve } from "node:path";
-import { log } from "./log.js";
-import { cleanupWorktree } from "./worktree.js";
-const TAG = "worktree-gc";
-/**
- * One-shot garbage collection for `.harmony-worktrees/*`.
- *
- * A directory is removed when BOTH:
- *   - no active run in the state store has it as its `worktreePath`, AND
- *   - it was last modified more than `minAgeMs` ago (default 1h).
- *
- * The age check protects brand-new worktrees that a worker just created
- * but hasn't yet recorded the path for in the state store.
- *
- * Returns a summary; callers decide whether to log at info or warn.
- */
-export function runWorktreeGc(basePath, store, opts = {}) {
-    const minAgeMs = opts.minAgeMs ?? 60 * 60 * 1000;
-    const now = (opts.now ?? Date.now)();
-    const result = { checked: 0, removed: [], skipped: [], errors: [] };
-    const repoRoot = getRepoRoot();
-    if (!repoRoot) {
-        result.errors.push({ path: "<repo-root>", error: "not a git repo" });
-        return result;
-    }
-    const baseAbs = resolve(repoRoot, basePath);
-    let entries;
-    try {
-        entries = readdirSync(baseAbs);
-    }
-    catch {
-        // Directory doesn't exist yet — nothing to GC, not an error.
-        return result;
-    }
-    const activePaths = new Set(store
-        .getActiveRuns()
-        .map((r) => r.worktreePath)
-        .filter((p) => !!p));
-    for (const entry of entries) {
-        const full = resolve(baseAbs, entry);
-        result.checked++;
-        let mtimeMs;
-        try {
-            const stat = statSync(full);
-            if (!stat.isDirectory()) {
-                result.skipped.push(full);
-                continue;
-            }
-            mtimeMs = stat.mtimeMs;
-        }
-        catch (err) {
-            result.errors.push({
-                path: full,
-                error: err instanceof Error ? err.message : String(err),
-            });
-            continue;
-        }
-        if (activePaths.has(full)) {
-            result.skipped.push(full);
-            continue;
-        }
-        if (now - mtimeMs < minAgeMs) {
-            result.skipped.push(full);
-            continue;
-        }
-        try {
-            cleanupWorktree(full);
-            result.removed.push(full);
-        }
-        catch (err) {
-            result.errors.push({
-                path: full,
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-    }
-    // Prune any stale metadata leftover from deleted worktrees.
-    try {
-        execFileSync("git", ["worktree", "prune", "--expire=now"], {
-            cwd: repoRoot,
-            stdio: "pipe",
-        });
-    }
-    catch {
-        // non-fatal
-    }
-    if (result.removed.length > 0) {
-        log.info(TAG, `GC removed ${result.removed.length} orphan worktree(s): ${result.removed.map((p) => p.split("/").pop()).join(", ")}`);
-    }
-    if (result.errors.length > 0) {
-        log.warn(TAG, `GC had ${result.errors.length} error(s): ${result.errors
-            .map((e) => `${e.path}: ${e.error}`)
-            .join("; ")}`);
-    }
-    return result;
-}
-/**
- * Sweep stale failed-attempt branches off the remote.
- *
- * Lists `origin/<prefix>*`, asks git for each ref's committer timestamp via
- * `for-each-ref`, and deletes anything older than `retentionDays`. Runs on
- * the same GC tick that handles worktree directories — protecting unpushed
- * commits is the job of the daemon (always push before verify); this sweep
- * just keeps the namespace tidy.
- */
-export function pruneFailedRemoteBranches(opts) {
-    const result = {
-        scanned: 0,
-        removed: [],
-        skipped: [],
-        errors: [],
-    };
-    if (!opts.prefix)
-        return result;
-    // 0 or negative retention is opt-out — caller wants nothing pruned.
-    if (!Number.isFinite(opts.retentionDays) || opts.retentionDays <= 0) {
-        return result;
-    }
-    const repoRoot = getRepoRoot();
-    if (!repoRoot) {
-        result.errors.push({ ref: "<repo-root>", error: "not a git repo" });
-        return result;
-    }
-    // Refresh the remote refs we know about. Pruned remote branches drop from
-    // local tracking, so we never try to delete refs the server already lost.
-    try {
-        execFileSync("git", ["fetch", "--prune", "origin"], {
-            cwd: repoRoot,
-            stdio: "pipe",
-        });
-    }
-    catch (err) {
-        result.errors.push({
-            ref: "fetch",
-            error: err instanceof Error ? err.message : String(err),
-        });
-        // Continue — for-each-ref may still find usable cached refs.
-    }
-    const refPattern = `refs/remotes/origin/${opts.prefix}*`;
-    let listing = "";
-    try {
-        listing = execFileSync("git", [
-            "for-each-ref",
-            "--format=%(refname:strip=3) %(committerdate:unix)",
-            refPattern,
-        ], { cwd: repoRoot, encoding: "utf-8" });
-    }
-    catch (err) {
-        result.errors.push({
-            ref: refPattern,
-            error: err instanceof Error ? err.message : String(err),
-        });
-        return result;
-    }
-    const cutoffSecs = (opts.now ?? Date.now)() / 1000 - opts.retentionDays * 24 * 60 * 60;
-    for (const line of listing.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        const sp = trimmed.lastIndexOf(" ");
-        if (sp < 0)
-            continue;
-        const ref = trimmed.slice(0, sp);
-        const ts = Number(trimmed.slice(sp + 1));
-        result.scanned++;
-        if (!Number.isFinite(ts) || ts >= cutoffSecs) {
-            result.skipped.push(ref);
-            continue;
-        }
-        try {
-            execFileSync("git", ["push", "origin", `:refs/heads/${ref}`], {
-                cwd: repoRoot,
-                stdio: "pipe",
-            });
-            result.removed.push(ref);
-        }
-        catch (err) {
-            result.errors.push({
-                ref,
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-    }
-    if (result.removed.length > 0) {
-        log.info(TAG, `Pruned ${result.removed.length} stale remote branch(es) under ${opts.prefix}: ${result.removed.join(", ")}`);
-    }
-    if (result.errors.length > 0) {
-        log.warn(TAG, `Remote branch GC had ${result.errors.length} error(s): ${result.errors
-            .map((e) => `${e.ref}: ${e.error}`)
-            .join("; ")}`);
-    }
-    return result;
-}
-export class WorktreeGc {
-    basePath;
-    store;
-    intervalMs;
-    remoteOpts;
-    timer = null;
-    constructor(basePath, store, intervalMs, remoteOpts) {
-        this.basePath = basePath;
-        this.store = store;
-        this.intervalMs = intervalMs;
-        this.remoteOpts = remoteOpts;
-    }
-    start() {
-        // Run once at startup, then on interval.
-        this.tick();
-        this.timer = setInterval(() => this.tick(), this.intervalMs);
-    }
-    stop() {
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
-    }
-    tick() {
-        try {
-            runWorktreeGc(this.basePath, this.store);
-        }
-        catch (err) {
-            log.warn(TAG, `GC tick failed: ${err instanceof Error ? err.message : err}`);
-        }
-        if (this.remoteOpts) {
-            try {
-                pruneFailedRemoteBranches(this.remoteOpts);
-            }
-            catch (err) {
-                log.warn(TAG, `Remote GC tick failed: ${err instanceof Error ? err.message : err}`);
-            }
-        }
-    }
-}
-function getRepoRoot() {
-    try {
-        return execFileSync("git", ["rev-parse", "--show-toplevel"], {
-            encoding: "utf-8",
-        }).trim();
-    }
-    catch {
-        return null;
-    }
-}

package/dist/worktree.d.ts

@@ -1,18 +0,0 @@
-/**
- * Create a git worktree for the agent to work in.
- * Returns the absolute path to the new worktree.
- */
-export declare function createWorktree(basePath: string, baseBranch: string, branchName: string): string;
-/**
- * Remove a git worktree and its branch.
- */
-export declare function cleanupWorktree(worktreePath: string, branchName?: string): void;
-/**
- * Generate a branch name from a card's short ID and title.
- *
- * Agent branches start under the failedBranchPrefix (default `agent-attempts/`)
- * and are renamed to the approvedBranchPrefix (default `agent/`) only after the
- * Review pipeline approves them. Branches under `agent-attempts/` are pruned
- * by the GC after `failedAttemptRetentionDays`.
- */
-export declare function makeBranchName(shortId: number, title: string, prefix?: string): string;

package/dist/worktree.js

@@ -1,177 +0,0 @@
-import { execFileSync, execSync } from "node:child_process";
-import { existsSync, rmSync } from "node:fs";
-import { resolve } from "node:path";
-import { log } from "./log.js";
-import { installCommand } from "./pm.js";
-const TAG = "worktree";
-/**
- * Create a git worktree for the agent to work in.
- * Returns the absolute path to the new worktree.
- */
-export function createWorktree(basePath, baseBranch, branchName) {
-    const repoRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], {
-        encoding: "utf-8",
-    }).trim();
-    const worktreeDir = resolve(repoRoot, basePath, branchName);
-    if (existsSync(worktreeDir)) {
-        log.warn(TAG, `Worktree already exists at ${worktreeDir}, cleaning up`);
-        cleanupWorktree(worktreeDir, branchName);
-    }
-    // Prune stale worktree metadata. If a previous daemon crashed or its
-    // worktree dir was deleted externally, git may still think the branch is
-    // checked out, which blocks `git branch -D` and `git worktree add`.
-    // `--expire=now` overrides `gc.worktreePruneExpire` (default 3 months) so
-    // freshly-orphaned entries are removed immediately.
-    try {
-        execFileSync("git", ["worktree", "prune", "--expire=now"], {
-            cwd: repoRoot,
-            stdio: "pipe",
-        });
-    }
-    catch {
-        // non-fatal
-    }
-    // Fetch latest from remote to ensure base branch is up to date
-    try {
-        execFileSync("git", ["fetch", "origin", baseBranch], {
-            cwd: repoRoot,
-            stdio: "pipe",
-        });
-    }
-    catch {
-        log.warn(TAG, "Failed to fetch latest — continuing with local state");
-    }
-    // Create worktree with a fresh branch based on origin/<baseBranch>.
-    // `-B` resets the branch if it already exists — agent branches are owned
-    // per-attempt, so starting fresh from origin is the desired behavior.
-    log.info(TAG, `Creating worktree: ${worktreeDir} (branch: ${branchName})`);
-    try {
-        execFileSync("git", [
-            "worktree",
-            "add",
-            "-B",
-            branchName,
-            worktreeDir,
-            `origin/${baseBranch}`,
-        ], { cwd: repoRoot, stdio: "pipe" });
-    }
-    catch (err) {
-        // Last-resort recovery: if `-B` still fails (e.g. branch checked out in
-        // another registered worktree), force-delete the branch and retry.
-        const msg = err instanceof Error ? err.message : String(err);
-        log.warn(TAG, `worktree add failed, attempting forced recovery: ${msg}`);
-        // Remove any registered worktree at this path (phantom or otherwise).
-        try {
-            execFileSync("git", ["worktree", "remove", worktreeDir, "--force"], {
-                cwd: repoRoot,
-                stdio: "pipe",
-            });
-        }
-        catch {
-            // best-effort
-        }
-        // Force-prune any stale worktree admin entries referencing this branch.
-        try {
-            execFileSync("git", ["worktree", "prune", "--expire=now"], {
-                cwd: repoRoot,
-                stdio: "pipe",
-            });
-        }
-        catch {
-            // best-effort
-        }
-        try {
-            execFileSync("git", ["branch", "-D", branchName], {
-                cwd: repoRoot,
-                stdio: "pipe",
-            });
-        }
-        catch {
-            // ignore; retry will surface the real error
-        }
-        execFileSync("git", [
-            "worktree",
-            "add",
-            "-B",
-            branchName,
-            worktreeDir,
-            `origin/${baseBranch}`,
-        ], { cwd: repoRoot, stdio: "pipe" });
-    }
-    // Install dependencies in the worktree
-    log.info(TAG, "Installing dependencies in worktree...");
-    try {
-        execSync(installCommand(), {
-            cwd: worktreeDir,
-            stdio: "pipe",
-            timeout: 60_000,
-        });
-    }
-    catch {
-        log.warn(TAG, "Install failed (may be fine if deps are hoisted)");
-    }
-    return worktreeDir;
-}
-/**
- * Remove a git worktree and its branch.
- */
-export function cleanupWorktree(worktreePath, branchName) {
-    const repoRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], {
-        encoding: "utf-8",
-    }).trim();
-    try {
-        execFileSync("git", ["worktree", "remove", worktreePath, "--force"], {
-            cwd: repoRoot,
-            stdio: "pipe",
-        });
-        log.info(TAG, `Removed worktree: ${worktreePath}`);
-    }
-    catch (err) {
-        log.warn(TAG, `Failed to remove worktree cleanly: ${err instanceof Error ? err.message : err}`);
-        // Force-remove the directory if git worktree remove failed
-        if (existsSync(worktreePath)) {
-            rmSync(worktreePath, { recursive: true, force: true });
-        }
-        // Prune stale worktree entries
-        try {
-            execFileSync("git", ["worktree", "prune", "--expire=now"], {
-                cwd: repoRoot,
-                stdio: "pipe",
-            });
-        }
-        catch {
-            // best-effort
-        }
-    }
-    // Delete the branch so it doesn't block future runs
-    if (branchName) {
-        try {
-            execFileSync("git", ["branch", "-D", branchName], {
-                cwd: repoRoot,
-                stdio: "pipe",
-            });
-        }
-        catch {
-            // best-effort
-        }
-    }
-}
-/**
- * Generate a branch name from a card's short ID and title.
- *
- * Agent branches start under the failedBranchPrefix (default `agent-attempts/`)
- * and are renamed to the approvedBranchPrefix (default `agent/`) only after the
- * Review pipeline approves them. Branches under `agent-attempts/` are pruned
- * by the GC after `failedAttemptRetentionDays`.
- */
-export function makeBranchName(shortId, title, prefix = "agent-attempts/") {
-    const slug = title
-        .toLowerCase()
-        .trim()
-        .replace(/[^\w\s-]/g, "")
-        .replace(/\s+/g, "-")
-        .replace(/-+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .slice(0, 40);
-    return `${prefix}${shortId}-${slug || "task"}`;
-}