@bolloon/bolloon-agent 0.2.11 → 0.2.13

package/dist/agents/pi-sdk-session-manager.js

@@ -0,0 +1,297 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { getGlobalSharedContext } from '../social/global-shared-context.js';
+import { Session, saveSession, loadSession } from '@bolloon/constraint-runtime';
+const SHARED_SESSION_PATH = path.join(process.env.HOME || '/tmp', '.bolloon', 'sessions');
+const PERSONA_PATH = path.join(process.env.HOME || '/tmp', '.bolloon', 'persona.json');
+/**
+ * PiSessionManager — 负责:
+ *   - 加载 / 持久化 persona
+ *   - 加载 / 持久化 channels (含 P2P 远端 channel)
+ *   - 维护 working memory + summarized memory + file context
+ *   - token 用量累加
+ *   - shared context (addUserAction / addSharedKnowledge / createCooperation)
+ *
+ * 从 pi-sdk.ts 抽出 (2026-07-06) — 业务逻辑独立, 不依赖 PiAgentSession 的 LLM 循环.
+ */
+export class PiSessionManager {
+    session;
+    state;
+    memory;
+    persona = null;
+    channels = new Map();
+    channelsPath;
+    initialized = false;
+    sessionDir;
+    cwd;
+    sharedContext;
+    agentId;
+    constructor(agentId, cwd) {
+        this.cwd = cwd;
+        this.sessionDir = path.join(cwd, '.port_sessions');
+        this.agentId = agentId;
+        const sessionId = `pi-session-${Date.now()}`;
+        this.session = new Session(sessionId);
+        this.state = {
+            id: sessionId,
+            agentId,
+            cwd,
+            startedAt: new Date().toISOString(),
+            lastActive: new Date().toISOString()
+        };
+        this.memory = {
+            workingMemory: [],
+            summarizedMemory: [],
+            fileContext: new Map()
+        };
+        this.channelsPath = path.join(SHARED_SESSION_PATH, 'pi-channels.json');
+        this.sharedContext = getGlobalSharedContext();
+    }
+    get sessionId() {
+        return this.session.sessionId;
+    }
+    get turnCount() {
+        return this.session.turnCount;
+    }
+    addSessionMessage(msg) {
+        this.session.addMessage(msg);
+        this.persistSession();
+    }
+    getSessionHistory() {
+        return this.session.history;
+    }
+    setSessionContext(key, value) {
+        this.session.setContext(key, value);
+        this.persistSession();
+    }
+    getSessionContext(key) {
+        return this.session.getContext(key);
+    }
+    persistSession() {
+        try {
+            const stored = {
+                sessionId: this.session.sessionId,
+                messages: this.session.history,
+                inputTokens: 0,
+                outputTokens: 0
+            };
+            saveSession(stored);
+        }
+        catch (e) {
+            console.warn('Failed to persist session:', e);
+        }
+    }
+    loadPersistedSession() {
+        try {
+            const sessionId = this.state.id;
+            const stored = loadSession(sessionId);
+            for (const msg of stored.messages) {
+                this.session.addMessage(msg);
+            }
+        }
+        catch {
+            // No persisted session found, start fresh
+        }
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        await fs.mkdir(SHARED_SESSION_PATH, { recursive: true });
+        await fs.mkdir(this.sessionDir, { recursive: true });
+        this.persona = await this.loadPersona();
+        await this.loadChannels();
+        this.loadPersistedSession();
+        await this.sharedContext.initialize();
+        await this.sharedContext.registerAgent({
+            agentId: this.agentId,
+            sessionId: this.sessionId,
+            channelId: 'system',
+            capabilities: this.persona?.capabilities || [],
+            status: 'active',
+            name: this.persona?.name,
+            persona: this.persona ? {
+                name: this.persona.name,
+                description: this.persona.description,
+                capabilities: this.persona.capabilities
+            } : undefined
+        });
+        this.initialized = true;
+    }
+    async loadPersona() {
+        try {
+            const data = await fs.readFile(PERSONA_PATH, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return null;
+        }
+    }
+    async loadChannels() {
+        try {
+            const data = await fs.readFile(this.channelsPath, 'utf-8');
+            const channelsArray = JSON.parse(data);
+            this.channels.clear();
+            for (const channel of channelsArray) {
+                this.channels.set(channel.id, channel);
+            }
+        }
+        catch {
+            this.channels.clear();
+        }
+    }
+    async saveChannels() {
+        const channelsArray = Array.from(this.channels.values());
+        await fs.writeFile(this.channelsPath, JSON.stringify(channelsArray, null, 2));
+    }
+    async savePersona(persona) {
+        await fs.writeFile(PERSONA_PATH, JSON.stringify(persona, null, 2));
+        this.persona = persona;
+    }
+    getPersona() {
+        return this.persona;
+    }
+    getState() {
+        return { ...this.state, lastActive: new Date().toISOString() };
+    }
+    getMemory() {
+        return this.memory;
+    }
+    addToWorkingMemory(content) {
+        this.memory.workingMemory.push(content);
+        if (this.memory.workingMemory.length > 100) {
+            this.memory.workingMemory = this.memory.workingMemory.slice(-100);
+        }
+        this.state.lastActive = new Date().toISOString();
+    }
+    addSummarizedMemory(content) {
+        this.memory.summarizedMemory.push(content);
+        if (this.memory.summarizedMemory.length > 50) {
+            this.memory.summarizedMemory = this.memory.summarizedMemory.slice(-50);
+        }
+    }
+    addFileContext(filePath, content) {
+        this.memory.fileContext.set(filePath, content);
+        if (this.memory.fileContext.size > 20) {
+            const entries = Array.from(this.memory.fileContext.entries());
+            this.memory.fileContext = new Map(entries.slice(-20));
+        }
+    }
+    updateTokenUsage(promptTokens, completionTokens) {
+        this.state.tokenUsage = {
+            promptTokens: (this.state.tokenUsage?.promptTokens || 0) + promptTokens,
+            completionTokens: (this.state.tokenUsage?.completionTokens || 0) + completionTokens,
+            totalTokens: (this.state.tokenUsage?.totalTokens || 0) + promptTokens + completionTokens
+        };
+    }
+    async addMessage(channelId, message) {
+        await this.initialize();
+        if (!this.channels.has(channelId)) {
+            this.channels.set(channelId, {
+                id: channelId,
+                name: channelId,
+                messages: [],
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            });
+        }
+        const channel = this.channels.get(channelId);
+        channel.messages.push(message);
+        channel.updatedAt = new Date().toISOString();
+        await this.saveChannels();
+    }
+    async getChannelMessages(channelId) {
+        await this.initialize();
+        return this.channels.get(channelId)?.messages || [];
+    }
+    async createChannel(name, peerInfo, persona) {
+        await this.initialize();
+        const channelId = `ch_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+        const channel = {
+            id: channelId,
+            name,
+            messages: [],
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            ...peerInfo,
+            persona: persona || undefined
+        };
+        this.channels.set(channelId, channel);
+        await this.saveChannels();
+        return channel;
+    }
+    async getOrCreatePeerChannel(peerDid, peerName, persona) {
+        await this.initialize();
+        for (const channel of this.channels.values()) {
+            if (channel.peerDid === peerDid) {
+                return channel;
+            }
+        }
+        return this.createChannel(`与 ${peerName} 的对话`, {
+            peerDid,
+            peerName
+        }, persona);
+    }
+    async setChannelInfo(channelId, info) {
+        await this.initialize();
+        const channel = this.channels.get(channelId);
+        if (channel) {
+            Object.assign(channel, info, { updatedAt: new Date().toISOString() });
+            await this.saveChannels();
+        }
+    }
+    getAllChannels() {
+        return Array.from(this.channels.values());
+    }
+    getChannelPersona(channelId) {
+        return this.channels.get(channelId)?.persona;
+    }
+    async setChannelPersona(channelId, persona) {
+        await this.initialize();
+        const channel = this.channels.get(channelId);
+        if (channel) {
+            channel.persona = persona;
+            channel.updatedAt = new Date().toISOString();
+            await this.saveChannels();
+        }
+    }
+    async addUserActionToSharedContext(content, importance) {
+        await this.initialize();
+        await this.sharedContext.addUserAction(content, this.agentId, undefined, importance);
+        await this.sharedContext.updateAgentStatus(this.agentId, 'active');
+    }
+    async addSharedKnowledge(knowledge) {
+        await this.initialize();
+        await this.sharedContext.addSharedKnowledge(knowledge);
+    }
+    async getRecentActionsSummary(count) {
+        return this.sharedContext.getRecentActionsSummary(count);
+    }
+    async getSharedKnowledge() {
+        return this.sharedContext.getSharedKnowledge();
+    }
+    async getGlobalContext() {
+        return this.sharedContext.getFullContext();
+    }
+    async getGlobalContextSummary() {
+        return this.sharedContext.getContextSummary();
+    }
+    async createCooperation(type, task, toAgentId, context) {
+        await this.initialize();
+        return this.sharedContext.createCooperation(type, this.agentId, task, toAgentId, context);
+    }
+    async getPendingCooperations() {
+        return this.sharedContext.getPendingCooperations(this.agentId);
+    }
+    async updateCooperationStatus(cooperationId, status, result) {
+        await this.sharedContext.updateCooperationStatus(cooperationId, status, result);
+    }
+    async getAllRegisteredAgents() {
+        return this.sharedContext.getAllAgents();
+    }
+    async findAgentByCapability(capability) {
+        return this.sharedContext.findAgentByCapability(capability);
+    }
+    async updateAgentStatusInRegistry(status) {
+        await this.sharedContext.updateAgentStatus(this.agentId, status);
+    }
+}