sharkbait 1.0.26 → 1.0.28

package/dist/cli.js

@@ -1428,7 +1428,20 @@ async function isBeadsFunctional() {
       return { functional: true, useNoDb: false };
     }
   } catch {}
-  if (bdSupportsNoDb()) {
+  try {
+    const result = await exec([BD_PATH, "list", "--json", "--no-db"], { cwd: process.cwd() });
+    if (result.exitCode === 0) {
+      forceNoDb = true;
+      return { functional: true, useNoDb: true };
+    }
+  } catch {}
+  if (tryFixMetadataBackend()) {
+    try {
+      const result = await exec([BD_PATH, "list", "--json"], { cwd: process.cwd() });
+      if (result.exitCode === 0) {
+        return { functional: true, useNoDb: true };
+      }
+    } catch {}
     try {
       const result = await exec([BD_PATH, "list", "--json", "--no-db"], { cwd: process.cwd() });
       if (result.exitCode === 0) {
@@ -1437,7 +1450,7 @@ async function isBeadsFunctional() {
       }
     } catch {}
   }
-  return { functional: false, error: "bd list failed (dolt unreachable and --no-db fallback failed)" };
+  return { functional: false, error: "bd list failed (dolt unreachable, --no-db failed, metadata fix failed)" };
 }
 async function isBdInstalled() {
   try {
@@ -1447,13 +1460,25 @@ async function isBdInstalled() {
     return false;
   }
 }
-function bdSupportsNoDb() {
+function tryFixMetadataBackend(cwd) {
+  const dir = cwd || process.cwd();
+  const metadataPath = join3(dir, ".beads", "metadata.json");
   try {
-    const help = execSync(`${BD_PATH} init --help 2>&1`, { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
-    return help.includes("--no-db");
-  } catch {
-    return false;
-  }
+    if (!existsSync3(metadataPath))
+      return false;
+    const { readFileSync, writeFileSync } = __require("fs");
+    const raw = readFileSync(metadataPath, "utf-8");
+    const meta = JSON.parse(raw);
+    if (meta.backend === "dolt" || meta.database === "dolt") {
+      meta.backend = "no-db";
+      meta.database = "no-db";
+      delete meta.dolt_mode;
+      delete meta.dolt_database;
+      writeFileSync(metadataPath, JSON.stringify(meta, null, 2));
+      return true;
+    }
+  } catch {}
+  return false;
 }
 var beadsTools = [
   {
@@ -1590,18 +1615,27 @@ var beadsTools = [
             alreadyInitialized: true
           };
         }
-        if (bdSupportsNoDb()) {
-          try {
-            const result = await exec([BD_PATH, "init", "--no-db"], { cwd: process.cwd() });
-            if (result.exitCode === 0) {
-              return {
-                success: true,
-                message: "Beads reinitialized in no-db mode (dolt was not reachable).",
-                output: result.stdout.trim(),
-                mode: "no-db"
-              };
-            }
-          } catch {}
+        try {
+          const result = await exec([BD_PATH, "init", "--no-db"], { cwd: process.cwd() });
+          if (result.exitCode === 0) {
+            tryFixMetadataBackend();
+            return {
+              success: true,
+              message: "Beads reinitialized in no-db mode (dolt was not reachable).",
+              output: result.stdout.trim(),
+              mode: "no-db"
+            };
+          }
+        } catch {}
+        if (tryFixMetadataBackend()) {
+          const { functional: nowFunctional } = await isBeadsFunctional();
+          if (nowFunctional) {
+            return {
+              success: true,
+              message: "Beads metadata fixed — switched from dolt to no-db mode.",
+              mode: "no-db"
+            };
+          }
         }
         return {
           success: false,
@@ -1609,34 +1643,28 @@ var beadsTools = [
           proceedWithoutBeads: true
         };
       }
-      const args = [BD_PATH, "init"];
-      if (noDb && bdSupportsNoDb()) {
-        args.push("--no-db");
-      }
       try {
-        const result = await exec(args, { cwd: process.cwd() });
-        if (result.exitCode !== 0) {
-          if (!noDb && bdSupportsNoDb()) {
-            const fallback = await exec([BD_PATH, "init", "--no-db"], { cwd: process.cwd() });
-            if (fallback.exitCode === 0) {
-              return {
-                success: true,
-                message: "Beads initialized in no-db mode (dolt not available, using JSONL).",
-                output: fallback.stdout.trim(),
-                mode: "no-db"
-              };
-            }
-          }
+        const result = await exec([BD_PATH, "init", "--no-db"], { cwd: process.cwd() });
+        if (result.exitCode === 0) {
           return {
-            success: false,
-            message: `Failed to initialize beads: ${result.stderr || result.stdout}. Proceed with the task without beads.`,
-            proceedWithoutBeads: true
+            success: true,
+            message: "Beads initialized in no-db mode (JSONL-backed, no dolt dependency).",
+            output: result.stdout.trim(),
+            mode: "no-db"
+          };
+        }
+        const fallback = await exec([BD_PATH, "init"], { cwd: process.cwd() });
+        if (fallback.exitCode === 0) {
+          return {
+            success: true,
+            message: "Beads initialized successfully.",
+            output: fallback.stdout.trim()
           };
         }
         return {
-          success: true,
-          message: "Beads initialized successfully.",
-          output: result.stdout.trim()
+          success: false,
+          message: `Failed to initialize beads: ${fallback.stderr || fallback.stdout}. Proceed with the task without beads.`,
+          proceedWithoutBeads: true
         };
       } catch (error) {
         return {
@@ -1822,7 +1850,7 @@ var beadsTools = [
           return JSON.parse(result.stdout);
         }
       } catch {}
-      if (!forceNoDb && bdSupportsNoDb()) {
+      if (!forceNoDb) {
         try {
           const noDbArgs = [...args, "--no-db"];
           const result = await exec(noDbArgs);
@@ -1832,6 +1860,14 @@ var beadsTools = [
           }
         } catch {}
       }
+      if (tryFixMetadataBackend()) {
+        try {
+          const result = await exec(bdArgs("list", "--json"));
+          if (result.exitCode === 0) {
+            return JSON.parse(result.stdout);
+          }
+        } catch {}
+      }
       try {
         const { readFileSync, readdirSync: readdirSync2 } = await import("fs");
         const beadsDir = join3(process.cwd(), ".beads");
@@ -3561,17 +3597,23 @@ Revise your approach based on what we've learned.`
         content: fullContent,
         tool_calls: toolCalls
       });
-      const toolResults = await Promise.allSettled(toolCalls.map(async (call) => {
+      const parsedArgs = [];
+      for (let i = 0;i < toolCalls.length; i++) {
+        const call = toolCalls[i];
         let args;
         try {
           args = JSON.parse(call.function.arguments);
         } catch (parseErr) {
-          throw new Error(`Invalid tool arguments for ${call.function.name}: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`);
+          args = {};
         }
+        parsedArgs.push(args);
+        yield { type: "tool_start", name: call.function.name, args };
+      }
+      const toolResults = await Promise.allSettled(toolCalls.map(async (call, i) => {
         return {
           call,
-          args,
-          result: await this.tools.execute(call.function.name, args)
+          args: parsedArgs[i],
+          result: await this.tools.execute(call.function.name, parsedArgs[i])
         };
       }));
       for (let i = 0;i < toolResults.length; i++) {
@@ -3579,7 +3621,6 @@ Revise your approach based on what we've learned.`
         const settled = toolResults[i];
         if (settled.status === "fulfilled") {
           const { args, result } = settled.value;
-          yield { type: "tool_start", name: call.function.name, args };
           yield { type: "tool_result", name: call.function.name, result };
           this.messages.push({
             role: "tool",
@@ -3602,7 +3643,6 @@ Revise your approach based on what we've learned.`
           progressLedger.lastProgressAt = new Date;
         } else {
           const errorMsg = getErrorMessage(settled.reason);
-          yield { type: "tool_start", name: call.function.name, args: {} };
           yield { type: "tool_error", name: call.function.name, error: errorMsg };
           this.messages.push({
             role: "tool",
@@ -7009,7 +7049,7 @@ function Spinner({
   useEffect(() => {
     const timer = setInterval(() => {
       setFrameIndex((prev) => (prev + 1) % frames.length);
-    }, 200);
+    }, 300);
     return () => clearInterval(timer);
   }, [frames.length]);
   return /* @__PURE__ */ jsxDEV3(Box3, {
@@ -8574,13 +8614,16 @@ function App({ contextFiles: initialContextFiles, enableBeads: initialBeadsEnabl
     return config.azure.deployment;
   });
   const abortControllerRef = useRef(null);
+  const RENDER_INTERVAL = 150;
   const pendingOutputRef = useRef("");
   const pendingTokensRef = useRef(0);
   const pendingCostRef = useRef(0);
-  const outputTimerRef = useRef(null);
+  const activeToolCallsRef = useRef([]);
+  const toolCallsDirtyRef = useRef(false);
+  const renderTimerRef = useRef(null);
   const { exit } = useApp();
   const workingDir = currentDir;
-  const flushOutput = useCallback(() => {
+  const flushRender = useCallback(() => {
     const output = pendingOutputRef.current;
     const reasoning = pendingReasoningRef.current;
     const tokens = pendingTokensRef.current;
@@ -8597,22 +8640,34 @@ function App({ contextFiles: initialContextFiles, enableBeads: initialBeadsEnabl
       setSessionCost((prev) => prev + cost);
       pendingCostRef.current = 0;
     }
-    outputTimerRef.current = null;
+    if (toolCallsDirtyRef.current) {
+      setActiveToolCalls([...activeToolCallsRef.current]);
+      toolCallsDirtyRef.current = false;
+    }
+    renderTimerRef.current = null;
   }, []);
+  const scheduleRender = useCallback(() => {
+    if (!renderTimerRef.current) {
+      renderTimerRef.current = setTimeout(flushRender, RENDER_INTERVAL);
+    }
+  }, [flushRender]);
   const throttledSetOutput = useCallback((content, chunkTokens) => {
     pendingOutputRef.current = content;
     if (chunkTokens && chunkTokens > 0) {
       pendingTokensRef.current += chunkTokens;
       pendingCostRef.current += chunkTokens * 0.00003;
     }
-    if (!outputTimerRef.current) {
-      outputTimerRef.current = setTimeout(flushOutput, 80);
-    }
-  }, [flushOutput]);
+    scheduleRender();
+  }, [scheduleRender]);
+  const updateToolCalls = useCallback((updater) => {
+    activeToolCallsRef.current = updater(activeToolCallsRef.current);
+    toolCallsDirtyRef.current = true;
+    scheduleRender();
+  }, [scheduleRender]);
   useEffect2(() => {
     return () => {
-      if (outputTimerRef.current)
-        clearTimeout(outputTimerRef.current);
+      if (renderTimerRef.current)
+        clearTimeout(renderTimerRef.current);
     };
   }, []);
   const agent = React5.useMemo(() => new Agent({
@@ -8766,6 +8821,9 @@ function App({ contextFiles: initialContextFiles, enableBeads: initialBeadsEnabl
     setCurrentOutput("");
     setCurrentReasoning("");
     pendingReasoningRef.current = "";
+    pendingOutputRef.current = "";
+    activeToolCallsRef.current = [];
+    toolCallsDirtyRef.current = false;
     setActiveToolCalls([]);
     const inputTokens = estimateTokens(userMessage);
     setTokenCount((prev) => prev + inputTokens);
@@ -8780,9 +8838,7 @@ function App({ contextFiles: initialContextFiles, enableBeads: initialBeadsEnabl
         switch (event.type) {
           case "reasoning":
             pendingReasoningRef.current += event.content;
-            if (!outputTimerRef.current) {
-              outputTimerRef.current = setTimeout(flushOutput, 80);
-            }
+            scheduleRender();
             break;
           case "text":
             assistantContent += event.content;
@@ -8849,12 +8905,12 @@ ${event.consolidated}`,
               status: "running",
               startTime: Date.now()
             };
-            setActiveToolCalls((prev) => [...prev, newTool]);
+            updateToolCalls((prev) => [...prev, newTool]);
             break;
           }
           case "tool_result": {
             const duration = event.duration;
-            setActiveToolCalls((prev) => {
+            updateToolCalls((prev) => {
               const updated = prev.map((tc) => tc.name === event.name && tc.status === "running" ? {
                 ...tc,
                 status: "success",
@@ -8871,7 +8927,7 @@ ${event.consolidated}`,
           }
           case "tool_error": {
             const duration = event.duration;
-            setActiveToolCalls((prev) => prev.map((tc) => tc.name === event.name && tc.status === "running" ? {
+            updateToolCalls((prev) => prev.map((tc) => tc.name === event.name && tc.status === "running" ? {
               ...tc,
               status: "error",
               duration,
@@ -8883,9 +8939,9 @@ ${event.consolidated}`,
             setTokenCount(event.totalTokens);
             break;
           case "done":
-            if (outputTimerRef.current) {
-              clearTimeout(outputTimerRef.current);
-              outputTimerRef.current = null;
+            if (renderTimerRef.current) {
+              clearTimeout(renderTimerRef.current);
+              renderTimerRef.current = null;
             }
             if (pendingTokensRef.current > 0) {
               setTokenCount((prev) => prev + pendingTokensRef.current);
@@ -8897,7 +8953,8 @@ ${event.consolidated}`,
             }
             pendingOutputRef.current = "";
             pendingReasoningRef.current = "";
-            setCurrentReasoning("");
+            activeToolCallsRef.current = [];
+            toolCallsDirtyRef.current = false;
             if (assistantContent.trim()) {
               setMessages((prev) => [...prev, {
                 role: "assistant",
@@ -8907,6 +8964,7 @@ ${event.consolidated}`,
               }]);
             }
             setCurrentOutput("");
+            setCurrentReasoning("");
             setActiveToolCalls([]);
             setCurrentAgent(null);
             setThinkingMessage(null);
@@ -9089,7 +9147,7 @@ ${event.consolidated}`,
 }
 
 // src/version.ts
-var VERSION = "1.0.26";
+var VERSION = "1.0.28";
 
 // src/agent/start-chat.ts
 async function startChat(options = {}) {
@@ -10373,7 +10431,7 @@ ${"━".repeat(60)}`);
 }
 
 // src/version.ts
-var VERSION2 = "1.0.26";
+var VERSION2 = "1.0.28";
 
 // src/ui/logo.tsx
 import { Box as Box14, Text as Text14 } from "ink";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sharkbait",
-  "version": "1.0.26",
+  "version": "1.0.28",
   "description": "AI-powered coding assistant for the command line. Uses OpenAI Responses API (not Chat). Autonomous agents, parallel code reviews, 36 tools.",
   "type": "module",
   "main": "./dist/cli.js",