@compaction/cli 0.1.0

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

@@ -0,0 +1,539 @@
+import { createReadStream } from "node:fs";
+import { existsSync, readdirSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join, dirname, basename } from "node:path";
+import { createInterface } from "node:readline";
+import { createUsageMetadata } from "../usage-metadata.js";
+import { computeTraceFingerprint } from "../trace-fingerprint.js";
+import { CURRENT_AGENT_TRACE_ARTIFACT_VERSION } from "../trace-parser.js";
+// ─── Constants ────────────────────────────────────────────────────────────────
+const MAX_TOOL_RESULT_CHARS = 32_000;
+const TRUNCATION_SUFFIX = "[TRUNCATED — full content in source session JSONL]";
+export const PRIVACY_WARNING = "WARNING: The Claude Code session file may contain file content read during your session\n" +
+    "(source code, config files, Bash output, etc.). The captured trace is written locally\n" +
+    "to the output directory only. Do not share captured-trace.json artifacts without reviewing\n" +
+    "them for sensitive content first.";
+const SUBAGENT_WARNING = "Subagent JSONL files were not included in this capture. Pass --include-subagents to include them.";
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function extractTextContent(content) {
+    if (!content)
+        return "";
+    if (typeof content === "string")
+        return content;
+    return content
+        .filter((item) => item.type === "text" && item.text !== undefined)
+        .map((item) => item.text ?? "")
+        .join("\n");
+}
+function serializeToolInput(input) {
+    if (input === null || input === undefined)
+        return "";
+    if (typeof input === "string")
+        return input;
+    // Deterministic key order at each nesting level
+    return JSON.stringify(sortKeys(input));
+}
+function sortKeys(value) {
+    if (Array.isArray(value)) {
+        return value.map(sortKeys);
+    }
+    if (value !== null && typeof value === "object") {
+        const obj = value;
+        return Object.fromEntries(Object.keys(obj)
+            .sort()
+            .map((k) => [k, sortKeys(obj[k])]));
+    }
+    return value;
+}
+function truncate(text, maxChars) {
+    if (text.length <= maxChars)
+        return { text, truncated: false };
+    return { text: text.slice(0, maxChars) + "\n" + TRUNCATION_SUFFIX, truncated: true };
+}
+function extractToolResultContent(content, maxChars) {
+    if (!content)
+        return { text: "", truncated: false };
+    if (typeof content === "string") {
+        return truncate(content, maxChars);
+    }
+    // Join multiple content items
+    const joined = content
+        .map((item) => {
+        if (item.type === "text")
+            return item.text ?? "";
+        if (item.type === "tool_result") {
+            const inner = item.content;
+            if (typeof inner === "string")
+                return inner;
+            if (Array.isArray(inner))
+                return inner.map((c) => c.text ?? "").join("\n");
+        }
+        return "";
+    })
+        .filter(Boolean)
+        .join("\n---\n");
+    return truncate(joined, maxChars);
+}
+// ─── Read JSONL entries ───────────────────────────────────────────────────────
+async function readJsonlEntries(sourcePath) {
+    const entries = [];
+    const rl = createInterface({
+        input: createReadStream(sourcePath, { encoding: "utf8" }),
+        crlfDelay: Infinity
+    });
+    for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            entries.push(JSON.parse(trimmed));
+        }
+        catch {
+            // Skip malformed lines
+        }
+    }
+    return entries;
+}
+/**
+ * Process a list of JSONL entries into messages and usage accumulators.
+ *
+ * @param entries - Parsed JSONL entries.
+ * @param maxToolResultChars - Max characters for tool result content.
+ * @param includeAllIsSidechain - When true (subagent mode), include user/assistant entries
+ *   regardless of isSidechain (all subagent entries have isSidechain:true by design).
+ *   When false (main session mode), exclude entries with isSidechain:true.
+ * @param idPrefix - If provided, prefix each message id with "<idPrefix>-".
+ */
+function processEntries(entries, maxToolResultChars, includeAllIsSidechain, idPrefix) {
+    let sessionId = null;
+    let model = "unknown";
+    let aiTitle;
+    let firstTimestamp;
+    let lastTimestamp;
+    let thinkingBlockCount = 0;
+    let truncationCount = 0;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheCreationTokens = 0;
+    let cacheReadTokens = 0;
+    let assistantCount = 0;
+    let userCount = 0;
+    let otherCount = 0;
+    let agentId;
+    // Build a lookup map from tool_use_id → tool type name by scanning all assistant entries.
+    // This enables tool_result messages to carry the human-readable tool type name (e.g. "Read",
+    // "Bash") instead of the globally-unique tool_use_id UUID, which would make waste detection
+    // structurally impossible since no two UUIDs ever match.
+    const toolUseIdToName = new Map();
+    for (const entry of entries) {
+        if (entry.type !== "assistant")
+            continue;
+        const msg = entry.message;
+        if (!msg || !msg.content || typeof msg.content === "string")
+            continue;
+        for (const item of msg.content) {
+            if (item.type === "tool_use" && item.id && item.name) {
+                toolUseIdToName.set(item.id, item.name);
+            }
+        }
+    }
+    const messages = [];
+    for (const entry of entries) {
+        // Capture sessionId from any entry
+        if (!sessionId && entry.sessionId) {
+            sessionId = entry.sessionId;
+        }
+        // Capture agentId from any entry (present in subagent files)
+        if (!agentId && typeof entry["agentId"] === "string") {
+            agentId = entry["agentId"];
+        }
+        // Capture ai-title
+        if (entry.type === "ai-title" && entry.aiTitle) {
+            aiTitle = entry.aiTitle;
+            continue;
+        }
+        // Skip non-conversation entries
+        if (!["user", "assistant"].includes(entry.type)) {
+            otherCount++;
+            continue;
+        }
+        // isSidechain handling:
+        //   Main session: exclude entries with isSidechain === true (they are subagent branches)
+        //   Subagent file: include all user/assistant entries regardless of isSidechain
+        //   (all subagent entries have isSidechain:true by definition)
+        if (!includeAllIsSidechain && entry.isSidechain === true) {
+            otherCount++;
+            continue;
+        }
+        const timestamp = entry.timestamp ?? new Date().toISOString();
+        if (!firstTimestamp)
+            firstTimestamp = timestamp;
+        lastTimestamp = timestamp;
+        const makeId = (fallback) => {
+            const base = entry.uuid ?? fallback;
+            return idPrefix ? `${idPrefix}-${base}` : base;
+        };
+        if (entry.type === "assistant") {
+            assistantCount++;
+            const msg = entry.message;
+            if (!msg)
+                continue;
+            // Capture model from first assistant entry
+            if (model === "unknown" && msg.model) {
+                model = msg.model;
+            }
+            // Aggregate usage
+            if (msg.usage) {
+                inputTokens += msg.usage.input_tokens ?? 0;
+                outputTokens += msg.usage.output_tokens ?? 0;
+                cacheCreationTokens += msg.usage.cache_creation_input_tokens ?? 0;
+                cacheReadTokens += msg.usage.cache_read_input_tokens ?? 0;
+            }
+            // Extract content items
+            const content = msg.content;
+            if (!content)
+                continue;
+            const items = typeof content === "string"
+                ? [{ type: "text", text: content }]
+                : content;
+            for (const item of items) {
+                if (item.type === "thinking") {
+                    thinkingBlockCount++;
+                    continue; // Exclude thinking blocks
+                }
+                if (item.type === "text" && item.text !== undefined) {
+                    messages.push({
+                        id: makeId(`${sessionId ?? "unknown"}-${messages.length}`),
+                        role: "assistant",
+                        content: item.text,
+                        timestamp
+                    });
+                }
+                else if (item.type === "tool_use") {
+                    const serialized = serializeToolInput(item.input);
+                    const { text: truncatedContent, truncated } = truncate(serialized, maxToolResultChars);
+                    if (truncated) {
+                        truncationCount++;
+                    }
+                    messages.push({
+                        id: makeId(`${sessionId ?? "unknown"}-${messages.length}`),
+                        role: "assistant",
+                        content: truncatedContent,
+                        timestamp,
+                        toolName: item.name ?? undefined
+                    });
+                }
+            }
+        }
+        else if (entry.type === "user") {
+            userCount++;
+            const msg = entry.message;
+            if (!msg)
+                continue;
+            const content = msg.content;
+            if (!content)
+                continue;
+            const items = typeof content === "string"
+                ? [{ type: "text", text: content }]
+                : content;
+            for (const item of items) {
+                if (item.type === "tool_result") {
+                    const { text: extracted, truncated } = extractToolResultContent(item.content, maxToolResultChars);
+                    if (truncated) {
+                        truncationCount++;
+                    }
+                    // Resolve tool type name from the lookup map built from assistant tool_use items.
+                    // Fall back to the raw tool_use_id if not found (preserves backward compatibility).
+                    const resolvedToolName = item.tool_use_id
+                        ? (toolUseIdToName.get(item.tool_use_id) ?? item.tool_use_id)
+                        : undefined;
+                    messages.push({
+                        id: makeId(`${sessionId ?? "unknown"}-${messages.length}`),
+                        role: "tool",
+                        content: extracted,
+                        timestamp,
+                        toolName: resolvedToolName
+                    });
+                }
+                else if (item.type === "text" && item.text !== undefined) {
+                    messages.push({
+                        id: makeId(`${sessionId ?? "unknown"}-${messages.length}`),
+                        role: "user",
+                        content: item.text,
+                        timestamp
+                    });
+                }
+            }
+        }
+    }
+    return {
+        messages,
+        sessionId,
+        model,
+        aiTitle,
+        firstTimestamp,
+        lastTimestamp,
+        thinkingBlockCount,
+        truncationCount,
+        inputTokens,
+        outputTokens,
+        cacheCreationTokens,
+        cacheReadTokens,
+        assistantCount,
+        userCount,
+        otherCount,
+        agentId
+    };
+}
+async function readSubagentMeta(metaPath) {
+    try {
+        const raw = await readFile(metaPath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+// ─── Discover subagent JSONL files ────────────────────────────────────────────
+/**
+ * Discover subagent JSONL files from the subagents directory adjacent to the session file.
+ * The session file is expected at: <parent>/<session-id>.jsonl
+ * The subagents directory is at: <parent>/<session-id>/subagents/
+ */
+function discoverSubagentJSONLFiles(sessionPath) {
+    const sessionFileName = basename(sessionPath);
+    const sessionId = sessionFileName.replace(/\.jsonl$/, "");
+    const sessionDir = dirname(sessionPath);
+    const subagentsDir = join(sessionDir, sessionId, "subagents");
+    if (!existsSync(subagentsDir)) {
+        return [];
+    }
+    let entries;
+    try {
+        entries = readdirSync(subagentsDir);
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((name) => name.endsWith(".jsonl"))
+        .map((name) => join(subagentsDir, name));
+}
+/**
+ * Scan a single Claude Code session JSONL file for discovery metadata.
+ *
+ * Reuses the existing parser exactly (no re-implementation): it reads the same
+ * entries `normalize()` reads, runs the same `processEntries` over the main
+ * session, and counts subagent files via the same `discoverSubagentJSONLFiles`.
+ * Reads only the given session file (and lists its subagents directory).
+ * Surfaces metadata only; never returns message content.
+ */
+export async function scanSessionMetadata(sessionPath, projectSlug) {
+    const entries = await readJsonlEntries(sessionPath);
+    // Same parse the adapter uses for the main session (subagents excluded by default).
+    const main = processEntries(entries, MAX_TOOL_RESULT_CHARS, false, undefined);
+    // provider-reported-usage present iff any assistant entry carried a usage object.
+    let providerReportedUsagePresent = false;
+    let projectDir;
+    for (const entry of entries) {
+        if (!providerReportedUsagePresent && entry.type === "assistant" && entry.message?.usage) {
+            providerReportedUsagePresent = true;
+        }
+        if (projectDir === undefined && typeof entry.cwd === "string" && entry.cwd.length > 0) {
+            projectDir = entry.cwd;
+        }
+    }
+    const subagentCount = discoverSubagentJSONLFiles(sessionPath).length;
+    return {
+        sessionPath,
+        projectSlug,
+        projectDir: projectDir ?? decodeProjectSlug(projectSlug),
+        sessionId: main.sessionId,
+        firstTimestamp: main.firstTimestamp,
+        lastTimestamp: main.lastTimestamp,
+        messageCount: main.messages.length,
+        subagentCount,
+        providerReportedUsagePresent
+    };
+}
+/**
+ * Best-effort decode of a Claude Code project slug back to a directory path.
+ * Claude Code encodes the absolute working directory by replacing path
+ * separators with "-" (e.g. "-Users-me-Projects-app"). The decode is lossy
+ * (real "-" in path segments are indistinguishable from separators), so this is
+ * only a best-effort hint; the on-disk `cwd` from entries is preferred when
+ * available. Returns undefined when the slug does not look like an encoded path.
+ */
+function decodeProjectSlug(slug) {
+    if (!slug.startsWith("-"))
+        return undefined;
+    return slug.replace(/-/g, "/");
+}
+// ─── ClaudeCodeAdapter ───────────────────────────────────────────────────────
+export class ClaudeCodeAdapter {
+    id = "claude-code";
+    async normalize(input) {
+        const maxToolResultChars = typeof input.options?.["maxToolResultChars"] === "number"
+            ? input.options["maxToolResultChars"]
+            : MAX_TOOL_RESULT_CHARS;
+        const includeSubagents = input.options?.["includeSubagents"] === true;
+        // ── Process main session ──────────────────────────────────────────────────
+        const mainEntries = await readJsonlEntries(input.sourcePath);
+        const main = processEntries(mainEntries, maxToolResultChars, false, undefined);
+        const { sessionId, model, aiTitle, firstTimestamp: mainFirstTs, lastTimestamp: mainLastTs, thinkingBlockCount, truncationCount, assistantCount, userCount, otherCount } = main;
+        let inputTokens = main.inputTokens;
+        let outputTokens = main.outputTokens;
+        let cacheCreationTokens = main.cacheCreationTokens;
+        let cacheReadTokens = main.cacheReadTokens;
+        let allMessages = [...main.messages];
+        let firstTimestamp = mainFirstTs;
+        let lastTimestamp = mainLastTs;
+        const warnings = [PRIVACY_WARNING];
+        // Add thinking block warning if any were excluded
+        if (thinkingBlockCount > 0) {
+            warnings.push(`${thinkingBlockCount} thinking block(s) excluded — content is an opaque signed blob not suitable for trace analysis.`);
+        }
+        // Add truncation warning (updated after subagent processing below if needed)
+        // (handled after subagent loop)
+        // ── Process subagents ─────────────────────────────────────────────────────
+        const subagentProvenanceRecords = [];
+        let totalSubagentThinkingBlocks = thinkingBlockCount;
+        let totalTruncationCount = truncationCount;
+        if (includeSubagents) {
+            const subagentFiles = discoverSubagentJSONLFiles(input.sourcePath);
+            for (const subagentFile of subagentFiles) {
+                const subagentEntries = await readJsonlEntries(subagentFile);
+                // Derive agentId from the filename (e.g. a10161f797ef2c3ee.jsonl -> a10161f797ef2c3ee)
+                const subagentFileName = basename(subagentFile);
+                const fileAgentId = subagentFileName.replace(/\.jsonl$/, "");
+                const sub = processEntries(subagentEntries, maxToolResultChars, true, fileAgentId);
+                // Use agentId from entries if present; fall back to filename-derived id
+                const agentId = sub.agentId ?? fileAgentId;
+                // Accumulate totals
+                inputTokens += sub.inputTokens;
+                outputTokens += sub.outputTokens;
+                cacheCreationTokens += sub.cacheCreationTokens;
+                cacheReadTokens += sub.cacheReadTokens;
+                totalSubagentThinkingBlocks += sub.thinkingBlockCount;
+                totalTruncationCount += sub.truncationCount;
+                // Track timestamps across all sources
+                if (sub.firstTimestamp && (!firstTimestamp || sub.firstTimestamp < firstTimestamp)) {
+                    firstTimestamp = sub.firstTimestamp;
+                }
+                if (sub.lastTimestamp && (!lastTimestamp || sub.lastTimestamp > lastTimestamp)) {
+                    lastTimestamp = sub.lastTimestamp;
+                }
+                allMessages = allMessages.concat(sub.messages);
+                // Build provenance record
+                const subagentDir = dirname(subagentFile);
+                const metaPath = join(subagentDir, agentId, "meta.json");
+                const meta = await readSubagentMeta(metaPath);
+                const record = {
+                    agentId,
+                    entryCount: sub.assistantCount + sub.userCount
+                };
+                if (meta?.agentType !== undefined)
+                    record.agentType = meta.agentType;
+                if (meta?.description !== undefined)
+                    record.description = meta.description;
+                if (meta?.toolUseId !== undefined)
+                    record.toolUseId = meta.toolUseId;
+                subagentProvenanceRecords.push(record);
+            }
+            // Sort all messages by timestamp ascending
+            allMessages.sort((a, b) => {
+                const ta = a.timestamp ?? "";
+                const tb = b.timestamp ?? "";
+                return ta < tb ? -1 : ta > tb ? 1 : 0;
+            });
+        }
+        // Add thinking block warning (combined across main + subagents)
+        // Already added for main above; update if subagents added more
+        if (includeSubagents && totalSubagentThinkingBlocks > thinkingBlockCount) {
+            // Remove the main-only thinking block warning if it was added (update count)
+            const thinkingIdx = warnings.findIndex((w) => w.includes("thinking block(s) excluded"));
+            const totalThinking = totalSubagentThinkingBlocks;
+            if (thinkingIdx >= 0) {
+                warnings[thinkingIdx] = `${totalThinking} thinking block(s) excluded — content is an opaque signed blob not suitable for trace analysis.`;
+            }
+            else if (totalThinking > 0) {
+                warnings.push(`${totalThinking} thinking block(s) excluded — content is an opaque signed blob not suitable for trace analysis.`);
+            }
+        }
+        // Add truncation warning
+        if (totalTruncationCount > 0) {
+            warnings.push(`${totalTruncationCount} content item(s) truncated at ${maxToolResultChars} characters — full content in source session JSONL.`);
+        }
+        // Add subagent warning (conditional)
+        if (!includeSubagents) {
+            warnings.push(SUBAGENT_WARNING);
+        }
+        const now = new Date().toISOString();
+        const sessionPrefix = sessionId ? sessionId.slice(0, 8) : "unknown";
+        const title = aiTitle ?? `Claude Code session ${sessionPrefix}`;
+        const traceId = `claude-code-${sessionId ?? "unknown"}`;
+        const createdAt = firstTimestamp ?? now;
+        const durationMs = firstTimestamp && lastTimestamp
+            ? Math.max(0, new Date(lastTimestamp).getTime() - new Date(firstTimestamp).getTime())
+            : 0;
+        const totalTokens = inputTokens + outputTokens + cacheCreationTokens + cacheReadTokens;
+        const trace = {
+            id: traceId,
+            title,
+            artifactVersion: CURRENT_AGENT_TRACE_ARTIFACT_VERSION,
+            source: "real_captured",
+            createdAt,
+            generatedAt: now,
+            model,
+            durationMs,
+            messages: allMessages
+        };
+        const usage = createUsageMetadata({
+            inputTokens,
+            outputTokens,
+            totalTokens,
+            cacheReadInputTokens: cacheReadTokens,
+            cacheCreationInputTokens: cacheCreationTokens,
+            providerReportedTokens: true,
+            estimatedTokens: false,
+            model,
+            provider: "anthropic",
+            limitations: [
+                "Token counts are from the Claude Code session JSONL usage fields (actual API response metadata).",
+                "Cost is estimated from the Anthropic price table, not from billing records.",
+                "Cache read tokens priced at ~10% of standard input rate (estimated). Cache creation tokens priced at ~125% of standard input rate (estimated). Not billing-confirmed."
+            ]
+        });
+        const limitations = [
+            `Assistant entries: ${assistantCount}`,
+            `User entries: ${userCount}`,
+            `Other/excluded entries: ${otherCount}`,
+            `Thinking blocks excluded: ${thinkingBlockCount}`,
+            `Cache creation tokens (stored in provenance, not in cost estimate): ${cacheCreationTokens}`,
+            `Cache read tokens (stored in provenance, not in cost estimate): ${cacheReadTokens}`
+        ];
+        if (includeSubagents) {
+            limitations.push(`Subagents included: ${subagentProvenanceRecords.length} subagent JSONL file(s) processed.`);
+        }
+        // Per-run distinctness fingerprint: a one-way digest over the canonical normalized
+        // trace content (NOT raw content). It is computed from `trace` after capture-time
+        // fields (capturedAt/generatedAt/sourcePath/durationMs) are set, but those varying
+        // fields are intentionally NOT part of the digest input (see trace-fingerprint.ts),
+        // so re-capturing the same session yields the same fingerprint. Surfacing it lets
+        // distinct real sessions be told apart from re-captures without ever counting a
+        // re-capture as new.
+        const traceFingerprint = computeTraceFingerprint(trace);
+        const provenance = {
+            captureAdapter: this.id,
+            sourcePath: input.sourcePath,
+            capturedAt: now,
+            sessionId,
+            warnings,
+            limitations,
+            traceFingerprint,
+            ...(includeSubagents ? { subagents: subagentProvenanceRecords } : {})
+        };
+        return { trace, usage, provenance };
+    }
+}
+//# sourceMappingURL=claude-code-adapter.js.map

package/dist/core/adapters/claude-code-discovery.d.ts

@@ -0,0 +1,40 @@
+import type { ClaudeCodeSessionMetadata } from "./claude-code-adapter.js";
+/**
+ * Local, read-only discovery of available Claude Code sessions.
+ *
+ * Scans the standard Claude Code projects layout
+ * (`~/.claude/projects/<slug>/<session-id>.jsonl`) and returns metadata-only
+ * records for each discoverable session, reusing the existing adapter parser
+ * (`scanSessionMetadata`) so counts match what `capture claude-code --session`
+ * would produce. This module performs NO network calls, NO upload, and NO
+ * provider-API access — it only reads the local filesystem under the projects
+ * root (default `~/.claude/projects`, overridable for testability).
+ *
+ * Privacy: discovery surfaces metadata ONLY. It never reads or returns session
+ * message content into the listing. Session files themselves may contain local
+ * file content (consistent with the capture privacy warning).
+ */
+export declare const DISCOVERY_PRIVACY_NOTE: string;
+/** Resolve the default Claude Code projects root (~/.claude/projects). */
+export declare function defaultProjectsDir(): string;
+export interface DiscoverSessionsOptions {
+    /** Override the projects root directory (default: ~/.claude/projects). Read-only. */
+    projectsDir?: string;
+}
+export interface DiscoverSessionsResult {
+    /** The projects root that was scanned. */
+    projectsDir: string;
+    /** Whether the projects root exists. */
+    projectsDirExists: boolean;
+    /** Discovered sessions, sorted newest-first by lastTimestamp (then path). */
+    sessions: ClaudeCodeSessionMetadata[];
+}
+/**
+ * Discover all Claude Code sessions under the projects root.
+ *
+ * Layout scanned (read-only): <projectsDir>/<slug>/<session-id>.jsonl
+ * Each `<slug>` directory is one project; each top-level `.jsonl` within it is
+ * one session. (The `<session-id>/subagents/` sub-directory is NOT treated as a
+ * session; its file count is reported as the session's subagent count.)
+ */
+export declare function discoverClaudeCodeSessions(options?: DiscoverSessionsOptions): Promise<DiscoverSessionsResult>;

package/dist/core/adapters/claude-code-discovery.js

@@ -0,0 +1,100 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { scanSessionMetadata } from "./claude-code-adapter.js";
+/**
+ * Local, read-only discovery of available Claude Code sessions.
+ *
+ * Scans the standard Claude Code projects layout
+ * (`~/.claude/projects/<slug>/<session-id>.jsonl`) and returns metadata-only
+ * records for each discoverable session, reusing the existing adapter parser
+ * (`scanSessionMetadata`) so counts match what `capture claude-code --session`
+ * would produce. This module performs NO network calls, NO upload, and NO
+ * provider-API access — it only reads the local filesystem under the projects
+ * root (default `~/.claude/projects`, overridable for testability).
+ *
+ * Privacy: discovery surfaces metadata ONLY. It never reads or returns session
+ * message content into the listing. Session files themselves may contain local
+ * file content (consistent with the capture privacy warning).
+ */
+export const DISCOVERY_PRIVACY_NOTE = "Discovery is local and read-only: it scans your local Claude Code projects directory only " +
+    "(no network calls, no upload). It surfaces session metadata only — never session content. " +
+    "Note: the underlying session files may contain local file content; review captured artifacts " +
+    "before sharing.";
+/** Resolve the default Claude Code projects root (~/.claude/projects). */
+export function defaultProjectsDir() {
+    return join(homedir(), ".claude", "projects");
+}
+function isJsonlFile(name) {
+    return name.endsWith(".jsonl");
+}
+/**
+ * Discover all Claude Code sessions under the projects root.
+ *
+ * Layout scanned (read-only): <projectsDir>/<slug>/<session-id>.jsonl
+ * Each `<slug>` directory is one project; each top-level `.jsonl` within it is
+ * one session. (The `<session-id>/subagents/` sub-directory is NOT treated as a
+ * session; its file count is reported as the session's subagent count.)
+ */
+export async function discoverClaudeCodeSessions(options = {}) {
+    const projectsDir = options.projectsDir ?? defaultProjectsDir();
+    if (!existsSync(projectsDir)) {
+        return { projectsDir, projectsDirExists: false, sessions: [] };
+    }
+    let slugDirs;
+    try {
+        slugDirs = readdirSync(projectsDir).filter((name) => {
+            const full = join(projectsDir, name);
+            try {
+                return statSync(full).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    catch {
+        return { projectsDir, projectsDirExists: true, sessions: [] };
+    }
+    const sessions = [];
+    for (const slug of slugDirs) {
+        const slugPath = join(projectsDir, slug);
+        let sessionFiles;
+        try {
+            sessionFiles = readdirSync(slugPath).filter((name) => {
+                if (!isJsonlFile(name))
+                    return false;
+                const full = join(slugPath, name);
+                try {
+                    return statSync(full).isFile();
+                }
+                catch {
+                    return false;
+                }
+            });
+        }
+        catch {
+            continue;
+        }
+        for (const fileName of sessionFiles) {
+            const sessionPath = join(slugPath, fileName);
+            try {
+                const metadata = await scanSessionMetadata(sessionPath, slug);
+                sessions.push(metadata);
+            }
+            catch {
+                // Skip unreadable / malformed session files; discovery stays resilient.
+            }
+        }
+    }
+    // Sort newest-first by lastTimestamp, falling back to path for determinism.
+    sessions.sort((a, b) => {
+        const ta = a.lastTimestamp ?? "";
+        const tb = b.lastTimestamp ?? "";
+        if (ta !== tb)
+            return ta < tb ? 1 : -1;
+        return a.sessionPath < b.sessionPath ? -1 : a.sessionPath > b.sessionPath ? 1 : 0;
+    });
+    return { projectsDir, projectsDirExists: true, sessions };
+}
+//# sourceMappingURL=claude-code-discovery.js.map