@gethmy/agent 1.7.0 → 1.7.2

package/dist/review-worker.js

@@ -1,638 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import { addLabelByName, moveCardToColumn } from "./board-helpers.js";
-import { buildTokenPayload } from "./completion.js";
-import { log } from "./log.js";
-import { signalGroup, spawnInGroup, terminateGroup } from "./process-group.js";
-import { ProgressTracker } from "./progress-tracker.js";
-import { parseReviewOutput, runReviewCompletion } from "./review-completion.js";
-import { buildReviewSystemPrompt, buildReviewUserPrompt, } from "./review-prompt.js";
-import { checkoutExistingBranch, extractBranchFromDescription, } from "./review-worktree.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, NEED_REVIEW_LABEL, NEED_REVIEW_LABEL_COLOR, } from "./types.js";
-import { DevServerReadinessError, probeDevServer, waitForDevServer, } from "./verification.js";
-import { cleanupWorktree } from "./worktree.js";
-const TAG = "review-worker";
-const CANCEL_SIGINT_TIMEOUT = 30_000;
-const CANCEL_SIGTERM_TIMEOUT = 10_000;
-export class ReviewWorker {
-    config;
-    client;
-    onDone;
-    stateStore;
-    workspaceId;
-    id;
-    state = "idle";
-    cardId = null;
-    branchName = null;
-    worktreePath = null;
-    startedAt = null;
-    process = null;
-    devServerProcess = null;
-    timeoutTimer = null;
-    heartbeatTimer = null;
-    progressTracker = null;
-    lastSessionStats = null;
-    aborted = false;
-    runId = null;
-    lastRunLogPath = null;
-    sessionId = null;
-    constructor(id, config, client, _userEmail, onDone, stateStore, workspaceId, _projectId) {
-        this.config = config;
-        this.client = client;
-        this.onDone = onDone;
-        this.stateStore = stateStore;
-        this.workspaceId = workspaceId;
-        this.id = id;
-    }
-    startHeartbeat() {
-        this.stopHeartbeat();
-        const interval = this.config.timing.heartbeatMs;
-        this.heartbeatTimer = setInterval(() => {
-            if (this.runId) {
-                this.stateStore.heartbeat(this.runId).catch(() => {
-                    /* retry next tick */
-                });
-            }
-        }, 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,
-            });
-        }
-        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 reviewPort() {
-        return this.config.review.devServerPort + (this.id - this.config.poolSize);
-    }
-    get isActive() {
-        return (this.state === "preparing" ||
-            this.state === "running" ||
-            this.state === "verifying" ||
-            this.state === "completing");
-    }
-    /**
-     * Start reviewing a card. Runs the full lifecycle:
-     * PREPARING → REVIEWING → COMPLETING → IDLE
-     */
-    async run(card, column, labels, subtasks) {
-        this.aborted = false;
-        this.cardId = card.id;
-        this.startedAt = Date.now();
-        this.runId = newRunId();
-        try {
-            // --- PREPARING ---
-            this.state = "preparing";
-            log.info(this.tag, `Preparing review for #${card.short_id} "${card.title}"`);
-            this.startHeartbeat();
-            await this.stateStore.insertRun({
-                runId: this.runId,
-                cardId: card.id,
-                cardShortId: card.short_id,
-                pipeline: "review",
-                workerId: this.id,
-                sessionId: null,
-                worktreePath: null,
-                branchName: null,
-                daemonPid: process.pid,
-                phase: "preparing",
-                startedAt: this.startedAt,
-                lastHeartbeatAt: this.startedAt,
-                endedAt: null,
-                status: "active",
-                costCents: 0,
-            });
-            // Extract branch name from card description
-            this.branchName = extractBranchFromDescription(card.description);
-            const localMode = !this.branchName;
-            let localDiff = null;
-            if (localMode) {
-                // LOCAL FALLBACK: no branch → review local working tree
-                log.info(this.tag, `No branch found for #${card.short_id}, attempting local review`);
-                // Use repo root as working directory
-                this.worktreePath = execFileSync("git", ["rev-parse", "--show-toplevel"], {
-                    encoding: "utf-8",
-                    timeout: 5_000,
-                }).trim();
-                // Try to find reviewable changes
-                const resolved = this.resolveLocalChanges(this.worktreePath, card.short_id);
-                if (!resolved) {
-                    // No changes found — mark for human review and leave in current column
-                    log.info(this.tag, `No local changes found for #${card.short_id} — marking for human review (staying in Review)`);
-                    await addLabelByName(this.client, card, NEED_REVIEW_LABEL, NEED_REVIEW_LABEL_COLOR);
-                    return;
-                }
-                log.info(this.tag, `Found local changes via ${resolved.source} for #${card.short_id}`);
-                localDiff = resolved.diff;
-            }
-            if (this.branchName) {
-                log.info(this.tag, `Review branch: ${this.branchName}`);
-            }
-            // Start agent session and make it visible on the board
-            const { session: reviewSession } = await this.client.startAgentSession(card.id, {
-                agentIdentifier: agentIdentifier(this.id),
-                agentName: `${AGENT_NAME} (Review)`,
-                status: "working",
-                currentTask: localMode
-                    ? "Reviewing local changes"
-                    : "Setting up review worktree",
-                progressPercent: 5,
-            });
-            this.sessionId =
-                reviewSession &&
-                    typeof reviewSession === "object" &&
-                    "id" in reviewSession
-                    ? (reviewSession.id ?? null)
-                    : null;
-            // Fire label addition concurrently with sync worktree checkout
-            const labelPromise = addLabelByName(this.client, card, "agent", "#8b5cf6");
-            if (!localMode) {
-                // Checkout existing branch into worktree (sync)
-                this.worktreePath = checkoutExistingBranch(this.config.worktree.basePath, this.branchName);
-            }
-            await labelPromise;
-            if (this.aborted)
-                return;
-            // --- REVIEWING ---
-            this.state = "running";
-            await this.recordPhase("running");
-            if (!this.worktreePath) {
-                throw new Error("worktreePath not set before review phase");
-            }
-            // Start dev server (only in branch mode — local mode uses existing server)
-            const port = this.reviewPort;
-            const cwd = this.worktreePath;
-            if (!localMode) {
-                log.info(this.tag, `Starting dev server on port ${port}...`);
-                this.devServerProcess = spawnInGroup("bun", ["run", "dev", "--", "--port", String(port)], { cwd, stdio: ["ignore", "pipe", "pipe"] });
-                // Surface the dev-server warmup as `waiting` so the AgentTopBar
-                // doesn't sit on a stale `working` task while the server takes
-                // 10–20 seconds to boot.
-                await this.client.updateAgentProgress(card.id, {
-                    agentIdentifier: agentIdentifier(this.id),
-                    agentName: `${AGENT_NAME} (Review)`,
-                    status: "waiting",
-                    currentTask: `Starting dev server on port ${port}…`,
-                    progressPercent: 10,
-                });
-                // Invariant I2: review only proceeds with a proven-live dev server.
-                // waitForDevServer rejects on timeout / exit; probeDevServer verifies
-                // the port actually answers HTTP.
-                await waitForDevServer(this.devServerProcess, 30_000);
-                await probeDevServer(port);
-                log.info(this.tag, `Dev server ready on port ${port}`);
-                // Restore active status now that the server is live.
-                await this.client.updateAgentProgress(card.id, {
-                    agentIdentifier: agentIdentifier(this.id),
-                    agentName: `${AGENT_NAME} (Review)`,
-                    status: "working",
-                    currentTask: "Reviewing changes",
-                    progressPercent: 15,
-                });
-            }
-            if (this.aborted)
-                return;
-            // Get diff
-            let diff = "";
-            try {
-                if (localMode) {
-                    // Use pre-computed diff from resolveLocalChanges
-                    diff = localDiff ?? "";
-                }
-                else {
-                    diff = execFileSync("git", ["diff", `origin/${this.config.worktree.baseBranch}..HEAD`], { cwd, encoding: "utf-8", timeout: 30_000 });
-                }
-            }
-            catch {
-                diff = "(unable to retrieve diff)";
-            }
-            const previewUrl = `http://localhost:${port}`;
-            const enriched = {
-                card,
-                column,
-                labels,
-                subtasks,
-                mode: "review",
-            };
-            const systemPrompt = buildReviewSystemPrompt();
-            const userPrompt = buildReviewUserPrompt(enriched, this.branchName, cwd, previewUrl, diff, this.config.worktree.baseBranch);
-            // AGP P2: persist a session-linked snapshot of the review system
-            // prompt so outcome feedback can credit / penalise the framing.
-            // Best-effort — never block review on logging.
-            try {
-                const sessionResp = await this.client.getAgentSession(card.id);
-                const reviewSession = sessionResp.session;
-                const reviewSessionId = reviewSession?.id ?? null;
-                const contentHash = createHash("sha256")
-                    .update(systemPrompt)
-                    .digest("hex");
-                await this.client.recordPromptHistory({
-                    cardId: card.id,
-                    generatedPrompt: systemPrompt,
-                    variant: "execute",
-                    contextIncluded: { source: "review-knowledge", mode: "review" },
-                    sessionId: reviewSessionId,
-                    contentHash,
-                    templateVersion: 1,
-                    confidence: 0.5,
-                });
-            }
-            catch (err) {
-                log.warn(this.tag, `prompt_history persistence skipped: ${err instanceof Error ? err.message : String(err)}`);
-            }
-            await this.client.updateAgentProgress(card.id, {
-                agentIdentifier: agentIdentifier(this.id),
-                agentName: `${AGENT_NAME} (Review)`,
-                status: "working",
-                currentTask: "Running Claude review",
-                progressPercent: 20,
-            });
-            // Start timeout watchdog
-            this.timeoutTimer = setTimeout(() => {
-                log.warn(this.tag, `Review timeout reached (${this.config.review.maxTimeout}ms), cancelling`);
-                this.cancel();
-            }, this.config.review.maxTimeout);
-            // Set up progress tracking
-            this.progressTracker = new ProgressTracker(this.client, card.id, this.id, subtasks);
-            // Spawn Claude CLI for review with streaming
-            const stdout = await this.spawnClaude(userPrompt, systemPrompt, this.progressTracker, card.short_id);
-            // Capture session stats before stopping tracker
-            this.lastSessionStats = this.progressTracker?.stats ?? null;
-            this.progressTracker?.stop();
-            this.progressTracker = null;
-            const sessionStats = this.lastSessionStats;
-            if (this.aborted)
-                return;
-            // --- COMPLETING ---
-            this.state = "completing";
-            await this.recordPhase("completing");
-            log.info(this.tag, `Claude review finished for #${card.short_id}`);
-            // Kill dev server (only if we started one)
-            if (!localMode) {
-                this.killDevServer();
-            }
-            // Parse findings
-            const result = parseReviewOutput(stdout);
-            log.info(this.tag, `Review verdict: ${result.verdict} (${result.findings.length} finding(s))`);
-            await this.client.updateAgentProgress(card.id, {
-                agentIdentifier: agentIdentifier(this.id),
-                agentName: `${AGENT_NAME} (Review)`,
-                status: "working",
-                currentTask: `Processing ${result.verdict} verdict`,
-                progressPercent: 80,
-            });
-            // Run review completion pipeline
-            await runReviewCompletion(this.client, card, result, this.config, cwd, this.branchName, sessionStats, this.lastRunLogPath, this.workspaceId, this.sessionId, this.stateStore);
-        }
-        catch (err) {
-            this.state = "error";
-            const msg = err instanceof Error ? err.message : String(err);
-            log.error(this.tag, `Error reviewing #${card.short_id}: ${msg}`);
-            // End session as paused on error. Retried via runTransition so a
-            // transient API failure no longer orphans the session.
-            try {
-                const stats = this.lastSessionStats ?? this.progressTracker?.stats;
-                await runTransition(this.client, card, {
-                    endSession: {
-                        status: "paused",
-                        ...buildTokenPayload(stats),
-                    },
-                });
-            }
-            catch (tErr) {
-                log.error(this.tag, `endAgentSession unrecoverable on #${card.short_id}: ${tErr instanceof TransitionError ? tErr.detail : tErr}`);
-            }
-            // Dev server readiness failures are infrastructure errors, not
-            // implementation errors — the code under review may be perfectly
-            // fine. Invariant I2: never approve without a live server, but
-            // also never bounce the card back to "To Do" for rework. Keep
-            // it in Review with a "Need Review" label so a human steps in.
-            if (err instanceof DevServerReadinessError) {
-                try {
-                    await addLabelByName(this.client, card, NEED_REVIEW_LABEL, NEED_REVIEW_LABEL_COLOR);
-                    log.info(this.tag, `#${card.short_id} kept in Review — dev server unavailable, human review needed`);
-                }
-                catch {
-                    log.warn(this.tag, "Failed to add Need Review label after dev-server failure");
-                }
-            }
-            else {
-                // Move card out of Review to break the re-enqueue loop for other errors
-                try {
-                    await moveCardToColumn(this.client, card, this.config.review.failColumn);
-                    log.info(this.tag, `Moved #${card.short_id} to "${this.config.review.failColumn}" after error`);
-                }
-                catch {
-                    log.warn(this.tag, "Failed to move card to fail column after error");
-                }
-            }
-            if (this.runId) {
-                try {
-                    await this.stateStore.endRun(this.runId, this.state === "error" ? "paused" : "completed");
-                }
-                catch {
-                    // best-effort
-                }
-            }
-        }
-        finally {
-            if (this.runId) {
-                try {
-                    const run = this.stateStore.getRun(this.runId);
-                    if (run && run.endedAt === null) {
-                        // Cancelled runs are paused, not completed — they never
-                        // produced a verdict so treating them as success would be
-                        // a lie to the budget/attempt bookkeeping.
-                        const status = this.state === "error" || this.aborted ? "paused" : "completed";
-                        await this.stateStore.endRun(this.runId, status);
-                    }
-                }
-                catch {
-                    // best-effort
-                }
-            }
-            this.cleanup();
-            this.state = "idle";
-            this.onDone(this);
-        }
-    }
-    /**
-     * Pause the current review by suspending the Claude process (SIGSTOP).
-     */
-    async pause() {
-        if (!this.isActive || !this.process || this.process.killed)
-            return;
-        log.info(this.tag, `Pausing review on ${this.cardId}`);
-        signalGroup(this.process, "SIGSTOP");
-        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 review on ${this.cardId}`);
-        signalGroup(this.process, "SIGCONT");
-        this.timeoutTimer = setTimeout(() => {
-            log.warn(this.tag, `Timeout reached (${this.config.review.maxTimeout}ms), cancelling`);
-            this.cancel();
-        }, this.config.review.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 review. Sends escalating signals to both processes.
-     */
-    async cancel() {
-        if (!this.isActive)
-            return;
-        this.aborted = true;
-        this.state = "cancelling";
-        log.info(this.tag, `Cancelling review on ${this.cardId}`);
-        // Capture tokens/cost snapshot before stopping the tracker so a
-        // cancelled run still persists its usage to the session.
-        const snapshotStats = this.lastSessionStats ?? this.progressTracker?.stats;
-        // Stop progress tracking
-        if (this.progressTracker) {
-            this.progressTracker?.stop();
-            this.progressTracker = null;
-        }
-        // Kill dev server first
-        this.killDevServer();
-        // Then kill Claude process group with escalating signals
-        if (this.process && !this.process.killed) {
-            await terminateGroup(this.process, {
-                sigintTimeoutMs: CANCEL_SIGINT_TIMEOUT,
-                sigtermTimeoutMs: CANCEL_SIGTERM_TIMEOUT,
-            });
-        }
-        // End agent session as paused
-        if (this.cardId) {
-            try {
-                await this.client.endAgentSession(this.cardId, {
-                    status: "paused",
-                    ...buildTokenPayload(snapshotStats),
-                });
-            }
-            catch {
-                // best-effort
-            }
-        }
-    }
-    spawnClaude(prompt, systemPrompt, tracker, shortId) {
-        return new Promise((resolve, reject) => {
-            const args = [
-                "--output-format",
-                "stream-json",
-                "--verbose",
-                "--model",
-                this.config.claude.reviewModel,
-                "--max-turns",
-                String(this.config.claude.maxTurns),
-                "--allowedTools",
-                "Bash(readonly),Read,Glob,Grep,Agent,mcp__harmony__*",
-                ...(systemPrompt ? ["--append-system-prompt", systemPrompt] : []),
-                ...this.config.claude.additionalArgs,
-                "--",
-                prompt,
-            ];
-            log.info(this.tag, `Spawning review: claude ${args.slice(0, 5).join(" ")} ...`);
-            const runLog = openRunLog(this.tag, this.runId, shortId);
-            this.lastRunLogPath = runLog?.path ?? null;
-            if (runLog) {
-                log.info(this.tag, `Run log: ${runLog.path}`);
-                runLog.stream.write(`# run=${this.runId} card=#${shortId} pipeline=review 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 progress tracking + text reconstruction for verdict
-            const parser = new StreamParser();
-            tracker.attach(parser);
-            const textChunks = [];
-            parser.on("text", (content) => {
-                textChunks.push(content);
-            });
-            parser.on("parse_error", (msg) => {
-                log.debug(this.tag, `Stream parse error (non-fatal): ${msg}`);
-                runLog?.stream.write(`\n[parse_error] ${msg}\n`);
-            });
-            // Attach parser to stdout (single consumer)
-            if (this.process.stdout) {
-                parser.attach(this.process.stdout);
-                if (runLog) {
-                    this.process.stdout.on("data", (chunk) => {
-                        runLog.stream.write(chunk);
-                    });
-                }
-            }
-            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;
-                // Reconstruct text from stream parser text events
-                const stdout = textChunks.join("");
-                const stats = tracker.stats;
-                if (runLog) {
-                    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"} ` +
-                        `textChars=${stdout.length} ended=${new Date().toISOString()}\n`);
-                    runLog.stream.end();
-                }
-                if (this.aborted) {
-                    resolve(stdout);
-                }
-                else if (code === 0) {
-                    resolve(stdout);
-                }
-                else {
-                    reject(new Error(`claude exited with code ${code}${stderr ? `: ${stderr.slice(0, 500)}` : ""}`));
-                }
-            });
-        });
-    }
-    killDevServer() {
-        if (this.devServerProcess && !this.devServerProcess.killed) {
-            signalGroup(this.devServerProcess, "SIGTERM");
-            this.devServerProcess = null;
-            log.debug(this.tag, "Killed dev server group");
-        }
-    }
-    resolveLocalChanges(repoRoot, shortId) {
-        // 1. Check uncommitted changes (staged + unstaged combined)
-        try {
-            const localChanges = execFileSync("git", ["diff", "HEAD"], {
-                cwd: repoRoot,
-                encoding: "utf-8",
-                timeout: 5_000,
-            });
-            if (localChanges) {
-                return { diff: localChanges, source: "uncommitted changes" };
-            }
-        }
-        catch {
-            log.warn(this.tag, "Failed to check uncommitted changes");
-        }
-        // 2. Search recent commits for card reference
-        try {
-            const matchingCommits = execFileSync("git", ["log", "--format=%H", "-20", `--grep=#${shortId}`], { cwd: repoRoot, encoding: "utf-8", timeout: 10_000 }).trim();
-            if (matchingCommits) {
-                const hashes = matchingCommits
-                    .split("\n")
-                    .filter((h) => /^[0-9a-f]{4,40}$/i.test(h));
-                if (hashes.length === 0)
-                    return null;
-                log.info(this.tag, `Found ${hashes.length} commit(s) referencing #${shortId}`);
-                // Generate a combined diff from all matching commits
-                const diffs = [];
-                for (const hash of hashes) {
-                    try {
-                        const commitDiff = execFileSync("git", ["diff", `${hash}~1..${hash}`], { cwd: repoRoot, encoding: "utf-8", timeout: 30_000 });
-                        if (commitDiff)
-                            diffs.push(commitDiff);
-                    }
-                    catch {
-                        log.warn(this.tag, `Failed to diff commit ${hash}`);
-                    }
-                }
-                if (diffs.length > 0) {
-                    return {
-                        diff: diffs.join("\n"),
-                        source: `${diffs.length} commit(s) matching #${shortId}`,
-                    };
-                }
-            }
-        }
-        catch {
-            log.warn(this.tag, "Failed to search recent commits");
-        }
-        return null;
-    }
-    cleanup() {
-        if (this.timeoutTimer) {
-            clearTimeout(this.timeoutTimer);
-            this.timeoutTimer = null;
-        }
-        this.stopHeartbeat();
-        this.killDevServer();
-        // Clean up worktree on error (only if we created one — skip in local mode)
-        if (this.worktreePath && this.state === "error" && this.branchName) {
-            try {
-                cleanupWorktree(this.worktreePath, this.branchName);
-            }
-            catch {
-                log.warn(this.tag, "Failed to cleanup review worktree");
-            }
-        }
-        this.process = null;
-        this.cardId = null;
-        this.branchName = null;
-        this.worktreePath = null;
-        this.startedAt = null;
-        this.runId = null;
-        this.lastSessionStats = null;
-    }
-}

package/dist/review-worktree.d.ts

@@ -1,12 +0,0 @@
-/**
- * Checkout an existing remote branch into a worktree for review.
- * Unlike createWorktree() which creates a new branch, this checks out
- * an existing branch that was pushed by the implementation worker.
- */
-export declare function checkoutExistingBranch(basePath: string, branchName: string): string;
-/**
- * Extract branch name from card description's completion summary.
- * Looks for: Branch: `agent/...`
- * Validates that the extracted name contains only safe characters.
- */
-export declare function extractBranchFromDescription(description: string | null | undefined): string | null;