@alexjbarnes/cockpit 0.1.1 → 0.3.0

package/dist/src/server/transcript.js

@@ -3,27 +3,65 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTranscriptPath = getTranscriptPath;
 exports.transcriptExists = transcriptExists;
+exports.deleteTranscript = deleteTranscript;
+exports.countTranscriptMessages = countTranscriptMessages;
 exports.readMoreLines = readMoreLines;
 exports.loadLastUsage = loadLastUsage;
 exports.loadTranscript = loadTranscript;
+exports.loadPromptHistory = loadPromptHistory;
+exports.loadLastAssistantMessage = loadLastAssistantMessage;
 exports.loadMoreMessages = loadMoreMessages;
 exports.findSessionCwd = findSessionCwd;
 exports.scanAllSessions = scanAllSessions;
+exports.scanSessionsForCwd = scanSessionsForCwd;
+exports.scanSessionsByIds = scanSessionsByIds;
+exports.listAllTranscriptFiles = listAllTranscriptFiles;
+exports.findTranscriptFile = findTranscriptFile;
+exports.checkNonAnthropicThinking = checkNonAnthropicThinking;
+exports.stripNonAnthropicThinking = stripNonAnthropicThinking;
+exports.globalSearch = globalSearch;
 const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
-const node_os_1 = require("node:os");
 const node_path_1 = __importDefault(require("node:path"));
 const node_readline_1 = require("node:readline");
 const uuid_1 = require("uuid");
+const paths_1 = require("../server/paths");
 const debug_logger_1 = require("./debug-logger");
+const session_prefs_1 = require("./session-prefs");
 function getTranscriptPath(sessionId, cwd) {
     const projectKey = cwd.replace(/[/.]/g, "-");
-    return node_path_1.default.join((0, node_os_1.homedir)(), ".claude", "projects", projectKey, `${sessionId}.jsonl`);
+    return node_path_1.default.join((0, paths_1.getClaudeDir)(), "projects", projectKey, `${sessionId}.jsonl`);
 }
 function transcriptExists(sessionId, cwd) {
     return (0, node_fs_1.existsSync)(getTranscriptPath(sessionId, cwd));
 }
+async function deleteTranscript(sessionId, cwd) {
+    const fp = getTranscriptPath(sessionId, cwd);
+    if (!(0, node_fs_1.existsSync)(fp))
+        return false;
+    await (0, promises_1.unlink)(fp);
+    return true;
+}
+function countTranscriptMessages(sessionId, cwd) {
+    const fp = getTranscriptPath(sessionId, cwd);
+    if (!(0, node_fs_1.existsSync)(fp))
+        return 0;
+    try {
+        const raw = (0, node_fs_1.readFileSync)(fp, "utf-8");
+        let count = 0;
+        for (const line of raw.split("\n")) {
+            if (line.includes('"role"') && (line.includes('"assistant"') || line.includes('"user"'))) {
+                count++;
+            }
+        }
+        return count;
+    }
+    catch {
+        return 0;
+    }
+}
 const CLI_XML_RE = /<(?:task-notification|local-command-caveat|local-command-stdout|system-reminder)[^>]*>[\s\S]*?<\/(?:task-notification|local-command-caveat|local-command-stdout|system-reminder)>[\s\S]*/g;
 const FILE_TAG_RE = /<file\s+path="([^"]+)">\n([\s\S]*?)\n<\/file>/g;
 function extractTextFiles(text) {
@@ -45,13 +83,14 @@ function stripCommandXml(text) {
         return "";
     if (trimmed.startsWith("<local-command-stdout>"))
         return "";
-    if (trimmed.startsWith("<command-name>")) {
+    if (trimmed.startsWith("<command-name>") || trimmed.startsWith("<command-message>") || trimmed.startsWith("<command-args>")) {
         const match = trimmed.match(/<command-name>(\/[^<]+)<\/command-name>/);
         if (match) {
             if (match[1] === "/compact")
                 return "";
             return match[1];
         }
+        return "";
     }
     return text;
 }
@@ -106,9 +145,6 @@ async function readTailLines(filePath, targetCount) {
             }
             // Not enough lines, double chunk and retry
             chunkSize *= 2;
-            if (chunkSize >= totalSize) {
-                return { lines, byteOffset: 0, totalSize };
-            }
         }
     }
     finally {
@@ -154,9 +190,6 @@ async function readMoreLines(filePath, byteOffset, targetCount) {
                 return { lines: result, newByteOffset: offset === 0 ? 0 : newByteOffset };
             }
             chunkSize *= 2;
-            if (chunkSize >= byteOffset) {
-                return { lines, newByteOffset: 0 };
-            }
         }
     }
     finally {
@@ -255,7 +288,7 @@ function parseLines(lines) {
                             name: block.name || "unknown",
                             input: block.input ? JSON.stringify(block.input) : "",
                             output: "",
-                            status: "done",
+                            status: "running",
                         };
                         parentTool.children.push(child);
                         toolUseMap.set(child.id, child);
@@ -403,7 +436,7 @@ function parseLines(lines) {
                         name: block.name || "unknown",
                         input: block.input ? JSON.stringify(block.input) : "",
                         output: "",
-                        status: "done",
+                        status: "running",
                     };
                     toolUses.push(tool);
                     blocks.push({ type: "tool_use", toolUse: tool });
@@ -481,6 +514,65 @@ async function loadTranscript(sessionId, cwd, options) {
     (0, debug_logger_1.debugLog)(`[transcript:${sid}] ${readLabel}: ${lines.length} lines, ${messages.length} msgs | read=${(tRead - t0).toFixed(0)}ms parse=${(tParse - tRead).toFixed(0)}ms total=${(tParse - t0).toFixed(0)}ms`);
     return { messages, byteOffset, totalSize, lastUsage };
 }
+const COMPACTION_PREFIX = "This session is being continued from a previous conversation";
+const STRIP_ATTACHMENTS_RE = /^\[Attached [^\]]+\]\n*/gm;
+async function loadPromptHistory(sessionId, cwd) {
+    const fp = getTranscriptPath(sessionId, cwd);
+    if (!(0, node_fs_1.existsSync)(fp))
+        return [];
+    const seen = new Set();
+    const prompts = [];
+    const rl = (0, node_readline_1.createInterface)({ input: (0, node_fs_1.createReadStream)(fp, "utf-8"), crlfDelay: Infinity });
+    for await (const line of rl) {
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (entry.type !== "user" || !entry.message)
+            continue;
+        const content = entry.message.content;
+        let text = "";
+        if (typeof content === "string") {
+            text = stripCommandXml(content);
+        }
+        else if (Array.isArray(content)) {
+            const hasToolResults = content.some((b) => b.type === "tool_result");
+            if (hasToolResults)
+                continue;
+            text = content
+                .filter((b) => b.type === "text" && b.text)
+                .map((b) => b.text)
+                .join("\n");
+            if (text)
+                text = stripCommandXml(text);
+        }
+        text = text.replace(STRIP_ATTACHMENTS_RE, "").trim();
+        if (!text || text.startsWith("/"))
+            continue;
+        if (text.startsWith(COMPACTION_PREFIX))
+            continue;
+        if (text.startsWith("<") && text.includes("system-reminder"))
+            continue;
+        if (seen.has(text)) {
+            prompts.splice(prompts.indexOf(text), 1);
+        }
+        seen.add(text);
+        prompts.push(text);
+    }
+    prompts.reverse();
+    return prompts;
+}
+async function loadLastAssistantMessage(cliSessionId, cwd) {
+    const { messages } = await loadTranscript(cliSessionId, cwd, { tailLines: 100 });
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === "assistant")
+            return messages[i];
+    }
+    return null;
+}
 async function loadMoreMessages(sessionId, cwd, byteOffset, targetLines) {
     if (byteOffset <= 0)
         return { messages: [], newByteOffset: 0 };
@@ -576,7 +668,7 @@ async function extractSessionMeta(filePath) {
     }
 }
 async function findSessionCwd(sessionId) {
-    const projectsDir = node_path_1.default.join((0, node_os_1.homedir)(), ".claude", "projects");
+    const projectsDir = node_path_1.default.join((0, paths_1.getClaudeDir)(), "projects");
     if (!(0, node_fs_1.existsSync)(projectsDir))
         return null;
     let projectDirs;
@@ -599,7 +691,7 @@ async function findSessionCwd(sessionId) {
     return null;
 }
 async function scanAllSessions() {
-    const projectsDir = node_path_1.default.join((0, node_os_1.homedir)(), ".claude", "projects");
+    const projectsDir = node_path_1.default.join((0, paths_1.getClaudeDir)(), "projects");
     if (!(0, node_fs_1.existsSync)(projectsDir))
         return [];
     let projectDirs;
@@ -646,6 +738,7 @@ async function scanAllSessions() {
             cwd,
             dirName: node_path_1.default.basename(cwd) || cwd,
             sessions,
+            totalSessionCount: sessions.length,
         });
     }
     result.sort((a, b) => {
@@ -655,3 +748,341 @@ async function scanAllSessions() {
     });
     return result;
 }
+function metaToSessionInfo(meta) {
+    const prefs = (0, session_prefs_1.getSessionPrefs)(meta.id);
+    return {
+        id: meta.id,
+        name: prefs?.name || meta.title,
+        cwd: meta.cwd,
+        createdAt: meta.createdAt,
+        lastActiveAt: meta.lastActiveAt,
+        status: "idle",
+        model: prefs?.model,
+        runtime: prefs?.runtime,
+        pendingRequestCount: 0,
+    };
+}
+async function scanSessionsForCwd(targetCwd) {
+    const projectsDir = node_path_1.default.join((0, paths_1.getClaudeDir)(), "projects");
+    if (!(0, node_fs_1.existsSync)(projectsDir))
+        return [];
+    let projectDirs;
+    try {
+        projectDirs = await (0, promises_1.readdir)(projectsDir);
+    }
+    catch {
+        return [];
+    }
+    const results = [];
+    for (const dir of projectDirs) {
+        const dirPath = node_path_1.default.join(projectsDir, dir);
+        let files;
+        try {
+            files = await (0, promises_1.readdir)(dirPath);
+        }
+        catch {
+            continue;
+        }
+        const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
+        const metas = await Promise.all(jsonlFiles.map((f) => extractSessionMeta(node_path_1.default.join(dirPath, f))));
+        for (const meta of metas) {
+            if (meta && meta.cwd === targetCwd) {
+                results.push(metaToSessionInfo(meta));
+            }
+        }
+    }
+    results.sort((a, b) => b.lastActiveAt - a.lastActiveAt);
+    return results;
+}
+async function scanSessionsByIds(ids) {
+    if (ids.length === 0)
+        return [];
+    const projectsDir = node_path_1.default.join((0, paths_1.getClaudeDir)(), "projects");
+    if (!(0, node_fs_1.existsSync)(projectsDir))
+        return [];
+    let projectDirs;
+    try {
+        projectDirs = await (0, promises_1.readdir)(projectsDir);
+    }
+    catch {
+        return [];
+    }
+    const idSet = new Set(ids);
+    const results = [];
+    for (const dir of projectDirs) {
+        if (idSet.size === 0)
+            break;
+        const dirPath = node_path_1.default.join(projectsDir, dir);
+        let files;
+        try {
+            files = await (0, promises_1.readdir)(dirPath);
+        }
+        catch {
+            continue;
+        }
+        const matching = files.filter((f) => f.endsWith(".jsonl") && idSet.has(f.slice(0, -".jsonl".length)));
+        if (matching.length === 0)
+            continue;
+        const metas = await Promise.all(matching.map((f) => extractSessionMeta(node_path_1.default.join(dirPath, f))));
+        for (const meta of metas) {
+            if (meta) {
+                results.push(metaToSessionInfo(meta));
+                idSet.delete(meta.id);
+            }
+        }
+    }
+    return results;
+}
+async function listAllTranscriptFiles() {
+    const projectsDir = node_path_1.default.join((0, paths_1.getClaudeDir)(), "projects");
+    if (!(0, node_fs_1.existsSync)(projectsDir))
+        return [];
+    let projectDirs;
+    try {
+        projectDirs = await (0, promises_1.readdir)(projectsDir);
+    }
+    catch {
+        return [];
+    }
+    const results = [];
+    for (const dir of projectDirs) {
+        if (dir.includes(".cockpit"))
+            continue;
+        const dirPath = node_path_1.default.join(projectsDir, dir);
+        let files;
+        try {
+            files = await (0, promises_1.readdir)(dirPath);
+        }
+        catch {
+            continue;
+        }
+        for (const f of files) {
+            if (!f.endsWith(".jsonl"))
+                continue;
+            const filePath = node_path_1.default.join(dirPath, f);
+            try {
+                const s = await (0, promises_1.stat)(filePath);
+                results.push({ filePath, sessionId: f.slice(0, -6), mtimeMs: s.mtimeMs });
+            }
+            catch { }
+        }
+    }
+    results.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return results;
+}
+async function findTranscriptFile(sessionId) {
+    const projectsDir = node_path_1.default.join((0, paths_1.getClaudeDir)(), "projects");
+    if (!(0, node_fs_1.existsSync)(projectsDir))
+        return null;
+    let projectDirs;
+    try {
+        projectDirs = await (0, promises_1.readdir)(projectsDir);
+    }
+    catch {
+        return null;
+    }
+    const filename = `${sessionId}.jsonl`;
+    for (const dir of projectDirs) {
+        const filePath = node_path_1.default.join(projectsDir, dir, filename);
+        if ((0, node_fs_1.existsSync)(filePath))
+            return filePath;
+    }
+    return null;
+}
+async function checkNonAnthropicThinking(filePath) {
+    const raw = await (0, promises_1.readFile)(filePath, "utf-8");
+    let count = 0;
+    const models = new Set();
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (entry.type !== "assistant" || !entry.message)
+            continue;
+        const model = entry.message.model || "";
+        if (model.startsWith("claude"))
+            continue;
+        const content = entry.message.content;
+        if (!Array.isArray(content))
+            continue;
+        const hasThinking = content.some((b) => typeof b === "object" && b !== null && b.type === "thinking");
+        if (hasThinking) {
+            count++;
+            if (model)
+                models.add(model);
+        }
+    }
+    return { hasNonAnthropicThinking: count > 0, count, models: [...models] };
+}
+async function stripNonAnthropicThinking(filePath) {
+    const raw = await (0, promises_1.readFile)(filePath, "utf-8");
+    const lines = raw.split("\n");
+    const output = [];
+    let stripped = 0;
+    for (const line of lines) {
+        if (!line.trim()) {
+            output.push(line);
+            continue;
+        }
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            output.push(line);
+            continue;
+        }
+        if (entry.type !== "assistant" || !entry.message) {
+            output.push(line);
+            continue;
+        }
+        const model = entry.message.model || "";
+        if (model.startsWith("claude")) {
+            output.push(line);
+            continue;
+        }
+        const content = entry.message.content;
+        if (!Array.isArray(content)) {
+            output.push(line);
+            continue;
+        }
+        const filtered = content.filter((b) => !(typeof b === "object" && b !== null && b.type === "thinking"));
+        if (filtered.length !== content.length) {
+            stripped++;
+            entry.message.content = filtered;
+            output.push(JSON.stringify(entry));
+        }
+        else {
+            output.push(line);
+        }
+    }
+    await (0, promises_1.writeFile)(filePath, output.join("\n"));
+    return stripped;
+}
+async function globalSearch(query, limit, offset = 0) {
+    const MAX_FILES = 500;
+    const MAX_PARSED_BASE = 30;
+    const MAX_PER_FILE = 10;
+    const effectiveLimit = Math.min(limit, 100);
+    const lowerQuery = query.toLowerCase();
+    // When paginating, allow parsing more files to reach the offset
+    const maxParsed = MAX_PARSED_BASE + Math.ceil(offset / MAX_PER_FILE);
+    const files = await listAllTranscriptFiles();
+    const searchFiles = files.slice(0, MAX_FILES);
+    const results = [];
+    let totalFound = 0;
+    let filesParsed = 0;
+    let truncated = false;
+    for (const file of searchFiles) {
+        if (results.length >= effectiveLimit || filesParsed >= maxParsed) {
+            truncated = true;
+            break;
+        }
+        let raw;
+        try {
+            raw = await (0, promises_1.readFile)(file.filePath, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        if (!raw.toLowerCase().includes(lowerQuery))
+            continue;
+        filesParsed++;
+        const lines = raw.split(/\r?\n/).filter((l) => l.trim());
+        const { messages } = parseLines(lines);
+        let cwd = "";
+        let sessionTitle = "";
+        for (let j = 0; j < Math.min(lines.length, 50); j++) {
+            try {
+                const entry = JSON.parse(lines[j]);
+                if (entry.type === "user" && entry.cwd && !cwd)
+                    cwd = entry.cwd;
+                if (entry.type === "user" && entry.message && !sessionTitle) {
+                    const content = entry.message.content;
+                    let candidate = "";
+                    if (typeof content === "string")
+                        candidate = content;
+                    else if (Array.isArray(content)) {
+                        const tb = content.find((b) => b.type === "text" && b.text);
+                        if (tb?.text)
+                            candidate = tb.text;
+                    }
+                    if (candidate && !candidate.startsWith("[") && !candidate.startsWith("<")) {
+                        sessionTitle = candidate.slice(0, 120);
+                    }
+                }
+                if (cwd && sessionTitle)
+                    break;
+            }
+            catch { }
+        }
+        if (!cwd)
+            continue;
+        if (cwd.endsWith(".cockpit/reviews") || cwd.endsWith(".cockpit/jobs"))
+            continue;
+        const dirName = node_path_1.default.basename(cwd) || cwd;
+        let fileResults = 0;
+        for (let i = 0; i < messages.length; i++) {
+            if (fileResults >= MAX_PER_FILE || results.length >= effectiveLimit)
+                break;
+            const msg = messages[i];
+            if (msg.role !== "user" && msg.role !== "assistant")
+                continue;
+            if (i > 0 && messages[i - 1].content === "__compacted__")
+                continue;
+            if (i > 1 && messages[i - 2].content === "__compacted__")
+                continue;
+            let text = "";
+            if (msg.blocks && msg.blocks.length > 0) {
+                text = msg.blocks
+                    .filter((b) => b.type === "text")
+                    .map((b) => b.text)
+                    .join("\n");
+            }
+            if (!text && typeof msg.content === "string") {
+                text = msg.content;
+            }
+            if (!text)
+                continue;
+            const matchIndex = text.toLowerCase().indexOf(lowerQuery);
+            if (matchIndex === -1)
+                continue;
+            totalFound++;
+            fileResults++;
+            if (totalFound <= offset)
+                continue;
+            const previewStart = Math.max(0, matchIndex - 100);
+            const previewEnd = Math.min(text.length, matchIndex + query.length + 100);
+            let preview = text.slice(previewStart, previewEnd);
+            let matchStart = matchIndex - previewStart;
+            if (previewStart > 0) {
+                preview = "..." + preview;
+                matchStart += 3;
+            }
+            if (previewEnd < text.length) {
+                preview = preview + "...";
+            }
+            results.push({
+                sessionId: file.sessionId,
+                sessionName: sessionTitle || "Untitled session",
+                cwd,
+                dirName,
+                messageId: msg.id,
+                role: msg.role,
+                timestamp: msg.timestamp,
+                preview,
+                matchStart,
+                matchLength: query.length,
+                fullContent: text.length > 2000 ? text.slice(0, 2000) + "..." : text,
+            });
+        }
+    }
+    results.sort((a, b) => b.timestamp - a.timestamp);
+    return { results, totalFilesSearched: searchFiles.length, truncated };
+}