evolcore 0.0.1 → 0.0.3

package/dist/core/session/adapters/gemini-session-file-adapter.js

@@ -0,0 +1,181 @@
+/**
+ * Gemini SessionFileAdapter
+ *
+ * Reads Gemini CLI session files from ~/.gemini/tmp/{project}/chats/.
+ * Gemini stores sessions as JSON files with naming convention:
+ *   session-{YYYY-MM-DDTHH-mm}-{uuid-prefix}.json
+ *
+ * Each file contains:
+ *   { sessionId, projectHash, startTime, lastUpdated, messages, kind }
+ *
+ * Messages have type: 'user' | 'gemini' (not 'role').
+ */
+import { logger } from '../../../utils/logger.js';
+import { buildCliSessionPreview } from '../session-title.js';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+export class GeminiSessionFileAdapter {
+    baseagent = 'gemini';
+    getGeminiHome() {
+        return path.join(os.homedir(), '.gemini');
+    }
+    /**
+     * Resolve Gemini project key for a project path.
+     * Priority:
+     * 1. ~/.gemini/projects.json explicit mapping
+     * 2. .project_root file content match under ~/.gemini/tmp/<project-key>/
+     * 3. basename(projectPath) fallback
+     */
+    resolveProjectKey(projectPath) {
+        const geminiHome = this.getGeminiHome();
+        const projectsPath = path.join(geminiHome, 'projects.json');
+        try {
+            if (fs.existsSync(projectsPath)) {
+                const data = JSON.parse(fs.readFileSync(projectsPath, 'utf-8'));
+                const mapped = data?.projects?.[projectPath];
+                if (typeof mapped === 'string' && mapped.trim())
+                    return mapped;
+            }
+        }
+        catch (error) {
+            logger.debug('[GeminiAdapter] Failed to read projects.json:', error);
+        }
+        const tmpDir = path.join(geminiHome, 'tmp');
+        if (fs.existsSync(tmpDir)) {
+            try {
+                for (const entry of fs.readdirSync(tmpDir, { withFileTypes: true })) {
+                    if (!entry.isDirectory())
+                        continue;
+                    const rootFile = path.join(tmpDir, entry.name, '.project_root');
+                    if (!fs.existsSync(rootFile))
+                        continue;
+                    try {
+                        const content = fs.readFileSync(rootFile, 'utf-8').trim();
+                        if (content === projectPath)
+                            return entry.name;
+                    }
+                    catch {
+                        // ignore broken .project_root
+                    }
+                }
+            }
+            catch (error) {
+                logger.debug('[GeminiAdapter] Failed to scan tmp project roots:', error);
+            }
+        }
+        return path.basename(projectPath);
+    }
+    /**
+     * Resolve the Gemini chats directory for a given project path.
+     */
+    resolveChatsDir(projectPath) {
+        const geminiHome = this.getGeminiHome();
+        const projectKey = this.resolveProjectKey(projectPath);
+        return path.join(geminiHome, 'tmp', projectKey, 'chats');
+    }
+    /**
+     * Find the session file matching a given session UUID.
+     * Gemini files are named session-{date}-{uuid-prefix}.json where
+     * uuid-prefix is the first 8 chars of the session UUID.
+     */
+    findSessionFile(projectPath, agentSessionId) {
+        const chatsDir = this.resolveChatsDir(projectPath);
+        if (!fs.existsSync(chatsDir))
+            return null;
+        const uuidPrefix = agentSessionId.substring(0, 8);
+        try {
+            const files = fs.readdirSync(chatsDir);
+            const match = files.find(f => f.includes(uuidPrefix) && f.endsWith('.json'));
+            return match ? path.join(chatsDir, match) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    readSessionData(projectPath, agentSessionId) {
+        const filePath = this.findSessionFile(projectPath, agentSessionId);
+        if (!filePath)
+            return null;
+        try {
+            return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        }
+        catch (error) {
+            logger.warn(`[GeminiAdapter] Failed to read session file: ${filePath}`, error);
+            return null;
+        }
+    }
+    checkExists(projectPath, agentSessionId) {
+        return this.findSessionFile(projectPath, agentSessionId) !== null;
+    }
+    getFileInfo(projectPath, agentSessionId) {
+        const data = this.readSessionData(projectPath, agentSessionId);
+        if (!data)
+            return { turns: 0 };
+        const msgs = data.messages || [];
+        const userTurns = msgs.filter((m) => m.type === 'user').length;
+        const preview = this.buildSessionPreview(data, false, false, 80);
+        return { turns: userTurns, title: preview.title || undefined };
+    }
+    readFirstMessage(projectPath, agentSessionId) {
+        return this.readUserMessage(projectPath, agentSessionId, 'first');
+    }
+    readLastUserMessage(projectPath, agentSessionId) {
+        return this.readUserMessage(projectPath, agentSessionId, 'last');
+    }
+    scanCliSessions(projectPath, limit = 10) {
+        const chatsDir = this.resolveChatsDir(projectPath);
+        if (!fs.existsSync(chatsDir))
+            return [];
+        try {
+            const files = fs.readdirSync(chatsDir)
+                .filter(f => f.startsWith('session-') && f.endsWith('.json'))
+                .map((f) => {
+                const filePath = path.join(chatsDir, f);
+                const stat = fs.statSync(filePath);
+                // Extract UUID from filename: session-{date}-{uuid-prefix}.json
+                // Read the file to get full UUID
+                try {
+                    const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                    const preview = this.buildSessionPreview(data, false, false, 80);
+                    if (!preview.hasReal)
+                        return null;
+                    return { uuid: data.sessionId, mtime: stat.mtimeMs, title: preview.title || undefined };
+                }
+                catch {
+                    return null;
+                }
+            })
+                .filter((e) => e !== null)
+                .sort((a, b) => b.mtime - a.mtime)
+                .slice(0, limit);
+            return files;
+        }
+        catch (error) {
+            logger.warn('[GeminiAdapter] scanCliSessions failed:', error);
+            return [];
+        }
+    }
+    readUserMessage(projectPath, agentSessionId, which) {
+        const data = this.readSessionData(projectPath, agentSessionId);
+        if (!data)
+            return null;
+        return this.buildSessionPreview(data, which === 'last').title;
+    }
+    buildSessionPreview(data, reverse = false, includeSyntheticFallback = true, maxLength = 50) {
+        const messages = (data.messages || [])
+            .filter((message) => message.type === 'user')
+            .map((message) => this.extractRawUserText(message.content))
+            .filter((text) => !!text);
+        if (reverse)
+            messages.reverse();
+        return buildCliSessionPreview(messages, 'gemini', { includeSyntheticFallback, maxLength });
+    }
+    extractRawUserText(content) {
+        const text = Array.isArray(content)
+            ? content.find((part) => part?.text)?.text || ''
+            : String(content || '');
+        const normalized = text.trim().replace(/\s+/g, ' ');
+        return normalized || null;
+    }
+}

package/dist/core/session/session-file-adapter.js

@@ -0,0 +1,7 @@
+/**
+ * SessionFileAdapter — 会话文件操作的 Agent 抽象层
+ *
+ * 不同 Agent 后端（Claude / Codex）使用不同的会话文件存储格式和路径。
+ * 此接口将文件操作抽象为统一 API，由各 Agent 适配器分别实现。
+ */
+export {};

package/dist/core/session/session-file-health.js

@@ -0,0 +1,45 @@
+import fsPromises from 'fs/promises';
+import { logger } from '../../utils/logger.js';
+/**
+ * 检查会话文件健康度（接收完整文件路径）
+ */
+export async function checkSessionFile(sessionFile) {
+    const issues = [];
+    try {
+        const stats = await fsPromises.stat(sessionFile);
+        const sizeMB = stats.size / (1024 * 1024);
+        if (stats.size > 50 * 1024 * 1024) {
+            issues.push(`会话文件过大: ${sizeMB.toFixed(1)}MB`);
+        }
+        const content = await fsPromises.readFile(sessionFile, 'utf-8');
+        const lines = content.split('\n').filter(l => l.trim());
+        for (let i = 0; i < lines.length; i++) {
+            try {
+                JSON.parse(lines[i]);
+            }
+            catch (e) {
+                issues.push(`会话文件格式损坏（第 ${i + 1} 行）`);
+                return { healthy: false, issues, corrupt: true, fileSize: stats.size };
+            }
+        }
+        return {
+            healthy: issues.length === 0,
+            issues,
+            fileSize: stats.size
+        };
+    }
+    catch (error) {
+        logger.error('[SessionFileHealth] Check failed:', error);
+        issues.push(`文件读取失败: ${error.message}`);
+        return { healthy: false, issues, corrupt: true };
+    }
+}
+/**
+ * 备份单个会话文件（在同目录下创建 .bak 副本）
+ */
+export async function backupSessionFile(sessionFile) {
+    const backupPath = `${sessionFile}.bak-${Date.now()}`;
+    await fsPromises.copyFile(sessionFile, backupPath);
+    logger.info(`[SessionFileHealth] Backup created: ${backupPath}`);
+    return backupPath;
+}

package/dist/core/session/session-fs-store.js

@@ -0,0 +1,273 @@
+import fs from 'fs';
+import path from 'path';
+// 文件系统非法字符（Windows 最严格）：< > : " / \ | ? *
+// 还有控制字符 0x00-0x1F。我们把这些字符编码为 %XX（hex 大写）。
+// `%` 本身也要转义为 %25，保证可逆。
+const UNSAFE_CHARS_RE = /[<>:"/\\|?*\x00-\x1F%]/g;
+function encodeSegment(s) {
+    return s.replace(UNSAFE_CHARS_RE, ch => '%' + ch.charCodeAt(0).toString(16).toUpperCase().padStart(2, '0'));
+}
+function decodeSegment(s) {
+    return s.replace(/%([0-9A-Fa-f]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+}
+/**
+ * 计算 chat 目录的完整路径。
+ * - aun: sessionsDir/aun/<urlEncode(selfAID|'_unknown')>/<urlEncode(channelId)>/
+ * - wecom: sessionsDir/wecom/<urlEncode(channelKey)>/<urlEncode(channelId)>/
+ * - 其它: sessionsDir/<channelType>/<urlEncode(channelId)>/
+ */
+export function chatDirPath(sessionsDir, channelType, channelId, selfAID, channelKey) {
+    if (channelType === 'aun') {
+        return path.join(sessionsDir, channelType, encodeSegment(selfAID || '_unknown'), encodeSegment(channelId));
+    }
+    if (channelType === 'wecom' && channelKey?.startsWith('wecom#')) {
+        return path.join(sessionsDir, channelType, encodeSegment(channelKey), encodeSegment(channelId));
+    }
+    return path.join(sessionsDir, channelType, encodeSegment(channelId));
+}
+/** 解码目录段（用于扫描时把目录名还原为原始 channelId/selfAID） */
+export function decodeDirSegment(seg) {
+    return decodeSegment(seg);
+}
+export function generateSessionId(now) {
+    const ts = now ?? Date.now();
+    const d = new Date(ts);
+    const yyyy = d.getFullYear();
+    const mm = String(d.getMonth() + 1).padStart(2, '0');
+    const dd = String(d.getDate()).padStart(2, '0');
+    return `meta_${yyyy}${mm}${dd}_${ts}`;
+}
+export function formatTimestamp(epochMs) {
+    const d = new Date(epochMs);
+    const yyyy = d.getFullYear();
+    const mo = String(d.getMonth() + 1).padStart(2, '0');
+    const dd = String(d.getDate()).padStart(2, '0');
+    const hh = String(d.getHours()).padStart(2, '0');
+    const mi = String(d.getMinutes()).padStart(2, '0');
+    const ss = String(d.getSeconds()).padStart(2, '0');
+    return `${yyyy}-${mo}-${dd} ${hh}:${mi}:${ss}`;
+}
+export function atomicWriteJson(filePath, data) {
+    const tmpPath = filePath + '.tmp';
+    const content = JSON.stringify(data, null, 2) + '\n';
+    const fd = fs.openSync(tmpPath, 'w');
+    fs.writeSync(fd, content);
+    fs.fsyncSync(fd);
+    fs.closeSync(fd);
+    try {
+        fs.unlinkSync(filePath);
+    }
+    catch (e) {
+        if (e.code !== 'ENOENT')
+            throw e;
+    }
+    fs.renameSync(tmpPath, filePath);
+}
+export function appendJsonl(filePath, record) {
+    const line = JSON.stringify(record) + '\n';
+    const fd = fs.openSync(filePath, 'a');
+    fs.writeSync(fd, line);
+    fs.fsyncSync(fd);
+    fs.closeSync(fd);
+}
+export function readJsonFile(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return undefined;
+        if (e instanceof SyntaxError)
+            return undefined;
+        throw e;
+    }
+}
+export function readLastJsonlLine(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.trimEnd().split('\n');
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const line = lines[i].trim();
+            if (!line)
+                continue;
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+        }
+        return undefined;
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return undefined;
+        throw e;
+    }
+}
+export function readAllJsonlLines(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const results = [];
+        for (const line of content.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                results.push(JSON.parse(trimmed));
+            }
+            catch { /* skip corrupt line */ }
+        }
+        return results;
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return [];
+        throw e;
+    }
+}
+/**
+ * 扫描所有 chat 目录。
+ * - aun: channelType / selfAID / channelId  (3层)
+ * - wecom: channelType / channelKey / channelId (3层；兼容旧的2层目录)
+ * - 其它: channelType / channelId           (2层)
+ */
+export function scanChatDirs(sessionsDir) {
+    const results = [];
+    let typeEntries;
+    try {
+        typeEntries = fs.readdirSync(sessionsDir, { withFileTypes: true });
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return [];
+        throw e;
+    }
+    for (const typeEntry of typeEntries) {
+        if (!typeEntry.isDirectory())
+            continue;
+        const channelType = typeEntry.name;
+        const typeDir = path.join(sessionsDir, channelType);
+        let level2Entries;
+        try {
+            level2Entries = fs.readdirSync(typeDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        if (channelType === 'aun') {
+            // 3-layer: aun/selfAID/channelId
+            for (const selfEntry of level2Entries) {
+                if (!selfEntry.isDirectory())
+                    continue;
+                const selfDir = path.join(typeDir, selfEntry.name);
+                let chatEntries;
+                try {
+                    chatEntries = fs.readdirSync(selfDir, { withFileTypes: true });
+                }
+                catch {
+                    continue;
+                }
+                for (const chatEntry of chatEntries) {
+                    if (!chatEntry.isDirectory())
+                        continue;
+                    results.push({
+                        channelType,
+                        selfAID: decodeSegment(selfEntry.name),
+                        channelId: decodeSegment(chatEntry.name),
+                        dirPath: path.join(selfDir, chatEntry.name),
+                    });
+                }
+            }
+        }
+        else if (channelType === 'wecom') {
+            for (const entry of level2Entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const decoded = decodeSegment(entry.name);
+                const entryDir = path.join(typeDir, entry.name);
+                if (decoded.startsWith('wecom#') && decoded.split('#').length === 3) {
+                    let chatEntries;
+                    try {
+                        chatEntries = fs.readdirSync(entryDir, { withFileTypes: true });
+                    }
+                    catch {
+                        continue;
+                    }
+                    for (const chatEntry of chatEntries) {
+                        if (!chatEntry.isDirectory())
+                            continue;
+                        results.push({
+                            channelType,
+                            selfAID: '',
+                            channelKey: decoded,
+                            channelId: decodeSegment(chatEntry.name),
+                            dirPath: path.join(entryDir, chatEntry.name),
+                        });
+                    }
+                }
+                else {
+                    results.push({
+                        channelType,
+                        selfAID: '',
+                        channelId: decoded,
+                        dirPath: entryDir,
+                    });
+                }
+            }
+        }
+        else {
+            // 2-layer: channelType/channelId
+            for (const chatEntry of level2Entries) {
+                if (!chatEntry.isDirectory())
+                    continue;
+                results.push({
+                    channelType,
+                    selfAID: '',
+                    channelId: decodeSegment(chatEntry.name),
+                    dirPath: path.join(typeDir, chatEntry.name),
+                });
+            }
+        }
+    }
+    return results;
+}
+export function scanMetaFiles(chatDir) {
+    try {
+        const entries = fs.readdirSync(chatDir);
+        return entries
+            .filter(f => f.startsWith('meta_') && f.endsWith('.jsonl'))
+            .sort();
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return [];
+        throw e;
+    }
+}
+export function ensureChatDir(sessionsDir, channelType, channelId, selfAID, channelKey) {
+    const dir = chatDirPath(sessionsDir, channelType, channelId, selfAID, channelKey);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.mkdirSync(path.join(dir, '_threads'), { recursive: true });
+    fs.mkdirSync(path.join(dir, '_trash'), { recursive: true });
+    return dir;
+}
+export function readThreadIndex(chatDir) {
+    const raw = readJsonFile(path.join(chatDir, '_threads', 'thread-index.json')) || {};
+    // Migrate legacy format: { threadId: sessionId } → { threadId: { sessionId, sessionKey, metaFile } }
+    const result = {};
+    for (const [tid, val] of Object.entries(raw)) {
+        if (typeof val === 'string') {
+            // Legacy: val is sessionId
+            result[tid] = { sessionId: val, sessionKey: '', metaFile: `${val}.jsonl` };
+        }
+        else {
+            result[tid] = val;
+        }
+    }
+    return result;
+}
+export function writeThreadIndex(chatDir, index) {
+    atomicWriteJson(path.join(chatDir, '_threads', 'thread-index.json'), index);
+}

package/dist/core/session/session-key.js

@@ -0,0 +1,24 @@
+/**
+ * sessionKey: agent 内部会话路由键。
+ * 格式: channelType#urlEncode(channelId)#urlEncode(threadId)
+ * 无话题时 threadId 固定为 'main'。
+ */
+export const DEFAULT_THREAD_ID = 'main';
+export function formatSessionKey(channelType, channelId, threadId) {
+    const tid = threadId || DEFAULT_THREAD_ID;
+    return `${channelType}#${encodeURIComponent(channelId)}#${encodeURIComponent(tid)}`;
+}
+export function parseSessionKey(key) {
+    const first = key.indexOf('#');
+    if (first <= 0)
+        throw new Error(`Invalid session key: ${key}`);
+    const rest = key.slice(first + 1);
+    const second = rest.indexOf('#');
+    if (second <= 0)
+        throw new Error(`Invalid session key (missing threadId): ${key}`);
+    return {
+        channelType: key.slice(0, first),
+        channelId: decodeURIComponent(rest.slice(0, second)),
+        threadId: decodeURIComponent(rest.slice(second + 1)),
+    };
+}