Handle when a clanker fails to format an edit request

On occassion, clankers will fail to properly escape json when making a
large edit request. The validate edit extension gives a decent error
that you can copy/paste to the clanker so they can fix their mistake.

Also added a little /thinking command to set the thinking level
interactively.

Author: NonlinearFruit

mappings/common.json

@@ -9,6 +9,8 @@
   ["nvim/*", "~/.config/nvim"],
   ["pi/answer-extension.ts", "~/.pi/agent/extensions/answer-extension.ts"],
   ["pi/cursor-rules-extension.ts", "~/.pi/agent/extensions/cursor-rules-extension.ts"],
+  ["pi/thinking-extension.ts", "~/.pi/agent/extensions/thinking-extension.ts"],
+  ["pi/validate-edit-extension.ts", "~/.pi/agent/extensions/validate-edit-extension.ts"],
   ["pi/models.json", "~/.pi/agent/models.json"],
   ["pi/save-last-extension.ts", "~/.pi/agent/extensions/save-last-extension.ts"],
   ["pi/settings.json", "~/.pi/agent/settings.json"],

pi/thinking-extension.ts

@@ -0,0 +1,32 @@
+const DESCRIPTION = {
+  off: "No reasoning (fastest)",
+  minimal: "Minimal internal reasoning",
+  low: "Low-effort reasoning",
+  medium: "Balanced reasoning and speed",
+  high: "Deep reasoning",
+  xhigh: "Maximum reasoning (slowest)",
+};
+const LEVELS = Object.keys(DESCRIPTION)
+
+export default function thinkingExtension(pi) {
+  pi.registerCommand("thinking", {
+    description: "Set thinking level",
+    getArgumentCompletions: (prefix) =>
+      LEVELS
+        .filter(l => l.startsWith(prefix))
+        .map(l => ({ value: l, label: `${l} - ${DESCRIPTION[l]}` })),
+    handler: (args, ctx) => handleThinking(args, ctx, pi),
+  });
+}
+
+async function handleThinking(args, ctx, pi) {
+  const arg = args.trim();
+  const level = LEVELS.includes(arg)
+    ? arg
+    : await ctx.ui.select("Thinking level:", LEVELS);
+
+  if (level && level !== pi.getThinkingLevel()) {
+    pi.setThinkingLevel(level);
+    ctx.ui.notify(`${level} (${DESCRIPTION[level]})`, "success");
+  }
+}

pi/validate-edit-extension.ts

@@ -0,0 +1,84 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { isToolCallEventType } from "@mariozechner/pi-coding-agent";
+
+export default function (pi: ExtensionAPI) {
+  pi.on("tool_call", async (event, ctx) => {
+    if (!isToolCallEventType("edit", event)) return;
+
+    const error = validateEdits(event.input.edits);
+    if (error) {
+      ctx.ui.notify(error, "error");
+      return { block: true, reason: "Invalid edit parameters" };
+    }
+  });
+}
+
+function validateEdits(edits: unknown): string | null {
+  if (!Array.isArray(edits)) {
+    return "❌ edits must be an array";
+  }
+
+  if (edits.length === 0) return null;
+
+  for (let i = 0; i < edits.length; i++) {
+    const item = edits[i];
+
+    if (!isValidEditItem(item)) {
+      return `❌ Edit ${i}: must have oldText (string) and newText (string)`;
+    }
+
+    const jsonError = trySerializeEdit(item as EditItem);
+    if (jsonError) {
+      return `❌ Edit ${i} has JSON serialization error:\n  ${jsonError}\n\n` +
+             `Common cause: Unescaped quotes in oldText or newText.\n` +
+             `Tip: Break into smaller edits or escape special characters.`;
+    }
+  }
+
+  const overlapError = findOverlap(edits as EditItem[]);
+  if (overlapError) {
+    return `❌ ${overlapError}\n\n` +
+           `Solution: Ensure each oldText is unique and non-overlapping.`;
+  }
+
+  return null;
+}
+
+function isValidEditItem(item: unknown): boolean {
+  if (typeof item !== "object" || item === null) return false;
+  const e = item as Record<string, unknown>;
+  return typeof e.oldText === "string" && typeof e.newText === "string";
+}
+
+function trySerializeEdit(edit: EditItem): string | null {
+  try {
+    JSON.stringify({ edits: [edit] });
+    return null;
+  } catch (err) {
+    return (err as Error).message;
+  }
+}
+
+function findOverlap(edits: EditItem[]): string | null {
+  for (let i = 0; i < edits.length; i++) {
+    for (let j = i + 1; j < edits.length; j++) {
+      const a = edits[i].oldText;
+      const b = edits[j].oldText;
+
+      if (a === b) {
+        return `Edits ${i} and ${j}: identical oldText`;
+      }
+
+      if (a.includes(b) || b.includes(a)) {
+        return `Edits ${i} and ${j}: overlapping oldText (one contains the other)`;
+      }
+    }
+  }
+
+  return null;
+}
+
+interface EditItem {
+  oldText: string;
+  newText: string;
+}