claude-inspect 0.7.1 → 0.8.0

package/dist/app/server/cli.js

@@ -12,6 +12,10 @@ import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { parseArgs } from 'node:util';
+import v8 from 'node:v8';
+// Läuft dauerhaft im Hintergrund: kleiner Heap statt Höchsttempo. Gemessen mit ~1.600 Transcripts
+// 140 statt 700 MB Speicher, der erste Scan dauert dafür ~20 % länger. Keine harte Grenze.
+v8.setFlagsFromString('--optimize-for-size');
 const env = process.env;
 function version() {
     const here = dirname(fileURLToPath(import.meta.url));

package/dist/app/server/history/aggregator.js

@@ -5,6 +5,22 @@ import { toolSummary } from '../../shared/tools.js';
 import { registry } from '../formats/index.js';
 import { subagentDir } from '../sources/subagents.js';
 import { JsonlTail } from '../util/jsonl.js';
+/** Wiederkehrende Texte (Modell- und Tool-Namen) nur einmal im Speicher halten. */
+const interned = new Map();
+function intern(s) {
+    let v = interned.get(s);
+    if (v === undefined)
+        interned.set(s, (v = s));
+    return v;
+}
+/**
+ * Eigene Kopie eines gekürzten Strings. V8 legt Teilstrings als Verweis auf den Ausgangstext an –
+ * eine 200-Zeichen-Zusammenfassung hielte sonst den kompletten (evtl. mehrere KB großen) Befehl fest.
+ */
+function own(s) {
+    return s.length < 13 ? s : Buffer.from(s, 'utf8').toString('utf8');
+}
+const CHUNK_BYTES = 2 * 1024 * 1024;
 const FILE_TOOLS = {
     Read: 'reads',
     Edit: 'edits',
@@ -110,19 +126,22 @@ export class HistoryIndex {
         }
         agg.size = size;
         agg.project = project;
-        let lines;
-        try {
-            ({ lines } = await agg.tail.readNew());
-        }
-        catch {
-            return;
-        }
-        for (const l of lines) {
-            if (l.value === undefined)
-                continue;
-            const { out } = registry.decode('transcript', l.value, path, l.line, { silent: true });
-            for (const e of out)
-                this.fold(agg, e);
+        // in Stücken lesen: große Transcripts (50–100 MB) nicht komplett geparst im Speicher halten
+        for (let more = true; more;) {
+            let lines;
+            try {
+                ({ lines, more } = await agg.tail.readNew(undefined, CHUNK_BYTES));
+            }
+            catch {
+                return;
+            }
+            for (const l of lines) {
+                if (l.value === undefined)
+                    continue;
+                const { out } = registry.decode('transcript', l.value, path, l.line, { silent: true });
+                for (const e of out)
+                    this.fold(agg, e);
+            }
         }
     }
     fold(agg, e) {
@@ -144,8 +163,8 @@ export class HistoryIndex {
                     agentId: agg.agentId,
                     project: agg.project,
                     toolUseId: e.toolUseId,
-                    name: e.name,
-                    summary: toolSummary(e.name, e.input).slice(0, 200),
+                    name: intern(e.name),
+                    summary: own(toolSummary(e.name, e.input).slice(0, 200)),
                     ts: Number.isNaN(ts) ? 0 : ts,
                     file,
                 });
@@ -168,7 +187,9 @@ export class HistoryIndex {
                 break;
         }
         if ((e.kind === 'assistant-text' || e.kind === 'thinking' || e.kind === 'tool-use') && e.usage && e.messageId && e.model && e.model !== '<synthetic>') {
-            agg.usage.set(e.messageId, { model: e.model, ts: Number.isNaN(ts) ? 0 : ts, usage: e.usage });
+            const tokens = emptyTotals();
+            addUsage(tokens, e.usage);
+            agg.usage.set(e.messageId, { model: intern(e.model), ts: Number.isNaN(ts) ? 0 : ts, tokens });
         }
     }
     // ---------------------------------------------------------------------------
@@ -209,8 +230,7 @@ export class HistoryIndex {
             for (const u of a.usage.values()) {
                 if (u.ts < since)
                     continue;
-                const one = emptyTotals();
-                addUsage(one, u.usage);
+                const one = u.tokens;
                 let m = byModel.get(u.model);
                 if (!m)
                     byModel.set(u.model, (m = emptyTotals()));
@@ -307,12 +327,9 @@ export class HistoryIndex {
                 let t = out.get(u.model);
                 if (!t)
                     out.set(u.model, (t = emptyTotals()));
-                addUsage(t, u.usage);
-                if (each) {
-                    const one = emptyTotals();
-                    addUsage(one, u.usage);
-                    each(u.model, u.ts, one);
-                }
+                mergeTotals(t, u.tokens);
+                if (each)
+                    each(u.model, u.ts, { ...u.tokens });
             }
         }
         return out;

package/dist/app/server/history/search.js

@@ -1,8 +1,11 @@
 import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
 import { toolSummary } from '../../shared/tools.js';
 import { paths } from '../config.js';
 import { registry } from '../formats/index.js';
 import { pathTail } from '../sources/projects.js';
+const home = homedir();
+const tildify = (p) => (home && p.startsWith(home) ? '~' + p.slice(home.length) : p);
 function snippet(text, needle, radius = 90) {
     const i = text.toLowerCase().indexOf(needle);
     if (i < 0)
@@ -33,7 +36,7 @@ function searchable(e) {
  * nach dem Suchbegriff durchsucht, nur Trefferzeilen werden dekodiert.
  * Neueste Dateien zuerst; bricht bei `limit` Treffern oder nach `budgetMs` ab.
  */
-export async function search(query, files, knownSessions, limit = 200, budgetMs = 6000, perFile = 5) {
+export async function search(query, files, knownSessions, limit = 200, budgetMs = 15_000, perFile = 5) {
     const t0 = Date.now();
     const needle = query.trim().toLowerCase();
     const hits = [];
@@ -41,6 +44,16 @@ export async function search(query, files, knownSessions, limit = 200, budgetMs
     let truncated = false;
     if (needle.length < 2)
         return { query, hits, scannedFiles: 0, totalFiles: files.length, truncated, ms: 0 };
+    // Dateinamen und Pfade der Transcripts (z. B. "agent-a1b2….jsonl", Session-Id, Pfadteile)
+    const pathNeedle = (needle.startsWith('~') && home ? home.toLowerCase() + needle.slice(1) : needle).replace(/\\/g, '/');
+    for (const f of files) {
+        const p = f.path.replace(/\\/g, '/');
+        if (!p.toLowerCase().includes(pathNeedle))
+            continue;
+        hits.push({ sessionId: f.sessionId, agentId: f.agentId, project: f.project, title: f.title, line: 0, kind: 'file', snippet: tildify(f.path) });
+        if (hits.length >= 50)
+            break;
+    }
     outer: for (const f of files) {
         if (Date.now() - t0 > budgetMs) {
             truncated = true;

package/dist/app/server/inspector.js

@@ -1,6 +1,7 @@
 import { EventEmitter } from 'node:events';
 import { watch } from 'node:fs';
 import { stat } from 'node:fs/promises';
+import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
 import { CLAUDE_DIR, DATA_DIR, relToClaude } from './config.js';
 import { buildDigest } from './review/digest.js';
@@ -483,14 +484,62 @@ export class Inspector extends EventEmitter {
     }
     async search(q) {
         const files = [];
+        const subMeta = new Map();
         for (const f of this.index.list()) {
             const sum = await this.index.summary(f);
             files.push({ path: f.path, sessionId: f.sessionId, project: sum.project, title: sum.title });
             for (const sf of await listSubagents(f.path)) {
                 files.push({ path: sf.path, sessionId: f.sessionId, agentId: sf.agentId, project: sum.project, title: sf.meta.description ?? sum.title });
+                subMeta.set(`${f.sessionId}/${sf.agentId}`, { type: sf.meta.agentType, description: sf.meta.description, path: sf.path });
             }
         }
-        return search(q, files, new Set(this.index.list().map((f) => f.sessionId)));
+        const res = await search(q, files, new Set(this.index.list().map((f) => f.sessionId)));
+        // Agenten der Treffer samt Vorfahren (Hauptagent, per claude -p aufrufender Agent) für die Baumansicht
+        const agents = {};
+        const home = homedir();
+        const tilde = (p) => (home && p.startsWith(home) ? '~' + p.slice(home.length) : p);
+        const add = async (sessionId, agentId, depth = 0) => {
+            const key = agentId ? `${sessionId}/${agentId}` : sessionId;
+            if (agents[key])
+                return key;
+            const f = this.index.get(sessionId);
+            if (!f || depth > 8)
+                return undefined;
+            const sum = await this.index.summary(f);
+            if (agentId) {
+                const m = subMeta.get(key);
+                agents[key] = {
+                    key,
+                    sessionId,
+                    agentId,
+                    kind: 'subagent',
+                    label: m?.type ?? 'subagent',
+                    sublabel: m?.description,
+                    project: sum.project,
+                    parentKey: await add(sessionId, undefined, depth + 1),
+                    file: tilde(m?.path ?? f.path),
+                };
+                return key;
+            }
+            const link = this.spawns.parentOf(sessionId);
+            const proc = this.processes.find((p) => p.sessionId === sessionId);
+            agents[key] = {
+                key,
+                sessionId,
+                kind: link ? 'spawn' : 'main',
+                label: proc?.name ?? sum.title ?? sessionId.slice(0, 8),
+                sublabel: link ? (this.spawns.childInfo(sessionId)?.agentSetting ?? 'claude -p') : undefined,
+                project: sum.project,
+                file: tilde(f.path),
+            };
+            if (link)
+                agents[key].parentKey = await add(link.parentSessionId, link.parentAgentId, depth + 1);
+            return key;
+        };
+        for (const h of res.hits)
+            if (h.kind !== 'history-prompt')
+                await add(h.sessionId, h.agentId);
+        return { ...res, agents };
     }
     /**
      * Ablauf einer Session für Zeitleiste und Graph: Hauptagent, Subagenten

package/dist/app/server/sources/spawns.js

@@ -189,19 +189,23 @@ export class SpawnIndex {
         }
         st.size = size;
         try {
-            const { lines, reset } = await st.tail.readNew((t) => t.includes('"Bash"') && t.includes('claude'));
-            if (reset)
-                st.calls = [];
-            for (const l of lines) {
-                const raw = l.value;
-                if (!isObj(raw) || raw.type !== 'assistant')
-                    continue;
-                const content = obj(raw.message)?.content;
-                if (!Array.isArray(content))
-                    continue;
-                for (const b of content) {
-                    if (isObj(b) && b.type === 'tool_use' && b.name === 'Bash')
-                        st.calls.push(...parseCall(raw, b, sessionId, agentId));
+            // in Stücken lesen, damit große Dateien nicht komplett im Speicher landen
+            for (let more = true; more;) {
+                const r = await st.tail.readNew((t) => t.includes('"Bash"') && t.includes('claude'), 8 * 1024 * 1024);
+                more = r.more;
+                if (r.reset)
+                    st.calls = [];
+                for (const l of r.lines) {
+                    const raw = l.value;
+                    if (!isObj(raw) || raw.type !== 'assistant')
+                        continue;
+                    const content = obj(raw.message)?.content;
+                    if (!Array.isArray(content))
+                        continue;
+                    for (const b of content) {
+                        if (isObj(b) && b.type === 'tool_use' && b.name === 'Bash')
+                            st.calls.push(...parseCall(raw, b, sessionId, agentId));
+                    }
                 }
             }
         }

package/dist/app/server/util/jsonl.js

@@ -22,8 +22,10 @@ export class JsonlTail {
     /**
      * @param prefilter Optional: nur Zeilen parsen, deren Rohtext passt (spart bei
      *                  großen Dateien den Großteil der JSON.parse-Arbeit).
+     * @param maxBytes  Optional: höchstens so viel lesen; `more` sagt, ob noch etwas folgt.
+     *                  Hält den Speicherbedarf bei großen Dateien klein (statt alles auf einmal).
      */
-    async readNew(prefilter) {
+    async readNew(prefilter, maxBytes = Infinity) {
         const st = await stat(this.path);
         let reset = false;
         if (st.size < this.offset) {
@@ -34,10 +36,10 @@ export class JsonlTail {
             reset = true;
         }
         if (st.size === this.offset)
-            return { lines: [], reset };
+            return { lines: [], reset, more: false };
         const fh = await open(this.path, 'r');
         try {
-            const len = st.size - this.offset;
+            const len = Math.min(st.size - this.offset, maxBytes);
             const buf = Buffer.alloc(len);
             const { bytesRead } = await fh.read(buf, 0, len, this.offset);
             const chunk = Buffer.concat([this.leftover, buf.subarray(0, bytesRead)]);
@@ -53,7 +55,7 @@ export class JsonlTail {
                 start = i + 1;
             }
             this.leftover = Buffer.from(chunk.subarray(start));
-            return { lines, reset };
+            return { lines, reset, more: this.offset < st.size };
         }
         finally {
             await fh.close();