@gethmy/agent 1.7.1 → 1.7.2

package/dist/pool.js

@@ -1,259 +0,0 @@
-import { BudgetGuard } from "./budget.js";
-import { log } from "./log.js";
-import { PriorityQueue } from "./queue.js";
-import { ReviewWorker } from "./review-worker.js";
-import { AGENT_NAME, agentIdentifier, } from "./types.js";
-import { Worker } from "./worker.js";
-const TAG = "pool";
-export class Pool {
-    client;
-    stateStore;
-    implWorkers = [];
-    reviewWorkers = [];
-    implQueue;
-    reviewQueue;
-    budget;
-    constructor(config, client, userEmail, workspaceId, projectId, stateStore) {
-        this.client = client;
-        this.stateStore = stateStore;
-        this.implQueue = new PriorityQueue(config);
-        this.reviewQueue = new PriorityQueue(config);
-        this.budget = new BudgetGuard(config.budget, this.stateStore);
-        // 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");
-            }, workspaceId, projectId, stateStore));
-        }
-        // Create review workers. IDs offset by `config.poolSize` so impl and
-        // review worker IDs never collide (verification + review ports both
-        // derive from the worker ID, so collision would mean port collision).
-        if (config.review.enabled) {
-            for (let i = 0; i < config.review.poolSize; i++) {
-                const reviewWorkerId = config.poolSize + i;
-                this.reviewWorkers.push(new ReviewWorker(reviewWorkerId, config, client, userEmail, () => {
-                    this.tryDispatchFor(this.reviewWorkers, this.reviewQueue, "review");
-                }, stateStore, workspaceId, projectId));
-            }
-        }
-    }
-    /**
-     * Enqueue a card for processing with the given mode.
-     *
-     * Returns async so callers can await the give-up comment / waiting
-     * signal on skip. Budget checks happen here so the reconciler, realtime
-     * watcher, and manual API calls all go through the same gate.
-     */
-    async 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;
-        }
-        // Review pickups bypass per-card attempt limits (reviews are cheap
-        // and orthogonal to implement attempts). Daily budget still applies.
-        if (mode === "implement") {
-            const decision = this.budget.check(card.id);
-            if (!decision.allow) {
-                if (decision.reason === "daily_budget") {
-                    // Soft pause — surface as `waiting` so the board signals that
-                    // the daemon will pick this card up after the budget resets.
-                    log.warn(TAG, `#${card.short_id} skipped (daily_budget): ${decision.detail}`);
-                    await this.emitWaiting(card.id, `Daily budget reached — waiting for reset (${decision.detail})`);
-                }
-                else {
-                    // max_attempts: the daemon has given up on this card. The worker
-                    // already posted the one-shot give-up comment at the crossing, so
-                    // every later reconcile tick is expected noise — stay quiet until
-                    // the card is reassigned (which resets the attempt counter).
-                    log.debug(TAG, `#${card.short_id} gave up: ${decision.detail}`);
-                }
-                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;
-        const dispatched = this.tryDispatchFor(workers, queue, mode);
-        if (!dispatched) {
-            // No idle worker — the card will wait in the queue. Surface the
-            // queue position so the board ribbon shows the user something is
-            // happening even though no worker has the card yet.
-            const position = queue.cardIds().indexOf(card.id) + 1;
-            const total = queue.length;
-            await this.emitWaiting(card.id, position > 0
-                ? `Queued (${position}/${total}) — waiting for ${mode} worker`
-                : `Queued — waiting for ${mode} worker`);
-        }
-    }
-    /**
-     * 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.
-     */
-    async emitWaiting(cardId, currentTask) {
-        try {
-            await this.client.updateAgentProgress(cardId, {
-                agentIdentifier: agentIdentifier(0),
-                agentName: AGENT_NAME,
-                status: "waiting",
-                currentTask,
-            });
-        }
-        catch (err) {
-            log.debug(TAG, `waiting emit failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
-        }
-    }
-    /**
-     * Remove a card from any queue or cancel an active worker.
-     */
-    async removeCard(cardId) {
-        // Unassigning is the human's "try again" signal — clear any exhausted
-        // attempt counter so a reassign starts the card fresh (no DLQ to clear).
-        await this.stateStore.resetAttempts(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;
-    }
-    /**
-     * Handle an agent command (pause/resume/stop) for a specific card.
-     */
-    async handleAgentCommand(cardId, command) {
-        const worker = this.implWorkers.find((w) => w.cardId === cardId && w.isActive) ??
-            this.reviewWorkers.find((w) => w.cardId === cardId && w.isActive);
-        if (!worker) {
-            log.debug(TAG, `No active worker for card ${cardId}, ignoring ${command}`);
-            return;
-        }
-        log.info(TAG, `Agent command: ${command} → worker ${worker.id} (card ${cardId})`);
-        switch (command) {
-            case "pause":
-                await worker.pause();
-                break;
-            case "resume":
-                await worker.resume();
-                break;
-            case "stop":
-                await worker.cancel();
-                break;
-        }
-    }
-    /**
-     * Point-in-time snapshot for the HTTP /status endpoint. Safe to call
-     * from anywhere — reads in-memory state only.
-     */
-    snapshotWorkers() {
-        const out = [];
-        for (const w of this.implWorkers) {
-            out.push({
-                id: w.id,
-                pipeline: "implement",
-                state: w.state,
-                cardId: w.cardId,
-                cardShortId: null,
-                startedAt: w.startedAt,
-                branchName: w.branchName,
-            });
-        }
-        for (const w of this.reviewWorkers) {
-            out.push({
-                id: w.id,
-                pipeline: "review",
-                state: w.state,
-                cardId: w.cardId,
-                cardShortId: null,
-                startedAt: w.startedAt,
-                branchName: w.branchName,
-            });
-        }
-        return out;
-    }
-    snapshotQueues() {
-        return {
-            impl: this.implQueue.snapshot(),
-            review: this.reviewQueue.snapshot(),
-        };
-    }
-    /**
-     * 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 false;
-        }
-        const next = queue.dequeue();
-        if (!next)
-            return false;
-        const data = this.cardDataCache.get(next.cardId);
-        if (!data) {
-            log.warn(TAG, `No cached data for card ${next.cardId}, skipping`);
-            return false;
-        }
-        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);
-        return true;
-    }
-}

package/dist/process-group.d.ts

@@ -1,26 +0,0 @@
-import { type ChildProcess, type SpawnOptions } from "node:child_process";
-/**
- * Spawn a child in its own process group so we can reliably kill the
- * whole subtree later. The Claude CLI shells out to git, build tools,
- * dev servers, etc. — signalling only the direct child leaves orphans.
- *
- * - POSIX: `detached: true` puts the child in a new process group whose
- *   pgid equals its pid. Killing the negative pid signals every member.
- * - Windows: `detached: true` creates a new process group that can be
- *   signalled via the child's pid (no negation).
- */
-export declare function spawnInGroup(command: string, args: readonly string[], options?: SpawnOptions): ChildProcess;
-/**
- * Send a signal to every process in the group whose leader is `proc`.
- * On POSIX, this is `process.kill(-pid, signal)`. If the group has
- * already exited, returns silently.
- */
-export declare function signalGroup(proc: ChildProcess, signal: NodeJS.Signals): void;
-/**
- * Escalating termination: SIGINT → wait → SIGTERM → wait → SIGKILL.
- * Returns when the process has exited or all signals have been sent.
- */
-export declare function terminateGroup(proc: ChildProcess, opts: {
-    sigintTimeoutMs: number;
-    sigtermTimeoutMs: number;
-}): Promise<void>;

package/dist/process-group.js

@@ -1,72 +0,0 @@
-import { spawn, } from "node:child_process";
-import { log } from "./log.js";
-const TAG = "pgroup";
-/**
- * Spawn a child in its own process group so we can reliably kill the
- * whole subtree later. The Claude CLI shells out to git, build tools,
- * dev servers, etc. — signalling only the direct child leaves orphans.
- *
- * - POSIX: `detached: true` puts the child in a new process group whose
- *   pgid equals its pid. Killing the negative pid signals every member.
- * - Windows: `detached: true` creates a new process group that can be
- *   signalled via the child's pid (no negation).
- */
-export function spawnInGroup(command, args, options = {}) {
-    return spawn(command, args, {
-        ...options,
-        detached: true,
-        // Keep stdio wired up so streaming still works.
-        stdio: options.stdio ?? ["ignore", "pipe", "pipe"],
-    });
-}
-/**
- * Send a signal to every process in the group whose leader is `proc`.
- * On POSIX, this is `process.kill(-pid, signal)`. If the group has
- * already exited, returns silently.
- */
-export function signalGroup(proc, signal) {
-    if (!proc.pid || proc.killed)
-        return;
-    try {
-        if (process.platform === "win32") {
-            // No process groups on Windows; best effort tree kill via the child.
-            proc.kill(signal);
-            return;
-        }
-        process.kill(-proc.pid, signal);
-    }
-    catch (err) {
-        // ESRCH means the group is already gone — that is the goal, not an error.
-        const code = err.code;
-        if (code !== "ESRCH") {
-            log.warn(TAG, `signal ${signal} to pgid ${proc.pid} failed: ${err instanceof Error ? err.message : err}`);
-        }
-    }
-}
-/**
- * Escalating termination: SIGINT → wait → SIGTERM → wait → SIGKILL.
- * Returns when the process has exited or all signals have been sent.
- */
-export async function terminateGroup(proc, opts) {
-    if (!proc.pid || proc.killed)
-        return;
-    // Unpause first in case the process was suspended — otherwise it
-    // can't react to signals.
-    signalGroup(proc, "SIGCONT");
-    const waitForExit = (timeout) => new Promise((resolve) => {
-        if (proc.killed || proc.exitCode !== null)
-            return resolve(true);
-        const timer = setTimeout(() => resolve(false), timeout);
-        proc.once("exit", () => {
-            clearTimeout(timer);
-            resolve(true);
-        });
-    });
-    signalGroup(proc, "SIGINT");
-    if (await waitForExit(opts.sigintTimeoutMs))
-        return;
-    signalGroup(proc, "SIGTERM");
-    if (await waitForExit(opts.sigtermTimeoutMs))
-        return;
-    signalGroup(proc, "SIGKILL");
-}

package/dist/progress-tracker.d.ts

@@ -1,82 +0,0 @@
-import type { HarmonyApiClient } from "@gethmy/mcp/src/api-client.js";
-import type { CostUpdate, StreamParser } from "./stream-parser.js";
-export interface ActivityLogEntry {
-    phase: string | null;
-    eventType: "tool_start" | "tool_end" | "phase_change" | "error" | "summary";
-    toolName: string | null;
-    description: string;
-    metadata: Record<string, unknown>;
-    createdAt: string;
-}
-export declare class ProgressTracker {
-    private client;
-    private cardId;
-    private workerId;
-    private phase;
-    private progress;
-    private toolCallCount;
-    private hasEdited;
-    private lastUpdateAt;
-    private pendingUpdate;
-    private pendingTask;
-    private heartbeatTimer;
-    private stopped;
-    private lastAction;
-    private subtaskTotal;
-    private subtaskCompleted;
-    private subtaskMode;
-    private filesEdited;
-    private filesRead;
-    private lastCost;
-    private logBuffer;
-    private sessionId;
-    private lastAssistantText;
-    private assistantTextBlocks;
-    constructor(client: HarmonyApiClient, cardId: string, workerId: number, subtasks: {
-        completed: boolean;
-    }[]);
-    setSessionId(id: string): void;
-    /**
-     * Wire up the parser events and start the heartbeat.
-     */
-    attach(parser: StreamParser): void;
-    /**
-     * Stop all timers and flush any pending update.
-     */
-    stop(): void;
-    /** Get a summary of the session stats. */
-    get stats(): {
-        filesEdited: number;
-        filesEditedPaths: string[];
-        filesRead: number;
-        toolCalls: number;
-        cost: CostUpdate | null;
-        lastAssistantText: string;
-        assistantTextBlocks: string[];
-    };
-    private onToolStart;
-    private onToolEnd;
-    private onText;
-    private transitionTo;
-    private incrementProgress;
-    private currentTaskLabel;
-    /**
-     * Build a human-readable description of what a tool call is doing.
-     */
-    private describeToolAction;
-    /**
-     * Strip absolute paths to show only meaningful segments from src/ or packages/.
-     */
-    private shortPath;
-    private scheduleUpdate;
-    private sendUpdate;
-    private startHeartbeat;
-    flushFinal(): void;
-    private pushLogEntry;
-    private flushActivityLog;
-    private extractToolMetadata;
-    /**
-     * Safely extract a string property from an unknown tool input.
-     */
-    private extractString;
-}