@apmantza/greedysearch-pi 1.0.24 → 1.1.1

package/extractors/gemini.mjs

@@ -108,15 +108,49 @@ async function extractAnswer(tab) {
   const answer = await cdp(['eval', tab, `window.__geminiClipboard || ''`]);
   if (!answer) throw new Error('Clipboard interceptor returned empty text');
 
-  // Sources: links rendered in the page (best-effort; Shadow DOM may hide some)
+  // Click "Sources" button to open the sidebar with proper source cards
+  await cdp(['eval', tab, `
+    (function() {
+      var btn = document.querySelector('button.legacy-sources-sidebar-button, button.mdс-button--outline');
+      if (!btn) btn = Array.from(document.querySelectorAll('button')).find(b => b.innerText?.trim() === 'Sources');
+      if (btn) { btn.click(); return 'clicked'; }
+      return 'not-found';
+    })()
+  `]).catch(() => 'not-found');
+
+  // Wait for the sources sidebar to populate
+  await new Promise(r => setTimeout(r, 1500));
+
+  // Extract sources from the sidebar panel (has proper URLs + titles)
   const raw = await cdp(['eval', tab, `
     (function() {
-      var sources = Array.from(document.querySelectorAll('a[href^="http"]'))
+      // Find the Sources sidebar container by heading
+      var headings = Array.from(document.querySelectorAll('h1, h2, h3, [class*="header"]'));
+      var sourceHeading = headings.find(h => h.innerText?.trim() === 'Sources');
+      if (sourceHeading) {
+        var container = sourceHeading.closest('.container') || sourceHeading.parentElement;
+        var links = Array.from(container.querySelectorAll('a[href^="http"]'))
+          .map(a => ({ url: a.href.split('#')[0], title: a.innerText?.trim().split('\\n')[0] || '' }))
+          .filter(s => s.url && !s.url.includes('gemini.google') && !s.url.includes('gstatic') && !s.url.includes('google.com/search'))
+          .filter((v, i, arr) => arr.findIndex(x => x.url === v.url) === i)
+          .slice(0, 8);
+        return JSON.stringify(links);
+      }
+      // Fallback: inline source cards with aria-labels
+      var cards = Array.from(document.querySelectorAll('button[aria-label*="citation from"]'));
+      if (cards.length) {
+        return JSON.stringify(cards.map(b => {
+          var label = b.getAttribute('aria-label') || '';
+          var name = label.match(/from\\s+(.+?)\\.\\s/)?.[1] || label;
+          return { url: '', title: name };
+        }));
+      }
+      // Last resort: page-wide links (may include footer junk)
+      return JSON.stringify(Array.from(document.querySelectorAll('a[href^="http"]'))
         .map(a => ({ url: a.href.split('#')[0], title: a.innerText?.trim().split('\\n')[0] || '' }))
         .filter(s => s.url && !s.url.includes('gemini.google') && !s.url.includes('gstatic') && !s.url.includes('google.com/search'))
         .filter((v, i, arr) => arr.findIndex(x => x.url === v.url) === i)
-        .slice(0, 8);
-      return JSON.stringify(sources);
+        .slice(0, 8));
     })()
   `]).catch(() => '[]');
   const sources = JSON.parse(raw);

package/index.ts

@@ -22,7 +22,7 @@ function cdpAvailable(): boolean {
 
 function runSearch(engine: string, query: string, flags: string[] = []): Promise<Record<string, unknown>> {
 	return new Promise((resolve, reject) => {
-		const proc = spawn("node", [__dir + "/search.mjs", engine, ...flags, query], {
+		const proc = spawn("node", [__dir + "/search.mjs", engine, "--inline", ...flags, query], {
 			stdio: ["ignore", "pipe", "pipe"],
 		});
 		let out = "";
@@ -137,9 +137,13 @@ export default function greedySearchExtension(pi: ExtensionAPI) {
 				description: 'When true and engine is "all", deduplicates sources across engines and feeds them to Gemini for a single grounded synthesis. Adds ~30s but saves tokens and improves answer quality.',
 				default: false,
 			})),
+			fullAnswer: Type.Optional(Type.Boolean({
+				description: 'When true, returns the complete answer instead of a truncated preview (default: false, answers are shortened to ~300 chars to save tokens).',
+				default: false,
+			})),
 		}),
 		execute: async (_toolCallId, params) => {
-			const { query, engine = "all", synthesize = false } = params as { query: string; engine: string; synthesize?: boolean };
+			const { query, engine = "all", synthesize = false, fullAnswer = false } = params as { query: string; engine: string; synthesize?: boolean; fullAnswer?: boolean };
 
 			if (!cdpAvailable()) {
 				return {
@@ -150,6 +154,7 @@ export default function greedySearchExtension(pi: ExtensionAPI) {
 
 			const flags: string[] = [];
 			if (synthesize && engine === "all") flags.push("--synthesize");
+			if (fullAnswer) flags.push("--full");
 
 			let data: Record<string, unknown>;
 			try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apmantza/greedysearch-pi",
-  "version": "1.0.24",
+  "version": "1.1.1",
   "description": "Pi extension: search Perplexity, Bing Copilot, and Google AI in parallel with optional Gemini synthesis — grounded AI answers, not just links",
   "type": "module",
   "keywords": [

package/search.mjs

@@ -41,6 +41,8 @@ const ENGINES = {
   b:          'bing-copilot.mjs',
   google:     'google-ai.mjs',
   g:          'google-ai.mjs',
+  gemini:     'gemini.mjs',
+  gem:        'gemini.mjs',
   stackoverflow: 'stackoverflow-ai.mjs',
   so:         'stackoverflow-ai.mjs',
   stack:      'stackoverflow-ai.mjs',
@@ -52,6 +54,7 @@ const ENGINE_DOMAINS = {
   perplexity: 'perplexity.ai',
   bing:       'copilot.microsoft.com',
   google:     'google.com',
+  gemini:     'gemini.google.com',
   stackoverflow: 'stackoverflow.com',
 };
 

package/skills/greedy-search/SKILL.md

@@ -1,38 +1,72 @@
----
-name: greedy-search
-description: Multi-engine AI web search — Perplexity, Bing Copilot, Google AI in parallel. Use for current library docs, error messages, version diffs, and any research where training data may be stale.
----
-
-# Greedy Search Skill
-
-Use the `greedy_search` tool when you need current information from the web.
-
-## When to Use
-
-- Questions about libraries, APIs, or frameworks — especially version-specific
-- User pastes an error message or stack trace
-- Question contains "latest", "current", "2025", "2026", "deprecated", "still recommended"
-- Choosing between dependencies or tools
-- Architecture validation or best-practice confirmation
-- Any research question where training data may be stale
-
-## How to Use
-
-Call `greedy_search` with the user's question as `query`. Use `engine: "all"` (default) to fan out to all three engines in parallel for the highest-confidence answer.
-
-```
-greedy_search({ query: "how to use X in Y version", engine: "all" })
-```
-
-For quick lookups where one source is sufficient:
-- `engine: "perplexity"` — best for technical Q&A
-- `engine: "bing"` — best for recent news and Microsoft ecosystem
-- `engine: "google"` — best for broad coverage
-
-## Interpreting Results
-
-Each engine returns an AI-synthesized answer plus sources. Where all three agree, confidence is high. Where they diverge, present both perspectives to the user.
-
-## Requirements
-
-Chrome must be running. The extension auto-launches a dedicated GreedySearch Chrome instance if needed (via `launch.mjs`).
+---
+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.
+---
+
+# Greedy Search
+
+Use `greedy_search` when you need high-quality, multi-perspective answers from the web.
+
+## Greedy Search vs Built-in Web Search
+
+| | `web_search` | `greedy_search` |
+|---|---|---|
+| Speed | Instant (~2s) | 15-60s (one engine) / 30-90s (all engines) |
+| Quality | Good for simple lookups | Higher — 3 AI engines cross-verify |
+| Synthesis | Single engine answer | Optional Gemini synthesis (cleanest answer) |
+| Use for | Quick facts, simple questions | Research, decisions, complex topics |
+
+**Rule of thumb:** Use `web_search` for quick facts. Use `greedy_search` when the answer matters — architecture decisions, comparing libraries, understanding new releases, debugging tricky errors.
+
+## When to Use
+
+- **Version-specific changes** — "What changed in React 19?" / "Breaking changes in FastAPI 0.100"
+- **Choosing between tools** — "Prisma vs Drizzle in 2026" / "Best auth library for Next.js 15"
+- **Debugging** — User pastes an error message or stack trace
+- **Research tasks** — When you need to synthesize information from multiple sources
+- **Best practices** — "How to structure a monorepo" / "Auth patterns for SaaS"
+- **Anything where training data might be stale** — 2025+, 2026+, "latest", "current", "still maintained"
+
+## Engine Selection
+
+```greedy_search({ query: "what changed in React 19", engine: "all" })```
+
+| Engine | Latency | Best for |
+|---|---|---|
+| `all` (default) | 30-90s | Highest confidence — all 3 engines in parallel |
+| `perplexity` | 15-30s | Technical Q&A, code explanations, documentation |
+| `bing` | 15-30s | Recent news, Microsoft ecosystem |
+| `google` | 15-30s | Broad coverage, multiple perspectives |
+| `gemini` | 15-30s | Google's perspective, different training data |
+
+Use a single engine when speed matters and the question isn't contentious.
+
+## Synthesis Mode
+
+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 — ideal for research tasks where you'd otherwise need to parse 3 separate answers.
+
+Use synthesis when:
+- You need one definitive answer, not multiple perspectives
+- You're researching a topic to write about or make a decision
+- The question has a lot of noise and you want the signal
+
+Skip synthesis when:
+- You want to see where engines disagree (useful for controversial topics)
+- Speed matters
+
+## Full vs Short Answers
+
+Default mode returns ~300 char summaries to save tokens. Use `fullAnswer: true` when you need the complete response:
+
+```greedy_search({ query: "explain the React compiler", engine: "perplexity", fullAnswer: true })```
+
+## Interpreting Results
+
+- **All 3 agree** → High confidence, present as fact
+- **2 agree, 1 differs** → Likely correct but note the dissent
+- **All differ** → Present the different perspectives to the user
+- **Sources with `[3/3]` or `[2/3]`** → Cited by multiple engines, higher confidence