atoo-studio 0.0.1 → 0.0.2

package/dist/src/agents/lib/claude/fs-sessions.js

@@ -0,0 +1,329 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import readline from 'readline';
+const CLAUDE_PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects');
+const CLAUDE_HISTORY_PATH = path.join(os.homedir(), '.claude', 'history.jsonl');
+const CACHE_TTL = 30_000; // 30s
+/**
+ * Load session titles from ~/.claude/history.jsonl.
+ * Returns map of sessionId → first display text.
+ */
+function loadHistoryTitles() {
+    const titles = new Map();
+    try {
+        const content = fs.readFileSync(CLAUDE_HISTORY_PATH, 'utf-8');
+        for (const line of content.split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                const entry = JSON.parse(line);
+                if (entry.sessionId && entry.display && !titles.has(entry.sessionId)) {
+                    const d = entry.display.trim();
+                    // Skip slash commands and system prompts
+                    if (d && !d.startsWith('/')) {
+                        titles.set(entry.sessionId, d.substring(0, 100));
+                    }
+                }
+            }
+            catch { }
+        }
+    }
+    catch { }
+    return titles;
+}
+/**
+ * Strip XML/HTML-like tags from text (e.g. <local-command-caveat>...</local-command-caveat>).
+ */
+function stripXmlTags(text) {
+    return text.replace(/<[^>]+>/g, '').trim();
+}
+class FsSessionScanner {
+    cache = new Map();
+    lastScanTime = 0;
+    async scan() {
+        const now = Date.now();
+        if (now - this.lastScanTime < CACHE_TTL && this.cache.size > 0) {
+            return Array.from(this.cache.values());
+        }
+        // Load titles from history.jsonl for better session names
+        const historyTitles = loadHistoryTitles();
+        const results = [];
+        try {
+            const projectDirs = fs.readdirSync(CLAUDE_PROJECTS_DIR, { withFileTypes: true });
+            for (const dirEntry of projectDirs) {
+                if (!dirEntry.isDirectory())
+                    continue;
+                const dirHash = dirEntry.name;
+                const dirPath = path.join(CLAUDE_PROJECTS_DIR, dirHash);
+                try {
+                    const files = fs.readdirSync(dirPath);
+                    for (const file of files) {
+                        if (!file.endsWith('.jsonl'))
+                            continue;
+                        const uuid = file.replace('.jsonl', '');
+                        // Skip non-UUID filenames
+                        if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(uuid))
+                            continue;
+                        const jsonlPath = path.join(dirPath, file);
+                        try {
+                            const meta = await this.parseSessionMeta(jsonlPath, dirHash, uuid, historyTitles);
+                            if (meta)
+                                results.push(meta);
+                        }
+                        catch {
+                            // Skip unparseable files
+                        }
+                    }
+                }
+                catch {
+                    // Skip unreadable directories
+                }
+            }
+        }
+        catch {
+            // ~/.claude/projects doesn't exist
+        }
+        this.cache.clear();
+        for (const meta of results) {
+            this.cache.set(meta.uuid, meta);
+        }
+        this.lastScanTime = now;
+        return results;
+    }
+    async parseSessionMeta(jsonlPath, dirHash, uuid, historyTitles) {
+        const stat = fs.statSync(jsonlPath);
+        if (stat.size === 0)
+            return null;
+        let title = '';
+        let directory = '';
+        let lineCount = 0;
+        let bytesRead = 0;
+        let hasConversationEvent = false;
+        const MAX_LINES = 30;
+        const MAX_BYTES = 64 * 1024; // 64KB max for metadata extraction
+        return new Promise((resolve) => {
+            const stream = fs.createReadStream(jsonlPath, {
+                encoding: 'utf-8',
+                start: 0,
+                end: Math.min(stat.size, MAX_BYTES) - 1,
+            });
+            const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+            rl.on('line', (line) => {
+                lineCount++;
+                bytesRead += line.length + 1;
+                try {
+                    const event = JSON.parse(line);
+                    // Track whether file has real conversation events (not just snapshots)
+                    if (event.type && event.type !== 'file-history-snapshot') {
+                        hasConversationEvent = true;
+                    }
+                    // Extract cwd from first event that has it
+                    if (!directory && event.cwd) {
+                        directory = event.cwd;
+                    }
+                    // Extract title from first real user message (skip meta, commands, system tags)
+                    if (!title && event.type === 'user' && !event.isMeta && event.message?.content) {
+                        const content = event.message.content;
+                        let raw = '';
+                        if (typeof content === 'string') {
+                            raw = content.trim();
+                        }
+                        else if (Array.isArray(content)) {
+                            const textBlock = content.find((b) => b.type === 'text');
+                            if (textBlock?.text)
+                                raw = textBlock.text.trim();
+                        }
+                        // Skip slash commands, XML-tagged system messages, and /remote-control prompt
+                        if (raw && !raw.startsWith('/') && !raw.startsWith('<') && raw !== 'remote-control') {
+                            title = raw.substring(0, 100);
+                        }
+                    }
+                }
+                catch {
+                    // Skip unparseable lines
+                }
+                if (lineCount >= MAX_LINES && title && directory) {
+                    rl.close();
+                    stream.destroy();
+                }
+            });
+            rl.on('close', () => {
+                // Skip files that only contain file-history-snapshot events (ghost files
+                // created by Claude CLI on --resume without any actual conversation)
+                if (!hasConversationEvent) {
+                    resolve(null);
+                    return;
+                }
+                // Extrapolate event count from partial read
+                let eventCount = lineCount;
+                if (bytesRead > 0 && bytesRead < stat.size) {
+                    eventCount = Math.round((stat.size / bytesRead) * lineCount);
+                }
+                // Fallback directory from dir hash
+                if (!directory) {
+                    directory = dirHashToPath(dirHash);
+                }
+                // Resolve title: history.jsonl display > stripped user message > 'Untitled'
+                const historyTitle = historyTitles.get(uuid);
+                const resolvedTitle = historyTitle || (title ? stripXmlTags(title) : '') || 'Untitled';
+                resolve({
+                    uuid,
+                    dirHash,
+                    directory,
+                    title: resolvedTitle,
+                    lastModified: stat.mtime.toISOString(),
+                    fileSize: stat.size,
+                    eventCount,
+                    jsonlPath,
+                });
+            });
+            rl.on('error', () => resolve(null));
+        });
+    }
+    async readEvents(uuid) {
+        const meta = this.cache.get(uuid);
+        if (!meta)
+            return [];
+        const jsonlPath = meta.jsonlPath;
+        const content = fs.readFileSync(jsonlPath, 'utf-8');
+        const events = [];
+        for (const line of content.split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                const event = JSON.parse(line);
+                // Skip file-history-snapshot events
+                if (event.type === 'file-history-snapshot')
+                    continue;
+                // Map JSONL fields to SessionEvent format, preserving fields needed
+                // for chain building (cwd, parentUuid, version, etc.)
+                const mapped = {
+                    uuid: event.uuid,
+                    parentUuid: event.parentUuid,
+                    session_id: event.sessionId || event.session_id,
+                    type: event.type,
+                    message: event.message,
+                    timestamp: event.timestamp,
+                    cwd: event.cwd,
+                    version: event.version,
+                    gitBranch: event.gitBranch,
+                    userType: event.userType,
+                    isSidechain: event.isSidechain,
+                    permissionMode: event.permissionMode,
+                };
+                // Copy optional fields that some event types have
+                if (event.subtype)
+                    mapped.subtype = event.subtype;
+                if (event.data)
+                    mapped.data = event.data;
+                if (event.content)
+                    mapped.content = event.content;
+                if (event.toolUseResult)
+                    mapped.toolUseResult = event.toolUseResult;
+                if (event.hookCount !== undefined)
+                    mapped.hookCount = event.hookCount;
+                if (event.hookInfos)
+                    mapped.hookInfos = event.hookInfos;
+                if (event.hookErrors)
+                    mapped.hookErrors = event.hookErrors;
+                if (event.hasOutput !== undefined)
+                    mapped.hasOutput = event.hasOutput;
+                if (event.preventedContinuation !== undefined)
+                    mapped.preventedContinuation = event.preventedContinuation;
+                if (event.level)
+                    mapped.level = event.level;
+                if (event.toolUseID)
+                    mapped.toolUseID = event.toolUseID;
+                // Map parentUuid + isSidechain to parent_tool_use_id
+                // Only set when actually present — null/undefined should be omitted
+                // so the writer doesn't emit "parent_tool_use_id": null
+                if (event.isSidechain && event.parentUuid) {
+                    mapped.parent_tool_use_id = event.parentUuid;
+                }
+                else if (event.parent_tool_use_id) {
+                    mapped.parent_tool_use_id = event.parent_tool_use_id;
+                }
+                events.push(mapped);
+            }
+            catch {
+                // Skip unparseable lines
+            }
+        }
+        return events;
+    }
+    getByUuid(uuid) {
+        return this.cache.get(uuid);
+    }
+    invalidate() {
+        this.cache.clear();
+        this.lastScanTime = 0;
+    }
+    /**
+     * Find the most recently modified session UUID for a given working directory.
+     * Useful as a fallback when hook-based CLI session discovery fails.
+     */
+    async findMostRecentForCwd(cwd) {
+        await this.scan();
+        let best = null;
+        for (const meta of this.cache.values()) {
+            if (meta.directory !== cwd)
+                continue;
+            if (!best || new Date(meta.lastModified).getTime() > new Date(best.lastModified).getTime()) {
+                best = meta;
+            }
+        }
+        return best?.uuid ?? null;
+    }
+    /**
+     * Return all JSONL file paths (sessions + subagents) for sessions
+     * whose working directory matches any of the given cwds.
+     */
+    async getFilesForProject(cwds) {
+        await this.scan();
+        const cwdSet = new Set(cwds);
+        // Filter matching sessions and sort by lastModified descending (most recent first)
+        const matching = Array.from(this.cache.values())
+            .filter(meta => cwdSet.has(meta.directory))
+            .sort((a, b) => new Date(b.lastModified).getTime() - new Date(a.lastModified).getTime());
+        const files = [];
+        const seen = new Set();
+        for (const meta of matching) {
+            // Add main session file
+            if (!seen.has(meta.jsonlPath)) {
+                seen.add(meta.jsonlPath);
+                files.push(meta.jsonlPath);
+            }
+            // Add subagent files: <dirHash>/<uuid>/subagents/*.jsonl
+            const subagentsDir = path.join(path.dirname(meta.jsonlPath), meta.uuid, 'subagents');
+            try {
+                const entries = fs.readdirSync(subagentsDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.isFile() && entry.name.endsWith('.jsonl')) {
+                        const subPath = path.join(subagentsDir, entry.name);
+                        if (!seen.has(subPath)) {
+                            seen.add(subPath);
+                            files.push(subPath);
+                        }
+                    }
+                }
+            }
+            catch {
+                // No subagents directory
+            }
+        }
+        return files;
+    }
+}
+/**
+ * Convert dir hash back to path: "-home-furti-myproject" → "/home/furti/myproject"
+ * Validates with fs.existsSync().
+ */
+function dirHashToPath(dirHash) {
+    // Replace leading dash, then remaining dashes with /
+    const candidate = '/' + dirHash.replace(/^-/, '').replace(/-/g, '/');
+    if (fs.existsSync(candidate))
+        return candidate;
+    return dirHash; // fallback: return as-is
+}
+export const fsSessionScanner = new FsSessionScanner();

package/dist/src/agents/lib/claude/jsonl-writer.d.ts

@@ -0,0 +1,32 @@
+import type { SessionEvent } from '../../../events/types.js';
+/**
+ * Reconstruct SessionEvent[] as a Claude Code JSONL file for `claude --resume`.
+ * Path: ~/.claude/projects/<project-dir-hash>/<targetUuid>.jsonl
+ *
+ * Each SessionEvent is reconstructed into Claude's native JSONL format
+ * from its typed fields — not passed through as raw JSON. This enables
+ * cross-agent forking: events from any agent type can be written as
+ * valid Claude JSONL.
+ *
+ * @param events - Array of SessionEvents to write
+ * @param targetUuid - The UUID for the new session file (no "sess_" prefix)
+ * @param directory - The project working directory (for path hashing)
+ * @returns The full path to the written JSONL file
+ */
+export declare function writeForkedClaudeJsonl(events: SessionEvent[], targetUuid: string, directory: string): string;
+/**
+ * Fork a slice of SessionEvents into a resumable JSONL file.
+ * Handles event slicing, range-fork synthetic init, UUID generation, and writing.
+ *
+ * @returns The resume UUID, or null if the fork point wasn't found.
+ */
+/**
+ * Fork a slice of SessionEvents into a resumable JSONL file.
+ * Handles event slicing, range-fork synthetic init, UUID generation, and writing.
+ *
+ * The returned UUID is parent-linked: its first 16 hex chars are the last 16 hex chars
+ * of the parent session ID, enabling tree-view reconstruction in session history.
+ *
+ * @returns The resume UUID, or null if the fork point wasn't found.
+ */
+export declare function forkEventsToResumable(events: SessionEvent[], afterEventUuid: string, directory: string, parentSessionId: string, fromEventUuid?: string): string | null;