@gethmy/agent 1.7.1 → 1.7.3

package/dist/worker.js

@@ -1,507 +0,0 @@
-import { moveCardAndAddLabel } from "./board-helpers.js";
-import { buildGaveUpComment } from "./budget.js";
-import { buildTokenPayload, runCompletion, } from "./completion.js";
-import { log } from "./log.js";
-import { signalGroup, spawnInGroup, terminateGroup } from "./process-group.js";
-import { ProgressTracker } from "./progress-tracker.js";
-import { buildPrompt } from "./prompt.js";
-import { openRunLog } from "./run-log.js";
-import { newRunId } from "./state-store.js";
-import { StreamParser } from "./stream-parser.js";
-import { runTransition, TransitionError } from "./transitions.js";
-import { AGENT_NAME, agentIdentifier, } from "./types.js";
-import { cleanupWorktree, createWorktree, makeBranchName } from "./worktree.js";
-const TAG = "worker";
-const CANCEL_SIGINT_TIMEOUT = 30_000;
-const CANCEL_SIGTERM_TIMEOUT = 10_000;
-export class Worker {
-    config;
-    client;
-    onDone;
-    workspaceId;
-    projectId;
-    stateStore;
-    id;
-    state = "idle";
-    cardId = null;
-    branchName = null;
-    worktreePath = null;
-    startedAt = null;
-    process = null;
-    timeoutTimer = null;
-    heartbeatTimer = null;
-    progressTracker = null;
-    lastSessionStats;
-    aborted = false;
-    verificationFailed = false;
-    sessionId = null;
-    runId = null;
-    constructor(id, config, client, _userEmail, onDone, workspaceId, projectId, stateStore) {
-        this.config = config;
-        this.client = client;
-        this.onDone = onDone;
-        this.workspaceId = workspaceId;
-        this.projectId = projectId;
-        this.stateStore = stateStore;
-        this.id = id;
-    }
-    startHeartbeat() {
-        this.stopHeartbeat();
-        const interval = this.config.timing.heartbeatMs;
-        this.heartbeatTimer = setInterval(() => {
-            if (this.runId) {
-                this.stateStore.heartbeat(this.runId).catch(() => {
-                    /* next tick will retry */
-                });
-            }
-        }, interval);
-        // Don't block event loop shutdown for a pending heartbeat.
-        this.heartbeatTimer.unref();
-    }
-    stopHeartbeat() {
-        if (this.heartbeatTimer) {
-            clearInterval(this.heartbeatTimer);
-            this.heartbeatTimer = null;
-        }
-    }
-    async recordPhase(phase) {
-        if (!this.runId)
-            return;
-        try {
-            await this.stateStore.updateRun(this.runId, {
-                phase,
-                lastHeartbeatAt: Date.now(),
-                worktreePath: this.worktreePath,
-                branchName: this.branchName,
-                sessionId: this.sessionId,
-            });
-        }
-        catch (err) {
-            log.warn(this.tag, `state store updateRun failed: ${err instanceof Error ? err.message : err}`);
-        }
-    }
-    get tag() {
-        return `${TAG}:${this.id}`;
-    }
-    get isIdle() {
-        return this.state === "idle";
-    }
-    get isActive() {
-        return (this.state === "preparing" ||
-            this.state === "running" ||
-            this.state === "verifying" ||
-            this.state === "completing");
-    }
-    /**
-     * Start working on a card. Runs the full lifecycle:
-     * PREPARING → RUNNING → COMPLETING → IDLE
-     */
-    async run(card, column, labels, subtasks) {
-        this.aborted = false;
-        this.verificationFailed = false;
-        this.cardId = card.id;
-        this.startedAt = Date.now();
-        this.runId = newRunId();
-        try {
-            // --- PREPARING ---
-            this.state = "preparing";
-            this.branchName = makeBranchName(card.short_id, card.title, this.config.worktree.failedBranchPrefix);
-            log.info(this.tag, `Preparing #${card.short_id} "${card.title}"`);
-            // Per-card attempt counter resets on success; give-up triggers off it.
-            await this.stateStore.incrementAttempt(card.id);
-            // Start the heartbeat loop so the reconciler knows this run is
-            // still alive even if no phase transitions happen for a while
-            // (Claude can spend 5+ minutes in one tool call).
-            this.startHeartbeat();
-            // Record this run durably so we can recover on crash.
-            await this.stateStore.insertRun({
-                runId: this.runId,
-                cardId: card.id,
-                cardShortId: card.short_id,
-                pipeline: "implement",
-                workerId: this.id,
-                sessionId: null,
-                worktreePath: null,
-                branchName: this.branchName,
-                daemonPid: process.pid,
-                phase: "preparing",
-                startedAt: this.startedAt,
-                lastHeartbeatAt: this.startedAt,
-                endedAt: null,
-                status: "active",
-                costCents: 0,
-            });
-            // Start agent session and make it visible on the board
-            const { session } = await this.client.startAgentSession(card.id, {
-                agentIdentifier: agentIdentifier(this.id),
-                agentName: AGENT_NAME,
-                status: "working",
-                currentTask: "Setting up worktree",
-                progressPercent: 5,
-            });
-            const sid = session && typeof session === "object" && "id" in session
-                ? session.id
-                : null;
-            if (!sid) {
-                log.warn(TAG, "startAgentSession returned no session id");
-            }
-            this.sessionId = sid;
-            await this.recordPhase("preparing");
-            // Move card to "In Progress" and add "agent" label so the board shows the progress ring
-            const moved = await moveCardAndAddLabel(this.client, card, "In Progress", "agent");
-            if (!moved) {
-                log.warn(this.tag, `Card #${card.short_id} was NOT moved to "In Progress" — check API logs`);
-            }
-            if (this.aborted)
-                return;
-            // Create worktree
-            this.worktreePath = createWorktree(this.config.worktree.basePath, this.config.worktree.baseBranch, this.branchName);
-            if (this.aborted)
-                return;
-            // --- RUNNING ---
-            this.state = "running";
-            await this.recordPhase("running");
-            const enriched = {
-                card,
-                column,
-                labels,
-                subtasks,
-                mode: "implement",
-            };
-            const prompt = await buildPrompt(enriched, this.branchName, this.worktreePath, this.client, this.workspaceId, this.projectId);
-            await this.client.updateAgentProgress(card.id, {
-                agentIdentifier: agentIdentifier(this.id),
-                agentName: AGENT_NAME,
-                status: "working",
-                currentTask: "Running Claude CLI",
-                progressPercent: 10,
-            });
-            // Start timeout watchdog
-            this.timeoutTimer = setTimeout(() => {
-                log.warn(this.tag, `Timeout reached (${this.config.maxTimeout}ms), cancelling`);
-                this.cancel();
-            }, this.config.maxTimeout);
-            // Spawn Claude CLI
-            await this.spawnClaude(prompt, card, subtasks);
-            if (this.aborted)
-                return;
-            // --- VERIFYING + COMPLETING ---
-            this.state = "verifying";
-            await this.recordPhase("verifying");
-            log.info(this.tag, `Claude finished for #${card.short_id}, running verification & completion`);
-            await this.client.updateAgentProgress(card.id, {
-                agentIdentifier: agentIdentifier(this.id),
-                agentName: AGENT_NAME,
-                status: "working",
-                currentTask: "Verifying implementation",
-                progressPercent: 75,
-            });
-            this.state = "completing";
-            await this.recordPhase("completing");
-            const completed = await runCompletion(this.client, card, this.branchName, this.worktreePath, this.config, this.id, this.lastSessionStats, this.workspaceId, this.sessionId, this.stateStore);
-            // A verification failure is a failed attempt, not a success — even
-            // though runCompletion returns normally (it has already moved the card
-            // to the fail column and ended the session). Flag it so the finally
-            // block records a failure and counts it toward the give-up budget.
-            this.verificationFailed = !completed;
-        }
-        catch (err) {
-            this.state = "error";
-            const msg = err instanceof Error ? err.message : String(err);
-            log.error(this.tag, `Error on #${card.short_id}: ${msg}`);
-            // End session as paused. Retried — a transient API blip here used
-            // to orphan the session and leave the card stuck with a progress ring.
-            try {
-                await runTransition(this.client, card, {
-                    endSession: {
-                        status: "paused",
-                        ...buildTokenPayload(this.lastSessionStats),
-                    },
-                });
-            }
-            catch (tErr) {
-                log.error(this.tag, `endAgentSession unrecoverable on #${card.short_id}: ${tErr instanceof TransitionError ? tErr.detail : tErr}`);
-            }
-            if (this.runId) {
-                try {
-                    await this.stateStore.endRun(this.runId, "paused", msg);
-                }
-                catch {
-                    // state-store best-effort; already persisted on last heartbeat
-                }
-                await this.recordOutcome(card.id, "failure");
-            }
-        }
-        finally {
-            // Only bookkeep success when we actually succeeded. "cancelling"
-            // and aborted runs are failures/user-initiated stops, not wins —
-            // counting them as success would reset attempts and mask real
-            // failure loops. A verification failure is likewise a failed attempt.
-            const succeeded = this.runId &&
-                this.state !== "error" &&
-                !this.aborted &&
-                !this.verificationFailed;
-            if (succeeded) {
-                try {
-                    await this.stateStore.endRun(this.runId, "completed");
-                }
-                catch {
-                    // best-effort — state store failures don't block worker exit
-                }
-                await this.recordOutcome(card.id, "success");
-            }
-            else if (this.runId && this.aborted) {
-                // Cancelled run: don't touch attempts counter, but close the
-                // state store row so it isn't mistaken for a live run.
-                try {
-                    await this.stateStore.endRun(this.runId, "paused", "cancelled");
-                }
-                catch {
-                    // best-effort
-                }
-            }
-            else if (this.runId && this.verificationFailed) {
-                // Verification failed (no exception was thrown). Count it as a
-                // failed attempt so repeated failures eventually trip the give-up
-                // budget — runCompletion already moved the card + ended the session.
-                try {
-                    await this.stateStore.endRun(this.runId, "paused", "verification");
-                }
-                catch {
-                    // best-effort
-                }
-                await this.recordOutcome(card.id, "failure");
-            }
-            this.cleanup();
-            this.state = "idle";
-            this.onDone(this);
-        }
-    }
-    async recordOutcome(cardId, outcome) {
-        try {
-            const cost = this.lastSessionStats?.cost;
-            if (cost) {
-                const cents = Math.round(cost.totalCostUsd * 100);
-                await this.stateStore.addCost(cardId, cents);
-            }
-            await this.stateStore.recordOutcome(cardId, outcome);
-            // Give-up: if this failure exhausted the attempt budget, post a single
-            // human-facing comment here at the crossing. The pool guard then skips
-            // the card quietly until it is reassigned (which resets attempts), so
-            // this fires exactly once — no permanent DLQ, no label, no manual clear.
-            if (outcome === "failure") {
-                const max = this.config.budget.maxAttemptsPerCard;
-                const attempts = this.stateStore.getCard(cardId)?.attempts ?? 0;
-                if (attempts >= max) {
-                    try {
-                        const body = buildGaveUpComment(max, this.stateStore.getRecentFailures(cardId, 3));
-                        await this.client.addComment(cardId, body, {
-                            commentType: "blocker",
-                        });
-                        log.warn(this.tag, `gave up on ${cardId} after ${attempts} attempts`);
-                    }
-                    catch (err) {
-                        log.warn(this.tag, `failed to post give-up comment for ${cardId}: ${err instanceof Error ? err.message : err}`);
-                    }
-                }
-            }
-        }
-        catch (err) {
-            log.warn(this.tag, `recordOutcome(${outcome}) failed: ${err instanceof Error ? err.message : err}`);
-        }
-    }
-    /**
-     * Pause the current work by suspending the Claude process (SIGSTOP).
-     */
-    async pause() {
-        if (!this.isActive || !this.process || this.process.killed)
-            return;
-        log.info(this.tag, `Pausing work on ${this.cardId}`);
-        signalGroup(this.process, "SIGSTOP");
-        // Pause the timeout timer
-        if (this.timeoutTimer) {
-            clearTimeout(this.timeoutTimer);
-            this.timeoutTimer = null;
-        }
-        // Update agent session so the UI reflects the paused state
-        if (this.cardId) {
-            try {
-                await this.client.updateAgentProgress(this.cardId, {
-                    agentIdentifier: agentIdentifier(this.id),
-                    agentName: AGENT_NAME,
-                    status: "paused",
-                });
-            }
-            catch {
-                log.warn(this.tag, "Failed to update agent session to paused");
-            }
-        }
-    }
-    /**
-     * Resume the Claude process after a pause (SIGCONT).
-     */
-    async resume() {
-        if (!this.isActive || !this.process || this.process.killed)
-            return;
-        log.info(this.tag, `Resuming work on ${this.cardId}`);
-        signalGroup(this.process, "SIGCONT");
-        // Restart timeout timer with remaining time (use full timeout for simplicity)
-        this.timeoutTimer = setTimeout(() => {
-            log.warn(this.tag, `Timeout reached (${this.config.maxTimeout}ms), cancelling`);
-            this.cancel();
-        }, this.config.maxTimeout);
-        // Update agent session so the UI reflects the resumed state
-        if (this.cardId) {
-            try {
-                await this.client.updateAgentProgress(this.cardId, {
-                    agentIdentifier: agentIdentifier(this.id),
-                    agentName: AGENT_NAME,
-                    status: "working",
-                });
-            }
-            catch {
-                log.warn(this.tag, "Failed to update agent session to working");
-            }
-        }
-    }
-    /**
-     * Cancel the current work. Sends escalating signals to the Claude process.
-     */
-    async cancel() {
-        if (!this.isActive)
-            return;
-        this.aborted = true;
-        this.state = "cancelling";
-        log.info(this.tag, `Cancelling work on ${this.cardId}`);
-        if (this.process && !this.process.killed) {
-            await terminateGroup(this.process, {
-                sigintTimeoutMs: CANCEL_SIGINT_TIMEOUT,
-                sigtermTimeoutMs: CANCEL_SIGTERM_TIMEOUT,
-            });
-        }
-        // End agent session as paused (retry on API jitter).
-        if (this.cardId) {
-            try {
-                const stats = this.lastSessionStats ?? this.progressTracker?.stats;
-                await this.client.endAgentSession(this.cardId, {
-                    status: "paused",
-                    ...buildTokenPayload(stats),
-                });
-            }
-            catch (err) {
-                log.warn(this.tag, `endAgentSession after cancel failed: ${err instanceof Error ? err.message : err}`);
-            }
-        }
-    }
-    async spawnClaude(prompt, card, subtasks) {
-        return new Promise((resolve, reject) => {
-            const args = [
-                "-p",
-                "--verbose", // required for stream-json to emit all event types
-                "--output-format",
-                "stream-json",
-                "--model",
-                this.config.claude.model,
-                "--max-turns",
-                String(this.config.claude.maxTurns),
-                "--allowedTools",
-                "Bash,Read,Write,Edit,Glob,Grep,Agent,mcp__harmony__*",
-                ...this.config.claude.additionalArgs,
-                "--",
-                prompt,
-            ];
-            log.info(this.tag, `Spawning: claude ${args.slice(0, 4).join(" ")} ...`);
-            const runLog = openRunLog(this.tag, this.runId, card.short_id);
-            if (runLog) {
-                log.info(this.tag, `Run log: ${runLog.path}`);
-                runLog.stream.write(`# run=${this.runId} card=#${card.short_id} started=${new Date().toISOString()}\n` +
-                    `# args: ${args.slice(0, -2).join(" ")} -- <prompt:${prompt.length} chars>\n\n`);
-            }
-            this.process = spawnInGroup("claude", args, {
-                cwd: this.worktreePath,
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-            // Stream parser for structured NDJSON events
-            const parser = new StreamParser();
-            // Progress tracker for phase-based updates
-            this.progressTracker = new ProgressTracker(this.client, card.id, this.id, subtasks);
-            if (this.sessionId) {
-                this.progressTracker.setSessionId(this.sessionId);
-            }
-            this.progressTracker.attach(parser);
-            // Attach stdout to parser
-            if (this.process.stdout) {
-                parser.attach(this.process.stdout);
-                if (runLog) {
-                    this.process.stdout.on("data", (chunk) => {
-                        runLog.stream.write(chunk);
-                    });
-                }
-            }
-            parser.on("parse_error", (msg) => {
-                log.debug(this.tag, `Stream parse error (non-fatal): ${msg}`);
-                runLog?.stream.write(`\n[parse_error] ${msg}\n`);
-            });
-            let stderr = "";
-            this.process.stderr?.on("data", (data) => {
-                stderr += data.toString();
-                runLog?.stream.write(`[stderr] ${data.toString()}`);
-            });
-            this.process.on("error", (err) => {
-                reject(new Error(`Failed to spawn claude: ${err.message}`));
-            });
-            this.process.on("close", (code) => {
-                this.process = null;
-                this.lastSessionStats = this.progressTracker?.stats;
-                this.progressTracker?.flushFinal();
-                this.progressTracker?.stop();
-                this.progressTracker = null;
-                if (runLog) {
-                    const stats = this.lastSessionStats;
-                    runLog.stream.write(`\n# exit code=${code} aborted=${this.aborted} ` +
-                        `toolCalls=${stats?.toolCalls ?? 0} filesEdited=${stats?.filesEdited ?? 0} ` +
-                        `cost=$${stats?.cost?.totalCostUsd.toFixed(4) ?? "0"} ` +
-                        `ended=${new Date().toISOString()}\n`);
-                    runLog.stream.end();
-                }
-                if (this.aborted) {
-                    resolve(); // Cancellation is not an error
-                }
-                else if (code === 0) {
-                    resolve();
-                }
-                else {
-                    reject(new Error(`claude exited with code ${code}${stderr ? `: ${stderr.slice(0, 500)}` : ""}`));
-                }
-            });
-        });
-    }
-    cleanup() {
-        if (this.progressTracker) {
-            this.progressTracker.stop();
-            this.progressTracker = null;
-        }
-        this.stopHeartbeat();
-        this.lastSessionStats = undefined;
-        if (this.timeoutTimer) {
-            clearTimeout(this.timeoutTimer);
-            this.timeoutTimer = null;
-        }
-        // Clean up worktree + branch on error
-        if (this.worktreePath && this.state === "error") {
-            try {
-                cleanupWorktree(this.worktreePath, this.branchName ?? undefined);
-            }
-            catch {
-                log.warn(this.tag, "Failed to cleanup worktree");
-            }
-        }
-        this.process = null;
-        this.cardId = null;
-        this.branchName = null;
-        this.worktreePath = null;
-        this.startedAt = null;
-        this.runId = null;
-        this.sessionId = null;
-    }
-}

package/dist/worktree-gc.d.ts

@@ -1,67 +0,0 @@
-import type { StateStore } from "./state-store.js";
-export interface RemoteBranchGcOptions {
-    /** Prefix to scan (e.g. `agent-attempts/`). */
-    prefix: string;
-    /** Retention in days. Branches older than this are removed. */
-    retentionDays: number;
-    /** Optional sync clock, for deterministic tests. */
-    now?: () => number;
-}
-export interface RemoteBranchGcResult {
-    scanned: number;
-    removed: string[];
-    skipped: string[];
-    errors: Array<{
-        ref: string;
-        error: string;
-    }>;
-}
-export interface GcResult {
-    checked: number;
-    removed: string[];
-    skipped: string[];
-    errors: Array<{
-        path: string;
-        error: string;
-    }>;
-}
-export interface GcOptions {
-    /** Directories younger than this are kept (a worker may be about to use them). */
-    minAgeMs?: number;
-    /** Optional sync clock, for deterministic tests. */
-    now?: () => number;
-}
-/**
- * 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 declare function runWorktreeGc(basePath: string, store: StateStore, opts?: GcOptions): GcResult;
-/**
- * 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 declare function pruneFailedRemoteBranches(opts: RemoteBranchGcOptions): RemoteBranchGcResult;
-export declare class WorktreeGc {
-    private basePath;
-    private store;
-    private intervalMs;
-    private remoteOpts?;
-    private timer;
-    constructor(basePath: string, store: StateStore, intervalMs: number, remoteOpts?: RemoteBranchGcOptions | undefined);
-    start(): void;
-    stop(): void;
-    private tick;
-}