@shanesaravia/hive 0.2.0 → 0.3.0

package/packages/server/dist/watch/jobsWatcher.js

@@ -55,8 +55,11 @@ export class JobsWatcher {
                     // only a terse question in needs/detail, and done turns store a
                     // one-line summary in output.result. The full reply lives in the
                     // session transcript (timeline text is a 4KB tail as fallback).
-                    if (job.state === "done" || job.state === "blocked") {
-                        job.lastText = this.resolveLastText(jobId, job, directory);
+                    if (job.state === "done" || job.state === "blocked" || job.state === "working") {
+                        const turn = this.resolveTurnTexts(jobId, job, directory);
+                        if (job.state !== "working")
+                            job.lastText = turn.final;
+                        job.progressTexts = turn.updates;
                     }
                     next.set(jobId, job);
                 }
@@ -69,16 +72,25 @@ export class JobsWatcher {
         for (const listener of this.jobsListeners)
             listener(this.jobs);
     }
+    /** Cached per job by state.json's updatedAt and the transcript's size, so reloads don't re-read transcripts. */
     lastTextCache = new Map();
-    /** Cached per job/updatedAt so reloads don't re-read transcripts. */
-    resolveLastText(jobId, job, directory) {
+    resolveTurnTexts(jobId, job, directory) {
+        const transcript = transcriptPath(job.sessionId);
+        let size;
+        try {
+            size = transcript ? fs.statSync(transcript).size : undefined;
+        }
+        catch {
+            size = undefined;
+        }
         const cached = this.lastTextCache.get(jobId);
-        if (cached && cached.updatedAt === job.updatedAt)
-            return cached.text;
-        const text = readTranscriptFinalText(job.sessionId)
-            ?? readLatestTimelineText(path.join(directory, jobId, "timeline.jsonl"));
-        this.lastTextCache.set(jobId, { updatedAt: job.updatedAt, text });
-        return text;
+        if (cached && cached.updatedAt === job.updatedAt && cached.size === size)
+            return { final: cached.final, updates: cached.updates };
+        const turn = transcript ? readTranscriptTurn(transcript) : undefined;
+        const final = turn?.final ?? readLatestTimelineText(path.join(directory, jobId, "timeline.jsonl"));
+        const entry = { updatedAt: job.updatedAt, size, final, updates: turn?.updates ?? [] };
+        this.lastTextCache.set(jobId, entry);
+        return { final, updates: entry.updates };
     }
     tailTimeline(jobId, directory) {
         const timelinePath = path.join(directory, jobId, "timeline.jsonl");
@@ -116,11 +128,14 @@ export class JobsWatcher {
     }
 }
 const TRANSCRIPT_TAIL_BYTES = 256 * 1024;
-/** Locates the session's transcript under ~/.claude/projects and returns the
- * last assistant text message — the model's actual final reply. */
-function readTranscriptFinalText(sessionId) {
+/** Locates the session's transcript under ~/.claude/projects. */
+const transcriptPaths = new Map();
+function transcriptPath(sessionId) {
     if (!sessionId)
         return undefined;
+    const known = transcriptPaths.get(sessionId);
+    if (known && fs.existsSync(known))
+        return known;
     const root = path.join(os.homedir(), ".claude", "projects");
     let dirs;
     try {
@@ -133,17 +148,27 @@ function readTranscriptFinalText(sessionId) {
         const file = path.join(root, dir, `${sessionId}.jsonl`);
         if (!fs.existsSync(file))
             continue;
-        return finalAssistantText(file);
+        transcriptPaths.set(sessionId, file);
+        return file;
     }
     return undefined;
 }
-function finalAssistantText(file) {
+/** How much of what the model says between tool calls the conversation keeps. */
+const PROGRESS_UPDATE_LIMIT = 8;
+const PROGRESS_UPDATE_CHARS = 320;
+/**
+ * The current turn's assistant text, from the tail of the transcript: the
+ * final reply, and what the model said along the way — narration between
+ * tool calls, oldest first, trimmed. A turn starts at the last user message
+ * that is not a tool result.
+ */
+export function readTranscriptTurn(file) {
     let fd;
     try {
         fd = fs.openSync(file, "r");
     }
     catch {
-        return undefined;
+        return { updates: [] };
     }
     try {
         const size = fs.fstatSync(fd).size;
@@ -151,6 +176,7 @@ function finalAssistantText(file) {
         const buf = Buffer.alloc(size - offset);
         fs.readSync(fd, buf, 0, buf.length, offset);
         const lines = buf.toString("utf-8").split("\n");
+        const texts = [];
         // Skip a line truncated by the tail window (index 0 when offset > 0).
         for (let i = lines.length - 1; i >= (offset > 0 ? 1 : 0); i--) {
             const line = lines[i].trim();
@@ -158,21 +184,26 @@ function finalAssistantText(file) {
                 continue;
             try {
                 const entry = JSON.parse(line);
-                if (entry.type !== "assistant" || !Array.isArray(entry.message?.content))
+                const content = entry.message?.content;
+                if (entry.type === "user") {
+                    const isPrompt = typeof content === "string" || (Array.isArray(content) && content.some((item) => item?.type === "text"));
+                    if (isPrompt)
+                        break;
                     continue;
-                const text = entry.message.content
-                    .filter((item) => item?.type === "text" && typeof item.text === "string")
-                    .map((item) => item.text)
-                    .join("\n")
-                    .trim();
+                }
+                if (entry.type !== "assistant" || !Array.isArray(content))
+                    continue;
+                const text = content.filter((item) => item?.type === "text" && typeof item.text === "string").map((item) => item.text).join("\n").trim();
                 if (text)
-                    return text;
+                    texts.unshift(text);
             }
             catch {
                 continue;
             }
         }
-        return undefined;
+        const final = texts.at(-1);
+        const updates = texts.slice(0, -1).slice(-PROGRESS_UPDATE_LIMIT).map((text) => text.length > PROGRESS_UPDATE_CHARS ? `${text.slice(0, PROGRESS_UPDATE_CHARS - 1).trimEnd()}…` : text);
+        return { final, updates };
     }
     finally {
         fs.closeSync(fd);

package/packages/server/dist/worktrees/worktreeReclaim.js

@@ -0,0 +1,156 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Hive launches missions through the provider CLI's native `--worktree`
+ * primitive (see control/launcher.ts) but nothing ever reclaimed the result,
+ * so every templated mission leaked a checked-out worktree and a branch.
+ *
+ * Reclamation is deliberately scoped to worktrees Hive itself caused to
+ * exist: the CLI creates them under `<repo>/.claude/worktrees/<name>` on a
+ * `worktree-<name>` branch. Anything outside that layout is left alone, so a
+ * stale or wrong `worktreePath` on a job record can never delete a real
+ * checkout.
+ */
+/** Path segment the provider CLI uses for its managed worktrees. */
+const MANAGED_SEGMENT = path.join(".claude", "worktrees");
+function git(cwd, args) {
+    return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+}
+/**
+ * git may answer --git-common-dir with either an absolute or a
+ * repository-relative path depending on where it runs, and resolving a
+ * relative answer against the wrong base silently yields a bogus path.
+ * --path-format is authoritative where available (git 2.31+).
+ */
+function commonGitDir(cwd) {
+    try {
+        return git(cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+    }
+    catch {
+        return path.resolve(cwd, git(cwd, ["rev-parse", "--git-common-dir"]));
+    }
+}
+/**
+ * A managed worktree lives under `.claude/worktrees/` AND reports a git common
+ * directory different from its own git dir. Both checks matter: the path shape
+ * alone would trust unverified job metadata, and the git check alone would
+ * happily remove a worktree the user created by hand somewhere else.
+ */
+export function isManagedWorktree(worktreePath) {
+    if (!worktreePath.includes(MANAGED_SEGMENT))
+        return false;
+    let gitEntry;
+    try {
+        gitEntry = fs.statSync(path.join(worktreePath, ".git"));
+    }
+    catch {
+        return false;
+    }
+    // A linked worktree records its git directory in a `.git` FILE; a main
+    // checkout has a `.git` DIRECTORY. That distinction is what stops a real
+    // repository from ever being reclaimed, and unlike comparing
+    // --git-dir against --git-common-dir it cannot be fooled by git mixing
+    // absolute and relative path output for a nested directory.
+    if (!gitEntry.isFile())
+        return false;
+    try {
+        return git(worktreePath, ["rev-parse", "--is-inside-work-tree"]) === "true";
+    }
+    catch {
+        return false;
+    }
+}
+/** Uncommitted tracked or untracked changes in the worktree. */
+export function isWorktreeDirty(worktreePath) {
+    try {
+        return git(worktreePath, ["status", "--porcelain"]).length > 0;
+    }
+    catch {
+        // Unreadable means unverifiable, and unverifiable must not be discarded.
+        return true;
+    }
+}
+/**
+ * `completed` is reversible — a follow-up message implicitly reopens a
+ * completed mission (see rest.ts), and "Clear completed desks" completes many
+ * missions at once — so uncommitted work survives it. `deleted` and `archived`
+ * are explicit, per-mission, terminal gestures and reclaim unconditionally.
+ */
+function discardsUncommittedWork(trigger) {
+    return trigger !== "completed";
+}
+/**
+ * Removes a mission's worktree and its branch. Safe to call for any mission:
+ * missions without a worktree, and worktrees already gone, report "absent".
+ */
+export function reclaimWorktree(target, trigger) {
+    const worktreePath = target.path;
+    if (!worktreePath)
+        return { status: "absent" };
+    if (!fs.existsSync(worktreePath))
+        return { status: "absent", path: worktreePath, branch: target.branch };
+    if (!isManagedWorktree(worktreePath)) {
+        return { status: "unmanaged", path: worktreePath, branch: target.branch, detail: "not a Hive-managed worktree" };
+    }
+    if (!discardsUncommittedWork(trigger) && isWorktreeDirty(worktreePath)) {
+        return { status: "kept_dirty", path: worktreePath, branch: target.branch, detail: "uncommitted changes preserved" };
+    }
+    // The main checkout owns the worktree administrative data, so removal and
+    // branch deletion must run from the common repository, not from inside the
+    // directory being deleted.
+    let repositoryRoot;
+    try {
+        repositoryRoot = path.dirname(commonGitDir(worktreePath));
+    }
+    catch (error) {
+        return { status: "failed", path: worktreePath, branch: target.branch, detail: error.message };
+    }
+    try {
+        // Locked worktrees are Hive's own (the CLI locks some during launch);
+        // unlock is a no-op when the worktree was never locked.
+        try {
+            git(repositoryRoot, ["worktree", "unlock", worktreePath]);
+        }
+        catch { /* not locked */ }
+        git(repositoryRoot, ["worktree", "remove", "--force", worktreePath]);
+    }
+    catch (error) {
+        return { status: "failed", path: worktreePath, branch: target.branch, detail: error.message };
+    }
+    let detail;
+    if (target.branch) {
+        const branch = target.branch.replace(/^refs\/heads\//, "");
+        try {
+            // -D rather than -d: the branch was just verified to hold no
+            // uncommitted work, and an unmerged experiment branch is exactly what
+            // this reclaim is meant to collect. The commits stay in the reflog.
+            git(repositoryRoot, ["branch", "-D", branch]);
+        }
+        catch {
+            detail = `worktree removed; branch ${branch} retained`;
+        }
+    }
+    try {
+        git(repositoryRoot, ["worktree", "prune"]);
+    }
+    catch { /* best effort */ }
+    return { status: "removed", path: worktreePath, branch: target.branch, detail };
+}
+/** Human-readable line for the mission activity timeline. */
+export function reclaimEventDetail(result, trigger) {
+    const name = result.path ? path.basename(result.path) : "worktree";
+    if (result.status === "removed") {
+        return `Worktree ${name} reclaimed after mission ${trigger}${result.detail ? ` · ${result.detail}` : ""}`;
+    }
+    if (result.status === "kept_dirty") {
+        return `Worktree ${name} kept: uncommitted changes remain after mission ${trigger}`;
+    }
+    if (result.status === "failed") {
+        return `Worktree ${name} could not be reclaimed: ${result.detail ?? "git error"}`;
+    }
+    if (result.status === "unmanaged") {
+        return `Worktree ${name} left in place: not a Hive-managed worktree`;
+    }
+    return undefined;
+}