wispy-cli 0.6.1 → 0.8.0

package/core/session.mjs

@@ -0,0 +1,196 @@
+/**
+ * core/session.mjs — Session management for Wispy
+ *
+ * Class SessionManager:
+ *   - create({ workstream?, channel?, chatId? }) → Session
+ *   - get(id) → Session
+ *   - list(filter?) → Session[]
+ *   - addMessage(id, message) → void
+ *   - clear(id) → void
+ *   - save(id) → void
+ *   - load(id) → Session
+ *   - getOrCreate(key) → Session  (for channel adapters: key = "telegram:chatId")
+ *
+ * File-based persistence: ~/.wispy/sessions/{id}.json
+ */
+
+import os from "node:os";
+import path from "node:path";
+import { readFile, writeFile, mkdir, readdir } from "node:fs/promises";
+import { SESSIONS_DIR } from "./config.mjs";
+
+export class Session {
+  constructor({ id, workstream = "default", channel = null, chatId = null, messages = [], createdAt = null }) {
+    this.id = id;
+    this.workstream = workstream;
+    this.channel = channel;
+    this.chatId = chatId;
+    this.messages = messages;
+    this.createdAt = createdAt ?? new Date().toISOString();
+    this.updatedAt = new Date().toISOString();
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      workstream: this.workstream,
+      channel: this.channel,
+      chatId: this.chatId,
+      messages: this.messages,
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+    };
+  }
+}
+
+export class SessionManager {
+  constructor() {
+    this._sessions = new Map(); // id → Session (in-memory cache)
+    this._keyMap = new Map();   // composite key → id (for getOrCreate)
+  }
+
+  /**
+   * Create a new session
+   */
+  create({ workstream = "default", channel = null, chatId = null } = {}) {
+    const id = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+    const session = new Session({ id, workstream, channel, chatId });
+    this._sessions.set(id, session);
+    if (channel && chatId) {
+      this._keyMap.set(`${channel}:${chatId}`, id);
+    }
+    return session;
+  }
+
+  /**
+   * Get a session by ID. Returns null if not found in memory.
+   */
+  get(id) {
+    return this._sessions.get(id) ?? null;
+  }
+
+  /**
+   * Get or load a session by ID.
+   */
+  async getOrLoad(id) {
+    if (this._sessions.has(id)) return this._sessions.get(id);
+    return this.load(id);
+  }
+
+  /**
+   * List sessions matching an optional filter.
+   */
+  list(filter = null) {
+    const all = Array.from(this._sessions.values());
+    if (!filter) return all;
+    return all.filter(s => {
+      if (filter.workstream && s.workstream !== filter.workstream) return false;
+      if (filter.channel && s.channel !== filter.channel) return false;
+      return true;
+    });
+  }
+
+  /**
+   * Add a message to a session.
+   */
+  addMessage(id, message) {
+    const session = this._sessions.get(id);
+    if (!session) throw new Error(`Session not found: ${id}`);
+    session.messages.push(message);
+    session.updatedAt = new Date().toISOString();
+    // Keep last 50 messages
+    if (session.messages.length > 50) {
+      session.messages = session.messages.slice(-50);
+    }
+  }
+
+  /**
+   * Clear message history for a session.
+   */
+  clear(id) {
+    const session = this._sessions.get(id);
+    if (!session) throw new Error(`Session not found: ${id}`);
+    session.messages = [];
+    session.updatedAt = new Date().toISOString();
+  }
+
+  /**
+   * Save a session to disk.
+   */
+  async save(id) {
+    const session = this._sessions.get(id);
+    if (!session) throw new Error(`Session not found: ${id}`);
+    await mkdir(SESSIONS_DIR, { recursive: true });
+    const filePath = path.join(SESSIONS_DIR, `${id}.json`);
+    await writeFile(filePath, JSON.stringify(session.toJSON(), null, 2) + "\n", "utf8");
+  }
+
+  /**
+   * Load a session from disk.
+   */
+  async load(id) {
+    const filePath = path.join(SESSIONS_DIR, `${id}.json`);
+    try {
+      const raw = await readFile(filePath, "utf8");
+      const data = JSON.parse(raw);
+      const session = new Session(data);
+      this._sessions.set(id, session);
+      if (session.channel && session.chatId) {
+        this._keyMap.set(`${session.channel}:${session.chatId}`, id);
+      }
+      return session;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Get or create a session by a composite key (e.g., "telegram:chatId").
+   * Used by channel adapters to maintain per-chat sessions.
+   */
+  async getOrCreate(key, opts = {}) {
+    // Check in-memory key map
+    if (this._keyMap.has(key)) {
+      const id = this._keyMap.get(key);
+      if (this._sessions.has(id)) return this._sessions.get(id);
+    }
+
+    // Try to find on disk by scanning sessions dir
+    try {
+      const files = await readdir(SESSIONS_DIR);
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        const id = file.replace(".json", "");
+        const existing = await this.load(id);
+        if (existing) {
+          const existingKey = existing.channel && existing.chatId
+            ? `${existing.channel}:${existing.chatId}`
+            : null;
+          if (existingKey === key) return existing;
+        }
+      }
+    } catch { /* sessions dir might not exist yet */ }
+
+    // Parse channel:chatId from key
+    const colonIdx = key.indexOf(":");
+    const channel = colonIdx !== -1 ? key.slice(0, colonIdx) : null;
+    const chatId = colonIdx !== -1 ? key.slice(colonIdx + 1) : key;
+
+    const session = this.create({ channel, chatId, ...opts });
+    this._keyMap.set(key, session.id);
+    return session;
+  }
+
+  /**
+   * Get all messages for a session, including a system prompt prefix.
+   * Ensures the system message is always first.
+   */
+  getMessages(id) {
+    const session = this._sessions.get(id);
+    if (!session) return [];
+    return session.messages;
+  }
+}
+
+// Default global instance
+export const sessionManager = new SessionManager();