@apmantza/greedysearch-pi 1.2.1 → 1.4.0

package/README.md

@@ -4,12 +4,13 @@ Pi extension that adds a `greedy_search` tool — fans out queries to Perplexity
 
 Forked from [GreedySearch-claude](https://github.com/apmantza/GreedySearch-claude).
 
-## What's New (v1.2.0)
+## What's New (v1.4.0)
 
-- **Fixed parallel search race condition** — multiple `greedy_search` calls can now run concurrently without tab conflicts
-- **Improved Bing Copilot verification** — better auto-handling of Turnstile challenges and modal dialogs
-- **Added test suite** — run `./test.sh` to verify all modes work correctly
-- **Atomic port file writes** — prevents corruption when multiple processes connect to Chrome
+- **Grounded synthesis** — Gemini now receives a normalized source registry with stable source IDs, agreement summaries, caveats, and cited claims
+- **Real deep research** — top sources are fetched before synthesis so deep research answers are grounded in fetched evidence, not just engine summaries
+- **Richer source metadata** — source output now includes canonical URLs, domains, source types, per-engine attribution, and confidence metadata
+- **Cleaner tab lifecycle** — temporary Perplexity, Bing, and Google tabs are closed after each fan-out search, and synthesis finishes on the Gemini tab
+- **Isolated Chrome targeting** — GreedySearch now refuses to fall back to your normal Chrome session, preventing stray remote-debugging prompts
 
 ## Install
 
@@ -69,7 +70,15 @@ For complex research questions, use `synthesize: true` with `engine: "all"`:
 greedy_search({ query: "best auth patterns for SaaS in 2026", engine: "all", synthesize: true })
 ```
 
-This deduplicates sources across engines and feeds them to Gemini for one clean, synthesized answer. Adds ~30s but produces the highest quality output with deduped sources showing consensus scores (`[2/3]`, `[3/3]`).
+This deduplicates sources across engines, builds a normalized source registry, and feeds that context to Gemini for one clean synthesized answer. Adds ~30s but now returns agreement summaries, caveats, key claims, and better-labeled top sources.
+
+For the most grounded mode, use deep research from the CLI:
+
+```bash
+node search.mjs all "best auth patterns for SaaS in 2026" --deep-research
+```
+
+Deep research fetches top source pages before synthesis and reports source confidence metadata such as agreement level, fetched-source success rate, and source mix.
 
 **Use synthesis when:**
 - You need one definitive answer, not multiple perspectives
@@ -112,7 +121,7 @@ greedy_search({ query: "Error: Cannot find module 'react-dom/client' Next.js 15"
 
 ## Requirements
 
-- **Chrome** — must be installed. The extension auto-launches a dedicated Chrome instance on port 9222 (separate from your main browser session).
+- **Chrome** — must be installed. The extension auto-launches a dedicated Chrome instance on port 9222 with its own isolated profile and DevTools port file, separate from your main browser session.
 - **Node.js 22+** — for built-in `fetch` and WebSocket support.
 
 ## Setup (first time)

package/cdp.mjs

@@ -37,21 +37,22 @@ function getDevToolsActivePortPath() {
   return join(homedir(), '.config', 'google-chrome', 'DevToolsActivePort');
 }
 
-function getWsUrl() {
-  // If CDP_PROFILE_DIR is set (by search.mjs), prefer that profile's port file
-  // so GreedySearch targets its own Chrome, not the user's main session.
-  const profileDir = process.env.CDP_PROFILE_DIR;
-  if (profileDir) {
-    const p = profileDir.replace(/\\/g, '/') + '/DevToolsActivePort';
-    if (existsSync(p)) {
-      const lines = readFileSync(p, 'utf8').trim().split('\n');
-      return `ws://127.0.0.1:${lines[0]}${lines[1]}`;
-    }
-  }
-  const portFile = getDevToolsActivePortPath();
-  const lines = readFileSync(portFile, 'utf8').trim().split('\n');
-  return `ws://127.0.0.1:${lines[0]}${lines[1]}`;
-}
+function getWsUrl() {
+  // If CDP_PROFILE_DIR is set (by search.mjs), prefer that profile's port file
+  // so GreedySearch targets its own Chrome, not the user's main session.
+  const profileDir = process.env.CDP_PROFILE_DIR;
+  if (profileDir) {
+    const p = profileDir.replace(/\\/g, '/') + '/DevToolsActivePort';
+    if (existsSync(p)) {
+      const lines = readFileSync(p, 'utf8').trim().split('\n');
+      return `ws://127.0.0.1:${lines[0]}${lines[1]}`;
+    }
+    throw new Error(`GreedySearch DevToolsActivePort not found at ${p}. Refusing to fall back to the main Chrome session.`);
+  }
+  const portFile = getDevToolsActivePortPath();
+  const lines = readFileSync(portFile, 'utf8').trim().split('\n');
+  return `ws://127.0.0.1:${lines[0]}${lines[1]}`;
+}
 
 const sleep = (ms) => new Promise(r => setTimeout(r, ms));
 

package/index.ts

@@ -68,31 +68,164 @@ function runSearch(
 	});
 }
 
+function formatEngineName(engine: string): string {
+	if (engine === "bing") return "Bing Copilot";
+	if (engine === "google") return "Google AI";
+	return engine.charAt(0).toUpperCase() + engine.slice(1);
+}
+
+function humanizeSourceType(sourceType: string): string {
+	if (!sourceType) return "";
+	if (sourceType === "official-docs") return "official docs";
+	return sourceType.replace(/-/g, " ");
+}
+
+function sourceUrl(source: Record<string, unknown>): string {
+	return String(source.displayUrl || source.canonicalUrl || source.url || "");
+}
+
+function sourceLabel(source: Record<string, unknown>): string {
+	return String(source.title || source.domain || sourceUrl(source) || "Untitled source");
+}
+
+function sourceConsensus(source: Record<string, unknown>): number {
+	if (typeof source.engineCount === "number") return source.engineCount;
+	const engines = Array.isArray(source.engines) ? (source.engines as string[]) : [];
+	return engines.length;
+}
+
+function formatAgreementLevel(level: string): string {
+	if (!level) return "Mixed";
+	return level.charAt(0).toUpperCase() + level.slice(1);
+}
+
+function getSourceMap(sources: Array<Record<string, unknown>>): Map<string, Record<string, unknown>> {
+	return new Map(
+		sources
+			.map((source) => [String(source.id || ""), source] as const)
+			.filter(([id]) => id),
+	);
+}
+
+function formatSourceLine(source: Record<string, unknown>): string {
+	const id = String(source.id || "?");
+	const url = sourceUrl(source);
+	const title = sourceLabel(source);
+	const domain = String(source.domain || "");
+	const engines = Array.isArray(source.engines) ? (source.engines as string[]) : [];
+	const consensus = sourceConsensus(source);
+	const typeLabel = humanizeSourceType(String(source.sourceType || ""));
+	const fetch = source.fetch as Record<string, unknown> | undefined;
+	const fetchStatus = fetch?.ok ? `fetched ${fetch.status || 200}` : fetch?.attempted ? "fetch failed" : "";
+	const pieces = [
+		`${id} - [${title}](${url})`,
+		domain,
+		typeLabel,
+		engines.length ? `cited by ${engines.map(formatEngineName).join(", ")} (${consensus}/3)` : `${consensus}/3`,
+		fetchStatus,
+	].filter(Boolean);
+	return `- ${pieces.join(" - ")}`;
+}
+
+function renderSourceEvidence(lines: string[], source: Record<string, unknown>): void {
+	const fetch = source.fetch as Record<string, unknown> | undefined;
+	if (!fetch?.attempted) return;
+
+	const snippet = String(fetch.snippet || "").trim();
+	const lastModified = String(fetch.lastModified || "").trim();
+	if (snippet) lines.push(`  Evidence: ${snippet}`);
+	if (lastModified) lines.push(`  Last-Modified: ${lastModified}`);
+	if (fetch.error) lines.push(`  Fetch error: ${String(fetch.error)}`);
+}
+
+function pickSources(
+	sources: Array<Record<string, unknown>>,
+	recommendedIds: string[] = [],
+	max = 6,
+): Array<Record<string, unknown>> {
+	if (!sources.length) return [];
+	const sourceMap = getSourceMap(sources);
+	const recommended = recommendedIds
+		.map((id) => sourceMap.get(id))
+		.filter((source): source is Record<string, unknown> => Boolean(source));
+	if (recommended.length > 0) return recommended.slice(0, max);
+	return sources.slice(0, max);
+}
+
+function renderSynthesis(
+	lines: string[],
+	synthesis: Record<string, unknown>,
+	sources: Array<Record<string, unknown>>,
+	maxSources = 6,
+): void {
+	if (synthesis.answer) {
+		lines.push("## Answer");
+		lines.push(String(synthesis.answer));
+		lines.push("");
+	}
+
+	const agreement = synthesis.agreement as Record<string, unknown> | undefined;
+	const agreementSummary = String(agreement?.summary || "").trim();
+	const agreementLevel = String(agreement?.level || "").trim();
+	if (agreementSummary || agreementLevel) {
+		lines.push("## Consensus");
+		lines.push(`- ${formatAgreementLevel(agreementLevel)}${agreementSummary ? ` - ${agreementSummary}` : ""}`);
+		lines.push("");
+	}
+
+	const differences = Array.isArray(synthesis.differences) ? (synthesis.differences as string[]) : [];
+	if (differences.length > 0) {
+		lines.push("## Where Engines Differ");
+		for (const difference of differences) lines.push(`- ${difference}`);
+		lines.push("");
+	}
+
+	const caveats = Array.isArray(synthesis.caveats) ? (synthesis.caveats as string[]) : [];
+	if (caveats.length > 0) {
+		lines.push("## Caveats");
+		for (const caveat of caveats) lines.push(`- ${caveat}`);
+		lines.push("");
+	}
+
+	const claims = Array.isArray(synthesis.claims)
+		? (synthesis.claims as Array<Record<string, unknown>>)
+		: [];
+	if (claims.length > 0) {
+		lines.push("## Key Claims");
+		for (const claim of claims) {
+			const sourceIds = Array.isArray(claim.sourceIds) ? (claim.sourceIds as string[]) : [];
+			const support = String(claim.support || "moderate");
+			lines.push(`- ${String(claim.claim || "")} [${support}${sourceIds.length ? `; ${sourceIds.join(", ")}` : ""}]`);
+		}
+		lines.push("");
+	}
+
+	const recommendedIds = Array.isArray(synthesis.recommendedSources)
+		? (synthesis.recommendedSources as string[])
+		: [];
+	const topSources = pickSources(sources, recommendedIds, maxSources);
+	if (topSources.length > 0) {
+		lines.push("## Top Sources");
+		for (const source of topSources) lines.push(formatSourceLine(source));
+		lines.push("");
+	}
+}
+
 function formatResults(engine: string, data: Record<string, unknown>): string {
 	const lines: string[] = [];
 
 	if (engine === "all") {
-		// Synthesized output: prefer _synthesis + _sources
 		const synthesis = data._synthesis as Record<string, unknown> | undefined;
 		const dedupedSources = data._sources as Array<Record<string, unknown>> | undefined;
 		if (synthesis?.answer) {
-			lines.push("## Synthesis");
-			lines.push(String(synthesis.answer));
-			if (dedupedSources?.length) {
-				lines.push("\n**Top sources by consensus:**");
-				for (const s of dedupedSources.slice(0, 6)) {
-					const engines = (s.engines as string[]) || [];
-					lines.push(`- [${s.title || s.url}](${s.url}) [${engines.length}/3]`);
-				}
-			}
-			lines.push("\n---\n*Synthesized from Perplexity, Bing Copilot, and Google AI*");
+			renderSynthesis(lines, synthesis, dedupedSources || [], 6);
+			lines.push("*Synthesized from Perplexity, Bing Copilot, and Google AI*\n");
 			return lines.join("\n").trim();
 		}
 
-		// Standard output: per-engine answers
 		for (const [eng, result] of Object.entries(data)) {
 			if (eng.startsWith("_")) continue;
-			lines.push(`\n## ${eng.charAt(0).toUpperCase() + eng.slice(1)}`);
+			lines.push(`\n## ${formatEngineName(eng)}`);
 			const r = result as Record<string, unknown>;
 			if (r.error) {
 				lines.push(`Error: ${r.error}`);
@@ -125,6 +258,107 @@ function formatResults(engine: string, data: Record<string, unknown>): string {
 	return lines.join("\n").trim();
 }
 
+function formatDeepResearch(data: Record<string, unknown>): string {
+	const lines: string[] = [];
+	const confidence = data._confidence as Record<string, unknown> | undefined;
+	const dedupedSources = data._sources as Array<Record<string, unknown>> | undefined;
+	const synthesis = data._synthesis as Record<string, unknown> | undefined;
+
+	lines.push("# Deep Research Report\n");
+
+	if (confidence) {
+		const enginesResponded = (confidence.enginesResponded as string[]) || [];
+		const enginesFailed = (confidence.enginesFailed as string[]) || [];
+		const agreementLevel = String(confidence.agreementLevel || "mixed");
+		const firstPartySourceCount = Number(confidence.firstPartySourceCount || 0);
+		const sourceTypeBreakdown = confidence.sourceTypeBreakdown as Record<string, number> | undefined;
+
+		lines.push("## Confidence\n");
+		lines.push(`- Agreement: ${formatAgreementLevel(agreementLevel)}`);
+		lines.push(`- Engines responded: ${enginesResponded.map(formatEngineName).join(", ") || "none"}`);
+		if (enginesFailed.length > 0) {
+			lines.push(`- Engines failed: ${enginesFailed.map(formatEngineName).join(", ")}`);
+		}
+		lines.push(`- Top source consensus: ${confidence.topSourceConsensus || 0}/3 engines`);
+		lines.push(`- Total unique sources: ${confidence.sourcesCount || 0}`);
+		lines.push(`- Official sources: ${confidence.officialSourceCount || 0}`);
+		lines.push(`- First-party sources: ${firstPartySourceCount}`);
+		lines.push(`- Fetch success rate: ${confidence.fetchedSourceSuccessRate || 0}`);
+		if (sourceTypeBreakdown && Object.keys(sourceTypeBreakdown).length > 0) {
+			lines.push(`- Source mix: ${Object.entries(sourceTypeBreakdown).map(([type, count]) => `${humanizeSourceType(type)} ${count}`).join(", ")}`);
+		}
+		lines.push("");
+	}
+
+	if (synthesis?.answer) renderSynthesis(lines, synthesis, dedupedSources || [], 8);
+
+	lines.push("## Engine Perspectives\n");
+	for (const engine of ["perplexity", "bing", "google"]) {
+		const r = data[engine] as Record<string, unknown> | undefined;
+		if (!r) continue;
+		lines.push(`### ${formatEngineName(engine)}`);
+		if (r.error) {
+			lines.push(`⚠️ Error: ${r.error}`);
+		} else if (r.answer) {
+			lines.push(String(r.answer).slice(0, 2000));
+		}
+		lines.push("");
+	}
+
+	if (dedupedSources && dedupedSources.length > 0) {
+		lines.push("## Source Registry\n");
+		for (const source of dedupedSources) {
+			lines.push(formatSourceLine(source));
+			renderSourceEvidence(lines, source);
+		}
+		lines.push("");
+	}
+
+	return lines.join("\n").trim();
+}
+
+function formatCodingTask(data: Record<string, unknown> | Record<string, Record<string, unknown>>): string {
+	const lines: string[] = [];
+
+	// Check if it's multi-engine result
+	const hasMultipleEngines = "gemini" in data || "copilot" in data;
+	
+	if (hasMultipleEngines) {
+		// Multi-engine result
+		for (const [engineName, result] of Object.entries(data)) {
+			const r = result as Record<string, unknown>;
+			lines.push(`## ${engineName.charAt(0).toUpperCase() + engineName.slice(1)}\n`);
+			
+			if (r.error) {
+				lines.push(`⚠️ Error: ${r.error}\n`);
+			} else {
+				if (r.explanation) lines.push(String(r.explanation));
+				if (Array.isArray(r.code) && r.code.length > 0) {
+					for (const block of r.code) {
+						const b = block as { language: string; code: string };
+						lines.push(`\n\`\`\`${b.language}\n${b.code}\n\`\`\`\n`);
+					}
+				}
+				if (r.url) lines.push(`*Source: ${r.url}*`);
+			}
+			lines.push("");
+		}
+	} else {
+		// Single engine result
+		const r = data as Record<string, unknown>;
+		if (r.explanation) lines.push(String(r.explanation));
+		if (Array.isArray(r.code) && r.code.length > 0) {
+			for (const block of r.code) {
+				const b = block as { language: string; code: string };
+				lines.push(`\n\`\`\`${b.language}\n${b.code}\n\`\`\`\n`);
+			}
+		}
+		if (r.url) lines.push(`*Source: ${r.url}*`);
+	}
+
+	return lines.join("\n").trim();
+}
+
 export default function greedySearchExtension(pi: ExtensionAPI) {
 	pi.on("session_start", async (_event, ctx) => {
 		if (!cdpAvailable()) {
@@ -219,4 +453,171 @@ export default function greedySearchExtension(pi: ExtensionAPI) {
 			}
 		},
 	});
+
+	// ─── deep_research ─────────────────────────────────────────────────────────
+	pi.registerTool({
+		name: "deep_research",
+		label: "Deep Research",
+		description:
+			"Comprehensive multi-engine research with source fetching and synthesis. " +
+			"Runs Perplexity, Bing Copilot, and Google AI in parallel with full answers, " +
+			"deduplicates and ranks sources by consensus, fetches content from top sources, " +
+			"and synthesizes via Gemini. Returns a structured research document with confidence scores. " +
+			"Use for architecture decisions, library comparisons, best practices, or any research where the answer matters.",
+		promptSnippet: "Deep multi-engine research with source deduplication and synthesis",
+		parameters: Type.Object({
+			query: Type.String({ description: "The research question" }),
+		}),
+		execute: async (_toolCallId, params, signal, onUpdate) => {
+			const { query } = params as { query: string };
+
+			if (!cdpAvailable()) {
+				return {
+					content: [{ type: "text", text: "cdp.mjs missing — try reinstalling." }],
+					details: {} as { raw?: Record<string, unknown> },
+				};
+			}
+
+			const completed = new Set<string>();
+
+			const onProgress = (eng: string, status: "done" | "error") => {
+				completed.add(eng);
+				const parts: string[] = [];
+				for (const e of ALL_ENGINES) {
+					if (completed.has(e)) parts.push(`✅ ${e}`);
+					else parts.push(`⏳ ${e}`);
+				}
+				if (completed.size >= 3) parts.push("🔄 synthesizing");
+
+				onUpdate?.({
+					content: [{ type: "text", text: `**Researching...** ${parts.join(" · ")}` }],
+					details: { _progress: true },
+				} as any);
+			};
+
+			try {
+				// Run deep research (includes full answers, synthesis, and source fetching)
+				const data = await runSearch("all", query, ["--deep-research"], signal, onProgress);
+				const text = formatDeepResearch(data);
+				return {
+					content: [{ type: "text", text: text || "No results returned." }],
+					details: { raw: data },
+				};
+			} catch (e) {
+				const msg = e instanceof Error ? e.message : String(e);
+				return {
+					content: [{ type: "text", text: `Deep research failed: ${msg}` }],
+					details: {} as { raw?: Record<string, unknown> },
+				};
+			}
+		},
+	});
+
+	// ─── coding_task ───────────────────────────────────────────────────────────
+	pi.registerTool({
+		name: "coding_task",
+		label: "Coding Task",
+		description:
+			"Delegate a coding task to Gemini and/or Copilot via browser automation. " +
+			"Returns extracted code blocks and explanations. Supports multiple modes: " +
+			"'code' (write/modify code), 'review' (senior engineer code review), " +
+			"'plan' (architect risk assessment), 'test' (edge case testing), " +
+			"'debug' (fresh-eyes root cause analysis). " +
+			"Best for getting a 'second opinion' on hard problems, debugging tricky issues, " +
+			"or risk-assessing major refactors. Use engine 'all' for both perspectives.",
+		promptSnippet: "Browser-based coding assistant with Gemini and Copilot",
+		parameters: Type.Object({
+			task: Type.String({ description: "The coding task or question" }),
+			engine: Type.Union(
+				[
+					Type.Literal("all"),
+					Type.Literal("gemini"),
+					Type.Literal("copilot"),
+				],
+				{
+					description: 'Engine to use. "all" runs both Gemini and Copilot in parallel.',
+					default: "gemini",
+				},
+			),
+			mode: Type.Union(
+				[
+					Type.Literal("code"),
+					Type.Literal("review"),
+					Type.Literal("plan"),
+					Type.Literal("test"),
+					Type.Literal("debug"),
+				],
+				{
+					description: "Task mode: code (default), review (code review), plan (architect review), test (write tests), debug (root cause analysis)",
+					default: "code",
+				},
+			),
+			context: Type.Optional(Type.String({
+				description: "Optional code context/snippet to include with the task",
+			})),
+		}),
+		execute: async (_toolCallId, params, signal, onUpdate) => {
+			const { task, engine = "gemini", mode = "code", context } = params as {
+				task: string; engine: string; mode: string; context?: string;
+			};
+
+			if (!cdpAvailable()) {
+				return {
+					content: [{ type: "text", text: "cdp.mjs missing — try reinstalling." }],
+					details: {} as { raw?: Record<string, unknown> },
+				};
+			}
+
+			const flags: string[] = ["--engine", engine, "--mode", mode];
+			if (context) flags.push("--context", context);
+
+			try {
+				onUpdate?.({
+					content: [{ type: "text", text: `**Coding task...** 🔄 ${engine === "all" ? "Gemini + Copilot" : engine} (${mode} mode)` }],
+					details: { _progress: true },
+				} as any);
+
+				const data = await new Promise<Record<string, unknown>>((resolve, reject) => {
+					const proc = spawn("node", [__dir + "/coding-task.mjs", task, ...flags], {
+						stdio: ["ignore", "pipe", "pipe"],
+					});
+					let out = "";
+					let err = "";
+
+					const onAbort = () => { proc.kill("SIGTERM"); reject(new Error("Aborted")); };
+					signal?.addEventListener("abort", onAbort, { once: true });
+
+					proc.stdout.on("data", (d: Buffer) => (out += d));
+					proc.stderr.on("data", (d: Buffer) => { err += d; });
+					proc.on("close", (code: number) => {
+						signal?.removeEventListener("abort", onAbort);
+						if (code !== 0) {
+							reject(new Error(err.trim() || `coding-task.mjs exited with code ${code}`));
+						} else {
+							try {
+								resolve(JSON.parse(out.trim()));
+							} catch {
+								reject(new Error(`Invalid JSON from coding-task.mjs: ${out.slice(0, 200)}`));
+							}
+						}
+					});
+
+					// Timeout after 3 minutes
+					setTimeout(() => { proc.kill("SIGTERM"); reject(new Error("Coding task timed out after 180s")); }, 180000);
+				});
+
+				const text = formatCodingTask(data);
+				return {
+					content: [{ type: "text", text: text || "No response." }],
+					details: { raw: data },
+				};
+			} catch (e) {
+				const msg = e instanceof Error ? e.message : String(e);
+				return {
+					content: [{ type: "text", text: `Coding task failed: ${msg}` }],
+					details: {} as { raw?: Record<string, unknown> },
+				};
+			}
+		},
+	});
 }