@bdsqqq/pi 0.0.1

package/dist/extensions/search-sessions.js

@@ -0,0 +1,426 @@
+import { withPromptPatch } from "../core/prompt-patch.js";
+import { boxRendererWindowed } from "../core/box-format.js";
+import { getExtensionConfig } from "../core/config.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { execSync } from "node:child_process";
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+import * as os from "node:os";
+//#region packages/extensions/search-sessions/index.ts
+/**
+* search_sessions tool — find session branches by keyword, file, or date.
+*
+* a session is a tree of entries (messages, tool calls, branches).
+* the searchable unit is a BRANCH — a root-to-leaf path through the tree.
+* each branch has its own files-touched set, message chain, and timestamp range.
+*
+* pipeline: glob session files → optional rg keyword pre-filter → parse JSONL →
+* enumerate branches → filter by params → return sorted results.
+*/
+const CONFIG_DEFAULTS = {
+	maxResults: 50,
+	sessionsDir: path.join(os.homedir(), ".pi", "agent", "sessions"),
+	rgTimeoutMs: 1e4
+};
+/** per-block excerpts for collapsed display — first 5 visual lines */
+const COLLAPSED_EXCERPTS = [{
+	focus: "head",
+	context: 5
+}];
+function isTextContent(part) {
+	return part.type === "text" && typeof part.text === "string";
+}
+/** tool argument keys that contain file paths */
+const PATH_KEYS = [
+	"path",
+	"filePath",
+	"file_path"
+];
+function extractFilePaths(args) {
+	if (!args) return [];
+	const paths = [];
+	for (const key of PATH_KEYS) if (typeof args[key] === "string") paths.push(args[key]);
+	return paths;
+}
+/** extract file paths from free text — @-mentions and absolute paths */
+function extractFilePathsFromText(text) {
+	const paths = [];
+	for (const m of text.matchAll(/@([\w./-]+\/[\w./-]+)/g)) if (m[1]) paths.push(m[1]);
+	for (const m of text.matchAll(/(?:^|\s)(\/[\w./-]+)/gm)) if (m[1]) paths.push(m[1]);
+	return paths;
+}
+function parseSessionFile(filePath) {
+	let raw;
+	try {
+		raw = fs.readFileSync(filePath, "utf-8");
+	} catch {
+		return {
+			header: null,
+			entries: [],
+			sessionName: ""
+		};
+	}
+	const lines = raw.split("\n").filter((l) => l.trim());
+	let header = null;
+	const entries = [];
+	let sessionName = "";
+	for (const line of lines) try {
+		const entry = JSON.parse(line);
+		if (entry.type === "session") header = entry;
+		else if (entry.type === "session_info" && entry.name) sessionName = entry.name;
+		if (entry.id) entries.push(entry);
+	} catch {}
+	return {
+		header,
+		entries,
+		sessionName
+	};
+}
+function enumerateBranches(header, entries, sessionName, filePath) {
+	const parentSessionPath = header.parentSession;
+	const children = /* @__PURE__ */ new Map();
+	for (const e of entries) {
+		const parent = e.parentId ?? null;
+		if (!children.has(parent)) children.set(parent, []);
+		children.get(parent).push(e);
+	}
+	const hasChildren = /* @__PURE__ */ new Set();
+	for (const e of entries) if (e.parentId) hasChildren.add(e.parentId);
+	const leaves = entries.filter((e) => !hasChildren.has(e.id));
+	const byId = /* @__PURE__ */ new Map();
+	for (const e of entries) byId.set(e.id, e);
+	const branches = [];
+	for (const leaf of leaves) {
+		if (leaf.type === "session" || leaf.type === "model_change" || leaf.type === "thinking_level_change") {
+			let hasMsgs = false;
+			let cur = leaf;
+			while (cur) {
+				if (cur.type === "message") {
+					hasMsgs = true;
+					break;
+				}
+				cur = cur.parentId ? byId.get(cur.parentId) : void 0;
+			}
+			if (!hasMsgs) continue;
+		}
+		const chain = [];
+		let current = leaf;
+		while (current) {
+			chain.unshift(current);
+			current = current.parentId ? byId.get(current.parentId) : void 0;
+		}
+		const files = /* @__PURE__ */ new Set();
+		const models = /* @__PURE__ */ new Set();
+		const textChunks = [];
+		let messageCount = 0;
+		let firstUserMessage = "";
+		for (const entry of chain) {
+			if (entry.type === "model_change" && typeof entry.modelId === "string") models.add(entry.modelId);
+			if (entry.type === "message") {
+				const msg = entry.message;
+				if (!msg) continue;
+				messageCount++;
+				if (msg.role === "user") {
+					for (const part of msg.content || []) if (isTextContent(part) && part.text) {
+						if (!firstUserMessage) firstUserMessage = part.text.slice(0, 200);
+						textChunks.push(part.text);
+						for (const p of extractFilePathsFromText(part.text)) files.add(p);
+					}
+				}
+				if (msg.role === "assistant" && Array.isArray(msg.content)) for (const part of msg.content) {
+					if (isTextContent(part) && part.text) textChunks.push(part.text);
+					if (part.type === "toolCall" && part.arguments) for (const p of extractFilePaths(part.arguments)) files.add(p);
+				}
+			}
+		}
+		const timestamps = chain.map((e) => e.timestamp).filter(Boolean).sort();
+		branches.push({
+			sessionId: header.id,
+			sessionName,
+			leafId: leaf.id,
+			workspace: header.cwd,
+			filePath,
+			timestampStart: timestamps[0] || header.timestamp,
+			timestampEnd: timestamps[timestamps.length - 1] || header.timestamp,
+			filesTouched: [...files],
+			models: [...models],
+			messageCount,
+			firstUserMessage,
+			searchableText: textChunks.join("\n"),
+			parentSessionPath
+		});
+	}
+	return branches;
+}
+function matchesKeyword(branch, keyword) {
+	const lower = keyword.toLowerCase();
+	if (branch.sessionName.toLowerCase().includes(lower)) return true;
+	if (branch.searchableText.toLowerCase().includes(lower)) return true;
+	return false;
+}
+function matchesFile(branch, fileQuery) {
+	const lower = fileQuery.toLowerCase();
+	return branch.filesTouched.some((f) => f.toLowerCase().includes(lower));
+}
+function parseDate(dateStr) {
+	const relMatch = dateStr.match(/^(\d+)([dw])$/);
+	if (relMatch && relMatch[1] && relMatch[2]) {
+		const n = parseInt(relMatch[1], 10);
+		const unit = relMatch[2];
+		const now = /* @__PURE__ */ new Date();
+		if (unit === "d") now.setDate(now.getDate() - n);
+		else if (unit === "w") now.setDate(now.getDate() - n * 7);
+		return now;
+	}
+	const d = new Date(dateStr);
+	return isNaN(d.getTime()) ? null : d;
+}
+function matchesDateRange(branch, after, before) {
+	const branchEnd = new Date(branch.timestampEnd);
+	const branchStart = new Date(branch.timestampStart);
+	if (after) {
+		const afterDate = parseDate(after);
+		if (afterDate && branchEnd < afterDate) return false;
+	}
+	if (before) {
+		const beforeDate = parseDate(before);
+		if (beforeDate && branchStart > beforeDate) return false;
+	}
+	return true;
+}
+function rgFilterFiles(keyword, sessionsDir, timeoutMs) {
+	try {
+		const result = execSync(`rg -l -i ${JSON.stringify(keyword)} ${JSON.stringify(sessionsDir)}`, {
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			],
+			timeout: timeoutMs
+		}).toString().trim();
+		if (!result) return /* @__PURE__ */ new Set();
+		return new Set(result.split("\n").filter(Boolean));
+	} catch {
+		return null;
+	}
+}
+function formatBranchResults(branches) {
+	if (branches.length === 0) return {
+		text: "(no matching sessions found)",
+		headerLineIndices: []
+	};
+	const lines = [];
+	const headerLineIndices = [];
+	lines.push(`found ${branches.length} matching branch${branches.length !== 1 ? "es" : ""}:`);
+	lines.push("");
+	for (let i = 0; i < branches.length; i++) {
+		const b = branches[i];
+		if (!b) continue;
+		const dateStr = new Date(b.timestampEnd).toLocaleDateString("en-US", {
+			weekday: "short",
+			year: "numeric",
+			month: "short",
+			day: "numeric"
+		});
+		const timeStr = new Date(b.timestampEnd).toLocaleTimeString("en-US", {
+			hour: "2-digit",
+			minute: "2-digit"
+		});
+		headerLineIndices.push(lines.length);
+		lines.push(`### ${i + 1}. ${b.sessionName || "(unnamed)"}`);
+		lines.push(`session: ${b.sessionId} / branch: ${b.leafId}`);
+		if (b.parentSessionPath) {
+			const parentId = b.parentSessionPath.split("/").pop()?.replace(/\.jsonl$/, "")?.split("_")[1] || b.parentSessionPath;
+			lines.push(`forked from: ${parentId}`);
+		}
+		lines.push(`${dateStr} ${timeStr} — ${b.messageCount} messages`);
+		if (b.models.length > 0) lines.push(`models: ${b.models.join(", ")}`);
+		if (b.filesTouched.length > 0) {
+			const shown = b.filesTouched.slice(0, 10);
+			lines.push(`files: ${shown.join(", ")}${b.filesTouched.length > 10 ? ` (+${b.filesTouched.length - 10} more)` : ""}`);
+		}
+		if (b.firstUserMessage) {
+			const preview = b.firstUserMessage.length > 150 ? `${b.firstUserMessage.slice(0, 150)}...` : b.firstUserMessage;
+			lines.push(`> ${preview}`);
+		}
+		if (i < branches.length - 1) lines.push("");
+	}
+	return {
+		text: lines.join("\n"),
+		headerLineIndices
+	};
+}
+/** convert branch results to BoxSections for box-format rendering */
+function branchesToSections(branches) {
+	return branches.map((b, i) => {
+		const dateStr = new Date(b.timestampEnd).toLocaleDateString("en-US", {
+			weekday: "short",
+			year: "numeric",
+			month: "short",
+			day: "numeric"
+		});
+		const timeStr = new Date(b.timestampEnd).toLocaleTimeString("en-US", {
+			hour: "2-digit",
+			minute: "2-digit"
+		});
+		const lines = [];
+		lines.push({
+			text: `session: ${b.sessionId} / branch: ${b.leafId}`,
+			highlight: true
+		});
+		if (b.parentSessionPath) {
+			const parentId = b.parentSessionPath.split("/").pop()?.replace(/\.jsonl$/, "")?.split("_")[1] || b.parentSessionPath;
+			lines.push({
+				text: `forked from: ${parentId}`,
+				highlight: true
+			});
+		}
+		lines.push({
+			text: `${dateStr} ${timeStr} — ${b.messageCount} messages`,
+			highlight: true
+		});
+		if (b.models.length > 0) lines.push({
+			text: `models: ${b.models.join(", ")}`,
+			highlight: true
+		});
+		if (b.filesTouched.length > 0) {
+			const shown = b.filesTouched.slice(0, 10);
+			lines.push({
+				text: `files: ${shown.join(", ")}${b.filesTouched.length > 10 ? ` (+${b.filesTouched.length - 10} more)` : ""}`,
+				highlight: true
+			});
+		}
+		if (b.firstUserMessage) {
+			const preview = b.firstUserMessage.length > 150 ? `${b.firstUserMessage.slice(0, 150)}...` : b.firstUserMessage;
+			lines.push({
+				text: `> ${preview}`,
+				highlight: false
+			});
+		}
+		return {
+			header: b.sessionName || `session ${i + 1}`,
+			blocks: [{ lines }]
+		};
+	});
+}
+function createSearchSessionsTool(config = CONFIG_DEFAULTS) {
+	return {
+		name: "search_sessions",
+		label: "Search Sessions",
+		description: "Search pi session history by keyword, file path, or date range.\n\nSessions are trees with branches. Each branch (root-to-leaf path) is a separate search result with its own files-touched set and message chain.\n\nScoped to current workspace by default. Use `all_workspaces: true` to search everywhere.\n\nUse `read_session` to extract detailed content from a specific session.\n\nWHEN TO USE:\n- \"Find the session where I worked on X\"\n- \"What session touched this file?\"\n- \"Show recent sessions\"\n- Looking up prior context from past conversations\n\nWHEN NOT TO USE:\n- Current session context (already available)\n- Git history (use git log)",
+		parameters: Type.Object({
+			keyword: Type.Optional(Type.String({ description: "Text to search for in session names, user messages, and assistant responses." })),
+			file: Type.Optional(Type.String({ description: "File path (partial match) to find sessions that touched this file." })),
+			after: Type.Optional(Type.String({ description: "Only return sessions after this date. ISO date (2026-02-20) or relative (7d, 2w)." })),
+			before: Type.Optional(Type.String({ description: "Only return sessions before this date. ISO date or relative." })),
+			workspace: Type.Optional(Type.String({ description: "Filter by workspace path (partial match against session cwd). Defaults to current workspace." })),
+			all_workspaces: Type.Optional(Type.Boolean({ description: "Search across all workspaces instead of just the current one." }))
+		}),
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			const p = params;
+			if (!fs.existsSync(config.sessionsDir)) return { content: [{
+				type: "text",
+				text: "(no sessions directory found)"
+			}] };
+			let sessionFiles = [];
+			try {
+				const walkDir = (dir) => {
+					for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+						const full = path.join(dir, entry.name);
+						if (entry.isDirectory()) walkDir(full);
+						else if (entry.name.endsWith(".jsonl")) sessionFiles.push(full);
+					}
+				};
+				walkDir(config.sessionsDir);
+			} catch {
+				return {
+					content: [{
+						type: "text",
+						text: "(could not read sessions directory)"
+					}],
+					isError: true
+				};
+			}
+			if (sessionFiles.length === 0) return { content: [{
+				type: "text",
+				text: "(no sessions found)"
+			}] };
+			if (p.keyword) {
+				const matches = rgFilterFiles(p.keyword, config.sessionsDir, config.rgTimeoutMs);
+				if (matches !== null) sessionFiles = sessionFiles.filter((f) => matches.has(f));
+			}
+			if (p.after || p.before) sessionFiles = sessionFiles.filter((f) => {
+				const tsMatch = path.basename(f).match(/^(\d{4}-\d{2}-\d{2})T/);
+				if (!tsMatch || !tsMatch[1]) return true;
+				const fileDate = new Date(tsMatch[1]);
+				if (p.after) {
+					const afterDate = parseDate(p.after);
+					if (afterDate && fileDate < afterDate) return false;
+				}
+				if (p.before) {
+					const beforeDate = parseDate(p.before);
+					if (beforeDate && fileDate > beforeDate) return false;
+				}
+				return true;
+			});
+			const allBranches = [];
+			const workspaceFilter = p.all_workspaces ? void 0 : p.workspace || ctx.cwd;
+			for (const file of sessionFiles) {
+				const { header, entries, sessionName } = parseSessionFile(file);
+				if (!header) continue;
+				if (workspaceFilter && !header.cwd.toLowerCase().includes(workspaceFilter.toLowerCase())) continue;
+				const branches = enumerateBranches(header, entries, sessionName, file);
+				allBranches.push(...branches);
+			}
+			let filtered = allBranches;
+			if (p.keyword) filtered = filtered.filter((b) => matchesKeyword(b, p.keyword));
+			if (p.file) filtered = filtered.filter((b) => matchesFile(b, p.file));
+			if (p.after || p.before) filtered = filtered.filter((b) => matchesDateRange(b, p.after, p.before));
+			filtered.sort((a, b) => new Date(b.timestampEnd).getTime() - new Date(a.timestampEnd).getTime());
+			const shown = filtered.length > config.maxResults ? [...filtered.slice(0, Math.floor(config.maxResults / 2)), ...filtered.slice(-Math.floor(config.maxResults / 2))] : filtered;
+			const truncated = filtered.length > config.maxResults ? filtered.length - shown.length : 0;
+			const { text: output } = formatBranchResults(shown);
+			const resultSections = branchesToSections(shown);
+			return {
+				content: [{
+					type: "text",
+					text: output
+				}],
+				details: {
+					resultSections,
+					truncated
+				}
+			};
+		},
+		renderCall(args, theme) {
+			const parts = [];
+			if (args.keyword) parts.push(args.keyword);
+			if (args.file) parts.push(`file:${args.file}`);
+			if (args.after) parts.push(`after:${args.after}`);
+			if (args.before) parts.push(`before:${args.before}`);
+			if (args.workspace) parts.push(`ws:${args.workspace}`);
+			const preview = parts.join(" ") || "...";
+			return new Text(theme.fg("toolTitle", theme.bold("search_sessions ")) + theme.fg("dim", preview), 0, 0);
+		},
+		renderResult(result, { expanded }, _theme) {
+			const sections = result.details?.resultSections;
+			if (!sections?.length) return new Text(result.content?.[0]?.text ?? "(no output)", 0, 0);
+			const truncated = result.details?.truncated ?? 0;
+			const notices = truncated > 0 ? [`${truncated} sessions omitted`] : void 0;
+			return boxRendererWindowed(() => sections, {
+				collapsed: {
+					maxSections: 3,
+					excerpts: COLLAPSED_EXCERPTS
+				},
+				expanded: {}
+			}, notices, expanded);
+		}
+	};
+}
+function search_sessions_default(pi) {
+	const cfg = getExtensionConfig("@bds_pi/search-sessions", CONFIG_DEFAULTS);
+	pi.registerTool(withPromptPatch(createSearchSessionsTool(cfg)));
+}
+//#endregion
+export { createSearchSessionsTool, search_sessions_default as default };

package/dist/extensions/session-name.d.ts

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

package/dist/extensions/session-name.js

@@ -0,0 +1,54 @@
+import { getExtensionConfig } from "../core/config.js";
+import { complete } from "@mariozechner/pi-ai";
+//#region packages/extensions/session-name/index.ts
+/**
+* auto session naming — generates a short title from the first user message.
+*
+* fires on the `input` event so the name appears while the agent is still
+* thinking. uses haiku for speed/cost. only names the session once.
+*/
+const CONFIG_DEFAULTS = { model: {
+	provider: "openrouter",
+	id: "anthropic/claude-haiku-4.5"
+} };
+function session_name_default(pi) {
+	const cfg = getExtensionConfig("@bds_pi/session-name", CONFIG_DEFAULTS);
+	let named = false;
+	pi.on("input", async (event, ctx) => {
+		if (named) return;
+		if (pi.getSessionName()) {
+			named = true;
+			return;
+		}
+		const text = event.text.trim();
+		if (text.startsWith("/") || text.length < 10) return;
+		named = true;
+		const model = ctx.modelRegistry.find(cfg.model.provider, cfg.model.id) ?? ctx.model;
+		if (!model) return;
+		generateName(model, ctx.modelRegistry, text).then((name) => {
+			if (name) pi.setSessionName(name);
+		}).catch(() => {});
+	});
+	pi.on("session_switch", async () => {
+		named = false;
+	});
+}
+async function generateName(model, registry, userMessage) {
+	const apiKey = await registry.getApiKey(model);
+	if (!apiKey) return null;
+	const response = await complete(model, { messages: [{
+		role: "user",
+		content: [{
+			type: "text",
+			text: `Generate a 3-5 word title for a coding session that starts with this message. Return ONLY the title, no quotes, no punctuation, no explanation. Lowercase.\n\n${userMessage.slice(0, 500)}`
+		}],
+		timestamp: Date.now()
+	}] }, {
+		apiKey,
+		maxTokens: 20
+	});
+	if (response.stopReason === "aborted") return null;
+	return response.content.filter((c) => c.type === "text").map((c) => c.text).join("").trim() || null;
+}
+//#endregion
+export { session_name_default as default };

package/dist/extensions/skill.d.ts

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