npm - chainlesschain - Versions diffs - 0.45.11 → 0.45.12 - Mend

chainlesschain 0.45.11 → 0.45.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

package/src/assets/web-panel/index.html CHANGED Viewed

@@ -8,9 +8,9 @@
     // Injected by web-ui-server.js at serve time
     window.__CC_CONFIG__ = __CC_CONFIG_PLACEHOLDER__;
   </script>
-  <script type="module" crossorigin src="./assets/index-DQ5xXK7O.js"></script>
+  <script type="module" crossorigin src="./assets/index-vW799KpE.js"></script>
   <link rel="modulepreload" crossorigin href="./assets/vendor-CN0Iv_qZ.js">
-  <link rel="modulepreload" crossorigin href="./assets/antd-ChLPLhSn.js">
+  <link rel="modulepreload" crossorigin href="./assets/antd-CJSBocer.js">
   <link rel="stylesheet" crossorigin href="./assets/index-CyGyEIVX.css">
 </head>
 <body>

package/src/commands/session.js CHANGED Viewed

@@ -13,6 +13,13 @@ import {
   deleteSession,
   exportSessionMarkdown,
 } from "../lib/session-manager.js";
+import {
+  listJsonlSessions,
+  rebuildMessages,
+  sessionExists,
+  readEvents,
+} from "../lib/jsonl-session-store.js";
+import { feature } from "../lib/feature-flags.js";
 export function registerSessionCommand(program) {
   const session = program
@@ -28,14 +35,39 @@ export function registerSessionCommand(program) {
     .action(async (options) => {
       try {
         const ctx = await bootstrap({ verbose: program.opts().verbose });
-        if (!ctx.db) {
-          logger.error("Database not available");
-          process.exit(1);
+        const limit = Math.max(1, parseInt(options.limit) || 20);
+        let sessions = [];
+        // Merge DB sessions + JSONL sessions
+        if (ctx.db) {
+          const db = ctx.db.getDatabase();
+          sessions.push(
+            ...listSessions(db, { limit }).map((s) => ({
+              ...s,
+              _store: "db",
+            })),
+          );
+        }
+        if (feature("JSONL_SESSION")) {
+          sessions.push(
+            ...listJsonlSessions({ limit }).map((s) => ({
+              ...s,
+              _store: "jsonl",
+            })),
+          );
         }
-        const db = ctx.db.getDatabase();
-        const sessions = listSessions(db, {
-          limit: Math.max(1, parseInt(options.limit) || 20),
-        });
+        // Deduplicate by id (JSONL takes precedence), sort by updated_at
+        const seen = new Set();
+        sessions = sessions
+          .sort((a, b) => (b.updated_at > a.updated_at ? 1 : -1))
+          .filter((s) => {
+            if (seen.has(s.id)) return false;
+            seen.add(s.id);
+            return true;
+          })
+          .slice(0, limit);
         if (options.json) {
           console.log(JSON.stringify(sessions, null, 2));
@@ -46,8 +78,10 @@ export function registerSessionCommand(program) {
         } else {
           logger.log(chalk.bold(`Sessions (${sessions.length}):\n`));
           for (const s of sessions) {
+            const storeTag =
+              s._store === "jsonl" ? chalk.yellow("[JSONL]") : "";
             logger.log(
-              `  ${chalk.gray(s.id.slice(0, 16))}  ${chalk.white(s.title)}  ${chalk.cyan(s.message_count + " msgs")}  ${chalk.gray(s.updated_at)}`,
+              `  ${chalk.gray(s.id.slice(0, 16))}  ${chalk.white(s.title)}  ${chalk.cyan(s.message_count + " msgs")}  ${chalk.gray(s.updated_at)} ${storeTag}`,
             );
             if (s.summary) {
               logger.log(`    ${chalk.gray(s.summary.substring(0, 100))}`);
@@ -72,12 +106,29 @@ export function registerSessionCommand(program) {
     .action(async (id, options) => {
       try {
         const ctx = await bootstrap({ verbose: program.opts().verbose });
-        if (!ctx.db) {
-          logger.error("Database not available");
-          process.exit(1);
+        let sess = null;
+        // Try JSONL first if enabled
+        if (feature("JSONL_SESSION") && sessionExists(id)) {
+          const events = readEvents(id);
+          const startEvent = events.find((e) => e.type === "session_start");
+          const msgs = rebuildMessages(id);
+          sess = {
+            id,
+            title: startEvent?.data?.title || "Untitled",
+            provider: startEvent?.data?.provider || "",
+            model: startEvent?.data?.model || "",
+            message_count: msgs.length,
+            messages: msgs,
+            _store: "jsonl",
+          };
+        }
+        // Fallback to DB
+        if (!sess && ctx.db) {
+          const db = ctx.db.getDatabase();
+          sess = getSession(db, id);
         }
-        const db = ctx.db.getDatabase();
-        const sess = getSession(db, id);
         if (!sess) {
           logger.error(`Session not found: ${id}`);
@@ -127,12 +178,27 @@ export function registerSessionCommand(program) {
     .action(async (id, options) => {
       try {
         const ctx = await bootstrap({ verbose: program.opts().verbose });
-        if (!ctx.db) {
-          logger.error("Database not available");
-          process.exit(1);
+        let sess = null;
+        // Try JSONL first
+        if (feature("JSONL_SESSION") && sessionExists(id)) {
+          const events = readEvents(id);
+          const startEvent = events.find((e) => e.type === "session_start");
+          sess = {
+            id,
+            title: startEvent?.data?.title || "Untitled",
+            provider: startEvent?.data?.provider || "",
+            model: startEvent?.data?.model || "",
+            messages: rebuildMessages(id),
+          };
+          sess.message_count = sess.messages.length;
+        }
+        // Fallback to DB
+        if (!sess && ctx.db) {
+          const db = ctx.db.getDatabase();
+          sess = getSession(db, id);
         }
-        const db = ctx.db.getDatabase();
-        const sess = getSession(db, id);
         if (!sess) {
           logger.error(`Session not found: ${id}`);

package/src/lib/prompt-compressor.js CHANGED Viewed

@@ -60,6 +60,105 @@ function getContent(msg) {
     : JSON.stringify(msg.content || "");
 }
+// ── Provider context window registry ───────────────────────────────────
+/**
+ * Known context window sizes (in tokens) per model/provider.
+ * Used by adaptive compression to auto-tune maxTokens.
+ */
+export const CONTEXT_WINDOWS = {
+  // Ollama local models
+  "qwen2.5:7b": 32768,
+  "qwen2.5:14b": 32768,
+  "qwen2.5-coder:14b": 32768,
+  "qwen2:7b": 32768,
+  "llama3:8b": 8192,
+  "mistral:7b": 32768,
+  "codellama:7b": 16384,
+  // OpenAI
+  "gpt-4o": 128000,
+  "gpt-4o-mini": 128000,
+  "gpt-4-turbo": 128000,
+  "gpt-3.5-turbo": 16385,
+  o1: 200000,
+  // Anthropic
+  "claude-opus-4-6": 200000,
+  "claude-sonnet-4-6": 200000,
+  "claude-haiku-4-5-20251001": 200000,
+  // DeepSeek
+  "deepseek-chat": 64000,
+  "deepseek-coder": 64000,
+  "deepseek-reasoner": 64000,
+  // DashScope
+  "qwen-turbo": 131072,
+  "qwen-plus": 131072,
+  "qwen-max": 32768,
+  // Gemini
+  "gemini-2.0-flash": 1048576,
+  "gemini-2.0-pro": 1048576,
+  "gemini-1.5-flash": 1048576,
+  // Kimi
+  "moonshot-v1-auto": 131072,
+  "moonshot-v1-8k": 8192,
+  "moonshot-v1-32k": 32768,
+  "moonshot-v1-128k": 131072,
+  // Volcengine
+  "doubao-seed-1-6-251015": 32768,
+  // Provider-level defaults (fallback when model not listed)
+  _provider_defaults: {
+    ollama: 32768,
+    openai: 128000,
+    anthropic: 200000,
+    deepseek: 64000,
+    dashscope: 131072,
+    gemini: 1048576,
+    kimi: 131072,
+    volcengine: 32768,
+    minimax: 32768,
+    mistral: 32768,
+  },
+};
+/**
+ * Get context window size for a model/provider combination.
+ * @param {string} [model] — Model name
+ * @param {string} [provider] — Provider name
+ * @returns {number} Context window in tokens
+ */
+export function getContextWindow(model, provider) {
+  if (model && CONTEXT_WINDOWS[model]) {
+    return CONTEXT_WINDOWS[model];
+  }
+  if (provider && CONTEXT_WINDOWS._provider_defaults[provider]) {
+    return CONTEXT_WINDOWS._provider_defaults[provider];
+  }
+  return 32768; // Conservative default
+}
+/**
+ * Calculate adaptive compression thresholds based on context window.
+ *
+ * Strategy:
+ * - maxTokens = 60% of context window (reserve 40% for system prompt + response)
+ * - maxMessages scales with context: small ctx → 15, large ctx → 50
+ * - For very large contexts (>128k), enable less aggressive compression
+ *
+ * @param {number} contextWindow — Context window in tokens
+ * @returns {{ maxMessages: number, maxTokens: number, aggressive: boolean }}
+ */
+export function adaptiveThresholds(contextWindow) {
+  const maxTokens = Math.floor(contextWindow * 0.6);
+  // Scale messages: 15 for 8k, 20 for 32k, 30 for 128k, 50 for 200k+
+  const maxMessages = Math.min(
+    50,
+    Math.max(15, Math.floor(10 + Math.log2(contextWindow / 1024) * 5)),
+  );
+  // Aggressive compression only for small context windows
+  const aggressive = contextWindow < 32768;
+  return { maxMessages, maxTokens, aggressive };
+}
 // ── PromptCompressor class ──────────────────────────────────────────────
 export class PromptCompressor {
@@ -69,14 +168,45 @@ export class PromptCompressor {
    * @param {number} [options.maxTokens=8000] — Token threshold for auto-compact
    * @param {number} [options.similarityThreshold=0.9] — Dedup similarity threshold
    * @param {Function} [options.llmQuery] — async (prompt) => string, for summarization
+   * @param {string} [options.model] — Model name (for adaptive thresholds)
+   * @param {string} [options.provider] — Provider name (for adaptive thresholds)
    */
   constructor(options = {}) {
-    this.maxMessages = options.maxMessages || 20;
-    this.maxTokens = options.maxTokens || 8000;
+    // If model/provider supplied and no explicit maxMessages/maxTokens, auto-adapt
+    if (
+      (options.model || options.provider) &&
+      !options.maxMessages &&
+      !options.maxTokens
+    ) {
+      const ctxWindow = getContextWindow(options.model, options.provider);
+      const adaptive = adaptiveThresholds(ctxWindow);
+      this.maxMessages = adaptive.maxMessages;
+      this.maxTokens = adaptive.maxTokens;
+      this._adaptive = true;
+      this._contextWindow = ctxWindow;
+    } else {
+      this.maxMessages = options.maxMessages || 20;
+      this.maxTokens = options.maxTokens || 8000;
+      this._adaptive = false;
+      this._contextWindow = null;
+    }
     this.similarityThreshold = options.similarityThreshold || 0.9;
     this.llmQuery = options.llmQuery || null;
   }
+  /**
+   * Reconfigure thresholds for a new model/provider (e.g. after model switch).
+   * Only updates if no explicit overrides were set in constructor.
+   */
+  adaptToModel(model, provider) {
+    const ctxWindow = getContextWindow(model, provider);
+    const adaptive = adaptiveThresholds(ctxWindow);
+    this.maxMessages = adaptive.maxMessages;
+    this.maxTokens = adaptive.maxTokens;
+    this._adaptive = true;
+    this._contextWindow = ctxWindow;
+  }
   /**
    * Run all enabled compression strategies on messages.
    * Returns { messages, stats }.

package/src/lib/sub-agent-context.js CHANGED Viewed

@@ -11,6 +11,13 @@
 import crypto from "crypto";
 import { CLIContextEngineering } from "./cli-context-engineering.js";
 import { agentLoop, buildSystemPrompt, AGENT_TOOLS } from "./agent-core.js";
+import { feature } from "./feature-flags.js";
+import {
+  createWorktree,
+  removeWorktree,
+  isolateTask,
+} from "./worktree-isolator.js";
+import { isGitRepo } from "./git-integration.js";
 // ─── Constants ──────────────────────────────────────────────────────────────
@@ -38,6 +45,7 @@ export class SubAgentContext {
    * @param {object} [options.permanentMemory] - Permanent memory instance
    * @param {object} [options.llmOptions] - LLM provider/model/key options
    * @param {string} [options.cwd] - Working directory
+   * @param {boolean} [options.useWorktree] - Force worktree isolation (overrides flag)
    * @returns {SubAgentContext}
    */
   static create(options = {}) {
@@ -59,6 +67,12 @@ export class SubAgentContext {
     this.createdAt = new Date().toISOString();
     this.completedAt = null;
+    // Worktree isolation state
+    this._useWorktree = options.useWorktree ?? feature("WORKTREE_ISOLATION");
+    this._worktreePath = null;
+    this._worktreeBranch = null;
+    this._repoDir = this.cwd;
     // ── Isolated state ──────────────────────────────────────────────
     // Independent message history — never shared with parent
     this.messages = [];
@@ -110,6 +124,60 @@ export class SubAgentContext {
       );
     }
+    // If worktree isolation is enabled, wrap execution in isolated worktree
+    if (this._useWorktree && isGitRepo(this._repoDir)) {
+      return this._runInWorktree(userPrompt, loopOptions);
+    }
+    return this._runCore(userPrompt, loopOptions);
+  }
+  /**
+   * Run in an isolated git worktree. Creates worktree → runs → cleans up.
+   */
+  async _runInWorktree(userPrompt, loopOptions = {}) {
+    const taskId = `${this.role}-${this.id.slice(4)}`;
+    try {
+      const { result, branch, worktreePath, hasChanges } = await isolateTask(
+        this._repoDir,
+        taskId,
+        async (wtPath) => {
+          this._worktreePath = wtPath;
+          this._worktreeBranch = `agent/${taskId}`;
+          // Override cwd to worktree for tool execution
+          this.cwd = wtPath;
+          return this._runCore(userPrompt, loopOptions);
+        },
+      );
+      // Annotate result with worktree info
+      if (result) {
+        result.worktree = {
+          branch,
+          path: worktreePath,
+          hasChanges,
+        };
+      }
+      return result;
+    } catch (err) {
+      // If worktree creation fails (e.g. not a git repo), fall back to direct
+      this.status = "failed";
+      this.completedAt = new Date().toISOString();
+      this.result = {
+        summary: `Worktree isolation failed: ${err.message}`,
+        artifacts: [],
+        tokenCount: this._tokenCount,
+        toolsUsed: [...new Set(this._toolsUsed)],
+        iterationCount: this._iterationCount,
+      };
+      return this.result;
+    }
+  }
+  /**
+   * Core agent loop execution (shared by direct and worktree paths).
+   */
+  async _runCore(userPrompt, loopOptions = {}) {
     // Add user message
     this.messages.push({ role: "user", content: userPrompt });
@@ -291,6 +359,9 @@ export class SubAgentContext {
       iterationCount: this._iterationCount,
       createdAt: this.createdAt,
       completedAt: this.completedAt,
+      worktree: this._worktreePath
+        ? { path: this._worktreePath, branch: this._worktreeBranch }
+        : null,
     };
   }
 }

package/src/lib/ws-server.js CHANGED Viewed

@@ -290,6 +290,12 @@ export class ChainlessChainWSServer extends EventEmitter {
       case "orchestrate":
         this._handleOrchestrate(id, ws, message);
         break;
+      case "tasks-list":
+        this._handleTasksList(id, ws);
+        break;
+      case "tasks-stop":
+        this._handleTasksStop(id, ws, message);
+        break;
       default:
         this._send(ws, {
           id,
@@ -384,6 +390,45 @@ export class ChainlessChainWSServer extends EventEmitter {
     }
   }
+  /** @private — list background tasks */
+  _handleTasksList(id, ws) {
+    try {
+      const { BackgroundTaskManager } = require("./background-task-manager.js");
+      // Reuse singleton or create lightweight instance for listing
+      if (!this._taskManager) {
+        this._taskManager = new BackgroundTaskManager();
+      }
+      const tasks = this._taskManager.list();
+      this._send(ws, { id, type: "tasks-list", tasks });
+    } catch (err) {
+      this._send(ws, { id, type: "tasks-list", tasks: [] });
+    }
+  }
+  /** @private — stop a background task */
+  _handleTasksStop(id, ws, message) {
+    try {
+      if (this._taskManager && message.taskId) {
+        this._taskManager.stop(message.taskId);
+        this._send(ws, { id, type: "tasks-stopped", taskId: message.taskId });
+      } else {
+        this._send(ws, {
+          id,
+          type: "error",
+          code: "NO_TASK",
+          message: "taskId required or no task manager",
+        });
+      }
+    } catch (err) {
+      this._send(ws, {
+        id,
+        type: "error",
+        code: "TASKS_STOP_FAILED",
+        message: err.message,
+      });
+    }
+  }
   /** @private */
   _handleAuth(clientId, ws, message) {
     const { id, token } = message;

package/src/repl/agent-repl.js CHANGED Viewed

@@ -29,6 +29,14 @@ import {
   saveMessages,
   getSession,
 } from "../lib/session-manager.js";
+import {
+  startSession as jsonlStartSession,
+  appendUserMessage,
+  appendAssistantMessage,
+  appendCompactEvent,
+  rebuildMessages,
+  sessionExists,
+} from "../lib/jsonl-session-store.js";
 import { storeMemory, consolidateMemory } from "../lib/hierarchical-memory.js";
 import { CLIContextEngineering } from "../lib/cli-context-engineering.js";
 import { createChatFn } from "../lib/cowork-adapter.js";
@@ -108,9 +116,9 @@ export async function startAgentRepl(options = {}) {
     // Continue without DB — static prompt fallback
   }
-  // Initialize prompt compressor
+  // Initialize prompt compressor (adaptive to model's context window)
   if (feature("PROMPT_COMPRESSOR")) {
-    _compressor = new PromptCompressor({ maxMessages: 20, maxTokens: 8000 });
+    _compressor = new PromptCompressor({ model, provider });
   }
   // Initialize permanent memory
@@ -133,7 +141,18 @@ export async function startAgentRepl(options = {}) {
   _hookDb = db;
   // Resume existing session or create new one
-  if (db && options.sessionId) {
+  const useJsonl = feature("JSONL_SESSION");
+  if (useJsonl && options.sessionId) {
+    // JSONL resume: check if session file exists
+    try {
+      if (sessionExists(options.sessionId)) {
+        sessionId = options.sessionId;
+      }
+    } catch (_err) {
+      // Non-critical
+    }
+  } else if (db && options.sessionId) {
     try {
       const existing = getSession(db, options.sessionId);
       if (existing && existing.messages) {
@@ -144,16 +163,25 @@ export async function startAgentRepl(options = {}) {
     }
   }
-  if (db && !sessionId) {
-    try {
-      const session = createSession(db, {
-        title: `Agent ${new Date().toISOString().slice(0, 10)}`,
-        provider,
-        model,
-      });
-      sessionId = session.id;
-    } catch (_err) {
-      // Non-critical
+  if (!sessionId) {
+    const meta = {
+      title: `Agent ${new Date().toISOString().slice(0, 10)}`,
+      provider,
+      model,
+    };
+    if (useJsonl) {
+      try {
+        sessionId = jsonlStartSession(null, meta);
+      } catch (_err) {
+        // Non-critical
+      }
+    } else if (db) {
+      try {
+        const session = createSession(db, meta);
+        sessionId = session.id;
+      } catch (_err) {
+        // Non-critical
+      }
     }
   }
@@ -162,16 +190,28 @@ export async function startAgentRepl(options = {}) {
   ];
   // Load resumed session messages
-  if (db && options.sessionId && sessionId) {
+  if (options.sessionId && sessionId) {
     try {
-      const existing = getSession(db, sessionId);
-      if (existing && existing.messages) {
-        const parsed =
-          typeof existing.messages === "string"
-            ? JSON.parse(existing.messages)
-            : existing.messages;
-        messages.push(...parsed.filter((m) => m.role !== "system"));
-        logger.info(`Resumed session ${sessionId} (${parsed.length} messages)`);
+      if (useJsonl) {
+        const rebuilt = rebuildMessages(sessionId);
+        if (rebuilt.length > 0) {
+          messages.push(...rebuilt.filter((m) => m.role !== "system"));
+          logger.info(
+            `Resumed JSONL session ${sessionId} (${rebuilt.length} messages)`,
+          );
+        }
+      } else if (db) {
+        const existing = getSession(db, sessionId);
+        if (existing && existing.messages) {
+          const parsed =
+            typeof existing.messages === "string"
+              ? JSON.parse(existing.messages)
+              : existing.messages;
+          messages.push(...parsed.filter((m) => m.role !== "system"));
+          logger.info(
+            `Resumed session ${sessionId} (${parsed.length} messages)`,
+          );
+        }
       }
     } catch (_err) {
       // Non-critical
@@ -434,10 +474,16 @@ export async function startAgentRepl(options = {}) {
       const sessionArg = trimmed.slice(8).trim();
       if (sessionArg.startsWith("resume ")) {
         const resumeId = sessionArg.slice(7).trim();
-        if (!db) {
-          logger.info("No database available for session resume");
-        } else {
-          try {
+        try {
+          if (useJsonl && sessionExists(resumeId)) {
+            const rebuilt = rebuildMessages(resumeId);
+            messages.length = 1; // keep system prompt
+            messages.push(...rebuilt.filter((m) => m.role !== "system"));
+            sessionId = resumeId;
+            logger.info(
+              `Resumed JSONL session ${sessionId} (${rebuilt.length} messages)`,
+            );
+          } else if (db) {
             const existing = getSession(db, resumeId);
             if (existing && existing.messages) {
               const parsed =
@@ -453,9 +499,11 @@ export async function startAgentRepl(options = {}) {
             } else {
               logger.info(`Session not found: ${resumeId}`);
             }
-          } catch (err) {
-            logger.error(`Resume failed: ${err.message}`);
+          } else {
+            logger.info("No session store available");
           }
+        } catch (err) {
+          logger.error(`Resume failed: ${err.message}`);
         }
       } else {
         logger.info(`Session ID: ${sessionId || "none"}`);
@@ -1052,9 +1100,17 @@ export async function startAgentRepl(options = {}) {
       }
       // Auto-save session
-      if (db && sessionId) {
+      if (sessionId) {
         try {
-          saveMessages(db, sessionId, messages);
+          if (useJsonl) {
+            // Append incremental events (user + assistant)
+            appendUserMessage(sessionId, trimmed);
+            if (response) {
+              appendAssistantMessage(sessionId, response);
+            }
+          } else if (db) {
+            saveMessages(db, sessionId, messages);
+          }
         } catch (_e) {
           // Non-critical
         }
@@ -1074,6 +1130,13 @@ export async function startAgentRepl(options = {}) {
             logger.verbose(
               `Auto-compacted: ${stats.strategy} (saved ${stats.saved} tokens)`,
             );
+            // Write compact checkpoint to JSONL for crash recovery
+            if (useJsonl && sessionId) {
+              appendCompactEvent(sessionId, {
+                ...stats,
+                messages: compacted,
+              });
+            }
           }
         } catch (_e) {
           // Non-critical — continue with uncompacted messages
@@ -1116,9 +1179,17 @@ export async function startAgentRepl(options = {}) {
   rl.on("close", async () => {
     // Save session on exit
-    if (db && sessionId) {
+    if (sessionId) {
       try {
-        saveMessages(db, sessionId, messages);
+        if (useJsonl) {
+          // JSONL: write final compact snapshot for fast rebuild
+          appendCompactEvent(sessionId, {
+            strategy: "session-end",
+            messages,
+          });
+        } else if (db) {
+          saveMessages(db, sessionId, messages);
+        }
       } catch (_e) {
         // Non-critical
       }