@apmantza/greedysearch-pi 1.9.2 → 2.0.0

package/src/types.ts

@@ -1,104 +1,110 @@
-/**
- * TypeScript interfaces for GreedySearch data structures
- *
- * These types document the shape of data flowing between modules.
- * They can be imported by TypeScript files (index.ts, tool handlers, formatters)
- * and used for type safety without runtime overhead.
- */
-
-// ============================================================================
-// Search Result Types
-// ============================================================================
-
-/** A single source extracted from search results */
-export interface Source {
-	url: string;
-	title: string;
-	type?: "official-docs" | "maintainer-blog" | "repo" | "community" | "website";
-	domain?: string;
-	snippet?: string;
-}
-
-/** Result from a single search engine */
-export interface SearchResult {
-	engine: string;
-	answer: string;
-	sources: Source[];
-	url?: string;
-	query?: string;
-	error?: string;
-}
-
-/** Synthesis result combining multiple engine results */
-export interface SynthesisResult {
-	answer: string;
-	agreementLevel?: "consensus" | "majority" | "mixed" | "conflicting";
-	claims?: Claim[];
-	sourceIds?: string[];
-	confidence?: ConfidenceMetrics;
-}
-
-/** A single claim within a synthesis */
-export interface Claim {
-	text: string;
-	sourceIds: string[];
-	confidence?: "high" | "medium" | "low";
-}
-
-/** Confidence metrics for a synthesis */
-export interface ConfidenceMetrics {
-	overall: number;        // 0-1
-	consensus: number;      // fraction of engines agreeing
-	sourceCount: number;
-	engineCount: number;
-}
-
-// ============================================================================
-// Source Registry Types
-// ============================================================================
-
-/** A classified source in the registry */
-export interface ClassifiedSource extends Source {
-	engineOrigin: string[];
-	isOfficial: boolean;
-	consensus: number;  // fraction of engines citing this source
-}
-
-// ============================================================================
-// Tool Result Types
-// ============================================================================
-
-/** Progress update sent via onUpdate during long-running searches */
-export interface ProgressUpdate {
-	content: Array<{ type: "text"; text: string }>;
-	details: { _progress: true };
-}
-
-/** Pi tool result format */
-export interface ToolResult {
-	content: Array<{ type: "text"; text: string }>;
-	details: Record<string, unknown>;
-}
-
-// ============================================================================
-// Engine Configuration Types
-// ============================================================================
-
-/** Engine definition for the ENGINES map */
-export interface EngineConfig {
-	/** Extractor script filename (e.g. "perplexity.mjs") */
-	script: string;
-	/** Human-readable label for progress messages */
-	label: string;
-	/** Domain pattern for source matching */
-	domain: string;
-	/** URL pattern for the engine */
-	url: string;
-}
-
-// ============================================================================
-// Constants
-// ============================================================================
-
-// Runtime defaults are in src/search/defaults.mjs (since .ts files can't be
-// imported directly by Node.js). Import DEFAULTS from there for runtime values.
+/**
+ * TypeScript interfaces for GreedySearch data structures
+ *
+ * These types document the shape of data flowing between modules.
+ * They can be imported by TypeScript files (index.ts, tool handlers, formatters)
+ * and used for type safety without runtime overhead.
+ */
+
+// ============================================================================
+// Search Result Types
+// ============================================================================
+
+/** A single source extracted from search results */
+export interface Source {
+	url: string;
+	title: string;
+	type?:
+		| "official-docs"
+		| "maintainer-blog"
+		| "repo"
+		| "academic"
+		| "community"
+		| "website";
+	domain?: string;
+	snippet?: string;
+}
+
+/** Result from a single search engine */
+export interface SearchResult {
+	engine: string;
+	answer: string;
+	sources: Source[];
+	url?: string;
+	query?: string;
+	error?: string;
+}
+
+/** Synthesis result combining multiple engine results */
+export interface SynthesisResult {
+	answer: string;
+	agreementLevel?: "consensus" | "majority" | "mixed" | "conflicting";
+	claims?: Claim[];
+	sourceIds?: string[];
+	confidence?: ConfidenceMetrics;
+}
+
+/** A single claim within a synthesis */
+export interface Claim {
+	text: string;
+	sourceIds: string[];
+	confidence?: "high" | "medium" | "low";
+}
+
+/** Confidence metrics for a synthesis */
+export interface ConfidenceMetrics {
+	overall: number; // 0-1
+	consensus: number; // fraction of engines agreeing
+	sourceCount: number;
+	engineCount: number;
+}
+
+// ============================================================================
+// Source Registry Types
+// ============================================================================
+
+/** A classified source in the registry */
+export interface ClassifiedSource extends Source {
+	engineOrigin: string[];
+	isOfficial: boolean;
+	consensus: number; // fraction of engines citing this source
+}
+
+// ============================================================================
+// Tool Result Types
+// ============================================================================
+
+/** Progress update sent via onUpdate during long-running searches */
+export interface ProgressUpdate {
+	content: Array<{ type: "text"; text: string }>;
+	details: { _progress: true };
+}
+
+/** Pi tool result format */
+export interface ToolResult {
+	content: Array<{ type: "text"; text: string }>;
+	details: Record<string, unknown>;
+}
+
+// ============================================================================
+// Engine Configuration Types
+// ============================================================================
+
+/** Engine definition for the ENGINES map */
+export interface EngineConfig {
+	/** Extractor script filename (e.g. "perplexity.mjs") */
+	script: string;
+	/** Human-readable label for progress messages */
+	label: string;
+	/** Domain pattern for source matching */
+	domain: string;
+	/** URL pattern for the engine */
+	url: string;
+}
+
+// ============================================================================
+// Constants
+// ============================================================================
+
+// Runtime defaults are in src/search/defaults.mjs (since .ts files can't be
+// imported directly by Node.js). Import DEFAULTS from there for runtime values.

package/test.mjs

@@ -9,6 +9,7 @@
 //   node test.mjs flags          # flag/option tests only
 //   node test.mjs edge           # edge case tests only
 //   node test.mjs unit           # fast unit tests only (no Chrome needed)
+//   node test.mjs synth          # synthesis config smoke (gemini + chatgpt)
 
 import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
@@ -93,7 +94,7 @@ function checkJson(file, checkFn) {
 // Unit Tests (no Chrome required)
 // ─────────────────────────────────────────────────────────────────────────────
 
-if (["", "all", "unit", "quick", "smoke"].includes(mode)) {
+if (["", "all", "unit", "quick", "smoke", "synth"].includes(mode)) {
 	section("🧪 Unit Tests");
 
 	subsection("stripQuotes — param double-escaping workaround (issue #2)");
@@ -245,18 +246,110 @@ if (["", "all", "unit", "quick", "smoke"].includes(mode)) {
 			failMsg(`pplxPattern: ${label} — expected ${expected}, got ${matched}`);
 	}
 
-	subsection("mode marker file — isChromeHeadless detection");
-	const { isChromeHeadless: isHeadlessCheck } = await import(
-		"./src/search/chrome.mjs"
+	subsection("Chrome lifecycle — visible/headless mode detection");
+	const { detectHeadlessFromChromeCommandLine, isChromeHeadless } =
+		await import("./src/search/chrome.mjs");
+	const { commandLineMatchesGreedyChrome } = await import(
+		"./src/search/browser-lifecycle.mjs"
 	);
-	const headlessResult = typeof isHeadlessCheck === "function";
-	if (headlessResult) passMsg("isChromeHeadless: function exists");
+
+	const visibleCmd =
+		'"C:/Program Files/Google/Chrome/Application/chrome.exe" --remote-debugging-port=9222 --user-data-dir=C:\\Users\\me\\AppData\\Local\\Temp\\greedysearch-chrome-profile about:blank';
+	const headlessCmd = `${visibleCmd} --headless=new`;
+	const rendererCmd = `${visibleCmd} --type=renderer`;
+
+	if (detectHeadlessFromChromeCommandLine(visibleCmd) === false) {
+		passMsg("chrome mode: live visible command line overrides stale marker");
+	} else {
+		failMsg("chrome mode: visible command line should detect non-headless");
+	}
+	if (detectHeadlessFromChromeCommandLine(headlessCmd) === true) {
+		passMsg("chrome mode: live headless command line detected");
+	} else {
+		failMsg("chrome mode: headless command line should detect headless");
+	}
+	if (detectHeadlessFromChromeCommandLine(rendererCmd) === null) {
+		passMsg("chrome mode: ignores child renderer processes");
+	} else {
+		failMsg("chrome mode: renderer command line should be ignored");
+	}
+	if (
+		commandLineMatchesGreedyChrome(
+			visibleCmd,
+			"C:/Users/me/AppData/Local/Temp/greedysearch-chrome-profile",
+		)
+	) {
+		passMsg(
+			"stale cleanup: Windows backslash profile path verifies as GreedySearch Chrome",
+		);
+	} else {
+		failMsg(
+			"stale cleanup: should accept equivalent slash/backslash profile paths",
+		);
+	}
+	if (
+		!commandLineMatchesGreedyChrome(
+			rendererCmd,
+			"C:/Users/me/AppData/Local/Temp/greedysearch-chrome-profile",
+		)
+	) {
+		passMsg("stale cleanup: renderer child is not treated as browser process");
+	} else {
+		failMsg(
+			"stale cleanup: renderer child should not verify as browser process",
+		);
+	}
+	if (typeof isChromeHeadless === "function")
+		passMsg("isChromeHeadless: function exists");
 	else failMsg("isChromeHeadless: not a function");
 
+	subsection("Synthesis routing — configurable synthesizer helpers");
+	const { normalizeSynthesizer, getSynthesisStartUrl } = await import(
+		"./src/search/synthesis-runner.mjs"
+	);
+	if (normalizeSynthesizer("gem") === "gemini")
+		passMsg("synthesizer: gem alias normalizes to gemini");
+	else failMsg("synthesizer: gem alias should normalize to gemini");
+	if (normalizeSynthesizer("gpt") === "chatgpt")
+		passMsg("synthesizer: gpt alias normalizes to chatgpt");
+	else failMsg("synthesizer: gpt alias should normalize to chatgpt");
+	if (getSynthesisStartUrl("chatgpt") === "https://chatgpt.com/")
+		passMsg("synthesizer: chatgpt start URL");
+	else failMsg("synthesizer: unexpected chatgpt start URL");
+
 	subsection("Research mode option/query normalization");
 	const { clampResearchOptions, normalizeResearchQueries } = await import(
 		"./src/search/research.mjs"
 	);
+	const { ALL_ENGINES, DEFAULT_SYNTHESIZER, ENGINES, RESEARCH_ENGINES } =
+		await import("./src/search/constants.mjs");
+	if (RESEARCH_ENGINES.join(",") === ALL_ENGINES.join(",")) {
+		passMsg("research config: reuses normal all-engine fan-out");
+	} else {
+		failMsg(
+			`research config: expected ${ALL_ENGINES.join(",")}, got ${RESEARCH_ENGINES.join(",")}`,
+		);
+	}
+	if (DEFAULT_SYNTHESIZER === "gemini") {
+		passMsg("research config: default synthesizer is gemini");
+	} else {
+		failMsg(
+			`research config: expected gemini default, got ${DEFAULT_SYNTHESIZER}`,
+		);
+	}
+	if (!ENGINES.consensus && !ENGINES.cns) {
+		passMsg("research config: consensus is not a registered engine");
+	} else {
+		failMsg("research config: consensus should not be registered");
+	}
+	if (
+		ENGINES["semantic-scholar"] &&
+		ENGINES.s2 === ENGINES["semantic-scholar"]
+	) {
+		passMsg("research config: semantic-scholar is registered with s2 alias");
+	} else {
+		failMsg("research config: semantic-scholar registration missing");
+	}
 	const clamped = clampResearchOptions({
 		breadth: 99,
 		iterations: 0,
@@ -367,6 +460,66 @@ if (["", "all", "unit", "quick", "smoke"].includes(mode)) {
 		);
 	}
 
+	const academicRanked = buildSourceRegistry(
+		{
+			"semantic-scholar": {
+				sources: [
+					{
+						title:
+							"Chain of Thought Prompting Elicits Reasoning in Large Language Models",
+						url: "https://arxiv.org/pdf/2201.11903.pdf",
+					},
+				],
+			},
+		},
+		"large language models",
+	);
+	if (
+		academicRanked[0]?.engines.includes("semantic-scholar") &&
+		academicRanked[0]?.sourceType === "academic"
+	) {
+		passMsg("source ranking: semantic-scholar sources are indexed as academic");
+	} else {
+		failMsg(
+			`source ranking: unexpected academic source ${JSON.stringify(academicRanked[0])}`,
+		);
+	}
+
+	// Social hard guardrail: a single-engine x.com citation must never be
+	// S1. Composite score is high (Google rank #1, x.com matched the
+	// "x" letter in "context"), so the smartScore −20 penalty alone
+	// isn't enough — the post-sort demotion is what keeps socials out
+	// of the top 12.
+	const socialGuardrail = buildSourceRegistry(
+		{
+			google: {
+				sources: [
+					{
+						title: "Redis on X",
+						url: "https://x.com/Redisinc/status/123",
+					},
+					{
+						title: "Self-Route paper",
+						url: "https://arxiv.org/abs/2407.16833",
+					},
+				],
+			},
+		},
+		"retrieval augmented generation vs long context LLMs for factual accuracy and hallucination reduction",
+	);
+	if (
+		socialGuardrail[0]?.sourceType !== "social" &&
+		socialGuardrail[0]?.domain === "arxiv.org"
+	) {
+		passMsg(
+			"source ranking: social sources are demoted below academic even with a higher composite score",
+		);
+	} else {
+		failMsg(
+			`source ranking: S1 should be arxiv, got ${socialGuardrail[0]?.domain} (${socialGuardrail[0]?.sourceType})`,
+		);
+	}
+
 	// ─── Phase 2: Quality Evaluator + Novelty Gate ────────────────────────
 
 	subsection("Novelty Gate — Jaccard similarity");
@@ -496,6 +649,139 @@ if (["", "all", "unit", "quick", "smoke"].includes(mode)) {
 	if (gapTargets) passMsg("fallback queries: targets identified gaps");
 	else failMsg("fallback queries: gaps not targeted");
 
+	// ─────────────────────────────────────────────────────────────────────────
+	// Synthesis routing — config-driven live smoke
+	//
+	// Verifies the `synthesizer` field in ~/.pi/greedyconfig is honored by
+	// `engine: "all" --synthesize`. Runs both the default (gemini) and an
+	// override (chatgpt). Backups the user's config and restores it after.
+	//
+	// Mode gating: only runs in "", "all", or "synth". Skipped in unit/quick/
+	// smoke because it requires Chrome + network and takes several minutes.
+	// ─────────────────────────────────────────────────────────────────────────
+	if (["", "all", "synth"].includes(mode)) {
+		subsection(
+			"Synthesis routing — config-driven live smoke (gemini + chatgpt)",
+		);
+		const { existsSync, copyFileSync, writeFileSync, unlinkSync } =
+			await import("node:fs");
+		const { homedir } = await import("node:os");
+		const { join } = await import("node:path");
+		const cfgDir = join(homedir(), ".pi");
+		const cfgFile = join(cfgDir, "greedyconfig");
+		const backup = join(cfgDir, "greedyconfig.test-backup");
+		const hadOriginal = existsSync(cfgFile);
+		if (hadOriginal) copyFileSync(cfgFile, backup);
+
+		const meaningfulQuery = "Who is Apostolos Mantzaris?";
+		const engines = ["perplexity", "google", "chatgpt", "gemini"];
+		const results = {};
+
+		const runSynth = async (synthesizer) => {
+			mkdirSync(cfgDir, { recursive: true });
+			writeFileSync(
+				cfgFile,
+				JSON.stringify({ engines, synthesizer }, null, 2) + "\n",
+				"utf8",
+			);
+			const outFile = join(resultsDir, `synth_${synthesizer}.json`);
+			const script = `
+import { spawn } from 'node:child_process';
+import { writeFileSync } from 'node:fs';
+const proc = spawn(process.execPath, [
+  '${join(__dir, "bin", "search.mjs").replace(/\\/g, "\\\\")}',
+  'all', '--inline', '--stdin', '--headless', '--synthesize'
+], { stdio: ['pipe', 'pipe', 'pipe'] });
+let out = '', err = '';
+proc.stdout.on('data', d => out += d);
+proc.stderr.on('data', d => err += d);
+proc.stdin.end(${JSON.stringify(meaningfulQuery)});
+proc.on('close', code => {
+  writeFileSync(${JSON.stringify(outFile.replace(/\\/g, "\\\\"))}, JSON.stringify({
+    code, out, err,
+  }, null, 2));
+});
+`;
+			const tmp = join(resultsDir, `_synth_${synthesizer}.mjs`);
+			writeFileSync(tmp, script, "utf8");
+			await runNode([tmp], 240);
+			const data = JSON.parse(readFileSync(outFile, "utf8"));
+			let parsed = null;
+			try {
+				parsed = JSON.parse(data.out);
+			} catch (e) {
+				return {
+					synthesized: false,
+					synthesizedBy: null,
+					parseError: e.message,
+					rawOut: data.out.slice(0, 200),
+				};
+			}
+			return {
+				synthesized: parsed._synthesis?.synthesized === true,
+				synthesizedBy: parsed._synthesis?.synthesizedBy || null,
+				engines: Object.keys(parsed).filter((k) => !k.startsWith("_")),
+				chatgptAnswer: parsed.chatgpt?.answer || null,
+				chatgptError: parsed.chatgpt?.error || null,
+				chatgptStage: parsed.chatgpt?._envelope?.lastStage || null,
+				chatgptStages: parsed.chatgpt?._envelope?.stages || null,
+				answerPreview: String(parsed._synthesis?.answer || "").slice(0, 120),
+			};
+		};
+
+		try {
+			results.gemini = await runSynth("gemini");
+			if (
+				results.gemini.synthesized &&
+				results.gemini.synthesizedBy === "gemini"
+			) {
+				passMsg("synth=gemini: synthesizedBy === gemini");
+			} else {
+				failMsg(
+					`synth=gemini: expected synthesizedBy=gemini, got ${JSON.stringify(results.gemini)}`,
+				);
+			}
+
+			results.chatgpt = await runSynth("chatgpt");
+			if (
+				results.chatgpt.synthesized &&
+				results.chatgpt.synthesizedBy === "chatgpt"
+			) {
+				passMsg("synth=chatgpt: synthesizedBy === chatgpt");
+			} else {
+				failMsg(
+					`synth=chatgpt: expected synthesizedBy=chatgpt, got ${JSON.stringify(results.chatgpt)}`,
+				);
+			}
+
+			// Also assert chatgpt-search succeeded under parallel load — a
+			// regression of the throttling fix or the engine budget would
+			// re-introduce the "cdp timeout: eval" failure at stream-wait.
+			// We require an actual answer (not just a synthesis routing
+			// marker) so the test catches the underlying engine problem.
+			if (results.gemini.chatgptAnswer) {
+				passMsg(
+					"chatgpt-search: produced an answer (parallel contention not blocking)",
+				);
+			} else {
+				failMsg(
+					`chatgpt-search: no answer — error=${JSON.stringify(results.gemini.chatgptError)} lastStage=${results.gemini.chatgptStage}`,
+				);
+			}
+		} finally {
+			if (hadOriginal) {
+				copyFileSync(backup, cfgFile);
+				try {
+					unlinkSync(backup);
+				} catch {}
+			} else {
+				try {
+					unlinkSync(cfgFile);
+				} catch {}
+			}
+		}
+	}
+
 	// ─── Phase 3: Action Planner ──────────────────────────────────────────
 
 	subsection("Action Planner — validation & parsing");
@@ -689,6 +975,91 @@ END_JSON`,
 	} else {
 		failMsg("citation audit: S2 should be flagged as unfetched");
 	}
+
+	subsection("Research Floor and Question Ledger");
+	const { computeResearchFloor, createQuestionLedger, updateQuestionLedger } =
+		await import("./src/search/research.mjs");
+	const floorOk = computeResearchFloor({
+		sources: [
+			{ id: "S1", sourceType: "official-docs" },
+			{ id: "S2", sourceType: "community" },
+		],
+		fetchedSources: [
+			{ id: "S1", contentChars: 500 },
+			{ id: "S2", contentChars: 500 },
+			{ id: "S3", contentChars: 500 },
+		],
+		synthesis: {
+			claims: [{ claim: "React has docs", sourceIds: ["S1"] }],
+		},
+		citationAudit: { ok: true, cited: ["S1"], unfetched: [] },
+		rounds: [{ round: 1 }],
+		qualityScore: 8.2,
+		maxSources: 3,
+	});
+	if (floorOk.floorMet)
+		passMsg("research floor: passes with evidence and citations");
+	else failMsg(`research floor: expected pass, got ${JSON.stringify(floorOk)}`);
+
+	const floorMissingCitation = computeResearchFloor({
+		sources: [{ id: "S1", sourceType: "official-docs" }],
+		fetchedSources: [{ id: "S1", contentChars: 500 }],
+		synthesis: { claims: [] },
+		citationAudit: { ok: true, cited: [], unfetched: [] },
+		rounds: [{ round: 1 }],
+		qualityScore: 9,
+		maxSources: 1,
+	});
+	if (
+		!floorMissingCitation.floorMet &&
+		!floorMissingCitation.checks.citationsPresent
+	) {
+		passMsg("research floor: rejects missing citations");
+	} else {
+		failMsg("research floor: missing citations should fail");
+	}
+
+	const ledger = createQuestionLedger("What is React 19?");
+	updateQuestionLedger(ledger, {
+		roundNumber: 1,
+		actions: [
+			{
+				type: "search",
+				query: "React 19 actions",
+				researchGoal: "Find React 19 feature list",
+			},
+		],
+		learningPayload: {
+			answeredQuestions: [
+				{ id: "Q1", evidence: "React 19 is documented", sourceIds: ["S1"] },
+			],
+			newQuestions: ["Which React 19 features are stable?"],
+		},
+	});
+	const closedQ1 = ledger.find((q) => q.id === "Q1")?.status === "closed";
+	const addedOpen = ledger.some(
+		(q) => q.question.includes("stable") && q.status === "open",
+	);
+	if (closedQ1 && addedOpen) {
+		passMsg("question ledger: closes answered questions and adds follow-ups");
+	} else {
+		failMsg(`question ledger: unexpected ${JSON.stringify(ledger)}`);
+	}
+
+	subsection("Structured JSON parser");
+	const { parseStructuredJson } = await import("./src/search/synthesis.mjs");
+	const parsedLooseJson = parseStructuredJson(`BEGIN_JSON
+{"answer":"line one
+line two","claims":[{"claim":"x"}]}
+END_JSON
+trailing note`);
+	if (parsedLooseJson?.answer?.includes("line two")) {
+		passMsg("structured JSON: repairs raw newlines inside strings");
+	} else {
+		failMsg(
+			`structured JSON: failed to repair ${JSON.stringify(parsedLooseJson)}`,
+		);
+	}
 }
 
 // ─────────────────────────────────────────────────────────────────────────────