openfox 2.0.65 → 2.0.66

package/dist/{chunk-RYIREJAW.js → chunk-5EO6SEGV.js}

@@ -1,6 +1,6 @@
 import {
   createLLMClient
-} from "./chunk-QBYQ7KDX.js";
+} from "./chunk-B7WGOK7G.js";
 import {
   getModelProfile
 } from "./chunk-V4IE7HJY.js";
@@ -796,4 +796,4 @@ export {
   parseDefaultModelSelection,
   createProviderManager
 };
-//# sourceMappingURL=chunk-RYIREJAW.js.map
+//# sourceMappingURL=chunk-5EO6SEGV.js.map

package/dist/{chunk-OESYKZCM.js → chunk-5V5DM5E4.js}

@@ -1,10 +1,10 @@
 import {
   COMPACTION_PROMPT,
   createMessageStartEvent
-} from "./chunk-X5YCWKNS.js";
+} from "./chunk-R4UTFE63.js";
 import {
   getCurrentWindowMessageOptions
-} from "./chunk-AIJE3RYH.js";
+} from "./chunk-TFDK6VSG.js";
 
 // src/server/context/compactor.ts
 function appendCompactionPrompt(sessionId, append) {
@@ -31,4 +31,4 @@ export {
   shouldCompact,
   getCompactionTarget
 };
-//# sourceMappingURL=chunk-OESYKZCM.js.map
+//# sourceMappingURL=chunk-5V5DM5E4.js.map

package/dist/{chunk-QBYQ7KDX.js → chunk-B7WGOK7G.js}

@@ -11,8 +11,9 @@ import {
   buildNonStreamingCreateParams,
   buildStreamingCreateParams,
   getThinking,
-  mapFinishReason
-} from "./chunk-Z6W4YHJB.js";
+  mapFinishReason,
+  parseToolArguments
+} from "./chunk-BL5LOLVA.js";
 import {
   LLMError,
   OpenAIHttpClient
@@ -92,11 +93,10 @@ function createLLMClient(config, initialBackend = "unknown") {
         const message = choice.message;
         const content = message.content ?? "";
         const thinkingContent = getThinking(message, thinkingField) ?? "";
-        const toolCalls = message.tool_calls?.map((tc) => ({
-          id: tc.id,
-          name: tc.function.name,
-          arguments: JSON.parse(tc.function.arguments)
-        }));
+        const toolCalls = message.tool_calls?.map((tc) => {
+          const { arguments: args, parseError } = parseToolArguments(tc.function.arguments, { id: tc.id, name: tc.function.name });
+          return { id: tc.id, name: tc.function.name, arguments: args, ...parseError ? { parseError } : {} };
+        });
         return {
           id: httpResponse.id,
           content,
@@ -222,20 +222,21 @@ function createLLMClient(config, initialBackend = "unknown") {
         const finalThinking = fullThinking.trim();
         const parsedToolCalls = [];
         for (const [, tc] of toolCalls) {
-          try {
+          const { arguments: args, parseError } = parseToolArguments(tc.arguments, { id: tc.id, name: tc.name });
+          if (parseError) {
+            logger.warn("Failed to parse tool call arguments", { name: tc.name, arguments: tc.arguments, parseError });
             parsedToolCalls.push({
               id: tc.id,
               name: tc.name,
-              arguments: JSON.parse(tc.arguments)
+              arguments: args,
+              parseError,
+              rawArguments: tc.arguments
             });
-          } catch (error) {
-            logger.warn("Failed to parse tool call arguments", { name: tc.name, arguments: tc.arguments });
+          } else {
             parsedToolCalls.push({
               id: tc.id,
               name: tc.name,
-              arguments: {},
-              parseError: error instanceof Error ? error.message : "Unknown JSON parse error",
-              rawArguments: tc.arguments
+              arguments: args
             });
           }
         }
@@ -264,4 +265,4 @@ function createLLMClient(config, initialBackend = "unknown") {
 export {
   createLLMClient
 };
-//# sourceMappingURL=chunk-QBYQ7KDX.js.map
+//# sourceMappingURL=chunk-B7WGOK7G.js.map

package/dist/{chunk-Z6W4YHJB.js → chunk-BL5LOLVA.js}

@@ -1,4 +1,19 @@
 // src/server/llm/client-pure.ts
+function parseToolArguments(raw, _meta) {
+  const input = raw?.trim() ? raw : "{}";
+  try {
+    const parsed = JSON.parse(input);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { arguments: {}, parseError: "Tool arguments must be a JSON object" };
+    }
+    return { arguments: parsed };
+  } catch (error) {
+    return {
+      arguments: {},
+      parseError: error instanceof Error ? error.message : "Invalid JSON"
+    };
+  }
+}
 function buildModelParams(params) {
   return {
     ...params.temperature !== void 0 && { temperature: params.temperature },
@@ -195,6 +210,7 @@ function mapFinishReason(reason) {
 }
 
 export {
+  parseToolArguments,
   buildModelParams,
   getThinking,
   convertMessages,
@@ -203,4 +219,4 @@ export {
   buildStreamingCreateParams,
   mapFinishReason
 };
-//# sourceMappingURL=chunk-Z6W4YHJB.js.map
+//# sourceMappingURL=chunk-BL5LOLVA.js.map

package/dist/{chunk-TMUBLQFC.js → chunk-C3VLGVSQ.js}

@@ -822,9 +822,9 @@ function buildSnapshotFromSessionState(input) {
     criteria: session.criteria,
     metadataEntries: foldedState.metadataEntries,
     contextState: {
-      currentTokens: session.executionState?.currentTokenCount ?? foldedState.contextState.currentTokens,
+      currentTokens: foldedState.contextState.currentTokens,
       maxTokens: foldedState.contextState.maxTokens,
-      compactionCount: session.executionState?.compactionCount ?? foldedState.contextState.compactionCount,
+      compactionCount: foldedState.contextState.compactionCount,
       dangerZone: foldedState.contextState.dangerZone,
       canCompact: foldedState.contextState.canCompact,
       dynamicContextChanged: foldedState.contextState.dynamicContextChanged
@@ -867,4 +867,4 @@ export {
   buildSnapshot,
   buildSnapshotFromSessionState
 };
-//# sourceMappingURL=chunk-TMUBLQFC.js.map
+//# sourceMappingURL=chunk-C3VLGVSQ.js.map

package/dist/{chunk-ZPIZLTWU.js → chunk-GMXKJGJ2.js}

@@ -173,6 +173,10 @@ function runMigrations(db2) {
     logger.info("Migrating sessions table: adding cached_hash column");
     db2.exec(`ALTER TABLE sessions ADD COLUMN cached_hash TEXT`);
   }
+  if (!columnNames.includes("worktree")) {
+    logger.info("Migrating sessions table: adding worktree column");
+    db2.exec(`ALTER TABLE sessions ADD COLUMN worktree TEXT`);
+  }
   logger.info("Database migrations completed");
 }
 
@@ -180,4 +184,4 @@ export {
   initDatabase,
   getDatabase
 };
-//# sourceMappingURL=chunk-ZPIZLTWU.js.map
+//# sourceMappingURL=chunk-GMXKJGJ2.js.map

package/dist/{chunk-YQ3SOPBI.js → chunk-KXVFHMSM.js}

@@ -1,6 +1,6 @@
 import {
   getDatabase
-} from "./chunk-ZPIZLTWU.js";
+} from "./chunk-GMXKJGJ2.js";
 
 // src/server/db/projects.ts
 function createProject(name, workdir) {
@@ -117,4 +117,4 @@ export {
   deleteProject,
   toggleStar
 };
-//# sourceMappingURL=chunk-YQ3SOPBI.js.map
+//# sourceMappingURL=chunk-KXVFHMSM.js.map

package/dist/chunk-OBK3I4KD.js

@@ -0,0 +1,137 @@
+import {
+  gitSpawnEnv
+} from "./chunk-WGMJCFCE.js";
+import {
+  logger
+} from "./chunk-K44MW7JJ.js";
+
+// src/server/git/worktree.ts
+import { spawn } from "child_process";
+import { mkdir, readFile, appendFile, stat } from "fs/promises";
+import { resolve } from "path";
+function captureStdout(cwd, args) {
+  return new Promise((resolvePromise) => {
+    const proc = spawn("git", args, { cwd, env: gitSpawnEnv(), stdio: ["ignore", "pipe", "ignore"] });
+    let out = "";
+    proc.stdout.on("data", (d) => {
+      out += d.toString();
+    });
+    proc.on("close", (code) => resolvePromise(code === 0 ? out : null));
+    proc.on("error", () => resolvePromise(null));
+  });
+}
+function runGit(cwd, args) {
+  return new Promise((resolvePromise, reject) => {
+    const proc = spawn("git", args, { cwd, env: gitSpawnEnv(), stdio: ["ignore", "pipe", "pipe"] });
+    let stderr = "";
+    proc.stderr.on("data", (d) => {
+      stderr += d.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0) resolvePromise();
+      else reject(new Error(stderr.trim() || `git ${args[0]} failed (code ${code})`));
+    });
+    proc.on("error", (err) => reject(err));
+  });
+}
+function getGitBranch(cwd) {
+  return captureStdout(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]).then((r) => r?.trim() ?? null);
+}
+function listWorktrees(cwd) {
+  return captureStdout(cwd, ["worktree", "list", "--porcelain"]).then((out) => {
+    if (!out) return [];
+    const entries = [];
+    let current = {};
+    for (const line of out.split("\n")) {
+      if (line.startsWith("worktree ")) current.path = line.slice(9);
+      else if (line.startsWith("branch ")) current.branch = line.slice(7).replace("refs/heads/", "");
+      else if (line === "" && current.path && current.branch) {
+        entries.push({ path: current.path, branch: current.branch });
+        current = {};
+      }
+    }
+    if (current.path && current.branch) entries.push({ path: current.path, branch: current.branch });
+    return entries;
+  });
+}
+function validateRef(cwd, name) {
+  return runGit(cwd, ["check-ref-format", `refs/heads/${name}`]);
+}
+function addWorktree(cwd, args) {
+  return runGit(cwd, ["worktree", "add", ...args]);
+}
+async function ensureWorktreesIgnored(projectDir) {
+  const gitignorePath = resolve(projectDir, ".gitignore");
+  let content = "";
+  try {
+    content = await readFile(gitignorePath, "utf-8");
+  } catch {
+  }
+  const lines = content.split("\n");
+  const hasWorktreesIgnore = lines.some(
+    (line) => line.trim() === "worktrees/" || line.trim() === "/worktrees/" || line.trim() === "worktrees"
+  );
+  if (hasWorktreesIgnore) return;
+  const entry = content.length > 0 && !content.endsWith("\n") ? "\nworktrees/\n" : "worktrees/\n";
+  await appendFile(gitignorePath, entry);
+}
+function listBranches(cwd) {
+  return captureStdout(cwd, ["branch", "--format", "%(refname:short)%09%(HEAD)"]).then((out) => {
+    if (!out) return [];
+    const branches = [];
+    for (const line of out.trim().split("\n")) {
+      if (!line) continue;
+      const [name, head] = line.split("	");
+      if (name) branches.push({ name, current: head === "*" });
+    }
+    return branches;
+  });
+}
+function checkoutBranch(cwd, name) {
+  return runGit(cwd, ["checkout", name]);
+}
+function createBranch(cwd, name) {
+  return runGit(cwd, ["checkout", "-b", name]);
+}
+function branchExists(cwd, name) {
+  return captureStdout(cwd, ["rev-parse", "--verify", `refs/heads/${name}`]).then((r) => r !== null);
+}
+async function ensureWorktree(projectDir, name, startBranch) {
+  await validateRef(projectDir, name);
+  const worktreesDir = resolve(projectDir, "worktrees");
+  const wtPath = resolve(worktreesDir, name.replace(/\//g, "-"));
+  await mkdir(worktreesDir, { recursive: true });
+  await ensureWorktreesIgnored(projectDir).catch((err) => {
+    logger.warn("Failed to update .gitignore", { projectDir, error: String(err) });
+  });
+  const startBranchResolved = startBranch ?? await getGitBranch(projectDir) ?? "main";
+  try {
+    const st = await stat(wtPath);
+    if (st.isDirectory()) return { path: wtPath, name };
+  } catch {
+  }
+  try {
+    await addWorktree(projectDir, ["-b", name, wtPath, startBranchResolved]);
+  } catch (err) {
+    const exists = await branchExists(projectDir, name);
+    if (exists) {
+      await addWorktree(projectDir, [wtPath, name]);
+    } else {
+      throw err;
+    }
+  }
+  return { path: wtPath, name };
+}
+
+export {
+  getGitBranch,
+  listWorktrees,
+  validateRef,
+  addWorktree,
+  ensureWorktreesIgnored,
+  listBranches,
+  checkoutBranch,
+  createBranch,
+  ensureWorktree
+};
+//# sourceMappingURL=chunk-OBK3I4KD.js.map