@gethmy/agent 1.7.0 → 1.7.2

package/dist/progress-tracker.js

@@ -1,442 +0,0 @@
-import { log } from "./log.js";
-import { AGENT_NAME, agentIdentifier } from "./types.js";
-const TAG = "progress-tracker";
-const THROTTLE_MS = 5_000;
-const HEARTBEAT_MS = 60_000;
-const MAX_TASK_LENGTH = 120;
-const MAX_LOG_BUFFER = 500;
-// Hoisted regexes — avoids recompilation on every call
-const SENTENCE_SPLIT = /\.\s|\n/;
-const ACTION_PREFIX = /^(Let me|I'll|I need to|Now|First|Next|Looking|Checking|Creating|Adding|Updating|Fixing|Refactoring|Moving|The |This )/i;
-const GIT_COMMIT_RE = /\bgit\s+commit\b/;
-const BUILD_CMD_RE = /\b(test|build|lint|check|tsc|vitest|jest|(?:bun|npm|pnpm|yarn) run (?:build|lint))\b/;
-const PHASES = {
-    exploring: { min: 10, max: 25, label: "Exploring" },
-    implementing: { min: 25, max: 55, label: "Implementing" },
-    testing: { min: 55, max: 65, label: "Testing" },
-    committing: { min: 65, max: 70, label: "Committing" },
-    finishing: { min: 70, max: 75, label: "Finalizing" },
-};
-const PHASE_ORDER = {
-    exploring: 0,
-    implementing: 1,
-    testing: 2,
-    committing: 3,
-    finishing: 4,
-};
-// Tools that indicate implementation
-const EDIT_TOOLS = new Set(["Write", "Edit", "MultiEdit", "NotebookEdit"]);
-function truncate(str, max) {
-    return str.length > max ? `${str.slice(0, max - 3)}...` : str;
-}
-// Map file-based tools to their display verbs
-const FILE_TOOL_VERBS = {
-    Read: ["Reading", "file_path"],
-    Edit: ["Editing", "file_path"],
-    MultiEdit: ["Editing", "file_path"],
-    Write: ["Writing", "file_path"],
-    NotebookEdit: ["Editing notebook", "notebook_path"],
-};
-export class ProgressTracker {
-    client;
-    cardId;
-    workerId;
-    phase = "exploring";
-    progress = 10;
-    toolCallCount = 0;
-    hasEdited = false;
-    lastUpdateAt = 0;
-    pendingUpdate = null;
-    pendingTask = "";
-    heartbeatTimer = null;
-    stopped = false;
-    // Rich task tracking
-    lastAction = "";
-    // Subtask tracking
-    subtaskTotal;
-    subtaskCompleted;
-    subtaskMode;
-    // Rich activity tracking
-    filesEdited = new Set();
-    filesRead = new Set();
-    lastCost = null;
-    logBuffer = [];
-    sessionId = null;
-    // Last assistant text block — used by the episode write hook to
-    // capture an approach summary without re-running an LLM (plan §"Write hook").
-    lastAssistantText = "";
-    constructor(client, cardId, workerId, subtasks) {
-        this.client = client;
-        this.cardId = cardId;
-        this.workerId = workerId;
-        this.subtaskTotal = subtasks.length;
-        this.subtaskCompleted = subtasks.filter((s) => s.completed).length;
-        this.subtaskMode = subtasks.length > 0;
-    }
-    setSessionId(id) {
-        this.sessionId = id;
-    }
-    /**
-     * Wire up the parser events and start the heartbeat.
-     */
-    attach(parser) {
-        parser.on("tool_start", (name, input) => {
-            this.onToolStart(name, input);
-            const desc = this.describeToolAction(name, input);
-            if (desc) {
-                this.pushLogEntry({
-                    phase: this.phase,
-                    eventType: "tool_start",
-                    toolName: name,
-                    description: desc,
-                    metadata: this.extractToolMetadata(name, input),
-                });
-            }
-        });
-        parser.on("tool_end", (name, _id, content) => {
-            this.onToolEnd(name, content);
-            this.pushLogEntry({
-                phase: this.phase,
-                eventType: "tool_end",
-                toolName: name,
-                description: `Completed: ${name}`,
-                metadata: {},
-            });
-        });
-        parser.on("text", (content) => {
-            this.onText(content);
-        });
-        parser.on("cost_update", (cost) => {
-            this.lastCost = cost;
-        });
-        this.startHeartbeat();
-    }
-    /**
-     * Stop all timers and flush any pending update.
-     */
-    stop() {
-        this.stopped = true;
-        if (this.pendingUpdate) {
-            clearTimeout(this.pendingUpdate);
-            this.pendingUpdate = null;
-        }
-        if (this.heartbeatTimer) {
-            clearTimeout(this.heartbeatTimer);
-            this.heartbeatTimer = null;
-        }
-    }
-    /** Get a summary of the session stats. */
-    get stats() {
-        return {
-            filesEdited: this.filesEdited.size,
-            filesRead: this.filesRead.size,
-            toolCalls: this.toolCallCount,
-            cost: this.lastCost,
-            lastAssistantText: this.lastAssistantText,
-        };
-    }
-    onToolStart(name, input) {
-        this.toolCallCount++;
-        log.debug(TAG, `Tool: ${name} (count: ${this.toolCallCount}, phase: ${this.phase})`);
-        // Track files
-        const filePath = this.extractString(input, "file_path");
-        if (filePath) {
-            if (EDIT_TOOLS.has(name)) {
-                this.filesEdited.add(filePath);
-            }
-            else if (name === "Read" || name === "Glob" || name === "Grep") {
-                this.filesRead.add(filePath);
-            }
-        }
-        // Detect phase transitions
-        if (!this.hasEdited && EDIT_TOOLS.has(name)) {
-            this.hasEdited = true;
-            this.transitionTo("implementing");
-        }
-        else if (this.hasEdited && name === "Bash") {
-            const cmd = this.extractString(input, "command");
-            if (cmd && GIT_COMMIT_RE.test(cmd)) {
-                this.transitionTo("committing");
-            }
-            else if (cmd && BUILD_CMD_RE.test(cmd)) {
-                this.transitionTo("testing");
-            }
-        }
-        else if (name === "mcp__harmony__harmony_end_agent_session") {
-            this.transitionTo("finishing");
-        }
-        // Handle subtask toggling — override heuristic progress
-        if (name === "mcp__harmony__harmony_toggle_subtask" && this.subtaskMode) {
-            const val = this.extractString(input, "completed");
-            const completing = val === null || val === "true";
-            if (completing) {
-                this.subtaskCompleted = Math.min(this.subtaskCompleted + 1, this.subtaskTotal);
-            }
-            else {
-                this.subtaskCompleted = Math.max(this.subtaskCompleted - 1, 0);
-            }
-            const subtaskProgress = Math.round(10 + (this.subtaskCompleted / this.subtaskTotal) * 60);
-            this.progress = Math.max(this.progress, subtaskProgress);
-            this.scheduleUpdate(`Completed subtask ${this.subtaskCompleted}/${this.subtaskTotal}`);
-            return;
-        }
-        // Build rich action description and increment progress
-        const action = this.describeToolAction(name, input);
-        if (action) {
-            this.lastAction = action;
-        }
-        this.incrementProgress();
-    }
-    onToolEnd(name, content) {
-        // Detect build/test failures from Bash results
-        if (name === "Bash" && content && this.phase === "testing") {
-            const lower = content.slice(-500).toLowerCase();
-            if (lower.includes("error") &&
-                (lower.includes("build failed") ||
-                    lower.includes("failed to compile") ||
-                    lower.includes("exit code 1"))) {
-                this.lastAction = "Build failed — fixing errors";
-                this.scheduleUpdate(this.lastAction);
-            }
-        }
-        // Reset heartbeat on any activity
-        this.startHeartbeat();
-    }
-    onText(content) {
-        // Capture brief reasoning snippets from Claude's text output.
-        // Only update if the text looks like a meaningful status line
-        // (skip very short fragments from streaming).
-        const trimmed = content.trim();
-        if (trimmed.length < 10)
-            return;
-        // Always remember the latest non-trivial assistant turn for the episode
-        // write hook — last-turn trim, no LLM rewrite (plan §"Write hook").
-        this.lastAssistantText = trimmed;
-        // Extract first sentence or line as a brief description
-        const end = trimmed.search(SENTENCE_SPLIT);
-        const firstLine = (end === -1 ? trimmed : trimmed.slice(0, end)).trim();
-        if (firstLine.length >= 10 && firstLine.length <= 200) {
-            if (ACTION_PREFIX.test(firstLine)) {
-                this.lastAction = truncate(firstLine, MAX_TASK_LENGTH);
-            }
-        }
-    }
-    transitionTo(newPhase) {
-        if (PHASE_ORDER[newPhase] <= PHASE_ORDER[this.phase])
-            return;
-        log.info(TAG, `Phase: ${this.phase} → ${newPhase}`);
-        this.phase = newPhase;
-        this.progress = Math.max(this.progress, PHASES[newPhase].min);
-        // Reset stale action from prior phase; new phase starts with its own label
-        this.lastAction = "";
-        this.pushLogEntry({
-            phase: newPhase,
-            eventType: "phase_change",
-            toolName: null,
-            description: `Entering ${newPhase} phase`,
-            metadata: {},
-        });
-        this.scheduleUpdate(PHASES[newPhase].label);
-    }
-    incrementProgress() {
-        const config = PHASES[this.phase];
-        const range = config.max - config.min;
-        const step = Math.max(1, Math.round(range / 12));
-        const newProgress = Math.min(this.progress + step, config.max);
-        if (newProgress > this.progress) {
-            this.progress = newProgress;
-            this.scheduleUpdate(this.currentTaskLabel());
-        }
-    }
-    currentTaskLabel() {
-        if (this.lastAction)
-            return this.lastAction;
-        // Include file count context when available
-        const edited = this.filesEdited.size;
-        if (edited > 0) {
-            return `${PHASES[this.phase].label} (${edited} file${edited > 1 ? "s" : ""} modified)`;
-        }
-        return PHASES[this.phase].label;
-    }
-    /**
-     * Build a human-readable description of what a tool call is doing.
-     */
-    describeToolAction(name, input) {
-        // File-based tools: Read, Edit, MultiEdit, Write, NotebookEdit
-        const fileTool = FILE_TOOL_VERBS[name];
-        if (fileTool) {
-            const [verb, key] = fileTool;
-            const fp = this.extractString(input, key);
-            return fp ? `${verb} ${this.shortPath(fp)}` : verb;
-        }
-        switch (name) {
-            case "Glob": {
-                const pattern = this.extractString(input, "pattern");
-                return pattern ? `Searching for ${pattern}` : "Searching files";
-            }
-            case "Grep": {
-                const pattern = this.extractString(input, "pattern");
-                return pattern
-                    ? `Searching for "${truncate(pattern, 40)}"`
-                    : "Searching code";
-            }
-            case "Bash": {
-                const cmd = this.extractString(input, "command");
-                return cmd
-                    ? `Running: ${truncate(cmd.split("\n")[0], 80)}`
-                    : "Running command";
-            }
-            case "Agent": {
-                const desc = this.extractString(input, "description");
-                return desc
-                    ? `Sub-agent: ${truncate(desc, 60)}`
-                    : "Delegating to sub-agent";
-            }
-            default: {
-                if (name.startsWith("mcp__harmony__harmony_")) {
-                    const toolName = name
-                        .replace("mcp__harmony__harmony_", "")
-                        .replace(/_/g, " ");
-                    return `Harmony: ${toolName}`;
-                }
-                if (name.startsWith("mcp__")) {
-                    return `Tool: ${name.split("__").pop()?.replace(/_/g, " ") ?? name}`;
-                }
-                return null;
-            }
-        }
-    }
-    /**
-     * Strip absolute paths to show only meaningful segments from src/ or packages/.
-     */
-    shortPath(filePath) {
-        const parts = filePath.split("/");
-        const srcIdx = parts.lastIndexOf("src");
-        const pkgIdx = parts.lastIndexOf("packages");
-        const anchor = Math.max(srcIdx, pkgIdx);
-        if (anchor >= 0) {
-            return parts.slice(anchor).join("/");
-        }
-        return parts.slice(-3).join("/");
-    }
-    scheduleUpdate(currentTask) {
-        if (this.stopped)
-            return;
-        const now = Date.now();
-        const elapsed = now - this.lastUpdateAt;
-        // Always track latest task so throttled sends use the freshest label
-        this.pendingTask = currentTask;
-        if (elapsed >= THROTTLE_MS) {
-            this.sendUpdate(this.pendingTask);
-        }
-        else if (!this.pendingUpdate) {
-            const delay = THROTTLE_MS - elapsed;
-            this.pendingUpdate = setTimeout(() => {
-                this.pendingUpdate = null;
-                if (!this.stopped) {
-                    // Send the latest task, not the one captured at schedule time
-                    this.sendUpdate(this.pendingTask);
-                }
-            }, delay);
-        }
-        // If there's already a pending update, pendingTask is now updated — it will use the fresh value
-    }
-    sendUpdate(currentTask) {
-        this.lastUpdateAt = Date.now();
-        log.debug(TAG, `Progress: ${this.progress}% — ${currentTask}`);
-        this.client
-            .updateAgentProgress(this.cardId, {
-            agentIdentifier: agentIdentifier(this.workerId),
-            agentName: AGENT_NAME,
-            status: "working",
-            currentTask: truncate(currentTask, MAX_TASK_LENGTH),
-            progressPercent: this.progress,
-            phase: this.phase,
-            filesChanged: this.filesEdited.size,
-            costCents: Math.round((this.lastCost?.totalCostUsd ?? 0) * 100),
-            inputTokens: this.lastCost?.totalInputTokens ?? 0,
-            outputTokens: this.lastCost?.totalOutputTokens ?? 0,
-            cacheCreationInputTokens: this.lastCost?.totalCacheCreationInputTokens ?? 0,
-            cacheReadInputTokens: this.lastCost?.totalCacheReadInputTokens ?? 0,
-            modelName: this.lastCost?.modelName,
-        })
-            .catch((err) => {
-            log.warn(TAG, `Failed to send progress update: ${err}`);
-        });
-        this.flushActivityLog();
-    }
-    startHeartbeat() {
-        if (this.heartbeatTimer) {
-            clearTimeout(this.heartbeatTimer);
-        }
-        this.heartbeatTimer = setTimeout(() => {
-            if (!this.stopped) {
-                const task = this.lastAction
-                    ? `Still working — ${this.lastAction}`
-                    : "Still working...";
-                this.sendUpdate(truncate(task, MAX_TASK_LENGTH));
-                this.startHeartbeat();
-            }
-        }, HEARTBEAT_MS);
-    }
-    flushFinal() {
-        this.flushActivityLog();
-    }
-    pushLogEntry(entry) {
-        this.logBuffer.push({
-            ...entry,
-            createdAt: new Date().toISOString(),
-        });
-        if (this.logBuffer.length > MAX_LOG_BUFFER) {
-            this.logBuffer.shift();
-        }
-    }
-    flushActivityLog() {
-        if (!this.sessionId || this.logBuffer.length === 0)
-            return;
-        const raw = [...this.logBuffer];
-        this.logBuffer = [];
-        this.client
-            .flushActivityLog(this.cardId, {
-            sessionId: this.sessionId,
-            entries: raw.map((e) => ({
-                ...e,
-                phase: e.phase ?? undefined,
-                toolName: e.toolName ?? undefined,
-            })),
-        })
-            .catch((err) => {
-            log.warn(TAG, `Failed to flush activity log: ${err}`);
-            // Put entries back at the front of the buffer for retry
-            this.logBuffer.unshift(...raw);
-            if (this.logBuffer.length > MAX_LOG_BUFFER) {
-                this.logBuffer.length = MAX_LOG_BUFFER;
-            }
-        });
-    }
-    extractToolMetadata(_name, input) {
-        const meta = {};
-        const fp = this.extractString(input, "file_path");
-        if (fp)
-            meta.file_path = fp;
-        const cmd = this.extractString(input, "command");
-        if (cmd)
-            meta.command = cmd.split("\n")[0].slice(0, 200);
-        const pattern = this.extractString(input, "pattern");
-        if (pattern)
-            meta.pattern = pattern;
-        const desc = this.extractString(input, "description");
-        if (desc)
-            meta.description = desc;
-        return meta;
-    }
-    /**
-     * Safely extract a string property from an unknown tool input.
-     */
-    extractString(input, key) {
-        if (typeof input === "object" && input !== null && key in input) {
-            return String(input[key]);
-        }
-        return null;
-    }
-}

package/dist/prompt.d.ts

@@ -1,18 +0,0 @@
-import type { HarmonyApiClient } from "@gethmy/mcp/src/api-client.js";
-import type { EnrichedCard } from "./types.js";
-/**
- * Build the prompt for a card using the shared prompt generation pipeline.
- *
- * This calls `client.generateCardPrompt()` which assembles relevant memories
- * from the knowledge graph, applies role-based framing, and produces a
- * context-rich prompt — the same pipeline used by the MCP server.
- *
- * Falls back to a minimal local prompt if the API call fails.
- */
-export declare function buildPrompt(enriched: EnrichedCard, branchName: string, worktreePath: string, client: HarmonyApiClient, workspaceId: string, projectId?: string): Promise<string>;
-/**
- * Recall similar past episodes (implement solution/error type) and render them
- * as a "Similar past tasks" section. Returns the empty string on no hits or
- * recall failure — never throws.
- */
-export declare function renderPastEpisodesSection(client: HarmonyApiClient, title: string, description: string, workspaceId: string, projectId?: string): Promise<string>;

package/dist/prompt.js

@@ -1,117 +0,0 @@
-import { log } from "./log.js";
-const TAG = "prompt";
-/**
- * Build the prompt for a card using the shared prompt generation pipeline.
- *
- * This calls `client.generateCardPrompt()` which assembles relevant memories
- * from the knowledge graph, applies role-based framing, and produces a
- * context-rich prompt — the same pipeline used by the MCP server.
- *
- * Falls back to a minimal local prompt if the API call fails.
- */
-export async function buildPrompt(enriched, branchName, worktreePath, client, workspaceId, projectId) {
-    const { card } = enriched;
-    // Phase 1.5 read hook: surface similar past episodes for this card. Block
-    // on recall — v2 §6.3 budget already caps latency. Errors degrade silently
-    // so prompt build always succeeds (plan §"Read hook").
-    const pastEpisodesSection = await renderPastEpisodesSection(client, card.title, card.description ?? "", workspaceId, projectId);
-    try {
-        const result = await client.generateCardPrompt({
-            cardId: card.id,
-            workspaceId,
-            projectId,
-            variant: "execute",
-            customConstraints: `You are working in a git worktree at \`${worktreePath}\` on branch \`${branchName}\`.
-Do NOT push to main. All your work stays on \`${branchName}\`.
-When finished, call harmony_end_agent_session with status="completed".`,
-        });
-        log.info(TAG, `Generated prompt for #${card.short_id} — ${result.contextSummary.memoryCount} memories, ${result.tokenEstimate} tokens`);
-        return result.prompt + pastEpisodesSection;
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        log.warn(TAG, `Failed to generate prompt via API, using fallback: ${msg}`);
-        return (buildFallbackPrompt(enriched, branchName, worktreePath) +
-            pastEpisodesSection);
-    }
-}
-/**
- * Recall similar past episodes (implement solution/error type) and render them
- * as a "Similar past tasks" section. Returns the empty string on no hits or
- * recall failure — never throws.
- */
-export async function renderPastEpisodesSection(client, title, description, workspaceId, projectId) {
-    if (!projectId)
-        return "";
-    try {
-        const query = `${title}\n${description}`.trim();
-        const { entities } = await client.harmonyRecall({
-            workspaceId,
-            projectId,
-            query,
-            type: ["solution", "error"],
-            memory_tier: "episode",
-            scope: "project",
-            topK: 3,
-        });
-        if (entities.length === 0)
-            return "";
-        const bullets = entities
-            .map((entity) => {
-            const e = entity;
-            const meta = e.metadata ?? {};
-            const outcomeTag = meta.outcome ? `[${meta.outcome}]` : "[?]";
-            const approach = meta.approach_summary ?? "";
-            return `- ${outcomeTag} ${e.title ?? "(untitled episode)"}\n  Approach: ${approach}`;
-        })
-            .join("\n");
-        return `\n\n## Similar past tasks\n${bullets}`;
-    }
-    catch (err) {
-        log.warn(TAG, "past-episodes recall failed", {
-            event: "episode_recall_failed",
-            error: err instanceof Error ? err.message : String(err),
-        });
-        return "";
-    }
-}
-/**
- * Minimal fallback prompt when the API-based generation is unavailable.
- */
-function buildFallbackPrompt(enriched, branchName, worktreePath) {
-    const { card, column, labels, subtasks } = enriched;
-    const labelStr = labels.length > 0 ? labels.map((l) => l.name).join(", ") : "none";
-    const subtaskStr = subtasks.length > 0
-        ? subtasks
-            .map((s) => `- [${s.completed ? "x" : " "}] ${s.title}`)
-            .join("\n")
-        : "No subtasks defined.";
-    const description = card.description?.trim() || "No description provided.";
-    return `You are an AI agent working on a task from the Harmony project board.
-
-## Card: #${card.short_id} - ${card.title}
-**Labels**: ${labelStr}
-**Column**: ${column.name}
-**Priority**: ${card.priority}
-
-## Description
-${description}
-
-## Subtasks
-${subtaskStr}
-
-## Instructions
-1. Read the codebase and understand the context needed for this task
-2. Report progress via harmony_update_agent_progress at key milestones:
-   - After reading codebase and forming a plan (~20%)
-   - After each major implementation step (~30-60%)
-   - After completing each subtask (also toggle via harmony_toggle_subtask)
-   - Before committing (~65%)
-   Include a brief currentTask description.
-3. Implement the changes on branch \`${branchName}\`
-4. Commit your work with clear, descriptive commit messages
-5. When finished, call harmony_end_agent_session with status="completed"
-
-You are working in a git worktree at \`${worktreePath}\` on branch \`${branchName}\`.
-Do NOT push to main. All your work stays on \`${branchName}\`.`;
-}

package/dist/queue.d.ts

@@ -1,39 +0,0 @@
-import type { Card, Column, Label } from "@harmony/shared";
-import type { AgentConfig, QueueItem, WorkMode } from "./types.js";
-/**
- * Priority queue for cards waiting to be worked on.
- * Sorted by: label priority boost > column position boost > enqueue time (FIFO).
- */
-export declare class PriorityQueue {
-    private config;
-    private items;
-    constructor(config: AgentConfig);
-    /**
-     * Calculate priority score for a card.
-     */
-    scoreCard(_card: Card, column: Column, labels: Label[]): number;
-    /**
-     * Add a card to the queue. If already present, update its priority.
-     */
-    enqueue(card: Card, column: Column, labels: Label[], mode?: WorkMode): void;
-    /**
-     * Remove and return the highest-priority item.
-     */
-    dequeue(): QueueItem | null;
-    /**
-     * Remove a specific card from the queue.
-     */
-    remove(cardId: string): QueueItem | null;
-    /**
-     * Check if a card is in the queue.
-     */
-    has(cardId: string): boolean;
-    /**
-     * Get all queued card IDs.
-     */
-    cardIds(): string[];
-    get length(): number;
-    peek(): QueueItem | null;
-    /** Copy of the queue in priority order (for introspection). */
-    snapshot(): QueueItem[];
-}