npm - @tritard/waterbrother - Versions diffs - 0.8.27 → 0.8.28 - Mend

@tritard/waterbrother 0.8.27 → 0.8.28

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 (3) hide show

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@tritard/waterbrother",
-  "version": "0.8.27",
+  "version": "0.8.28",
   "description": "Waterbrother: Grok-powered coding CLI with local tools, sessions, operator modes, and approval controls",
   "type": "module",
   "bin": {

package/src/cli.js CHANGED Viewed

@@ -606,6 +606,50 @@ function buildSyntheticAssistantOutput(receipt) {
   return null;
 }
+function hasFrontendCodeEcho(text) {
+  const body = String(text || "");
+  return /```(?:html|css|js|javascript|jsx|tsx)?[\s\S]{120,}```/i.test(body) || /<!DOCTYPE html>/i.test(body);
+}
+function hasWriteMutationTool(receipt) {
+  const tools = Array.isArray(receipt?.tools) ? receipt.tools : [];
+  return tools.some((tool) => ["write_file", "replace_in_file", "apply_patch"].includes(tool?.name));
+}
+function deriveContractWriteTarget(contract) {
+  const paths = Array.isArray(contract?.paths) ? contract.paths : [];
+  for (const item of paths) {
+    const raw = String(item || "").trim();
+    if (!raw) continue;
+    const normalized = raw.replace(/\/\*\*?$/g, "").replace(/\*+$/g, "");
+    if (normalized) return normalized;
+  }
+  return null;
+}
+function shouldRecoverFrontendCodeEcho({ frontendExecutionContext, receipt, assistantText }) {
+  if (!frontendExecutionContext?.frontend) return false;
+  if (!receipt || receipt.mutated) return false;
+  if (!hasFrontendCodeEcho(assistantText)) return false;
+  if (hasWriteMutationTool(receipt)) return false;
+  const tools = Array.isArray(receipt.tools) ? receipt.tools : [];
+  return tools.some((tool) => tool?.name === "declare_contract") || tools.some((tool) => tool?.name === "make_directory");
+}
+function buildFrontendWriteRecoveryPrompt({ originalPrompt, contract }) {
+  const target = deriveContractWriteTarget(contract);
+  const lines = [
+    "You already planned the work but printed code into chat instead of writing files.",
+    `Original task: ${String(originalPrompt || "").trim()}`,
+    target ? `Write the generated frontend into the declared scope now: ${target}` : "Write the generated frontend into the declared contract scope now.",
+    "Do not print long code blocks in chat.",
+    "Use write_file (or replace_in_file/apply_patch if needed) to create the actual site files.",
+    "If this is a new site in a folder, default to writing index.html there unless multiple files are clearly justified.",
+    "After writing, reply briefly with only the files created or updated."
+  ];
+  return lines.join("\n\n");
+}
 function color256(fg, text) {
   return `\x1b[38;5;${fg}m${text}\x1b[0m`;
 }
@@ -3576,6 +3620,40 @@ async function runTextTurnInteractive({
     precomputedReceipt = await agent.toolRuntime.completeTurn({ signal: abortController?.signal });
     renderedAssistantText = buildSyntheticAssistantOutput(precomputedReceipt) || renderedAssistantText;
   }
+  if (!precomputedReceipt && frontendExecutionContext) {
+    const candidateReceipt = await agent.toolRuntime.completeTurn({ signal: abortController?.signal });
+    if (shouldRecoverFrontendCodeEcho({ frontendExecutionContext, receipt: candidateReceipt, assistantText: response.content || "" })) {
+      const recoverySpinner = createProgressSpinner("writing files...");
+      printLiveTrace("frontend recovery: assistant echoed code, retrying with write_file", context.runtime.traceMode);
+      agent.toolRuntime.setReadOnlyRoots(readOnlyRoots);
+      agent.toolRuntime.setWriteRoots(writeRoots);
+      if (frontendExecutionContext) {
+        const merged = { ...(previousExecutionContext || {}), ...frontendExecutionContext };
+        if (previousExecutionContext?.reminders && frontendExecutionContext.reminders) {
+          merged.reminders = `${previousExecutionContext.reminders}\n${frontendExecutionContext.reminders}`;
+        }
+        agent.setExecutionContext(merged);
+      }
+      try {
+        response = await agent.runTurn(buildFrontendWriteRecoveryPrompt({ originalPrompt: effectivePromptText, contract: candidateReceipt?.contract }), {
+          signal: abortController?.signal,
+          onStateChange(state) {
+            printLiveTrace(`state=${state}`, context.runtime.traceMode, { verboseOnly: true });
+          }
+        });
+        renderedAssistantText = response.content || "";
+      } finally {
+        recoverySpinner.stop();
+        agent.toolRuntime.setReadOnlyRoots([]);
+        agent.toolRuntime.setWriteRoots([]);
+        if (frontendExecutionContext) {
+          agent.setExecutionContext(previousExecutionContext);
+        }
+      }
+    } else {
+      precomputedReceipt = candidateReceipt;
+    }
+  }
   printAssistantOutput(renderedAssistantText);
   await setSessionRunState(currentSession, agent, "done");
   printTurnSummary(turnSummary, response, { modelId: agent.getModel(), costTracker: context.costTracker, traceMode: context.runtime.traceMode });

package/src/tools.js CHANGED Viewed

@@ -1037,12 +1037,23 @@ export function createToolRuntime({
     return { decision: "ask", reason: "No matching allow rule" };
   }
+  function getContractWriteRoots() {
+    const rawPaths = Array.isArray(currentTurn.contract?.paths) ? currentTurn.contract.paths : [];
+    return normalizePathList(
+      rawPaths
+        .map((item) => String(item || "").trim())
+        .filter(Boolean)
+        .map((item) => item.replace(/\/\*\*?$/g, "").replace(/\*+$/g, ""))
+        .filter(Boolean)
+    );
+  }
   function contractAllows(toolName, args = {}) {
     if (!currentTurn.contract) return { ok: !toolRequiresContract(toolName, args), reason: "No active contract" };
     if ((toolName === "write_file" || toolName === "replace_in_file" || toolName === "make_directory" || toolName === "delete_path") && args.path) {
       try {
         resolveSandboxPath(cwd, args.path, allowOutsideCwd, {
-          allowedWriteRoots: getCurrentWriteRoots()
+          allowedWriteRoots: [...getCurrentWriteRoots(), ...getContractWriteRoots()]
         });
       } catch {
         const touchedPaths = getTouchedPathsForTool(toolName, args);