@gethmy/agent 1.7.1 → 1.7.3

package/dist/git-pr.js

@@ -1,399 +0,0 @@
-import { execFile, execFileSync } from "node:child_process";
-import { promisify } from "node:util";
-import { log } from "./log.js";
-const execFileAsync = promisify(execFile);
-const TAG = "git-pr";
-export function detectGitProvider(cwd) {
-    try {
-        const url = execFileSync("git", ["remote", "get-url", "origin"], {
-            cwd,
-            encoding: "utf-8",
-        }).trim();
-        if (url.includes("github.com"))
-            return "github";
-        if (url.includes("dev.azure.com") || url.includes("visualstudio.com"))
-            return "azure";
-        if (url.includes("gitlab.com") || /\bgitlab\b/.test(url))
-            return "gitlab";
-        if (url.includes("bitbucket.org"))
-            return "bitbucket";
-        return "unknown";
-    }
-    catch {
-        return "unknown";
-    }
-}
-/**
- * Validate that the CLI for the detected git provider is installed and authenticated.
- * Returns the provider name or throws with instructions.
- */
-export function validateGitProviderCli(provider, cwd) {
-    switch (provider) {
-        case "github": {
-            try {
-                execFileSync("gh", ["auth", "status"], { cwd, stdio: "pipe" });
-            }
-            catch {
-                throw new Error("GitHub CLI (gh) is not authenticated. Run: gh auth login");
-            }
-            break;
-        }
-        case "azure": {
-            try {
-                execFileSync("az", ["--version"], { cwd, stdio: "pipe" });
-            }
-            catch {
-                throw new Error("Azure CLI (az) not found. Install it: https://learn.microsoft.com/en-us/cli/azure/install-azure-cli");
-            }
-            try {
-                execFileSync("az", ["account", "show"], { cwd, stdio: "pipe" });
-            }
-            catch {
-                throw new Error("Azure CLI is not authenticated. Run: az login");
-            }
-            break;
-        }
-        case "gitlab": {
-            try {
-                execFileSync("glab", ["auth", "status"], { cwd, stdio: "pipe" });
-            }
-            catch {
-                throw new Error("GitLab CLI (glab) is not installed or not authenticated. Install: https://gitlab.com/gitlab-org/cli — then run: glab auth login");
-            }
-            break;
-        }
-        case "bitbucket":
-        case "unknown":
-            log.warn(TAG, `Git provider "${provider}" — PR creation will be skipped (no CLI support)`);
-            break;
-    }
-}
-const VALID_PR_URL_RE = /^https:\/\/(github\.com|gitlab\.com|dev\.azure\.com|bitbucket\.org)\//;
-const PR_URL_RE = /PR:\s*(https?:\/\/[^\s)]+)/;
-/** Validate that a PR URL looks like a real provider URL. */
-function isValidPrUrl(url) {
-    return VALID_PR_URL_RE.test(url);
-}
-/**
- * Check whether a PR has been merged using the git provider CLI (async).
- */
-export async function checkPrMergeStatus(prUrl, cwd, provider) {
-    if (!isValidPrUrl(prUrl))
-        return "unknown";
-    try {
-        switch (provider) {
-            case "github": {
-                const { stdout } = await execFileAsync("gh", ["pr", "view", prUrl, "--json", "state", "--jq", ".state"], { cwd, encoding: "utf-8", timeout: 10_000 });
-                switch (stdout.trim()) {
-                    case "MERGED":
-                        return "merged";
-                    case "OPEN":
-                        return "open";
-                    case "CLOSED":
-                        return "closed";
-                    default:
-                        return "unknown";
-                }
-            }
-            case "gitlab": {
-                // Extract MR ID from URL (e.g. .../merge_requests/42)
-                const mrMatch = prUrl.match(/merge_requests\/(\d+)/);
-                if (!mrMatch)
-                    return "unknown";
-                const { stdout } = await execFileAsync("glab", ["mr", "view", mrMatch[1], "--output", "json"], { cwd, encoding: "utf-8", timeout: 10_000 });
-                let parsed;
-                try {
-                    parsed = JSON.parse(stdout.trim());
-                }
-                catch {
-                    log.warn(TAG, `Failed to parse glab JSON output for MR ${mrMatch[1]}`);
-                    return "unknown";
-                }
-                if (typeof parsed !== "object" || parsed === null)
-                    return "unknown";
-                const state = parsed.state;
-                if (state === "merged")
-                    return "merged";
-                if (state === "opened")
-                    return "open";
-                if (state === "closed")
-                    return "closed";
-                return "unknown";
-            }
-            default:
-                return "unknown";
-        }
-    }
-    catch {
-        return "unknown";
-    }
-}
-/**
- * Extract a PR URL from card description. Matches the format written by completion.ts:
- * `PR: https://...`
- */
-export function extractPrUrl(description) {
-    if (!description)
-        return null;
-    const match = description.match(PR_URL_RE);
-    if (!match)
-        return null;
-    try {
-        return new URL(match[1]).href;
-    }
-    catch {
-        return null;
-    }
-}
-// ============ PUSH (REWORK-AWARE) ============
-export function remoteBranchExists(branchName, cwd) {
-    try {
-        execFileSync("git", ["ls-remote", "--exit-code", "origin", `refs/heads/${branchName}`], { cwd, stdio: "pipe" });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export function pushBranch(branchName, cwd) {
-    if (remoteBranchExists(branchName, cwd)) {
-        log.info(TAG, `Remote branch ${branchName} exists (rework), force-pushing`);
-        // Resolve the remote tip explicitly so the lease anchors to a known SHA.
-        // Bare `--force-with-lease` only checks against the local tracking ref,
-        // which can be stale if it was never fetched in this worktree — that
-        // lets a concurrent update slip through. Fetch + pin the expected SHA.
-        let expectedSha = null;
-        try {
-            execFileSync("git", ["fetch", "origin", branchName], {
-                cwd,
-                stdio: "pipe",
-            });
-            expectedSha = execFileSync("git", ["rev-parse", `refs/remotes/origin/${branchName}`], { cwd, encoding: "utf-8" }).trim();
-        }
-        catch (err) {
-            log.warn(TAG, `could not resolve remote tip for ${branchName}, falling back to weak lease: ${err instanceof Error ? err.message : err}`);
-        }
-        const lease = expectedSha
-            ? `--force-with-lease=refs/heads/${branchName}:${expectedSha}`
-            : "--force-with-lease";
-        execFileSync("git", ["push", lease, "-u", "origin", branchName], {
-            cwd,
-            stdio: "pipe",
-        });
-    }
-    else {
-        execFileSync("git", ["push", "-u", "origin", branchName], {
-            cwd,
-            stdio: "pipe",
-        });
-    }
-}
-/**
- * Push the current branch's tip to `newRef` on origin and delete `oldRef`.
- * Used when an approved attempt graduates from `agent-attempts/*` to
- * `agent/*` — keeps the commits durable across the rename and avoids any
- * window where the work is unreachable on origin.
- */
-export function renameRemoteBranch(oldRef, newRef, cwd) {
-    if (oldRef === newRef)
-        return;
-    let sha;
-    try {
-        sha = execFileSync("git", ["rev-parse", "HEAD"], {
-            cwd,
-            encoding: "utf-8",
-        }).trim();
-    }
-    catch (err) {
-        throw new Error(`renameRemoteBranch: could not resolve HEAD: ${err instanceof Error ? err.message : err}`);
-    }
-    log.info(TAG, `Renaming remote ${oldRef} → ${newRef}`);
-    execFileSync("git", ["push", "origin", `${sha}:refs/heads/${newRef}`, "--force-with-lease"], { cwd, stdio: "pipe" });
-    try {
-        execFileSync("git", ["push", "origin", `:refs/heads/${oldRef}`], {
-            cwd,
-            stdio: "pipe",
-        });
-    }
-    catch (err) {
-        log.warn(TAG, `renameRemoteBranch: could not delete old ref ${oldRef}: ${err instanceof Error ? err.message : err}`);
-    }
-    try {
-        execFileSync("git", ["branch", "-m", oldRef, newRef], {
-            cwd,
-            stdio: "pipe",
-        });
-    }
-    catch {
-        // Worktree may not have the old branch checked out — non-fatal.
-    }
-}
-/**
- * Best-effort public branch URL for the recovery button on a failed session.
- * Returns null when we can't infer a tree URL — the daemon falls back to a
- * plain `git fetch && git checkout <ref>` instruction in that case.
- */
-export function getBranchWebUrl(branchName, cwd) {
-    try {
-        const remoteUrl = execFileSync("git", ["remote", "get-url", "origin"], {
-            cwd,
-            encoding: "utf-8",
-        }).trim();
-        const encoded = branchName.split("/").map(encodeURIComponent).join("/");
-        if (/github\.com[:/]([^/]+)\/([^/.]+)/.test(remoteUrl)) {
-            const m = remoteUrl.match(/github\.com[:/]([^/]+)\/([^/.]+?)(?:\.git)?$/);
-            if (m)
-                return `https://github.com/${m[1]}/${m[2]}/tree/${encoded}`;
-        }
-        if (/gitlab\.com[:/]([^/]+)\/([^/.]+)/.test(remoteUrl)) {
-            const m = remoteUrl.match(/gitlab\.com[:/](.+?)(?:\.git)?$/);
-            if (m)
-                return `https://gitlab.com/${m[1]}/-/tree/${encoded}`;
-        }
-        if (/bitbucket\.org[:/]([^/]+)\/([^/.]+)/.test(remoteUrl)) {
-            const m = remoteUrl.match(/bitbucket\.org[:/](.+?)(?:\.git)?$/);
-            if (m)
-                return `https://bitbucket.org/${m[1]}/branch/${encoded}`;
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-// ============ PR CREATION (PROVIDER-AWARE) ============
-export function buildPrBody(card, commitLog) {
-    return [
-        "## Summary",
-        "",
-        `Automated PR for card **#${card.short_id} — ${card.title}**.`,
-        "",
-        "## Commits",
-        "",
-        "```",
-        commitLog,
-        "```",
-        "",
-        "## Card",
-        "",
-        card.description?.slice(0, 500) || "No description.",
-        "",
-        "---",
-        "*Created by Harmony Agent Daemon*",
-    ].join("\n");
-}
-export function createPullRequest(card, branchName, worktreePath, config, provider) {
-    let commitLog = "";
-    try {
-        commitLog = execFileSync("git", ["log", "--oneline", `origin/${config.worktree.baseBranch}..HEAD`], { cwd: worktreePath, encoding: "utf-8" }).trim();
-    }
-    catch {
-        commitLog = "(unable to retrieve commit log)";
-    }
-    const title = `#${card.short_id} ${card.title}`;
-    const body = buildPrBody(card, commitLog);
-    const base = config.worktree.baseBranch;
-    // Check for existing PR first (rework case)
-    const existingUrl = findExistingPr(branchName, worktreePath, provider);
-    if (existingUrl) {
-        log.info(TAG, `PR already exists for ${branchName}, updating body...`);
-        updateExistingPr(branchName, body, worktreePath, provider);
-        return existingUrl;
-    }
-    // No existing PR — create a new one
-    try {
-        let result;
-        switch (provider) {
-            case "github":
-                result = execFileSync("gh", ["pr", "create", "--title", title, "--body", body, "--base", base], { cwd: worktreePath, encoding: "utf-8" }).trim();
-                break;
-            case "azure": {
-                const azOutput = execFileSync("az", [
-                    "repos",
-                    "pr",
-                    "create",
-                    "--title",
-                    title,
-                    "--description",
-                    body,
-                    "--source-branch",
-                    branchName,
-                    "--target-branch",
-                    base,
-                    "--auto-complete",
-                    "false",
-                ], { cwd: worktreePath, encoding: "utf-8" }).trim();
-                // az repos pr create returns JSON — extract the URL
-                try {
-                    const parsed = JSON.parse(azOutput);
-                    result = parsed.remoteUrl ?? parsed.url ?? azOutput;
-                }
-                catch {
-                    result = azOutput;
-                }
-                break;
-            }
-            case "gitlab":
-                result = execFileSync("glab", [
-                    "mr",
-                    "create",
-                    "--title",
-                    title,
-                    "--description",
-                    body,
-                    "--source-branch",
-                    branchName,
-                    "--target-branch",
-                    base,
-                    "--no-editor",
-                ], { cwd: worktreePath, encoding: "utf-8" }).trim();
-                break;
-            default:
-                log.warn(TAG, `No PR CLI for provider "${provider}" — branch pushed but no PR created`);
-                return null;
-        }
-        log.info(TAG, `PR created: ${result}`);
-        return result;
-    }
-    catch (err) {
-        log.error(TAG, `Failed to create PR: ${err instanceof Error ? err.message : err}`);
-        return null;
-    }
-}
-export function findExistingPr(branchName, worktreePath, provider) {
-    try {
-        switch (provider) {
-            case "github":
-                return execFileSync("gh", ["pr", "view", branchName, "--json", "url", "--jq", ".url"], { cwd: worktreePath, encoding: "utf-8" }).trim();
-            case "gitlab": {
-                const json = execFileSync("glab", ["mr", "view", branchName, "--output", "json"], { cwd: worktreePath, encoding: "utf-8" }).trim();
-                const parsed = JSON.parse(json);
-                return parsed.web_url || null;
-            }
-            default:
-                return null;
-        }
-    }
-    catch {
-        return null;
-    }
-}
-export function updateExistingPr(branchName, body, worktreePath, provider) {
-    try {
-        switch (provider) {
-            case "github":
-                execFileSync("gh", ["pr", "edit", branchName, "--body", body], {
-                    cwd: worktreePath,
-                    stdio: "pipe",
-                });
-                break;
-            case "gitlab":
-                execFileSync("glab", ["mr", "update", branchName, "--description", body], { cwd: worktreePath, stdio: "pipe" });
-                break;
-        }
-        log.info(TAG, `Updated existing PR body for ${branchName}`);
-    }
-    catch (err) {
-        log.warn(TAG, `Failed to update PR body: ${err instanceof Error ? err.message : err}`);
-    }
-}

package/dist/http-server.d.ts

@@ -1,66 +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;
-    }>;
-    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>;
-}
-/**
- * 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, 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 respondHealth;
-    private respondStatus;
-    private respondCommand;
-}

package/dist/http-server.js

@@ -1,96 +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, 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 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 }));
-    }
-    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;