xshat-lite 1.0.0

package/src/modules/session.mjs

@@ -0,0 +1,370 @@
+import fs from 'node:fs/promises';
+import { resolve } from 'node:path';
+import config from '../utils/config.mjs';
+import {
+  readJsonSafe,
+  resolveSiblingPath,
+  writeJsonAtomic
+} from '../utils/storage.mjs';
+
+export class SessionManager {
+  constructor({
+    dir = config.session.dir,
+    fsModule = fs,
+    clock = () => new Date()
+  } = {}) {
+    this.dir = dir;
+    this.fs = fsModule;
+    this.clock = clock;
+    this.current = null;
+    this.indexPath = resolveSiblingPath(this.dir, '_index.json');
+  }
+
+  async init() {
+    try {
+      await this.fs.mkdir(this.dir, { recursive: true });
+    } catch (error) {
+      console.error('Failed to create session directory:', error.message);
+    }
+  }
+
+  _nowIso() {
+    return this.clock().toISOString();
+  }
+
+  _path(id) {
+    return resolve(this.dir, `${id}.json`);
+  }
+
+  _toMeta(data) {
+    if (!data) {
+      return null;
+    }
+
+    return {
+      id: data.id,
+      provider: data.provider,
+      providerHistory: Array.isArray(data.providerHistory) ? data.providerHistory : [],
+      title: data.title || '(无标题)',
+      url: data.url,
+      createdAt: data.createdAt,
+      updatedAt: data.updatedAt,
+      messageCount: data.messages?.length || 0
+    };
+  }
+
+  async _loadIndex() {
+    const index = await readJsonSafe(this.indexPath, []);
+    return Array.isArray(index) ? index : [];
+  }
+
+  async _saveIndex(entries = []) {
+    const normalized = entries
+      .filter(Boolean)
+      .sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+    await writeJsonAtomic(this.indexPath, normalized);
+  }
+
+  async _upsertIndexEntry(sessionLike) {
+    const nextMeta = this._toMeta(sessionLike);
+    if (!nextMeta?.id) {
+      return;
+    }
+
+    const currentIndex = await this._loadIndex();
+    const filtered = currentIndex.filter((item) => item?.id !== nextMeta.id);
+    filtered.push(nextMeta);
+    await this._saveIndex(filtered);
+  }
+
+  async _removeIndexEntry(id) {
+    const currentIndex = await this._loadIndex();
+    await this._saveIndex(currentIndex.filter((item) => item?.id !== id));
+  }
+
+  create(provider) {
+    const now = this._nowIso();
+    this.current = {
+      id: `${provider.id}_${Date.now()}`,
+      provider: provider.id,
+      providerHistory: [
+        {
+          provider: provider.id,
+          reason: 'initial',
+          at: now
+        }
+      ],
+      title: '',
+      url: '',
+      createdAt: now,
+      updatedAt: now,
+      messages: [],
+      memory: {
+        pinned: [],
+        summary: '',
+        plan: [],
+        lastUserMessage: '',
+        lastAssistantMessage: ''
+      }
+    };
+    return this.current;
+  }
+
+  setUrl(url) {
+    if (this.current && url) {
+      this.current.url = url;
+    }
+  }
+
+  async switchProvider(provider, {
+    reason = 'manual'
+  } = {}) {
+    if (!this.current || !provider?.id) {
+      return null;
+    }
+
+    const now = this._nowIso();
+    this.current.provider = provider.id;
+    if (!Array.isArray(this.current.providerHistory)) {
+      this.current.providerHistory = [];
+    }
+    this.current.providerHistory.push({
+      provider: provider.id,
+      reason,
+      at: now
+    });
+    this.current.updatedAt = now;
+    await this._save();
+    return this.current;
+  }
+
+  async addMessage(role, content) {
+    if (!this.current) return;
+
+    this.current.messages.push({
+      role,
+      content,
+      time: this._nowIso()
+    });
+
+    if (!this.current.title && role === 'user') {
+      this.current.title = content.slice(0, 40);
+    }
+
+    if (!this.current.memory || typeof this.current.memory !== 'object') {
+      this.current.memory = {
+        pinned: [],
+        summary: '',
+        plan: [],
+        lastUserMessage: '',
+        lastAssistantMessage: ''
+      };
+    }
+
+    if (role === 'user') {
+      this.current.memory.lastUserMessage = String(content ?? '').trim();
+    }
+
+    if (role === 'assistant') {
+      this.current.memory.lastAssistantMessage = String(content ?? '').trim();
+    }
+
+    this.current.updatedAt = this._nowIso();
+    await this._save();
+  }
+
+  async updateMemory(patch = {}) {
+    if (!this.current) {
+      return null;
+    }
+
+    const currentMemory = this.current.memory && typeof this.current.memory === 'object'
+      ? this.current.memory
+      : {
+        pinned: [],
+        summary: '',
+        plan: [],
+        lastUserMessage: '',
+        lastAssistantMessage: ''
+      };
+
+    this.current.memory = {
+      ...currentMemory,
+      ...patch,
+      pinned: Array.isArray(patch.pinned ?? currentMemory.pinned)
+        ? (patch.pinned ?? currentMemory.pinned)
+        : [],
+      plan: Array.isArray(patch.plan ?? currentMemory.plan)
+        ? (patch.plan ?? currentMemory.plan)
+        : []
+    };
+    this.current.updatedAt = this._nowIso();
+    await this._save();
+    return this.current.memory;
+  }
+
+  async pinMemory(note) {
+    const text = String(note ?? '').trim();
+    if (!this.current || !text) {
+      return null;
+    }
+
+    const memory = this.current.memory && typeof this.current.memory === 'object'
+      ? this.current.memory
+      : {};
+    const pinned = Array.isArray(memory.pinned) ? [...memory.pinned] : [];
+    pinned.unshift({
+      text,
+      at: this._nowIso()
+    });
+
+    return this.updateMemory({
+      ...memory,
+      pinned: pinned.slice(0, 12)
+    });
+  }
+
+  async _save() {
+    if (!this.current) return;
+    try {
+      await writeJsonAtomic(this._path(this.current.id), this.current);
+      await this._upsertIndexEntry(this.current);
+    } catch (error) {
+      console.error('Failed to save session:', error.message);
+    }
+  }
+
+  async list() {
+    try {
+      const indexed = await this._loadIndex();
+      if (indexed.length > 0) {
+        return indexed;
+      }
+
+      const files = await this.fs.readdir(this.dir);
+      const sessions = await Promise.all(
+        files
+          .filter((file) => file.endsWith('.json') && file !== '_index.json')
+          .map((file) => this._readMeta(file))
+      );
+
+      const normalized = sessions
+        .filter(Boolean)
+        .sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+      await this._saveIndex(normalized);
+      return normalized;
+    } catch (error) {
+      console.error('Failed to list sessions:', error.message);
+      return [];
+    }
+  }
+
+  async _readMeta(file) {
+    try {
+      const raw = await this.fs.readFile(resolve(this.dir, file), 'utf-8');
+      const data = JSON.parse(raw);
+      return this._toMeta(data);
+    } catch {
+      return null;
+    }
+  }
+
+  async search(keyword) {
+    const all = await this.list();
+    if (!keyword) return all;
+
+    const lower = keyword.toLowerCase();
+    const matched = [];
+
+    for (const meta of all) {
+      if (meta.title.toLowerCase().includes(lower)) {
+        matched.push(meta);
+        continue;
+      }
+      const full = await this.load(meta.id);
+      if (full?.messages.some(m => m.content.toLowerCase().includes(lower))) {
+        matched.push(meta);
+      }
+    }
+
+    return matched;
+  }
+
+  async load(id) {
+    try {
+      const raw = await this.fs.readFile(this._path(id), 'utf-8');
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+
+  async resume(id) {
+    const data = await this.load(id);
+    if (data) {
+      if (!Array.isArray(data.providerHistory)) {
+        data.providerHistory = data.provider
+          ? [{
+            provider: data.provider,
+            reason: 'legacy',
+            at: data.createdAt || data.updatedAt || this._nowIso()
+          }]
+          : [];
+      }
+      if (!data.memory || typeof data.memory !== 'object') {
+        data.memory = {
+          pinned: [],
+          summary: '',
+          plan: [],
+          lastUserMessage: '',
+          lastAssistantMessage: ''
+        };
+      }
+      this.current = data;
+    }
+    return data;
+  }
+
+  async rename(id, title) {
+    const nextTitle = String(title ?? '').trim();
+    if (!nextTitle) {
+      return false;
+    }
+
+    const session = await this.load(id);
+    if (!session) {
+      return false;
+    }
+
+    session.title = nextTitle;
+    session.updatedAt = this._nowIso();
+
+    try {
+      await writeJsonAtomic(this._path(id), session);
+      await this._upsertIndexEntry(session);
+      if (this.current?.id === id) {
+        this.current = session;
+      }
+      return true;
+    } catch (error) {
+      console.error('Failed to rename session:', error.message);
+      return false;
+    }
+  }
+
+  async delete(id) {
+    try {
+      await this.fs.unlink(this._path(id));
+      await this._removeIndexEntry(id);
+      if (this.current?.id === id) {
+        this.current = null;
+      }
+      return true;
+    } catch (error) {
+      console.error('Failed to delete session:', error.message);
+      return false;
+    }
+  }
+}
+
+export default new SessionManager();