evolcore 0.0.1 → 0.0.2

package/dist/core/session/session-turn-coordinator.js

@@ -0,0 +1,205 @@
+import crypto from 'crypto';
+function cloneTurnMetadata(value) {
+    if (!value)
+        return { schemaVersion: 1, generation: 0 };
+    const cloned = JSON.parse(JSON.stringify(value));
+    delete cloned.lastCommittedAssistantUuid;
+    if (cloned.active) {
+        delete cloned.active.checkpoint;
+        delete cloned.active.protocolRecoveryCount;
+    }
+    return cloned;
+}
+export function readTurnMetadata(session) {
+    return cloneTurnMetadata(session.metadata?.turnState);
+}
+export class SessionTurnCoordinator {
+    sessionManager;
+    states = new Map();
+    constructor(sessionManager) {
+        this.sessionManager = sessionManager;
+    }
+    hydrate(session) {
+        const state = readTurnMetadata(session);
+        const cached = this.states.get(session.id);
+        if (!cached || state.generation > cached.generation) {
+            this.states.set(session.id, state);
+            return cloneTurnMetadata(state);
+        }
+        return cloneTurnMetadata(cached);
+    }
+    current(session) {
+        return this.hydrate(session);
+    }
+    isCurrent(lease) {
+        const state = this.states.get(lease.sessionId);
+        return !!state
+            && state.generation === lease.generation
+            && state.active?.turnId === lease.turnId
+            && state.active.taskId === lease.taskId;
+    }
+    canPublish(lease) {
+        const state = this.states.get(lease.sessionId);
+        if (!state || state.generation !== lease.generation)
+            return false;
+        if (state.active)
+            return this.isCurrent(lease);
+        return state.lastTerminal?.turnId === lease.turnId
+            && state.lastTerminal.taskId === lease.taskId
+            && state.lastTerminal.generation === lease.generation;
+    }
+    invalidate(sessionId, reason) {
+        const state = this.states.get(sessionId);
+        if (!state)
+            return undefined;
+        if (state.active?.status === 'interrupting' && state.active.cancelReason === reason) {
+            return cloneTurnMetadata(state);
+        }
+        const next = {
+            ...state,
+            generation: state.generation + 1,
+            active: state.active
+                ? { ...state.active, status: 'interrupting', cancelReason: reason, updatedAt: Date.now() }
+                : undefined,
+        };
+        this.states.set(sessionId, cloneTurnMetadata(next));
+        return cloneTurnMetadata(next);
+    }
+    async begin(session, taskId, inputId = crypto.randomUUID()) {
+        const state = this.hydrate(session);
+        const generation = state.generation + 1;
+        const turnId = `turn-${crypto.randomUUID()}`;
+        const startedAt = Date.now();
+        const active = {
+            turnId,
+            taskId,
+            generation,
+            inputId,
+            status: 'starting',
+            startedAt,
+            interactions: [],
+        };
+        const next = { ...state, schemaVersion: 1, generation, active };
+        await this.persist(session, next);
+        return { sessionId: session.id, taskId, turnId, generation, inputId };
+    }
+    async beginInterrupt(session, reason) {
+        this.hydrate(session);
+        const next = this.invalidate(session.id, reason) ?? this.hydrate(session);
+        await this.persist(session, next);
+        return cloneTurnMetadata(next);
+    }
+    async completeInterrupt(session, reason) {
+        const state = this.hydrate(session);
+        const active = state.active;
+        if (!active || active.status !== 'interrupting')
+            return undefined;
+        const next = {
+            ...state,
+            active: undefined,
+            lastTerminal: {
+                turnId: active.turnId,
+                taskId: active.taskId,
+                generation: active.generation,
+                status: reason === 'stop' || reason === 'explicit_cancel' ? 'cancelled' : 'superseded',
+                reason,
+                finishedAt: Date.now(),
+            },
+        };
+        await this.persist(session, next);
+        return active.taskId;
+    }
+    async markStatus(session, lease, status) {
+        return this.mutateCurrent(session, lease, active => ({ ...active, status, updatedAt: Date.now() }));
+    }
+    async openInteraction(session, lease, interaction) {
+        return this.mutateCurrent(session, lease, active => ({
+            ...active,
+            status: 'waiting_interaction',
+            interactions: [...active.interactions.filter(item => item.interactionId !== interaction.interactionId), interaction],
+            updatedAt: Date.now(),
+        }));
+    }
+    async settleInteraction(session, lease, interactionId, settlement) {
+        return this.mutateCurrent(session, lease, active => ({
+            ...active,
+            status: active.status === 'interrupting' ? 'interrupting' : 'running',
+            interactions: active.interactions.map(item => item.interactionId === interactionId
+                ? { ...item, settlement, settledAt: Date.now() }
+                : item),
+            updatedAt: Date.now(),
+        }));
+    }
+    evaluateCommit(lease, evidence) {
+        if (!this.isCurrent(lease))
+            return { ok: false, reason: 'stale_generation' };
+        if (evidence.openInteractionIds.length > 0)
+            return { ok: false, reason: 'interaction_open' };
+        if (evidence.openToolUseIds.length > 0)
+            return { ok: false, reason: 'tool_open' };
+        const madeProgress = evidence.textCount > 0 || evidence.toolUseCount > 0 || !!evidence.resultText?.trim();
+        if (!evidence.inputAccepted && !madeProgress)
+            return { ok: false, reason: 'input_not_consumed' };
+        const emptySuccess = !evidence.explicitNoop
+            && evidence.inputTokens === 0
+            && evidence.outputTokens === 0
+            && !madeProgress;
+        if (emptySuccess)
+            return { ok: false, reason: 'empty_success' };
+        return { ok: true };
+    }
+    async commit(session, lease, evidence) {
+        const decision = this.evaluateCommit(lease, evidence);
+        if (!decision.ok)
+            return decision;
+        const state = this.hydrate(session);
+        if (!this.isCurrent(lease) || !state.active)
+            return { ok: false, reason: 'stale_generation' };
+        const next = {
+            ...state,
+            active: undefined,
+            lastTerminal: {
+                turnId: lease.turnId,
+                taskId: lease.taskId,
+                generation: lease.generation,
+                status: 'committed',
+                finishedAt: Date.now(),
+            },
+        };
+        await this.persist(session, next);
+        return decision;
+    }
+    async finish(session, lease, status, reason) {
+        const state = this.hydrate(session);
+        if (!this.isCurrent(lease))
+            return false;
+        const next = {
+            ...state,
+            active: undefined,
+            lastTerminal: {
+                turnId: lease.turnId,
+                taskId: lease.taskId,
+                generation: lease.generation,
+                status,
+                reason,
+                finishedAt: Date.now(),
+            },
+        };
+        await this.persist(session, next);
+        return true;
+    }
+    async mutateCurrent(session, lease, mutate) {
+        const state = this.hydrate(session);
+        if (!this.isCurrent(lease) || !state.active)
+            return false;
+        const next = { ...state, active: mutate(state.active) };
+        await this.persist(session, next);
+        return true;
+    }
+    async persist(session, state) {
+        const metadata = { ...(session.metadata ?? {}), turnState: cloneTurnMetadata(state) };
+        session.metadata = metadata;
+        this.states.set(session.id, cloneTurnMetadata(state));
+        await this.sessionManager.updateSession(session.id, { metadata });
+    }
+}

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

@@ -0,0 +1,67 @@
+export function extractSessionUserContent(message) {
+    const value = message;
+    let text = '';
+    if (typeof value?.content === 'string') {
+        text = value.content;
+    }
+    else if (Array.isArray(value?.content)) {
+        text = value.content
+            .filter((block) => block?.type === 'text' && typeof block.text === 'string')
+            .map((block) => block.text)
+            .join(' ');
+    }
+    text = text.trim();
+    text = text.replace(/^【新消息插入】\s*/, '').replace(/\s*【请无视之前中断继续处理】$/, '').trim();
+    if (text.startsWith('‹')) {
+        const newline = text.indexOf('\n');
+        if (newline !== -1)
+            text = text.slice(newline + 1).trim();
+    }
+    if (text.startsWith('<messages>')) {
+        const parts = [];
+        const messagePattern = /<message(?:\s[^>]*)?>([\s\S]*?)<\/message>/g;
+        let match;
+        while ((match = messagePattern.exec(text)) !== null)
+            parts.push(match[1].trim());
+        if (parts.length > 0)
+            text = parts.join(' ');
+    }
+    text = text.replace(/\s+/g, ' ').trim();
+    if (!text)
+        return '';
+    return text.length > 50 ? `${text.slice(0, 50)}…` : text;
+}
+function isToolResultMessage(message) {
+    const content = message?.content;
+    return Array.isArray(content)
+        && content.length > 0
+        && content.every((block) => block?.type === 'tool_result');
+}
+export function buildSessionTurnList(messages) {
+    const turns = [];
+    let pending;
+    const finishPending = () => {
+        if (!pending?.assistantUuid)
+            return;
+        turns.push({
+            index: turns.length + 1,
+            userContent: pending.userContent,
+            userUuid: pending.userUuid,
+            assistantUuid: pending.assistantUuid,
+        });
+    };
+    for (const message of messages) {
+        if (message.type === 'user') {
+            if (isToolResultMessage(message.message))
+                continue;
+            finishPending();
+            const userContent = extractSessionUserContent(message.message);
+            pending = userContent ? { userContent, userUuid: message.uuid } : undefined;
+            continue;
+        }
+        if (message.type === 'assistant' && pending)
+            pending.assistantUuid = message.uuid;
+    }
+    finishPending();
+    return turns;
+}

package/dist/core/system-channels.js

@@ -0,0 +1,29 @@
+/**
+ * Internal control-plane scope shared by ECWeb and the Control AID.
+ *
+ * This is a logical routing key only. It must never own a persisted chat
+ * session; agent-scoped operations are resolved to a real agent channel.
+ */
+export const SYSTEM_CONTROL_CHANNEL = '__system__';
+/** Legacy synthetic channel directories created by the old control entries. */
+export const LEGACY_SYSTEM_CONTROL_CHANNELS = ['__control__', '__ecweb__'];
+export function isSystemControlChannel(channel) {
+    return channel === SYSTEM_CONTROL_CHANNEL
+        || LEGACY_SYSTEM_CONTROL_CHANNELS.some(legacy => channel === legacy);
+}
+export function isNonAgentSessionChannel(channel) {
+    return channel === 'daemon' || isSystemControlChannel(channel);
+}
+export function cleanupLegacySystemControlSessions(sessionsDir) {
+    const removed = [];
+    for (const channel of LEGACY_SYSTEM_CONTROL_CHANNELS) {
+        const legacyDir = path.join(sessionsDir, channel);
+        if (!fs.existsSync(legacyDir))
+            continue;
+        fs.rmSync(legacyDir, { recursive: true, force: true });
+        removed.push(channel);
+    }
+    return removed;
+}
+import fs from 'fs';
+import path from 'path';

package/dist/eck/baseagent-caps.js

@@ -0,0 +1,18 @@
+export const BASEAGENT_CAPS = {
+    'claude-code': {
+        autoLoadsRules: true,
+        supportsSystemPrompt: true,
+    },
+    'claude': {
+        autoLoadsRules: true,
+        supportsSystemPrompt: true,
+    },
+    'codex': {
+        autoLoadsRules: false,
+        supportsSystemPrompt: true,
+    },
+    'gemini': {
+        autoLoadsRules: false,
+        supportsSystemPrompt: true,
+    },
+};

package/dist/eck/detect.js

@@ -0,0 +1,47 @@
+import fs from 'fs';
+import path from 'path';
+import { BASEAGENT_CAPS } from './baseagent-caps.js';
+const MAX_DEPTH = 5;
+export function resolveEckInjection(agentConfig, projectPath, kitsRulesPath) {
+    const caps = BASEAGENT_CAPS[agentConfig.baseAgent]
+        ?? { autoLoadsRules: false, supportsSystemPrompt: true };
+    if (!caps.autoLoadsRules) {
+        return { shouldInject: true, reason: 'baseagent-no-autoload' };
+    }
+    const symlinkActive = detectEckSymlink(projectPath, kitsRulesPath);
+    if (symlinkActive) {
+        return { shouldInject: false, reason: 'symlink-active' };
+    }
+    return { shouldInject: true, reason: 'symlink-not-found' };
+}
+export function detectEckSymlink(projectPath, kitsRulesPath) {
+    let dir = projectPath;
+    let depth = 0;
+    while (depth < MAX_DEPTH) {
+        const eckDir = path.join(dir, '.claude', 'rules', 'eck');
+        if (fs.existsSync(eckDir)) {
+            try {
+                const realPath = fs.realpathSync(eckDir);
+                const kitsRulesReal = fs.realpathSync(kitsRulesPath);
+                if (pathEquals(realPath, kitsRulesReal)) {
+                    return true;
+                }
+            }
+            catch {
+                // detection failure → conservatively assume not loaded
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+        depth++;
+    }
+    return false;
+}
+function pathEquals(a, b) {
+    if (process.platform === 'win32') {
+        return path.resolve(a).toLowerCase() === path.resolve(b).toLowerCase();
+    }
+    return path.resolve(a) === path.resolve(b);
+}