@ogulcancelik/pi-session-recall 1.0.0 → 1.0.2

package/README.md

@@ -56,7 +56,7 @@ If no model is configured (or the configured model isn't available), it falls ba
 ## Requirements
 
 - [pi](https://github.com/badlogic/pi-mono) v0.40+
-- [ripgrep](https://github.com/BurntSushi/ripgrep) (`rg`) — used for fast session search
+- [ripgrep](https://github.com/BurntSushi/ripgrep) (`rg`) — recommended for fast search, falls back to `grep` or Node-native scan
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ogulcancelik/pi-session-recall",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Search and query past pi sessions. Recall previous conversations on demand.",
   "type": "module",
   "keywords": [
@@ -16,12 +16,13 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/ogulcancelik/pi-session-recall.git"
+    "url": "git+https://github.com/ogulcancelik/pi-extensions.git",
+    "directory": "packages/pi-session-recall"
   },
   "bugs": {
-    "url": "https://github.com/ogulcancelik/pi-session-recall/issues"
+    "url": "https://github.com/ogulcancelik/pi-extensions/issues"
   },
-  "homepage": "https://github.com/ogulcancelik/pi-session-recall#readme",
+  "homepage": "https://github.com/ogulcancelik/pi-extensions/tree/main/packages/pi-session-recall#readme",
   "engines": {
     "node": ">=18.0.0"
   },

package/session-recall.ts

@@ -44,8 +44,8 @@ import {
 	Text,
 } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
-import { execSync } from "node:child_process";
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync, writeFileSync, mkdirSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { homedir } from "node:os";
 
@@ -105,22 +105,28 @@ function getSessionsDir(): string {
  * Extract a readable project name from the encoded session directory path.
  * Session dirs are encoded as: --home-user-projects-myapp--
  * We strip the home directory prefix and convert dashes back to slashes.
+ *
+ * Uses the same encoding scheme as session-manager:
+ *   cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")
+ * This handles both Unix (/) and Windows (\, C:\) paths.
  */
 function projectFromPath(sessionPath: string): string {
-	// Match the encoded directory name between sessions/ and the next /
-	const match = sessionPath.match(/sessions\/(--.*?--)\//);
+	// Match the encoded directory name — handle both / and \ separators
+	const match = sessionPath.match(/sessions[/\\](--.*?--)[/\\]/);
 	if (!match || !match[1]) return "~";
 
 	// Decode: strip leading/trailing --, replace internal - with /
 	let encoded = match[1].slice(2, -2); // remove -- from both ends
 
-	// Strip home directory prefix (encoded as home-username)
-	const homeDir = homedir();
-	const homeParts = homeDir.split("/").filter(Boolean); // e.g. ["home", "can"]
-	const homePrefix = homeParts.join("-"); // "home-can"
-	if (encoded.startsWith(homePrefix + "-")) {
-		encoded = encoded.slice(homePrefix.length + 1);
-	} else if (encoded === homePrefix) {
+	// Encode homedir with the same scheme session-manager uses,
+	// so it works on both Unix (/home/can) and Windows (C:\Users\Pc)
+	const homeEncoded = homedir()
+		.replace(/^[/\\]/, "")
+		.replace(/[/\\:]/g, "-");
+
+	if (encoded.startsWith(homeEncoded + "-")) {
+		encoded = encoded.slice(homeEncoded.length + 1);
+	} else if (encoded === homeEncoded) {
 		return "~";
 	}
 
@@ -289,9 +295,193 @@ function buildWindowedContext(
 	return parts.join("\n\n");
 }
 
-/** Shell-escape a string for use in execSync */
-function escapeShellArg(arg: string): string {
-	return "'" + arg.replace(/'/g, "'\\''") + "'";
+// ── Search Backend ───────────────────────────────────────────────────────────
+
+type SearchBackend = "rg" | "grep" | "node";
+let cachedBackend: SearchBackend | undefined;
+
+/** Detect best available search backend: rg → grep → node-native */
+function getSearchBackend(): SearchBackend {
+	if (cachedBackend !== undefined) return cachedBackend;
+
+	for (const cmd of ["rg", "grep"] as const) {
+		try {
+			execFileSync(cmd, ["--version"], { stdio: "ignore", timeout: 5000 });
+			cachedBackend = cmd;
+			return cmd;
+		} catch {
+			// not available, try next
+		}
+	}
+
+	cachedBackend = "node";
+	return "node";
+}
+
+interface FileMatchCount {
+	path: string;
+	count: number;
+}
+
+/** Recursively find all .jsonl files under a directory */
+function walkJsonlFiles(dir: string): string[] {
+	const results: string[] = [];
+	function walk(d: string) {
+		let entries;
+		try {
+			entries = readdirSync(d, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const full = join(d, entry.name);
+			if (entry.isDirectory()) walk(full);
+			else if (entry.name.endsWith(".jsonl")) results.push(full);
+		}
+	}
+	walk(dir);
+	return results;
+}
+
+/**
+ * Search for a query across all session files, returning files with match counts.
+ * Falls back through rg → grep → node-native.
+ */
+function searchFiles(query: string, sessionsDir: string, timeout = 10000): FileMatchCount[] {
+	const backend = getSearchBackend();
+
+	if (backend === "rg") {
+		try {
+			const output = execFileSync("rg", ["-i", "-c", "-F", query, sessionsDir], {
+				encoding: "utf-8",
+				timeout,
+				stdio: ["pipe", "pipe", "pipe"],
+			});
+			return parseCountOutput(output);
+		} catch (err: any) {
+			if (err.status === 1) return []; // no matches
+			// rg failed unexpectedly — try grep
+		}
+	}
+
+	if (backend === "rg" || backend === "grep") {
+		try {
+			const output = execFileSync(
+				"grep",
+				["-r", "-i", "-c", "-F", "--include=*.jsonl", query, sessionsDir],
+				{
+					encoding: "utf-8",
+					timeout,
+					stdio: ["pipe", "pipe", "pipe"],
+				},
+			);
+			return parseCountOutput(output);
+		} catch (err: any) {
+			if (err.status === 1) return []; // no matches
+			// grep failed too — fall through to node
+		}
+	}
+
+	// Node-native fallback
+	return nodeSearchFiles(query, sessionsDir);
+}
+
+/** Parse `file:count` output from rg -c / grep -c */
+function parseCountOutput(output: string): FileMatchCount[] {
+	return output
+		.trim()
+		.split("\n")
+		.filter(Boolean)
+		.map((line) => {
+			const lastColon = line.lastIndexOf(":");
+			return {
+				path: line.slice(0, lastColon),
+				count: parseInt(line.slice(lastColon + 1), 10),
+			};
+		})
+		.filter((m) => m.count > 0);
+}
+
+/** Node-native: count case-insensitive matches per file */
+function nodeSearchFiles(query: string, sessionsDir: string): FileMatchCount[] {
+	const files = walkJsonlFiles(sessionsDir);
+	const queryLower = query.toLowerCase();
+	const results: FileMatchCount[] = [];
+
+	for (const filePath of files) {
+		try {
+			const content = readFileSync(filePath, "utf-8");
+			const lower = content.toLowerCase();
+			let count = 0;
+			let idx = 0;
+			while ((idx = lower.indexOf(queryLower, idx)) !== -1) {
+				count++;
+				idx += queryLower.length;
+			}
+			if (count > 0) results.push({ path: filePath, count });
+		} catch {
+			continue;
+		}
+	}
+
+	return results;
+}
+
+/**
+ * Find matching lines in a single file, up to maxMatches.
+ * Falls back through rg → grep → node-native.
+ */
+function searchLines(query: string, filePath: string, maxMatches: number): string[] {
+	const backend = getSearchBackend();
+
+	if (backend === "rg") {
+		try {
+			const output = execFileSync(
+				"rg",
+				["-i", "-F", "-m", String(maxMatches), query, filePath],
+				{ encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] },
+			);
+			return output.trim().split("\n").filter(Boolean);
+		} catch (err: any) {
+			if (err.status === 1) return []; // no matches
+			// rg failed — try grep
+		}
+	}
+
+	if (backend === "rg" || backend === "grep") {
+		try {
+			const output = execFileSync(
+				"grep",
+				["-i", "-F", "-m", String(maxMatches), query, filePath],
+				{ encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] },
+			);
+			return output.trim().split("\n").filter(Boolean);
+		} catch (err: any) {
+			if (err.status === 1) return []; // no matches
+			// grep failed too — fall through to node
+		}
+	}
+
+	// Node-native fallback
+	return nodeSearchLines(query, filePath, maxMatches);
+}
+
+/** Node-native: find matching lines in a file */
+function nodeSearchLines(query: string, filePath: string, maxMatches: number): string[] {
+	try {
+		const content = readFileSync(filePath, "utf-8");
+		const queryLower = query.toLowerCase();
+		const matches: string[] = [];
+		for (const line of content.split("\n")) {
+			if (matches.length >= maxMatches) break;
+			if (line.toLowerCase().includes(queryLower)) {
+				matches.push(line);
+			}
+		}
+		return matches;
+	} catch {
+		return [];
+	}
 }
 
 // ── Constants ────────────────────────────────────────────────────────────────
@@ -521,33 +711,16 @@ export default function sessionRecallExtension(pi: ExtensionAPI) {
 				return errorResult("No sessions directory found.");
 			}
 
-			let rgOutput: string;
-			try {
-				rgOutput = execSync(`rg -ic ${escapeShellArg(query)} ${escapeShellArg(sessionsDir)}`, {
-					encoding: "utf-8",
-					timeout: 10000,
-				});
-			} catch (err: any) {
-				if (err.status === 1) {
-					return {
-						content: [{ type: "text" as const, text: `No sessions found matching "${query}".` }],
-						details: { matchCount: 0 },
-					};
-				}
-				return errorResult(`Search failed: ${err.message}`);
+			const allMatches = searchFiles(query, sessionsDir);
+
+			if (allMatches.length === 0) {
+				return {
+					content: [{ type: "text" as const, text: `No sessions found matching "${query}".` }],
+					details: { matchCount: 0 },
+				};
 			}
 
-			const fileMatches = rgOutput
-				.trim()
-				.split("\n")
-				.filter(Boolean)
-				.map((line) => {
-					const lastColon = line.lastIndexOf(":");
-					return {
-						path: line.slice(0, lastColon),
-						count: parseInt(line.slice(lastColon + 1), 10),
-					};
-				})
+			const fileMatches = allMatches
 				.sort((a, b) => b.count - a.count || b.path.localeCompare(a.path))
 				.slice(0, MAX_SEARCH_RESULTS);
 
@@ -559,19 +732,11 @@ export default function sessionRecallExtension(pi: ExtensionAPI) {
 				const project = projectFromPath(filePath);
 				const date = dateFromPath(filePath);
 
-				let matchLines: string;
-				try {
-					matchLines = execSync(
-						`rg -i -m ${MAX_SNIPPETS_PER_SESSION} ${escapeShellArg(query)} ${escapeShellArg(filePath)}`,
-						{ encoding: "utf-8", timeout: 5000 },
-					);
-				} catch {
-					continue;
-				}
+				const matchLines = searchLines(query, filePath, MAX_SNIPPETS_PER_SESSION);
+				if (matchLines.length === 0) continue;
 
 				const snippets: string[] = [];
-				for (const line of matchLines.trim().split("\n")) {
-					if (!line) continue;
+				for (const line of matchLines) {
 					const msg = extractMessageText(line);
 					if (!msg) continue;
 					const snippet = snippetAround(msg.text, query);