@bdsqqq/pi 0.0.1

package/dist/extensions/read.d.ts

@@ -0,0 +1,23 @@
+import { ExtensionAPI, ToolDefinition } from "@mariozechner/pi-coding-agent";
+
+//#region packages/extensions/read/index.d.ts
+interface ReadLimits {
+  maxLines: number;
+  maxFileBytes: number;
+  maxLineBytes: number;
+  maxDirEntries: number;
+}
+declare const NORMAL_LIMITS: ReadLimits;
+declare function expandPath(filePath: string): string;
+declare function resolveToAbsolute(filePath: string, cwd: string): string;
+/**
+* try macOS filesystem variants when file doesn't exist at resolved path.
+* covers NFD normalization and narrow no-break space in AM/PM timestamps.
+*/
+declare function resolveWithVariants(filePath: string, cwd: string): string;
+declare function isSecretFile(filePath: string): boolean;
+declare function listDirectory(dirPath: string, maxEntries: number): string;
+declare function createReadTool(limits: ReadLimits): ToolDefinition;
+declare function export_default(pi: ExtensionAPI): void;
+//#endregion
+export { NORMAL_LIMITS, ReadLimits, createReadTool, export_default as default, expandPath, isSecretFile, listDirectory, resolveToAbsolute, resolveWithVariants };

package/dist/extensions/read.js

@@ -0,0 +1,323 @@
+import { withPromptPatch } from "../core/prompt-patch.js";
+import { boxRendererWindowed, osc8Link } from "../core/box-format.js";
+import { formatHeadTail } from "../core/output-buffer.js";
+import { getExtensionConfig } from "../core/config.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+import * as os from "node:os";
+//#region packages/extensions/read/index.ts
+/**
+* read tool — replaces pi's built-in with enhanced file reading.
+*
+* differences from pi's built-in:
+* - line-numbered output (`1: content`)
+* - directory listing integrated (no separate ls tool needed)
+* - secret file blocking (.env etc.)
+* - `~` expansion and `@` prefix stripping
+* - image support via base64
+*
+* uses `path` + optional `read_range` [start, end] interface.
+*/
+const NORMAL_LIMITS = {
+	maxLines: 500,
+	maxFileBytes: 64 * 1024,
+	maxLineBytes: 4096,
+	maxDirEntries: 1e3
+};
+const CONFIG_DEFAULTS = {
+	maxLines: 500,
+	maxFileBytes: 65536,
+	maxLineBytes: 4096,
+	maxDirEntries: 1e3
+};
+const SECRET_PATTERNS = [/^\.env$/, /^\.env\..+$/];
+const SECRET_EXCEPTIONS = new Set([
+	".env.example",
+	".env.sample",
+	".env.template"
+]);
+const IMAGE_MIME = {
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".png": "image/png",
+	".gif": "image/gif",
+	".webp": "image/webp"
+};
+function expandPath(filePath) {
+	const stripped = filePath.startsWith("@") ? filePath.slice(1) : filePath;
+	if (stripped === "~") return os.homedir();
+	if (stripped.startsWith("~/")) return os.homedir() + stripped.slice(1);
+	return stripped;
+}
+function resolveToAbsolute(filePath, cwd) {
+	const expanded = expandPath(filePath);
+	return path.isAbsolute(expanded) ? expanded : path.resolve(cwd, expanded);
+}
+/**
+* try macOS filesystem variants when file doesn't exist at resolved path.
+* covers NFD normalization and narrow no-break space in AM/PM timestamps.
+*/
+function resolveWithVariants(filePath, cwd) {
+	const resolved = resolveToAbsolute(filePath, cwd);
+	if (fs.existsSync(resolved)) return resolved;
+	const amPm = resolved.replace(/ (AM|PM)\./g, `\u202F$1.`);
+	if (amPm !== resolved && fs.existsSync(amPm)) return amPm;
+	const nfd = resolved.normalize("NFD");
+	if (nfd !== resolved && fs.existsSync(nfd)) return nfd;
+	return resolved;
+}
+function isSecretFile(filePath) {
+	const basename = path.basename(filePath);
+	if (SECRET_EXCEPTIONS.has(basename)) return false;
+	return SECRET_PATTERNS.some((p) => p.test(basename));
+}
+function getImageMime(filePath) {
+	return IMAGE_MIME[path.extname(filePath).toLowerCase()];
+}
+function listDirectory(dirPath, maxEntries) {
+	let entries;
+	try {
+		entries = fs.readdirSync(dirPath, { withFileTypes: true });
+	} catch (err) {
+		throw new Error(`cannot list directory: ${err.message}`);
+	}
+	return formatHeadTail(entries.map((e) => e.isDirectory() ? `${e.name}/` : e.name).sort((a, b) => a.localeCompare(b)), maxEntries, (n) => `... [${n} more entries] ...`);
+}
+function readFileContent(filePath, limits, readRange) {
+	const allLines = fs.readFileSync(filePath, "utf-8").split("\n");
+	const totalLines = allLines.length;
+	const start = Math.max(1, readRange?.[0] ?? 1);
+	const end = Math.min(totalLines, readRange?.[1] ?? start + limits.maxLines - 1);
+	end - start + 1;
+	const numbered = [];
+	for (let i = start - 1; i < end; i++) {
+		let line = allLines[i];
+		if (line === void 0) continue;
+		if (Buffer.byteLength(line, "utf-8") > limits.maxLineBytes) {
+			while (Buffer.byteLength(line, "utf-8") > limits.maxLineBytes) line = line.slice(0, Math.max(1, line.length - 100));
+			line += "... (line truncated)";
+		}
+		numbered.push(`${i + 1}: ${line}`);
+	}
+	if (numbered.reduce((sum, l) => sum + Buffer.byteLength(l, "utf-8") + 1, 0) <= limits.maxFileBytes) return {
+		text: numbered.join("\n"),
+		totalLines,
+		shownStart: start,
+		shownEnd: end
+	};
+	return {
+		text: formatHeadTail(numbered, limits.maxLines, (n) => `... [${n} lines truncated, ${limits.maxFileBytes / 1024}KB limit reached] ...`),
+		totalLines,
+		shownStart: start,
+		shownEnd: end
+	};
+}
+function createReadTool(limits) {
+	return {
+		name: "read",
+		label: "Read",
+		description: `Read a file or list a directory from the file system. If the path is a directory, it returns a list of entries. If the file or directory doesn't exist, an error is returned.
+
+- The path parameter MUST be an absolute path.
+- By default, this tool returns the first ${limits.maxLines} lines. To read more, call it multiple times with different read_ranges.\n- Use the Grep tool to find specific content in large files or files with long lines.
+- If you are unsure of the correct file path, use the glob tool to look up filenames by glob pattern.
+- The contents are returned with each line prefixed by its line number. For example, if a file has contents "abc\\n", you will receive "1: abc\\n". For directories, entries are returned one per line (without line numbers) with a trailing "/" for subdirectories.
+- This tool can read images (such as PNG, JPEG, and GIF files) and present them to the model visually.
+- When possible, call this tool in parallel for all files you will want to read.
+      - Avoid tiny repeated slices (e.g., 50‑line chunks). If you need more context from the same file, read a larger range or the full default window instead.`,
+		parameters: Type.Object({
+			path: Type.String({ description: "The absolute path to the file or directory (MUST be absolute, not relative)." }),
+			read_range: Type.Optional(Type.Array(Type.Number(), {
+				description: `An array of two integers specifying the start and end line numbers to view. Line numbers are 1-indexed. If not provided, defaults to [1, ${limits.maxLines}]. Examples: [500, 700], [700, 1400]`,
+				minItems: 2,
+				maxItems: 2
+			}))
+		}),
+		renderCall(args, theme) {
+			const filePath = args.path || "...";
+			const home = os.homedir();
+			const shortened = filePath.startsWith(home) ? `~${filePath.slice(home.length)}` : filePath;
+			const readRange = args.read_range;
+			let context = shortened;
+			if (Array.isArray(readRange) && readRange.length === 2) context += `:${readRange[0]}-${readRange[1]}`;
+			const linked = filePath.startsWith("/") ? osc8Link(`file://${filePath}`, context) : context;
+			return new Text(theme.fg("toolTitle", theme.bold("Read ")) + theme.fg("dim", linked), 0, 0);
+		},
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			const p = params;
+			const resolved = resolveWithVariants(p.path, ctx.cwd);
+			if (isSecretFile(resolved)) return {
+				content: [{
+					type: "text",
+					text: `refused to read ${path.basename(resolved)}: file may contain secrets. ask the user to share relevant values.`
+				}],
+				isError: true
+			};
+			if (!fs.existsSync(resolved)) return {
+				content: [{
+					type: "text",
+					text: `file not found: ${resolved}`
+				}],
+				isError: true
+			};
+			if (fs.statSync(resolved).isDirectory()) try {
+				return {
+					content: [{
+						type: "text",
+						text: listDirectory(resolved, limits.maxDirEntries)
+					}],
+					details: {
+						filePath: resolved,
+						isDirectory: true
+					}
+				};
+			} catch (err) {
+				return {
+					content: [{
+						type: "text",
+						text: err.message
+					}],
+					isError: true
+				};
+			}
+			const mime = getImageMime(resolved);
+			if (mime) try {
+				return { content: [{
+					type: "image",
+					data: fs.readFileSync(resolved).toString("base64"),
+					mimeType: mime
+				}] };
+			} catch (err) {
+				return {
+					content: [{
+						type: "text",
+						text: `failed to read image: ${err.message}`
+					}],
+					isError: true
+				};
+			}
+			try {
+				const readRange = p.read_range;
+				const { text, totalLines, shownStart, shownEnd } = readFileContent(resolved, limits, readRange);
+				let output = text;
+				let notice;
+				if (shownEnd < totalLines) {
+					notice = `showing lines ${shownStart}-${shownEnd} of ${totalLines}`;
+					output += `\n\n(${notice}. use read_range to see more.)`;
+				}
+				return {
+					content: [{
+						type: "text",
+						text: output
+					}],
+					details: {
+						filePath: resolved,
+						notice
+					}
+				};
+			} catch (err) {
+				return {
+					content: [{
+						type: "text",
+						text: `failed to read file: ${err.message}`
+					}],
+					isError: true
+				};
+			}
+		},
+		renderResult(result, _options, _theme) {
+			const text = result.content?.[0];
+			if (text?.type !== "text") return new Text("(no output)", 0, 0);
+			result.details?.filePath;
+			result.details?.isDirectory;
+			const notice = result.details?.notice;
+			const parsed = text.text.split("\n").map((line) => {
+				const m = line.match(/^(\s*\d+): (.*)$/);
+				if (m && m[1] && m[2]) return {
+					gutter: m[1].trim(),
+					text: m[2],
+					highlight: true
+				};
+				return {
+					text: line,
+					highlight: true
+				};
+			});
+			if (notice && parsed.length > 0) {
+				const last = parsed[parsed.length - 1];
+				if (last && last.text.startsWith(`(${notice}`)) {
+					parsed.pop();
+					const newLast = parsed[parsed.length - 1];
+					if (parsed.length && newLast && newLast.text === "") parsed.pop();
+				}
+			}
+			const notices = notice ? [notice] : void 0;
+			/** collapsed: head 3 + tail 5 visual lines */
+			const COLLAPSED_EXCERPTS = [{
+				focus: "head",
+				context: 3
+			}, {
+				focus: "tail",
+				context: 5
+			}];
+			const section = { blocks: [{ lines: parsed }] };
+			return boxRendererWindowed(() => [section], {
+				collapsed: { excerpts: COLLAPSED_EXCERPTS },
+				expanded: {}
+			}, notices, _options.expanded);
+		}
+	};
+}
+if (import.meta.vitest) {
+	const { describe, it, expect } = import.meta.vitest;
+	describe("expandPath", () => {
+		it("strips @ prefix", () => {
+			expect(expandPath("@/foo/bar")).toBe("/foo/bar");
+		});
+		it("expands ~ to homedir", () => {
+			expect(expandPath("~")).toBe(os.homedir());
+		});
+		it("expands ~/ to homedir + path", () => {
+			expect(expandPath("~/foo")).toBe(os.homedir() + "/foo");
+		});
+		it("returns unchanged path without prefix", () => {
+			expect(expandPath("/absolute/path")).toBe("/absolute/path");
+			expect(expandPath("relative/path")).toBe("relative/path");
+		});
+	});
+	describe("resolveToAbsolute", () => {
+		it("returns absolute paths unchanged", () => {
+			expect(resolveToAbsolute("/foo/bar", "/cwd")).toBe("/foo/bar");
+		});
+		it("resolves relative paths against cwd", () => {
+			expect(resolveToAbsolute("foo/bar", "/cwd")).toBe("/cwd/foo/bar");
+		});
+		it("expands ~ before resolving", () => {
+			expect(resolveToAbsolute("~/foo", "/cwd")).toBe(os.homedir() + "/foo");
+		});
+	});
+	describe("isSecretFile", () => {
+		it("blocks .env files", () => {
+			expect(isSecretFile("/home/user/.env")).toBe(true);
+			expect(isSecretFile("/home/user/.env.local")).toBe(true);
+			expect(isSecretFile("/home/user/.env.production")).toBe(true);
+		});
+		it("allows .env.example and friends", () => {
+			expect(isSecretFile("/home/user/.env.example")).toBe(false);
+			expect(isSecretFile("/home/user/.env.sample")).toBe(false);
+			expect(isSecretFile("/home/user/.env.template")).toBe(false);
+		});
+		it("allows other files", () => {
+			expect(isSecretFile("/home/user/config.json")).toBe(false);
+			expect(isSecretFile("/home/user/README.md")).toBe(false);
+		});
+	});
+}
+function read_default(pi) {
+	const cfg = getExtensionConfig("@bds_pi/read", CONFIG_DEFAULTS);
+	pi.registerTool(withPromptPatch(createReadTool(cfg)));
+}
+//#endregion
+export { NORMAL_LIMITS, createReadTool, read_default as default, expandPath, isSecretFile, listDirectory, resolveToAbsolute, resolveWithVariants };

package/dist/extensions/search-sessions.d.ts

@@ -0,0 +1,29 @@
+import { ExtensionAPI, ToolDefinition } from "@mariozechner/pi-coding-agent";
+
+//#region packages/extensions/search-sessions/index.d.ts
+type SearchSessionsExtConfig = {
+  maxResults: number;
+  sessionsDir: string;
+  rgTimeoutMs: number;
+};
+interface BranchResult {
+  sessionId: string;
+  sessionName: string;
+  leafId: string;
+  workspace: string;
+  filePath: string;
+  timestampStart: string;
+  timestampEnd: string;
+  filesTouched: string[];
+  models: string[];
+  messageCount: number;
+  firstUserMessage: string;
+  /** concatenated user + assistant text for keyword search (not displayed) */
+  searchableText: string;
+  /** path to parent session file if this session was forked */
+  parentSessionPath?: string;
+}
+declare function createSearchSessionsTool(config?: SearchSessionsExtConfig): ToolDefinition;
+declare function export_default(pi: ExtensionAPI): void;
+//#endregion
+export { BranchResult, createSearchSessionsTool, export_default as default };