@trim21/personal-pi-extensions 0.0.230 → 0.0.232

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trim21/personal-pi-extensions",
-  "version": "0.0.230",
+  "version": "0.0.232",
   "type": "module",
   "description": "Custom pi coding-agent extensions: bwrap sandbox, workspace guard, opencode edit, and more",
   "keywords": [

package/src/claude-code/grep.ts

@@ -3,8 +3,14 @@
  *
  * Split out of the former search.ts so spawn-agent subagents can load it
  * independently (declare `Grep` in the frontmatter to get only this tool).
+ *
+ * Parameter semantics and default behavior are aligned with Claude Code's
+ * GrepTool (ripgrep-based): hidden files searched, VCS directories excluded,
+ * lines capped at 500 columns, and an implicit head_limit of 250 entries.
  */
 
+import { stat } from "node:fs/promises";
+
 import { StringEnum } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
@@ -15,6 +21,16 @@ const GREP_OUTPUT_MODES = ["content", "files_with_matches", "count"] as const;
 
 type GrepOutputMode = (typeof GREP_OUTPUT_MODES)[number];
 
+/** Version control directories excluded from searches (noise in results). */
+const VCS_DIRECTORIES_TO_EXCLUDE = [".git", ".svn", ".hg", ".bzr", ".jj", ".sl"] as const;
+
+/**
+ * Default cap on results when head_limit is unspecified. Prevents broad
+ * patterns from flooding the context; pass head_limit=0 explicitly for
+ * unlimited results. Mirrors Claude Code's default of 250.
+ */
+const DEFAULT_HEAD_LIMIT = 250;
+
 function truncateOutput(output: string, maxCharacters = 30_000): string {
   if (output.length <= maxCharacters) return output;
   return `${output.slice(0, maxCharacters)}\n\n[Output truncated at ${maxCharacters} characters]`;
@@ -39,7 +55,10 @@ interface GrepParameters {
 
 export function buildGrepArguments(params: GrepParameters, cwd: string): string[] {
   const mode = params.output_mode ?? "files_with_matches";
-  const args = ["--color=never"];
+  const args = ["--color=never", "--hidden", "--max-columns", "500"];
+  for (const dir of VCS_DIRECTORIES_TO_EXCLUDE) {
+    args.push("--glob", `!${dir}`);
+  }
   switch (mode) {
     case "files_with_matches": {
       args.push("--files-with-matches");
@@ -51,7 +70,8 @@ export function buildGrepArguments(params: GrepParameters, cwd: string): string[
     }
     case "content": {
       args.push("--no-heading", "--with-filename");
-      if (params["-n"] !== false) args.push("--line-number");
+      const showLineNumbers = params["-n"] === true || params["-n"] === undefined;
+      if (showLineNumbers) args.push("--line-number");
       const before = params["-B"];
       const after = params["-A"];
       const around = params.context ?? params["-C"];
@@ -72,6 +92,43 @@ export function buildGrepArguments(params: GrepParameters, cwd: string): string[
   return args;
 }
 
+/**
+ * Sort a newline-separated list of file paths by modification time, most
+ * recent first, with file name as a tiebreaker. Files that can no longer be
+ * stat-ed sort last (mtime 0). Used for files_with_matches output, matching
+ * Claude Code's behaviour.
+ */
+export async function sortFilesByMtime(output: string): Promise<string> {
+  const paths = output.replace(/\n$/, "").split("\n").filter(Boolean);
+  if (paths.length <= 1) return output;
+  const stats = await Promise.allSettled(paths.map((path) => stat(path)));
+  const sorted = paths
+    .map((path, index) => ({
+      path,
+      mtimeMs: stats[index]?.status === "fulfilled" ? stats[index].value.mtimeMs : 0,
+    }))
+    .toSorted((left, right) => right.mtimeMs - left.mtimeMs || left.path.localeCompare(right.path))
+    .map((entry) => entry.path);
+  return sorted.join("\n");
+}
+
+/**
+ * Append an occurrence/file summary to `filename:count` output (count mode),
+ * mirroring Claude Code's "Found N occurrences across M files" result.
+ */
+export function summarizeCountOutput(output: string): string {
+  const lines = output.split("\n").filter((line) => line.includes(":"));
+  let occurrences = 0;
+  for (const line of lines) {
+    const colon = line.lastIndexOf(":");
+    occurrences += Number(line.slice(colon + 1)) || 0;
+  }
+  const files = lines.length;
+  const occurrenceLabel = occurrences === 1 ? "occurrence" : "occurrences";
+  const fileLabel = files === 1 ? "file" : "files";
+  return `${output.trimEnd()}\n\nFound ${occurrences} total ${occurrenceLabel} across ${files} ${fileLabel}.`;
+}
+
 export function pageGrepOutput(output: string, offset = 0, headLimit = 0): string {
   const lines = output ? output.replace(/\n$/, "").split("\n") : [];
   if (offset >= lines.length && lines.length > 0) return "No entries at this offset";
@@ -154,7 +211,21 @@ export function registerGrepTool(pi: ExtensionAPI): void {
       if (result.code === 1 || result.stdout === "") {
         return { content: [{ type: "text", text: "No files found" }], details: { matches: 0 } };
       }
-      const text = pageGrepOutput(result.stdout, params.offset ?? 0, params.head_limit ?? 0);
+      const mode = params.output_mode ?? "files_with_matches";
+      // head_limit defaults to DEFAULT_HEAD_LIMIT; an explicit 0 means unlimited.
+      const stdout =
+        mode === "files_with_matches" ? await sortFilesByMtime(result.stdout) : result.stdout;
+      const text = pageGrepOutput(
+        stdout,
+        params.offset ?? 0,
+        params.head_limit ?? DEFAULT_HEAD_LIMIT,
+      );
+      if (mode === "count") {
+        return {
+          content: [{ type: "text", text: summarizeCountOutput(text) }],
+          details: undefined,
+        };
+      }
       return { content: [{ type: "text", text }], details: undefined };
     },
   });

package/src/spawn-agent.ts

@@ -60,9 +60,11 @@ const MAX_PROGRESS_LINES = 5;
  * without bash need no bwrap setup (there are no commands to sandbox).
  * (Workspace write protection is embedded in the opencode write/edit tools.)
  *
- * Claude Code style tools (capitalized names, e.g. `Grep`/`Glob`) map to
- * their split claude-code files, so a subagent can enable exactly the search
- * tools it declares — e.g. `Grep` without `Glob`.
+ * Claude Code style tools (capitalized names) map to their claude-code
+ * files, so a subagent can enable exactly the tools it declares — e.g. `Grep`
+ * without `Glob`. The stateful file tools (`Read`/`Edit`/`Write`) share one
+ * implementation file (they share a read-snapshot state); the `--tools`
+ * allowlist still exposes only the declared subset.
  */
 const TOOL_EXTENSION_OVERRIDES: Record<string, string> = {
   read: "opencode/read.ts",
@@ -71,6 +73,9 @@ const TOOL_EXTENSION_OVERRIDES: Record<string, string> = {
   bash: "opencode/bash.ts",
   Grep: "claude-code/grep.ts",
   Glob: "claude-code/glob.ts",
+  Read: "claude-code/files.ts",
+  Edit: "claude-code/files.ts",
+  Write: "claude-code/files.ts",
 };
 
 // ── schema ───────────────────────────────────────────────────────────────────
@@ -205,10 +210,17 @@ export function buildSubagentArgs(
   const tools = agent.tools ?? DEFAULT_TOOLS;
   // Load the opencode override for each built-in tool the agent declares
   // (read/edit/write), so the subagent uses the enhanced implementation
-  // instead of the built-in one.
+  // instead of the built-in one. Several tool names can map to the same
+  // implementation file (e.g. cc Read/Edit/Write → claude-code/files.ts);
+  // loading a file twice would run its extension factory twice and create
+  // separate closure states, so each file is loaded at most once.
+  const loadedOverrideFiles = new Set<string>();
   for (const tool of tools) {
     const ext = TOOL_EXTENSION_OVERRIDES[tool];
-    if (ext) args.push("-e", extensionPath(ext));
+    if (ext && !loadedOverrideFiles.has(ext)) {
+      loadedOverrideFiles.add(ext);
+      args.push("-e", extensionPath(ext));
+    }
   }
   args.push("--tools", tools.join(","));
   if (systemPromptPath) args.push("--append-system-prompt", systemPromptPath);