@apmantza/greedysearch-pi 1.9.2 → 2.0.0

package/src/tools/greedy-search-handler.ts

@@ -16,8 +16,37 @@ import {
 	makeProgressTracker,
 	runSearch,
 	stripQuotes,
+	type ProgressUpdate,
+	type ToolResult,
 } from "./shared.js";
 
+type GreedySearchParams = {
+	query: string;
+	engine?: string;
+	synthesize?: boolean;
+	synthesizer?: string;
+	depth?: "fast" | "standard" | "deep" | "research" | string;
+	breadth?: number;
+	iterations?: number;
+	maxSources?: number;
+	researchOutDir?: string;
+	writeResearchBundle?: boolean;
+	fullAnswer?: boolean;
+	headless?: boolean;
+	visible?: boolean;
+	alwaysVisible?: boolean;
+};
+
+type ToolTheme = {
+	fg(style: string, text: string): string;
+	bold(text: string): string;
+};
+
+type RenderState = {
+	expanded: boolean;
+	isPartial?: boolean;
+};
+
 class Text {
 	constructor(
 		private text: string,
@@ -52,8 +81,10 @@ export function registerGreedySearchTool(pi: ExtensionAPI, baseDir: string) {
 		name: "greedy_search",
 		label: "Greedy Search",
 		description:
-			"WEB SEARCH ONLY — searches live web via Perplexity, Bing Copilot, and Google AI in parallel. " +
-			"Optionally synthesizes results with Gemini, deduplicates sources by consensus. " +
+			"WEB/RESEARCH SEARCH ONLY — searches live web via Perplexity, Google AI, ChatGPT, and Gemini, plus opt-in research through Semantic Scholar and Logically. " +
+			"Research mode reuses the configured ~/.pi/greedyconfig engines for child searches and Gemini for planning/final synthesis. " +
+			"Research mode is the centerpiece: it plans follow-up actions, fetches sources, audits citations, " +
+			"and writes a structured research bundle on disk. " +
 			"Use for: library docs, recent framework changes, error messages, best practices, current events. " +
 			"Reports streaming progress as each engine completes.",
 		promptSnippet: "Multi-engine AI web search with streaming progress",
@@ -61,14 +92,28 @@ export function registerGreedySearchTool(pi: ExtensionAPI, baseDir: string) {
 			query: Type.String({ description: "The search query" }),
 			engine: Type.String({
 				description:
-					'Engine to use: "all" (default), "perplexity", "bing", "google", "gemini", "gem". "all" fans out to Perplexity, Bing, and Google in parallel.',
+					'Engine to use: "all" (default), "perplexity", "google", "chatgpt", "gemini", "gem". Research engines: "semantic-scholar" (alias "s2") and "logically". "all" fans out to the configured engines and fetches top sources. Customize via ~/.pi/greedyconfig. Bing Copilot is still available as "bing" for signed-in users.',
 				default: "all",
 			}),
-			depth: Type.String({
-				description:
-					'Search depth: "fast" (no synthesis/source fetch, ~15-30s), "standard" (synthesis + sources, ~30-90s), "deep" (stronger grounding, ~60-180s), "research" (iterative query/learnings loop; slowest). Default: "standard". Note: single-engine searches default to fast unless depth is "research".',
-				default: "standard",
-			}),
+			synthesize: Type.Optional(
+				Type.Boolean({
+					description:
+						'Only for engine="all": synthesize the multi-engine results and fetched sources. Default: false.',
+					default: false,
+				}),
+			),
+			synthesizer: Type.Optional(
+				Type.String({
+					description:
+						'Synthesis engine for synthesize=true. Defaults to ~/.pi/greedyconfig synthesizer (currently "gemini" by default). Supported: "gemini", "chatgpt".',
+				}),
+			),
+			depth: Type.Optional(
+				Type.String({
+					description:
+						'Deprecated except "research". Use depth="research" for the iterative research workflow. Research child searches use ~/.pi/greedyconfig engines; Gemini handles research planning/final synthesis. Legacy values: "fast" skips source fetching; "standard"/"deep" alias synthesize=true.',
+				}),
+			),
 			breadth: Type.Optional(
 				Type.Number({
 					description:
@@ -89,6 +134,19 @@ export function registerGreedySearchTool(pi: ExtensionAPI, baseDir: string) {
 						'Only for depth="research": maximum fetched sources for the final report, 3-12.',
 				}),
 			),
+			researchOutDir: Type.Optional(
+				Type.String({
+					description:
+						'Only for depth="research": optional directory for the structured research bundle. Defaults to .pi/greedysearch-research/<timestamp>_<query>.',
+				}),
+			),
+			writeResearchBundle: Type.Optional(
+				Type.Boolean({
+					description:
+						'Only for depth="research": write the structured research bundle to disk (default true).',
+					default: true,
+				}),
+			),
 			fullAnswer: Type.Optional(
 				Type.Boolean({
 					description:
@@ -118,27 +176,33 @@ export function registerGreedySearchTool(pi: ExtensionAPI, baseDir: string) {
 				}),
 			),
 		}),
-		execute: async (_toolCallId, params, signal, onUpdate) => {
-			const { query, fullAnswer: fullAnswerParam } = params as {
-				query: string;
-				engine: string;
-				depth?: "fast" | "standard" | "deep" | "research";
-				breadth?: number;
-				iterations?: number;
-				maxSources?: number;
-				fullAnswer?: boolean;
-				headless?: boolean;
-				visible?: boolean;
-				alwaysVisible?: boolean;
-			};
-			const engine = stripQuotes((params as any).engine ?? "all") || "all";
-			const depth = (stripQuotes((params as any).depth ?? "standard") ||
-				"standard") as "fast" | "standard" | "deep" | "research";
-			const effectiveEngine = depth === "research" ? "all" : engine;
+		execute: async (
+			_toolCallId: string,
+			params: GreedySearchParams,
+			signal?: AbortSignal,
+			onUpdate?: (update: ProgressUpdate) => void,
+		) => {
+			const { query, fullAnswer: fullAnswerParam } = params;
+			const engine = stripQuotes(params.engine ?? "all") || "all";
+			const depthRaw = stripQuotes(params.depth ?? "") as
+				| "fast"
+				| "standard"
+				| "deep"
+				| "research"
+				| "";
+			const researchMode = depthRaw === "research";
+			const legacyFast = depthRaw === "fast";
+			const legacySynthesisDepth =
+				depthRaw === "standard" || depthRaw === "deep";
+			const synthesize =
+				engine === "all" &&
+				!legacyFast &&
+				(params.synthesize === true || legacySynthesisDepth);
+			const effectiveEngine = researchMode ? "all" : engine;
 			const visible =
-				(params as any).visible === true ||
-				(params as any).alwaysVisible === true ||
-				(params as any).headless === false ||
+				params.visible === true ||
+				params.alwaysVisible === true ||
+				params.headless === false ||
 				process.env.GREEDY_SEARCH_VISIBLE === "1" ||
 				process.env.GREEDY_SEARCH_ALWAYS_VISIBLE === "1";
 			const headless = !visible;
@@ -148,26 +212,32 @@ export function registerGreedySearchTool(pi: ExtensionAPI, baseDir: string) {
 			const flags: string[] = [];
 			const fullAnswer = fullAnswerParam ?? effectiveEngine !== "all";
 			if (fullAnswer) flags.push("--full");
-			if (depth === "research") {
+			if (researchMode) {
 				flags.push("--depth", "research");
-				if (typeof (params as any).breadth === "number")
-					flags.push("--breadth", String((params as any).breadth));
-				if (typeof (params as any).iterations === "number")
-					flags.push("--iterations", String((params as any).iterations));
-				if (typeof (params as any).maxSources === "number")
-					flags.push("--max-sources", String((params as any).maxSources));
-			} else if (depth === "deep") flags.push("--depth", "deep");
-			else if (depth === "fast") flags.push("--fast");
-			else if (depth === "standard" && engine === "all")
-				flags.push("--synthesize");
+				if (typeof params.breadth === "number")
+					flags.push("--breadth", String(params.breadth));
+				if (typeof params.iterations === "number")
+					flags.push("--iterations", String(params.iterations));
+				if (typeof params.maxSources === "number")
+					flags.push("--max-sources", String(params.maxSources));
+				if (typeof params.researchOutDir === "string")
+					flags.push("--research-out-dir", params.researchOutDir);
+				if (params.writeResearchBundle === false)
+					flags.push("--no-research-bundle");
+			} else if (legacyFast) flags.push("--fast");
+			else if (depthRaw === "deep") flags.push("--depth", "deep");
+			else if (synthesize) flags.push("--synthesize");
+			if (synthesize && typeof params.synthesizer === "string") {
+				flags.push("--synthesizer", params.synthesizer);
+			}
 
 			const onProgress =
 				effectiveEngine === "all"
 					? makeProgressTracker(
 							ALL_ENGINES,
 							onUpdate,
-							depth === "research" ? "Researching" : "Searching",
-							depth,
+							researchMode ? "Researching" : "Searching",
+							synthesize,
 						)
 					: undefined;
 
@@ -179,7 +249,7 @@ export function registerGreedySearchTool(pi: ExtensionAPI, baseDir: string) {
 					`${baseDir}/bin/search.mjs`,
 					signal,
 					onProgress,
-					headless,
+					{ headless },
 				);
 				const text = formatResults(effectiveEngine, data);
 				return {
@@ -191,7 +261,7 @@ export function registerGreedySearchTool(pi: ExtensionAPI, baseDir: string) {
 			}
 		},
 
-		renderCall(args, theme) {
+		renderCall(args: Partial<GreedySearchParams>, theme: ToolTheme) {
 			const q = (args.query || "").slice(0, 60);
 			const qDisplay = q.length < (args.query || "").length ? `${q}...` : q;
 			const engineDisplay =
@@ -205,11 +275,15 @@ export function registerGreedySearchTool(pi: ExtensionAPI, baseDir: string) {
 			);
 		},
 
-		renderResult(result, { expanded, isPartial }, theme) {
+		renderResult(
+			result: ToolResult,
+			{ expanded, isPartial }: RenderState,
+			theme: ToolTheme,
+		) {
 			if (isPartial) {
-				const progressText = (
-					result.content.find((c) => c.type === "text") as any
-				)?.text as string | undefined;
+				const progressText = result.content.find(
+					(c) => c.type === "text",
+				)?.text;
 				const display = progressText
 					? progressText.replace(/\*\*/g, "")
 					: "Searching...";
@@ -217,9 +291,7 @@ export function registerGreedySearchTool(pi: ExtensionAPI, baseDir: string) {
 			}
 
 			const textContent = result.content.find((c) => c.type === "text");
-			const raw = (result.details as any)?.raw as
-				| Record<string, unknown>
-				| undefined;
+			const raw = result.details?.raw as Record<string, unknown> | undefined;
 
 			// Collapsed: one-line summary only
 			if (!expanded) {
@@ -256,7 +328,7 @@ export function registerGreedySearchTool(pi: ExtensionAPI, baseDir: string) {
 				);
 				let totalSources = 0;
 				for (const key of engineKeys) {
-					const eng = (raw as any)[key] as Record<string, unknown> | undefined;
+					const eng = raw?.[key] as Record<string, unknown> | undefined;
 					const s = eng?.sources as Array<unknown> | undefined;
 					if (Array.isArray(s)) totalSources += s.length;
 				}
@@ -272,7 +344,7 @@ export function registerGreedySearchTool(pi: ExtensionAPI, baseDir: string) {
 				}
 
 				// No structured data — show content text as error/fallback
-				const snippet = (textContent as any)?.text as string | undefined;
+				const snippet = textContent?.text;
 				if (snippet) {
 					return new Text(
 						theme.fg("warning", ` → ${snippet.slice(0, 80)}`),

package/src/tools/shared.ts

@@ -1,186 +1,187 @@
-/**
- * Shared types, utilities, and runSearch for Pi tool handlers
- */
-
-import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import type { ProgressUpdate, ToolResult } from "../types.js";
-
-export type { ProgressUpdate, ToolResult } from "../types.js";
-
-// Canonical source is src/search/constants.mjs — keep in sync
-const ALL_ENGINES = ["perplexity", "bing", "google"] as const;
-
-export { ALL_ENGINES };
-
-/** Strip surrounding double-quotes that some framework versions inject into string params */
-export function stripQuotes(val: string): string {
-	return val.replace(/^"|"$/g, "");
-}
-
-/**
- * Check if the CDP module is available in the package directory
- */
-export function cdpAvailable(baseDir: string): boolean {
-	return existsSync(join(baseDir, "bin", "cdp.mjs"));
-}
-
-/**
- * Create a "cdp missing" error result
- */
-export function cdpMissingResult(): ToolResult {
-	return {
-		content: [
-			{
-				type: "text",
-				text: "cdp.mjs missing — try reinstalling: pi install git:github.com/apmantza/GreedySearch-pi",
-			},
-		],
-		details: {} as Record<string, unknown>,
-	};
-}
-
-/**
- * Create an error result with a message
- */
-export function errorResult(prefix: string, e: unknown): ToolResult {
-	const msg = e instanceof Error ? e.message : String(e);
-	return {
-		content: [{ type: "text", text: `${prefix}: ${msg}` }],
-		details: {} as Record<string, unknown>,
-	};
-}
-
-/**
- * Spawn search.mjs and collect JSON results, with progress streaming via stderr.
- * Shared by GreedySearch tool handlers.
- */
-export function runSearch(
-	engine: string,
-	query: string,
-	flags: string[],
-	searchBin: string,
-	signal?: AbortSignal,
-	onProgress?: (
-		engine: string,
-		status: "done" | "error" | "needs-human",
-	) => void,
-	headless?: boolean, // defaults to true (headless is the default)
-): Promise<Record<string, unknown>> {
-	return new Promise((resolve, reject) => {
-		const allFlags = [...flags];
-		// Headless is default — only skip if explicitly false or GREEDY_SEARCH_VISIBLE=1
-		if (headless !== false && process.env.GREEDY_SEARCH_VISIBLE !== "1")
-			allFlags.push("--headless");
-		if (headless === false) allFlags.push("--always-visible");
-		// Propagate visibility preference via env (--headless flag is informational;
-		// the actual headless control in search.mjs / launch.mjs reads the env var).
-		const procEnv = { ...process.env };
-		if (headless === false) {
-			procEnv.GREEDY_SEARCH_VISIBLE = "1";
-			procEnv.GREEDY_SEARCH_ALWAYS_VISIBLE = "1";
-		}
-		const proc = spawn(
-			process.execPath,
-			[searchBin, engine, "--inline", "--stdin", ...allFlags],
-			{ stdio: ["pipe", "pipe", "pipe"], env: procEnv },
-		);
-		// Pipe query via stdin to avoid leaking it in process table command-line
-		proc.stdin.write(query);
-		proc.stdin.end();
-		let out = "";
-		let err = "";
-
-		const onAbort = () => {
-			proc.kill("SIGTERM");
-			reject(new Error("Aborted"));
-		};
-		signal?.addEventListener("abort", onAbort, { once: true });
-
-		proc.stderr.on("data", (d: Buffer) => {
-			err += d;
-			for (const line of d.toString().split("\n")) {
-				// Engine progress: perplexity/bing/google
-				const engineMatch = line.match(
-					/^PROGRESS:(perplexity|bing|google):(done|error|needs-human)$/,
-				);
-				if (engineMatch && onProgress) {
-					onProgress(
-						engineMatch[1],
-						engineMatch[2] as "done" | "error" | "needs-human",
-					);
-				}
-				// Synthesis progress: skipped (manual verification) or done/error
-				const synthMatch = line.match(
-					/^PROGRESS:synthesis:(done|error|skipped)$/,
-				);
-				if (synthMatch && onProgress) {
-					onProgress(
-						"synthesis",
-						synthMatch[1] as "done" | "error" | "needs-human",
-					);
-				}
-			}
-		});
-
-		proc.stdout.on("data", (d: Buffer) => (out += d));
-		proc.on("close", (code: number) => {
-			signal?.removeEventListener("abort", onAbort);
-			if (code !== 0) {
-				reject(new Error(err.trim() || `search.mjs exited with code ${code}`));
-			} else {
-				try {
-					resolve(JSON.parse(out.trim()));
-				} catch {
-					reject(
-						new Error(`Invalid JSON from search.mjs: ${out.slice(0, 200)}`),
-					);
-				}
-			}
-		});
-	});
-}
-
-/**
- * Build a progress callback that tracks completed engines.
- * Returns an onProgress function suitable for runSearch.
- */
-export function makeProgressTracker(
-	engines: readonly string[],
-	onUpdate: ((update: ProgressUpdate) => void) | undefined,
-	suffix: "Searching" | "Researching",
-	depth: string,
-) {
-	const completed = new Map<string, "done" | "error" | "needs-human">();
-
-	return (eng: string, status: "done" | "error" | "needs-human") => {
-		completed.set(eng, status);
-		const parts: string[] = [];
-		for (const e of engines) {
-			const s = completed.get(e);
-			if (s === "done") parts.push(`✅ ${e} done`);
-			else if (s === "error") parts.push(`❌ ${e} failed`);
-			else if (s === "needs-human")
-				parts.push(`🔓 ${e} needs manual verification`);
-			else parts.push(`⏳ ${e}`);
-		}
-		// Synthesis status: when all engines complete in non-fast mode,
-		// show synthesis progress.  Handle "skipped" status (emitted when
-		// manual verification is needed and synthesis is bypassed).
-		if (depth !== "fast" && completed.size >= 3) {
-			const synStatus = completed.get("synthesis");
-			if (synStatus === "done") parts.push("✅ synthesized");
-			else if (synStatus === "error") parts.push("❌ synthesis failed");
-			else if (synStatus === "needs-human") parts.push("⏭️ synthesis skipped");
-			else parts.push("🔄 synthesizing");
-		}
-
-		onUpdate?.({
-			content: [
-				{ type: "text", text: `**${suffix}...** ${parts.join(" · ")}` },
-			],
-			details: { _progress: true },
-		} satisfies ProgressUpdate);
-	};
-}
+/**
+ * Shared types, utilities, and runSearch for Pi tool handlers
+ */
+
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import type { ProgressUpdate, ToolResult } from "../types.js";
+
+export type { ProgressUpdate, ToolResult } from "../types.js";
+
+// Import and re-export ALL_ENGINES from constants.mjs so it's always in sync.
+// constants.mjs reads ~/.pi/greedyconfig for user overrides.
+import { ALL_ENGINES } from "../search/constants.mjs";
+export { ALL_ENGINES };
+
+/** Strip surrounding double-quotes that some framework versions inject into string params */
+export function stripQuotes(val: string): string {
+	return val.replace(/^"|"$/g, "");
+}
+
+/**
+ * Check if the CDP module is available in the package directory
+ */
+export function cdpAvailable(baseDir: string): boolean {
+	return existsSync(join(baseDir, "bin", "cdp.mjs"));
+}
+
+/**
+ * Create a "cdp missing" error result
+ */
+export function cdpMissingResult(): ToolResult {
+	return {
+		content: [
+			{
+				type: "text",
+				text: "cdp.mjs missing — try reinstalling: pi install git:github.com/apmantza/GreedySearch-pi",
+			},
+		],
+		details: {} as Record<string, unknown>,
+	};
+}
+
+/**
+ * Create an error result with a message
+ */
+export function errorResult(prefix: string, e: unknown): ToolResult {
+	const msg = e instanceof Error ? e.message : String(e);
+	return {
+		content: [{ type: "text", text: `${prefix}: ${msg}` }],
+		details: {} as Record<string, unknown>,
+	};
+}
+
+/**
+ * Spawn search.mjs and collect JSON results, with progress streaming via stderr.
+ * Shared by GreedySearch tool handlers.
+ */
+export function runSearch(
+	engine: string,
+	query: string,
+	flags: string[],
+	searchBin: string,
+	signal?: AbortSignal,
+	onProgress?: (
+		engine: string,
+		status: "done" | "error" | "needs-human",
+	) => void,
+	options: { headless?: boolean } = {},
+): Promise<Record<string, unknown>> {
+	return new Promise((resolve, reject) => {
+		const { headless = true } = options;
+		const allFlags = [...flags];
+		// Headless is default — only skip if explicitly false or GREEDY_SEARCH_VISIBLE=1
+		if (headless !== false && process.env.GREEDY_SEARCH_VISIBLE !== "1")
+			allFlags.push("--headless");
+		if (headless === false) allFlags.push("--always-visible");
+		// Propagate visibility preference via env (--headless flag is informational;
+		// the actual headless control in search.mjs / launch.mjs reads the env var).
+		const procEnv = { ...process.env };
+		if (headless === false) {
+			procEnv.GREEDY_SEARCH_VISIBLE = "1";
+			procEnv.GREEDY_SEARCH_ALWAYS_VISIBLE = "1";
+		}
+		const proc = spawn(
+			process.execPath,
+			[searchBin, engine, "--inline", "--stdin", ...allFlags],
+			{ stdio: ["pipe", "pipe", "pipe"], env: procEnv },
+		);
+		// Pipe query via stdin to avoid leaking it in process table command-line
+		proc.stdin.write(query);
+		proc.stdin.end();
+		let out = "";
+		let err = "";
+
+		const onAbort = () => {
+			proc.kill("SIGTERM");
+			reject(new Error("Aborted"));
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+
+		proc.stderr.on("data", (d: Buffer) => {
+			err += d;
+			// Match PROGRESS lines for any known engine.
+			const ENGINE_PROGRESS_RE =
+				/^PROGRESS:(perplexity|google|chatgpt|bing|gemini|semantic-scholar|semanticscholar|s2|logically):(done|error|needs-human)$/;
+			for (const line of d.toString().split("\n")) {
+				// Engine progress: any known engine
+				const engineMatch = line.match(ENGINE_PROGRESS_RE);
+				if (engineMatch && onProgress) {
+					onProgress(
+						engineMatch[1],
+						engineMatch[2] as "done" | "error" | "needs-human",
+					);
+				}
+				// Synthesis progress: skipped (manual verification) or done/error
+				const synthMatch = line.match(
+					/^PROGRESS:synthesis:(done|error|skipped)$/,
+				);
+				if (synthMatch && onProgress) {
+					onProgress(
+						"synthesis",
+						synthMatch[1] as "done" | "error" | "needs-human",
+					);
+				}
+			}
+		});
+
+		proc.stdout.on("data", (d: Buffer) => (out += d));
+		proc.on("close", (code: number) => {
+			signal?.removeEventListener("abort", onAbort);
+			if (code !== 0) {
+				reject(new Error(err.trim() || `search.mjs exited with code ${code}`));
+			} else {
+				try {
+					resolve(JSON.parse(out.trim()));
+				} catch {
+					reject(
+						new Error(`Invalid JSON from search.mjs: ${out.slice(0, 200)}`),
+					);
+				}
+			}
+		});
+	});
+}
+
+/**
+ * Build a progress callback that tracks completed engines.
+ * Returns an onProgress function suitable for runSearch.
+ */
+export function makeProgressTracker(
+	engines: readonly string[],
+	onUpdate: ((update: ProgressUpdate) => void) | undefined,
+	suffix: "Searching" | "Researching",
+	showSynthesis: boolean,
+) {
+	const completed = new Map<string, "done" | "error" | "needs-human">();
+
+	return (eng: string, status: "done" | "error" | "needs-human") => {
+		completed.set(eng, status);
+		const parts: string[] = [];
+		for (const e of engines) {
+			const s = completed.get(e);
+			if (s === "done") parts.push(`✅ ${e} done`);
+			else if (s === "error") parts.push(`❌ ${e} failed`);
+			else if (s === "needs-human")
+				parts.push(`🔓 ${e} needs manual verification`);
+			else parts.push(`⏳ ${e}`);
+		}
+		// Synthesis status is shown only when the caller explicitly requested
+		// Gemini synthesis for a multi-engine search.
+		if (showSynthesis && completed.size >= engines.length) {
+			const synStatus = completed.get("synthesis");
+			if (synStatus === "done") parts.push("✅ synthesized");
+			else if (synStatus === "error") parts.push("❌ synthesis failed");
+			else if (synStatus === "needs-human") parts.push("⏭️ synthesis skipped");
+			else parts.push("🔄 synthesizing");
+		}
+
+		onUpdate?.({
+			content: [
+				{ type: "text", text: `**${suffix}...** ${parts.join(" · ")}` },
+			],
+			details: { _progress: true },
+		} satisfies ProgressUpdate);
+	};
+}