@shanesaravia/hive 0.3.0 → 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);
+    }
+}