@apmantza/greedysearch-pi 1.0.0

package/index.ts

@@ -0,0 +1,145 @@
+/**
+ * GreedySearch Pi Extension
+ *
+ * Adds a `greedy_search` tool to Pi that fans out queries to Perplexity,
+ * Bing Copilot, and Google AI in parallel, returning synthesized AI answers.
+ *
+ * Requires Chrome to be running (or it auto-launches a dedicated instance).
+ */
+
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+
+const __dir = dirname(fileURLToPath(import.meta.url));
+
+function cdpAvailable(): boolean {
+	return existsSync(join(__dir, "cdp.mjs"));
+}
+
+function runSearch(engine: string, query: string): Promise<Record<string, unknown>> {
+	return new Promise((resolve, reject) => {
+		const proc = spawn("node", [__dir + "/search.mjs", engine, query], {
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+		let out = "";
+		let err = "";
+		proc.stdout.on("data", (d: Buffer) => (out += d));
+		proc.stderr.on("data", (d: Buffer) => (err += d));
+		proc.on("close", (code: number) => {
+			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)}`));
+				}
+			}
+		});
+	});
+}
+
+function formatResults(engine: string, data: Record<string, unknown>): string {
+	const lines: string[] = [];
+
+	if (engine === "all") {
+		for (const [eng, result] of Object.entries(data)) {
+			if (eng.startsWith("_")) continue;
+			lines.push(`\n## ${eng.charAt(0).toUpperCase() + eng.slice(1)}`);
+			const r = result as Record<string, unknown>;
+			if (r.error) {
+				lines.push(`Error: ${r.error}`);
+			} else {
+				if (r.answer) lines.push(String(r.answer));
+				if (Array.isArray(r.sources) && r.sources.length > 0) {
+					lines.push("\nSources:");
+					for (const s of r.sources.slice(0, 3)) {
+						const src = s as Record<string, string>;
+						lines.push(`- [${src.title || src.url}](${src.url})`);
+					}
+				}
+			}
+		}
+	} else {
+		if (data.error) {
+			lines.push(`Error: ${data.error}`);
+		} else {
+			if (data.answer) lines.push(String(data.answer));
+			if (Array.isArray(data.sources) && data.sources.length > 0) {
+				lines.push("\nSources:");
+				for (const s of data.sources.slice(0, 5)) {
+					const src = s as Record<string, string>;
+					lines.push(`- [${src.title || src.url}](${src.url})`);
+				}
+			}
+		}
+	}
+
+	return lines.join("\n").trim();
+}
+
+export default function greedySearchExtension(pi: ExtensionAPI) {
+	pi.on("session_start", async (_event, ctx) => {
+		if (!cdpAvailable()) {
+			ctx.ui.notify(
+				"GreedySearch: cdp.mjs missing from package directory — try reinstalling: pi install git:github.com/apmantza/GreedySearch-pi",
+				"warning",
+			);
+		}
+	});
+
+	pi.registerTool({
+		name: "greedy_search",
+		label: "Greedy Search",
+		description:
+			"Search the web using AI-powered engines (Perplexity, Bing Copilot, Google AI) in parallel. " +
+			"Returns synthesized AI answers with sources. Use for current information, library docs, " +
+			"error messages, best practices, or any question where training data may be stale.",
+		parameters: Type.Object({
+			query: Type.String({ description: "The search query" }),
+			engine: Type.Union(
+				[
+					Type.Literal("all"),
+					Type.Literal("perplexity"),
+					Type.Literal("bing"),
+					Type.Literal("google"),
+				],
+				{
+					description: 'Engine to use. "all" fans out to all three in parallel (default).',
+					default: "all",
+				},
+			),
+		}),
+		execute: async (_toolCallId, params) => {
+			const { query, engine = "all" } = params as { query: string; engine: string };
+
+			if (!cdpAvailable()) {
+				return {
+					content: [{ type: "text", text: "cdp.mjs missing — try reinstalling: pi install git:github.com/apmantza/GreedySearch-pi" }],
+					details: {} as { raw?: Record<string, unknown> },
+				};
+			}
+
+			let data: Record<string, unknown>;
+			try {
+				data = await runSearch(engine, query);
+			} catch (e) {
+				const msg = e instanceof Error ? e.message : String(e);
+				return {
+					content: [{ type: "text", text: `Search failed: ${msg}` }],
+					details: {} as { raw?: Record<string, unknown> },
+				};
+			}
+
+			const text = formatResults(engine, data);
+			return {
+				content: [{ type: "text", text: text || "No results returned." }],
+				details: { raw: data } as { raw?: Record<string, unknown> },
+			};
+		},
+	});
+}

package/launch.mjs

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+// launch.mjs — start a dedicated Chrome instance for GreedySearch
+//
+// This Chrome instance uses --disable-features=DevToolsPrivacyUI which suppresses
+// the "Allow remote debugging?" dialog entirely. It runs on port 9223 so it doesn't
+// conflict with your main Chrome session.
+//
+// On launch, it overwrites the DevToolsActivePort file that cdp.mjs reads so all
+// extractors automatically target the GreedySearch Chrome, with no code changes.
+// The original file is restored on --kill.
+//
+// Usage:
+//   node launch.mjs          — launch (or report if already running)
+//   node launch.mjs --kill   — stop and restore original DevToolsActivePort
+//   node launch.mjs --status — check if running
+
+import { spawn } from 'child_process';
+import { existsSync, writeFileSync, readFileSync, copyFileSync, mkdirSync, unlinkSync } from 'fs';
+import { tmpdir, homedir, platform } from 'os';
+import { join } from 'path';
+import http from 'http';
+
+const PORT        = 9223;
+const PROFILE_DIR = join(tmpdir(), 'greedysearch-chrome-profile');
+const ACTIVE_PORT = join(PROFILE_DIR, 'DevToolsActivePort');
+const PID_FILE    = join(tmpdir(), 'greedysearch-chrome.pid');
+
+function findChrome() {
+  const os = platform();
+  const candidates = os === 'win32' ? [
+    'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
+    'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
+  ] : os === 'darwin' ? [
+    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+    '/Applications/Chromium.app/Contents/MacOS/Chromium',
+  ] : [
+    '/usr/bin/google-chrome',
+    '/usr/bin/google-chrome-stable',
+    '/usr/bin/chromium-browser',
+    '/usr/bin/chromium',
+    '/snap/bin/chromium',
+  ];
+  return candidates.find(existsSync) || null;
+}
+
+function systemPortPath() {
+  const os = platform();
+  if (os === 'win32') return join(homedir(), 'AppData', 'Local', 'Google', 'Chrome', 'User Data', 'DevToolsActivePort');
+  if (os === 'darwin') return join(homedir(), 'Library', 'Application Support', 'Google', 'Chrome', 'DevToolsActivePort');
+  return join(homedir(), '.config', 'google-chrome', 'DevToolsActivePort');
+}
+
+const SYSTEM_PORT   = systemPortPath();
+const SYSTEM_BACKUP = SYSTEM_PORT + '.bak';
+
+const CHROME_FLAGS = [
+  `--remote-debugging-port=${PORT}`,
+  '--disable-features=DevToolsPrivacyUI',      // suppresses "Allow remote debugging?" dialog
+  '--no-first-run',
+  '--no-default-browser-check',
+  '--disable-default-apps',
+  `--user-data-dir=${PROFILE_DIR}`,
+  '--profile-directory=Default',
+  'about:blank',
+];
+
+// ---------------------------------------------------------------------------
+
+
+function isRunning() {
+  if (!existsSync(PID_FILE)) return false;
+  const pid = parseInt(readFileSync(PID_FILE, 'utf8').trim());
+  if (!pid) return false;
+  try { process.kill(pid, 0); return pid; } catch { return false; }
+}
+
+function httpGet(url, timeoutMs = 1000) {
+  return new Promise(resolve => {
+    const req = http.get(url, res => {
+      let body = '';
+      res.on('data', d => body += d);
+      res.on('end', () => resolve({ ok: res.statusCode === 200, body }));
+    });
+    req.on('error', () => resolve({ ok: false }));
+    req.setTimeout(timeoutMs, () => { req.destroy(); resolve({ ok: false }); });
+  });
+}
+
+
+async function writePortFile(timeoutMs = 15000) {
+  // Chrome on Windows doesn't write DevToolsActivePort — we build it from the HTTP API.
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const { ok, body } = await httpGet(`http://localhost:${PORT}/json/version`, 1500);
+    if (ok) {
+      try {
+        const { webSocketDebuggerUrl } = JSON.parse(body);
+        // webSocketDebuggerUrl = "ws://localhost:9223/devtools/browser/..."
+        const wsPath = new URL(webSocketDebuggerUrl).pathname;
+        // Write in DevToolsActivePort format: port on line 1, path on line 2
+        const content = `${PORT}\n${wsPath}`;
+        writeFileSync(ACTIVE_PORT, content, 'utf8');
+        return true;
+      } catch { /* malformed response, retry */ }
+    }
+    await new Promise(r => setTimeout(r, 400));
+  }
+  return false;
+}
+
+function redirectCdpToGreedySearch() {
+  // Back up system DevToolsActivePort (user's main Chrome)
+  if (existsSync(SYSTEM_PORT) && !existsSync(SYSTEM_BACKUP)) {
+    copyFileSync(SYSTEM_PORT, SYSTEM_BACKUP);
+  }
+  // Point cdp.mjs to our dedicated Chrome's port
+  copyFileSync(ACTIVE_PORT, SYSTEM_PORT);
+}
+
+function restoreCdpToMainChrome() {
+  if (existsSync(SYSTEM_BACKUP)) {
+    copyFileSync(SYSTEM_BACKUP, SYSTEM_PORT);
+    console.log('Restored DevToolsActivePort to main Chrome.');
+  } else if (existsSync(SYSTEM_PORT)) {
+    // No backup means main Chrome wasn't using CDP — remove our file
+    try { unlinkSync(SYSTEM_PORT); } catch {}
+  }
+}
+
+// ---------------------------------------------------------------------------
+
+async function main() {
+  const arg = process.argv[2];
+
+  if (arg === '--kill') {
+    const pid = isRunning();
+    if (pid) {
+      try { process.kill(pid, 'SIGTERM'); console.log(`Stopped Chrome (pid ${pid}).`); }
+      catch (e) { console.error(`Failed: ${e.message}`); }
+    } else {
+      console.log('GreedySearch Chrome is not running.');
+    }
+    restoreCdpToMainChrome();
+    return;
+  }
+
+  if (arg === '--status') {
+    const pid = isRunning();
+    if (pid) console.log(`Running — pid ${pid}, port ${PORT}, DevToolsActivePort redirected.`);
+    else      console.log('Not running.');
+    return;
+  }
+
+  // Already running?
+  const existing = isRunning();
+  if (existing) {
+    console.log(`GreedySearch Chrome already running (pid ${existing}, port ${PORT}).`);
+    // Ensure redirect is in place (idempotent)
+    const ready = await writePortFile(5000);
+    if (ready) { redirectCdpToGreedySearch(); console.log('DevToolsActivePort redirected.'); }
+    return;
+  }
+
+  const CHROME_EXE = process.env.CHROME_PATH || findChrome();
+  if (!CHROME_EXE) {
+    console.error('Chrome not found. Tried standard paths for your OS.');
+    console.error('Set the CHROME_PATH environment variable to point to your Chrome binary.');
+    process.exit(1);
+  }
+
+  mkdirSync(PROFILE_DIR, { recursive: true });
+
+  console.log(`Launching GreedySearch Chrome on port ${PORT}...`);
+  const proc = spawn(CHROME_EXE, CHROME_FLAGS, {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: false,
+  });
+  proc.unref();
+  writeFileSync(PID_FILE, String(proc.pid));
+
+  // Wait for Chrome HTTP endpoint, build DevToolsActivePort file, redirect cdp.mjs
+  const portFileReady = await writePortFile();
+  if (!portFileReady) {
+    console.error('Chrome did not become ready within 15s.');
+    process.exit(1);
+  }
+  redirectCdpToGreedySearch();
+
+  console.log(`Ready. No more "Allow remote debugging?" dialogs.`);
+  console.log(`Run "node launch.mjs --kill" when done to restore your main Chrome's CDP.`);
+}
+
+main();

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@apmantza/greedysearch-pi",
+  "version": "1.0.0",
+  "description": "Pi extension: search Perplexity, Bing Copilot, and Google AI simultaneously — synthesized AI answers, not just links",
+  "type": "module",
+  "keywords": [
+    "pi-package"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/apmantza/GreedySearch-pi"
+  },
+  "license": "MIT",
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": "*",
+    "@sinclair/typebox": "*"
+  }
+}

package/search.mjs

@@ -0,0 +1,297 @@
+#!/usr/bin/env node
+// search.mjs — unified CLI for GreedySearch extractors
+//
+// Usage:
+//   node search.mjs <engine> "<query>"
+//   node search.mjs all "<query>"
+//
+// Engines:
+//   perplexity | pplx | p
+//   bing       | copilot | b
+//   google     | g
+//   stackoverflow | so | stack
+//   all        — fan-out to all engines in parallel
+//
+// Output: JSON to stdout, errors to stderr
+//
+// Examples:
+//   node search.mjs p "what is memoization"
+//   node search.mjs so "node.js event loop explained"
+//   node search.mjs all "how does TCP congestion control work"
+
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { join, dirname } from 'path';
+import { readFileSync, existsSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+
+const __dir = dirname(fileURLToPath(import.meta.url));
+// Pi installs chrome-cdp-skill to ~/.pi/agent/git/...; fall back to Claude Code path
+// Always use the bundled Windows-compatible cdp.mjs
+const CDP = join(__dir, 'cdp.mjs');
+const PAGES_CACHE = `${tmpdir().replace(/\\/g, '/')}/cdp-pages.json`;
+
+const ENGINES = {
+  perplexity: 'perplexity.mjs',
+  pplx:       'perplexity.mjs',
+  p:          'perplexity.mjs',
+  bing:       'bing-copilot.mjs',
+  copilot:    'bing-copilot.mjs',
+  b:          'bing-copilot.mjs',
+  google:     'google-ai.mjs',
+  g:          'google-ai.mjs',
+  stackoverflow: 'stackoverflow-ai.mjs',
+  so:         'stackoverflow-ai.mjs',
+  stack:      'stackoverflow-ai.mjs',
+};
+
+const ALL_ENGINES = ['perplexity', 'bing', 'google']; // stackoverflow: disabled until polling fix
+
+const ENGINE_DOMAINS = {
+  perplexity: 'perplexity.ai',
+  bing:       'copilot.microsoft.com',
+  google:     'google.com',
+  stackoverflow: 'stackoverflow.com',
+};
+
+function getTabFromCache(engine) {
+  try {
+    if (!existsSync(PAGES_CACHE)) return null;
+    const pages = JSON.parse(readFileSync(PAGES_CACHE, 'utf8'));
+    const found = pages.find(p => p.url.includes(ENGINE_DOMAINS[engine]));
+    return found ? found.targetId.slice(0, 8) : null;
+  } catch { return null; }
+}
+
+function cdp(args, timeoutMs = 15000) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('node', [CDP, ...args], { stdio: ['ignore', 'pipe', 'pipe'] });
+    let out = '', err = '';
+    proc.stdout.on('data', d => out += d);
+    proc.stderr.on('data', d => err += d);
+    const t = setTimeout(() => { proc.kill(); reject(new Error(`cdp timeout: ${args[0]}`)); }, timeoutMs);
+    proc.on('close', code => {
+      clearTimeout(t);
+      if (code !== 0) reject(new Error(err.trim() || `cdp exit ${code}`));
+      else resolve(out.trim());
+    });
+  });
+}
+
+async function getAnyTab() {
+  const list = await cdp(['list']);
+  const first = list.split('\n')[0];
+  if (!first) throw new Error('No Chrome tabs found');
+  return first.slice(0, 8);
+}
+
+async function getOrReuseBlankTab() {
+  // Reuse an existing about:blank tab rather than always creating a new one
+  const listOut = await cdp(['list']);
+  const lines = listOut.split('\n').filter(Boolean);
+  for (const line of lines) {
+    if (line.includes('about:blank')) {
+      return line.slice(0, 8); // prefix of the blank tab's targetId
+    }
+  }
+  // No blank tab — open a new one
+  const anchor = await getAnyTab();
+  const raw = await cdp(['evalraw', anchor, 'Target.createTarget', '{"url":"about:blank"}']);
+  const { targetId } = JSON.parse(raw);
+  return targetId;
+}
+
+async function openNewTab() {
+  const anchor = await getAnyTab();
+  const raw = await cdp(['evalraw', anchor, 'Target.createTarget', '{"url":"about:blank"}']);
+  const { targetId } = JSON.parse(raw);
+  return targetId;
+}
+
+async function closeTab(targetId) {
+  try {
+    const anchor = await getAnyTab();
+    await cdp(['evalraw', anchor, 'Target.closeTarget', JSON.stringify({ targetId })]);
+  } catch { /* best-effort */ }
+}
+
+function runExtractor(script, query, tabPrefix = null, short = false) {
+  const extraArgs = [
+    ...(tabPrefix ? ['--tab', tabPrefix] : []),
+    ...(short    ? ['--short']          : []),
+  ];
+  return new Promise((resolve, reject) => {
+    const proc = spawn('node', [join(__dir, 'extractors', script), query, ...extraArgs], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let out = '';
+    let err = '';
+    proc.stdout.on('data', d => out += d);
+    proc.stderr.on('data', d => err += d);
+    proc.on('close', code => {
+      if (code !== 0) reject(new Error(err.trim() || `extractor exit ${code}`));
+      else {
+        try { resolve(JSON.parse(out.trim())); }
+        catch { reject(new Error(`bad JSON from ${script}: ${out.slice(0, 100)}`)); }
+      }
+    });
+  });
+}
+
+
+async function fetchTopSource(url) {
+  const tab = await openNewTab();
+  await cdp(['list']); // refresh cache so the new tab is findable
+  try {
+    await cdp(['nav', tab, url], 30000);
+    await new Promise(r => setTimeout(r, 1500));
+    const content = await cdp(['eval', tab, `
+      (function(){
+        var el = document.querySelector('article, [role="main"], main, .post-content, .article-body, #content, .content');
+        var text = (el || document.body).innerText;
+        return text.replace(/\\s+/g, ' ').trim().slice(0, 1500);
+      })()
+    `]);
+    return { url, content };
+  } catch (e) {
+    return { url, content: null, error: e.message };
+  } finally {
+    await closeTab(tab);
+  }
+}
+
+function pickTopSource(out) {
+  for (const engine of ['perplexity', 'google', 'bing']) {
+    const r = out[engine];
+    if (r?.sources?.length > 0) return r.sources[0];
+  }
+  return null;
+}
+
+function writeOutput(data, outFile) {
+  const json = JSON.stringify(data, null, 2) + '\n';
+  if (outFile) {
+    writeFileSync(outFile, json, 'utf8');
+    process.stderr.write(`Results written to ${outFile}\n`);
+  } else {
+    process.stdout.write(json);
+  }
+}
+
+async function ensureChrome() {
+  try {
+    await cdp(['list'], 3000);
+  } catch {
+    process.stderr.write('Chrome not running — auto-launching GreedySearch Chrome...\n');
+    await new Promise((resolve, reject) => {
+      const proc = spawn('node', [join(__dir, 'launch.mjs')], { stdio: 'inherit' });
+      proc.on('close', code => code === 0 ? resolve() : reject(new Error('launch.mjs failed')));
+    });
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length < 2 || args[0] === '--help') {
+    process.stderr.write([
+      'Usage: node search.mjs <engine> "<query>"',
+      '',
+      'Engines: perplexity (p), bing (b), google (g), stackoverflow (so), all',
+      '',
+      'Examples:',
+      '  node search.mjs p "what is memoization"',
+      '  node search.mjs so "node.js event loop explained"',
+      '  node search.mjs all "TCP congestion control"',
+    ].join('\n') + '\n');
+    process.exit(1);
+  }
+
+  await ensureChrome();
+
+  const short       = args.includes('--short');
+  const fetchSource = args.includes('--fetch-top-source');
+  const outIdx      = args.indexOf('--out');
+  const outFile     = outIdx !== -1 ? args[outIdx + 1] : null;
+  const rest        = args.filter((a, i) =>
+    a !== '--short' &&
+    a !== '--fetch-top-source' &&
+    a !== '--out' &&
+    (outIdx === -1 || i !== outIdx + 1)
+  );
+  const engine = rest[0].toLowerCase();
+  const query  = rest.slice(1).join(' ');
+
+  if (engine === 'all') {
+    await cdp(['list']); // refresh pages cache
+
+    // Assign tabs: reuse existing engine tabs from cache, open new ones only where needed.
+    // Track opened tabs separately so we only close what we created.
+    const tabs = [];
+    const openedTabs = [];
+    let blankReused = false;
+
+    for (const e of ALL_ENGINES) {
+      const existing = getTabFromCache(e);
+      if (existing) {
+        tabs.push(existing);
+      } else if (!blankReused) {
+        const tab = await getOrReuseBlankTab();
+        tabs.push(tab);
+        openedTabs.push(tab);
+        blankReused = true;
+      } else {
+        await new Promise(r => setTimeout(r, 500));
+        const tab = await openNewTab();
+        tabs.push(tab);
+        openedTabs.push(tab);
+      }
+    }
+
+    // All tabs assigned — run extractors in parallel
+    const results = await Promise.allSettled(
+      ALL_ENGINES.map((e, i) =>
+        runExtractor(ENGINES[e], query, tabs[i], short).then(r => ({ engine: e, ...r }))
+      )
+    );
+
+    // Close only tabs we opened (not pre-existing ones)
+    await Promise.allSettled(openedTabs.map(closeTab));
+
+    const out = {};
+    for (let i = 0; i < results.length; i++) {
+      const r = results[i];
+      if (r.status === 'fulfilled') {
+        out[r.value.engine] = r.value;
+      } else {
+        out[ALL_ENGINES[i]] = { error: r.reason?.message || 'unknown error' };
+      }
+    }
+
+    if (fetchSource) {
+      const top = pickTopSource(out);
+      if (top) out._topSource = await fetchTopSource(top.url);
+    }
+
+    writeOutput(out, outFile);
+    return;
+  }
+
+  const script = ENGINES[engine];
+  if (!script) {
+    process.stderr.write(`Unknown engine: "${engine}"\nAvailable: ${Object.keys(ENGINES).join(', ')}\n`);
+    process.exit(1);
+  }
+
+  try {
+    const result = await runExtractor(script, query, null, short);
+    if (fetchSource && result.sources?.length > 0) {
+      result.topSource = await fetchTopSource(result.sources[0].url);
+    }
+    writeOutput(result, outFile);
+  } catch (e) {
+    process.stderr.write(`Error: ${e.message}\n`);
+    process.exit(1);
+  }
+}
+
+main();