@gethmy/agent 1.0.0 → 1.0.1

package/dist/log.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Structured logging for the agent daemon.
+ * Always logs to stderr so stdout stays clean for potential piping.
+ */
+export declare const log: {
+    info(tag: string, msg: string): void;
+    warn(tag: string, msg: string): void;
+    error(tag: string, msg: string): void;
+    debug(tag: string, msg: string): void;
+};

package/dist/log.js

@@ -0,0 +1,35 @@
+/**
+ * Structured logging for the agent daemon.
+ * Always logs to stderr so stdout stays clean for potential piping.
+ */
+const COLORS = {
+    reset: "\x1b[0m",
+    dim: "\x1b[2m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    cyan: "\x1b[36m",
+};
+function timestamp() {
+    return new Date().toISOString().slice(11, 23);
+}
+function fmt(level, color, tag, msg) {
+    return `${COLORS.dim}${timestamp()}${COLORS.reset} ${color}${level}${COLORS.reset} ${COLORS.cyan}[${tag}]${COLORS.reset} ${msg}`;
+}
+export const log = {
+    info(tag, msg) {
+        console.error(fmt("INFO ", COLORS.green, tag, msg));
+    },
+    warn(tag, msg) {
+        console.error(fmt("WARN ", COLORS.yellow, tag, msg));
+    },
+    error(tag, msg) {
+        console.error(fmt("ERROR", COLORS.red, tag, msg));
+    },
+    debug(tag, msg) {
+        if (process.env.DEBUG) {
+            console.error(fmt("DEBUG", COLORS.dim, tag, msg));
+        }
+    },
+};

package/dist/merge-monitor.d.ts

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,155 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { addLabelByName, hasApprovedLabel, moveCardToColumn, } 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;
+        log.info(TAG, `Merge monitor every ${this.intervalMs / 1000}s`);
+        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);
+            const cards = (board.cards ?? []);
+            const columns = (board.columns ?? []);
+            // 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));
+            // Filter cards in review columns that have the "Ready to Merge" label
+            const approvedLabel = this.config.review.approvedLabel;
+            const candidates = cards.filter((c) => !c.archived_at &&
+                reviewColumnIds.has(c.column_id) &&
+                hasApprovedLabel((c.labels ?? []), approvedLabel));
+            if (candidates.length === 0) {
+                log.debug(TAG, "No Ready to Merge cards found");
+                return;
+            }
+            // Process max 5 per tick to respect rate limits
+            const batch = candidates.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) => {
+                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);
+                }
+                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) {
+        // 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 cardLabels = (card.labels ?? []);
+        const approvedLabelObj = cardLabels.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)
+        const existing = card.description || "";
+        if (!existing.includes("Merged at")) {
+            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 description: ${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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,36 @@
+import type { HarmonyApiClient } from "@gethmy/mcp/src/api-client.js";
+import type { Card, Column, Label, Subtask } from "@harmony/shared";
+import type { AgentConfig, WorkMode } from "./types.js";
+export declare class Pool {
+    private implWorkers;
+    private reviewWorkers;
+    private implQueue;
+    private reviewQueue;
+    constructor(config: AgentConfig, client: HarmonyApiClient, userEmail: string);
+    /**
+     * Enqueue a card for processing with the given mode.
+     */
+    enqueue(card: Card, column: Column, labels: Label[], subtasks: Subtask[], mode?: WorkMode): void;
+    /**
+     * 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>;
+    /**
+     * Gracefully shutdown all workers.
+     */
+    shutdown(): Promise<void>;
+    private cardDataCache;
+    private tryDispatchFor;
+}

package/dist/pool.js

@@ -0,0 +1,134 @@
+import { log } from "./log.js";
+import { PriorityQueue } from "./queue.js";
+import { ReviewWorker } from "./review-worker.js";
+import { Worker } from "./worker.js";
+const TAG = "pool";
+export class Pool {
+    implWorkers = [];
+    reviewWorkers = [];
+    implQueue;
+    reviewQueue;
+    constructor(config, client, userEmail) {
+        this.implQueue = new PriorityQueue(config);
+        this.reviewQueue = new PriorityQueue(config);
+        // Create implementation workers
+        for (let i = 0; i < config.poolSize; i++) {
+            this.implWorkers.push(new Worker(i, config, client, userEmail, () => {
+                this.tryDispatchFor(this.implWorkers, this.implQueue, "impl");
+            }));
+        }
+        // Create review worker(s) — 1 review worker per pool
+        if (config.review.enabled) {
+            const reviewWorkerId = config.poolSize; // offset to avoid ID collision
+            this.reviewWorkers.push(new ReviewWorker(reviewWorkerId, config, client, userEmail, () => {
+                this.tryDispatchFor(this.reviewWorkers, this.reviewQueue, "review");
+            }));
+        }
+        const reviewCount = this.reviewWorkers.length;
+        log.info(TAG, `Pool initialized: ${config.poolSize} impl worker(s), ${reviewCount} review worker(s)`);
+    }
+    /**
+     * Enqueue a card for processing with the given mode.
+     */
+    enqueue(card, column, labels, subtasks, mode = "implement") {
+        // Don't enqueue if already in any queue or actively being worked on
+        if (this.implQueue.has(card.id) ||
+            this.reviewQueue.has(card.id) ||
+            this.isCardActive(card.id)) {
+            log.debug(TAG, `Card ${card.id} already queued or active, skipping`);
+            return;
+        }
+        const queue = mode === "review" ? this.reviewQueue : this.implQueue;
+        queue.enqueue(card, column, labels, mode);
+        // Store card data for when it gets dispatched
+        this.cardDataCache.set(card.id, { card, column, labels, subtasks, mode });
+        const workers = mode === "review" ? this.reviewWorkers : this.implWorkers;
+        this.tryDispatchFor(workers, queue, mode);
+    }
+    /**
+     * Remove a card from any queue or cancel an active worker.
+     */
+    async removeCard(cardId) {
+        // Try both queues
+        for (const queue of [this.implQueue, this.reviewQueue]) {
+            const removed = queue.remove(cardId);
+            if (removed) {
+                this.cardDataCache.delete(cardId);
+                log.info(TAG, `Removed #${removed.shortId} from ${removed.mode} queue`);
+                return;
+            }
+        }
+        // Cancel active worker (check impl first, then review)
+        const worker = this.implWorkers.find((w) => w.cardId === cardId) ??
+            this.reviewWorkers.find((w) => w.cardId === cardId);
+        if (worker) {
+            log.info(TAG, `Cancelling worker ${worker.id} for card ${cardId}`);
+            await worker.cancel();
+        }
+    }
+    /**
+     * Check if a card is currently being worked on by any worker.
+     */
+    isCardActive(cardId) {
+        return (this.implWorkers.some((w) => w.cardId === cardId && w.isActive) ||
+            this.reviewWorkers.some((w) => w.cardId === cardId && w.isActive));
+    }
+    /**
+     * Check if a card is known to the pool (queued or active).
+     */
+    isCardKnown(cardId) {
+        return (this.implQueue.has(cardId) ||
+            this.reviewQueue.has(cardId) ||
+            this.isCardActive(cardId));
+    }
+    /**
+     * Get all card IDs that are either queued or active.
+     */
+    knownCardIds() {
+        const ids = new Set([
+            ...this.implQueue.cardIds(),
+            ...this.reviewQueue.cardIds(),
+        ]);
+        for (const w of this.implWorkers) {
+            if (w.cardId)
+                ids.add(w.cardId);
+        }
+        for (const w of this.reviewWorkers) {
+            if (w.cardId)
+                ids.add(w.cardId);
+        }
+        return ids;
+    }
+    /**
+     * Gracefully shutdown all workers.
+     */
+    async shutdown() {
+        log.info(TAG, "Shutting down pool...");
+        const active = [
+            ...this.implWorkers.filter((w) => w.isActive),
+            ...this.reviewWorkers.filter((w) => w.isActive),
+        ];
+        await Promise.all(active.map((w) => w.cancel()));
+        log.info(TAG, "Pool shutdown complete");
+    }
+    // --- Private ---
+    cardDataCache = new Map();
+    tryDispatchFor(workers, queue, label) {
+        const idle = workers.find((w) => w.isIdle);
+        if (!idle) {
+            log.debug(TAG, `No idle ${label} workers (queue: ${queue.length})`);
+            return;
+        }
+        const next = queue.dequeue();
+        if (!next)
+            return;
+        const data = this.cardDataCache.get(next.cardId);
+        if (!data) {
+            log.warn(TAG, `No cached data for card ${next.cardId}, skipping`);
+            return;
+        }
+        this.cardDataCache.delete(next.cardId);
+        log.info(TAG, `Dispatching #${next.shortId} to ${label} worker ${idle.id}`);
+        idle.run(data.card, data.column, data.labels, data.subtasks);
+    }
+}

package/dist/progress-tracker.d.ts

@@ -0,0 +1,39 @@
+import type { HarmonyApiClient } from "@gethmy/mcp/src/api-client.js";
+import type { StreamParser } from "./stream-parser.js";
+export declare class ProgressTracker {
+    private client;
+    private cardId;
+    private workerId;
+    private phase;
+    private progress;
+    private toolCallCount;
+    private hasEdited;
+    private lastUpdateAt;
+    private pendingUpdate;
+    private heartbeatTimer;
+    private stopped;
+    private subtaskTotal;
+    private subtaskCompleted;
+    private subtaskMode;
+    constructor(client: HarmonyApiClient, cardId: string, workerId: number, subtasks: {
+        completed: boolean;
+    }[]);
+    /**
+     * Wire up the parser events and start the heartbeat.
+     */
+    attach(parser: StreamParser): void;
+    /**
+     * Stop all timers and flush any pending update.
+     */
+    stop(): void;
+    private onToolStart;
+    private onToolEnd;
+    private transitionTo;
+    private incrementProgress;
+    private currentTaskLabel;
+    private scheduleUpdate;
+    private sendUpdate;
+    private startHeartbeat;
+    private phaseOrder;
+    private extractBashCommand;
+}