@apmantza/greedysearch-pi 1.9.1 → 2.0.0

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

@@ -2,9 +2,11 @@
  * greedy_search tool handler — multi-engine AI web search
  */
 
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
 import { Type } from "@sinclair/typebox";
+
+type ExtensionAPI = {
+	registerTool(tool: Record<string, unknown>): void;
+};
 import { formatResults } from "../formatters/results.js";
 import {
 	ALL_ENGINES,
@@ -14,15 +16,75 @@ 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,
+		private paddingX = 0,
+		private paddingY = 0,
+	) {}
+
+	render(width: number): string[] {
+		const horizontal = " ".repeat(this.paddingX);
+		const blank = "";
+		const contentWidth = Math.max(1, width - this.paddingX * 2);
+		const lines = this.text.split("\n").flatMap((line) => {
+			if (line.length <= contentWidth) return [`${horizontal}${line}`];
+			const wrapped: string[] = [];
+			for (let i = 0; i < line.length; i += contentWidth) {
+				wrapped.push(`${horizontal}${line.slice(i, i + contentWidth)}`);
+			}
+			return wrapped;
+		});
+		return [
+			...Array.from({ length: this.paddingY }, () => blank),
+			...lines,
+			...Array.from({ length: this.paddingY }, () => blank),
+		];
+	}
+
+	invalidate() {}
+}
+
 export function registerGreedySearchTool(pi: ExtensionAPI, baseDir: string) {
 	pi.registerTool({
 		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",
@@ -30,14 +92,61 @@ 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" (synthesis + source fetching + confidence, ~60-180s). Default: "standard". Note: single-engine searches always run in fast mode regardless of this setting — synthesis requires multiple engines.',
-				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:
+						'Only for depth="research": number of parallel research directions per round, 1-5 (default: 3).',
+					default: 3,
+				}),
+			),
+			iterations: Type.Optional(
+				Type.Number({
+					description:
+						'Only for depth="research": number of iterative research rounds, 1-3 (default: 2).',
+					default: 2,
+				}),
+			),
+			maxSources: Type.Optional(
+				Type.Number({
+					description:
+						'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:
@@ -67,23 +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";
-				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";
+		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;
@@ -91,29 +210,48 @@ export function registerGreedySearchTool(pi: ExtensionAPI, baseDir: string) {
 			if (!cdpAvailable(baseDir)) return cdpMissingResult();
 
 			const flags: string[] = [];
-			const fullAnswer = fullAnswerParam ?? engine !== "all";
+			const fullAnswer = fullAnswerParam ?? effectiveEngine !== "all";
 			if (fullAnswer) flags.push("--full");
-			if (depth === "deep") flags.push("--depth", "deep");
-			else if (depth === "fast") flags.push("--fast");
-			else if (depth === "standard" && engine === "all")
-				flags.push("--synthesize");
+			if (researchMode) {
+				flags.push("--depth", "research");
+				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 =
-				engine === "all"
-					? makeProgressTracker(ALL_ENGINES, onUpdate, "Searching", depth)
+				effectiveEngine === "all"
+					? makeProgressTracker(
+							ALL_ENGINES,
+							onUpdate,
+							researchMode ? "Researching" : "Searching",
+							synthesize,
+						)
 					: undefined;
 
 			try {
 				const data = await runSearch(
-					engine,
+					effectiveEngine,
 					query,
 					flags,
 					`${baseDir}/bin/search.mjs`,
 					signal,
 					onProgress,
-					headless,
+					{ headless },
 				);
-				const text = formatResults(engine, data);
+				const text = formatResults(effectiveEngine, data);
 				return {
 					content: [{ type: "text", text: text || "No results returned." }],
 					details: { raw: data },
@@ -123,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 =
@@ -137,9 +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...";
@@ -147,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) {
@@ -170,7 +312,9 @@ export function registerGreedySearchTool(pi: ExtensionAPI, baseDir: string) {
 				const sources = raw?._sources as Array<unknown> | undefined;
 				if (synthesis) {
 					const sourceCount = Array.isArray(sources) ? sources.length : 0;
-					const agreement = (synthesis.agreement as Record<string, unknown> | undefined)?.level as string | undefined;
+					const agreement = (
+						synthesis.agreement as Record<string, unknown> | undefined
+					)?.level as string | undefined;
 					let summary = " → Synthesized";
 					if (sourceCount > 0)
 						summary += ` · ${sourceCount} source${sourceCount > 1 ? "s" : ""}`;
@@ -184,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;
 				}
@@ -200,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)}`),