@shanesaravia/hive 0.2.1 → 0.4.0

package/packages/server/dist/transcripts/transcriptReader.js

@@ -0,0 +1,345 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+/**
+ * The session transcript, read as the terminal renders it.
+ *
+ * Hive's activity feed is built from hooks, and a hook says only that a tool
+ * fired: it carries no assistant prose, no tool input beyond a summary, and no
+ * result at all. So the feed can report "Notification: Claude is waiting for
+ * your input" while being structurally incapable of saying what for.
+ *
+ * The provider already writes the whole thing to disk — every assistant turn,
+ * every tool call with its real input, every result — and each subagent gets
+ * its own file keyed by the same native agent id the roster tracks:
+ *
+ *   ~/.claude/projects/<slug>/<sessionId>.jsonl
+ *   ~/.claude/projects/<slug>/<sessionId>/subagents/agent-<agentId>.jsonl
+ *   ~/.claude/projects/<slug>/<sessionId>/subagents/agent-<agentId>.meta.json
+ *
+ * These files reach several megabytes on a long mission, so every read here is
+ * bounded — walking backwards from the end and stopping once it has enough.
+ */
+/** How much of a transcript to read per backward step. */
+const CHUNK_BYTES = 512 * 1024;
+/**
+ * The ceiling on how far back to walk for one read.
+ *
+ * A fixed tail window cannot work here: a single tool result carrying an image
+ * is megabytes of base64 on one line, and one observed worker's last 768KB held
+ * nine entries. So the read is driven by how many entries it has collected and
+ * merely bounded by bytes.
+ */
+const MAX_SCAN_BYTES = 16 * 1024 * 1024;
+/** Per-entry output cap. The reader keeps the line count so the UI can say what it cut. */
+const OUTPUT_CHARS = 4_000;
+const TEXT_CHARS = 12_000;
+// Read per call rather than captured, and honouring the same override
+// `skillDiscovery` uses, so a test can point the whole reader at a fixture.
+const projectsRoot = () => path.join(process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude"), "projects");
+/**
+ * Caches the containing directory per session; the file itself may be
+ * rewritten, and the cached entry is revalidated before it is trusted, so a
+ * changed root cannot serve a stale hit.
+ */
+const transcriptDirs = new Map();
+/** The `~/.claude/projects/<slug>` directory holding this session's transcript. */
+function projectDirFor(sessionId) {
+    const known = transcriptDirs.get(sessionId);
+    if (known && fs.existsSync(path.join(known, `${sessionId}.jsonl`)))
+        return known;
+    let slugs;
+    try {
+        slugs = fs.readdirSync(projectsRoot());
+    }
+    catch {
+        return undefined;
+    }
+    for (const slug of slugs) {
+        const dir = path.join(projectsRoot(), slug);
+        if (!fs.existsSync(path.join(dir, `${sessionId}.jsonl`)))
+            continue;
+        transcriptDirs.set(sessionId, dir);
+        return dir;
+    }
+    return undefined;
+}
+export function orchestratorTranscriptPath(sessionId) {
+    const dir = projectDirFor(sessionId);
+    const file = dir && path.join(dir, `${sessionId}.jsonl`);
+    return file && fs.existsSync(file) ? file : undefined;
+}
+export function workerTranscriptPath(sessionId, agentId) {
+    const dir = projectDirFor(sessionId);
+    if (!dir)
+        return undefined;
+    // The id comes from a URL, so it must never be able to climb out of the
+    // subagents directory.
+    if (!/^[A-Za-z0-9_-]+$/.test(agentId))
+        return undefined;
+    const file = path.join(dir, sessionId, "subagents", `agent-${agentId}.jsonl`);
+    return fs.existsSync(file) ? file : undefined;
+}
+function workerMeta(sessionId, agentId) {
+    const dir = projectDirFor(sessionId);
+    if (!dir || !/^[A-Za-z0-9_-]+$/.test(agentId))
+        return {};
+    try {
+        return JSON.parse(fs.readFileSync(path.join(dir, sessionId, "subagents", `agent-${agentId}.meta.json`), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Every transcript belonging to a mission: the manager's, then one per worker
+ * the provider actually recorded.
+ *
+ * The worker list comes from the filesystem rather than from the roster, so a
+ * worker whose identity Hive never resolved still has a readable log — and a
+ * roster entry with no transcript is not offered as an empty tab.
+ */
+export function transcriptSources(input) {
+    const sources = [];
+    const seen = new Set();
+    for (const sessionId of input.sessionIds) {
+        const manager = orchestratorTranscriptPath(sessionId);
+        if (manager && !seen.has("orchestrator")) {
+            seen.add("orchestrator");
+            sources.push({ id: "orchestrator", label: "Orchestrator", kind: "orchestrator", sessionId, updatedAt: mtime(manager), bytes: size(manager) });
+        }
+        const dir = projectDirFor(sessionId);
+        const subagents = dir ? path.join(dir, sessionId, "subagents") : undefined;
+        let entries;
+        try {
+            entries = subagents ? fs.readdirSync(subagents) : [];
+        }
+        catch {
+            entries = [];
+        }
+        for (const entry of entries) {
+            const match = entry.match(/^agent-([A-Za-z0-9_-]+)\.jsonl$/);
+            if (!match || seen.has(match[1]))
+                continue;
+            seen.add(match[1]);
+            const meta = workerMeta(sessionId, match[1]);
+            const file = path.join(subagents, entry);
+            sources.push({
+                id: match[1],
+                // The roster's name for the worker is the one already on screen
+                // elsewhere; the transcript's own description is the fallback.
+                label: input.labelFor?.(match[1]) ?? meta.description ?? match[1],
+                kind: "worker",
+                sessionId,
+                agentType: meta.agentType,
+                updatedAt: mtime(file),
+                bytes: size(file),
+            });
+        }
+    }
+    // Newest activity first among the workers; the manager always leads.
+    const workers = sources.filter((source) => source.kind === "worker").sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
+    return [...sources.filter((source) => source.kind === "orchestrator"), ...workers];
+}
+function mtime(file) {
+    try {
+        return fs.statSync(file).mtimeMs;
+    }
+    catch {
+        return undefined;
+    }
+}
+function size(file) {
+    try {
+        return fs.statSync(file).size;
+    }
+    catch {
+        return undefined;
+    }
+}
+function clamp(text, max) {
+    return text.length > max ? { text: `${text.slice(0, max)}…`, truncated: true } : { text, truncated: false };
+}
+/** A tool result's body, which the provider writes as a string or as blocks. */
+function resultText(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((item) => {
+            if (typeof item === "string")
+                return item;
+            if (item && typeof item === "object") {
+                const block = item;
+                if (typeof block.text === "string")
+                    return block.text;
+                if (block.type)
+                    return `[${block.type}]`;
+            }
+            return "";
+        })
+            .filter(Boolean)
+            .join("\n");
+    }
+    if (content && typeof content === "object")
+        return JSON.stringify(content);
+    return "";
+}
+/**
+ * How the terminal titles a tool call: the one field that says what it is
+ * doing, not the whole input object.
+ *
+ * A `Bash` whose header is `{"command":"…","description":"…"}` tells the reader
+ * nothing they could not have guessed; the command tells them everything.
+ */
+export function invocationOf(tool, input) {
+    const fields = input && typeof input === "object" ? input : {};
+    const str = (key) => (typeof fields[key] === "string" ? fields[key] : undefined);
+    const headline = str("command")
+        ?? str("file_path")
+        ?? str("path")
+        ?? str("pattern")
+        ?? str("description")
+        ?? str("query")
+        ?? str("prompt")
+        ?? str("url")
+        ?? str("skill")
+        ?? str("action")
+        ?? (Object.keys(fields).length ? JSON.stringify(fields) : "");
+    const single = headline.replace(/\s+/g, " ").trim();
+    return single ? `${tool}(${clamp(single, 200).text})` : tool;
+}
+/**
+ * Parses one transcript line into what the terminal would print, or nothing.
+ *
+ * Dropped outright: `attachment` and the provider's own bookkeeping records
+ * (titles, modes, queue operations), which have no on-screen form at all.
+ */
+function entriesFrom(raw) {
+    const ts = raw.timestamp ? Date.parse(raw.timestamp) : undefined;
+    const at = Number.isFinite(ts) ? ts : undefined;
+    const content = raw.message?.content;
+    if (raw.type === "user") {
+        // The turn's actual prompt — for a worker, its assignment.
+        if (typeof content === "string") {
+            const { text, truncated } = clamp(content.trim(), TEXT_CHARS);
+            return text ? [{ kind: "prompt", ts: at, text, truncated }] : [];
+        }
+        if (!Array.isArray(content))
+            return [];
+        const out = [];
+        for (const item of content) {
+            if (item?.type === "tool_result") {
+                const body = resultText(item.content);
+                const { text, truncated } = clamp(body.trim(), OUTPUT_CHARS);
+                out.push({
+                    kind: "tool_result",
+                    ts: at,
+                    output: text,
+                    truncated,
+                    lines: body ? body.split("\n").length : 0,
+                    isError: item.is_error === true,
+                    toolUseId: typeof item.tool_use_id === "string" ? item.tool_use_id : undefined,
+                });
+                continue;
+            }
+            if (item?.type === "text" && typeof item.text === "string") {
+                // Injected rather than typed: a skill's instructions, a system
+                // reminder, a tool's follow-up. Real in the transcript, but not a
+                // thing the user said — so it is kept and marked, not shown as a turn.
+                const injected = raw.isMeta === true || Boolean(raw.sourceToolUseID);
+                const { text, truncated } = clamp(item.text.trim(), TEXT_CHARS);
+                if (text)
+                    out.push({ kind: injected ? "injected" : "prompt", ts: at, text, truncated });
+            }
+        }
+        return out;
+    }
+    if (raw.type !== "assistant" || !Array.isArray(content))
+        return [];
+    const out = [];
+    for (const item of content) {
+        if (item?.type === "text" && typeof item.text === "string") {
+            const { text, truncated } = clamp(item.text.trim(), TEXT_CHARS);
+            if (text)
+                out.push({ kind: "assistant", ts: at, text, truncated, skill: raw.attributionSkill });
+            continue;
+        }
+        if (item?.type === "thinking") {
+            // Redacted thinking arrives as a signature with an empty body; there is
+            // nothing to show and a "Thinking" header over blank space is noise.
+            const thinking = typeof item.thinking === "string" ? item.thinking.trim() : "";
+            if (thinking) {
+                const { text, truncated } = clamp(thinking, TEXT_CHARS);
+                out.push({ kind: "thinking", ts: at, text, truncated });
+            }
+            continue;
+        }
+        if (item?.type === "tool_use" && typeof item.name === "string") {
+            out.push({
+                kind: "tool_use",
+                ts: at,
+                tool: item.name,
+                invocation: invocationOf(item.name, item.input),
+                input: clamp(JSON.stringify(item.input ?? {}, null, 2), OUTPUT_CHARS).text,
+                toolUseId: typeof item.id === "string" ? item.id : undefined,
+            });
+        }
+    }
+    return out;
+}
+/**
+ * Reads the tail of a transcript file into terminal-shaped entries.
+ *
+ * `limit` counts entries, not lines: one assistant message can produce a text
+ * block and several tool calls, and cutting mid-message would strand a tool
+ * call from the result that answers it.
+ */
+export function readTranscript(file, limit = 400) {
+    let fd;
+    try {
+        fd = fs.openSync(file, "r");
+    }
+    catch {
+        return { entries: [], truncated: false };
+    }
+    try {
+        const total = fs.fstatSync(fd).size;
+        let offset = total;
+        let entries = [];
+        // A line split across a chunk boundary: held here and prepended to the
+        // earlier chunk, which is the half that carries its beginning.
+        let partial = "";
+        while (offset > 0 && entries.length < limit && total - offset < MAX_SCAN_BYTES) {
+            const start = Math.max(0, offset - CHUNK_BYTES);
+            const buffer = Buffer.alloc(offset - start);
+            fs.readSync(fd, buffer, 0, buffer.length, start);
+            const lines = `${buffer.toString("utf8")}${partial}`.split("\n");
+            // Only a chunk that does not begin the file can begin mid-line.
+            partial = start > 0 ? lines.shift() ?? "" : "";
+            const chunk = [];
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    chunk.push(...entriesFrom(JSON.parse(trimmed)));
+                }
+                catch {
+                    continue;
+                }
+            }
+            entries = [...chunk, ...entries];
+            offset = start;
+        }
+        return {
+            entries: entries.slice(-limit),
+            truncated: offset > 0 || entries.length > limit,
+            path: file,
+            updatedAt: mtime(file),
+        };
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}

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);