@gethmy/agent 1.7.0 → 1.7.2

package/dist/http-server.d.ts

@@ -1,79 +0,0 @@
-export interface HealthSnapshot {
-    healthy: boolean;
-    checks: Record<string, boolean>;
-}
-export interface WorkerSnapshot {
-    id: number;
-    pipeline: "implement" | "review";
-    state: string;
-    cardId: string | null;
-    cardShortId: number | null;
-    phase: string | null;
-    startedAt: number | null;
-    branchName: string | null;
-}
-export interface StatusSnapshot {
-    daemonId: string;
-    daemonPid: number;
-    startedAt: number;
-    uptimeMs: number;
-    workers: WorkerSnapshot[];
-    implQueue: Array<{
-        cardId: string;
-        shortId: number;
-        priority: number;
-        enqueuedAt: number;
-    }>;
-    reviewQueue: Array<{
-        cardId: string;
-        shortId: number;
-        priority: number;
-        enqueuedAt: number;
-    }>;
-    dlq: Array<{
-        cardId: string;
-        reason: string;
-        attempts: number;
-        totalCostCents: number;
-    }>;
-    budget: {
-        todayCents: number;
-        dailyCapCents: number;
-    };
-}
-export type Command = "pause" | "resume" | "stop";
-export interface HttpServerOptions {
-    port: number;
-    bindAddr: string;
-    getStatus: () => StatusSnapshot;
-    getHealth: () => HealthSnapshot;
-    handleCommand: (cmd: Command, cardId: string) => Promise<void>;
-    /**
-     * Clear a card's DLQ marker. Routed through the daemon (not CLI
-     * direct-write) so we never have two processes racing to persist
-     * the same state-store file.
-     */
-    clearDlq: (cardId: string) => Promise<void>;
-}
-/**
- * Tiny introspection + control surface for the running daemon.
- * Binds to 127.0.0.1 by default so it's not network-reachable.
- *
- * GET /health — 200 when healthy, 503 otherwise. Simple liveness check
- *   suitable for process supervisors (systemd, pm2, docker healthcheck).
- * GET /status — full JSON snapshot: workers, queues, DLQ, budget.
- * POST /pause/:cardId, /resume/:cardId, /stop/:cardId — command path
- *   so an operator can nudge a stuck worker without killing the daemon.
- */
-export declare class HttpServer {
-    private opts;
-    private server;
-    constructor(opts: HttpServerOptions);
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    private route;
-    private respondDlqClear;
-    private respondHealth;
-    private respondStatus;
-    private respondCommand;
-}

package/dist/http-server.js

@@ -1,114 +0,0 @@
-import { createServer, } from "node:http";
-import { log } from "./log.js";
-const TAG = "http";
-/**
- * Tiny introspection + control surface for the running daemon.
- * Binds to 127.0.0.1 by default so it's not network-reachable.
- *
- * GET /health — 200 when healthy, 503 otherwise. Simple liveness check
- *   suitable for process supervisors (systemd, pm2, docker healthcheck).
- * GET /status — full JSON snapshot: workers, queues, DLQ, budget.
- * POST /pause/:cardId, /resume/:cardId, /stop/:cardId — command path
- *   so an operator can nudge a stuck worker without killing the daemon.
- */
-export class HttpServer {
-    opts;
-    server = null;
-    constructor(opts) {
-        this.opts = opts;
-    }
-    async start() {
-        return new Promise((resolve, reject) => {
-            this.server = createServer((req, res) => {
-                this.route(req, res).catch((err) => {
-                    log.error(TAG, `unhandled: ${err instanceof Error ? err.message : err}`);
-                    if (!res.headersSent) {
-                        res.writeHead(500, { "content-type": "application/json" });
-                        res.end(JSON.stringify({ error: "internal_error" }));
-                    }
-                });
-            });
-            this.server.once("error", reject);
-            this.server.listen(this.opts.port, this.opts.bindAddr, () => {
-                resolve();
-            });
-        });
-    }
-    async stop() {
-        if (!this.server)
-            return;
-        await new Promise((resolve) => {
-            this.server?.close(() => resolve());
-        });
-        this.server = null;
-    }
-    async route(req, res) {
-        const url = new URL(req.url ?? "/", "http://localhost");
-        const method = (req.method ?? "GET").toUpperCase();
-        const path = url.pathname;
-        if (method === "GET" && path === "/health") {
-            return this.respondHealth(res);
-        }
-        if (method === "GET" && path === "/status") {
-            return this.respondStatus(res);
-        }
-        if (method === "POST") {
-            const dlq = path.match(/^\/dlq\/clear\/([^/]+)$/);
-            if (dlq) {
-                return this.respondDlqClear(res, decodeURIComponent(dlq[1]));
-            }
-            const cmd = parseCommand(path);
-            if (cmd) {
-                return this.respondCommand(res, cmd.command, cmd.cardId);
-            }
-        }
-        res.writeHead(404, { "content-type": "application/json" });
-        res.end(JSON.stringify({ error: "not_found", path }));
-    }
-    async respondDlqClear(res, cardId) {
-        try {
-            await this.opts.clearDlq(cardId);
-            res.writeHead(200, { "content-type": "application/json" });
-            res.end(JSON.stringify({ ok: true, cardId }));
-        }
-        catch (err) {
-            res.writeHead(500, { "content-type": "application/json" });
-            res.end(JSON.stringify({
-                error: "clear_dlq_failed",
-                detail: err instanceof Error ? err.message : String(err),
-            }));
-        }
-    }
-    respondHealth(res) {
-        const health = this.opts.getHealth();
-        res.writeHead(health.healthy ? 200 : 503, {
-            "content-type": "application/json",
-        });
-        res.end(JSON.stringify(health));
-    }
-    respondStatus(res) {
-        const snapshot = this.opts.getStatus();
-        res.writeHead(200, { "content-type": "application/json" });
-        res.end(JSON.stringify(snapshot));
-    }
-    async respondCommand(res, command, cardId) {
-        try {
-            await this.opts.handleCommand(command, cardId);
-            res.writeHead(200, { "content-type": "application/json" });
-            res.end(JSON.stringify({ ok: true, command, cardId }));
-        }
-        catch (err) {
-            res.writeHead(500, { "content-type": "application/json" });
-            res.end(JSON.stringify({
-                error: "command_failed",
-                detail: err instanceof Error ? err.message : String(err),
-            }));
-        }
-    }
-}
-function parseCommand(path) {
-    const match = path.match(/^\/(pause|resume|stop)\/([^/]+)$/);
-    if (!match)
-        return null;
-    return { command: match[1], cardId: decodeURIComponent(match[2]) };
-}

package/dist/index.d.ts

@@ -1,5 +0,0 @@
-import { type DaemonConfig } from "./config.js";
-import { type StartupBanner } from "./startup-banner.js";
-declare function validatePrerequisites(config: DaemonConfig, banner: StartupBanner): Promise<string>;
-export { validatePrerequisites };
-export declare function main(): Promise<void>;

package/dist/log.d.ts

@@ -1,34 +0,0 @@
-/**
- * Structured logging for the agent daemon.
- *
- * When stderr is a TTY, output is ANSI-coloured single-line text — the
- * readable default for humans running the daemon interactively. When
- * stderr is piped/redirected (files, logshippers, systemd), output
- * falls back to one JSON object per line — trivially `jq`-able,
- * indexable, and machine-readable.
- *
- * Overrides: `--pretty` / HARMONY_AGENT_PRETTY=1 force pretty;
- * `--json`   / HARMONY_AGENT_JSON=1   force JSON. Explicit flags beat
- * TTY detection either way.
- *
- * Stdout is left clean so consumers can pipe structured data if they
- * want to (future use).
- */
-export interface LogContext {
-    event?: string;
-    runId?: string;
-    cardId?: string;
-    [key: string]: unknown;
-}
-export declare const log: {
-    info(tag: string, msg: string, ctx?: LogContext): void;
-    warn(tag: string, msg: string, ctx?: LogContext): void;
-    error(tag: string, msg: string, ctx?: LogContext): void;
-    debug(tag: string, msg: string, ctx?: LogContext): void;
-    /**
-     * Emit a named event. Semantically the same as `info` but signals to
-     * downstream tooling that this is a structured event worth indexing.
-     */
-    event(tag: string, event: string, ctx?: LogContext): void;
-};
-export declare function isPretty(): boolean;

package/dist/log.js

@@ -1,100 +0,0 @@
-/**
- * Structured logging for the agent daemon.
- *
- * When stderr is a TTY, output is ANSI-coloured single-line text — the
- * readable default for humans running the daemon interactively. When
- * stderr is piped/redirected (files, logshippers, systemd), output
- * falls back to one JSON object per line — trivially `jq`-able,
- * indexable, and machine-readable.
- *
- * Overrides: `--pretty` / HARMONY_AGENT_PRETTY=1 force pretty;
- * `--json`   / HARMONY_AGENT_JSON=1   force JSON. Explicit flags beat
- * TTY detection either way.
- *
- * Stdout is left clean so consumers can pipe structured data if they
- * want to (future use).
- */
-const COLORS = {
-    reset: "\x1b[0m",
-    dim: "\x1b[2m",
-    red: "\x1b[31m",
-    green: "\x1b[32m",
-    yellow: "\x1b[33m",
-    blue: "\x1b[34m",
-    cyan: "\x1b[36m",
-};
-const LEVEL_COLOR = {
-    debug: COLORS.dim,
-    info: COLORS.green,
-    warn: COLORS.yellow,
-    error: COLORS.red,
-};
-function pretty() {
-    if (process.env.HARMONY_AGENT_JSON === "1" ||
-        process.argv.includes("--json")) {
-        return false;
-    }
-    if (process.env.HARMONY_AGENT_PRETTY === "1")
-        return true;
-    if (process.argv.includes("--pretty"))
-        return true;
-    return Boolean(process.stderr.isTTY);
-}
-function shortTime(iso) {
-    return iso.slice(11, 23);
-}
-function emit(rec) {
-    if (rec.level === "debug" && !process.env.DEBUG)
-        return;
-    if (pretty()) {
-        const color = LEVEL_COLOR[rec.level];
-        const label = rec.level.toUpperCase().padEnd(5, " ");
-        const ctx = [];
-        if (rec.event)
-            ctx.push(`event=${rec.event}`);
-        if (rec.runId)
-            ctx.push(`run=${rec.runId}`);
-        if (rec.cardId)
-            ctx.push(`card=${rec.cardId}`);
-        const tail = ctx.length
-            ? ` ${COLORS.dim}(${ctx.join(" ")})${COLORS.reset}`
-            : "";
-        process.stderr.write(`${COLORS.dim}${shortTime(rec.ts)}${COLORS.reset} ${color}${label}${COLORS.reset} ${COLORS.cyan}[${rec.tag}]${COLORS.reset} ${rec.msg}${tail}\n`);
-        return;
-    }
-    process.stderr.write(`${JSON.stringify(rec)}\n`);
-}
-function record(level, tag, msg, ctx) {
-    const rec = {
-        ts: new Date().toISOString(),
-        level,
-        tag,
-        msg,
-        ...(ctx ?? {}),
-    };
-    emit(rec);
-}
-export const log = {
-    info(tag, msg, ctx) {
-        record("info", tag, msg, ctx);
-    },
-    warn(tag, msg, ctx) {
-        record("warn", tag, msg, ctx);
-    },
-    error(tag, msg, ctx) {
-        record("error", tag, msg, ctx);
-    },
-    debug(tag, msg, ctx) {
-        record("debug", tag, msg, ctx);
-    },
-    /**
-     * Emit a named event. Semantically the same as `info` but signals to
-     * downstream tooling that this is a structured event worth indexing.
-     */
-    event(tag, event, ctx) {
-        record("info", tag, event, { ...ctx, event });
-    },
-};
-export function isPretty() {
-    return pretty();
-}

package/dist/merge-monitor.d.ts

@@ -1,23 +0,0 @@
-import type { HarmonyApiClient } from "@gethmy/mcp/src/api-client.js";
-import type { AgentConfig } from "./types.js";
-/**
- * Polls "Ready to Merge" cards and detects when their PRs get merged,
- * then moves the card to Done and swaps labels.
- */
-export declare class MergeMonitor {
-    private client;
-    private projectId;
-    private config;
-    private intervalMs;
-    private timer;
-    private running;
-    private readonly provider;
-    private readonly cwd;
-    constructor(client: HarmonyApiClient, projectId: string, config: AgentConfig, intervalMs?: number);
-    start(): void;
-    stop(): void;
-    /** Schedule the next tick after `delayMs`, avoiding overlapping ticks. */
-    private scheduleNext;
-    private tick;
-    private completeMergedCard;
-}

package/dist/merge-monitor.js

@@ -1,169 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { addLabelByName, buildLabelMap, hasLabel, moveCardToColumn, resolveCardLabels, } from "./board-helpers.js";
-import { checkPrMergeStatus, detectGitProvider, extractPrUrl, } from "./git-pr.js";
-import { log } from "./log.js";
-import { extractBranchFromDescription } from "./review-worktree.js";
-const TAG = "merge-monitor";
-const execFileAsync = promisify(execFile);
-/**
- * Polls "Ready to Merge" cards and detects when their PRs get merged,
- * then moves the card to Done and swaps labels.
- */
-export class MergeMonitor {
-    client;
-    projectId;
-    config;
-    intervalMs;
-    timer = null;
-    running = false;
-    provider;
-    cwd;
-    constructor(client, projectId, config, intervalMs = 60_000) {
-        this.client = client;
-        this.projectId = projectId;
-        this.config = config;
-        this.intervalMs = intervalMs;
-        this.provider = detectGitProvider();
-        this.cwd = process.cwd();
-    }
-    start() {
-        this.running = true;
-        void this.scheduleNext(0);
-    }
-    stop() {
-        this.running = false;
-        if (this.timer) {
-            clearTimeout(this.timer);
-            this.timer = null;
-        }
-        log.info(TAG, "Merge monitor stopped");
-    }
-    /** Schedule the next tick after `delayMs`, avoiding overlapping ticks. */
-    async scheduleNext(delayMs) {
-        await new Promise((resolve) => {
-            this.timer = setTimeout(() => resolve(), delayMs);
-        });
-        if (!this.running)
-            return; // stopped while waiting
-        await this.tick();
-        if (this.running) {
-            void this.scheduleNext(this.intervalMs);
-        }
-    }
-    async tick() {
-        try {
-            const board = await this.client.getBoard(this.projectId, {
-                labelName: this.config.review.approvedLabel,
-            });
-            const cards = (board.cards ?? []);
-            const columns = (board.columns ?? []);
-            // Build label lookup (id → Label) to resolve card.labelIds
-            const labelMap = buildLabelMap((board.labels ?? []));
-            // Find review column IDs
-            const reviewColumnIds = new Set(columns
-                .filter((c) => this.config.review.pickupColumns.some((name) => name.toLowerCase() === c.name.toLowerCase()))
-                .map((c) => c.id));
-            // Cards are already pre-filtered by the approved label server-side via
-            // the `labelName` param. The column + label checks below are kept as
-            // defense-in-depth against API changes or stale cache.
-            const approvedLabel = this.config.review.approvedLabel;
-            const candidatesWithLabels = [];
-            for (const c of cards) {
-                if (c.archived_at || !reviewColumnIds.has(c.column_id))
-                    continue;
-                const labels = resolveCardLabels(c, labelMap);
-                if (hasLabel(labels, approvedLabel)) {
-                    candidatesWithLabels.push({ card: c, labels });
-                }
-            }
-            if (candidatesWithLabels.length === 0) {
-                log.debug(TAG, "No Ready to Merge cards found");
-                return;
-            }
-            // Process max 5 per tick to respect rate limits
-            const batch = candidatesWithLabels.slice(0, 5);
-            log.debug(TAG, `Checking ${batch.length} Ready to Merge card(s)`);
-            // Check PR states concurrently (async, non-blocking)
-            const results = await Promise.allSettled(batch.map(async ({ card, labels }) => {
-                const prUrl = extractPrUrl(card.description ?? null);
-                if (!prUrl) {
-                    log.debug(TAG, `#${card.short_id} has no PR URL — skipping`);
-                    return;
-                }
-                const state = await checkPrMergeStatus(prUrl, this.cwd, this.provider);
-                if (state === "merged") {
-                    log.info(TAG, `#${card.short_id} PR merged — completing`);
-                    await this.completeMergedCard(card, labels);
-                }
-                else {
-                    log.debug(TAG, `#${card.short_id} PR state: ${state}`);
-                }
-            }));
-            for (const r of results) {
-                if (r.status === "rejected") {
-                    log.warn(TAG, `Card processing failed: ${r.reason}`);
-                }
-            }
-        }
-        catch (err) {
-            log.error(TAG, `Tick failed: ${err instanceof Error ? err.message : err}`);
-        }
-    }
-    async completeMergedCard(card, resolvedLabels) {
-        // 1. Move to Done — bail if this fails since subsequent steps assume card is in Done
-        try {
-            await moveCardToColumn(this.client, card, this.config.review.moveToColumn);
-        }
-        catch (err) {
-            log.error(TAG, `Failed to move #${card.short_id} to Done: ${err instanceof Error ? err.message : err}`);
-            return;
-        }
-        // 2. Add "Merged" label
-        await addLabelByName(this.client, card, this.config.review.mergedLabel, this.config.review.mergedLabelColor);
-        // 3. Remove "Ready to Merge" label
-        const approvedLabelName = this.config.review.approvedLabel.toLowerCase();
-        const approvedLabelObj = resolvedLabels.find((l) => l.name.toLowerCase() === approvedLabelName);
-        if (approvedLabelObj) {
-            try {
-                await this.client.removeLabelFromCard(card.id, approvedLabelObj.id);
-                log.info(TAG, `Removed "${this.config.review.approvedLabel}" from #${card.short_id}`);
-            }
-            catch (err) {
-                log.warn(TAG, `Failed to remove label: ${err instanceof Error ? err.message : err}`);
-            }
-        }
-        // 4. Append merge timestamp to description (idempotent).
-        // Do NOT force done=true here — the column's `mark_cards_done` flag is the
-        // user's source of truth, and the backend `moveCard` in step 1 already
-        // applied it. Overriding here would ignore the user's column setting (#129).
-        const existing = card.description || "";
-        const alreadyStamped = existing.includes("Merged at");
-        if (!alreadyStamped) {
-            try {
-                const timestamp = new Date().toISOString();
-                const separator = existing ? "\n" : "";
-                await this.client.updateCard(card.id, {
-                    description: `${existing}${separator}Merged at ${timestamp}`,
-                });
-            }
-            catch (err) {
-                log.warn(TAG, `Failed to update card: ${err instanceof Error ? err.message : err}`);
-            }
-        }
-        // 5. Best-effort: clean up local branch (uses shared extraction with validation)
-        const branchName = extractBranchFromDescription(card.description);
-        if (branchName) {
-            try {
-                await execFileAsync("git", ["branch", "-D", "--", branchName], {
-                    cwd: this.cwd,
-                });
-                log.info(TAG, `Deleted local branch ${branchName}`);
-            }
-            catch {
-                // best-effort
-            }
-        }
-        log.info(TAG, `#${card.short_id} completed (merged)`);
-    }
-}

package/dist/pm.d.ts

@@ -1,14 +0,0 @@
-export type PackageManager = "bun" | "npm" | "pnpm" | "yarn";
-/**
- * Detect the package manager based on lockfiles in the repo root.
- */
-export declare function detectPackageManager(): PackageManager;
-/**
- * Return the install command string for the detected package manager.
- */
-export declare function installCommand(): string;
-/**
- * Return [cmd, args[]] suitable for spawn() or execFileSync() to run a package script.
- * Adds `--` separator for npm and pnpm when extra args are present.
- */
-export declare function spawnRunArgs(script: string, ...extra: string[]): [string, string[]];

package/dist/pm.js

@@ -1,63 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { existsSync } from "node:fs";
-import { log } from "./log.js";
-const TAG = "pm";
-let cached = null;
-/**
- * Detect the package manager based on lockfiles in the repo root.
- */
-export function detectPackageManager() {
-    if (cached)
-        return cached;
-    let repoRoot;
-    try {
-        repoRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], {
-            encoding: "utf-8",
-        }).trim();
-    }
-    catch {
-        repoRoot = process.cwd();
-    }
-    if (existsSync(`${repoRoot}/bun.lock`) ||
-        existsSync(`${repoRoot}/bun.lockb`)) {
-        cached = "bun";
-    }
-    else if (existsSync(`${repoRoot}/pnpm-lock.yaml`)) {
-        cached = "pnpm";
-    }
-    else if (existsSync(`${repoRoot}/yarn.lock`)) {
-        cached = "yarn";
-    }
-    else {
-        cached = "npm";
-    }
-    log.info(TAG, `Detected package manager: ${cached}`);
-    return cached;
-}
-/**
- * Return the install command string for the detected package manager.
- */
-export function installCommand() {
-    const pm = detectPackageManager();
-    switch (pm) {
-        case "bun":
-            return "bun install --frozen-lockfile";
-        case "pnpm":
-            return "pnpm install --frozen-lockfile";
-        case "yarn":
-            return "yarn install --frozen-lockfile";
-        case "npm":
-            return "npm ci";
-    }
-}
-/**
- * Return [cmd, args[]] suitable for spawn() or execFileSync() to run a package script.
- * Adds `--` separator for npm and pnpm when extra args are present.
- */
-export function spawnRunArgs(script, ...extra) {
-    const pm = detectPackageManager();
-    if (extra.length > 0 && (pm === "npm" || pm === "pnpm")) {
-        return [pm, ["run", script, "--", ...extra]];
-    }
-    return [pm, ["run", script, ...extra]];
-}

package/dist/pool.d.ts

@@ -1,70 +0,0 @@
-import type { HarmonyApiClient } from "@gethmy/mcp/src/api-client.js";
-import type { Card, Column, Label, Subtask } from "@harmony/shared";
-import { PriorityQueue } from "./queue.js";
-import type { StateStore } from "./state-store.js";
-import { type AgentConfig, type WorkMode } from "./types.js";
-export declare class Pool {
-    private client;
-    private implWorkers;
-    private reviewWorkers;
-    private implQueue;
-    private reviewQueue;
-    private budget;
-    constructor(config: AgentConfig, client: HarmonyApiClient, userEmail: string, workspaceId: string, projectId: string, stateStore: StateStore);
-    /**
-     * Enqueue a card for processing with the given mode.
-     *
-     * Returns async so callers can await the DLQ side-effects on skip.
-     * Budget/DLQ checks happen here so the reconciler, realtime watcher,
-     * and manual API calls all go through the same gate.
-     */
-    enqueue(card: Card, column: Column, labels: Label[], subtasks: Subtask[], mode?: WorkMode): Promise<void>;
-    /**
-     * Best-effort waiting-state emit. Failures are swallowed because we don't
-     * want a board-API hiccup to drop the queue/budget event in pool.ts.
-     */
-    private emitWaiting;
-    /**
-     * Remove a card from any queue or cancel an active worker.
-     */
-    removeCard(cardId: string): Promise<void>;
-    /**
-     * Check if a card is currently being worked on by any worker.
-     */
-    isCardActive(cardId: string): boolean;
-    /**
-     * Check if a card is known to the pool (queued or active).
-     */
-    isCardKnown(cardId: string): boolean;
-    /**
-     * Get all card IDs that are either queued or active.
-     */
-    knownCardIds(): Set<string>;
-    /**
-     * Handle an agent command (pause/resume/stop) for a specific card.
-     */
-    handleAgentCommand(cardId: string, command: "pause" | "resume" | "stop"): Promise<void>;
-    /**
-     * Point-in-time snapshot for the HTTP /status endpoint. Safe to call
-     * from anywhere — reads in-memory state only.
-     */
-    snapshotWorkers(): Array<{
-        id: number;
-        pipeline: "implement" | "review";
-        state: string;
-        cardId: string | null;
-        cardShortId: number | null;
-        startedAt: number | null;
-        branchName: string | null;
-    }>;
-    snapshotQueues(): {
-        impl: ReturnType<PriorityQueue["snapshot"]>;
-        review: ReturnType<PriorityQueue["snapshot"]>;
-    };
-    /**
-     * Gracefully shutdown all workers.
-     */
-    shutdown(): Promise<void>;
-    private cardDataCache;
-    private tryDispatchFor;
-}