@gethmy/agent 1.7.0 → 1.7.2

package/dist/episode-writer.js

@@ -1,232 +0,0 @@
-import { log } from "./log.js";
-const TAG = "episode-writer";
-const MAX_APPROACH_SUMMARY_CHARS = 400;
-/**
- * Rule-derived quality score (0..1) for an implement run. Failures default to 0.
- * Plan §"Quality score": +0.4 if build passed, +0.2 if lint passed, +0.2 if no
- * error thrown, +0.2 if run completed cleanly.
- */
-export function computeQualityScore(result, opts) {
-    if (!result.passed)
-        return 0;
-    let score = 0;
-    if (result.buildErrors.length === 0)
-        score += 0.4;
-    if (result.lintWarnings.length === 0)
-        score += 0.2;
-    if (!opts.errorThrown)
-        score += 0.2;
-    if (opts.runCompletedCleanly)
-        score += 0.2;
-    return Math.min(1, score);
-}
-/**
- * Clamp confidence into the documented [0.4, 1.0] band so failures retain a
- * minimum floor (plan §"Episode record shape").
- */
-function clampConfidence(qualityScore) {
-    return Math.max(0.4, Math.min(1.0, qualityScore));
-}
-/**
- * Trim a free-form summary down to the documented 400-char cap. v1 uses a
- * last-turn trim rather than an LLM rewrite (plan §"Write hook"). Empty or
- * whitespace-only input collapses to a marker so the episode still surfaces
- * as a recallable hit (rather than an empty bullet) in future prompts.
- */
-export function trimApproachSummary(text) {
-    const trimmed = text.trim();
-    if (trimmed.length === 0)
-        return "(no approach summary captured)";
-    if (trimmed.length <= MAX_APPROACH_SUMMARY_CHARS)
-        return trimmed;
-    return `${trimmed.slice(0, MAX_APPROACH_SUMMARY_CHARS - 1).trimEnd()}…`;
-}
-/**
- * Build the entity payload for one episode. Pure — returned object can be
- * snapshotted in tests without hitting the network.
- */
-export function buildEpisodePayload(input, projectId) {
-    if (input.kind === "implement") {
-        const qualityScore = computeQualityScore(input.result, {
-            errorThrown: input.errorMessage !== undefined,
-            runCompletedCleanly: input.result.passed,
-        });
-        const type = input.outcome === "success" ? "solution" : "error";
-        const importance = input.outcome === "success" ? 7 : 5;
-        const approachSummary = trimApproachSummary(input.approachSummary);
-        const outcomeRationale = input.outcome === "success"
-            ? `Build ${input.result.buildErrors.length === 0 ? "passed" : "failed"}, lint ${input.result.lintWarnings.length === 0 ? "clean" : "issues"}.`
-            : `Verification failed: ${input.errorMessage ?? "see findings"}.`;
-        const metadata = {
-            episode_kind: "implement",
-            card_short_id: input.card.short_id,
-            card_title: input.card.title,
-            approach_summary: approachSummary,
-            outcome: input.outcome,
-            quality_score: qualityScore,
-            duration_ms: input.cost?.durationMs ?? 0,
-            token_cost: {
-                input: input.cost?.totalInputTokens ?? 0,
-                output: input.cost?.totalOutputTokens ?? 0,
-                usd: input.cost?.totalCostUsd ?? 0,
-            },
-            files_touched: input.filesEdited,
-            num_turns: input.cost?.numTurns ?? 0,
-        };
-        if (input.errorMessage)
-            metadata.error = input.errorMessage;
-        if (input.agentSessionId)
-            metadata.agent_session_id = input.agentSessionId;
-        return {
-            workspace_id: input.workspaceId,
-            project_id: projectId,
-            type,
-            memory_tier: "episode",
-            scope: "project",
-            title: `Agent run implement — #${input.card.short_id}: ${input.card.title}`,
-            content: `${approachSummary}\n\nOutcome: ${outcomeRationale}`,
-            metadata,
-            importance,
-            confidence: clampConfidence(qualityScore),
-            tags: ["implement", input.outcome, `card:${input.card.short_id}`],
-            agent_identifier: "harmony-agent",
-        };
-    }
-    // Review episode
-    const qualityScore = input.verdict === "approved" ? 1 : 0.4;
-    const summary = trimApproachSummary(input.summary || "(no summary captured)");
-    const metadata = {
-        episode_kind: "review",
-        card_short_id: input.card.short_id,
-        card_title: input.card.title,
-        approach_summary: summary,
-        outcome: input.verdict === "approved" ? "success" : "failure",
-        quality_score: qualityScore,
-        duration_ms: input.cost?.durationMs ?? 0,
-        token_cost: {
-            input: input.cost?.totalInputTokens ?? 0,
-            output: input.cost?.totalOutputTokens ?? 0,
-            usd: input.cost?.totalCostUsd ?? 0,
-        },
-        files_touched: 0,
-        num_turns: input.cost?.numTurns ?? 0,
-    };
-    if (input.agentSessionId)
-        metadata.agent_session_id = input.agentSessionId;
-    if (input.reviewSessionId)
-        metadata.review_session_id = input.reviewSessionId;
-    if (input.originalEpisodeId)
-        metadata.original_episode_id = input.originalEpisodeId;
-    return {
-        workspace_id: input.workspaceId,
-        project_id: projectId,
-        type: "decision",
-        memory_tier: "episode",
-        scope: "project",
-        title: `Agent run review — #${input.card.short_id}: ${input.card.title}`,
-        content: `Review verdict: ${input.verdict}.\n\n${summary}`,
-        metadata,
-        importance: 8,
-        confidence: clampConfidence(qualityScore),
-        tags: ["review", input.verdict, `card:${input.card.short_id}`],
-        agent_identifier: "harmony-agent",
-    };
-}
-/**
- * Write one episode entity. Best-effort: any failure is logged and swallowed
- * so the calling pipeline can complete (plan D8: episode writes never block
- * run completion).
- *
- * Returns the entity id on success, or null on swallowed failure.
- */
-export async function writeEpisode(client, input) {
-    const payload = buildEpisodePayload(input, input.card.project_id);
-    try {
-        const { entity } = await client.createMemoryEntity({
-            ...payload,
-            metadata: payload.metadata,
-        });
-        const id = entity && typeof entity === "object" && "id" in entity
-            ? (entity.id ?? null)
-            : null;
-        log.info(TAG, `episode written for #${input.card.short_id}`, {
-            cardId: input.card.id,
-            event: "episode_write",
-            kind: input.kind,
-        });
-        return id;
-    }
-    catch (err) {
-        log.warn(TAG, `episode write failed for #${input.card.short_id}`, {
-            cardId: input.card.id,
-            event: "episode_write_failed",
-            kind: input.kind,
-            error: err instanceof Error ? err.message : String(err),
-        });
-        return null;
-    }
-}
-/**
- * Find the most recent implement episode for a given card so the review
- * pipeline can back-fill its verdict. Returns null when none exists or the
- * lookup throws — back-fill is best-effort.
- */
-export async function findLatestImplementEpisode(client, workspaceId, projectId, cardShortId) {
-    try {
-        const { entities } = await client.harmonyRecall({
-            workspaceId,
-            projectId,
-            type: ["solution", "error"],
-            memory_tier: "episode",
-            scope: "project",
-            tags: [`card:${cardShortId}`],
-            topK: 1,
-        });
-        const first = entities[0];
-        if (first &&
-            typeof first === "object" &&
-            "id" in first &&
-            typeof first.id === "string") {
-            return first.id;
-        }
-        return null;
-    }
-    catch (err) {
-        log.warn(TAG, "implement-episode lookup failed", {
-            event: "episode_lookup_failed",
-            cardShortId,
-            error: err instanceof Error ? err.message : String(err),
-        });
-        return null;
-    }
-}
-/**
- * Apply the review verdict to an earlier implement episode (plan §"Read hook"
- * back-fill block). Approved nudges the original episode's confidence up;
- * rejected tombstones it via superseded_by.
- */
-export async function backfillReviewVerdict(client, originalEpisodeId, verdict, reviewEpisodeId) {
-    try {
-        if (verdict === "approved") {
-            const { entity } = await client.getMemoryEntity(originalEpisodeId);
-            const current = entity?.confidence ?? 0.4;
-            const bumped = Math.min(1, current + 0.05);
-            await client.updateMemoryEntity(originalEpisodeId, {
-                confidence: bumped,
-            });
-        }
-        else {
-            await client.updateMemoryEntity(originalEpisodeId, {
-                superseded_by: reviewEpisodeId,
-            });
-        }
-    }
-    catch (err) {
-        log.warn(TAG, "review back-fill failed", {
-            event: "episode_backfill_failed",
-            originalEpisodeId,
-            verdict,
-            error: err instanceof Error ? err.message : String(err),
-        });
-    }
-}

package/dist/git-pr.d.ts

@@ -1,38 +0,0 @@
-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;
-/**
- * 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 declare function renameRemoteBranch(oldRef: string, newRef: string, cwd: string): void;
-/**
- * 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 declare function getBranchWebUrl(branchName: string, cwd: string): string | null;
-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

@@ -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}`);
-    }
-}