braindump 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kushal Srivastava
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,180 @@
+# AgentRelay
+
+A CLI tool that captures your AI coding agent session and generates a portable resume prompt so you can seamlessly continue in a different agent when tokens run out.
+
+## The Problem
+
+AI coding agents are context silos. When your session hits a rate limit or runs out of tokens, you lose all that context. AgentRelay captures it and generates a handoff prompt so a new agent can pick up exactly where the last one left off.
+
+## Supported Agents
+
+| Agent | Status |
+|-------|--------|
+| Claude Code | Working |
+| Cursor | Working |
+| Codex CLI | Working |
+
+## Installation
+
+```bash
+# From npm
+npm install -g agentrelay
+
+# From source
+git clone https://github.com/Kushalwho/agentrelay.git
+cd agentrelay
+npm install
+npm run build
+npm link
+```
+
+## Quick Start
+
+```bash
+# Detect installed agents
+agentrelay detect
+
+# Full handoff — capture, compress, generate resume prompt
+agentrelay handoff
+
+# Target a specific agent for the resume format
+agentrelay handoff --target cursor
+
+# Preview without writing files
+agentrelay handoff --dry-run
+
+# Watch for rate limits (auto-detects agents)
+agentrelay watch
+
+# The resume prompt is in .handoff/RESUME.md and on your clipboard
+# Paste it into your target agent and keep working
+```
+
+## Commands
+
+```
+agentrelay detect                         Scan for installed agents
+agentrelay list [--source <agent>]        List recent sessions
+agentrelay capture [--source <agent>]     Capture session to .handoff/session.json
+agentrelay handoff [options]              Full pipeline: capture -> compress -> resume
+agentrelay watch [--agents <csv>]         Watch sessions for changes and rate limits
+agentrelay resume [--file <path>]         Re-generate resume from captured session
+agentrelay info                           Show agent paths and config
+```
+
+### Handoff Options
+
+```
+-s, --source <agent>    Source agent (claude-code, cursor, codex). Auto-detected if omitted.
+-t, --target <target>   Target agent or "file"/"clipboard". Default: file + clipboard.
+--session <id>          Specific session ID. Default: most recent session.
+-p, --project <path>    Project path. Default: current directory.
+--tokens <n>            Token budget override. Default: based on target agent.
+--dry-run               Preview what would be captured without writing files.
+--no-clipboard          Skip clipboard copy (useful in CI/headless environments).
+-o, --output <path>     Custom output path. Directory or file path.
+-v, --verbose           Show detailed debug output.
+```
+
+### Watch Options
+
+```
+--agents <csv>          Comma-separated agents to watch (claude-code, cursor, codex).
+--interval <seconds>    Polling interval in seconds. Default: 30.
+-p, --project <path>    Only watch sessions for this project.
+```
+
+### Target-Specific Hints
+
+When you specify `--target`, the resume prompt includes agent-specific instructions:
+
+| Target | Hint |
+|--------|------|
+| `cursor` | "Paste this into Cursor's Composer to continue." |
+| `codex` | "Feed this to Codex CLI with `codex resume` or paste it." |
+| `claude-code` | "Paste this into a new Claude Code session to continue." |
+
+## How It Works
+
+```
++-----------------+    +--------------+    +-----------------+    +--------------+
+|  Agent Session  |    |   Capture    |    |   Compress      |    |  RESUME.md   |
+|  (JSONL/SQLite) | -> |  + Analyze   | -> |  (7 priority    | -> |  + clipboard |
+|                 |    |  + Enrich    |    |   layers)       |    |              |
++-----------------+    +--------------+    +-----------------+    +--------------+
+```
+
+1. **Capture** -- Reads session data from the agent's native storage (JSONL for Claude Code/Codex, SQLite for Cursor)
+2. **Analyze** -- Extracts task state, decisions, blockers, and completed steps from the conversation
+3. **Enrich** -- Adds project context: git branch/status/log, directory tree, memory files
+4. **Compress** -- Priority-layered compression to fit any context window
+5. **Generate** -- Builds a self-summarizing resume prompt that tells the new agent to pick up exactly where the last one left off
+6. **Deliver** -- Writes to `.handoff/RESUME.md` and copies to clipboard
+
+## Compression Priority Layers
+
+| Priority | Layer | Always included? |
+|----------|-------|-----------------|
+| 1 | Task state (what's done, in progress, remaining) | Yes |
+| 2 | Active files (diffs/content of changed files) | Yes |
+| 3 | Decisions and blockers | Yes |
+| 4 | Project context (git, directory tree, memory files) | If room |
+| 5 | Session overview (stats, first/last message) | If room |
+| 6 | Recent messages (last 20) | If room |
+| 7 | Full history (older messages) | If room |
+
+## Development
+
+```bash
+npm install              # Install dependencies
+npm run dev -- detect    # Run in dev mode
+npm test                 # Run tests (watch mode)
+npm run test:run         # Run tests (single run)
+npm run lint             # Type check
+npm run build            # Build to dist/
+```
+
+## Project Structure
+
+```
+src/
+├── adapters/                  # Agent-specific session readers
+│   ├── claude-code/adapter.ts # JSONL parser for ~/.claude/projects/
+│   ├── cursor/adapter.ts      # SQLite reader for Cursor workspaceStorage
+│   └── codex/adapter.ts       # JSONL parser for ~/.codex/sessions/
+├── core/
+│   ├── compression.ts         # Priority-layered compression engine
+│   ├── conversation-analyzer.ts # Extracts tasks, decisions, blockers
+│   ├── prompt-builder.ts      # RESUME.md template assembly
+│   ├── token-estimator.ts     # Character-based token estimation
+│   ├── project-context.ts     # Git info, directory tree, memory files
+│   ├── registry.ts            # Agent metadata (paths, context windows)
+│   └── watcher.ts             # Polling-based session watcher
+├── providers/
+│   ├── file-provider.ts       # Writes .handoff/RESUME.md
+│   └── clipboard-provider.ts  # Copies to system clipboard
+├── types/index.ts             # All TypeScript interfaces
+└── cli/index.ts               # Commander.js CLI entry point
+```
+
+## Tests
+
+70 tests passing across 8 test files:
+- Adapter tests (Claude Code, Cursor, Codex) with real JSONL/SQLite parsing
+- Compression engine tests across all priority layers
+- Conversation analyzer tests
+- Prompt builder tests including target-agent hints
+- Watcher tests with mocked adapters and fake timers
+- End-to-end handoff flow integration tests
+
+## CI
+
+GitHub Actions runs on every PR and push to main:
+- TypeScript type check
+- Tests (vitest)
+- Build
+- Node.js 18, 20, 22
+
+## License
+
+MIT

package/dist/adapters/base-adapter.d.ts

@@ -0,0 +1,13 @@
+import type { AgentAdapter, AgentId, CapturedSession, SessionInfo } from "../types/index.js";
+/**
+ * Base class with shared utilities for all adapters.
+ * Concrete adapters extend this and implement the abstract methods.
+ */
+export declare abstract class BaseAdapter implements AgentAdapter {
+    abstract agentId: AgentId;
+    abstract detect(): Promise<boolean>;
+    abstract listSessions(projectPath?: string): Promise<SessionInfo[]>;
+    abstract capture(sessionId: string): Promise<CapturedSession>;
+    abstract captureLatest(projectPath?: string): Promise<CapturedSession>;
+}
+//# sourceMappingURL=base-adapter.d.ts.map

package/dist/adapters/base-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-adapter.d.ts","sourceRoot":"","sources":["../../src/adapters/base-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAE7F;;;GAGG;AACH,8BAAsB,WAAY,YAAW,YAAY;IACvD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAE1B,QAAQ,CAAC,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC;IACnC,QAAQ,CAAC,YAAY,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IACnE,QAAQ,CAAC,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAC7D,QAAQ,CAAC,aAAa,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;CACvE"}

package/dist/adapters/base-adapter.js

@@ -0,0 +1,7 @@
+/**
+ * Base class with shared utilities for all adapters.
+ * Concrete adapters extend this and implement the abstract methods.
+ */
+export class BaseAdapter {
+}
+//# sourceMappingURL=base-adapter.js.map

package/dist/adapters/base-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-adapter.js","sourceRoot":"","sources":["../../src/adapters/base-adapter.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,OAAgB,WAAW;CAOhC"}

package/dist/adapters/claude-code/adapter.d.ts

@@ -0,0 +1,47 @@
+import { BaseAdapter } from "../base-adapter.js";
+import type { AgentId, CapturedSession, SessionInfo } from "../../types/index.js";
+/**
+ * Adapter for Claude Code sessions.
+ * Reads JSONL files from ~/.claude/projects/<path-hash>/<session-uuid>.jsonl
+ */
+export declare class ClaudeCodeAdapter extends BaseAdapter {
+    agentId: AgentId;
+    /** Root directory where Claude Code stores project sessions. */
+    private get projectsDir();
+    detect(): Promise<boolean>;
+    listSessions(projectPath?: string): Promise<SessionInfo[]>;
+    capture(sessionId: string): Promise<CapturedSession>;
+    captureLatest(projectPath?: string): Promise<CapturedSession>;
+    /**
+     * Convert an absolute project path to the hash format Claude Code uses for
+     * subdirectory names.  Slashes (and on Windows, backslashes and the drive
+     * colon) are replaced with hyphens.
+     *
+     * Example (Linux):  /home/user/project  ->  -home-user-project
+     * Example (Windows): C:\Users\kusha\proj -> C--Users-kusha-proj
+     */
+    private pathToHash;
+    /**
+     * Reverse the hash back to a plausible absolute path.
+     *
+     * Example (Linux):  -home-user-project  ->  /home/user/project
+     * Example (Windows): C--Users-kusha-proj -> C:\Users\kusha\proj
+     */
+    private hashToPath;
+    /**
+     * Read basic session info from a .jsonl file without loading it all into memory.
+     * Reads the first line for startedAt/preview and the last line for lastActiveAt,
+     * and counts lines for messageCount.
+     */
+    private readSessionInfo;
+    /**
+     * Locate the session file for a given session UUID by searching all
+     * subdirectories under ~/.claude/projects/.
+     */
+    private findSessionFile;
+    /**
+     * Stream-read a JSONL file and return all non-empty lines.
+     */
+    private readJsonlLines;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/dist/adapters/claude-code/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/claude-code/adapter.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAIjD,OAAO,KAAK,EACV,OAAO,EACP,eAAe,EAGf,WAAW,EACZ,MAAM,sBAAsB,CAAC;AAE9B;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,WAAW;IAChD,OAAO,EAAE,OAAO,CAAiB;IAEjC,gEAAgE;IAChE,OAAO,KAAK,WAAW,GAEtB;IAMK,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC;IAkB1B,YAAY,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IA8C1D,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IA4KpD,aAAa,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAiBnE;;;;;;;OAOG;IACH,OAAO,CAAC,UAAU;IAclB;;;;;OAKG;IACH,OAAO,CAAC,UAAU;IAclB;;;;OAIG;YACW,eAAe;IAyE7B;;;OAGG;YACW,eAAe;IAc7B;;OAEG;YACW,cAAc;CAiB7B"}

package/dist/adapters/claude-code/adapter.js

@@ -0,0 +1,382 @@
+import fs from "node:fs";
+import { createReadStream } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import readline from "node:readline";
+import { glob } from "glob";
+import { BaseAdapter } from "../base-adapter.js";
+import { analyzeConversation } from "../../core/conversation-analyzer.js";
+import { extractProjectContext } from "../../core/project-context.js";
+import { validateSession } from "../../core/validation.js";
+/**
+ * Adapter for Claude Code sessions.
+ * Reads JSONL files from ~/.claude/projects/<path-hash>/<session-uuid>.jsonl
+ */
+export class ClaudeCodeAdapter extends BaseAdapter {
+    agentId = "claude-code";
+    /** Root directory where Claude Code stores project sessions. */
+    get projectsDir() {
+        return path.join(os.homedir(), ".claude", "projects");
+    }
+    // ---------------------------------------------------------------------------
+    // detect
+    // ---------------------------------------------------------------------------
+    async detect() {
+        if (!fs.existsSync(this.projectsDir)) {
+            return false;
+        }
+        const files = await glob("**/*.jsonl", {
+            cwd: this.projectsDir,
+            nodir: true,
+            absolute: false,
+        });
+        return files.length > 0;
+    }
+    // ---------------------------------------------------------------------------
+    // listSessions
+    // ---------------------------------------------------------------------------
+    async listSessions(projectPath) {
+        if (!fs.existsSync(this.projectsDir)) {
+            return [];
+        }
+        let pattern;
+        if (projectPath) {
+            const hash = this.pathToHash(projectPath);
+            pattern = `${hash}/*.jsonl`;
+        }
+        else {
+            pattern = "**/*.jsonl";
+        }
+        const files = await glob(pattern, {
+            cwd: this.projectsDir,
+            nodir: true,
+            absolute: true,
+        });
+        const sessions = [];
+        for (const filePath of files) {
+            try {
+                const info = await this.readSessionInfo(filePath);
+                if (info) {
+                    sessions.push(info);
+                }
+            }
+            catch {
+                // Skip unreadable files
+            }
+        }
+        // Sort by lastActiveAt descending (most recent first)
+        sessions.sort((a, b) => {
+            const aTime = a.lastActiveAt ?? "";
+            const bTime = b.lastActiveAt ?? "";
+            return bTime.localeCompare(aTime);
+        });
+        return sessions;
+    }
+    // ---------------------------------------------------------------------------
+    // capture
+    // ---------------------------------------------------------------------------
+    async capture(sessionId) {
+        const filePath = await this.findSessionFile(sessionId);
+        if (!filePath) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        const lines = await this.readJsonlLines(filePath);
+        const messages = [];
+        const fileChanges = new Map();
+        const seenMessageIds = new Set();
+        let totalTokens = 0;
+        let lastAssistantMessage = "";
+        let sessionStartedAt;
+        for (const line of lines) {
+            let entry;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                // Skip malformed lines
+                continue;
+            }
+            if (!entry.message) {
+                continue;
+            }
+            if (entry.message.id && seenMessageIds.has(entry.message.id)) {
+                continue;
+            }
+            if (entry.message.id) {
+                seenMessageIds.add(entry.message.id);
+            }
+            // Track session start time from the first entry's timestamp
+            if (!sessionStartedAt && entry.timestamp) {
+                sessionStartedAt = entry.timestamp;
+            }
+            const role = entry.message.role === "user" ? "user" : "assistant";
+            const contentBlocks = Array.isArray(entry.message.content)
+                ? entry.message.content
+                : [];
+            // Accumulate token counts
+            if (entry.message.usage) {
+                totalTokens +=
+                    (entry.message.usage.input_tokens ?? 0) +
+                        (entry.message.usage.output_tokens ?? 0);
+            }
+            // Extract text content from this message
+            const textParts = [];
+            for (const block of contentBlocks) {
+                if (block.type === "text" && block.text) {
+                    textParts.push(block.text);
+                }
+            }
+            const textContent = textParts.join("\n");
+            // Track last assistant message for in-progress summary
+            if (role === "assistant" && textContent) {
+                lastAssistantMessage = textContent;
+            }
+            // Create conversation message for text content
+            if (textContent) {
+                messages.push({
+                    role,
+                    content: textContent,
+                    timestamp: entry.timestamp,
+                    tokenCount: entry.message.usage
+                        ? (entry.message.usage.input_tokens ?? 0) +
+                            (entry.message.usage.output_tokens ?? 0)
+                        : undefined,
+                });
+            }
+            // Process tool_use blocks
+            for (const block of contentBlocks) {
+                if (block.type === "tool_use" && block.name) {
+                    // Add a tool message to the conversation
+                    messages.push({
+                        role: "tool",
+                        content: typeof block.input === "object"
+                            ? JSON.stringify(block.input)
+                            : String(block.input ?? ""),
+                        toolName: block.name,
+                        timestamp: entry.timestamp,
+                    });
+                    // Extract file changes from Write and Edit tool blocks
+                    if ((block.name === "Write" || block.name === "Edit") &&
+                        block.input &&
+                        typeof block.input === "object") {
+                        const input = block.input;
+                        const filePth = input.file_path ??
+                            input.path;
+                        if (filePth) {
+                            const ext = path.extname(filePth).slice(1);
+                            fileChanges.set(filePth, {
+                                path: filePth,
+                                changeType: block.name === "Write" ? "created" : "modified",
+                                diff: input.content,
+                                language: ext || undefined,
+                            });
+                        }
+                    }
+                }
+                // Also handle tool_result blocks
+                if (block.type === "tool_result") {
+                    const resultContent = typeof block.content === "string"
+                        ? block.content
+                        : JSON.stringify(block.content ?? "");
+                    messages.push({
+                        role: "tool",
+                        content: resultContent,
+                        timestamp: entry.timestamp,
+                    });
+                }
+            }
+        }
+        // Infer project path from the directory structure
+        const parentDir = path.basename(path.dirname(filePath));
+        const inferredProjectPath = this.hashToPath(parentDir);
+        const projectContext = await extractProjectContext(inferredProjectPath);
+        const analysis = analyzeConversation(messages);
+        const session = {
+            version: "1.0",
+            source: "claude-code",
+            capturedAt: new Date().toISOString(),
+            sessionId,
+            sessionStartedAt,
+            project: {
+                ...projectContext,
+                path: projectContext.path || inferredProjectPath,
+                name: projectContext.name || path.basename(inferredProjectPath),
+            },
+            conversation: {
+                messageCount: messages.length,
+                estimatedTokens: totalTokens,
+                messages,
+            },
+            filesChanged: Array.from(fileChanges.values()),
+            decisions: analysis.decisions,
+            blockers: analysis.blockers,
+            task: {
+                description: analysis.taskDescription,
+                completed: analysis.completedSteps,
+                remaining: [],
+                inProgress: lastAssistantMessage
+                    ? lastAssistantMessage.substring(0, 200)
+                    : undefined,
+                blockers: analysis.blockers,
+            },
+        };
+        return validateSession(session);
+    }
+    // ---------------------------------------------------------------------------
+    // captureLatest
+    // ---------------------------------------------------------------------------
+    async captureLatest(projectPath) {
+        const sessions = await this.listSessions(projectPath);
+        if (sessions.length === 0) {
+            throw new Error(projectPath
+                ? `No Claude Code sessions found for project: ${projectPath}`
+                : "No Claude Code sessions found");
+        }
+        return this.capture(sessions[0].id);
+    }
+    // ---------------------------------------------------------------------------
+    // Private helpers
+    // ---------------------------------------------------------------------------
+    /**
+     * Convert an absolute project path to the hash format Claude Code uses for
+     * subdirectory names.  Slashes (and on Windows, backslashes and the drive
+     * colon) are replaced with hyphens.
+     *
+     * Example (Linux):  /home/user/project  ->  -home-user-project
+     * Example (Windows): C:\Users\kusha\proj -> C--Users-kusha-proj
+     */
+    pathToHash(projectPath) {
+        let normalized = projectPath;
+        if (process.platform === "win32") {
+            // Replace backslashes with forward slashes first for uniform handling
+            normalized = normalized.replace(/\\/g, "/");
+            // Handle drive letter: C: -> C-
+            normalized = normalized.replace(/^([A-Za-z]):/, "$1-");
+        }
+        // Replace all forward slashes with hyphens
+        return normalized.replace(/\//g, "-");
+    }
+    /**
+     * Reverse the hash back to a plausible absolute path.
+     *
+     * Example (Linux):  -home-user-project  ->  /home/user/project
+     * Example (Windows): C--Users-kusha-proj -> C:\Users\kusha\proj
+     */
+    hashToPath(hash) {
+        // Detect Windows-style hash: starts with a drive letter followed by a dash
+        const windowsDriveMatch = hash.match(/^([A-Za-z])-(.*)$/);
+        if (windowsDriveMatch) {
+            const drive = windowsDriveMatch[1];
+            const rest = windowsDriveMatch[2];
+            // The rest has leading dash from root, replace dashes with backslash
+            return `${drive}:${rest.replace(/-/g, "\\")}`;
+        }
+        // Unix-style: leading dash represents root /
+        return hash.replace(/-/g, "/");
+    }
+    /**
+     * Read basic session info from a .jsonl file without loading it all into memory.
+     * Reads the first line for startedAt/preview and the last line for lastActiveAt,
+     * and counts lines for messageCount.
+     */
+    async readSessionInfo(filePath) {
+        const fileName = path.basename(filePath, ".jsonl");
+        // Infer project path from parent directory name
+        const parentDir = path.basename(path.dirname(filePath));
+        const projectPath = this.hashToPath(parentDir);
+        let firstLine;
+        let lastLine;
+        let lineCount = 0;
+        const rl = readline.createInterface({
+            input: createReadStream(filePath, { encoding: "utf-8" }),
+            crlfDelay: Infinity,
+        });
+        for await (const line of rl) {
+            if (!line.trim())
+                continue;
+            lineCount++;
+            if (lineCount === 1) {
+                firstLine = line;
+            }
+            lastLine = line;
+        }
+        if (lineCount === 0 || !firstLine) {
+            return null;
+        }
+        let startedAt;
+        let lastActiveAt;
+        let preview;
+        try {
+            const firstEntry = JSON.parse(firstLine);
+            startedAt = firstEntry.timestamp;
+            // Extract preview from first message text content
+            if (firstEntry.message?.content) {
+                const blocks = Array.isArray(firstEntry.message.content)
+                    ? firstEntry.message.content
+                    : [];
+                for (const block of blocks) {
+                    if (block.type === "text" && block.text) {
+                        preview = block.text.substring(0, 200);
+                        break;
+                    }
+                }
+            }
+        }
+        catch {
+            // Malformed first line — still include the session with what we have
+        }
+        if (lastLine && lastLine !== firstLine) {
+            try {
+                const lastEntry = JSON.parse(lastLine);
+                lastActiveAt = lastEntry.timestamp;
+            }
+            catch {
+                // Ignore malformed last line
+            }
+        }
+        else {
+            lastActiveAt = startedAt;
+        }
+        return {
+            id: fileName,
+            startedAt,
+            lastActiveAt,
+            messageCount: lineCount,
+            projectPath,
+            preview,
+        };
+    }
+    /**
+     * Locate the session file for a given session UUID by searching all
+     * subdirectories under ~/.claude/projects/.
+     */
+    async findSessionFile(sessionId) {
+        if (!fs.existsSync(this.projectsDir)) {
+            return null;
+        }
+        const matches = await glob(`**/${sessionId}.jsonl`, {
+            cwd: this.projectsDir,
+            nodir: true,
+            absolute: true,
+        });
+        return matches.length > 0 ? matches[0] : null;
+    }
+    /**
+     * Stream-read a JSONL file and return all non-empty lines.
+     */
+    async readJsonlLines(filePath) {
+        const lines = [];
+        const rl = readline.createInterface({
+            input: createReadStream(filePath, { encoding: "utf-8" }),
+            crlfDelay: Infinity,
+        });
+        for await (const line of rl) {
+            const trimmed = line.trim();
+            if (trimmed) {
+                lines.push(trimmed);
+            }
+        }
+        return lines;
+    }
+}
+//# sourceMappingURL=adapter.js.map