evolcore 0.0.1 → 0.0.3

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

@@ -0,0 +1,100 @@
+import { formatTimestamp } from './session-fs-store.js';
+import { formatSessionKey, DEFAULT_THREAD_ID } from './session-key.js';
+export function sessionToFile(session) {
+    const metadata = {};
+    if (session.metadata) {
+        if (session.metadata.peerId)
+            metadata.peerId = session.metadata.peerId;
+        if (session.metadata.peerName)
+            metadata.peerName = session.metadata.peerName;
+        if (session.metadata.peerType)
+            metadata.peerType = session.metadata.peerType;
+        if (session.metadata.groupId)
+            metadata.groupId = session.metadata.groupId;
+        if (session.metadata.replyContext)
+            metadata.replyContext = session.metadata.replyContext;
+        if (session.metadata.agentSessions)
+            metadata.agentSessions = session.metadata.agentSessions;
+        if (session.metadata.resumeAt)
+            metadata.resumeAt = session.metadata.resumeAt;
+        for (const [k, v] of Object.entries(session.metadata)) {
+            if (['isActive', 'channelKey', 'channelName', 'permissionMode', 'peerId', 'peerName', 'peerType', 'groupId', 'replyContext', 'agentSessions', 'resumeAt'].includes(k))
+                continue;
+            if (v !== undefined)
+                metadata[k] = v;
+        }
+    }
+    const now = session.updatedAt || Date.now();
+    const channelType = session.channelType || session.channel;
+    const threadId = session.threadId || DEFAULT_THREAD_ID;
+    if (!session.baseagent) {
+        throw new Error(`[session-mapper] sessionToFile: session.baseagent is empty for session ${session.id}`);
+    }
+    return {
+        id: session.id,
+        channel: session.channel,
+        channelType,
+        channelId: session.channelId,
+        sessionKey: formatSessionKey(channelType, session.channelId, threadId),
+        selfAID: session.selfAID,
+        baseagent: session.baseagent,
+        threadId: session.threadId || '',
+        chatType: session.chatType || 'private',
+        projectPath: session.projectPath,
+        agentSessionId: session.agentSessionId ?? null,
+        name: session.name ?? null,
+        activeTask: session.processingState ?? null,
+        metadata,
+        createdAt: session.createdAt,
+        createdAtStr: formatTimestamp(session.createdAt),
+        updatedAt: now,
+        updatedAtStr: formatTimestamp(now),
+    };
+}
+export function fileToSession(file) {
+    const metadata = {};
+    // 兼容旧字段名 agentType → baseagent
+    const baseagent = file.baseagent || file.agentType;
+    if (!baseagent) {
+        throw new Error(`[session-mapper] fileToSession: baseagent is empty for session ${file.id}`);
+    }
+    if (file.metadata.peerId)
+        metadata.peerId = file.metadata.peerId;
+    if (file.metadata.peerName)
+        metadata.peerName = file.metadata.peerName;
+    if (file.metadata.peerType)
+        metadata.peerType = file.metadata.peerType;
+    if (file.metadata.groupId)
+        metadata.groupId = file.metadata.groupId;
+    if (file.metadata.replyContext)
+        metadata.replyContext = file.metadata.replyContext;
+    if (file.metadata.agentSessions)
+        metadata.agentSessions = file.metadata.agentSessions;
+    if (file.metadata.resumeAt)
+        metadata.resumeAt = file.metadata.resumeAt;
+    // permissionMode 不再从文件还原到 metadata（运行时 per-message 解析）
+    for (const [k, v] of Object.entries(file.metadata)) {
+        if (['peerId', 'peerName', 'peerType', 'groupId', 'replyContext', 'agentSessions', 'resumeAt', 'permissionMode'].includes(k))
+            continue;
+        if (v !== undefined)
+            metadata[k] = v;
+    }
+    return {
+        id: file.id,
+        channel: file.channel,
+        channelType: file.channelType,
+        channelId: file.channelId,
+        sessionKey: file.sessionKey || formatSessionKey(file.channelType, file.channelId, file.threadId || DEFAULT_THREAD_ID),
+        selfAID: file.selfAID,
+        baseagent,
+        threadId: file.threadId,
+        chatType: file.chatType,
+        projectPath: file.projectPath,
+        agentSessionId: file.agentSessionId ?? undefined,
+        name: file.name ?? undefined,
+        processingState: file.activeTask ?? undefined,
+        metadata,
+        createdAt: file.createdAt,
+        updatedAt: file.updatedAt,
+    };
+}

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

@@ -0,0 +1,314 @@
+import { resolveEffective } from '../../config/config-manager.js';
+import { formatPeerKey } from '../relation/peer-identity.js';
+import { logger } from '../../utils/logger.js';
+import { isTransientProtocolMessage, messageLogPath } from '../message/message-log.js';
+import { readAllJsonlLines } from './session-fs-store.js';
+const DEFAULT_AFTER_HOURS = 24;
+const DEFAULT_EFFORT = 'low';
+const DEFAULT_FALLBACK = 'continue';
+const MAX_CONTEXT_MESSAGES = 40;
+const MAX_CONTEXT_CHARS = 16_000;
+const MAX_MESSAGE_CHARS = 2_000;
+const MODEL_TIMEOUT_MS = 10_000;
+const RECENT_DECISION_TTL_MS = 30_000;
+const NEW_CONFIDENCE_THRESHOLD = 0.85;
+const JUDGE_BASEAGENT = 'claude';
+const EXPLICIT_NEW_RE = /^(?:新话题|换个话题|重新开始|新开会话|新会话)[：:，,；;。！!\n]/;
+const EXPLICIT_CONTINUE_RE = /^(?:继续上次|延续上次|继续|接着)[：:，,；;。！!\n]/;
+const NON_CONVERSATION_TYPES = new Set([
+    'command',
+    'thought',
+    'status',
+    'event',
+    'tool_call',
+    'tool_result',
+]);
+export function classifyExplicitSessionRenewSignal(content) {
+    const normalized = content.trimStart();
+    if (EXPLICIT_NEW_RE.test(normalized))
+        return 'new';
+    if (EXPLICIT_CONTINUE_RE.test(normalized))
+        return 'continue';
+    return undefined;
+}
+export function isSessionRenewConversationEntry(entry, sessionId) {
+    return entry.sessionId === sessionId
+        && !isTransientProtocolMessage(entry)
+        && !NON_CONVERSATION_TYPES.has(entry.msgType)
+        && entry.content.trim().length > 0;
+}
+export function selectSessionRenewContext(entries) {
+    if (entries.length <= MAX_CONTEXT_MESSAGES)
+        return trimContextByChars(entries);
+    const selected = [entries[0], ...entries.slice(-(MAX_CONTEXT_MESSAGES - 1))];
+    return trimContextByChars(selected);
+}
+export function selectLatestHaikuModel(models) {
+    let selected;
+    for (const rawModel of models) {
+        const id = rawModel.trim();
+        if (!id)
+            continue;
+        const leaf = id.toLowerCase().split('/').at(-1) ?? '';
+        const tokens = leaf.split('-');
+        const haikuIndex = tokens.indexOf('haiku');
+        if (haikuIndex < 0)
+            continue;
+        const versionTokens = haikuIndex <= 1
+            ? tokens.slice(haikuIndex + 1)
+            : tokens.slice(1, haikuIndex);
+        const versions = versionTokens
+            .filter(token => /^\d{1,2}$/.test(token))
+            .map(Number);
+        const dates = tokens
+            .filter(token => /^\d{8}$/.test(token))
+            .map(Number);
+        const candidate = {
+            id,
+            major: versions[0] ?? 0,
+            minor: versions[1] ?? 0,
+            date: dates.length > 0 ? Math.max(...dates) : 0,
+        };
+        if (!selected
+            || candidate.major > selected.major
+            || (candidate.major === selected.major && candidate.minor > selected.minor)
+            || (candidate.major === selected.major && candidate.minor === selected.minor && candidate.date > selected.date)) {
+            selected = candidate;
+        }
+    }
+    return selected?.id;
+}
+function trimContextByChars(entries) {
+    if (entries.length === 0)
+        return [];
+    const first = entries[0];
+    const tail = [];
+    let remaining = MAX_CONTEXT_CHARS - Math.min(first.content.length, MAX_MESSAGE_CHARS);
+    for (let index = entries.length - 1; index >= 1 && remaining > 0; index--) {
+        const entry = entries[index];
+        const length = Math.min(entry.content.length, MAX_MESSAGE_CHARS);
+        if (tail.length > 0 && length > remaining)
+            break;
+        tail.push(entry);
+        remaining -= length;
+    }
+    return [first, ...tail.reverse()];
+}
+export class SessionRenewService {
+    sessionManager;
+    inferenceProviderResolver;
+    locks = new Map();
+    recentDecisions = new Map();
+    now;
+    configResolver;
+    constructor(sessionManager, inferenceProviderResolver, options = {}) {
+        this.sessionManager = sessionManager;
+        this.inferenceProviderResolver = inferenceProviderResolver;
+        this.now = options.now ?? (() => Date.now());
+        this.configResolver = options.resolveConfig;
+    }
+    async resolve(request) {
+        const config = this.resolveConfig(request);
+        if (!config || config.enabled !== true)
+            return { session: request.session, renewed: false };
+        const routeKey = this.routeKey(request);
+        return await this.withLock(routeKey, async () => {
+            const cached = this.recentDecisions.get(routeKey);
+            if (cached && cached.candidateSessionId === request.session.id && cached.expiresAt > this.now()) {
+                const selected = cached.selectedSessionId === request.session.id
+                    ? request.session
+                    : await this.sessionManager.getSessionById(cached.selectedSessionId);
+                if (selected) {
+                    selected.identity = request.session.identity;
+                    return {
+                        session: selected,
+                        renewed: cached.decision === 'new',
+                        decision: cached.decision,
+                        source: cached.source,
+                    };
+                }
+            }
+            const active = this.sessionManager.getActiveSessionSync(request.channelName, request.channelId, request.channelType, request.selfAid);
+            if (active && active.id !== request.session.id) {
+                active.identity = request.session.identity;
+                return { session: active, renewed: true, decision: 'new', source: 'fallback' };
+            }
+            return await this.resolveLocked(routeKey, request, config);
+        });
+    }
+    async resolveLocked(routeKey, request, config) {
+        if (request.session.threadId || request.session.processingState)
+            return { session: request.session, renewed: false };
+        const afterHours = validPositiveNumber(config.after_hours) ?? DEFAULT_AFTER_HOURS;
+        const entries = this.readConversationEntries(request.session);
+        const last = entries[entries.length - 1];
+        if (!last) {
+            if (request.isNewSession)
+                return { session: request.session, renewed: false };
+            const idleMs = this.now() - request.session.updatedAt;
+            return await this.finishDecision(routeKey, request, 'new', 'missing_history', idleMs);
+        }
+        const idleMs = this.now() - last.ts;
+        if (idleMs <= afterHours * 60 * 60 * 1000)
+            return { session: request.session, renewed: false };
+        let source;
+        let decision = classifyExplicitSessionRenewSignal(request.content);
+        if (decision) {
+            source = 'explicit';
+        }
+        else if (request.replyToMessageId
+            && entries.some(entry => entry.msgId === request.replyToMessageId)) {
+            decision = 'continue';
+            source = 'reply';
+        }
+        else {
+            let judgeModel;
+            try {
+                const provider = this.inferenceProviderResolver.getTextInferenceProvider(request.channelName, JUDGE_BASEAGENT, request.selfAid);
+                if (!provider)
+                    throw new Error(`text inference provider unavailable: ${JUDGE_BASEAGENT}`);
+                const judged = await this.judgeWithModel(request, config, entries, idleMs, provider);
+                judgeModel = judged.model;
+                decision = judged.decision === 'new' && judged.confidence < NEW_CONFIDENCE_THRESHOLD
+                    ? 'continue'
+                    : judged.decision;
+                source = 'model';
+            }
+            catch (error) {
+                decision = config.fallback_action ?? DEFAULT_FALLBACK;
+                source = 'fallback';
+                logger.warn(`[SessionRenew] judge failed, using fallback=${decision}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return await this.finishDecision(routeKey, request, decision, source, idleMs, judgeModel);
+        }
+        return await this.finishDecision(routeKey, request, decision, source, idleMs);
+    }
+    async finishDecision(routeKey, request, decision, source, idleMs, judgeModel) {
+        const selected = decision === 'new'
+            ? await this.sessionManager.createRenewedSession(request.session)
+            : request.session;
+        selected.identity = request.session.identity;
+        this.recentDecisions.set(routeKey, {
+            candidateSessionId: request.session.id,
+            selectedSessionId: selected.id,
+            decision,
+            source,
+            expiresAt: this.now() + RECENT_DECISION_TTL_MS,
+        });
+        logger.info(`[SessionRenew] session=${request.session.id} selected=${selected.id} decision=${decision} source=${source} idleHours=${(idleMs / 3_600_000).toFixed(2)} baseagent=${judgeModel ? JUDGE_BASEAGENT : 'none'} model=${judgeModel || 'none'}`);
+        return { session: selected, renewed: decision === 'new', decision, source };
+    }
+    resolveConfig(request) {
+        if (this.configResolver)
+            return this.configResolver(request);
+        if (!request.selfAid)
+            return undefined;
+        const peerKeyId = request.chatType === 'group'
+            ? (request.groupId || request.channelId)
+            : (request.peerId || request.channelId);
+        const peerKey = formatPeerKey(request.channelType, peerKeyId);
+        return resolveEffective({
+            self: request.selfAid,
+            peerKey,
+        }, { cache: true }).session_renew;
+    }
+    readConversationEntries(session) {
+        const entries = readAllJsonlLines(messageLogPath(this.sessionManager.getChatDir(session)));
+        return entries
+            .filter(entry => isSessionRenewConversationEntry(entry, session.id))
+            .sort((left, right) => left.ts - right.ts);
+    }
+    async judgeWithModel(request, config, entries, idleMs, provider) {
+        const context = selectSessionRenewContext(entries).map(entry => ({
+            dir: entry.dir,
+            content: entry.content.slice(0, MAX_MESSAGE_CHARS),
+            ts: entry.ts,
+            msgType: entry.msgType,
+        }));
+        const prompt = JSON.stringify({
+            old_session_messages: context,
+            new_message: request.content,
+            reply_to_message_id: request.replyToMessageId || null,
+            chat_type: request.chatType,
+            idle_hours: Number((idleMs / 3_600_000).toFixed(2)),
+        });
+        const systemPrompt = [
+            'You are a session continuity classifier.',
+            'Decide whether the new message continues the old conversation or starts an independent conversation.',
+            'Use NEW only when the new intent is clearly independent. When uncertain, choose CONTINUE.',
+            'Do not call tools. Do not explain your reasoning.',
+            'Return exactly one JSON object: {"decision":"continue|new","confidence":0..1,"reason_code":"short_code"}.',
+        ].join('\n');
+        const controller = new AbortController();
+        let timer;
+        try {
+            const operation = (async () => {
+                if (!provider.listModels)
+                    throw new Error('Claude text inference provider does not expose a model list');
+                const models = await provider.listModels(controller.signal);
+                const model = selectLatestHaikuModel(models);
+                if (!model)
+                    throw new Error('Claude model list contains no Haiku model');
+                const text = await provider.completeText({
+                    model,
+                    effort: config.effort || DEFAULT_EFFORT,
+                    system: systemPrompt,
+                    input: prompt,
+                    signal: controller.signal,
+                });
+                return { model, text };
+            })();
+            const timeout = new Promise((_resolve, reject) => {
+                timer = setTimeout(() => {
+                    controller.abort();
+                    reject(new Error(`judge timed out after ${MODEL_TIMEOUT_MS}ms`));
+                }, MODEL_TIMEOUT_MS);
+            });
+            const result = await Promise.race([operation, timeout]);
+            return { ...parseModelResult(result.text), model: result.model };
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    routeKey(request) {
+        return [request.channelType, request.selfAid || '', request.channelId, request.session.threadId || ''].join('#');
+    }
+    async withLock(key, operation) {
+        const previous = this.locks.get(key) ?? Promise.resolve();
+        let release;
+        const current = new Promise(resolve => { release = resolve; });
+        const tail = previous.then(() => current);
+        this.locks.set(key, tail);
+        await previous;
+        try {
+            return await operation();
+        }
+        finally {
+            release();
+            if (this.locks.get(key) === tail)
+                this.locks.delete(key);
+        }
+    }
+}
+function validPositiveNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+function parseModelResult(text) {
+    const match = text.match(/\{[\s\S]*\}/);
+    if (!match)
+        throw new Error('judge returned no JSON object');
+    const parsed = JSON.parse(match[0]);
+    if (parsed.decision !== 'continue' && parsed.decision !== 'new') {
+        throw new Error('judge returned invalid decision');
+    }
+    if (typeof parsed.confidence !== 'number' || !Number.isFinite(parsed.confidence) || parsed.confidence < 0 || parsed.confidence > 1) {
+        throw new Error('judge returned invalid confidence');
+    }
+    return {
+        decision: parsed.decision,
+        confidence: parsed.confidence,
+        reasonCode: typeof parsed.reason_code === 'string' ? parsed.reason_code : undefined,
+    };
+}

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

@@ -0,0 +1,128 @@
+const SYSTEM_PROMPT_MARKERS = [
+    '--- [SYSTEM_PROMPT_END] ---',
+    '<system-reminder>',
+    'EvolCore Context Kit documents are shown below.',
+];
+// EvolCore 消息渲染器给每条入站消息加的路由前缀（kits/templates/message-fragments/item.md）。
+// 两种形态：私聊 `‹… → self:AID›`、群聊 `‹… → 群:LABEL · self:AID›`——都以 `‹` 开头、含 `· from:`、
+// 经 `→` 到达 `self:`、以 `›` 收尾。`[^›]*` 保证只吞到第一个 `›`，真人不可能手打这种全角前缀。
+const MESSAGE_ROUTE_PREFIX_RE = /^‹[^›]*·\s*from:[^›]*→[^›]*self:[^›]*›\s*/;
+/**
+ * 判断文本是否以 EvolCore 路由前缀开头，即该会话是 EvolCore 自身驱动 base agent 产生的
+ * （不是用户在终端直接发起的 CLI 会话）。用于 `/s cli` 列表把"自己的会话"排除在导入候选之外，
+ * 语义等同 Claude adapter 的 `entrypoint != sdk-ts`。判的是来源，与 isSyntheticCliPrompt（合成性）正交。
+ */
+export function isEvolcoreRoutedMessage(text) {
+    if (typeof text !== 'string')
+        return false;
+    return MESSAGE_ROUTE_PREFIX_RE.test(text.trimStart());
+}
+const SHARED_SYNTHETIC_CLI_PROMPT_PREFIXES = [
+    'Use Bash exactly once to run:',
+    'Use the Bash tool now to execute',
+    'Review this change for security vulnerabilities',
+    'You previously flagged these candidate vulnerabilities',
+];
+const BACKEND_SYNTHETIC_CLI_PROMPT_PREFIXES = {
+    claude: [
+        // 斜杠命令 / skill 注入的脚手架前缀
+        'Base directory for this skill:',
+    ],
+    codex: [],
+    gemini: [],
+};
+// Claude Code 斜杠命令 / skill / hook 注入的脚手架，经真实会话数据核对，形态包括：
+// - <local-command-caveat> / <local-command-stdout> / <local-command-stderr> 等 local-command 标签族
+// - <command-message> / <command-name> / <command-args> 等 command 标签族
+// - 整条消息就是一个内置斜杠命令调用（如 "/resume <uuid>"、"/model"、"/clear"）
+//   注意：只匹配已知内置命令，避免误伤以绝对路径开头的真人消息（如 "/tmp 清一下"）。
+const CLAUDE_SYNTHETIC_TAG_RE = /^<\/?(?:local-command|command)-[a-z]+>/i;
+const CLAUDE_SYNTHETIC_SLASH_RE = /^\/(?:resume|clear|compact|model|init|review|cost|config|status|help|agents?|context|memory|export|hooks?|mcp|ide|login|logout|doctor|bug|release-notes|vim|terminal-setup|add-dir|permissions)(?:\s|$)/i;
+/**
+ * 判断 user 文本是否为 CLI / skill / hook 注入的脚手架 prompt。
+ * 通用前缀跨后端复用，后端专属前缀 / 模式按 adapter 类型补充。
+ */
+export function isSyntheticCliPrompt(text, backend = 'claude') {
+    if (typeof text !== 'string')
+        return false;
+    const trimmed = text.trimStart();
+    if (!trimmed)
+        return false;
+    const prefixHit = [
+        ...SHARED_SYNTHETIC_CLI_PROMPT_PREFIXES,
+        ...BACKEND_SYNTHETIC_CLI_PROMPT_PREFIXES[backend],
+    ].some(prefix => trimmed.startsWith(prefix));
+    if (prefixHit)
+        return true;
+    if (backend === 'claude') {
+        return CLAUDE_SYNTHETIC_TAG_RE.test(trimmed) || CLAUDE_SYNTHETIC_SLASH_RE.test(trimmed);
+    }
+    return false;
+}
+/** 将 adapter 提取的原始 user 文本归一为统一的真人/脚手架摘要。 */
+export function summarizeCliPrompts(messages, backend) {
+    let firstSyntheticMessage;
+    for (const message of messages) {
+        if (typeof message !== 'string' || !message.trim())
+            continue;
+        const normalized = sanitizeSessionTitle(message);
+        if (!normalized)
+            continue;
+        if (isSyntheticCliPrompt(message, backend)) {
+            firstSyntheticMessage ??= normalized;
+            continue;
+        }
+        return { firstRealMessage: normalized, firstSyntheticMessage };
+    }
+    return { firstSyntheticMessage };
+}
+export function resolveCliSessionTitle(explicitTitle, summary, backend) {
+    const sanitizedTitle = sanitizeSessionTitle(explicitTitle);
+    if (sanitizedTitle && !isSyntheticCliPrompt(explicitTitle, backend))
+        return sanitizedTitle;
+    return summary.firstRealMessage;
+}
+export function buildCliSessionPreview(messages, backend, options = {}) {
+    const summary = summarizeCliPrompts(messages, backend);
+    const includeSyntheticFallback = options.includeSyntheticFallback ?? true;
+    const maxLength = options.maxLength ?? 50;
+    const resolvedTitle = resolveCliSessionTitle(options.explicitTitle, summary, backend)
+        || (includeSyntheticFallback ? summary.firstSyntheticMessage : undefined);
+    const title = resolvedTitle
+        ? resolvedTitle.substring(0, maxLength) + (resolvedTitle.length > maxLength ? '...' : '')
+        : null;
+    return { title, hasReal: !!summary.firstRealMessage };
+}
+export function sanitizeSessionTitle(title) {
+    if (typeof title !== 'string')
+        return undefined;
+    let cleanTitle = title;
+    for (const marker of SYSTEM_PROMPT_MARKERS) {
+        const markerIndex = cleanTitle.indexOf(marker);
+        if (markerIndex >= 0) {
+            cleanTitle = cleanTitle.slice(0, markerIndex);
+        }
+    }
+    cleanTitle = cleanTitle.trim().replace(MESSAGE_ROUTE_PREFIX_RE, '').replace(/\s+/g, ' ');
+    if (!cleanTitle)
+        return undefined;
+    if (/^\.+$/.test(cleanTitle))
+        return undefined;
+    return cleanTitle.length > 80 ? `${cleanTitle.slice(0, 80)}...` : cleanTitle;
+}
+export function displaySessionTitle(title, fallback = '默认会话') {
+    return sanitizeSessionTitle(title) || sanitizeSessionTitle(fallback) || fallback;
+}
+export function deriveSessionTitle(currentTitle, messageContent, threadId) {
+    const normalizedCurrent = sanitizeSessionTitle(currentTitle);
+    if (normalizedCurrent && !shouldAutoFillSessionTitle(normalizedCurrent, threadId)) {
+        return normalizedCurrent;
+    }
+    return sanitizeSessionTitle(messageContent) || normalizedCurrent || '默认会话';
+}
+export function shouldAutoFillSessionTitle(title, threadId) {
+    const normalized = sanitizeSessionTitle(title);
+    if (normalized === '默认会话')
+        return true;
+    return !!threadId && threadId !== 'main' && normalized === '话题会话';
+}