@apmantza/greedysearch-pi 1.2.1 → 1.3.0

package/index.ts

@@ -125,6 +125,124 @@ 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 fetchedSources = data._fetchedSources as Array<Record<string, unknown>> | undefined;
+	const dedupedSources = data._sources as Array<Record<string, unknown>> | undefined;
+
+	lines.push("# Deep Research Report\n");
+
+	// Confidence summary
+	if (confidence) {
+		const enginesResponded = (confidence.enginesResponded as string[]) || [];
+		const enginesFailed = (confidence.enginesFailed as string[]) || [];
+		const consensusScore = confidence.consensusScore || 0;
+
+		lines.push("## Confidence\n");
+		lines.push(`- **Engines responded:** ${enginesResponded.join(", ") || "none"}`);
+		if (enginesFailed.length > 0) {
+			lines.push(`- **Engines failed:** ${enginesFailed.join(", ")}`);
+		}
+		lines.push(`- **Top source consensus:** ${consensusScore}/3 engines`);
+		lines.push(`- **Total unique sources:** ${confidence.sourcesCount || 0}`);
+		lines.push("");
+	}
+
+	// Per-engine answers
+	lines.push("## Findings\n");
+	for (const engine of ["perplexity", "bing", "google"]) {
+		const r = data[engine] as Record<string, unknown> | undefined;
+		if (!r) continue;
+		lines.push(`### ${engine.charAt(0).toUpperCase() + engine.slice(1)}`);
+		if (r.error) {
+			lines.push(`⚠️ Error: ${r.error}`);
+		} else if (r.answer) {
+			lines.push(String(r.answer).slice(0, 2000));
+		}
+		lines.push("");
+	}
+
+	// Synthesis
+	const synthesis = data._synthesis as Record<string, unknown> | undefined;
+	if (synthesis?.answer) {
+		lines.push("## Synthesized Answer\n");
+		lines.push(String(synthesis.answer));
+		lines.push("");
+	}
+
+	// Deduplicated sources by consensus
+	if (dedupedSources && dedupedSources.length > 0) {
+		lines.push("## Sources (Ranked by Consensus)\n");
+		for (const s of dedupedSources) {
+			const engines = (s.engines as string[]) || [];
+			const consensus = engines.length;
+			lines.push(`- **[${consensus}/3]** [${s.title || "Untitled"}](${s.url})`);
+		}
+		lines.push("");
+	}
+
+	// Fetched source content
+	if (fetchedSources && fetchedSources.length > 0) {
+		lines.push("## Source Content (Top Matches)\n");
+		for (const fs of fetchedSources) {
+			lines.push(`### ${fs.title || fs.url}`);
+			lines.push(`*Source: ${fs.url}*`);
+			lines.push("");
+			if (fs.content) {
+				lines.push(String(fs.content).slice(0, 3000));
+			} else if (fs.error) {
+				lines.push(`⚠️ Could not fetch: ${fs.error}`);
+			}
+			lines.push("\n---\n");
+		}
+	}
+
+	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 +337,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> },
+				};
+			}
+		},
+	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apmantza/greedysearch-pi",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "Pi extension: browser-automation tool that searches Perplexity, Bing Copilot, and Google AI in parallel, extracts answers and sources via CDP, with optional Gemini synthesis — grounded AI answers from real browser interactions.",
   "type": "module",
   "keywords": [

package/search.mjs

@@ -165,6 +165,75 @@ async function fetchTopSource(url) {
   }
 }
 
+async function fetchSourceContent(url, maxChars = 5000) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 15000);
+    
+    const res = await fetch(url, {
+      signal: controller.signal,
+      headers: {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+        'Accept': 'text/html,application/xhtml+xml',
+        'Accept-Language': 'en-US,en;q=0.9',
+      },
+    });
+    clearTimeout(timeout);
+    
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    
+    const html = await res.text();
+    
+    // Simple HTML extraction - remove tags and extract text
+    const content = html
+      .replace(/<script[\s\S]*?<\/script>/gi, '')
+      .replace(/<style[\s\S]*?<\/style>/gi, '')
+      .replace(/<nav[\s\S]*?<\/nav>/gi, '')
+      .replace(/<header[\s\S]*?<\/header>/gi, '')
+      .replace(/<footer[\s\S]*?<\/footer>/gi, '')
+      .replace(/<[^>]+>/g, ' ')
+      .replace(/&[a-z]+;/gi, ' ')
+      .replace(/\s+/g, ' ')
+      .trim()
+      .slice(0, maxChars);
+    
+    // Extract title
+    const titleMatch = html.match(/<title[^>]*>([^<]+)<\/title>/i);
+    const title = titleMatch ? titleMatch[1].trim() : '';
+    
+    return { url, title, content };
+  } catch (e) {
+    return { url, title: '', content: null, error: e.message };
+  }
+}
+
+async function fetchMultipleSources(sources, maxSources = 5, maxChars = 5000) {
+  process.stderr.write(`[greedysearch] Fetching content from ${Math.min(sources.length, maxSources)} sources...\n`);
+  
+  // Fetch sources sequentially (CDP doesn't handle parallel tab operations well)
+  const toFetch = sources.slice(0, maxSources);
+  const fetched = [];
+  
+  for (let i = 0; i < toFetch.length; i++) {
+    const s = toFetch[i];
+    process.stderr.write(`[greedysearch] Fetching ${i + 1}/${toFetch.length}: ${s.url.slice(0, 60)}...\n`);
+    try {
+      const result = await fetchSourceContent(s.url, maxChars);
+      if (result.content && result.content.length > 100) {
+        fetched.push(result);
+        process.stderr.write(`[greedysearch] ✓ Got ${result.content.length} chars\n`);
+      } else {
+        process.stderr.write(`[greedysearch] ✗ Empty or too short\n`);
+      }
+    } catch (e) {
+      process.stderr.write(`[greedysearch] ✗ Failed: ${e.message.slice(0, 80)}\n`);
+    }
+    process.stderr.write(`PROGRESS:fetch:${i + 1}/${toFetch.length}\n`);
+  }
+  
+  return fetched;
+}
+
 function pickTopSource(out) {
   for (const engine of ['perplexity', 'google', 'bing']) {
     const r = out[engine];
@@ -234,8 +303,8 @@ async function synthesizeWithGemini(query, results) {
     proc.stderr.on('data', d => err += d);
     const t = setTimeout(() => {
       proc.kill();
-      reject(new Error('Gemini synthesis timed out after 120s'));
-    }, 120000);
+      reject(new Error('Gemini synthesis timed out after 180s'));
+    }, 180000);
     proc.on('close', code => {
       clearTimeout(t);
       if (code !== 0) reject(new Error(err.trim() || 'gemini extractor failed'));
@@ -388,28 +457,37 @@ async function main() {
       '',
       'Engines: perplexity (p), bing (b), google (g), gemini (gem), all',
       '',
+      'Flags:',
+      '  --full              Return complete answers (~3000+ chars)',
+      '  --synthesize        Synthesize results via Gemini (adds ~30s)',
+      '  --deep-research     Full research: full answers + source fetching + synthesis',
+      '  --fetch-top-source  Fetch content from top source',
+      '  --inline            Output JSON to stdout (for piping)',
+      '',
       'Examples:',
       '  node search.mjs p "what is memoization"',
-      '  node search.mjs so "node.js event loop explained"',
       '  node search.mjs all "TCP congestion control"',
+      '  node search.mjs all "RAG vs fine-tuning" --deep-research',
     ].join('\n') + '\n');
     process.exit(1);
   }
 
   await ensureChrome();
 
-  const full        = args.includes('--full');
-  const short       = !full;   // brief by default; --full opts into complete answers
-  const fetchSource = args.includes('--fetch-top-source');
-  const synthesize  = args.includes('--synthesize');
-  const inline      = args.includes('--inline');
-  const outIdx      = args.indexOf('--out');
-  const outFile     = outIdx !== -1 ? args[outIdx + 1] : null;
-  const rest        = args.filter((a, i) =>
+  const full          = args.includes('--full') || args.includes('--deep-research');
+  const short         = !full;
+  const fetchSource   = args.includes('--fetch-top-source');
+  const synthesize    = args.includes('--synthesize') || args.includes('--deep-research');
+  const deepResearch  = args.includes('--deep-research');
+  const inline        = args.includes('--inline');
+  const outIdx        = args.indexOf('--out');
+  const outFile       = outIdx !== -1 ? args[outIdx + 1] : null;
+  const rest          = args.filter((a, i) =>
     a !== '--full' &&
-    a !== '--short' &&  // keep accepting --short for back-compat
+    a !== '--short' &&
     a !== '--fetch-top-source' &&
     a !== '--synthesize' &&
+    a !== '--deep-research' &&
     a !== '--inline' &&
     a !== '--out' &&
     (outIdx === -1 || i !== outIdx + 1)
@@ -481,6 +559,31 @@ async function main() {
       if (top) out._topSource = await fetchTopSource(top.url);
     }
 
+    // Deep research mode: fetch top sources and return structured document
+    if (deepResearch) {
+      process.stderr.write('PROGRESS:deep-research:start\n');
+      
+      // Get top sources by consensus
+      const topSources = out._sources || [];
+      
+      if (topSources.length > 0) {
+        // Fetch content from top sources
+        out._fetchedSources = await fetchMultipleSources(topSources, 5, 8000);
+        process.stderr.write('PROGRESS:deep-research:done\n');
+      } else {
+        out._fetchedSources = [];
+        process.stderr.write('PROGRESS:deep-research:no-sources\n');
+      }
+      
+      // Build confidence scores
+      out._confidence = {
+        sourcesCount: topSources.length,
+        consensusScore: topSources.length > 0 ? topSources[0]?.engines?.length || 0 : 0,
+        enginesResponded: ALL_ENGINES.filter(e => out[e]?.answer && !out[e]?.error),
+        enginesFailed: ALL_ENGINES.filter(e => out[e]?.error),
+      };
+    }
+
     writeOutput(out, outFile, { inline, synthesize, query });
     return;
   }

package/skills/greedy-search/SKILL.md

@@ -1,11 +1,84 @@
 ---
 name: greedy-search
-description: Multi-engine AI web search — Perplexity, Bing Copilot, Google AI in parallel with optional Gemini synthesis. Use for high-quality research where training data may be stale or single-engine results are insufficient.
+description: Multi-engine AI web search — greedy_search, deep_research, and coding_task. Use for high-quality research where training data may be stale or single-engine results are insufficient.
 ---
 
-# Greedy Search
+# GreedySearch Tools
 
-Use `greedy_search` when you need high-quality, multi-perspective answers from the web.
+## Tool Overview
+
+| Tool | Speed | Use for |
+|------|-------|---------|
+| `greedy_search` | 15-90s | Quick lookups, comparisons, debugging errors |
+| `deep_research` | 60-120s | Architecture decisions, thorough research, source-backed answers |
+| `coding_task` | 60-180s | Second opinions on code, reviews, debugging tricky issues |
+
+## When to Use Which
+
+- **`greedy_search`** — Default. Fast enough for most things. Use when you need current info.
+- **`deep_research`** — When the answer *matters*. Gives you a structured document with confidence scores, deduplicated sources ranked by consensus, Gemini synthesis, AND actual content from top sources.
+- **`coding_task`** — When you need a "second opinion" on hard problems. Best for `debug` and `plan` modes on tricky issues.
+
+---
+
+# greedy_search
+
+Multi-engine AI web search with streaming progress.
+
+```greedy_search({ query: "what changed in React 19", engine: "all" })```
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `query` | string | required | The search question |
+| `engine` | string | `"all"` | `all`, `perplexity`, `bing`, `google`, `gemini` |
+| `synthesize` | boolean | `false` | Synthesize via Gemini |
+| `fullAnswer` | boolean | `false` | Complete answer vs ~300 char summary |
+
+**When to use:** Quick lookups, error messages, comparing tools, "what's new in X".
+
+---
+
+# deep_research
+
+Comprehensive research with source fetching and synthesis. Returns a structured document.
+
+```deep_research({ query: "RAG vs fine-tuning for production" })```
+
+Returns:
+- Full answers from all 3 engines (Perplexity, Bing, Google)
+- Gemini synthesis combining all perspectives
+- Deduplicated sources ranked by consensus (3/3 > 2/3 > 1/3)
+- Fetched content from top 5 sources (no CDP — uses native fetch)
+- Confidence metadata (which engines responded, consensus score)
+
+**When to use:** Architecture decisions, "which library should I use", research for a writeup, anything where you need source-backed confidence.
+
+---
+
+# coding_task
+
+Browser-based coding assistant using Gemini and/or Copilot.
+
+```coding_task({ task: "debug this race condition", mode: "debug", engine: "all" })```
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `task` | string | required | The coding task/question |
+| `engine` | string | `"gemini"` | `gemini`, `copilot`, or `all` |
+| `mode` | string | `"code"` | See modes below |
+| `context` | string | — | Code snippet to include |
+
+**Modes:**
+
+| Mode | Use when |
+|------|----------|
+| `debug` | Stuck on a tricky bug. Fresh eyes catch different failure modes. |
+| `plan` | About to refactor something big. Gemini plays devil's advocate. |
+| `review` | Code review before merge. High-stakes code benefits from second opinion. |
+| `test` | Need edge cases the author missed. |
+| `code` | Just need the code written (but you can probably do this yourself faster). |
+
+**When to use:** Debugging tricky issues, planning major refactors, security-critical reviews. **Skip for** simple code generation — you're faster.
 
 ## Greedy Search vs Built-in Web Search