npm - @apmantza/greedysearch-pi - Versions diffs - 1.1.0 → 1.1.2 - Mend

@apmantza/greedysearch-pi 1.1.0 → 1.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/index.ts +222 -177
package/package.json +1 -1
package/results/2026-03-21_11-35-35_test-query-for-file-writing.json +6 -0
package/search.mjs +11 -1
package/skills/greedy-search/SKILL.md +72 -38

package/index.ts CHANGED Viewed

@@ -1,177 +1,222 @@
-/**
- * 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, flags: string[] = []): Promise<Record<string, unknown>> {
-	return new Promise((resolve, reject) => {
-		const proc = spawn("node", [__dir + "/search.mjs", engine, "--inline", ...flags, 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") {
-		// 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*");
-			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)}`);
-			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. " +
-			"Optionally synthesize results with Gemini — deduplicates sources by consensus and returns one grounded answer. " +
-			"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"),
-					Type.Literal("gemini"),
-					Type.Literal("gem"),
-				],
-				{
-					description: 'Engine to use. "all" fans out to Perplexity, Bing, and Google in parallel (default).',
-					default: "all",
-				},
-			),
-			synthesize: Type.Optional(Type.Boolean({
-				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, fullAnswer = false } = params as { query: string; engine: string; synthesize?: boolean; fullAnswer?: boolean };
-			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> },
-				};
-			}
-			const flags: string[] = [];
-			if (synthesize && engine === "all") flags.push("--synthesize");
-			if (fullAnswer) flags.push("--full");
-			let data: Record<string, unknown>;
-			try {
-				data = await runSearch(engine, query, flags);
-			} 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> },
-			};
-		},
-	});
-}
+/**
+ * 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.
+ *
+ * Reports streaming progress as each engine completes.
+ * 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));
+const ALL_ENGINES = ["perplexity", "bing", "google"] as const;
+function cdpAvailable(): boolean {
+	return existsSync(join(__dir, "cdp.mjs"));
+}
+function runSearch(
+	engine: string,
+	query: string,
+	flags: string[] = [],
+	signal?: AbortSignal,
+	onProgress?: (engine: string, status: "done" | "error") => void,
+): Promise<Record<string, unknown>> {
+	return new Promise((resolve, reject) => {
+		const proc = spawn("node", [__dir + "/search.mjs", engine, "--inline", ...flags, query], {
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+		let out = "";
+		let err = "";
+		const onAbort = () => { proc.kill("SIGTERM"); reject(new Error("Aborted")); };
+		signal?.addEventListener("abort", onAbort, { once: true });
+		// Watch stderr for progress events (PROGRESS:engine:done|error)
+		proc.stderr.on("data", (d: Buffer) => {
+			err += d;
+			const lines = d.toString().split("\n");
+			for (const line of lines) {
+				const match = line.match(/^PROGRESS:(\w+):(done|error)$/);
+				if (match && onProgress) {
+					onProgress(match[1], match[2] as "done" | "error");
+				}
+			}
+		});
+		proc.stdout.on("data", (d: Buffer) => (out += d));
+		proc.on("close", (code: number) => {
+			signal?.removeEventListener("abort", onAbort);
+			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") {
+		// 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*");
+			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)}`);
+			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. " +
+			"Optionally synthesize results with Gemini — deduplicates sources by consensus and returns one grounded answer. " +
+			"Reports streaming progress as each engine completes. " +
+			"Use for current information, library docs, error messages, best practices, or any question where training data may be stale.",
+		promptSnippet: "Multi-engine AI web search with streaming progress",
+		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"),
+					Type.Literal("gemini"),
+					Type.Literal("gem"),
+				],
+				{
+					description: 'Engine to use. "all" fans out to Perplexity, Bing, and Google in parallel (default).',
+					default: "all",
+				},
+			),
+			synthesize: Type.Optional(Type.Boolean({
+				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, signal, onUpdate) => {
+			const { query, engine = "all", synthesize = false, fullAnswer = false } = params as {
+				query: string; engine: string; synthesize?: boolean; fullAnswer?: boolean;
+			};
+			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> },
+				};
+			}
+			const flags: string[] = [];
+			if (fullAnswer) flags.push("--full");
+			if (synthesize && engine === "all") flags.push("--synthesize");
+			// Track progress for "all" engine mode
+			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} done`);
+					else parts.push(`⏳ ${e}`);
+				}
+				if (synthesize && completed.size >= 3) parts.push("🔄 synthesizing");
+				onUpdate?.({
+					content: [{ type: "text", text: `**Searching...** ${parts.join(" · ")}` }],
+					details: { _progress: true },
+				} as any);
+			};
+			try {
+				const data = await runSearch(engine, query, flags, signal, engine === "all" ? onProgress : undefined);
+				const text = formatResults(engine, 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: `Search failed: ${msg}` }],
+					details: {} as { raw?: Record<string, unknown> },
+				};
+			}
+		},
+	});
+}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@apmantza/greedysearch-pi",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "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/results/2026-03-21_11-35-35_test-query-for-file-writing.json ADDED Viewed

@@ -0,0 +1,6 @@
+{
+  "query": "test query for file writing",
+  "url": "https://www.perplexity.ai/search/test-query-for-file-writing-.FobTp2uSWSg70txH6RthQ",
+  "answer": "This message is just a test query and does not trigger any actual file‑writing action on your system.  \n\nIf you want, you can describe what kind of file you’d like to write (for example: a text file, Python script, CSV, etc.), and I can give you a concrete example in code that you can run…",
+  "sources": []
+}

package/search.mjs CHANGED Viewed

@@ -405,7 +405,15 @@ async function main() {
     // 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 }))
+        runExtractor(ENGINES[e], query, tabs[i], short)
+          .then(r => {
+            process.stderr.write(`PROGRESS:${e}:done\n`);
+            return { engine: e, ...r };
+          })
+          .catch(err => {
+            process.stderr.write(`PROGRESS:${e}:error\n`);
+            throw err;
+          })
       )
     );
@@ -424,6 +432,7 @@ async function main() {
     // Synthesize with Gemini if requested
     if (synthesize) {
+      process.stderr.write('PROGRESS:synthesis:start\n');
       process.stderr.write('[greedysearch] Synthesizing results with Gemini...\n');
       try {
         const synthesis = await synthesizeWithGemini(query, out);
@@ -432,6 +441,7 @@ async function main() {
           sources: synthesis.sources || [],
           synthesized: true,
         };
+        process.stderr.write('PROGRESS:synthesis:done\n');
       } catch (e) {
         process.stderr.write(`[greedysearch] Synthesis failed: ${e.message}\n`);
         out._synthesis = { error: e.message, synthesized: false };

package/skills/greedy-search/SKILL.md CHANGED Viewed

@@ -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