@jingyi0605/codingns 0.8.0 → 0.8.5

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

@@ -0,0 +1,684 @@
+import { existsSync, readdirSync, readFileSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { messageIdFromRawRef, nextTimestamp, normalizeWorkspacePath, safeDate, sliceHistory } from "./utils.js";
+import { buildKimiMessageRawRef, extractKimiDisplayTextSegments, normalizeKimiMessageRecord, readKimiFirstNonEmptyString, readKimiFirstPresentValue, readKimiPath } from "../kimi-message-normalizer.js";
+import { buildKimiSessionRawStoreRef, buildKimiWorkspacePathByHash, parseKimiSessionIdFromRawStoreRef, readKimiWorkDirRecords } from "../kimi-shared.js";
+const SUBSCRIBE_POLL_INTERVAL_MS = 800;
+const KIMI_SESSION_SUMMARY_CACHE_LIMIT = 512;
+export class KimiAdapter {
+    options;
+    providerId = "kimi";
+    sessionSummaryCache = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    async detectSessions(workspacePath, options) {
+        const discovery = await this.detectSessionsDetailed(workspacePath, options);
+        return discovery.sessions;
+    }
+    async detectSessionsDetailed(workspacePath, options) {
+        const startedAt = Date.now();
+        const targetWorkspacePath = normalizeWorkspacePath(workspacePath);
+        const workspacePathByHash = buildKimiWorkspacePathByHash(readKimiWorkDirRecords(this.options.homeDir));
+        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 files of this.listSessionFiles()) {
+            scannedFiles += 1;
+            const rawStoreRef = buildKimiSessionRawStoreRef(files.sessionId);
+            const cached = this.sessionSummaryCache.get(rawStoreRef);
+            const known = knownByRawStoreRef.get(rawStoreRef);
+            if (cached &&
+                cached.sourceMtimeMs === files.sourceMtimeMs &&
+                cached.sourceSizeBytes === files.sourceSizeBytes) {
+                this.touchSessionSummaryCache(rawStoreRef, cached);
+                skippedByMtimeSize += 1;
+                if (cached.summary &&
+                    normalizeWorkspacePath(cached.summary.workspacePath) === targetWorkspacePath) {
+                    sessions.push({
+                        ...cached.summary,
+                        provider: this.providerId,
+                        providerSessionId: files.sessionId,
+                        rawStoreRef,
+                        sourceMtimeMs: files.sourceMtimeMs,
+                        sourceSizeBytes: files.sourceSizeBytes
+                    });
+                    continue;
+                }
+                if (cached.workspacePath &&
+                    normalizeWorkspacePath(cached.workspacePath) !== targetWorkspacePath) {
+                    continue;
+                }
+            }
+            if (known
+                && known.sourceMtimeMs === files.sourceMtimeMs
+                && known.sourceSizeBytes === files.sourceSizeBytes
+                && normalizeWorkspacePath(known.workspacePath) === targetWorkspacePath) {
+                skippedByMtimeSize += 1;
+                sessions.push({
+                    ...known,
+                    provider: this.providerId,
+                    providerSessionId: files.sessionId,
+                    rawStoreRef,
+                    sourceMtimeMs: files.sourceMtimeMs,
+                    sourceSizeBytes: files.sourceSizeBytes
+                });
+                this.touchSessionSummaryCache(rawStoreRef, {
+                    sourceMtimeMs: files.sourceMtimeMs,
+                    sourceSizeBytes: files.sourceSizeBytes,
+                    workspacePath: known.workspacePath,
+                    summary: {
+                        ...known,
+                        provider: this.providerId,
+                        providerSessionId: files.sessionId,
+                        rawStoreRef,
+                        sourceMtimeMs: files.sourceMtimeMs,
+                        sourceSizeBytes: files.sourceSizeBytes
+                    }
+                });
+                continue;
+            }
+            parsedFiles += 1;
+            bytesRead += files.sourceSizeBytes;
+            const summary = this.buildSessionSummary(files, workspacePath, false, workspacePathByHash);
+            if (!summary) {
+                this.touchSessionSummaryCache(rawStoreRef, {
+                    sourceMtimeMs: files.sourceMtimeMs,
+                    sourceSizeBytes: files.sourceSizeBytes,
+                    workspacePath: null,
+                    summary: null
+                });
+                continue;
+            }
+            if (normalizeWorkspacePath(summary.workspacePath) !== targetWorkspacePath) {
+                this.touchSessionSummaryCache(rawStoreRef, {
+                    sourceMtimeMs: files.sourceMtimeMs,
+                    sourceSizeBytes: files.sourceSizeBytes,
+                    workspacePath: summary.workspacePath,
+                    summary: null
+                });
+                continue;
+            }
+            sessions.push(summary);
+            this.touchSessionSummaryCache(rawStoreRef, {
+                sourceMtimeMs: files.sourceMtimeMs,
+                sourceSizeBytes: files.sourceSizeBytes,
+                workspacePath: summary.workspacePath,
+                summary
+            });
+        }
+        const sortedSessions = sessions.sort((left, right) => (right.lastMessageAt ?? "").localeCompare(left.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 readRecentSessionHistory(providerSessionId, rawStoreRef, _totalMessageCount, limit) {
+        return this.readSessionHistory(providerSessionId, rawStoreRef, null, limit, "backward");
+    }
+    async readSessionHistory(providerSessionId, rawStoreRef, cursor, limit, direction = "forward") {
+        const files = this.resolveSessionFiles(providerSessionId, rawStoreRef);
+        const messages = this.parseSessionMessages(files, true);
+        return sliceHistory(messages, cursor, limit, direction);
+    }
+    subscribeSession(providerSessionId, rawStoreRef, cursor, limit, onEvent) {
+        let currentCursor = cursor;
+        let lastRevision = this.readSessionRevision(providerSessionId, rawStoreRef);
+        const timer = setInterval(async () => {
+            const nextRevision = this.readSessionRevision(providerSessionId, rawStoreRef);
+            if (!nextRevision || !lastRevision || nextRevision <= lastRevision) {
+                return;
+            }
+            lastRevision = nextRevision;
+            const page = await this.readSessionHistory(providerSessionId, rawStoreRef, currentCursor, limit, "forward");
+            if (page.messages.length === 0) {
+                return;
+            }
+            currentCursor = page.cursor;
+            await onEvent({
+                messages: page.messages,
+                cursor: page.cursor
+            });
+        }, SUBSCRIBE_POLL_INTERVAL_MS);
+        return {
+            close() {
+                clearInterval(timer);
+            }
+        };
+    }
+    async resumeSession(providerSessionId, rawStoreRef) {
+        const files = this.resolveSessionFiles(providerSessionId, rawStoreRef);
+        return {
+            provider: this.providerId,
+            providerSessionId: files.sessionId,
+            resumedAt: nextTimestamp(),
+            rawStoreRef: buildKimiSessionRawStoreRef(files.sessionId)
+        };
+    }
+    async startSession(_workspacePath, _options) {
+        throw new Error("KIMI_READ_ONLY_PROVIDER");
+    }
+    async sendMessage(_providerSessionId, _rawStoreRef, _content, _clientRequestId, _permissionMode) {
+        throw new Error("KIMI_READ_ONLY_PROVIDER");
+    }
+    async readSessionTitle(providerSessionId, rawStoreRef) {
+        const files = this.resolveSessionFiles(providerSessionId, rawStoreRef);
+        const summary = this.buildSessionSummary(files, "", true, buildKimiWorkspacePathByHash(readKimiWorkDirRecords(this.options.homeDir)));
+        return summary?.title ?? files.sessionId;
+    }
+    async renameSessionTitle(_providerSessionId, _rawStoreRef, _title) {
+        throw new Error("KIMI_READ_ONLY_PROVIDER");
+    }
+    async updateSessionArchiveState(_providerSessionId, rawStoreRef, isArchived) {
+        return {
+            rawStoreRef,
+            isArchived
+        };
+    }
+    async deleteSession(providerSessionId, rawStoreRef) {
+        const files = this.resolveSessionFiles(providerSessionId, rawStoreRef);
+        if (!existsSync(files.sessionDir)) {
+            throw new Error("PROVIDER_SESSION_NOT_FOUND");
+        }
+        rmSync(files.sessionDir, { recursive: true, force: true });
+        this.sessionSummaryCache.delete(buildKimiSessionRawStoreRef(files.sessionId));
+    }
+    getProviderCapabilities() {
+        const currentDefaultModel = normalizeOptionalText(this.options.defaultModel);
+        return {
+            provider: this.providerId,
+            canStartSession: true,
+            canResumeSession: true,
+            canSendMessage: true,
+            inRunInputMode: "none",
+            supportsSubagents: false,
+            supportsInterrupt: true,
+            supportsStructuredToolCalls: true,
+            supportsTokenUsage: false,
+            supportsAttachments: false,
+            supportsPermissionPrompt: false,
+            supportsCheckpoint: false,
+            supportsSessionDelete: true,
+            modelOptions: [
+                {
+                    id: "provider-default",
+                    name: currentDefaultModel
+                        ? `跟随 Kimi CLI 默认模型（当前：${currentDefaultModel}）`
+                        : "跟随 Kimi CLI 默认模型",
+                    usesProviderDefault: true
+                }
+            ],
+            limitations: [
+                "当前按单轮命令模式运行，每次消息会单独启动一轮 Kimi CLI 进程，暂不支持在同一轮运行中继续追加指导。"
+            ]
+        };
+    }
+    async getSessionCapabilities() {
+        return this.getProviderCapabilities();
+    }
+    async readContextUsage() {
+        return null;
+    }
+    resolveSessionFiles(providerSessionId, rawStoreRef) {
+        const sessionIdFromStoreRef = parseKimiSessionIdFromRawStoreRef(rawStoreRef);
+        const sessionId = sessionIdFromStoreRef && sessionIdFromStoreRef.length > 0
+            ? sessionIdFromStoreRef
+            : providerSessionId.trim();
+        if (!sessionId) {
+            throw new Error("PROVIDER_SESSION_ID_REQUIRED");
+        }
+        const files = this.listSessionFiles().find((item) => item.sessionId === sessionId);
+        if (!files) {
+            throw new Error("PROVIDER_SESSION_NOT_FOUND");
+        }
+        return files;
+    }
+    readSessionRevision(providerSessionId, rawStoreRef) {
+        try {
+            const files = this.resolveSessionFiles(providerSessionId, rawStoreRef);
+            return files.sourceMtimeMs * 1_000 + files.sourceSizeBytes;
+        }
+        catch {
+            return null;
+        }
+    }
+    listSessionFiles() {
+        const sessionsRoot = join(this.options.homeDir, "sessions");
+        if (!existsSync(sessionsRoot)) {
+            return [];
+        }
+        const results = [];
+        const firstLevel = readdirSync(sessionsRoot, { withFileTypes: true });
+        for (const hashDir of firstLevel) {
+            if (!hashDir.isDirectory()) {
+                continue;
+            }
+            const hashPath = join(sessionsRoot, hashDir.name);
+            const secondLevel = readdirSync(hashPath, { withFileTypes: true });
+            for (const sessionDirEntry of secondLevel) {
+                if (!sessionDirEntry.isDirectory()) {
+                    continue;
+                }
+                const sessionDir = join(hashPath, sessionDirEntry.name);
+                const statePath = buildExistingFilePath(sessionDir, "state.json");
+                const contextPath = buildExistingFilePath(sessionDir, "context.jsonl");
+                const wirePath = buildExistingFilePath(sessionDir, "wire.jsonl");
+                const sourceStats = readSessionSourceStats([statePath, contextPath, wirePath]);
+                if (!sourceStats) {
+                    continue;
+                }
+                const state = readJsonFileSafely(statePath);
+                const sessionId = readKimiFirstNonEmptyString(state, [
+                    ["sessionId"],
+                    ["session_id"],
+                    ["id"],
+                    ["session", "id"]
+                ]) ?? sessionDirEntry.name;
+                results.push({
+                    workDirHash: hashDir.name,
+                    sessionId,
+                    sessionDir,
+                    statePath,
+                    contextPath,
+                    wirePath,
+                    sourceMtimeMs: sourceStats.mtimeMs,
+                    sourceSizeBytes: sourceStats.sizeBytes
+                });
+            }
+        }
+        return results;
+    }
+    buildSessionSummary(files, fallbackWorkspacePath, strict, workspacePathByHash) {
+        const state = readJsonFileSafely(files.statePath, strict, files.sessionId, "state.json");
+        const messages = this.parseSessionMessages(files, strict);
+        const workspacePath = readKimiFirstNonEmptyString(state, [
+            ["cwd"],
+            ["workspacePath"],
+            ["workspace_path"],
+            ["workdir"],
+            ["workingDirectory"],
+            ["workspace", "path"],
+            ["workspace", "cwd"],
+            ["project", "path"]
+        ]) ??
+            workspacePathByHash.get(files.workDirHash) ??
+            readWorkspacePathFromSessionLogs(files, strict) ??
+            fallbackWorkspacePath;
+        if (!workspacePath.trim()) {
+            return null;
+        }
+        const sessionTitle = readKimiFirstNonEmptyString(state, [
+            ["title"],
+            ["custom_title"],
+            ["sessionTitle"],
+            ["session", "title"],
+            ["summary", "title"]
+        ]) ??
+            messages.find((message) => message.role === "user")?.content.slice(0, 48) ??
+            files.sessionId;
+        return {
+            provider: this.providerId,
+            providerSessionId: files.sessionId,
+            title: sessionTitle,
+            workspacePath,
+            rawStoreRef: buildKimiSessionRawStoreRef(files.sessionId),
+            isArchived: readFirstBoolean(state, [["archived"], ["isArchived"], ["session", "archived"]]) ?? false,
+            lastMessageAt: resolveKimiSummaryLastMessageAt(messages, files.sourceMtimeMs),
+            messageCount: messages.length,
+            sourceMtimeMs: files.sourceMtimeMs,
+            sourceSizeBytes: files.sourceSizeBytes
+        };
+    }
+    parseSessionMessages(files, strict) {
+        const drafts = [];
+        let sourceOrder = 0;
+        // 约定：context 作为主历史，wire 只补充 context 中缺失的运行时细节。
+        const contextLines = readJsonLinesSafely(files.contextPath, strict, files.sessionId, "context.jsonl");
+        for (const line of contextLines) {
+            sourceOrder = appendMessageDrafts(drafts, files.sessionId, "context", line, sourceOrder);
+        }
+        const wireLines = readJsonLinesSafely(files.wirePath, strict, files.sessionId, "wire.jsonl");
+        for (const line of wireLines) {
+            sourceOrder = appendMessageDrafts(drafts, files.sessionId, "wire", line, sourceOrder);
+        }
+        drafts.sort((left, right) => {
+            if (left.sortAtMs !== right.sortAtMs) {
+                return left.sortAtMs - right.sortAtMs;
+            }
+            return left.sourceOrder - right.sourceOrder;
+        });
+        const collapsedDrafts = collapseEquivalentKimiDrafts(dropWireDraftsCoveredByContext(drafts));
+        return collapsedDrafts.map((draft, index) => ({
+            messageId: messageIdFromRawRef(draft.rawRef),
+            provider: "kimi",
+            providerSessionId: files.sessionId,
+            role: draft.role,
+            kind: draft.kind,
+            content: draft.content,
+            toolCall: draft.toolCall,
+            timestamp: draft.timestamp,
+            sequence: index + 1,
+            rawRef: draft.rawRef
+        }));
+    }
+    touchSessionSummaryCache(rawStoreRef, entry) {
+        this.sessionSummaryCache.delete(rawStoreRef);
+        this.sessionSummaryCache.set(rawStoreRef, entry);
+        while (this.sessionSummaryCache.size > KIMI_SESSION_SUMMARY_CACHE_LIMIT) {
+            const oldestKey = this.sessionSummaryCache.keys().next().value;
+            if (!oldestKey) {
+                break;
+            }
+            this.sessionSummaryCache.delete(oldestKey);
+        }
+    }
+}
+function appendMessageDrafts(drafts, sessionId, source, line, sourceOrder) {
+    const timestamp = resolveMessageTimestamp(line.data, line.lineNumber, source);
+    const sortAtMs = Date.parse(timestamp);
+    const normalizedMessages = normalizeKimiMessageRecord(line.data);
+    for (const normalized of normalizedMessages) {
+        sourceOrder += 1;
+        drafts.push({
+            source,
+            role: normalized.role,
+            kind: normalized.kind,
+            content: normalized.content,
+            toolCall: normalized.toolCall,
+            timestamp,
+            sortAtMs,
+            rawRef: buildKimiMessageRawRef(sessionId, source, line.lineNumber, normalized.partIndex ?? undefined),
+            sourceOrder
+        });
+    }
+    return sourceOrder;
+}
+function collapseEquivalentKimiDrafts(drafts) {
+    const collapsed = [];
+    for (const draft of drafts) {
+        let equivalentIndex = -1;
+        for (let index = collapsed.length - 1; index >= 0; index -= 1) {
+            if (isEquivalentKimiDraft(collapsed[index], draft)) {
+                equivalentIndex = index;
+                break;
+            }
+        }
+        if (equivalentIndex === -1) {
+            collapsed.push(draft);
+            continue;
+        }
+        collapsed[equivalentIndex] = pickPreferredKimiDraft(collapsed[equivalentIndex], draft);
+    }
+    return collapsed;
+}
+function isEquivalentKimiDraft(left, right) {
+    if (left.role !== right.role || left.kind !== right.kind) {
+        return false;
+    }
+    if ((left.kind === "tool_call" || left.kind === "tool_result")
+        && left.toolCall?.callId
+        && right.toolCall?.callId) {
+        return left.toolCall.callId === right.toolCall.callId;
+    }
+    if (left.kind !== "text"
+        && left.kind !== "thinking") {
+        return false;
+    }
+    const leftComparable = normalizeComparableKimiDraftContent(left.content);
+    const rightComparable = normalizeComparableKimiDraftContent(right.content);
+    if (!leftComparable || leftComparable !== rightComparable) {
+        return false;
+    }
+    return Math.abs(left.sortAtMs - right.sortAtMs) <= 2 * 60 * 1_000;
+}
+function dropWireDraftsCoveredByContext(drafts) {
+    const contextCounts = new Map();
+    for (const draft of drafts) {
+        const comparableKey = buildComparableKimiDraftKey(draft);
+        if (!comparableKey || draft.source !== "context") {
+            continue;
+        }
+        contextCounts.set(comparableKey, (contextCounts.get(comparableKey) ?? 0) + 1);
+    }
+    const result = [];
+    for (const draft of drafts) {
+        const comparableKey = buildComparableKimiDraftKey(draft);
+        if (comparableKey
+            && draft.source === "wire"
+            && (contextCounts.get(comparableKey) ?? 0) > 0) {
+            contextCounts.set(comparableKey, (contextCounts.get(comparableKey) ?? 1) - 1);
+            continue;
+        }
+        result.push(draft);
+    }
+    return result;
+}
+function pickPreferredKimiDraft(left, right) {
+    const leftQuality = scoreKimiDraftQuality(left);
+    const rightQuality = scoreKimiDraftQuality(right);
+    if (leftQuality !== rightQuality) {
+        return rightQuality > leftQuality ? right : left;
+    }
+    const leftSourcePriority = kimiDraftSourcePriority(left.source);
+    const rightSourcePriority = kimiDraftSourcePriority(right.source);
+    if (leftSourcePriority !== rightSourcePriority) {
+        return rightSourcePriority > leftSourcePriority ? right : left;
+    }
+    if (left.content.length !== right.content.length) {
+        return right.content.length > left.content.length ? right : left;
+    }
+    if (left.sortAtMs !== right.sortAtMs) {
+        return right.sortAtMs >= left.sortAtMs ? right : left;
+    }
+    return right.sourceOrder >= left.sourceOrder ? right : left;
+}
+function scoreKimiDraftQuality(draft) {
+    let score = 0;
+    const lowerContent = draft.content.toLowerCase();
+    score += normalizeComparableKimiDraftContent(draft.content).length;
+    if (draft.toolCall?.callId) {
+        score += 100;
+    }
+    if (draft.content.includes("<system-reminder")) {
+        score -= 200;
+    }
+    if (draft.content.includes("<system>")) {
+        score -= 80;
+    }
+    if (lowerContent.includes("turnbegin") || lowerContent.includes("contentpart")) {
+        score -= 100;
+    }
+    if (lowerContent.includes("statusupdate") || /chatcmpl[-_a-z0-9]+/i.test(draft.content)) {
+        score -= 100;
+    }
+    return score;
+}
+function kimiDraftSourcePriority(source) {
+    return source === "context" ? 2 : 1;
+}
+function normalizeComparableKimiDraftContent(content) {
+    const cleaned = extractKimiDisplayTextSegments(content).join("\n\n") || content;
+    return cleaned
+        .replace(/\r\n/g, "\n")
+        .trim()
+        .replace(/\s+/g, " ");
+}
+function buildComparableKimiDraftKey(draft) {
+    if ((draft.kind === "tool_call" || draft.kind === "tool_result")
+        && draft.toolCall?.callId) {
+        return `${draft.role}:${draft.kind}:${draft.toolCall.callId}`;
+    }
+    if (draft.kind !== "text" && draft.kind !== "thinking") {
+        return null;
+    }
+    const comparableContent = normalizeComparableKimiDraftContent(draft.content);
+    if (!comparableContent) {
+        return null;
+    }
+    return `${draft.role}:${draft.kind}:${comparableContent}`;
+}
+function resolveMessageTimestamp(record, lineNumber, source) {
+    const candidate = readKimiFirstPresentValue(record, [
+        ["timestamp"],
+        ["createdAt"],
+        ["created_at"],
+        ["time"],
+        ["event", "timestamp"],
+        ["message", "timestamp"],
+        ["payload", "timestamp"]
+    ]);
+    const normalized = safeDate(candidate, "");
+    if (normalized) {
+        return normalized;
+    }
+    const offset = source === "context" ? 0 : 500;
+    return new Date(Date.UTC(2020, 0, 1) + lineNumber * 1_000 + offset).toISOString();
+}
+function readWorkspacePathFromSessionLogs(files, strict) {
+    const lines = [
+        ...readJsonLinesSafely(files.contextPath, strict, files.sessionId, "context.jsonl"),
+        ...readJsonLinesSafely(files.wirePath, strict, files.sessionId, "wire.jsonl")
+    ];
+    for (const line of lines) {
+        const workspacePath = readKimiFirstNonEmptyString(line.data, [
+            ["cwd"],
+            ["workspacePath"],
+            ["workspace_path"],
+            ["workdir"],
+            ["workingDirectory"],
+            ["workspace", "path"],
+            ["workspace", "cwd"],
+            ["project", "path"],
+            ["message", "cwd"],
+            ["payload", "cwd"]
+        ]);
+        if (workspacePath?.trim()) {
+            return workspacePath.trim();
+        }
+    }
+    return null;
+}
+function buildExistingFilePath(sessionDir, fileName) {
+    const filePath = join(sessionDir, fileName);
+    return existsSync(filePath) ? filePath : null;
+}
+function readSessionSourceStats(filePaths) {
+    const existingPaths = filePaths.filter((filePath) => Boolean(filePath));
+    if (existingPaths.length === 0) {
+        return null;
+    }
+    let mtimeMs = 0;
+    let sizeBytes = 0;
+    for (const filePath of existingPaths) {
+        const stats = statSync(filePath);
+        mtimeMs = Math.max(mtimeMs, stats.mtimeMs);
+        sizeBytes += stats.size;
+    }
+    return {
+        mtimeMs,
+        sizeBytes
+    };
+}
+function readJsonFileSafely(filePath, strict = false, sessionId = "", fileName = "") {
+    if (!filePath || !existsSync(filePath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(readFileSync(filePath, "utf8"));
+    }
+    catch (error) {
+        if (strict) {
+            throw createKimiHistoryParseError({
+                sessionId,
+                fileName: fileName || filePath,
+                detail: error instanceof Error ? error.message : "INVALID_JSON"
+            });
+        }
+        return null;
+    }
+}
+function readJsonLinesSafely(filePath, strict, sessionId, fileName) {
+    if (!filePath || !existsSync(filePath)) {
+        return [];
+    }
+    const lines = readFileSync(filePath, "utf8")
+        .split(/\r?\n/)
+        .map((line) => line.trimEnd());
+    const records = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (!line.trim()) {
+            continue;
+        }
+        try {
+            const data = JSON.parse(line);
+            records.push({
+                lineNumber: index + 1,
+                data
+            });
+        }
+        catch (error) {
+            if (!strict) {
+                continue;
+            }
+            throw createKimiHistoryParseError({
+                sessionId,
+                fileName,
+                lineNumber: index + 1,
+                detail: error instanceof Error ? error.message : "INVALID_JSON_LINE"
+            });
+        }
+    }
+    return records;
+}
+function createKimiHistoryParseError(input) {
+    const location = input.lineNumber ? `:${input.lineNumber}` : "";
+    return new Error(`KIMI_HISTORY_PARSE_ERROR session=${input.sessionId} file=${input.fileName}${location} detail=${input.detail}`);
+}
+function readFirstBoolean(record, paths) {
+    if (!record) {
+        return null;
+    }
+    for (const path of paths) {
+        const value = readKimiPath(record, path);
+        if (typeof value === "boolean") {
+            return value;
+        }
+    }
+    return null;
+}
+function normalizeOptionalText(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : null;
+}
+function resolveKimiSummaryLastMessageAt(messages, sourceMtimeMs) {
+    const lastMessageTimestamp = messages.at(-1)?.timestamp ?? null;
+    if (!lastMessageTimestamp) {
+        return Number.isFinite(sourceMtimeMs) ? new Date(sourceMtimeMs).toISOString() : null;
+    }
+    return isSyntheticKimiTimestamp(lastMessageTimestamp)
+        ? new Date(sourceMtimeMs).toISOString()
+        : lastMessageTimestamp;
+}
+function isSyntheticKimiTimestamp(timestamp) {
+    return timestamp.startsWith("2020-01-01T00:");
+}
+//# sourceMappingURL=kimi.js.map