promptcase 1.0.4

package/dist/services/claude-capture.js

@@ -0,0 +1,368 @@
+/**
+ * Claude prompt capture service
+ *
+ * Reads prompts from ~/.claude/ directory.
+ *
+ * Data sources:
+ * - ~/.claude/projects/[encoded-cwd]/[session-id].jsonl  (project transcripts, one file per session)
+ * - ~/.claude/history.jsonl                              (global prompt history, display-only)
+ *
+ * The encoded-cwd format replaces "/" with "-" (e.g. "-Users-siddhikagupta-Desktop-PromptCase"
+ * decodes to "/Users/siddhikagupta/Desktop/PromptCase").
+ *
+ * Each .jsonl project file has lines like:
+ *   {"type":"user","message":{"role":"user","content":[...]},"timestamp":"...","sessionId":"..."}
+ *   {"type":"queue-operation","operation":"enqueue",...}     (skip)
+ *   {"type":"assistant",...}                                 (skip)
+ *
+ * We extract only `type === "user"` lines and skip noise like
+ * `<local-command-caveat>`, `<ide_opened_file>`, `<command-name>`, and
+ * `isMeta: true` system messages.
+ */
+import { promises as fs, createReadStream } from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as readline from 'node:readline';
+import { createHash } from 'crypto';
+import { PROMPT_MIN_LENGTH } from '../lib/constants.js';
+const MIN_PROMPT_LENGTH = PROMPT_MIN_LENGTH;
+// Patterns that indicate non-prompt content (system/meta messages). We
+// strip these from joined text; if nothing meaningful remains, the
+// entry is skipped entirely.
+const NOISE_PATTERNS = [
+    /^<local-command-caveat>/i,
+    /^<local-command-stdout>/i,
+    /^<local-command-stderr>/i,
+    /^<ide_opened_file>/i,
+    /^<command-name>/i,
+    /^<command-message>/i,
+    /^<command-args>/i,
+];
+const HTML_TAG = /<[^>]+>/g;
+// Compiled once at module load — replaces the runtime regex allocation
+// that the original code did for every prompt.
+const NOISE_PEEK = /^<local-command-|^<ide_opened|^<command-/i;
+export class ClaudeCaptureService {
+    claudeDir;
+    historyFile;
+    projectsDir;
+    constructor() {
+        this.claudeDir = path.join(os.homedir(), '.claude');
+        this.historyFile = path.join(this.claudeDir, 'history.jsonl');
+        this.projectsDir = path.join(this.claudeDir, 'projects');
+    }
+    /**
+     * Get all Claude sessions from projects directory.
+     *
+     * Real layout: each subdirectory under `~/.claude/projects/` represents a
+     * working directory (path with "/" replaced by "-"). Inside that, each
+     * `*.jsonl` file is one session (filename = sessionId).
+     *
+     * All disk IO is non-blocking — important because users on machines
+     * with hundreds of session files shouldn't have the event loop stalled
+     * by `statSync` per file.
+     */
+    async getSessions() {
+        let projectEntries;
+        try {
+            projectEntries = await fs.readdir(this.projectsDir, { withFileTypes: true });
+        }
+        catch {
+            return [];
+        }
+        const sessions = [];
+        for (const projectEntry of projectEntries) {
+            if (!projectEntry.isDirectory())
+                continue;
+            if (projectEntry.name.startsWith('.'))
+                continue;
+            const projectDirPath = path.join(this.projectsDir, projectEntry.name);
+            const projectPath = this.decodeProjectPath(projectEntry.name);
+            let files;
+            try {
+                files = await fs.readdir(projectDirPath);
+            }
+            catch {
+                continue;
+            }
+            const jsonlFiles = files.filter((f) => f.endsWith('.jsonl') && !f.startsWith('.'));
+            // Stat all files in one parallel batch — fs.stat on macOS is a per-file
+            // syscall, batching with Promise.all is significantly faster than
+            // statSync in a loop.
+            const stats = await Promise.all(jsonlFiles.map((file) => fs.stat(path.join(projectDirPath, file)).then((s) => ({ file, stat: s }), () => null)));
+            for (const entry of stats) {
+                if (!entry)
+                    continue;
+                const sessionId = entry.file.replace(/\.jsonl$/, '');
+                sessions.push({
+                    id: sessionId,
+                    projectId: sessionId,
+                    projectPath,
+                    startedAt: entry.stat.birthtime,
+                    lastModified: entry.stat.mtime,
+                });
+            }
+        }
+        return sessions.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+    }
+    /**
+     * Decode an encoded cwd directory name back to a real path.
+     * "-Users-siddhikagupta-Desktop-PromptCase" → "/Users/siddhikagupta/Desktop/PromptCase"
+     */
+    decodeProjectPath(encoded) {
+        return '/' + encoded.replace(/^-/, '').replace(/-/g, '/');
+    }
+    /**
+     * Encode a real project path to its directory name under projects/.
+     * Inverse of `decodeProjectPath`. Used to locate session files for a given
+     * session record returned from `getSessions()`.
+     */
+    encodeProjectPath(projectPath) {
+        return '-' + projectPath.replace(/^\//, '').replace(/\//g, '-');
+    }
+    /**
+     * Parse user prompts from a session file. Streams the file line by line
+     * so we don't have to load multi-MB transcripts into memory.
+     */
+    async parseSessionPrompts(sessionFile, projectPath) {
+        let stream;
+        try {
+            stream = createReadStream(sessionFile);
+        }
+        catch {
+            return [];
+        }
+        const rl = readline.createInterface({
+            input: stream,
+            crlfDelay: Infinity,
+        });
+        const prompts = [];
+        let messageIndex = 0;
+        const sessionId = path.basename(sessionFile, '.jsonl');
+        try {
+            for await (const line of rl) {
+                if (!line.trim())
+                    continue;
+                let parsed;
+                try {
+                    parsed = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                // Only user-typed messages; skip assistant/queue-operation/meta entries.
+                if (parsed.type !== 'user')
+                    continue;
+                if (parsed.isMeta === true)
+                    continue;
+                const content = this.extractPromptText(parsed);
+                if (!content)
+                    continue;
+                const trimmed = content.trim();
+                if (trimmed.length < MIN_PROMPT_LENGTH)
+                    continue;
+                if (this.isOnlyNoise(trimmed))
+                    continue;
+                const timestamp = parsed.timestamp
+                    ? new Date(parsed.timestamp)
+                    : parsed.captured_at
+                        ? new Date(parsed.captured_at)
+                        : new Date();
+                prompts.push({
+                    id: parsed.uuid || `msg_${sessionId}_${messageIndex}`,
+                    content: trimmed,
+                    timestamp,
+                    sessionId: parsed.sessionId || sessionId,
+                    projectPath,
+                    messageIndex: messageIndex++,
+                });
+            }
+        }
+        finally {
+            // Always release the file handle when we're done, even if the
+            // consumer broke out of the loop early (rare, but worth defending).
+            rl.close();
+            stream.destroy();
+        }
+        return prompts;
+    }
+    /**
+     * Extract the user prompt text from a parsed user message.
+     * Handles the three observed content shapes:
+     *   1. message.content is a string
+     *   2. message.content is an array of {type:"text", text:"..."} blocks
+     *   3. content is at the top level (older format)
+     */
+    extractPromptText(message) {
+        const content = message.message?.content ?? message.content;
+        if (content == null)
+            return null;
+        if (typeof content === 'string') {
+            return content;
+        }
+        if (Array.isArray(content)) {
+            const textParts = [];
+            for (const part of content) {
+                if (!part || typeof part !== 'object')
+                    continue;
+                // Accept both explicit {type:"text"} blocks and blocks that omit
+                // `type` but still carry `text` (observed in some Claude Code output).
+                if (typeof part.text === 'string') {
+                    textParts.push(part.text);
+                }
+            }
+            return textParts.length > 0 ? textParts.join('\n') : null;
+        }
+        return null;
+    }
+    /**
+     * Quick test — does the text start with a known noise tag?
+     * Avoids the expensive replace+strip if there's clearly nothing to clean.
+     */
+    isOnlyNoise(text) {
+        if (!NOISE_PEEK.test(text))
+            return false;
+        let cleaned = text;
+        for (const pattern of NOISE_PATTERNS) {
+            cleaned = cleaned.replace(pattern, '');
+        }
+        cleaned = cleaned.replace(HTML_TAG, '').trim();
+        return cleaned.length < MIN_PROMPT_LENGTH;
+    }
+    /**
+     * Generate a title from prompt content (first line or first 100 chars)
+     */
+    generateTitle(content) {
+        const firstLine = content.split('\n').find((l) => l.trim().length > 0) ?? content;
+        const trimmed = firstLine.trim();
+        if (trimmed.length <= 100)
+            return trimmed;
+        return trimmed.slice(0, 100) + '...';
+    }
+    /**
+     * Read prompts from the global history.jsonl file.
+     * Each line: {display, pastedContents, timestamp, project, sessionId}
+     * `display` is the user-entered prompt text.
+     * `timestamp` is in milliseconds (Unix epoch ms).
+     */
+    async getHistoryPrompts(limit) {
+        let content;
+        try {
+            content = await fs.readFile(this.historyFile, 'utf-8');
+        }
+        catch {
+            return [];
+        }
+        const lines = content.split('\n');
+        const results = [];
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            let obj;
+            try {
+                obj = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            const display = (obj.display ?? '').toString();
+            if (display.trim().length < MIN_PROMPT_LENGTH)
+                continue;
+            if (this.isOnlyNoise(display.trim()))
+                continue;
+            const ts = typeof obj.timestamp === 'number' ? new Date(obj.timestamp) : new Date();
+            const contentClean = display.trim();
+            results.push({
+                content: contentClean,
+                title: this.generateTitle(contentClean),
+                timestamp: ts,
+                projectPath: obj.project ?? '',
+                sessionId: obj.sessionId ?? 'history',
+                hash: this.sha256Hash(contentClean),
+            });
+        }
+        // Newest first
+        results.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+        return results.slice(0, limit);
+    }
+    /**
+     * Get all prompts from all sources (project transcripts + history),
+     * deduplicated by SHA-256 content hash, sorted newest first.
+     */
+    async getAllPrompts(since, limit = 100) {
+        const sessions = await this.getSessions();
+        const seenHashes = new Set();
+        const allPrompts = [];
+        // 1) Project transcripts — primary source, richer content.
+        for (const session of sessions) {
+            const encoded = this.encodeProjectPath(session.projectPath);
+            const sessionFile = path.join(this.projectsDir, encoded, session.id + '.jsonl');
+            const prompts = await this.parseSessionPrompts(sessionFile, session.projectPath);
+            for (const prompt of prompts) {
+                if (since && prompt.timestamp < since)
+                    continue;
+                const hash = this.sha256Hash(prompt.content);
+                if (seenHashes.has(hash))
+                    continue;
+                seenHashes.add(hash);
+                allPrompts.push({
+                    content: prompt.content,
+                    title: this.generateTitle(prompt.content),
+                    timestamp: prompt.timestamp,
+                    projectPath: prompt.projectPath,
+                    sessionId: prompt.sessionId,
+                    hash,
+                });
+            }
+        }
+        // 2) history.jsonl — catches prompts from `claude -p "..."` and other
+        //    invocations that may not produce a full transcript.
+        const historyPrompts = await this.getHistoryPrompts(limit * 2);
+        for (const prompt of historyPrompts) {
+            if (since && prompt.timestamp < since)
+                continue;
+            if (seenHashes.has(prompt.hash))
+                continue;
+            seenHashes.add(prompt.hash);
+            allPrompts.push(prompt);
+        }
+        allPrompts.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+        return allPrompts.slice(0, limit);
+    }
+    /**
+     * Count session files quickly for diagnostics (e.g. status output).
+     * Reads the projects directory once and returns the count of `.jsonl`
+     * files across all project subdirectories. Faster than `getSessions()`
+     * because it skips the per-file stat.
+     */
+    async countSessionFiles() {
+        let projectEntries;
+        try {
+            projectEntries = await fs.readdir(this.projectsDir, { withFileTypes: true });
+        }
+        catch {
+            return 0;
+        }
+        let total = 0;
+        for (const entry of projectEntries) {
+            if (!entry.isDirectory() || entry.name.startsWith('.'))
+                continue;
+            try {
+                const files = await fs.readdir(path.join(this.projectsDir, entry.name));
+                total += files.filter((f) => f.endsWith('.jsonl') && !f.startsWith('.')).length;
+            }
+            catch {
+                // skip unreadable dir
+            }
+        }
+        return total;
+    }
+    /**
+     * SHA-256 of the full content — matches the server's hash so dedup works
+     * across CLI runs.
+     */
+    sha256Hash(content) {
+        return createHash('sha256').update(content).digest('hex');
+    }
+}
+//# sourceMappingURL=claude-capture.js.map