chainlesschain 0.45.10 → 0.45.11

package/src/lib/worktree-isolator.js

@@ -0,0 +1,231 @@
+/**
+ * Worktree Isolator — git worktree-based task isolation.
+ *
+ * Creates temporary git worktrees for parallel agent tasks,
+ * ensuring file operations don't interfere with the main working tree.
+ *
+ * Feature-flag gated: WORKTREE_ISOLATION
+ */
+
+import { execSync } from "node:child_process";
+import { existsSync, rmSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { isGitRepo, gitExec } from "./git-integration.js";
+
+const WORKTREE_DIR = ".worktrees";
+
+// ── Low-level worktree operations ───────────────────────────────────────
+
+/**
+ * Create a new git worktree with a new branch.
+ * @param {string} repoDir — Root of the git repository
+ * @param {string} branchName — Branch name (e.g. "agent/task-123")
+ * @param {string} [baseBranch] — Base branch (default: HEAD)
+ * @returns {{ path: string, branch: string }}
+ */
+export function createWorktree(repoDir, branchName, baseBranch) {
+  if (!isGitRepo(repoDir)) {
+    throw new Error("Not a git repository");
+  }
+
+  const worktreePath = resolve(
+    repoDir,
+    WORKTREE_DIR,
+    branchName.replace(/\//g, "-"),
+  );
+
+  if (existsSync(worktreePath)) {
+    throw new Error(`Worktree already exists: ${worktreePath}`);
+  }
+
+  const base = baseBranch || "HEAD";
+  gitExec(`worktree add "${worktreePath}" -b "${branchName}" ${base}`, repoDir);
+
+  return { path: worktreePath, branch: branchName };
+}
+
+/**
+ * Remove a git worktree and its branch.
+ * @param {string} repoDir
+ * @param {string} worktreePath — Absolute path to the worktree
+ * @param {object} [options]
+ * @param {boolean} [options.deleteBranch=true] — Also delete the branch
+ */
+export function removeWorktree(repoDir, worktreePath, options = {}) {
+  const deleteBranch = options.deleteBranch !== false;
+
+  // Get branch name before removal
+  let branch = null;
+  if (deleteBranch) {
+    try {
+      branch = execSync("git rev-parse --abbrev-ref HEAD", {
+        cwd: worktreePath,
+        encoding: "utf-8",
+      }).trim();
+    } catch (_e) {
+      // Can't determine branch — skip branch deletion
+    }
+  }
+
+  try {
+    gitExec(`worktree remove "${worktreePath}" --force`, repoDir);
+  } catch (_e) {
+    // If git worktree remove fails, try manual cleanup
+    if (existsSync(worktreePath)) {
+      rmSync(worktreePath, { recursive: true, force: true });
+    }
+    gitExec("worktree prune", repoDir);
+  }
+
+  // Delete the branch
+  if (
+    deleteBranch &&
+    branch &&
+    branch !== "HEAD" &&
+    !branch.startsWith("main") &&
+    !branch.startsWith("master")
+  ) {
+    try {
+      gitExec(`branch -D "${branch}"`, repoDir);
+    } catch (_e) {
+      // Branch might already be deleted
+    }
+  }
+}
+
+/**
+ * List all worktrees.
+ * @param {string} repoDir
+ * @returns {Array<{path: string, branch: string, head: string}>}
+ */
+export function listWorktrees(repoDir) {
+  if (!isGitRepo(repoDir)) return [];
+
+  try {
+    const output = gitExec("worktree list --porcelain", repoDir);
+    const worktrees = [];
+    let current = {};
+
+    for (const line of output.split("\n")) {
+      if (line.startsWith("worktree ")) {
+        if (current.path) worktrees.push(current);
+        current = { path: line.slice(9) };
+      } else if (line.startsWith("HEAD ")) {
+        current.head = line.slice(5);
+      } else if (line.startsWith("branch ")) {
+        current.branch = line.slice(7).replace("refs/heads/", "");
+      } else if (line === "bare") {
+        current.bare = true;
+      }
+    }
+    if (current.path) worktrees.push(current);
+
+    return worktrees;
+  } catch (_e) {
+    return [];
+  }
+}
+
+/**
+ * Prune stale worktrees (where directory no longer exists).
+ * @param {string} repoDir
+ * @returns {number} Number pruned
+ */
+export function pruneWorktrees(repoDir) {
+  if (!isGitRepo(repoDir)) return 0;
+
+  const before = listWorktrees(repoDir).length;
+  gitExec("worktree prune", repoDir);
+  const after = listWorktrees(repoDir).length;
+  return before - after;
+}
+
+// ── High-level isolation API ────────────────────────────────────────────
+
+/**
+ * Run a function in an isolated git worktree.
+ *
+ * Creates a worktree → executes fn(worktreePath) → cleans up.
+ * If fn throws, the worktree is still cleaned up.
+ *
+ * @param {string} repoDir — Root of the git repository
+ * @param {string} taskId — Used to generate branch name: agent/{taskId}
+ * @param {Function} fn — async (worktreePath) => result
+ * @returns {Promise<{result, branch, merged}>}
+ */
+export async function isolateTask(repoDir, taskId, fn) {
+  const branchName = `agent/${taskId}`;
+  const { path: worktreePath } = createWorktree(repoDir, branchName);
+
+  try {
+    const result = await fn(worktreePath);
+
+    // Check if the worktree has any changes
+    const hasChanges = _hasUncommittedChanges(worktreePath);
+
+    return {
+      result,
+      branch: branchName,
+      worktreePath,
+      hasChanges,
+    };
+  } finally {
+    // Always clean up the worktree (but keep branch if there are commits)
+    try {
+      const hasCommits = _hasBranchCommits(repoDir, branchName);
+      removeWorktree(repoDir, worktreePath, {
+        deleteBranch: !hasCommits,
+      });
+    } catch (_e) {
+      // Best-effort cleanup
+    }
+  }
+}
+
+/**
+ * Clean up all agent worktrees (e.g. after crash recovery).
+ * @param {string} repoDir
+ * @returns {number} Number of worktrees cleaned
+ */
+export function cleanupAgentWorktrees(repoDir) {
+  const worktrees = listWorktrees(repoDir);
+  let cleaned = 0;
+
+  for (const wt of worktrees) {
+    if (wt.branch && wt.branch.startsWith("agent/")) {
+      try {
+        removeWorktree(repoDir, wt.path, { deleteBranch: true });
+        cleaned++;
+      } catch (_e) {
+        // Skip if can't clean
+      }
+    }
+  }
+
+  pruneWorktrees(repoDir);
+  return cleaned;
+}
+
+// ── Internal helpers ────────────────────────────────────────────────────
+
+function _hasUncommittedChanges(worktreePath) {
+  try {
+    const output = execSync("git status --porcelain", {
+      cwd: worktreePath,
+      encoding: "utf-8",
+    });
+    return output.trim().length > 0;
+  } catch (_e) {
+    return false;
+  }
+}
+
+function _hasBranchCommits(repoDir, branchName) {
+  try {
+    // Check if branch has commits not in HEAD
+    const output = gitExec(`log HEAD..${branchName} --oneline`, repoDir);
+    return output.trim().length > 0;
+  } catch (_e) {
+    return false;
+  }
+}

package/src/repl/agent-repl.js

@@ -38,6 +38,8 @@ import {
 } from "../lib/task-model-selector.js";
 import { CLIPermanentMemory } from "../lib/permanent-memory.js";
 import { CLIAutonomousAgent, GoalStatus } from "../lib/autonomous-agent.js";
+import { PromptCompressor } from "../lib/prompt-compressor.js";
+import { feature } from "../lib/feature-flags.js";
 import {
   AGENT_TOOLS,
   buildSystemPrompt,
@@ -50,6 +52,7 @@ import {
  * Reference to the runtime DB for hook execution (set during startAgentRepl)
  */
 let _hookDb = null;
+let _compressor = null;
 
 /**
  * Execute a tool call — delegates to agent-core with REPL's hookDb and cwd.
@@ -105,6 +108,11 @@ export async function startAgentRepl(options = {}) {
     // Continue without DB — static prompt fallback
   }
 
+  // Initialize prompt compressor
+  if (feature("PROMPT_COMPRESSOR")) {
+    _compressor = new PromptCompressor({ maxMessages: 20, maxTokens: 8000 });
+  }
+
   // Initialize permanent memory
   let permanentMemory = null;
   try {
@@ -373,7 +381,15 @@ export async function startAgentRepl(options = {}) {
     }
 
     if (trimmed === "/compact") {
-      if (contextEngine && messages.length > 5) {
+      if (_compressor && messages.length > 3) {
+        const { messages: compacted, stats } =
+          await _compressor.compress(messages);
+        messages.length = 0;
+        messages.push(...compacted);
+        logger.info(
+          `Compacted: ${stats.originalMessages} → ${stats.compressedMessages} messages, saved ${stats.saved} tokens (${stats.strategy})`,
+        );
+      } else if (contextEngine && messages.length > 5) {
         const compacted = contextEngine.smartCompact(messages);
         messages.length = 0;
         messages.push(...compacted);
@@ -381,7 +397,6 @@ export async function startAgentRepl(options = {}) {
           `Compacted to ${messages.length} messages (importance-based)`,
         );
       } else if (messages.length > 5) {
-        // Fallback: original logic
         const systemMsg = messages[0];
         const recent = messages.slice(-4);
         messages.length = 0;
@@ -1044,6 +1059,27 @@ export async function startAgentRepl(options = {}) {
           // Non-critical
         }
       }
+      // Auto-compact when context grows too large
+      if (
+        feature("PROMPT_COMPRESSOR") &&
+        _compressor &&
+        _compressor.shouldAutoCompact(messages)
+      ) {
+        try {
+          const { messages: compacted, stats } =
+            await _compressor.compress(messages);
+          messages.length = 0;
+          messages.push(...compacted);
+          if (stats.saved > 0) {
+            logger.verbose(
+              `Auto-compacted: ${stats.strategy} (saved ${stats.saved} tokens)`,
+            );
+          }
+        } catch (_e) {
+          // Non-critical — continue with uncompacted messages
+        }
+      }
+
       // Store as episodic memory
       if (db) {
         try {