chainlesschain 0.40.2 → 0.41.0

package/src/lib/ws-server.js

@@ -94,6 +94,12 @@ export class ChainlessChainWSServer extends EventEmitter {
     /** Running child processes: requestId → ChildProcess */
     this.processes = new Map();
 
+    /** Session manager for stateful agent/chat sessions */
+    this.sessionManager = options.sessionManager || null;
+
+    /** Session handlers: sessionId → WSAgentHandler | WSChatHandler */
+    this.sessionHandlers = new Map();
+
     this._heartbeatTimer = null;
     this._clientCounter = 0;
   }
@@ -128,6 +134,21 @@ export class ChainlessChainWSServer extends EventEmitter {
       this._heartbeatTimer = null;
     }
 
+    // Close all session handlers
+    for (const [sessionId, handler] of this.sessionHandlers) {
+      if (handler && handler.destroy) {
+        handler.destroy();
+      }
+      if (this.sessionManager) {
+        try {
+          this.sessionManager.closeSession(sessionId);
+        } catch (_err) {
+          // Non-critical
+        }
+      }
+    }
+    this.sessionHandlers.clear();
+
     // Kill all running child processes
     for (const [id, child] of this.processes) {
       try {
@@ -205,7 +226,7 @@ export class ChainlessChainWSServer extends EventEmitter {
   }
 
   /** @private */
-  _handleMessage(clientId, ws, message) {
+  async _handleMessage(clientId, ws, message) {
     const { id, type } = message;
 
     if (!id) {
@@ -245,6 +266,27 @@ export class ChainlessChainWSServer extends EventEmitter {
       case "cancel":
         this._cancelRequest(id, ws);
         break;
+      case "session-create":
+        await this._handleSessionCreate(id, ws, message);
+        break;
+      case "session-resume":
+        await this._handleSessionResume(id, ws, message);
+        break;
+      case "session-message":
+        this._handleSessionMessage(id, ws, message);
+        break;
+      case "session-list":
+        this._handleSessionList(id, ws);
+        break;
+      case "session-close":
+        this._handleSessionClose(id, ws, message);
+        break;
+      case "slash-command":
+        this._handleSlashCommand(id, ws, message);
+        break;
+      case "session-answer":
+        this._handleSessionAnswer(id, ws, message);
+        break;
       default:
         this._send(ws, {
           id,
@@ -441,6 +483,271 @@ export class ChainlessChainWSServer extends EventEmitter {
     }
   }
 
+  // ─── Session handlers ─────────────────────────────────────────────
+
+  /** @private */
+  async _handleSessionCreate(id, ws, message) {
+    if (!this.sessionManager) {
+      this._send(ws, {
+        id,
+        type: "error",
+        code: "NO_SESSION_SUPPORT",
+        message: "Session support not configured on this server",
+      });
+      return;
+    }
+
+    const { sessionType, provider, model, apiKey, baseUrl, projectRoot } =
+      message;
+
+    try {
+      const { sessionId } = this.sessionManager.createSession({
+        type: sessionType || "agent",
+        provider,
+        model,
+        apiKey,
+        baseUrl,
+        projectRoot,
+      });
+
+      const session = this.sessionManager.getSession(sessionId);
+
+      // Lazy-load handler modules to avoid circular deps
+      try {
+        const { WebSocketInteractionAdapter } =
+          await import("./interaction-adapter.js");
+        session.interaction = new WebSocketInteractionAdapter(ws, sessionId);
+
+        let handler;
+        if ((sessionType || "agent") === "chat") {
+          const { WSChatHandler } = await import("./ws-chat-handler.js");
+          handler = new WSChatHandler({
+            session,
+            interaction: session.interaction,
+          });
+        } else {
+          const { WSAgentHandler } = await import("./ws-agent-handler.js");
+          handler = new WSAgentHandler({
+            session,
+            interaction: session.interaction,
+            db: this.sessionManager.db,
+          });
+        }
+        this.sessionHandlers.set(sessionId, handler);
+      } catch (_err) {
+        // Handler creation failed — session still created, handler can be set later
+      }
+
+      this.emit("session:create", { sessionId, type: sessionType || "agent" });
+
+      this._send(ws, {
+        id,
+        type: "session-created",
+        sessionId,
+        sessionType: sessionType || "agent",
+      });
+    } catch (err) {
+      this._send(ws, {
+        id,
+        type: "error",
+        code: "SESSION_CREATE_FAILED",
+        message: err.message,
+      });
+    }
+  }
+
+  /** @private */
+  async _handleSessionResume(id, ws, message) {
+    if (!this.sessionManager) {
+      this._send(ws, {
+        id,
+        type: "error",
+        code: "NO_SESSION_SUPPORT",
+        message: "Session support not configured",
+      });
+      return;
+    }
+
+    const { sessionId } = message;
+    const session = this.sessionManager.resumeSession(sessionId);
+
+    if (!session) {
+      this._send(ws, {
+        id,
+        type: "error",
+        code: "SESSION_NOT_FOUND",
+        message: `Session not found: ${sessionId}`,
+      });
+      return;
+    }
+
+    // Rebuild interaction adapter and handler for the resumed session
+    if (!this.sessionHandlers.has(sessionId)) {
+      try {
+        const { WebSocketInteractionAdapter } =
+          await import("./interaction-adapter.js");
+        session.interaction = new WebSocketInteractionAdapter(ws, sessionId);
+
+        let handler;
+        if (session.type === "chat") {
+          const { WSChatHandler } = await import("./ws-chat-handler.js");
+          handler = new WSChatHandler({
+            session,
+            interaction: session.interaction,
+          });
+        } else {
+          const { WSAgentHandler } = await import("./ws-agent-handler.js");
+          handler = new WSAgentHandler({
+            session,
+            interaction: session.interaction,
+            db: this.sessionManager.db,
+          });
+        }
+        this.sessionHandlers.set(sessionId, handler);
+      } catch (_err) {
+        // Handler creation failed — session resumed without handler
+      }
+    }
+
+    // Filter out system messages for history
+    const history = (session.messages || []).filter((m) => m.role !== "system");
+
+    this._send(ws, {
+      id,
+      type: "session-resumed",
+      sessionId: session.id,
+      history,
+    });
+  }
+
+  /** @private */
+  _handleSessionMessage(id, ws, message) {
+    const { sessionId, content } = message;
+    const handler = this.sessionHandlers.get(sessionId);
+
+    if (!handler) {
+      this._send(ws, {
+        id,
+        type: "error",
+        code: "SESSION_NOT_FOUND",
+        message: `No active session handler for: ${sessionId}`,
+      });
+      return;
+    }
+
+    // Fire and forget — handler emits events via interaction adapter
+    handler
+      .handleMessage(content, id)
+      .then(() => {
+        // Persist messages after each turn
+        if (this.sessionManager) {
+          try {
+            this.sessionManager.persistMessages(sessionId);
+          } catch (_err) {
+            // Non-critical
+          }
+        }
+      })
+      .catch((err) => {
+        this._send(ws, {
+          id,
+          type: "error",
+          code: "MESSAGE_FAILED",
+          message: err.message,
+        });
+      });
+  }
+
+  /** @private */
+  _handleSessionList(id, ws) {
+    if (!this.sessionManager) {
+      this._send(ws, {
+        id,
+        type: "error",
+        code: "NO_SESSION_SUPPORT",
+        message: "Session support not configured",
+      });
+      return;
+    }
+
+    const sessions = this.sessionManager.listSessions();
+    this._send(ws, {
+      id,
+      type: "session-list-result",
+      sessions,
+    });
+  }
+
+  /** @private */
+  _handleSessionClose(id, ws, message) {
+    const { sessionId } = message;
+
+    // Remove handler
+    const handler = this.sessionHandlers.get(sessionId);
+    if (handler && handler.destroy) {
+      handler.destroy();
+    }
+    this.sessionHandlers.delete(sessionId);
+
+    // Close session in manager
+    if (this.sessionManager) {
+      try {
+        this.sessionManager.closeSession(sessionId);
+      } catch (_err) {
+        // Non-critical
+      }
+    }
+
+    this.emit("session:close", { sessionId });
+
+    this._send(ws, {
+      id,
+      type: "result",
+      success: true,
+      sessionId,
+    });
+  }
+
+  /** @private */
+  _handleSlashCommand(id, ws, message) {
+    const { sessionId, command } = message;
+    const handler = this.sessionHandlers.get(sessionId);
+
+    if (!handler) {
+      this._send(ws, {
+        id,
+        type: "error",
+        code: "SESSION_NOT_FOUND",
+        message: `No active session handler for: ${sessionId}`,
+      });
+      return;
+    }
+
+    handler.handleSlashCommand(command, id);
+  }
+
+  /** @private */
+  _handleSessionAnswer(id, ws, message) {
+    const { sessionId, requestId, answer } = message;
+
+    if (!this.sessionManager) {
+      this._send(ws, {
+        id,
+        type: "error",
+        code: "NO_SESSION_SUPPORT",
+        message: "Session support not configured",
+      });
+      return;
+    }
+
+    const session = this.sessionManager.getSession(sessionId);
+    if (session && session.interaction && session.interaction.resolveAnswer) {
+      session.interaction.resolveAnswer(requestId, answer);
+    }
+
+    this._send(ws, { id, type: "result", success: true });
+  }
+
   /** @private — ping/pong heartbeat to detect dead connections */
   _startHeartbeat() {
     this._heartbeatTimer = setInterval(() => {

package/src/lib/ws-session-manager.js

@@ -0,0 +1,363 @@
+/**
+ * WebSocket Session Manager
+ *
+ * Registry and lifecycle management for stateful agent/chat sessions
+ * accessed over WebSocket. Each session maintains its own message history,
+ * context engine, permanent memory, plan manager, and LLM configuration.
+ */
+
+import { createHash } from "crypto";
+import fs from "fs";
+import path from "path";
+import { PlanModeManager } from "./plan-mode.js";
+import { CLIContextEngineering } from "./cli-context-engineering.js";
+import { CLIPermanentMemory } from "./permanent-memory.js";
+import {
+  createSession as dbCreateSession,
+  saveMessages as dbSaveMessages,
+  getSession as dbGetSession,
+  listSessions as dbListSessions,
+} from "./session-manager.js";
+import { getBaseSystemPrompt } from "./agent-core.js";
+
+/**
+ * @typedef {object} Session
+ * @property {string} id
+ * @property {"agent"|"chat"} type
+ * @property {"active"|"closed"} status
+ * @property {Array} messages
+ * @property {string} provider
+ * @property {string} model
+ * @property {string|null} apiKey
+ * @property {string|null} baseUrl
+ * @property {string} projectRoot
+ * @property {string|null} rulesContent
+ * @property {PlanModeManager} planManager
+ * @property {CLIContextEngineering|null} contextEngine
+ * @property {CLIPermanentMemory|null} permanentMemory
+ * @property {import("./interaction-adapter.js").WebSocketInteractionAdapter|null} interaction
+ * @property {string} createdAt
+ * @property {string} lastActivity
+ */
+
+export class WSSessionManager {
+  /**
+   * @param {object} options
+   * @param {object} [options.db] - Database instance
+   * @param {object} [options.config] - Config object
+   * @param {string} [options.defaultProjectRoot] - Default project root
+   */
+  constructor(options = {}) {
+    this.db = options.db || null;
+    this.config = options.config || {};
+    this.defaultProjectRoot = options.defaultProjectRoot || process.cwd();
+
+    /** @type {Map<string, Session>} */
+    this.sessions = new Map();
+  }
+
+  /**
+   * Generate a unique session ID
+   */
+  _generateId() {
+    const hash = createHash("sha256")
+      .update(Math.random().toString() + Date.now().toString())
+      .digest("hex")
+      .slice(0, 8);
+    return `ws-session-${Date.now()}-${hash}`;
+  }
+
+  /**
+   * Create a new session.
+   *
+   * @param {object} options
+   * @param {"agent"|"chat"} [options.type="agent"]
+   * @param {string} [options.projectRoot]
+   * @param {string} [options.provider="ollama"]
+   * @param {string} [options.model]
+   * @param {string} [options.apiKey]
+   * @param {string} [options.baseUrl]
+   * @returns {{ sessionId: string }}
+   */
+  createSession(options = {}) {
+    const sessionId = this._generateId();
+    const type = options.type || "agent";
+    const projectRoot = options.projectRoot || this.defaultProjectRoot;
+    const provider = options.provider || "ollama";
+    const model =
+      options.model || (provider === "ollama" ? "qwen2.5:7b" : null);
+    const baseUrl = options.baseUrl || "http://localhost:11434";
+
+    // Load project context
+    let rulesContent = null;
+    try {
+      const rulesPath = path.join(projectRoot, ".chainlesschain", "rules.md");
+      if (fs.existsSync(rulesPath)) {
+        rulesContent = fs.readFileSync(rulesPath, "utf8");
+      }
+    } catch (_err) {
+      // Non-critical
+    }
+
+    // Create plan manager (non-singleton, per-session)
+    const planManager = new PlanModeManager();
+
+    // Create context engine
+    let contextEngine = null;
+    let permanentMemory = null;
+    try {
+      const memoryDir = path.join(projectRoot, "memory");
+      permanentMemory = new CLIPermanentMemory({
+        db: this.db,
+        memoryDir,
+      });
+      permanentMemory.initialize();
+    } catch (_err) {
+      // Non-critical
+    }
+
+    try {
+      contextEngine = new CLIContextEngineering({
+        db: this.db,
+        permanentMemory,
+      });
+    } catch (_err) {
+      // Non-critical
+    }
+
+    // Build initial system prompt
+    let systemPrompt = getBaseSystemPrompt(projectRoot);
+    if (rulesContent) {
+      systemPrompt += `\n\n## Project Rules\n${rulesContent}`;
+    }
+
+    const messages = [{ role: "system", content: systemPrompt }];
+
+    // Persist to DB
+    if (this.db) {
+      try {
+        dbCreateSession(this.db, {
+          id: sessionId,
+          title: `WS ${type} ${new Date().toISOString().slice(0, 10)}`,
+          provider,
+          model: model || "",
+          messages,
+        });
+      } catch (_err) {
+        // Non-critical
+      }
+    }
+
+    const session = {
+      id: sessionId,
+      type,
+      status: "active",
+      messages,
+      provider,
+      model,
+      apiKey: options.apiKey || null,
+      baseUrl,
+      projectRoot,
+      rulesContent,
+      planManager,
+      contextEngine,
+      permanentMemory,
+      interaction: null, // Set by ws-server after creation
+      createdAt: new Date().toISOString(),
+      lastActivity: new Date().toISOString(),
+    };
+
+    this.sessions.set(sessionId, session);
+
+    return { sessionId };
+  }
+
+  /**
+   * Resume an existing session from DB.
+   *
+   * @param {string} sessionId
+   * @returns {Session|null}
+   */
+  resumeSession(sessionId) {
+    // Check in-memory first
+    if (this.sessions.has(sessionId)) {
+      const session = this.sessions.get(sessionId);
+      session.status = "active";
+      session.lastActivity = new Date().toISOString();
+      return session;
+    }
+
+    // Try loading from DB
+    if (!this.db) return null;
+
+    try {
+      const dbSession = dbGetSession(this.db, sessionId);
+      if (!dbSession) return null;
+
+      const messages =
+        typeof dbSession.messages === "string"
+          ? JSON.parse(dbSession.messages)
+          : dbSession.messages || [];
+
+      const planManager = new PlanModeManager();
+      let contextEngine = null;
+      let permanentMemory = null;
+
+      try {
+        const memoryDir = path.join(this.defaultProjectRoot, "memory");
+        permanentMemory = new CLIPermanentMemory({
+          db: this.db,
+          memoryDir,
+        });
+        permanentMemory.initialize();
+      } catch (_err) {
+        // Non-critical
+      }
+
+      try {
+        contextEngine = new CLIContextEngineering({
+          db: this.db,
+          permanentMemory,
+        });
+      } catch (_err) {
+        // Non-critical
+      }
+
+      const session = {
+        id: dbSession.id,
+        type: "agent", // Default, since DB doesn't store type
+        status: "active",
+        messages,
+        provider: dbSession.provider || "ollama",
+        model: dbSession.model || null,
+        apiKey: null,
+        baseUrl: "http://localhost:11434",
+        projectRoot: this.defaultProjectRoot,
+        rulesContent: null,
+        planManager,
+        contextEngine,
+        permanentMemory,
+        interaction: null,
+        createdAt: dbSession.created_at,
+        lastActivity: new Date().toISOString(),
+      };
+
+      this.sessions.set(session.id, session);
+      return session;
+    } catch (_err) {
+      return null;
+    }
+  }
+
+  /**
+   * Close a session and persist final state.
+   *
+   * @param {string} sessionId
+   */
+  closeSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+
+    session.status = "closed";
+
+    // Persist messages to DB
+    if (this.db) {
+      try {
+        dbSaveMessages(this.db, sessionId, session.messages);
+      } catch (_err) {
+        // Non-critical
+      }
+    }
+
+    // Auto-summarize into permanent memory
+    if (session.permanentMemory && session.messages.length > 4) {
+      try {
+        session.permanentMemory.autoSummarize(session.messages);
+      } catch (_err) {
+        // Non-critical
+      }
+    }
+
+    // Clean up plan manager listeners
+    if (session.planManager) {
+      session.planManager.removeAllListeners();
+    }
+
+    this.sessions.delete(sessionId);
+  }
+
+  /**
+   * List all sessions (in-memory + DB).
+   *
+   * @returns {Array<{id, type, status, createdAt, lastActivity}>}
+   */
+  listSessions() {
+    const results = [];
+
+    // In-memory active sessions
+    for (const [, session] of this.sessions) {
+      results.push({
+        id: session.id,
+        type: session.type,
+        status: session.status,
+        provider: session.provider,
+        model: session.model,
+        messageCount: session.messages.length,
+        createdAt: session.createdAt,
+        lastActivity: session.lastActivity,
+      });
+    }
+
+    // DB sessions (exclude already-listed in-memory ones)
+    if (this.db) {
+      try {
+        const dbSessions = dbListSessions(this.db, { limit: 20 });
+        const inMemoryIds = new Set(this.sessions.keys());
+        for (const dbs of dbSessions) {
+          if (!inMemoryIds.has(dbs.id)) {
+            results.push({
+              id: dbs.id,
+              type: "unknown",
+              status: "persisted",
+              provider: dbs.provider,
+              model: dbs.model,
+              messageCount: dbs.message_count,
+              createdAt: dbs.created_at,
+              lastActivity: dbs.updated_at,
+            });
+          }
+        }
+      } catch (_err) {
+        // Non-critical
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Get a session by ID.
+   *
+   * @param {string} sessionId
+   * @returns {Session|null}
+   */
+  getSession(sessionId) {
+    return this.sessions.get(sessionId) || null;
+  }
+
+  /**
+   * Persist current messages for a session.
+   */
+  persistMessages(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session || !this.db) return;
+
+    try {
+      dbSaveMessages(this.db, sessionId, session.messages);
+    } catch (_err) {
+      // Non-critical
+    }
+
+    session.lastActivity = new Date().toISOString();
+  }
+}