@jingyi0605/codingns 0.7.4 → 0.8.0

package/node_modules/@codingns/session-sync-core/dist/providers/claude-code.js

@@ -1,1184 +0,0 @@
-import { basename, dirname, join } from "node:path";
-import { existsSync, rmSync, statSync, writeFileSync } from "node:fs";
-import crypto from "node:crypto";
-import { buildClaudeMessageSignature, buildClaudeProgressiveTrackKey, buildClaudeStableRawRef, normalizeClaudeMessagePart, normalizeClaudeMessageParts, readClaudeMessageId, shouldReuseClaudeProgressiveIdentity, toClaudeRecord } from "../claude-message-utils.js";
-import { appendJsonLine, createRawRef, encodeCursor, ensureDirectory, ensureText, messageIdFromRawRef, nextTimestamp, normalizeWorkspacePath, readFirstNonEmptyLine, readJsonLines, safeDate, sliceHistory } from "./utils.js";
-import { CLAUDE_CODE_SESSION_STORE_PROFILE } from "./claude-session-store.js";
-const HISTORY_CACHE_LIMIT = 6;
-const SESSION_SUMMARY_CACHE_LIMIT = 512;
-const DEFAULT_CLAUDE_CONTEXT_WINDOW = 200_000;
-export const CLAUDE_COMPAT_MODEL_OPTIONS = [
-    {
-        id: "provider-default",
-        name: "跟随 CLI 默认模型",
-        usesProviderDefault: true
-    },
-    {
-        id: "sonnet",
-        name: "Sonnet"
-    },
-    {
-        id: "opus",
-        name: "Opus"
-    },
-    {
-        id: "haiku",
-        name: "Haiku"
-    }
-];
-export class ClaudeCodeAdapter {
-    options;
-    providerId;
-    historyCache = new Map();
-    sessionSummaryCache = new Map();
-    constructor(options) {
-        this.options = options;
-        this.providerId = options.providerId ?? "claude-code";
-    }
-    async detectSessions(workspacePath, options) {
-        const discovery = await this.detectSessionsDetailed(workspacePath, options);
-        return discovery.sessions;
-    }
-    async detectSessionsDetailed(workspacePath, options) {
-        const startedAt = Date.now();
-        const targetPath = normalizeWorkspacePath(workspacePath);
-        const files = this.listWorkspaceFiles(workspacePath);
-        const subagentMetadataByFilePath = buildClaudeSubagentMetadataIndex(files);
-        const knownByRawStoreRef = new Map((options?.knownSessions ?? [])
-            .filter((session) => session.provider === this.providerId)
-            .map((session) => [session.rawStoreRef, session]));
-        const sessions = [];
-        let scannedFiles = 0;
-        let skippedByMtimeSize = 0;
-        let parsedFiles = 0;
-        let bytesRead = 0;
-        for (const filePath of files) {
-            scannedFiles += 1;
-            if (isPendingClaudeRuntimeFile(filePath)) {
-                continue;
-            }
-            if (shouldHideClaudeDebugSession(filePath)) {
-                continue;
-            }
-            const stats = statSync(filePath);
-            const cachedSummary = this.sessionSummaryCache.get(filePath);
-            const known = knownByRawStoreRef.get(filePath);
-            const subagentMetadata = subagentMetadataByFilePath.get(filePath);
-            const providerSessionId = subagentMetadata?.providerSessionId ?? basename(filePath, ".jsonl");
-            if (cachedSummary &&
-                cachedSummary.mtimeMs === stats.mtimeMs &&
-                cachedSummary.size === stats.size) {
-                this.touchSessionSummaryCache(filePath, cachedSummary);
-                skippedByMtimeSize += 1;
-                if (cachedSummary.summary &&
-                    normalizeWorkspacePath(cachedSummary.summary.workspacePath) === targetPath) {
-                    sessions.push({
-                        ...cachedSummary.summary,
-                        provider: this.providerId,
-                        providerSessionId,
-                        rawStoreRef: filePath,
-                        parentProviderSessionId: subagentMetadata?.parentProviderSessionId ?? null,
-                        isSubagent: subagentMetadata !== undefined,
-                        subagentLabel: cachedSummary.summary.subagentLabel ?? subagentMetadata?.subagentLabel ?? null,
-                        sourceMtimeMs: stats.mtimeMs,
-                        sourceSizeBytes: stats.size
-                    });
-                    continue;
-                }
-                if (cachedSummary.workspacePath &&
-                    normalizeWorkspacePath(cachedSummary.workspacePath) !== targetPath) {
-                    continue;
-                }
-            }
-            if (known
-                && known.sourceMtimeMs === stats.mtimeMs
-                && known.sourceSizeBytes === stats.size
-                && normalizeWorkspacePath(known.workspacePath) === targetPath) {
-                skippedByMtimeSize += 1;
-                sessions.push({
-                    ...known,
-                    provider: this.providerId,
-                    providerSessionId,
-                    rawStoreRef: filePath,
-                    parentProviderSessionId: subagentMetadata?.parentProviderSessionId ?? null,
-                    isSubagent: subagentMetadata !== undefined,
-                    subagentLabel: known.subagentLabel ?? subagentMetadata?.subagentLabel ?? null,
-                    sourceMtimeMs: stats.mtimeMs,
-                    sourceSizeBytes: stats.size
-                });
-                this.touchSessionSummaryCache(filePath, {
-                    filePath,
-                    mtimeMs: stats.mtimeMs,
-                    size: stats.size,
-                    workspacePath: known.workspacePath,
-                    summary: {
-                        ...known,
-                        provider: this.providerId,
-                        providerSessionId,
-                        rawStoreRef: filePath,
-                        parentProviderSessionId: subagentMetadata?.parentProviderSessionId ?? null,
-                        isSubagent: subagentMetadata !== undefined,
-                        subagentLabel: known.subagentLabel ?? subagentMetadata?.subagentLabel ?? null,
-                        sourceMtimeMs: stats.mtimeMs,
-                        sourceSizeBytes: stats.size
-                    }
-                });
-                continue;
-            }
-            parsedFiles += 1;
-            bytesRead += stats.size;
-            const records = readJsonLines(filePath);
-            const typedRecords = records.map((record) => record.data);
-            const detectedWorkspacePath = typedRecords
-                .map((record) => normalizeWorkspacePath(ensureText(record.cwd)))
-                .find((value) => value.length > 0) ?? null;
-            const matchesWorkspace = detectedWorkspacePath === targetPath;
-            if (!matchesWorkspace) {
-                this.touchSessionSummaryCache(filePath, {
-                    filePath,
-                    mtimeMs: stats.mtimeMs,
-                    size: stats.size,
-                    workspacePath: detectedWorkspacePath,
-                    summary: null
-                });
-                continue;
-            }
-            const messages = this.parseMessages(filePath, typedRecords);
-            const title = this.resolveDetectedClaudeTitle(typedRecords, messages, filePath);
-            const lastMessageAt = messages.at(-1)?.timestamp ??
-                (ensureText(typedRecords.at(-1)?.timestamp) || null);
-            const summary = {
-                provider: this.providerId,
-                providerSessionId,
-                title,
-                workspacePath,
-                rawStoreRef: filePath,
-                lastMessageAt,
-                messageCount: messages.length,
-                parentProviderSessionId: subagentMetadata?.parentProviderSessionId ?? null,
-                isSubagent: subagentMetadata !== undefined,
-                subagentLabel: subagentMetadata?.subagentLabel ?? null,
-                sourceMtimeMs: stats.mtimeMs,
-                sourceSizeBytes: stats.size
-            };
-            sessions.push(summary);
-            this.touchSessionSummaryCache(filePath, {
-                filePath,
-                mtimeMs: stats.mtimeMs,
-                size: stats.size,
-                workspacePath,
-                summary
-            });
-        }
-        const sortedSessions = sessions.sort((left, right) => (left.lastMessageAt ?? "").localeCompare(right.lastMessageAt ?? ""));
-        const diagnostic = {
-            provider: this.providerId,
-            status: "success",
-            durationMs: Date.now() - startedAt,
-            sessionCount: sortedSessions.length,
-            isComplete: true,
-            errorMessage: null,
-            scannedFiles,
-            skippedByMtimeSize,
-            parsedFiles,
-            bytesRead
-        };
-        return {
-            sessions: sortedSessions,
-            isComplete: true,
-            providerDiagnostics: [diagnostic]
-        };
-    }
-    async readSessionHistory(providerSessionId, rawStoreRef, cursor, limit, direction = "forward") {
-        const messages = this.getParsedMessages(rawStoreRef, providerSessionId);
-        return sliceHistory(messages, cursor, limit, direction);
-    }
-    subscribeSession(providerSessionId, rawStoreRef, cursor, limit, onEvent) {
-        let currentCursor = cursor;
-        let lastMtime = statSync(rawStoreRef).mtimeMs;
-        const timer = setInterval(async () => {
-            const nextStat = statSync(rawStoreRef);
-            if (nextStat.mtimeMs <= lastMtime) {
-                return;
-            }
-            lastMtime = nextStat.mtimeMs;
-            const page = await this.readSessionHistory(providerSessionId, rawStoreRef, currentCursor, limit);
-            if (page.messages.length === 0) {
-                return;
-            }
-            currentCursor = page.cursor;
-            await onEvent({
-                messages: page.messages,
-                cursor: page.cursor
-            });
-        }, 300);
-        return {
-            close() {
-                clearInterval(timer);
-            }
-        };
-    }
-    async resumeSession(providerSessionId, rawStoreRef) {
-        statSync(rawStoreRef);
-        return {
-            provider: this.providerId,
-            providerSessionId,
-            resumedAt: nextTimestamp(),
-            rawStoreRef
-        };
-    }
-    async startSession(workspacePath, options) {
-        const sessionId = crypto.randomUUID();
-        const filePath = this.getSessionStoreProfile().resolveSessionFilePath(this.options.homeDir, workspacePath, sessionId);
-        const projectDir = dirname(filePath);
-        ensureDirectory(projectDir);
-        const now = nextTimestamp();
-        appendJsonLine(filePath, {
-            type: "queue-operation",
-            operation: "enqueue",
-            timestamp: now,
-            sessionId
-        });
-        if (options.initialPrompt) {
-            appendJsonLine(filePath, {
-                parentUuid: null,
-                isSidechain: false,
-                promptId: crypto.randomUUID(),
-                type: "user",
-                message: {
-                    role: "user",
-                    content: [{ type: "text", text: options.initialPrompt }]
-                },
-                uuid: crypto.randomUUID(),
-                timestamp: now,
-                cwd: workspacePath,
-                sessionId
-            });
-        }
-        appendJsonLine(filePath, {
-            type: "ai-title",
-            sessionId,
-            aiTitle: options.initialPrompt?.slice(0, 48) || this.getDefaultSessionTitle()
-        });
-        return {
-            session: {
-                provider: this.providerId,
-                providerSessionId: sessionId,
-                title: options.initialPrompt?.slice(0, 48) || this.getDefaultSessionTitle(),
-                workspacePath,
-                rawStoreRef: filePath,
-                isArchived: false,
-                lastMessageAt: now,
-                messageCount: options.initialPrompt ? 1 : 0
-            },
-            initialCursor: encodeCursor(options.initialPrompt ? 1 : 0)
-        };
-    }
-    async forkSession(providerSessionId, workspacePath, options) {
-        const sourceFilePath = this.resolveForkSourceFilePath(options.rawStoreRef, providerSessionId, workspacePath);
-        const sourceRecords = readJsonLines(sourceFilePath).map((record) => record.data);
-        const forkedSessionId = crypto.randomUUID();
-        const targetFilePath = this.getSessionStoreProfile().resolveSessionFilePath(this.options.homeDir, workspacePath, forkedSessionId);
-        const projectDir = dirname(targetFilePath);
-        ensureDirectory(projectDir);
-        let forkedRecords = sourceRecords.map((record) => cloneJsonRecord(record));
-        let providerSourceMessageId = null;
-        let forkMethod = "native_session_fork";
-        if (options.sourceType === "message") {
-            const targetMessageId = options.sourceMessageId?.trim();
-            if (!targetMessageId) {
-                throw new Error("FORK_SOURCE_MESSAGE_ID_REQUIRED");
-            }
-            const target = this.locateForkTarget(sourceRecords, providerSessionId, targetMessageId);
-            if (!target) {
-                throw new Error("FORK_SOURCE_MESSAGE_NOT_FOUND");
-            }
-            forkedRecords = forkedRecords.slice(0, target.recordIndex + 1);
-            forkedRecords[target.recordIndex] = truncateClaudeForkRecord(forkedRecords[target.recordIndex], target, options.sourceMessageSnapshot ?? null);
-            providerSourceMessageId = target.providerSourceMessageId;
-            forkMethod = "native_message_fork";
-        }
-        const persistedForkRecords = forkedRecords
-            // fork 后的标题必须由子会话自己生成，不能把父会话的 ai-title 原样抄过去。
-            .filter((record) => shouldPreserveClaudeForkRecord(record));
-        const serializedRecords = persistedForkRecords
-            .map((record) => replaceClaudeRecordSessionId(record, forkedSessionId))
-            .map((record) => JSON.stringify(record))
-            .join("\n");
-        writeFileSync(targetFilePath, `${serializedRecords}\n`, "utf8");
-        this.historyCache.delete(targetFilePath);
-        this.sessionSummaryCache.delete(targetFilePath);
-        const messages = this.getParsedMessages(targetFilePath, forkedSessionId);
-        const title = this.resolveClaudeTitle(persistedForkRecords) || "";
-        return {
-            session: {
-                provider: this.providerId,
-                providerSessionId: forkedSessionId,
-                title,
-                workspacePath,
-                rawStoreRef: targetFilePath,
-                isArchived: false,
-                lastMessageAt: messages.at(-1)?.timestamp ?? nextTimestamp(),
-                messageCount: messages.length,
-                parentProviderSessionId: null,
-                isSubagent: false,
-                subagentLabel: null
-            },
-            forkMethod,
-            forkSourceType: options.sourceType,
-            inheritedPrefixMessageCount: messages.length,
-            providerSourceMessageId
-        };
-    }
-    async sendMessage(providerSessionId, rawStoreRef, content, clientRequestId, _permissionMode) {
-        const records = readJsonLines(rawStoreRef).map((record) => record.data);
-        const lineNumber = records.length + 1;
-        const acceptedAt = nextTimestamp();
-        const cwd = records
-            .map((record) => ensureText(record.cwd))
-            .find((value) => value.length > 0) ?? "";
-        appendJsonLine(rawStoreRef, {
-            parentUuid: null,
-            isSidechain: false,
-            promptId: crypto.randomUUID(),
-            type: "user",
-            message: {
-                role: "user",
-                content: [{ type: "text", text: content }]
-            },
-            uuid: crypto.randomUUID(),
-            timestamp: acceptedAt,
-            cwd,
-            sessionId: providerSessionId,
-            clientRequestId
-        });
-        const rawRef = createRawRef(this.providerId, rawStoreRef, lineNumber, 0);
-        this.historyCache.delete(rawStoreRef);
-        this.sessionSummaryCache.delete(rawStoreRef);
-        return {
-            acceptedAt,
-            clientRequestId,
-            message: {
-                messageId: messageIdFromRawRef(rawRef),
-                provider: this.providerId,
-                providerSessionId,
-                role: "user",
-                kind: "text",
-                content,
-                toolCall: null,
-                timestamp: acceptedAt,
-                sequence: this.parseMessages(rawStoreRef, readJsonLines(rawStoreRef).map((record) => record.data), providerSessionId).length,
-                rawRef
-            }
-        };
-    }
-    async readSessionTitle(providerSessionId, rawStoreRef) {
-        if (isPendingClaudeRuntimeRef(providerSessionId, rawStoreRef)) {
-            return "";
-        }
-        statSync(rawStoreRef);
-        const records = readJsonLines(rawStoreRef).map((record) => record.data);
-        const messages = this.parseMessages(rawStoreRef, records, providerSessionId);
-        return this.resolveDetectedClaudeTitle(records, messages, rawStoreRef);
-    }
-    async renameSessionTitle(providerSessionId, rawStoreRef, title) {
-        const nextTitle = title.trim();
-        statSync(rawStoreRef);
-        appendJsonLine(rawStoreRef, {
-            type: "ai-title",
-            sessionId: providerSessionId,
-            aiTitle: nextTitle
-        });
-        this.historyCache.delete(rawStoreRef);
-        this.sessionSummaryCache.delete(rawStoreRef);
-        return nextTitle;
-    }
-    async updateSessionArchiveState() {
-        throw new Error("claude-code archive state is managed by host");
-    }
-    async deleteSession(providerSessionId, rawStoreRef) {
-        const targetFilePath = this.resolveForkSourceFilePath(rawStoreRef, providerSessionId);
-        if (!existsSync(targetFilePath)) {
-            throw new Error("PROVIDER_SESSION_NOT_FOUND");
-        }
-        rmSync(targetFilePath, { force: true });
-        this.historyCache.delete(targetFilePath);
-        this.sessionSummaryCache.delete(targetFilePath);
-    }
-    getProviderCapabilities() {
-        return {
-            provider: this.providerId,
-            canStartSession: true,
-            canResumeSession: true,
-            canSendMessage: true,
-            inRunInputMode: "streaming_guidance",
-            supportsSubagents: true,
-            supportsInterrupt: false,
-            supportsStructuredToolCalls: true,
-            supportsTokenUsage: true,
-            supportsAttachments: true,
-            supportsPermissionPrompt: true,
-            supportsPermissionRequests: true,
-            supportsSessionFork: true,
-            supportsSessionDelete: true,
-            supportsCheckpoint: false,
-            modelOptions: this.options.modelOptions ?? CLAUDE_COMPAT_MODEL_OPTIONS,
-            limitations: this.options.capabilityLimitations
-                ?? ["当前实现只读取原生 jsonl，会话恢复不负责拉起外部 Claude 进程。"]
-        };
-    }
-    async getSessionCapabilities() {
-        return this.getProviderCapabilities();
-    }
-    async readContextUsage(providerSessionId, rawStoreRef) {
-        statSync(rawStoreRef);
-        const records = readJsonLines(rawStoreRef).map((record) => record.data);
-        for (let index = records.length - 1; index >= 0; index -= 1) {
-            const snapshot = extractClaudeUsageSnapshot(records[index]);
-            if (!snapshot) {
-                continue;
-            }
-            const uncachedInputTokens = readNonNegativeInteger(snapshot.usage.input_tokens) ?? 0;
-            const cacheCreationInputTokens = readNonNegativeInteger(snapshot.usage.cache_creation_input_tokens) ?? 0;
-            const cacheReadInputTokens = readNonNegativeInteger(snapshot.usage.cache_read_input_tokens) ?? 0;
-            const cachedInputTokens = cacheCreationInputTokens + cacheReadInputTokens;
-            const promptTokens = uncachedInputTokens + cachedInputTokens;
-            const modelId = ensureText(snapshot.model ?? snapshot.recordModel).trim() || null;
-            const contextWindow = resolveClaudeContextWindow(modelId);
-            return {
-                provider: this.providerId,
-                promptTokens,
-                uncachedInputTokens,
-                cachedInputTokens,
-                contextWindow,
-                usageRatio: clampClaudeUsageRatio(promptTokens, contextWindow),
-                source: "provider-log",
-                contextWindowSource: "model-map",
-                modelId,
-                capturedAt: safeDate(snapshot.timestamp, "").trim() || null,
-                isEstimated: true
-            };
-        }
-        return null;
-    }
-    resolveClaudeTitle(records) {
-        // Claude 会在会话过程中多次刷新 ai-title，取最后一个有效值才是当前标题。
-        for (let index = records.length - 1; index >= 0; index -= 1) {
-            const record = records[index];
-            if (record?.type !== "ai-title") {
-                continue;
-            }
-            const title = ensureText(record.aiTitle).trim();
-            if (title.length > 0) {
-                return title;
-            }
-        }
-        return "";
-    }
-    resolveDetectedClaudeTitle(records, messages, rawStoreRef) {
-        return (this.resolveClaudeTitle(records) ||
-            resolveClaudeFallbackTitle(messages) ||
-            this.resolveClaudeSlug(records) ||
-            basename(rawStoreRef, ".jsonl"));
-    }
-    resolveClaudeSlug(records) {
-        for (let index = records.length - 1; index >= 0; index -= 1) {
-            const slug = ensureText(records[index]?.slug).trim();
-            if (slug.length > 0) {
-                return slug;
-            }
-        }
-        return "";
-    }
-    listWorkspaceFiles(workspacePath) {
-        return this.getSessionStoreProfile().resolveWorkspaceFiles(this.options.homeDir, workspacePath);
-    }
-    resolveForkSourceFilePath(rawStoreRef, providerSessionId, workspacePath = "") {
-        if (existsSync(rawStoreRef)) {
-            return rawStoreRef;
-        }
-        const discoveredFilePath = this.getSessionStoreProfile().findSessionFile(this.options.homeDir, workspacePath, providerSessionId);
-        if (discoveredFilePath) {
-            return discoveredFilePath;
-        }
-        throw new Error("PROVIDER_SESSION_NOT_FOUND");
-    }
-    locateForkTarget(records, providerSessionId, sourceMessageId) {
-        const toolNameById = new Map();
-        const stableMessageRefByIdentity = new Map();
-        const progressiveMessagesByTrackKey = new Map();
-        let sequence = 0;
-        let matched = null;
-        records.forEach((record, recordIndex) => {
-            this.collectMessageEnvelopes(record).forEach((envelope) => {
-                const parts = normalizeClaudeMessageParts(envelope.message.content);
-                parts.forEach((part, partIndex) => {
-                    const normalized = normalizeClaudeMessagePart({
-                        part,
-                        envelope,
-                        providerId: this.providerId,
-                        providerSessionId,
-                        partIndex,
-                        timestamp: safeDate(envelope.timestamp, nextTimestamp()),
-                        toolNameById,
-                        resolveStableMessageRef: (identity) => {
-                            const existing = stableMessageRefByIdentity.get(identity);
-                            if (existing) {
-                                return existing;
-                            }
-                            sequence += 1;
-                            const created = {
-                                sequence,
-                                rawRef: buildClaudeStableRawRef(identity, this.providerId)
-                            };
-                            stableMessageRefByIdentity.set(identity, created);
-                            return created;
-                        }
-                    });
-                    if (!normalized) {
-                        return;
-                    }
-                    if (normalized.role === "user") {
-                        progressiveMessagesByTrackKey.clear();
-                    }
-                    const trackKey = buildClaudeProgressiveTrackKey(normalized, partIndex);
-                    const previousProgressive = trackKey
-                        ? progressiveMessagesByTrackKey.get(trackKey) ?? null
-                        : null;
-                    const nextMessage = previousProgressive && shouldReuseClaudeProgressiveIdentity(previousProgressive, normalized)
-                        ? {
-                            ...normalized,
-                            messageId: previousProgressive.messageId,
-                            rawRef: previousProgressive.rawRef,
-                            sequence: previousProgressive.sequence
-                        }
-                        : normalized;
-                    if (trackKey) {
-                        progressiveMessagesByTrackKey.set(trackKey, nextMessage);
-                    }
-                    if (nextMessage.messageId === sourceMessageId) {
-                        matched = {
-                            recordIndex,
-                            partIndex,
-                            recordSource: envelope.source,
-                            providerSourceMessageId: envelope.messageId
-                        };
-                    }
-                });
-            });
-        });
-        return matched;
-    }
-    getParsedMessages(filePath, providerSessionId) {
-        const stats = statSync(filePath);
-        const cached = this.historyCache.get(filePath);
-        if (cached
-            && cached.providerSessionId === providerSessionId
-            && cached.mtimeMs === stats.mtimeMs
-            && cached.size === stats.size) {
-            this.touchHistoryCache(filePath, cached);
-            return cached.messages;
-        }
-        const records = readJsonLines(filePath).map((record) => record.data);
-        const messages = this.parseMessages(filePath, records, providerSessionId);
-        this.touchHistoryCache(filePath, {
-            filePath,
-            providerSessionId,
-            mtimeMs: stats.mtimeMs,
-            size: stats.size,
-            messages
-        });
-        return messages;
-    }
-    touchHistoryCache(filePath, entry) {
-        this.historyCache.delete(filePath);
-        this.historyCache.set(filePath, entry);
-        while (this.historyCache.size > HISTORY_CACHE_LIMIT) {
-            const oldestKey = this.historyCache.keys().next().value;
-            if (!oldestKey) {
-                break;
-            }
-            this.historyCache.delete(oldestKey);
-        }
-    }
-    touchSessionSummaryCache(filePath, entry) {
-        this.sessionSummaryCache.delete(filePath);
-        this.sessionSummaryCache.set(filePath, entry);
-        while (this.sessionSummaryCache.size > SESSION_SUMMARY_CACHE_LIMIT) {
-            const oldestKey = this.sessionSummaryCache.keys().next().value;
-            if (!oldestKey) {
-                break;
-            }
-            this.sessionSummaryCache.delete(oldestKey);
-        }
-    }
-    parseMessages(filePath, records, providerSessionId = basename(filePath, ".jsonl")) {
-        const messageEntries = [];
-        const entryIndexByMessageId = new Map();
-        const toolNameById = new Map();
-        const stableMessageRefByIdentity = new Map();
-        const progressiveMessagesByTrackKey = new Map();
-        let sequence = 0;
-        let nextGroupOrder = 0;
-        const groupOrderByKey = new Map();
-        records.forEach((record, recordIndex) => {
-            this.collectMessageEnvelopes(record).forEach((envelope, envelopeIndex) => {
-                const parts = normalizeClaudeMessageParts(envelope.message.content);
-                const groupKey = buildClaudeEnvelopeGroupKey(envelope, record, recordIndex, envelopeIndex);
-                const groupOrder = (() => {
-                    const existing = groupOrderByKey.get(groupKey);
-                    if (existing !== undefined) {
-                        return existing;
-                    }
-                    nextGroupOrder += 1;
-                    groupOrderByKey.set(groupKey, nextGroupOrder);
-                    return nextGroupOrder;
-                })();
-                parts.forEach((part, partIndex) => {
-                    const normalized = normalizeClaudeMessagePart({
-                        part,
-                        envelope,
-                        providerId: this.providerId,
-                        providerSessionId,
-                        partIndex,
-                        timestamp: safeDate(envelope.timestamp, nextTimestamp()),
-                        toolNameById,
-                        resolveStableMessageRef: (identity) => {
-                            const existing = stableMessageRefByIdentity.get(identity);
-                            if (existing) {
-                                return existing;
-                            }
-                            sequence += 1;
-                            const created = {
-                                sequence,
-                                rawRef: buildClaudeStableRawRef(identity, this.providerId)
-                            };
-                            stableMessageRefByIdentity.set(identity, created);
-                            return created;
-                        }
-                    });
-                    if (!normalized) {
-                        return;
-                    }
-                    if (normalized.role === "user") {
-                        progressiveMessagesByTrackKey.clear();
-                    }
-                    const trackKey = buildClaudeProgressiveTrackKey(normalized, partIndex);
-                    const previousProgressive = trackKey
-                        ? progressiveMessagesByTrackKey.get(trackKey) ?? null
-                        : null;
-                    const nextMessage = previousProgressive && shouldReuseClaudeProgressiveIdentity(previousProgressive, normalized)
-                        ? {
-                            ...normalized,
-                            messageId: previousProgressive.messageId,
-                            rawRef: previousProgressive.rawRef,
-                            sequence: previousProgressive.sequence
-                        }
-                        : normalized;
-                    if (trackKey) {
-                        progressiveMessagesByTrackKey.set(trackKey, nextMessage);
-                    }
-                    const signature = buildClaudeMessageSignature(nextMessage);
-                    const currentEntryIndex = entryIndexByMessageId.get(nextMessage.messageId);
-                    const current = currentEntryIndex === undefined
-                        ? null
-                        : (messageEntries[currentEntryIndex]?.message ?? null);
-                    if (current && buildClaudeMessageSignature(current) === signature) {
-                        return;
-                    }
-                    if (currentEntryIndex === undefined) {
-                        entryIndexByMessageId.set(nextMessage.messageId, messageEntries.length);
-                        messageEntries.push({
-                            message: nextMessage,
-                            groupOrder,
-                            partIndex
-                        });
-                        return;
-                    }
-                    messageEntries[currentEntryIndex] = {
-                        message: nextMessage,
-                        groupOrder,
-                        partIndex
-                    };
-                });
-            });
-        });
-        return messageEntries
-            .sort((left, right) => {
-            if (left.groupOrder !== right.groupOrder) {
-                return left.groupOrder - right.groupOrder;
-            }
-            const kindOrder = resolveClaudeHistoryKindOrder(left.message.kind)
-                - resolveClaudeHistoryKindOrder(right.message.kind);
-            if (kindOrder !== 0) {
-                return kindOrder;
-            }
-            if (left.partIndex !== right.partIndex) {
-                return left.partIndex - right.partIndex;
-            }
-            const timestampOrder = left.message.timestamp.localeCompare(right.message.timestamp);
-            if (timestampOrder !== 0) {
-                return timestampOrder;
-            }
-            return left.message.rawRef.localeCompare(right.message.rawRef);
-        })
-            .map((entry, index) => ({
-            ...entry.message,
-            sequence: index + 1
-        }));
-    }
-    collectMessageEnvelopes(record) {
-        const envelopes = [];
-        const directType = ensureText(record.type);
-        const directMessage = toClaudeRecord(record.message);
-        if (directType === "user" || directType === "assistant") {
-            envelopes.push({
-                type: directType,
-                source: "direct",
-                messageId: readClaudeMessageId(directMessage, record),
-                timestamp: record.timestamp,
-                message: directMessage
-            });
-        }
-        const progressMessage = this.readProgressEnvelope(record);
-        if (progressMessage) {
-            envelopes.push(progressMessage);
-        }
-        return envelopes;
-    }
-    readProgressEnvelope(record) {
-        if (ensureText(record.type) !== "progress") {
-            return null;
-        }
-        const nested = toClaudeRecord(toClaudeRecord(record.data).message);
-        const nestedType = ensureText(nested.type);
-        const nestedMessage = toClaudeRecord(nested.message);
-        if (nestedType !== "user" && nestedType !== "assistant") {
-            return null;
-        }
-        return {
-            type: nestedType,
-            source: "progress",
-            messageId: readClaudeMessageId(nestedMessage, nested),
-            timestamp: nested.timestamp ?? record.timestamp,
-            message: nestedMessage
-        };
-    }
-    getSessionStoreProfile() {
-        return this.options.sessionStoreProfile ?? CLAUDE_CODE_SESSION_STORE_PROFILE;
-    }
-    getDefaultSessionTitle() {
-        return this.options.defaultSessionTitle ?? "New Claude Code session";
-    }
-}
-function buildClaudeEnvelopeGroupKey(envelope, record, recordIndex, envelopeIndex) {
-    if (envelope.messageId) {
-        return `${envelope.type}:message:${envelope.messageId}`;
-    }
-    const sessionId = ensureText(record.sessionId).trim()
-        || ensureText(record.session_id).trim()
-        || "unknown";
-    const timestamp = ensureText(record.timestamp).trim() || `record-${recordIndex}`;
-    return `${envelope.type}:${envelope.source}:${sessionId}:${timestamp}:${recordIndex}:${envelopeIndex}`;
-}
-function resolveClaudeHistoryKindOrder(kind) {
-    switch (kind) {
-        case "thinking":
-            return 0;
-        case "text":
-            return 1;
-        case "tool_call":
-            return 2;
-        case "tool_result":
-            return 3;
-        default:
-            return 4;
-    }
-}
-function isPendingClaudeRuntimeRef(providerSessionId, rawStoreRef) {
-    if (providerSessionId.trim().toLowerCase().startsWith("pending://")) {
-        return true;
-    }
-    const normalizedRawStoreRef = rawStoreRef.replaceAll("\\", "/").toLowerCase();
-    return normalizedRawStoreRef.includes("/.pending-");
-}
-function resolveClaudeFallbackTitle(messages) {
-    const preferredMessage = messages.find((message) => message.role === "user" && !looksLikeClaudeSyntheticTitleMessage(message.content));
-    if (preferredMessage) {
-        return normalizeClaudeMessageTitle(preferredMessage.content);
-    }
-    const firstUserMessage = messages.find((message) => message.role === "user");
-    return normalizeClaudeMessageTitle(firstUserMessage?.content);
-}
-function normalizeClaudeMessageTitle(content) {
-    const normalized = ensureText(content).trim().replace(/\s+/g, " ");
-    if (normalized.length === 0) {
-        return null;
-    }
-    return normalized.slice(0, 48);
-}
-function looksLikeClaudeSyntheticTitleMessage(content) {
-    const normalized = content.trim();
-    if (normalized.length === 0) {
-        return true;
-    }
-    if (looksLikeClaudeRulesMessage(normalized)) {
-        return true;
-    }
-    return /^<(?:ide_[a-z0-9_:-]+|local-command-[a-z0-9_:-]+|command-name)>[\s\S]*$/i.test(normalized);
-}
-function looksLikeClaudeRulesMessage(content) {
-    const beginsWithRulesHeader = /^#?\s*AGENTS\.md instructions for\b/i.test(content);
-    if (beginsWithRulesHeader) {
-        return true;
-    }
-    return /AGENTS\.md instructions for/i.test(content)
-        && /<INSTRUCTIONS>/i.test(content);
-}
-function cloneJsonRecord(value) {
-    return JSON.parse(JSON.stringify(value));
-}
-function replaceClaudeRecordSessionId(record, sessionId) {
-    const nextRecord = cloneJsonRecord(record);
-    replaceClaudeSessionIdRecursive(nextRecord, sessionId);
-    return nextRecord;
-}
-function replaceClaudeSessionIdRecursive(value, sessionId) {
-    if (!value || typeof value !== "object") {
-        return;
-    }
-    if (Array.isArray(value)) {
-        value.forEach((item) => replaceClaudeSessionIdRecursive(item, sessionId));
-        return;
-    }
-    const record = value;
-    if (typeof record.sessionId === "string" && record.sessionId.trim().length > 0) {
-        record.sessionId = sessionId;
-    }
-    Object.values(record).forEach((nested) => replaceClaudeSessionIdRecursive(nested, sessionId));
-}
-function truncateClaudeForkRecord(record, target, snapshot = null) {
-    const nextRecord = cloneJsonRecord(record);
-    if (target.recordSource === "progress") {
-        const progressData = toClaudeRecord(nextRecord.data);
-        const nestedEnvelope = toClaudeRecord(progressData.message);
-        nestedEnvelope.message = truncateClaudeMessageContent(toClaudeRecord(nestedEnvelope.message), target.partIndex, snapshot);
-        progressData.message = nestedEnvelope;
-        nextRecord.data = progressData;
-        return nextRecord;
-    }
-    nextRecord.message = truncateClaudeMessageContent(toClaudeRecord(nextRecord.message), target.partIndex, snapshot);
-    return nextRecord;
-}
-function truncateClaudeMessageContent(message, partIndex, snapshot = null) {
-    const content = message.content;
-    if (Array.isArray(content)) {
-        const truncated = content.slice(0, partIndex + 1);
-        const targetPart = truncated[partIndex];
-        if (snapshot && targetPart && typeof targetPart === "object" && !Array.isArray(targetPart)) {
-            const nextPart = { ...targetPart };
-            if (snapshot.kind === "thinking") {
-                nextPart.thinking = snapshot.content;
-            }
-            else {
-                nextPart.text = snapshot.content;
-            }
-            truncated[partIndex] = nextPart;
-        }
-        message.content = truncated;
-    }
-    return message;
-}
-function shouldPreserveClaudeForkRecord(record) {
-    return record.type !== "ai-title";
-}
-function buildClaudeSubagentMetadataIndex(files) {
-    const metadataByFilePath = new Map();
-    const filePathSet = new Set(files);
-    for (const filePath of files) {
-        const metadata = parseClaudeSubagentPathMetadata(filePath);
-        if (!metadata) {
-            continue;
-        }
-        metadataByFilePath.set(filePath, metadata);
-    }
-    for (const filePath of files) {
-        const records = readJsonLines(filePath).map((record) => record.data);
-        const taskSpawnMetadata = parseClaudeTaskSpawnMetadata(filePath, records, filePathSet);
-        for (const [childFilePath, metadata] of taskSpawnMetadata) {
-            const existing = metadataByFilePath.get(childFilePath);
-            if (!existing) {
-                metadataByFilePath.set(childFilePath, metadata);
-                continue;
-            }
-            metadataByFilePath.set(childFilePath, {
-                ...existing,
-                subagentLabel: existing.subagentLabel ?? metadata.subagentLabel
-            });
-        }
-    }
-    return metadataByFilePath;
-}
-function parseClaudeSubagentPathMetadata(filePath) {
-    const normalizedPath = filePath.replaceAll("\\", "/");
-    const matched = normalizedPath.match(/\/([^/]+)\/subagents\/([^/]+)\.jsonl$/i);
-    if (!matched?.[1] || !matched[2]) {
-        return null;
-    }
-    const parentProviderSessionId = matched[1];
-    const agentFileName = matched[2];
-    return {
-        providerSessionId: `${parentProviderSessionId}::${agentFileName}`,
-        parentProviderSessionId,
-        subagentLabel: readClaudeSubagentMetaLabel(filePath)
-    };
-}
-function parseClaudeTaskSpawnMetadata(filePath, records, filePathSet) {
-    const taskSpawnMetadata = new Map();
-    const taskRequestByToolId = new Map();
-    const parentDir = dirname(filePath);
-    for (const record of records) {
-        const sessionId = ensureText(record.sessionId).trim();
-        if (!sessionId) {
-            continue;
-        }
-        for (const message of collectClaudeRecordMessages(record)) {
-            if (message.role === "assistant") {
-                for (const taskRequest of extractClaudeTaskRequests(message.message)) {
-                    taskRequestByToolId.set(taskRequest.toolUseId, {
-                        parentProviderSessionId: sessionId,
-                        subagentLabel: formatClaudeSubagentLabel(taskRequest.subagentType, taskRequest.description)
-                    });
-                }
-                continue;
-            }
-            if (message.role !== "user") {
-                continue;
-            }
-            for (const toolUseId of extractClaudeToolResultIds(message.message)) {
-                const taskRequest = taskRequestByToolId.get(toolUseId);
-                const agentFileName = normalizeClaudeAgentFileName(readClaudeTaskResultAgentId(record));
-                if (!taskRequest || !agentFileName) {
-                    continue;
-                }
-                const childFilePath = join(parentDir, `${agentFileName}.jsonl`);
-                if (!filePathSet.has(childFilePath)) {
-                    continue;
-                }
-                taskSpawnMetadata.set(childFilePath, {
-                    providerSessionId: `${taskRequest.parentProviderSessionId}::${agentFileName}`,
-                    parentProviderSessionId: taskRequest.parentProviderSessionId,
-                    subagentLabel: taskRequest.subagentLabel
-                });
-            }
-        }
-    }
-    return taskSpawnMetadata;
-}
-function collectClaudeRecordMessages(record) {
-    const messages = [];
-    const directRole = ensureText(toClaudeRecord(record.message).role).trim();
-    const directMessage = toClaudeRecord(record.message);
-    if ((directRole === "assistant" || directRole === "user") && Object.keys(directMessage).length > 0) {
-        messages.push({
-            role: directRole,
-            message: directMessage
-        });
-    }
-    if (ensureText(record.type) !== "progress") {
-        return messages;
-    }
-    const nested = toClaudeRecord(toClaudeRecord(record.data).message);
-    const nestedRole = ensureText(toClaudeRecord(nested.message).role).trim();
-    const nestedMessage = toClaudeRecord(nested.message);
-    if ((nestedRole === "assistant" || nestedRole === "user") && Object.keys(nestedMessage).length > 0) {
-        messages.push({
-            role: nestedRole,
-            message: nestedMessage
-        });
-    }
-    return messages;
-}
-function extractClaudeTaskRequests(message) {
-    const content = Array.isArray(message.content) ? message.content : [];
-    const requests = [];
-    for (const item of content) {
-        const part = toClaudeRecord(item);
-        const partType = ensureText(part.type).trim();
-        const toolUseId = ensureText(part.id).trim();
-        const toolName = ensureText(part.name).trim();
-        if (partType !== "tool_use" || toolName !== "Task" || !toolUseId) {
-            continue;
-        }
-        const input = toClaudeRecord(part.input);
-        requests.push({
-            toolUseId,
-            subagentType: ensureText(input.subagent_type).trim(),
-            description: ensureText(input.description).trim()
-        });
-    }
-    return requests;
-}
-function extractClaudeToolResultIds(message) {
-    const content = Array.isArray(message.content) ? message.content : [];
-    const toolResultIds = [];
-    for (const item of content) {
-        const part = toClaudeRecord(item);
-        if (ensureText(part.type).trim() !== "tool_result") {
-            continue;
-        }
-        const toolUseId = ensureText(part.tool_use_id).trim();
-        if (toolUseId) {
-            toolResultIds.push(toolUseId);
-        }
-    }
-    return toolResultIds;
-}
-function readClaudeTaskResultAgentId(record) {
-    const toolUseResult = toClaudeRecord(record.toolUseResult);
-    return ensureText(toolUseResult.agentId).trim();
-}
-function normalizeClaudeAgentFileName(agentId) {
-    const normalizedAgentId = agentId.trim();
-    if (!normalizedAgentId) {
-        return null;
-    }
-    if (/^agent-[^/]+$/i.test(normalizedAgentId)) {
-        return normalizedAgentId;
-    }
-    return /^[-a-z0-9_]+$/i.test(normalizedAgentId) ? `agent-${normalizedAgentId}` : null;
-}
-function readClaudeSubagentMetaLabel(filePath) {
-    const metaFilePath = filePath.replace(/\.jsonl$/i, ".meta.json");
-    if (!existsSync(metaFilePath)) {
-        return null;
-    }
-    try {
-        const meta = JSON.parse(readFirstNonEmptyLine(metaFilePath, 64 * 1024) ?? "{}");
-        return formatClaudeSubagentLabel(ensureText(meta.agentType).trim(), ensureText(meta.description).trim());
-    }
-    catch {
-        return null;
-    }
-}
-function formatClaudeSubagentLabel(subagentType, description) {
-    const normalizedType = subagentType.trim().toLowerCase();
-    const normalizedDescription = description.trim();
-    if (!normalizedType && !normalizedDescription) {
-        return null;
-    }
-    if (!normalizedType) {
-        return normalizedDescription;
-    }
-    if (!normalizedDescription) {
-        return normalizedType;
-    }
-    return `${normalizedType} · ${normalizedDescription}`;
-}
-function shouldHideClaudeDebugSession(filePath) {
-    const normalizedPath = filePath.replaceAll("\\", "/");
-    if (normalizedPath.includes("/subagents/")) {
-        return false;
-    }
-    const firstLine = readFirstNonEmptyLine(filePath);
-    if (!firstLine) {
-        return false;
-    }
-    try {
-        const record = JSON.parse(firstLine);
-        const firstUserContent = extractClaudeDebugMessageText(record.message?.content);
-        return (record.type === "user" &&
-            Boolean(record.isSidechain) &&
-            ensureText(record.agentId).trim().length > 0 &&
-            /^agent-[^/]+\.jsonl$/i.test(basename(filePath)) &&
-            firstUserContent === "Warmup");
-    }
-    catch {
-        return false;
-    }
-}
-function isPendingClaudeRuntimeFile(filePath) {
-    const normalizedPath = filePath.replaceAll("\\", "/").toLowerCase();
-    return /\/\.pending-[^/]+\.jsonl$/i.test(normalizedPath);
-}
-function extractClaudeDebugMessageText(content) {
-    if (typeof content === "string") {
-        return content.trim();
-    }
-    if (!Array.isArray(content)) {
-        return "";
-    }
-    return content
-        .map((item) => {
-        if (typeof item === "string") {
-            return item;
-        }
-        if (!item || typeof item !== "object") {
-            return "";
-        }
-        return ensureText(item.text);
-    })
-        .join("\n")
-        .trim();
-}
-function extractClaudeUsageSnapshot(record) {
-    const directType = ensureText(record.type).trim();
-    if (directType === "assistant") {
-        const message = (record.message ?? {});
-        const usage = (message.usage ?? {});
-        if (Object.keys(usage).length > 0) {
-            return {
-                usage,
-                timestamp: record.timestamp,
-                model: message.model,
-                recordModel: record.model
-            };
-        }
-    }
-    if (directType !== "progress") {
-        return null;
-    }
-    const data = (record.data ?? {});
-    const nested = (data.message ?? {});
-    if (ensureText(nested.type).trim() !== "assistant") {
-        return null;
-    }
-    const message = (nested.message ?? {});
-    const usage = (message.usage ?? {});
-    if (Object.keys(usage).length === 0) {
-        return null;
-    }
-    return {
-        usage,
-        timestamp: nested.timestamp ?? record.timestamp,
-        model: message.model,
-        recordModel: nested.model ?? record.model
-    };
-}
-function readNonNegativeInteger(value) {
-    if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
-        return Math.trunc(value);
-    }
-    if (typeof value === "string" && /^\d+$/.test(value.trim())) {
-        return Number.parseInt(value.trim(), 10);
-    }
-    return null;
-}
-function resolveClaudeContextWindow(modelId) {
-    const normalizedModelId = modelId?.trim().toLowerCase() ?? "";
-    if (normalizedModelId.includes("claude") ||
-        normalizedModelId === "sonnet" ||
-        normalizedModelId === "opus" ||
-        normalizedModelId === "haiku" ||
-        normalizedModelId.length === 0) {
-        return DEFAULT_CLAUDE_CONTEXT_WINDOW;
-    }
-    return DEFAULT_CLAUDE_CONTEXT_WINDOW;
-}
-function clampClaudeUsageRatio(promptTokens, contextWindow) {
-    if (contextWindow <= 0) {
-        return 0;
-    }
-    return Math.min(Math.max(promptTokens / contextWindow, 0), 1);
-}
-//# sourceMappingURL=claude-code.js.map