@bdsqqq/pi 0.0.1

package/dist/extensions/glob.js

@@ -0,0 +1,163 @@
+import { withPromptPatch } from "../core/prompt-patch.js";
+import { boxRendererWindowed, textSection } from "../core/box-format.js";
+import { formatHeadTail } from "../core/output-buffer.js";
+import { getExtensionConfig } from "../core/config.js";
+import * as path from "node:path";
+import { spawn } from "node:child_process";
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+import { createInterface } from "node:readline";
+//#region packages/extensions/glob/index.ts
+/**
+* glob tool — replaces pi's built-in find with enhanced file finding.
+*
+* differences from pi's built-in:
+* - uses rg --files (not fd — one less dependency)
+* - sorted by mtime (most recent first, via rg --sortr modified)
+* - pagination via offset + limit
+* - hidden files included by default (--hidden)
+* - .git/.jj excluded
+*
+* shadows pi's built-in `find` tool via same-name registration.
+*/
+const COLLAPSED_EXCERPTS = [{
+	focus: "head",
+	context: 3
+}, {
+	focus: "tail",
+	context: 5
+}];
+const CONFIG_DEFAULTS = { defaultLimit: 500 };
+function createGlobTool(config = CONFIG_DEFAULTS) {
+	return {
+		name: "find",
+		label: "Find Files",
+		description: "Fast file pattern matching tool that works with any codebase size.\n\nReturns matching file paths sorted by most recent modification time first.\n\n## Pattern syntax\n- `**/*.js` — All JavaScript files in any directory\n- `src/**/*.ts` — TypeScript files under src/\n- `*.json` — JSON files in the current directory\n- `**/*test*` — Files with \"test\" in their name\n- `**/*.{js,ts}` — JavaScript and TypeScript files\n",
+		parameters: Type.Object({
+			filePattern: Type.String({ description: "Glob pattern like \"**/*.js\" or \"src/**/*.ts\" to match files." }),
+			limit: Type.Optional(Type.Number({ description: "Maximum number of results to return." })),
+			offset: Type.Optional(Type.Number({ description: "Number of results to skip (for pagination)." }))
+		}),
+		renderCall(args, theme) {
+			const pattern = args.filePattern || "...";
+			return new Text(theme.fg("toolTitle", theme.bold("Find ")) + theme.fg("dim", pattern), 0, 0);
+		},
+		renderResult(result, { expanded }, _theme) {
+			const content = result.content?.[0];
+			if (!content || content.type !== "text") return new Text("(no output)", 0, 0);
+			return boxRendererWindowed(() => [textSection(void 0, content.text)], {
+				collapsed: { excerpts: COLLAPSED_EXCERPTS },
+				expanded: {}
+			}, void 0, expanded);
+		},
+		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+			const p = params;
+			const searchPath = ctx.cwd;
+			const limit = p.limit ?? config.defaultLimit;
+			const offset = p.offset ?? 0;
+			return new Promise((resolve) => {
+				const child = spawn("rg", [
+					"--files",
+					"--hidden",
+					"--color=never",
+					"--sortr",
+					"modified",
+					"--glob",
+					"!.git",
+					"--glob",
+					"!.jj",
+					"--glob",
+					p.filePattern,
+					searchPath
+				], { stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				] });
+				const rl = createInterface({ input: child.stdout });
+				let stderr = "";
+				let aborted = false;
+				const allPaths = [];
+				const onAbort = () => {
+					aborted = true;
+					if (!child.killed) child.kill();
+				};
+				signal?.addEventListener("abort", onAbort, { once: true });
+				child.stderr?.on("data", (chunk) => {
+					stderr += chunk.toString();
+				});
+				rl.on("line", (line) => {
+					const trimmed = line.trim();
+					if (!trimmed) return;
+					const rel = path.relative(searchPath, trimmed).replace(/\\/g, "/");
+					if (rel && !rel.startsWith("..")) allPaths.push(rel);
+				});
+				child.on("error", (err) => {
+					rl.close();
+					signal?.removeEventListener("abort", onAbort);
+					resolve({
+						content: [{
+							type: "text",
+							text: `find error: ${err.message}`
+						}],
+						isError: true
+					});
+				});
+				child.on("close", (code) => {
+					rl.close();
+					signal?.removeEventListener("abort", onAbort);
+					if (aborted) {
+						resolve({
+							content: [{
+								type: "text",
+								text: "search aborted"
+							}],
+							isError: true
+						});
+						return;
+					}
+					if (code !== 0 && code !== 1 && allPaths.length === 0) {
+						resolve({
+							content: [{
+								type: "text",
+								text: stderr.trim() || `rg exited with code ${code}`
+							}],
+							isError: true
+						});
+						return;
+					}
+					if (allPaths.length === 0) {
+						resolve({ content: [{
+							type: "text",
+							text: "no files found matching pattern"
+						}] });
+						return;
+					}
+					const total = allPaths.length;
+					let output;
+					if (offset > 0) {
+						const paginated = allPaths.slice(offset, offset + limit);
+						output = paginated.join("\n");
+						output += `\n\n(showing ${offset + 1}-${offset + paginated.length} of ${total} results)`;
+					} else if (total > limit) {
+						output = formatHeadTail(allPaths, limit, (n) => `... [${n} more results, use a more specific pattern to narrow] ...`);
+						output += `\n\n(${total} total results)`;
+					} else output = allPaths.join("\n");
+					resolve({
+						content: [{
+							type: "text",
+							text: output
+						}],
+						details: { header: p.filePattern }
+					});
+				});
+			});
+		}
+	};
+}
+function glob_default(pi) {
+	const cfg = getExtensionConfig("@bds_pi/glob", CONFIG_DEFAULTS);
+	pi.registerTool(withPromptPatch(createGlobTool(cfg)));
+}
+//#endregion
+export { createGlobTool, glob_default as default };

package/dist/extensions/grep.d.ts

@@ -0,0 +1,13 @@
+import { ExtensionAPI, ToolDefinition } from "@mariozechner/pi-coding-agent";
+
+//#region packages/extensions/grep/index.d.ts
+type GrepExtConfig = {
+  maxTotalMatches: number;
+  maxPerFile: number;
+  maxLineChars: number;
+  contextLines: number;
+};
+declare function createGrepTool(config?: GrepExtConfig): ToolDefinition;
+declare function export_default(pi: ExtensionAPI): void;
+//#endregion
+export { createGrepTool, export_default as default };

package/dist/extensions/grep.js

@@ -0,0 +1,356 @@
+import { withPromptPatch } from "../core/prompt-patch.js";
+import { boxRendererWindowed, osc8Link } from "../core/box-format.js";
+import { headTail } from "../core/output-buffer.js";
+import { getExtensionConfig } from "../core/config.js";
+import * as path from "node:path";
+import { spawn } from "node:child_process";
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+import * as os from "node:os";
+import { createInterface } from "node:readline";
+//#region packages/extensions/grep/index.ts
+/**
+* grep tool — replaces pi's built-in with tighter limits and context lines.
+*
+* differences from pi's built-in:
+* - per-file match limit (10, prevents one noisy file from consuming quota)
+* - 200-char line truncation (vs pi's 500)
+* - caseSensitive param (default case-sensitive)
+* - suggests literal:true when pattern contains regex metacharacters
+* - spawns rg directly (no ensureTool — nix provides rg on PATH)
+* - includes ±1 context lines around matches (via rg --context) so
+*   the LLM sees surrounding code and show() has natural gaps to elide
+*
+* shadows pi's built-in `grep` tool via same-name registration.
+*/
+const CONFIG_DEFAULTS = {
+	maxTotalMatches: 100,
+	maxPerFile: 10,
+	maxLineChars: 200,
+	contextLines: 1
+};
+/** max files shown in collapsed display */
+const COLLAPSED_MAX_FILES = 3;
+/** per-block excerpts for collapsed display — show first 5 visual lines */
+const COLLAPSED_EXCERPTS = [{
+	focus: "head",
+	context: 5
+}];
+function truncateLine(line, maxChars) {
+	if (line.length <= maxChars) return line;
+	return line.slice(0, maxChars) + "...";
+}
+function looksLikeRegex(pattern) {
+	return /[{}()[\]|\\+*?^$]/.test(pattern);
+}
+/**
+* convert GrepFile[] to BoxSection[] for box-format rendering.
+* each file becomes a section, contiguous match groups become blocks.
+*/
+function grepToSections(files, maxPerFile) {
+	return files.map((f) => {
+		const blocks = [];
+		let current = [];
+		let lastLineNum = -2;
+		for (const m of f.matches) {
+			if (lastLineNum >= 0 && m.lineNum > lastLineNum + 1) {
+				if (current.length > 0) {
+					blocks.push({ lines: current });
+					current = [];
+				}
+			}
+			current.push({
+				gutter: String(m.lineNum),
+				text: m.text,
+				highlight: !m.isContext
+			});
+			lastLineNum = m.lineNum;
+		}
+		if (current.length > 0) blocks.push({ lines: current });
+		return {
+			header: f.path + (f.hitLimit ? ` [${maxPerFile} match limit]` : ""),
+			blocks
+		};
+	});
+}
+function createGrepTool(config = CONFIG_DEFAULTS) {
+	const maxCollectMatches = config.maxTotalMatches * 2;
+	return {
+		name: "grep",
+		label: "Grep",
+		description: `Search for exact text patterns in files using ripgrep, a fast keyword search tool.
+
+# When to use
+- Finding exact text matches (variable names, function calls, specific strings)
+
+# Constraints
+- Results are limited to ${config.maxTotalMatches} matches (up to ${config.maxPerFile} per file)\n- Lines are truncated at ${config.maxLineChars} characters\n\n# Strategy
+- Use 'path' or 'glob' to narrow searches; run multiple focused calls rather than one broad search
+- Uses Rust-style regex (escape \`{\` and \`}\`); use \`literal: true\` for literal text search
+`,
+		parameters: Type.Object({
+			pattern: Type.String({ description: "The pattern to search for (regex by default)." }),
+			path: Type.Optional(Type.String({ description: "The file or directory path to search in. Cannot be used with glob." })),
+			glob: Type.Optional(Type.String({ description: "The glob pattern to filter files (e.g., '**/*.ts'). Cannot be used with path." })),
+			caseSensitive: Type.Optional(Type.Boolean({ description: "Whether to search case-sensitively (default: true)." })),
+			literal: Type.Optional(Type.Boolean({ description: "Whether to treat the pattern as a literal string instead of a regex." }))
+		}),
+		renderCall(args, theme) {
+			const pattern = args.pattern || "...";
+			const searchPath = args.path || args.glob || ".";
+			const home = os.homedir();
+			const shortened = searchPath.startsWith(home) ? `~${searchPath.slice(home.length)}` : searchPath;
+			const linkedPath = searchPath.startsWith("/") ? osc8Link(`file://${searchPath}`, shortened) : shortened;
+			const caseSuffix = args.caseSensitive === false ? " -i" : "";
+			return new Text(theme.fg("toolTitle", theme.bold("Grep ")) + theme.fg("dim", `/${pattern}/${caseSuffix} in ${linkedPath}`), 0, 0);
+		},
+		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+			const p = params;
+			const searchPath = p.path ? path.isAbsolute(p.path) ? p.path : path.resolve(ctx.cwd, p.path) : ctx.cwd;
+			return new Promise((resolve) => {
+				const args = [
+					"--json",
+					"--line-number",
+					"--color=never",
+					"--hidden",
+					"--context",
+					String(config.contextLines)
+				];
+				if (p.caseSensitive === false) args.push("--ignore-case");
+				if (p.literal) args.push("--fixed-strings");
+				if (p.glob) args.push("--glob", p.glob);
+				args.push("--", p.pattern, searchPath);
+				const child = spawn("rg", args, { stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				] });
+				const rl = createInterface({ input: child.stdout });
+				let stderr = "";
+				let totalMatches = 0;
+				let killedDueToLimit = false;
+				let aborted = false;
+				/** all match + context events, in stream order */
+				const events = [];
+				const onAbort = () => {
+					aborted = true;
+					if (!child.killed) child.kill();
+				};
+				signal?.addEventListener("abort", onAbort, { once: true });
+				child.stderr?.on("data", (chunk) => {
+					stderr += chunk.toString();
+				});
+				rl.on("line", (line) => {
+					if (!line.trim() || killedDueToLimit) return;
+					let event;
+					try {
+						event = JSON.parse(line);
+					} catch {
+						return;
+					}
+					if (event.type !== "match" && event.type !== "context") return;
+					const filePath = event.data?.path?.text;
+					const lineNumber = event.data?.line_number;
+					const lineText = (event.data?.lines?.text ?? "").replace(/\r?\n$/, "");
+					if (!filePath || typeof lineNumber !== "number") return;
+					if (event.type === "match") totalMatches++;
+					events.push({
+						kind: event.type,
+						filePath,
+						lineNumber,
+						lineText
+					});
+					if (totalMatches >= maxCollectMatches) {
+						killedDueToLimit = true;
+						if (!child.killed) child.kill();
+					}
+				});
+				child.on("error", (err) => {
+					rl.close();
+					signal?.removeEventListener("abort", onAbort);
+					resolve({
+						content: [{
+							type: "text",
+							text: `grep error: ${err.message}`
+						}],
+						isError: true
+					});
+				});
+				child.on("close", (code) => {
+					rl.close();
+					signal?.removeEventListener("abort", onAbort);
+					if (aborted) {
+						resolve({
+							content: [{
+								type: "text",
+								text: "search aborted"
+							}],
+							isError: true
+						});
+						return;
+					}
+					if (!killedDueToLimit && code !== 0 && code !== 1) {
+						resolve({
+							content: [{
+								type: "text",
+								text: stderr.trim() || `ripgrep exited with code ${code}`
+							}],
+							isError: true
+						});
+						return;
+					}
+					if (totalMatches === 0) {
+						let text = "no matches found";
+						if (!p.literal && looksLikeRegex(p.pattern)) text += "\n\n(pattern contains regex characters — try literal: true if searching for exact text)";
+						resolve({ content: [{
+							type: "text",
+							text
+						}] });
+						return;
+					}
+					const fileOrder = [];
+					const fileEvents = /* @__PURE__ */ new Map();
+					for (const ev of events) {
+						if (!fileEvents.has(ev.filePath)) {
+							fileOrder.push(ev.filePath);
+							fileEvents.set(ev.filePath, []);
+						}
+						fileEvents.get(ev.filePath).push(ev);
+					}
+					const outputLines = [];
+					/** output line indices that are actual matches (not context) */
+					const matchLineIndices = [];
+					/** index of first match line per file — focus points for collapsed display */
+					const firstMatchPerFile = [];
+					const perFileMatchCount = /* @__PURE__ */ new Map();
+					const fileGroups = [];
+					for (let fi = 0; fi < fileOrder.length; fi++) {
+						const filePath = fileOrder[fi];
+						if (!filePath) continue;
+						const fileEvts = fileEvents.get(filePath);
+						const includedMatchLines = /* @__PURE__ */ new Set();
+						let matchesInFile = 0;
+						for (const ev of fileEvts) if (ev.kind === "match") {
+							matchesInFile++;
+							if (matchesInFile <= config.maxPerFile) includedMatchLines.add(ev.lineNumber);
+						}
+						perFileMatchCount.set(filePath, Math.min(matchesInFile, config.maxPerFile));
+						const includedLines = /* @__PURE__ */ new Set();
+						for (const ln of includedMatchLines) {
+							includedLines.add(ln);
+							for (let d = 1; d <= config.contextLines; d++) {
+								includedLines.add(ln - d);
+								includedLines.add(ln + d);
+							}
+						}
+						if (fi > 0) outputLines.push("");
+						const rel = path.relative(searchPath, filePath).replace(/\\/g, "/");
+						const displayPath = rel && !rel.startsWith("..") ? rel : path.basename(filePath);
+						const grepFile = {
+							path: displayPath,
+							matches: [],
+							hitLimit: matchesInFile > config.maxPerFile
+						};
+						let lastOutputLineNum = -Infinity;
+						let isFirstMatchInFile = true;
+						for (const ev of fileEvts) {
+							if (!includedLines.has(ev.lineNumber)) continue;
+							if (ev.lineNumber <= lastOutputLineNum) continue;
+							if (lastOutputLineNum >= 0 && ev.lineNumber > lastOutputLineNum + 1) outputLines.push("--");
+							const idx = outputLines.length;
+							outputLines.push(`${displayPath}:${ev.lineNumber}: ${truncateLine(ev.lineText, config.maxLineChars)}`);
+							lastOutputLineNum = ev.lineNumber;
+							grepFile.matches.push({
+								lineNum: ev.lineNumber,
+								text: truncateLine(ev.lineText, config.maxLineChars),
+								isContext: ev.kind === "context"
+							});
+							if (includedMatchLines.has(ev.lineNumber)) {
+								matchLineIndices.push(idx);
+								if (isFirstMatchInFile) {
+									firstMatchPerFile.push(idx);
+									isFirstMatchInFile = false;
+								}
+							}
+						}
+						fileGroups.push(grepFile);
+					}
+					let output;
+					const notices = [];
+					let finalMatchIndices;
+					if (outputLines.length > config.maxTotalMatches * 3) {
+						const limit = config.maxTotalMatches * 2;
+						const { head, tail, truncatedCount } = headTail(outputLines, limit);
+						output = [
+							...head,
+							"",
+							`... [${truncatedCount} lines truncated] ...`,
+							"",
+							...tail
+						].join("\n");
+						const headLen = head.length;
+						const gapLen = 3;
+						const tailStart = outputLines.length - tail.length;
+						finalMatchIndices = matchLineIndices.map((i) => {
+							if (i < headLen) return i;
+							if (i >= tailStart) return headLen + gapLen + (i - tailStart);
+							return -1;
+						}).filter((i) => i >= 0);
+						notices.push(`${truncatedCount} lines truncated, showing first and last ${limit / 2}`);
+					} else {
+						output = outputLines.join("\n");
+						finalMatchIndices = matchLineIndices;
+					}
+					if (killedDueToLimit) notices.push(`stopped at ${maxCollectMatches} matches — refine pattern`);
+					const filesAtLimit = Array.from(perFileMatchCount.values()).filter((c) => c >= config.maxPerFile).length;
+					if (filesAtLimit > 0) notices.push(`${filesAtLimit} file${filesAtLimit > 1 ? "s" : ""} hit the ${config.maxPerFile}-per-file limit`);
+					if (notices.length > 0) output += `\n\n[${notices.join(". ")}]`;
+					resolve({
+						content: [{
+							type: "text",
+							text: output
+						}],
+						details: {
+							fileGroups,
+							notices,
+							matchLineIndices: finalMatchIndices,
+							firstMatchPerFile,
+							searchPath
+						}
+					});
+				});
+			});
+		},
+		renderResult(result, { expanded }, _theme) {
+			const fileGroups = result.details?.fileGroups;
+			const notices = result.details?.notices ?? [];
+			const basePath = result.details?.searchPath;
+			if (!fileGroups?.length) return new Text(result.content?.[0]?.text ?? "(no output)", 0, 0);
+			const sections = grepToSections(fileGroups, config.maxPerFile);
+			if (basePath) for (let i = 0; i < sections.length; i++) {
+				const fg = fileGroups[i];
+				const section = sections[i];
+				if (!fg || !section) continue;
+				const relPath = fg.path;
+				const absPath = basePath + "/" + relPath;
+				sections[i] = {
+					...section,
+					header: osc8Link(`file://${absPath}`, section.header ?? "")
+				};
+			}
+			return boxRendererWindowed(() => sections, {
+				collapsed: {
+					maxSections: COLLAPSED_MAX_FILES,
+					excerpts: COLLAPSED_EXCERPTS
+				},
+				expanded: {}
+			}, notices.length > 0 ? notices : void 0, expanded);
+		}
+	};
+}
+function grep_default(pi) {
+	const cfg = getExtensionConfig("@bds_pi/grep", CONFIG_DEFAULTS);
+	pi.registerTool(withPromptPatch(createGrepTool(cfg)));
+}
+//#endregion
+export { createGrepTool, grep_default as default };

package/dist/extensions/handoff.d.ts

@@ -0,0 +1,6 @@
+import { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+//#region packages/extensions/handoff/index.d.ts
+declare function export_default(pi: ExtensionAPI): void;
+//#endregion
+export { export_default as default };