@gethmy/agent 1.7.1 → 1.7.3

package/dist/review-worktree.js

@@ -1,95 +0,0 @@
-import { execFileSync, execSync } from "node:child_process";
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
-import { log } from "./log.js";
-import { installCommand } from "./pm.js";
-import { cleanupWorktree } from "./worktree.js";
-const TAG = "review-worktree";
-/**
- * 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 function checkoutExistingBranch(basePath, branchName) {
-    const repoRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], {
-        encoding: "utf-8",
-    }).trim();
-    const worktreeDir = resolve(repoRoot, basePath, `review-${branchName}`);
-    if (existsSync(worktreeDir)) {
-        log.warn(TAG, `Review worktree already exists at ${worktreeDir}, cleaning up`);
-        cleanupWorktree(worktreeDir);
-    }
-    // Force-prune orphaned worktree metadata (dir removed externally but git
-    // still registers the branch as checked out). Default expiry is 3 months,
-    // which leaves fresh stale entries in place.
-    try {
-        execFileSync("git", ["worktree", "prune", "--expire=now"], {
-            cwd: repoRoot,
-            stdio: "pipe",
-        });
-    }
-    catch {
-        // non-fatal
-    }
-    // Fetch latest to ensure we have the remote branch
-    try {
-        execFileSync("git", ["fetch", "origin", branchName], {
-            cwd: repoRoot,
-            stdio: "pipe",
-        });
-    }
-    catch {
-        throw new Error(`Failed to fetch remote branch: ${branchName}`);
-    }
-    // Delete stale local branch if it exists
-    try {
-        execFileSync("git", ["branch", "-D", branchName], {
-            cwd: repoRoot,
-            stdio: "pipe",
-        });
-    }
-    catch {
-        // Branch doesn't exist locally — that's fine
-    }
-    // Create worktree from the remote branch
-    log.info(TAG, `Creating review worktree: ${worktreeDir} (branch: ${branchName})`);
-    execFileSync("git", [
-        "worktree",
-        "add",
-        "--track",
-        "-b",
-        branchName,
-        worktreeDir,
-        `origin/${branchName}`,
-    ], { cwd: repoRoot, stdio: "pipe" });
-    // Install dependencies
-    log.info(TAG, "Installing dependencies in review 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;
-}
-/**
- * Extract branch name from card description's completion summary.
- * Looks for: Branch: `agent/...`
- * Validates that the extracted name contains only safe characters.
- */
-export function extractBranchFromDescription(description) {
-    if (!description)
-        return null;
-    const match = description.match(/Branch:\s*`([^`]+)`/);
-    const branch = match?.[1] ?? null;
-    // Validate branch name contains only safe git ref characters
-    if (branch && !/^[a-zA-Z0-9/_.-]+$/.test(branch)) {
-        log.warn(TAG, `Extracted branch name contains unsafe characters: ${branch}`);
-        return null;
-    }
-    return branch;
-}

package/dist/run-log.d.ts

@@ -1,6 +0,0 @@
-import { type WriteStream } from "node:fs";
-export interface RunLog {
-    path: string;
-    stream: WriteStream;
-}
-export declare function openRunLog(tag: string, runId: string | null, shortId: number): RunLog | null;

package/dist/run-log.js

@@ -1,19 +0,0 @@
-import { createWriteStream, mkdirSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { log } from "./log.js";
-export function openRunLog(tag, runId, shortId) {
-    if (!runId)
-        return null;
-    try {
-        const dir = join(homedir(), ".harmony-mcp", "runs");
-        mkdirSync(dir, { recursive: true });
-        const path = join(dir, `${runId}-card-${shortId}.log`);
-        const stream = createWriteStream(path, { flags: "a" });
-        return { path, stream };
-    }
-    catch (err) {
-        log.warn(tag, `Failed to open run log: ${err instanceof Error ? err.message : err}`);
-        return null;
-    }
-}

package/dist/startup-banner.d.ts

@@ -1,29 +0,0 @@
-/**
- * Startup banner — collapses the ~21 individually-timestamped INFO lines
- * the daemon used to emit at startup into a single grouped block in
- * pretty/TTY mode. JSON mode is unchanged (each `check()` falls through
- * to `log.info("daemon", msg)` so log shippers see the same records).
- *
- * Usage:
- *   const banner = createStartupBanner(config, PKG_VERSION);
- *   banner.check("Claude CLI 2.1.126");
- *   banner.setProjectName("Harmony");
- *   banner.check("API key validated");
- *   ...
- *   await banner.ready("watching for card assignments");
- *
- * Pretty rendering is deferred until `ready()` so the whole block lands
- * atomically with one stderr.write — nothing can interleave inside it.
- * If a startup error occurs and a warn/error needs to fire, call
- * `banner.fail()` first so the banner suppresses itself and the warning
- * isn't hidden under the block.
- */
-import type { DaemonConfig } from "./config.js";
-export interface StartupBanner {
-    setProjectName(name: string): void;
-    setGitProvider(provider: string): void;
-    check(message: string): void;
-    ready(message: string): Promise<void>;
-    fail(): void;
-}
-export declare function createStartupBanner(config: DaemonConfig, version: string): StartupBanner;

package/dist/startup-banner.js

@@ -1,143 +0,0 @@
-import { isPretty, log } from "./log.js";
-const TAG = "daemon";
-const RULE_WIDTH = 70;
-const ANSI = {
-    reset: "\x1b[0m",
-    dim: "\x1b[2m",
-    cyan: "\x1b[36m",
-};
-export function createStartupBanner(config, version) {
-    return isPretty()
-        ? prettyBanner(config, version)
-        : jsonBanner(config, version);
-}
-function prettyBanner(config, version) {
-    const checks = [];
-    let projectName;
-    let gitProvider;
-    let failed = false;
-    let rendered = false;
-    return {
-        setProjectName(name) {
-            projectName = name;
-        },
-        setGitProvider(provider) {
-            gitProvider = provider;
-        },
-        check(message) {
-            checks.push(message);
-        },
-        fail() {
-            failed = true;
-        },
-        async ready(message) {
-            if (failed || rendered)
-                return;
-            rendered = true;
-            const block = renderPretty({
-                version,
-                config,
-                projectName,
-                gitProvider,
-                checks,
-                readyMessage: message,
-            });
-            process.stderr.write(block);
-        },
-    };
-}
-function jsonBanner(config, version) {
-    // Mirror today's structured output: one log.info per startup event.
-    // Emit the version line eagerly so JSON consumers still see it first.
-    log.info(TAG, `Harmony Agent Daemon v${version} starting...`);
-    log.info(TAG, `Project: ${config.projectId} | Pool: ${config.agent.poolSize} | Model: ${config.agent.claude.model} | Pickup: ${config.agent.pickupColumns.join(", ")}`);
-    if (config.agent.review.enabled) {
-        log.info(TAG, `Review: enabled | Columns: ${config.agent.review.pickupColumns.join(", ")} | → ${config.agent.review.moveToColumn} / ${config.agent.review.failColumn}`);
-    }
-    let failed = false;
-    return {
-        setProjectName(_name) {
-            // No-op in JSON mode — the explicit `Project access (X)` check
-            // line that follows already conveys this and avoids duplication.
-        },
-        setGitProvider(provider) {
-            log.info(TAG, `Git provider: ${provider}`);
-        },
-        check(message) {
-            log.info(TAG, message);
-        },
-        fail() {
-            failed = true;
-        },
-        async ready(message) {
-            if (failed)
-                return;
-            log.info(TAG, message);
-        },
-    };
-}
-function renderPretty(input) {
-    const { version, config, projectName, gitProvider, checks, readyMessage } = input;
-    const lines = [];
-    lines.push("");
-    lines.push(titleRule(`Harmony Agent Daemon v${version}`));
-    lines.push("");
-    for (const row of configRows(config, projectName, gitProvider)) {
-        lines.push(`  ${dim(row.label.padEnd(9))} ${row.value}`);
-    }
-    lines.push("");
-    for (const msg of checks) {
-        lines.push(`  ${cyan("✓")} ${msg}`);
-    }
-    lines.push("");
-    lines.push(`${cyan("▶")} ${cyan("Ready")} — ${readyMessage}`);
-    lines.push(dim("─".repeat(RULE_WIDTH)));
-    lines.push("");
-    return lines.join("\n");
-}
-function configRows(config, projectName, gitProvider) {
-    const rows = [];
-    const projectLabel = projectName
-        ? `${projectName} (${shortenId(config.projectId)})`
-        : shortenId(config.projectId);
-    rows.push({ label: "Project", value: projectLabel });
-    rows.push({ label: "User", value: config.userEmail });
-    const reviewEnabled = config.agent.review.enabled;
-    const poolDesc = reviewEnabled
-        ? `Pool ${config.agent.poolSize} impl + ${config.agent.review.poolSize} review`
-        : `Pool ${config.agent.poolSize} impl`;
-    const flowDesc = reviewEnabled
-        ? `Pickup ${config.agent.pickupColumns[0]} → ${config.agent.completion.moveToColumn} → ${config.agent.review.moveToColumn}`
-        : `Pickup ${config.agent.pickupColumns.join(", ")}`;
-    rows.push({
-        label: "Model",
-        value: `${config.agent.claude.model}  ·  ${poolDesc}  ·  ${flowDesc}`,
-    });
-    const tail = [];
-    if (gitProvider)
-        tail.push(gitProvider);
-    if (config.agent.http.enabled) {
-        tail.push(`HTTP http://${config.agent.http.bindAddr}:${config.agent.http.port}`);
-    }
-    if (tail.length > 0) {
-        rows.push({ label: "Git", value: tail.join("  ·  ") });
-    }
-    return rows;
-}
-function titleRule(title) {
-    const prefix = "─── ";
-    const surround = ` `;
-    const suffix = "─".repeat(Math.max(3, RULE_WIDTH - prefix.length - title.length - surround.length));
-    return dim(`${prefix}${title}${surround}${suffix}`);
-}
-function shortenId(id) {
-    if (id.length <= 8)
-        return id;
-    return `${id.slice(0, 8)}…`;
-}
-function dim(s) {
-    return `${ANSI.dim}${s}${ANSI.reset}`;
-}
-function cyan(s) {
-    return `${ANSI.cyan}${s}${ANSI.reset}`;
-}

package/dist/state-store.d.ts

@@ -1,89 +0,0 @@
-export type RunPipeline = "implement" | "review";
-export type RunStatus = "active" | "completed" | "paused" | "orphaned";
-export interface RunRecord {
-    runId: string;
-    cardId: string;
-    cardShortId: number;
-    pipeline: RunPipeline;
-    workerId: number;
-    sessionId: string | null;
-    worktreePath: string | null;
-    branchName: string | null;
-    daemonPid: number;
-    phase: string;
-    startedAt: number;
-    lastHeartbeatAt: number;
-    endedAt: number | null;
-    status: RunStatus;
-    costCents: number;
-    errorMessage?: string;
-}
-export interface FailureSummaryRecord {
-    summary: string;
-    ts: number;
-    reason?: "verification" | "review" | "daemon_restart" | "budget" | "other";
-    recoveryBranch?: string;
-}
-export interface CardRecord {
-    cardId: string;
-    attempts: number;
-    totalCostCents: number;
-    lastAttemptAt: number | null;
-    lastOutcome: "success" | "failure" | null;
-    failureHistory?: FailureSummaryRecord[];
-}
-export declare function newRunId(): string;
-export declare function defaultStatePath(): string;
-/**
- * Durable run-and-card state for the agent daemon. One writer (this daemon),
- * so in-process serialization via a promise chain is sufficient — no file locks.
- * Persists to JSON via write-to-tmp + rename, which is atomic on POSIX.
- */
-export declare class StateStore {
-    private path;
-    private state;
-    private writeQueue;
-    constructor(path: string);
-    static open(path?: string): StateStore;
-    private load;
-    private persist;
-    /** Await any pending writes. Useful for tests and shutdown. */
-    flush(): Promise<void>;
-    setDaemon(daemonId: string, pid: number): Promise<void>;
-    getDaemon(): {
-        daemonId: string | null;
-        daemonPid: number | null;
-        daemonStartedAt: number | null;
-    };
-    insertRun(run: RunRecord): Promise<void>;
-    updateRun(runId: string, patch: Partial<RunRecord>): Promise<void>;
-    heartbeat(runId: string): Promise<void>;
-    endRun(runId: string, status: RunStatus, errorMessage?: string): Promise<void>;
-    getRun(runId: string): RunRecord | null;
-    getActiveRuns(): RunRecord[];
-    getRunsForCard(cardId: string): RunRecord[];
-    /** Trim completed runs older than `beforeTs` to keep the file small. */
-    purgeOldRuns(beforeTs: number): Promise<void>;
-    private ensureCard;
-    getCard(cardId: string): CardRecord | null;
-    incrementAttempt(cardId: string): Promise<number>;
-    recordOutcome(cardId: string, outcome: "success" | "failure"): Promise<void>;
-    /**
-     * Reset a card's attempt counter so a card that previously gave up
-     * (attempts >= maxAttemptsPerCard) becomes eligible again. Called when a
-     * card is unassigned/reassigned — reassignment is the human's "try again".
-     * No-op for an unknown card.
-     */
-    resetAttempts(cardId: string): Promise<void>;
-    /**
-     * Push a failure summary onto the card's bounded history (most-recent first,
-     * capped at 5). Read back by the give-up comment and the Agent History
-     * UI section to give users a post-mortem trail across attempts.
-     */
-    recordFailureSummary(cardId: string, entry: Omit<FailureSummaryRecord, "ts"> & {
-        ts?: number;
-    }): Promise<void>;
-    getRecentFailures(cardId: string, limit?: number): FailureSummaryRecord[];
-    addCost(cardId: string, cents: number): Promise<void>;
-    getDailyCostCents(date?: string): number;
-}

package/dist/state-store.js

@@ -1,230 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-import { log } from "./log.js";
-const TAG = "state-store";
-const SCHEMA_VERSION = 1;
-function emptyState() {
-    return {
-        version: SCHEMA_VERSION,
-        daemonId: null,
-        daemonPid: null,
-        daemonStartedAt: null,
-        runs: [],
-        cards: [],
-        daily: [],
-    };
-}
-function todayUtc() {
-    return new Date().toISOString().slice(0, 10);
-}
-export function newRunId() {
-    const ts = Date.now().toString(36);
-    const rand = Math.random().toString(36).slice(2, 10);
-    return `r_${ts}_${rand}`;
-}
-export function defaultStatePath() {
-    return join(homedir(), ".harmony-mcp", "agent-state.json");
-}
-/**
- * Durable run-and-card state for the agent daemon. One writer (this daemon),
- * so in-process serialization via a promise chain is sufficient — no file locks.
- * Persists to JSON via write-to-tmp + rename, which is atomic on POSIX.
- */
-export class StateStore {
-    path;
-    state;
-    writeQueue = Promise.resolve();
-    constructor(path) {
-        this.path = path;
-        this.state = this.load();
-    }
-    static open(path) {
-        const resolved = path ?? defaultStatePath();
-        const dir = dirname(resolved);
-        if (!existsSync(dir))
-            mkdirSync(dir, { recursive: true });
-        return new StateStore(resolved);
-    }
-    load() {
-        if (!existsSync(this.path))
-            return emptyState();
-        try {
-            const raw = readFileSync(this.path, "utf-8");
-            const parsed = JSON.parse(raw);
-            if (parsed?.version !== SCHEMA_VERSION) {
-                log.warn(TAG, `state file has version ${parsed?.version}, expected ${SCHEMA_VERSION} — starting fresh`);
-                return emptyState();
-            }
-            return {
-                version: SCHEMA_VERSION,
-                daemonId: parsed.daemonId ?? null,
-                daemonPid: parsed.daemonPid ?? null,
-                daemonStartedAt: parsed.daemonStartedAt ?? null,
-                runs: parsed.runs ?? [],
-                cards: parsed.cards ?? [],
-                daily: parsed.daily ?? [],
-            };
-        }
-        catch (err) {
-            log.error(TAG, `failed to read state file: ${err instanceof Error ? err.message : err}`);
-            return emptyState();
-        }
-    }
-    persist() {
-        const fire = async () => {
-            const tmp = `${this.path}.tmp`;
-            const data = JSON.stringify(this.state, null, 2);
-            writeFileSync(tmp, data, "utf-8");
-            renameSync(tmp, this.path);
-        };
-        this.writeQueue = this.writeQueue.then(fire, fire);
-        return this.writeQueue;
-    }
-    /** Await any pending writes. Useful for tests and shutdown. */
-    flush() {
-        return this.writeQueue;
-    }
-    // ---------- Daemon metadata ----------
-    setDaemon(daemonId, pid) {
-        this.state.daemonId = daemonId;
-        this.state.daemonPid = pid;
-        this.state.daemonStartedAt = Date.now();
-        return this.persist();
-    }
-    getDaemon() {
-        return {
-            daemonId: this.state.daemonId,
-            daemonPid: this.state.daemonPid,
-            daemonStartedAt: this.state.daemonStartedAt,
-        };
-    }
-    // ---------- Runs ----------
-    insertRun(run) {
-        this.state.runs.push(run);
-        return this.persist();
-    }
-    updateRun(runId, patch) {
-        const idx = this.state.runs.findIndex((r) => r.runId === runId);
-        if (idx === -1)
-            return Promise.resolve();
-        this.state.runs[idx] = { ...this.state.runs[idx], ...patch };
-        return this.persist();
-    }
-    heartbeat(runId) {
-        return this.updateRun(runId, { lastHeartbeatAt: Date.now() });
-    }
-    endRun(runId, status, errorMessage) {
-        const patch = {
-            status,
-            endedAt: Date.now(),
-        };
-        if (errorMessage !== undefined)
-            patch.errorMessage = errorMessage;
-        return this.updateRun(runId, patch);
-    }
-    getRun(runId) {
-        return this.state.runs.find((r) => r.runId === runId) ?? null;
-    }
-    getActiveRuns() {
-        return this.state.runs.filter((r) => r.endedAt === null);
-    }
-    getRunsForCard(cardId) {
-        return this.state.runs.filter((r) => r.cardId === cardId);
-    }
-    /** Trim completed runs older than `beforeTs` to keep the file small. */
-    purgeOldRuns(beforeTs) {
-        this.state.runs = this.state.runs.filter((r) => r.endedAt === null || r.endedAt >= beforeTs);
-        return this.persist();
-    }
-    // ---------- Cards ----------
-    ensureCard(cardId) {
-        let rec = this.state.cards.find((c) => c.cardId === cardId);
-        if (!rec) {
-            rec = {
-                cardId,
-                attempts: 0,
-                totalCostCents: 0,
-                lastAttemptAt: null,
-                lastOutcome: null,
-            };
-            this.state.cards.push(rec);
-        }
-        return rec;
-    }
-    getCard(cardId) {
-        return this.state.cards.find((c) => c.cardId === cardId) ?? null;
-    }
-    async incrementAttempt(cardId) {
-        const rec = this.ensureCard(cardId);
-        rec.attempts += 1;
-        rec.lastAttemptAt = Date.now();
-        await this.persist();
-        return rec.attempts;
-    }
-    async recordOutcome(cardId, outcome) {
-        const rec = this.ensureCard(cardId);
-        rec.lastOutcome = outcome;
-        if (outcome === "success")
-            rec.attempts = 0;
-        await this.persist();
-    }
-    /**
-     * Reset a card's attempt counter so a card that previously gave up
-     * (attempts >= maxAttemptsPerCard) becomes eligible again. Called when a
-     * card is unassigned/reassigned — reassignment is the human's "try again".
-     * No-op for an unknown card.
-     */
-    async resetAttempts(cardId) {
-        const rec = this.getCard(cardId);
-        if (!rec || rec.attempts === 0)
-            return;
-        rec.attempts = 0;
-        await this.persist();
-    }
-    /**
-     * Push a failure summary onto the card's bounded history (most-recent first,
-     * capped at 5). Read back by the give-up comment and the Agent History
-     * UI section to give users a post-mortem trail across attempts.
-     */
-    async recordFailureSummary(cardId, entry) {
-        const rec = this.ensureCard(cardId);
-        const next = {
-            summary: entry.summary.slice(0, 500),
-            ts: entry.ts ?? Date.now(),
-            reason: entry.reason,
-            recoveryBranch: entry.recoveryBranch,
-        };
-        const existing = rec.failureHistory ?? [];
-        rec.failureHistory = [next, ...existing].slice(0, 5);
-        await this.persist();
-    }
-    getRecentFailures(cardId, limit = 3) {
-        const rec = this.getCard(cardId);
-        if (!rec?.failureHistory)
-            return [];
-        return rec.failureHistory.slice(0, limit);
-    }
-    async addCost(cardId, cents) {
-        if (cents <= 0)
-            return;
-        const rec = this.ensureCard(cardId);
-        rec.totalCostCents += cents;
-        const today = todayUtc();
-        let daily = this.state.daily.find((d) => d.date === today);
-        if (!daily) {
-            daily = { date: today, costCents: 0 };
-            this.state.daily.push(daily);
-        }
-        daily.costCents += cents;
-        const cutoff = new Date(Date.now() - 30 * 86_400_000)
-            .toISOString()
-            .slice(0, 10);
-        this.state.daily = this.state.daily.filter((d) => d.date >= cutoff);
-        await this.persist();
-    }
-    getDailyCostCents(date) {
-        const key = date ?? todayUtc();
-        return this.state.daily.find((d) => d.date === key)?.costCents ?? 0;
-    }
-}

package/dist/stream-parser-selftest.d.ts

@@ -1,9 +0,0 @@
-/**
- * Feed a minimal Claude-CLI stream-json fixture through StreamParser and
- * assert the expected events fire. Intended as a startup canary: if the CLI
- * ever changes its envelope shape, the daemon fails loud on boot instead of
- * silently parking every card with a parse error (see card #128).
- *
- * Throws on any missing event; returns silently on success.
- */
-export declare function verifyStreamParserFormat(): void;