@trim21/personal-pi-extensions 0.0.152 → 0.0.153

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trim21/personal-pi-extensions",
-  "version": "0.0.152",
+  "version": "0.0.153",
   "type": "module",
   "description": "Custom pi coding-agent extensions: bwrap sandbox, workspace guard, opencode edit, and more",
   "keywords": [
@@ -34,8 +34,17 @@
   "devDependencies": {
     "@earendil-works/pi-ai": "^0.80.6",
     "@earendil-works/pi-coding-agent": "^0.80.0",
+    "@eslint/js": "10.0.1",
     "@types/node": "^24.0.0",
+    "@typescript-eslint/utils": "8.66.0",
     "eslint": "^10.8.0",
+    "eslint-config-prettier": "10.1.8",
+    "eslint-plugin-erasable-syntax-only": "0.4.2",
+    "eslint-plugin-promise": "7.3.0",
+    "eslint-plugin-simple-import-sort": "14.0.0",
+    "eslint-plugin-tsdoc": "0.5.2",
+    "eslint-plugin-unicorn": "70.0.0",
+    "eslint-plugin-unused-imports": "4.4.1",
     "husky": "^9.1.7",
     "lint-staged": "^17.0.8",
     "prettier": "^3.6.0",

package/src/agents-md-user-message.ts

@@ -13,7 +13,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { getAgentDir, loadProjectContextFiles } from "@earendil-works/pi-coding-agent";
 
-export default function (pi: ExtensionAPI) {
+export default function agentsMdUserMessage(pi: ExtensionAPI) {
   let messageInjected = false;
 
   pi.on("before_agent_start", (event) => {

package/src/bash-default-timeout.ts

@@ -1,6 +1,6 @@
-import { isToolCallEventType, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { type ExtensionAPI, isToolCallEventType } from "@earendil-works/pi-coding-agent";
 
-export default function (pi: ExtensionAPI) {
+export default function bashDefaultTimeout(pi: ExtensionAPI) {
   pi.on("tool_call", (event) => {
     if (isToolCallEventType("bash", event) && event.input.timeout === undefined) {
       event.input.timeout = 180;

package/src/bwrap/index.ts

@@ -52,22 +52,18 @@
  *   pi -e ./bwrap --no-bwrap
  */
 
-import { spawn } from "node:child_process";
 import type { ChildProcess } from "node:child_process";
+import { spawn } from "node:child_process";
 import { constants } from "node:fs";
+import { closeSync, existsSync, openSync, readFileSync } from "node:fs";
 import { access as fsAccess } from "node:fs/promises";
-import { existsSync, readFileSync, openSync, closeSync } from "node:fs";
-import { join, delimiter } from "node:path";
+import { delimiter, join } from "node:path";
 import { fileURLToPath } from "node:url";
+
+import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
+import { type BashOperations, createBashTool, getAgentDir } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { Value } from "typebox/value";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import {
-  type BashOperations,
-  createBashTool,
-  getAgentDir,
-  Theme,
-} from "@earendil-works/pi-coding-agent";
 
 const SANDBOX_PROMPT = `
 ## Command Execution
@@ -110,31 +106,18 @@ and set \`request_full_access_reason\` to describe the failure.
 
 const PROTECTED_DIRS = [".git", ".pi", ".agent"];
 
-let bwrapPath = "";
-
-function findBwrap(override?: string): string {
-  if (override) {
-    if (existsSync(override)) return override;
-    throw new Error(`bwrap not found at configured path: ${override}`);
-  }
-
-  if (bwrapPath) return bwrapPath;
+const bwrapPath = findDefaultBwrap();
 
+function findDefaultBwrap(): string {
   const pathEnv = process.env.PATH ?? "";
   for (const dir of pathEnv.split(delimiter)) {
     const p = join(dir, "bwrap");
-    if (existsSync(p)) {
-      bwrapPath = p;
-      return p;
-    }
+    if (existsSync(p)) return p;
   }
 
   const candidates = ["/usr/bin/bwrap", "/usr/local/bin/bwrap", "/run/current-system/sw/bin/bwrap"];
   for (const p of candidates) {
-    if (existsSync(p)) {
-      bwrapPath = p;
-      return p;
-    }
+    if (existsSync(p)) return p;
   }
 
   throw new Error(
@@ -145,6 +128,10 @@ function findBwrap(override?: string): string {
   );
 }
 
+function findBwrap(override?: string): string {
+  return override ?? bwrapPath;
+}
+
 type BwrapMode = "allow-all" | "workspace-write" | "readonly";
 
 interface BwrapConfig {
@@ -177,12 +164,15 @@ function resolveBwrap(config: BwrapConfig): ResolvedBwrap {
     extraArgs: config.extraArgs ?? [],
   };
   switch (config.mode) {
-    case "allow-all":
+    case "allow-all": {
       return { ...base, bwrapEnabled: false, network: true };
-    case "workspace-write":
+    }
+    case "workspace-write": {
       return { ...base, bwrapEnabled: true, network: false };
-    case "readonly":
+    }
+    case "readonly": {
       return { ...base, bwrapEnabled: true, network: false, writablePaths: [] };
+    }
   }
 }
 
@@ -207,7 +197,8 @@ function deepMerge(base: BwrapConfig, overrides: Partial<BwrapConfig>): BwrapCon
 
 function expandPath(p: string): string {
   if (p.startsWith("~/")) {
-    const home = process.env.HOME!;
+    const home = process.env.HOME;
+    if (home === undefined) return p;
     return join(home, p.slice(2));
   }
   return p;
@@ -232,9 +223,10 @@ function loadConfig(cwd: string): BwrapConfig {
   ] as const) {
     if (existsSync(path)) {
       try {
-        Object.assign(target, JSON.parse(readFileSync(path, "utf-8")));
-      } catch (e) {
-        console.error(`Warning: Could not parse ${path}: ${String(e)}`);
+        Object.assign(target, JSON.parse(readFileSync(path, "utf8")));
+      } catch (error) {
+        // eslint-disable-next-line no-console -- config parse warnings go to stderr
+        console.error(`Warning: Could not parse ${path}: ${String(error)}`);
       }
     }
   }
@@ -316,7 +308,7 @@ function createBwrapBashOps(resolved: ResolvedBwrap): BashOperations {
       // ── seccomp: block AF_UNIX + network syscalls ───────────────
       // bwrap --unshare-net handles IP; seccomp closes the UNIX socket
       // gap (Docker CLI, mysqld, etc.). Filter is generated once.
-      const seccompFd = !resolved.network ? getSeccompFd() : undefined;
+      const seccompFd = resolved.network ? undefined : getSeccompFd();
 
       const baseArgs: string[] = [
         "--ro-bind",
@@ -331,8 +323,14 @@ function createBwrapBashOps(resolved: ResolvedBwrap): BashOperations {
 
       // Two spawn paths so TypeScript can infer the correct child type.
       const child: ChildProcess =
-        seccompFd !== undefined
-          ? spawn(
+        seccompFd === undefined
+          ? spawn(findBwrap(resolved.bwrapPath), [...baseArgs, "--", "bash", "-c", command], {
+              cwd,
+              detached: true,
+              stdio: ["ignore", "pipe", "pipe"],
+              env: process.env,
+            })
+          : spawn(
               findBwrap(resolved.bwrapPath),
               [...baseArgs, "--seccomp", "3", "--", "bash", "-c", command],
               {
@@ -341,13 +339,7 @@ function createBwrapBashOps(resolved: ResolvedBwrap): BashOperations {
                 stdio: ["ignore", "pipe", "pipe", seccompFd],
                 env: process.env,
               },
-            )
-          : spawn(findBwrap(resolved.bwrapPath), [...baseArgs, "--", "bash", "-c", command], {
-              cwd,
-              detached: true,
-              stdio: ["ignore", "pipe", "pipe"],
-              env: process.env,
-            });
+            );
 
       return new Promise((resolve, reject) => {
         let timedOut = false;
@@ -393,7 +385,7 @@ function createBwrapBashOps(resolved: ResolvedBwrap): BashOperations {
         // (potentially) exits. --die-with-parent already covers the
         // case where the parent actually dies.
         const forwardedSignals: NodeJS.Signals[] = ["SIGHUP", "SIGINT", "SIGTERM"];
-        const signalForwarders: Array<() => void> = [];
+        const signalForwarders: (() => void)[] = [];
 
         for (const sig of forwardedSignals) {
           const handler = () => {
@@ -445,10 +437,10 @@ function createBwrapBashOps(resolved: ResolvedBwrap): BashOperations {
 
 function escapeHtml(text: string): string {
   return text
-    .replace(/&/g, "&amp;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-    .replace(/"/g, "&quot;");
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;");
 }
 
 /**
@@ -469,7 +461,7 @@ function maxConsecutiveBackticks(text: string): number {
 }
 
 /**
- * Wrap code in fenced code blocks (```) for literal plain-text rendering.
+ * Wrap code in fenced code blocks for literal plain-text rendering.
  * Uses N+1 backticks for the fence where N is the longest consecutive
  * backtick sequence in the code, so no escaping is needed.
  */
@@ -512,7 +504,7 @@ const sandboxedBashSchema = Type.Object({
   ),
 });
 
-export default function (pi: ExtensionAPI) {
+export default function bwrapExtension(pi: ExtensionAPI) {
   pi.registerFlag("no-bwrap", {
     description: "Disable bwrap sandboxing for bash commands",
     type: "boolean",
@@ -569,7 +561,7 @@ export default function (pi: ExtensionAPI) {
           let choice: string | undefined;
           while (!choice) {
             choice = await ctx.ui.select(desc, ["Approve once", "Block", "Block with reason"]);
-            if (typeof choice === "undefined") {
+            if (choice === undefined) {
               ctx.abort();
               throw new Error("User denied the command execution.");
             }
@@ -625,9 +617,9 @@ export default function (pi: ExtensionAPI) {
     if (resolved.bwrapEnabled) {
       try {
         findBwrap(resolved.bwrapPath);
-      } catch (err) {
+      } catch (error) {
         resolved = null;
-        ctx.ui.notify(err instanceof Error ? err.message : "bwrap not found", "error");
+        ctx.ui.notify(error instanceof Error ? error.message : "bwrap not found", "error");
         return;
       }
     }
@@ -689,13 +681,8 @@ export default function (pi: ExtensionAPI) {
     },
   ) {
     setMode(mode);
-    const r = getResolved();
 
-    if (!r.bwrapEnabled) {
-      ctx.ui.setStatus("bwrap", ctx.ui.theme.fg("accent", `bwrap: ${mode}`));
-    } else {
-      ctx.ui.setStatus("bwrap", ctx.ui.theme.fg("accent", `bwrap: ${mode}`));
-    }
+    ctx.ui.setStatus("bwrap", ctx.ui.theme.fg("accent", `bwrap: ${mode}`));
 
     notifyMode(ctx, mode);
     pi.sendMessage({

package/src/gh-readonly.ts

@@ -28,14 +28,15 @@
  *   cp gh-readonly.ts .pi/extensions/
  */
 
+import { spawn } from "node:child_process";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { Value } from "typebox/value";
-import { spawn } from "node:child_process";
-import { homedir } from "node:os";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
 
 interface GhResult {
   stdout: string;
@@ -70,14 +71,16 @@ export function runGh(
     let onAbort: (() => void) | undefined;
 
     const killProcess = (reason: "timeout" | "abort") => {
-      if (!killed) {
-        killed = true;
-        killReason = reason;
-        proc.kill("SIGTERM");
-        setTimeout(() => {
-          if (!proc.killed) proc.kill("SIGKILL");
-        }, 5000);
+      if (killed) {
+        return;
       }
+
+      killed = true;
+      killReason = reason;
+      proc.kill("SIGTERM");
+      setTimeout(() => {
+        if (!proc.killed) proc.kill("SIGKILL");
+      }, 5000);
     };
 
     if (ctx.signal) {
@@ -214,7 +217,7 @@ function truncate(
   maxBytes = 50 * 1024,
 ): { text: string; truncated: boolean } {
   const lines = text.split("\n");
-  if (lines.length <= maxLines && Buffer.byteLength(text, "utf-8") <= maxBytes) {
+  if (lines.length <= maxLines && Buffer.byteLength(text, "utf8") <= maxBytes) {
     return { text, truncated: false };
   }
 
@@ -222,7 +225,7 @@ function truncate(
   let bytes = 0;
   for (const line of lines) {
     if (out.length >= maxLines) break;
-    const lineBytes = Buffer.byteLength(line + "\n", "utf-8");
+    const lineBytes = Buffer.byteLength(line + "\n", "utf8");
     if (bytes + lineBytes > maxBytes) break;
     out.push(line);
     bytes += lineBytes;
@@ -238,13 +241,13 @@ function toToolResult(
   stdout: string,
   input?: unknown,
 ): {
-  content: Array<{ type: "text"; text: string }>;
+  content: { type: "text"; text: string }[];
   details: Record<string, unknown>;
 } {
   const { text, truncated } = truncate(stdout);
   return {
     content: [{ type: "text", text }],
-    details: { ...(input !== undefined ? { input } : {}), truncated },
+    details: { ...(input !== undefined && { input }), truncated },
   };
 }
 
@@ -317,12 +320,12 @@ export interface JobInfo {
 export function stepsDetail(
   job: JobInfo,
   expandedSteps?: Set<number>,
-): Array<{ number: number; name: string; conclusion: string | null; expanded?: boolean }> {
+): { number: number; name: string; conclusion: string | null; expanded?: boolean }[] {
   return job.steps.map((s) => ({
     number: s.number,
     name: s.name,
     conclusion: s.conclusion,
-    ...(expandedSteps?.has(s.number) ? { expanded: true } : {}),
+    ...(expandedSteps?.has(s.number) && { expanded: true }),
   }));
 }
 
@@ -348,7 +351,7 @@ async function getJobLog(
   const fetchAndCache = async (): Promise<string> => {
     // Check file cache
     try {
-      return await readFile(cacheFile, "utf-8");
+      return await readFile(cacheFile, "utf8");
     } catch {
       // Not cached, fetch from GitHub
     }
@@ -400,20 +403,27 @@ async function resolveRepo(
 
 export function statusIcon(conclusion: string | null): string {
   switch (conclusion) {
-    case "success":
+    case "success": {
       return "✅";
-    case "failure":
+    }
+    case "failure": {
       return "❌";
-    case "cancelled":
+    }
+    case "cancelled": {
       return "🚫";
-    case "skipped":
+    }
+    case "skipped": {
       return "⏭️";
-    case "timed_out":
+    }
+    case "timed_out": {
       return "⏰";
-    case "action_required":
+    }
+    case "action_required": {
       return "⚠️";
-    default:
+    }
+    default: {
       return "🔄";
+    }
   }
 }
 
@@ -443,18 +453,16 @@ export function statusIcon(conclusion: string | null): string {
 export function extractStepFromLog(
   log: string,
   stepNumber: number,
-  apiSteps: Array<{ number: number; name: string }>,
+  apiSteps: { number: number; name: string }[],
 ): string | null {
-  const targetStep = apiSteps.find((s) => s.number === stepNumber);
-  if (!targetStep) return null;
+  if (apiSteps.every((s) => s.number !== stepNumber)) return null;
 
   const lines = log.split("\n");
 
   // Collect depth-1 "Run "/"Post Run " groups in log order.
-  const groups: Array<{ line: number; action: string }> = [];
+  const groups: { line: number; action: string }[] = [];
   let depth = 0;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
+  for (const [i, line] of lines.entries()) {
     if (line.includes("##[endgroup]")) {
       if (depth > 0) depth--;
       continue;
@@ -462,7 +470,7 @@ export function extractStepFromLog(
     if (line.includes("##[group]")) {
       depth++;
       if (depth === 1) {
-        const m = line.match(/##\[group\](.*)/);
+        const m = /##\[group\](.*)/.exec(line);
         const name = m ? m[1].trim() : "";
         if (name.startsWith("Run ") || name.startsWith("Post Run ")) {
           groups.push({ line: i, action: name.replace(/^(Run |Post Run )/, "").trim() });
@@ -483,7 +491,7 @@ export function extractStepFromLog(
   const runSteps = apiSteps
     .filter((s) => /^(Run |Post Run )/.test(s.name))
     .map((s) => ({ number: s.number, action: s.name.replace(/^(Run |Post Run )/, "").trim() }))
-    .sort((a, b) => a.number - b.number);
+    .toSorted((a, b) => a.number - b.number);
 
   // Greedily assign each run step the first unclaimed group whose action name
   // matches (log order). Leftover groups are composite-action internals.
@@ -498,9 +506,9 @@ export function extractStepFromLog(
   }
 
   // Anchor sequence in log order.
-  const anchors = [...stepToGroup.entries()]
+  const anchors = [...stepToGroup]
     .map(([stepNum, gi]) => ({ stepNum, line: groups[gi].line }))
-    .sort((a, b) => a.line - b.line);
+    .toSorted((a, b) => a.line - b.line);
 
   // Direct anchor hit: span from this anchor to the next one.
   const anchorIdx = anchors.findIndex((a) => a.stepNum === stepNumber);
@@ -522,9 +530,8 @@ export function extractStepFromLog(
   const spanStart = prevAnchor ? prevAnchor.line + 1 : 0;
   const spanEnd = nextAnchor ? nextAnchor.line : lines.length;
 
-  for (let gi = 0; gi < groups.length; gi++) {
+  for (const [gi, g] of groups.entries()) {
     if (used.has(gi)) continue;
-    const g = groups[gi];
     if (g.line >= spanStart && g.line < spanEnd) {
       return lines.slice(g.line, spanEnd).join("\n").trimEnd();
     }
@@ -543,15 +550,16 @@ export interface CiLogsJob {
   steps: StepInfo[];
 }
 
-export type CiLogsResult = {
-  content: Array<{ type: "text"; text: string }>;
+export interface CiLogsResult {
+  content: { type: "text"; text: string }[];
   details: Record<string, unknown>;
-};
+}
 
 /** GitHub Actions runner line prefix: `2026-08-05T16:35:50.8358826Z `. */
 const RUNNER_TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z /;
 /** ANSI color escape sequences. */
-const ANSI_RE = /\u001b\[[0-9;]*m/g;
+// eslint-disable-next-line no-control-regex -- intentional: matching raw ESC sequences in runner logs
+const ANSI_RE = /\u001B\[[0-9;]*m/g;
 
 /**
  * Strip the runner framing from a step's raw log, leaving the command's own
@@ -566,7 +574,7 @@ export function cleanStepOutput(stepLog: string): string {
       line
         .replace(/^\uFEFF/, "") // UTF-8 BOM on the first line
         .replace(RUNNER_TIMESTAMP_RE, "")
-        .replace(ANSI_RE, "")
+        .replaceAll(ANSI_RE, "")
         .replace(/\r$/, "")
         .trimEnd(),
     )
@@ -605,7 +613,7 @@ export async function renderStepLog(
   }
 
   const isNumeric = /^\d+$/.test(job);
-  const targetJob = jobs.find((j) => (isNumeric ? String(j.id) === job : j.name === job));
+  const targetJob = jobs.find((j) => (isNumeric ? String(j.id) : j.name) === job);
   if (!targetJob) {
     return {
       content: [
@@ -765,7 +773,7 @@ export async function renderJobLogs(
   let targetJobs = jobs;
   if (job) {
     const isNumeric = /^\d+$/.test(job);
-    targetJobs = jobs.filter((j) => (isNumeric ? String(j.id) === job : j.name === job));
+    targetJobs = jobs.filter((j) => (isNumeric ? String(j.id) : j.name) === job);
     if (targetJobs.length === 0) {
       return {
         content: [
@@ -816,7 +824,7 @@ export async function renderJobLogs(
         }
 
         const { text } = truncate(logToShow, limit ?? 500, 60 * 1024);
-        steps.push({ name: s.name, ...(text ? { output: text } : {}) });
+        steps.push({ name: s.name, ...(text && { output: text }) });
       } catch {
         // Log fetch failed — list the step without an output.
         steps.push({ name: s.name });
@@ -849,7 +857,7 @@ export async function renderJobLogs(
 
 // ── tools ────────────────────────────────────────────────────────────────────
 
-export default function (pi: ExtensionAPI) {
+export default function ghReadonlyTools(pi: ExtensionAPI) {
   // ── read-github-issue ──────────────────────────────────────────────────────
   pi.registerTool({
     name: "read-github-issue",

package/src/opencode-edit-engine.ts

@@ -70,14 +70,14 @@ const SimpleReplacer: Replacer = function* (_content, find) {
 const LineTrimmedReplacer: Replacer = function* (content, find) {
   const originalLines = content.split("\n");
   const searchLines = find.split("\n");
-  if (searchLines[searchLines.length - 1] === "") {
+  if (searchLines.at(-1) === "") {
     searchLines.pop();
   }
   for (let i = 0; i <= originalLines.length - searchLines.length; i++) {
     let matches = true;
-    for (let j = 0; j < searchLines.length; j++) {
+    for (const [j, searchLine] of searchLines.entries()) {
       const originalTrimmed = originalLines[i + j].trim();
-      const searchTrimmed = searchLines[j].trim();
+      const searchTrimmed = searchLine.trim();
       if (originalTrimmed !== searchTrimmed) {
         matches = false;
         break;
@@ -95,7 +95,7 @@ const LineTrimmedReplacer: Replacer = function* (content, find) {
           matchEndIndex += 1;
         }
       }
-      yield content.substring(matchStartIndex, matchEndIndex);
+      yield content.slice(matchStartIndex, matchEndIndex);
     }
   }
 };
@@ -106,15 +106,15 @@ const BlockAnchorReplacer: Replacer = function* (content, find) {
   if (searchLines.length < 3) {
     return;
   }
-  if (searchLines[searchLines.length - 1] === "") {
+  if (searchLines.at(-1) === "") {
     searchLines.pop();
   }
   const firstLineSearch = searchLines[0].trim();
-  const lastLineSearch = searchLines[searchLines.length - 1].trim();
+  const lastLineSearch = searchLines.at(-1)?.trim() ?? "";
   const searchBlockSize = searchLines.length;
   const maxLineDelta = Math.max(1, Math.floor(searchBlockSize * 0.25));
 
-  const candidates: Array<{ startLine: number; endLine: number }> = [];
+  const candidates: { startLine: number; endLine: number }[] = [];
   for (let i = 0; i < originalLines.length; i++) {
     if (originalLines[i].trim() !== firstLineSearch) {
       continue;
@@ -153,7 +153,7 @@ const BlockAnchorReplacer: Replacer = function* (content, find) {
         }
       }
     } else {
-      similarity = 1.0;
+      similarity = 1;
     }
     if (similarity >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) {
       let matchStartIndex = 0;
@@ -167,7 +167,7 @@ const BlockAnchorReplacer: Replacer = function* (content, find) {
           matchEndIndex += 1;
         }
       }
-      yield content.substring(matchStartIndex, matchEndIndex);
+      yield content.slice(matchStartIndex, matchEndIndex);
     }
     return;
   }
@@ -192,7 +192,7 @@ const BlockAnchorReplacer: Replacer = function* (content, find) {
       }
       similarity /= linesToCheck;
     } else {
-      similarity = 1.0;
+      similarity = 1;
     }
     if (similarity > maxSimilarity) {
       maxSimilarity = similarity;
@@ -212,16 +212,18 @@ const BlockAnchorReplacer: Replacer = function* (content, find) {
         matchEndIndex += 1;
       }
     }
-    yield content.substring(matchStartIndex, matchEndIndex);
+    yield content.slice(matchStartIndex, matchEndIndex);
   }
 };
 
+function normalizeWhitespace(text: string): string {
+  return text.replaceAll(/\s+/g, " ").trim();
+}
+
 const WhitespaceNormalizedReplacer: Replacer = function* (content, find) {
-  const normalizeWhitespace = (text: string) => text.replace(/\s+/g, " ").trim();
   const normalizedFind = normalizeWhitespace(find);
   const lines = content.split("\n");
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
+  for (const line of lines) {
     if (normalizeWhitespace(line) === normalizedFind) {
       yield line;
     } else {
@@ -230,8 +232,8 @@ const WhitespaceNormalizedReplacer: Replacer = function* (content, find) {
         const words = find.trim().split(/\s+/);
         if (words.length > 0) {
           const pattern = words
-            .map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
-            .join("\\s+");
+            .map((word) => word.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`))
+            .join(String.raw`\s+`);
           try {
             const regex = new RegExp(pattern);
             const match = line.match(regex);
@@ -256,21 +258,20 @@ const WhitespaceNormalizedReplacer: Replacer = function* (content, find) {
   }
 };
 
+function removeIndentation(text: string): string {
+  const lines = text.split("\n");
+  const nonEmptyLines = lines.filter((line) => line.trim().length > 0);
+  if (nonEmptyLines.length === 0) return text;
+  const minIndent = Math.min(
+    ...nonEmptyLines.map((line) => {
+      const match = /^(\s*)/.exec(line);
+      return match ? match[1].length : 0;
+    }),
+  );
+  return lines.map((line) => (line.trim().length === 0 ? line : line.slice(minIndent))).join("\n");
+}
+
 const IndentationFlexibleReplacer: Replacer = function* (content, find) {
-  const removeIndentation = (text: string) => {
-    const lines = text.split("\n");
-    const nonEmptyLines = lines.filter((line) => line.trim().length > 0);
-    if (nonEmptyLines.length === 0) return text;
-    const minIndent = Math.min(
-      ...nonEmptyLines.map((line) => {
-        const match = line.match(/^(\s*)/);
-        return match ? match[1].length : 0;
-      }),
-    );
-    return lines
-      .map((line) => (line.trim().length === 0 ? line : line.slice(minIndent)))
-      .join("\n");
-  };
   const normalizedFind = removeIndentation(find);
   const contentLines = content.split("\n");
   const findLines = find.split("\n");
@@ -282,33 +283,44 @@ const IndentationFlexibleReplacer: Replacer = function* (content, find) {
   }
 };
 
-const EscapeNormalizedReplacer: Replacer = function* (content, find) {
-  const unescapeString = (str: string): string => {
-    return str.replace(/\\(n|t|r|'|"|`|\\|\n|\$)/g, (_match, capturedChar) => {
-      switch (capturedChar) {
-        case "n":
-          return "\n";
-        case "t":
-          return "\t";
-        case "r":
-          return "\r";
-        case "'":
-          return "'";
-        case '"':
-          return '"';
-        case "`":
-          return "`";
-        case "\\":
-          return "\\";
-        case "\n":
-          return "\n";
-        case "$":
-          return "$";
-        default:
-          return _match;
+function unescapeString(str: string): string {
+  return str.replaceAll(/\\(n|t|r|'|"|`|\\|\n|\$)/g, (_match, capturedChar) => {
+    switch (capturedChar) {
+      case "n": {
+        return "\n";
+      }
+      case "t": {
+        return "\t";
+      }
+      case "r": {
+        return "\r";
+      }
+      case "'": {
+        return "'";
+      }
+      case '"': {
+        return '"';
       }
-    });
-  };
+      case "`": {
+        return "`";
+      }
+      case "\\": {
+        return "\\";
+      }
+      case "\n": {
+        return "\n";
+      }
+      case "$": {
+        return "$";
+      }
+      default: {
+        return _match;
+      }
+    }
+  });
+}
+
+const EscapeNormalizedReplacer: Replacer = function* (content, find) {
   const unescapedFind = unescapeString(find);
   if (content.includes(unescapedFind)) {
     yield unescapedFind;
@@ -357,12 +369,12 @@ const ContextAwareReplacer: Replacer = function* (content, find) {
   if (findLines.length < 3) {
     return;
   }
-  if (findLines[findLines.length - 1] === "") {
+  if (findLines.at(-1) === "") {
     findLines.pop();
   }
   const contentLines = content.split("\n");
   const firstLine = findLines[0].trim();
-  const lastLine = findLines[findLines.length - 1].trim();
+  const lastLine = findLines.at(-1)?.trim() ?? "";
   for (let i = 0; i < contentLines.length; i++) {
     if (contentLines[i].trim() !== firstLine) continue;
     for (let j = i + 2; j < contentLines.length; j++) {
@@ -446,11 +458,15 @@ export function replace(
         );
       }
       if (replaceAll) {
-        return content.replaceAll(search, newString);
+        return content.replaceAll(search, () => newString);
       }
       const lastIndex = content.lastIndexOf(search);
       if (index !== lastIndex) continue;
-      return content.substring(0, index) + newString + content.substring(index + search.length);
+      return (
+        content.slice(0, Math.max(0, index)) +
+        newString +
+        content.slice(Math.max(0, index + search.length))
+      );
     }
   }
 

package/src/opencode-edit.ts

@@ -9,12 +9,18 @@
  *   pi -e ./opencode-edit.ts
  */
 
+import { constants } from "node:fs";
+import { access, readFile, writeFile } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import {
   generateDiffString,
   generateUnifiedPatch,
   withFileMutationQueue,
 } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+
 import {
   detectLineEnding,
   normalizeToLF,
@@ -22,10 +28,6 @@ import {
   restoreLineEndings,
   stripBom,
 } from "./opencode-edit-engine.js";
-import { constants } from "fs";
-import { access, readFile, writeFile } from "fs/promises";
-import { isAbsolute, resolve } from "path";
-import { Type } from "typebox";
 
 // ── schema ────────────────────────────────────────────────────────────────────
 
@@ -42,7 +44,7 @@ const editSchema = Type.Object({
 
 // ── extension ─────────────────────────────────────────────────────────────────
 
-export default function (pi: ExtensionAPI) {
+export default function opencodeEdit(pi: ExtensionAPI) {
   pi.registerTool({
     name: "edit",
     label: "edit",
@@ -69,10 +71,11 @@ export default function (pi: ExtensionAPI) {
 
       const absolutePath = isAbsolute(filePath) ? filePath : resolve(ctx.cwd, filePath);
 
+      const throwIfAborted = (): void => {
+        if (signal?.aborted) throw new Error("Operation aborted");
+      };
+
       return withFileMutationQueue(absolutePath, async () => {
-        const throwIfAborted = (): void => {
-          if (signal?.aborted) throw new Error("Operation aborted");
-        };
         throwIfAborted();
 
         try {
@@ -83,12 +86,12 @@ export default function (pi: ExtensionAPI) {
             error instanceof Error && "code" in error && typeof error.code === "string"
               ? `Error code: ${error.code}`
               : String(error);
-          throw new Error(`Could not edit file: ${filePath}. ${msg}.`);
+          throw new Error(`Could not edit file: ${filePath}. ${msg}.`, { cause: error });
         }
         throwIfAborted();
 
         const buffer = await readFile(absolutePath);
-        const rawContent = buffer.toString("utf-8");
+        const rawContent = buffer.toString("utf8");
         throwIfAborted();
 
         // Strip BOM then normalize line endings to LF.
@@ -101,7 +104,7 @@ export default function (pi: ExtensionAPI) {
         throwIfAborted();
 
         const finalContent = bom + restoreLineEndings(newContent, originalEnding);
-        await writeFile(absolutePath, finalContent, "utf-8");
+        await writeFile(absolutePath, finalContent, "utf8");
         throwIfAborted();
 
         const diffResult = generateDiffString(normalizedContent, newContent);

package/src/opencode-read.ts

@@ -24,6 +24,7 @@
 import { constants } from "node:fs";
 import { access, open, readdir, readFile, stat } from "node:fs/promises";
 import { basename, dirname, isAbsolute, resolve as resolvePath, sep } from "node:path";
+
 import type { ImageContent, TextContent } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
@@ -71,10 +72,10 @@ const BINARY_EXTENSIONS = new Set([
   ".pyo",
 ]);
 
-const IMAGE_SIGNATURES: Array<{
+const IMAGE_SIGNATURES: {
   signature: Uint8Array | ((buf: Uint8Array) => boolean);
   mimeType: string;
-}> = [
+}[] = [
   { signature: new Uint8Array([0xff, 0xd8, 0xff]), mimeType: "image/jpeg" },
   {
     signature: new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
@@ -108,7 +109,7 @@ const IMAGE_SIGNATURES: Array<{
 function startsWithAscii(buf: Uint8Array, offset: number, text: string): boolean {
   if (buf.length < offset + text.length) return false;
   for (let i = 0; i < text.length; i++) {
-    if (buf[offset + i] !== text.charCodeAt(i)) return false;
+    if (buf[offset + i] !== text.codePointAt(i)) return false;
   }
   return true;
 }
@@ -144,7 +145,7 @@ async function detectImageMimeTypeFromFile(filePath: string): Promise<string | n
 
 function isBinaryExtension(filePath: string): boolean {
   const dotIndex = filePath.lastIndexOf(".");
-  if (dotIndex < 0) return false;
+  if (dotIndex === -1) return false;
   return BINARY_EXTENSIONS.has(filePath.slice(dotIndex).toLowerCase());
 }
 
@@ -186,7 +187,7 @@ function truncateHead(
   const lines = content ? content.split("\n") : [];
   if (content.endsWith("\n")) lines.pop();
   const totalLines = lines.length;
-  const totalBytes = Buffer.byteLength(content, "utf-8");
+  const totalBytes = Buffer.byteLength(content, "utf8");
 
   if (totalLines <= maxLines && totalBytes <= maxBytes) {
     return {
@@ -204,7 +205,7 @@ function truncateHead(
     };
   }
 
-  const firstLineBytes = lines.length > 0 ? Buffer.byteLength(lines[0], "utf-8") : 0;
+  const firstLineBytes = lines.length > 0 ? Buffer.byteLength(lines[0], "utf8") : 0;
   if (firstLineBytes > maxBytes) {
     return {
       content: "",
@@ -226,7 +227,7 @@ function truncateHead(
   let truncatedBy: "lines" | "bytes" = "lines";
 
   for (let i = 0; i < lines.length && i < maxLines; i++) {
-    const lineBytes = Buffer.byteLength(lines[i], "utf-8") + (i > 0 ? 1 : 0);
+    const lineBytes = Buffer.byteLength(lines[i], "utf8") + (i > 0 ? 1 : 0);
     if (outputBytesCount + lineBytes > maxBytes) {
       truncatedBy = "bytes";
       break;
@@ -247,7 +248,7 @@ function truncateHead(
     totalLines,
     totalBytes,
     outputLines: outputLinesArr.length,
-    outputBytes: Buffer.byteLength(outputContent, "utf-8"),
+    outputBytes: Buffer.byteLength(outputContent, "utf8"),
     lastLinePartial: false,
     firstLineExceedsLimit: false,
     maxLines,
@@ -300,7 +301,7 @@ async function formatDirectoryEntries(dirPath: string): Promise<string[]> {
   return results;
 }
 
-export default function (pi: ExtensionAPI) {
+export default function opencodeRead(pi: ExtensionAPI) {
   pi.registerTool({
     name: "read",
     label: "read",
@@ -317,14 +318,14 @@ export default function (pi: ExtensionAPI) {
       ),
     }),
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-      const { filePath: rawPath, offset, limit } = params;
-
-      const absolutePath = isAbsolute(rawPath) ? rawPath : resolvePath(ctx.cwd, rawPath);
-
       if (signal?.aborted) {
         throw new Error("Operation aborted");
       }
 
+      const { filePath: rawPath, offset, limit } = params;
+
+      const absolutePath = isAbsolute(rawPath) ? rawPath : resolvePath(ctx.cwd, rawPath);
+
       // Check if path exists
       let fileStat: Awaited<ReturnType<typeof stat>>;
       try {
@@ -366,8 +367,6 @@ export default function (pi: ExtensionAPI) {
       }
 
       // --- File read ---
-      let content: (TextContent | ImageContent)[];
-      let details: { truncation?: TruncationResult } | undefined;
 
       // Check accessibility
       try {
@@ -379,6 +378,8 @@ export default function (pi: ExtensionAPI) {
         };
       }
 
+      let content: (TextContent | ImageContent)[];
+
       // Check for images
       const mimeType = await detectImageMimeTypeFromFile(absolutePath);
       if (mimeType && SUPPORTED_IMAGE_MIMES.has(mimeType)) {
@@ -403,13 +404,12 @@ export default function (pi: ExtensionAPI) {
         };
       }
 
-      const textContent = buffer.toString("utf-8");
+      const textContent = buffer.toString("utf8");
       const allLines = textContent.split("\n");
       const totalFileLines = allLines.length;
 
       // Apply offset
       const startLine = offset ? Math.max(0, offset - 1) : 0;
-      const startLineDisplay = startLine + 1;
 
       if (startLine >= allLines.length) {
         return {
@@ -423,16 +423,20 @@ export default function (pi: ExtensionAPI) {
         };
       }
 
+      const startLineDisplay = startLine + 1;
+
+      let details: { truncation?: TruncationResult } | undefined;
+
       // Apply user-specified limit or default truncation
       let selectedContent: string;
       let userLimitedLines: number | undefined;
 
-      if (limit !== undefined) {
+      if (limit === undefined) {
+        selectedContent = allLines.slice(startLine).join("\n");
+      } else {
         const endLine = Math.min(startLine + limit, allLines.length);
         selectedContent = allLines.slice(startLine, endLine).join("\n");
         userLimitedLines = endLine - startLine;
-      } else {
-        selectedContent = allLines.slice(startLine).join("\n");
       }
 
       // Apply byte/line truncation
@@ -442,7 +446,7 @@ export default function (pi: ExtensionAPI) {
       const endLineDisplay = startLineDisplay + truncation.outputLines - 1;
 
       if (truncation.firstLineExceedsLimit) {
-        const firstLineSize = formatSize(Buffer.byteLength(allLines[startLine], "utf-8"));
+        const firstLineSize = formatSize(Buffer.byteLength(allLines[startLine], "utf8"));
         outputText = `<path>${absolutePath}</path>\n<type>file</type>\n`;
         outputText += `[Line ${startLineDisplay} is ${firstLineSize}, exceeds ${formatSize(DEFAULT_MAX_BYTES)} limit. Use bash to read this line.]`;
         details = { truncation };

package/src/opencode-write.ts

@@ -16,11 +16,12 @@
 
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, resolve as resolvePath } from "node:path";
+
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 
-export default function (pi: ExtensionAPI) {
+export default function opencodeWrite(pi: ExtensionAPI) {
   pi.registerTool({
     name: "write",
     label: "write",
@@ -39,15 +40,15 @@ export default function (pi: ExtensionAPI) {
       const absolutePath = resolvePath(ctx.cwd, rawPath);
       const dir = dirname(absolutePath);
 
-      return withFileMutationQueue(absolutePath, async () => {
-        const throwIfAborted = () => {
-          if (signal?.aborted) throw new Error("Operation aborted");
-        };
+      const throwIfAborted = () => {
+        if (signal?.aborted) throw new Error("Operation aborted");
+      };
 
+      return withFileMutationQueue(absolutePath, async () => {
         throwIfAborted();
         await mkdir(dir, { recursive: true });
         throwIfAborted();
-        await writeFile(absolutePath, content, "utf-8");
+        await writeFile(absolutePath, content, "utf8");
         throwIfAborted();
 
         return {

package/src/todo-pendant.ts

@@ -65,12 +65,12 @@ function formatTaskLine(t: Task): string {
 // Extension
 // ---------------------------------------------------------------------------
 
-export default function (pi: ExtensionAPI) {
+export default function todoPendant(pi: ExtensionAPI) {
   pi.on("tool_result", (event, ctx) => {
     if (event.toolName !== "todo") return;
 
     const details = event.details;
-    if (!isTaskDetails(details) || !details.tasks.length) {
+    if (!isTaskDetails(details) || details.tasks.length === 0) {
       ctx.ui.setWidget("todo-pendant", undefined);
       return;
     }
@@ -81,6 +81,9 @@ export default function (pi: ExtensionAPI) {
       return;
     }
 
-    ctx.ui.setWidget("todo-pendant", [...visible.map(formatTaskLine)]);
+    ctx.ui.setWidget(
+      "todo-pendant",
+      visible.map((t) => formatTaskLine(t)),
+    );
   });
 }

package/src/workspace-guard.ts

@@ -4,7 +4,7 @@
  * File-modifying tools (write, edit) are gated:
  * - Paths inside the workspace or /tmp are auto-allowed.
  * - Paths outside require user approval via confirmation dialog.
- *   The dialog shows a ```diff code block preview of the pending change.
+ *   The dialog shows a `diff` code block preview of the pending change.
  *
  * Read tools (read, ls, find, grep) are unrestricted.
  *
@@ -12,14 +12,16 @@
  *   pi -e workspace-guard
  */
 
-import { basename, isAbsolute, join, resolve, relative, sep } from "node:path";
-import { homedir } from "node:os";
 import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
+
 import {
-  generateUnifiedPatch,
   type ExtensionAPI,
+  generateUnifiedPatch,
   type ToolCallEvent,
 } from "@earendil-works/pi-coding-agent";
+
 import { normalizeForEdit, replace } from "./opencode-edit-engine.js";
 
 const WRITE_TOOLS = new Set(["write", "edit"]);
@@ -113,7 +115,7 @@ function applyChange(
     for (const edit of input.edits) {
       if (!isEditPair(edit)) return undefined;
       if (!next.includes(edit.oldText)) return undefined;
-      next = next.replace(edit.oldText, edit.newText);
+      next = next.replace(edit.oldText, () => edit.newText);
     }
     return next;
   }
@@ -121,7 +123,7 @@ function applyChange(
   return undefined;
 }
 
-/** Wrap patch text in a ```diff code block, truncating very large diffs. */
+/** Wrap patch text in a `diff` code block, truncating very large diffs. */
 function wrapDiff(patch: string): string {
   const lines = patch.split("\n");
   if (lines.length > MAX_PREVIEW_LINES) {
@@ -132,7 +134,7 @@ function wrapDiff(patch: string): string {
 }
 
 /**
- * Build a ```diff code block preview of the pending change.
+ * Build a `diff` code block preview of the pending change.
  * Returns undefined when the diff cannot be computed.
  */
 export async function buildDiffPreview(
@@ -142,7 +144,7 @@ export async function buildDiffPreview(
 ): Promise<string | undefined> {
   let oldContent = "";
   try {
-    oldContent = await readFile(resolvedPath, "utf-8");
+    oldContent = await readFile(resolvedPath, "utf8");
   } catch {
     // Unreadable or missing file: treat as empty so writes show as full additions.
   }
@@ -171,7 +173,7 @@ export async function buildDiffPreview(
   return wrapDiff(generateUnifiedPatch(basename(resolvedPath), oldContent, newContent, 2));
 }
 
-export default function (pi: ExtensionAPI) {
+export default function workspaceGuard(pi: ExtensionAPI) {
   pi.on("before_agent_start", (event, ctx) => {
     const currentCwd = ctx.cwd;
     return {
@@ -214,7 +216,7 @@ export default function (pi: ExtensionAPI) {
 
       choice = await ctx.ui.select(title, ["Approve once", "Block", "Block with reason"]);
 
-      if (typeof choice === "undefined") {
+      if (choice === undefined) {
         ctx.abort();
         return { block: true, reason: "Write outside workspace cancelled by user." };
       }