@gethmy/agent 1.0.0 → 1.0.1

package/dist/completion.d.ts

@@ -0,0 +1,7 @@
+import type { HarmonyApiClient } from "@gethmy/mcp/src/api-client.js";
+import type { Card } from "@harmony/shared";
+import { type AgentConfig } from "./types.js";
+/**
+ * Post-work pipeline: push branch, create PR, move card, post summary.
+ */
+export declare function runCompletion(client: HarmonyApiClient, card: Card, branchName: string, worktreePath: string, config: AgentConfig, workerId?: number): Promise<void>;

package/dist/completion.js

@@ -0,0 +1,132 @@
+import { execFileSync } from "node:child_process";
+import { moveCardToColumn } from "./board-helpers.js";
+import { createPullRequest, detectGitProvider, pushBranch } from "./git-pr.js";
+import { log } from "./log.js";
+import { AGENT_NAME, agentIdentifier } from "./types.js";
+import { attemptAutoFix, reportFindings, runVerification, } from "./verification.js";
+import { cleanupWorktree } from "./worktree.js";
+const TAG = "completion";
+// ============ COMPLETION PIPELINE ============
+/**
+ * Post-work pipeline: push branch, create PR, move card, post summary.
+ */
+export async function runCompletion(client, card, branchName, worktreePath, config, workerId = 0) {
+    // Check if there are any commits on the branch
+    const hasCommits = checkHasCommits(worktreePath, config.worktree.baseBranch);
+    if (!hasCommits) {
+        log.warn(TAG, `No commits on branch ${branchName} — skipping completion`);
+        await client.endAgentSession(card.id, {
+            status: "completed",
+            progressPercent: 100,
+        });
+        cleanupWorktree(worktreePath, branchName);
+        return;
+    }
+    // 1. Verification gate
+    if (config.verification.enabled) {
+        await client.updateAgentProgress(card.id, {
+            agentIdentifier: agentIdentifier(workerId),
+            agentName: AGENT_NAME,
+            status: "working",
+            currentTask: "Verifying build...",
+            progressPercent: 80,
+        });
+        let result = await runVerification(worktreePath, config, workerId);
+        if (!result.passed && config.verification.autoFix) {
+            for (let attempt = 0; attempt < config.verification.maxFixAttempts; attempt++) {
+                log.info(TAG, `Auto-fix attempt ${attempt + 1}/${config.verification.maxFixAttempts}`);
+                await client.updateAgentProgress(card.id, {
+                    agentIdentifier: agentIdentifier(workerId),
+                    agentName: AGENT_NAME,
+                    status: "working",
+                    currentTask: `Fixing issues (attempt ${attempt + 1})...`,
+                    progressPercent: 85,
+                });
+                const allErrors = [...result.buildErrors, ...result.lintWarnings];
+                await attemptAutoFix(worktreePath, config, allErrors);
+                result = await runVerification(worktreePath, config, workerId);
+                if (result.passed) {
+                    log.info(TAG, `Auto-fix succeeded on attempt ${attempt + 1}`);
+                    break;
+                }
+            }
+        }
+        if (!result.passed) {
+            log.warn(TAG, `Verification failed for #${card.short_id} — reporting findings`);
+            await reportFindings(client, card.id, result);
+            await moveCardToColumn(client, card, config.verification.failColumn);
+            await client.endAgentSession(card.id, { status: "paused" });
+            cleanupWorktree(worktreePath, branchName);
+            return;
+        }
+        log.info(TAG, `Verification passed for #${card.short_id}`);
+    }
+    // 2. Push branch (force-push on rework if remote branch already exists)
+    log.info(TAG, `Pushing branch ${branchName}...`);
+    pushBranch(branchName, worktreePath);
+    // 3. Create PR
+    let prUrl = null;
+    if (config.completion.createPR) {
+        const provider = detectGitProvider(worktreePath);
+        prUrl = createPullRequest(card, branchName, worktreePath, config, provider);
+    }
+    // 4. Move card to Review column
+    if (config.completion.moveToColumn) {
+        await moveCardToColumn(client, card, config.completion.moveToColumn);
+    }
+    // 5. Post summary — always includes branch, optionally PR link
+    if (config.completion.postSummary) {
+        await postSummary(client, card, branchName, worktreePath, prUrl, config.worktree.baseBranch);
+    }
+    // 6. End agent session
+    await client.endAgentSession(card.id, {
+        status: "completed",
+        progressPercent: 100,
+    });
+    // 7. Cleanup worktree
+    cleanupWorktree(worktreePath, branchName);
+    log.info(TAG, `Completion done for #${card.short_id}${prUrl ? ` — PR: ${prUrl}` : ""}`);
+}
+function checkHasCommits(worktreePath, baseBranch) {
+    try {
+        const count = execFileSync("git", ["rev-list", "--count", `origin/${baseBranch}..HEAD`], { cwd: worktreePath, encoding: "utf-8" }).trim();
+        return parseInt(count, 10) > 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function postSummary(client, card, branchName, worktreePath, prUrl, baseBranch) {
+    // Build commit summary
+    let commitLog = "";
+    try {
+        commitLog = execFileSync("git", ["log", "--oneline", `origin/${baseBranch}..HEAD`], { cwd: worktreePath, encoding: "utf-8" }).trim();
+    }
+    catch {
+        // best-effort
+    }
+    // Build description note
+    const SUMMARY_MARKER = "---\n**Agent completed**";
+    const parts = [`\n\n${SUMMARY_MARKER}`];
+    if (prUrl) {
+        parts.push(`PR: ${prUrl}`);
+    }
+    parts.push(`Branch: \`${branchName}\``);
+    if (commitLog) {
+        parts.push(`\n\`\`\`\n${commitLog}\n\`\`\``);
+    }
+    try {
+        // Strip any previous agent summary block before appending (rework)
+        const existingDesc = card.description || "";
+        const baseDesc = existingDesc.includes(SUMMARY_MARKER)
+            ? existingDesc.slice(0, existingDesc.indexOf(SUMMARY_MARKER)).trimEnd()
+            : existingDesc;
+        await client.updateCard(card.id, {
+            description: baseDesc + parts.join("\n"),
+        });
+        log.info(TAG, `Posted completion summary to #${card.short_id}`);
+    }
+    catch (err) {
+        log.error(TAG, `Failed to post summary: ${err instanceof Error ? err.message : err}`);
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,23 @@
+import { HarmonyApiClient } from "@gethmy/mcp/src/api-client.js";
+import type { AgentConfig, RealtimeCredentials } from "./types.js";
+export interface DaemonConfig {
+    apiKey: string;
+    apiUrl: string;
+    workspaceId: string;
+    projectId: string;
+    userEmail: string;
+    agent: AgentConfig;
+}
+/**
+ * Load daemon configuration from ~/.harmony-mcp/config.json,
+ * merging default agent settings with any user overrides.
+ */
+export declare function loadDaemonConfig(): DaemonConfig;
+/**
+ * Fetch Supabase realtime credentials from the Harmony API.
+ */
+export declare function fetchRealtimeCredentials(client: HarmonyApiClient): Promise<RealtimeCredentials>;
+/**
+ * Create an API client from daemon config.
+ */
+export declare function createApiClient(config: DaemonConfig): HarmonyApiClient;

package/dist/config.js

@@ -0,0 +1,91 @@
+import { execSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { HarmonyApiClient } from "@gethmy/mcp/src/api-client.js";
+import { getActiveProjectId, getActiveWorkspaceId, getApiKey, getApiUrl, getUserEmail, } from "@gethmy/mcp/src/config.js";
+import { DEFAULT_AGENT_CONFIG } from "./types.js";
+/**
+ * Resolve the git repo root so local config lookup always
+ * finds .harmony-mcp.json regardless of cwd.
+ */
+function getRepoRoot() {
+    return execSync("git rev-parse --show-toplevel", {
+        encoding: "utf-8",
+    }).trim();
+}
+/**
+ * Load daemon configuration from ~/.harmony-mcp/config.json,
+ * merging default agent settings with any user overrides.
+ */
+export function loadDaemonConfig() {
+    const repoRoot = getRepoRoot();
+    const apiKey = getApiKey();
+    const apiUrl = getApiUrl();
+    const workspaceId = getActiveWorkspaceId(repoRoot);
+    const projectId = getActiveProjectId(repoRoot);
+    const userEmail = getUserEmail();
+    if (!workspaceId) {
+        throw new Error("No active workspace configured. Run `npx @gethmy/mcp setup` first.");
+    }
+    if (!projectId) {
+        throw new Error("No active project configured. Run `npx @gethmy/mcp setup` first.");
+    }
+    if (!userEmail) {
+        throw new Error("No user email configured. Run `npx @gethmy/mcp setup` first.");
+    }
+    // Try to load agent-specific overrides from config file
+    let agentOverrides = {};
+    try {
+        const configPath = join(homedir(), ".harmony-mcp", "config.json");
+        const raw = readFileSync(configPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed.agent) {
+            agentOverrides = parsed.agent;
+        }
+    }
+    catch {
+        // No overrides, use defaults
+    }
+    const agent = {
+        ...DEFAULT_AGENT_CONFIG,
+        ...agentOverrides,
+        completion: {
+            ...DEFAULT_AGENT_CONFIG.completion,
+            ...(agentOverrides.completion ?? {}),
+        },
+        claude: {
+            ...DEFAULT_AGENT_CONFIG.claude,
+            ...(agentOverrides.claude ?? {}),
+        },
+        worktree: {
+            ...DEFAULT_AGENT_CONFIG.worktree,
+            ...(agentOverrides.worktree ?? {}),
+        },
+        verification: {
+            ...DEFAULT_AGENT_CONFIG.verification,
+            ...(agentOverrides.verification ?? {}),
+        },
+        review: {
+            ...DEFAULT_AGENT_CONFIG.review,
+            ...(agentOverrides.review ?? {}),
+        },
+    };
+    return { apiKey, apiUrl, workspaceId, projectId, userEmail, agent };
+}
+/**
+ * Fetch Supabase realtime credentials from the Harmony API.
+ */
+export async function fetchRealtimeCredentials(client) {
+    const result = (await client.request("GET", "/config/realtime"));
+    if (!result.supabaseUrl || !result.supabaseAnonKey) {
+        throw new Error("Invalid realtime credentials response from API");
+    }
+    return result;
+}
+/**
+ * Create an API client from daemon config.
+ */
+export function createApiClient(config) {
+    return new HarmonyApiClient({ apiKey: config.apiKey, apiUrl: config.apiUrl });
+}

package/dist/git-pr.d.ts

@@ -0,0 +1,25 @@
+import type { Card } from "@harmony/shared";
+import type { AgentConfig } from "./types.js";
+export type GitProvider = "github" | "azure" | "gitlab" | "bitbucket" | "unknown";
+export declare function detectGitProvider(cwd?: string): GitProvider;
+/**
+ * Validate that the CLI for the detected git provider is installed and authenticated.
+ * Returns the provider name or throws with instructions.
+ */
+export declare function validateGitProviderCli(provider: GitProvider, cwd?: string): void;
+export type PrState = "merged" | "open" | "closed" | "unknown";
+/**
+ * Check whether a PR has been merged using the git provider CLI (async).
+ */
+export declare function checkPrMergeStatus(prUrl: string, cwd: string, provider: GitProvider): Promise<PrState>;
+/**
+ * Extract a PR URL from card description. Matches the format written by completion.ts:
+ * `PR: https://...`
+ */
+export declare function extractPrUrl(description: string | null): string | null;
+export declare function remoteBranchExists(branchName: string, cwd: string): boolean;
+export declare function pushBranch(branchName: string, cwd: string): void;
+export declare function buildPrBody(card: Card, commitLog: string): string;
+export declare function createPullRequest(card: Card, branchName: string, worktreePath: string, config: AgentConfig, provider: GitProvider): string | null;
+export declare function findExistingPr(branchName: string, worktreePath: string, provider: GitProvider): string | null;
+export declare function updateExistingPr(branchName: string, body: string, worktreePath: string, provider: GitProvider): void;

package/dist/git-pr.js

@@ -0,0 +1,305 @@
+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`);
+        execFileSync("git", ["push", "--force-with-lease", "-u", "origin", branchName], { cwd, stdio: "pipe" });
+    }
+    else {
+        execFileSync("git", ["push", "-u", "origin", branchName], {
+            cwd,
+            stdio: "pipe",
+        });
+    }
+}
+// ============ 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/index.d.ts

@@ -0,0 +1 @@
+export {};