@apmantza/greedysearch-pi 1.8.0 → 1.8.2

package/bin/search.mjs

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-// search.mjs — unified CLI for GreedySearch extractors
+
+// search.mjs - unified CLI for GreedySearch extractors
 //
 // Usage:
 //   node search.mjs <engine> "<query>"
@@ -10,7 +11,7 @@
 //   bing       | copilot | b
 //   google     | g
 //   gemini     | gem
-//   all        — fan-out to all engines in parallel
+//   all        - fan-out to all engines in parallel
 //
 // Output: JSON to stdout, errors to stderr
 //
@@ -19,30 +20,45 @@
 //   node search.mjs gem "latest React features"
 //   node search.mjs all "how does TCP congestion control work"
 
+import { existsSync, readFileSync } from "node:fs";
+// Config file for user defaults
+import { homedir } from "node:os";
+import { join } from "node:path";
 import {
-	ALL_ENGINES,
-	ENGINES,
-} from "../src/search/constants.mjs";
-import {
-	buildSourceRegistry,
-	mergeFetchDataIntoSources,
-} from "../src/search/sources.mjs";
-import { buildConfidence } from "../src/search/synthesis.mjs";
-import { synthesizeWithGemini } from "../src/search/synthesis-runner.mjs";
-import {
-	cdp,
-	ensureChrome,
-	openNewTab,
 	activateTab,
+	cdp,
 	closeTab,
 	closeTabs,
+	ensureChrome,
+	openNewTab,
 } from "../src/search/chrome.mjs";
+import { ALL_ENGINES, ENGINES } from "../src/search/constants.mjs";
 import { runExtractor } from "../src/search/engines.mjs";
 import {
 	fetchMultipleSources,
 	fetchTopSource,
 } from "../src/search/fetch-source.mjs";
 import { writeOutput } from "../src/search/output.mjs";
+import {
+	buildSourceRegistry,
+	mergeFetchDataIntoSources,
+} from "../src/search/sources.mjs";
+import { buildConfidence } from "../src/search/synthesis.mjs";
+import { synthesizeWithGemini } from "../src/search/synthesis-runner.mjs";
+
+const CONFIG_DIR = join(homedir(), ".config", "greedysearch");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+function loadUserConfig() {
+	try {
+		if (existsSync(CONFIG_FILE)) {
+			return JSON.parse(readFileSync(CONFIG_FILE, "utf8"));
+		}
+	} catch {
+		// Ignore errors
+	}
+	return {};
+}
 
 // ─── Main ──────────────────────────────────────────────────────────────────
 
@@ -61,6 +77,11 @@ async function main() {
 				"  --deep-research     Deprecated: source fetching is now default",
 				"  --fetch-top-source  Fetch content from top source",
 				"  --inline            Output JSON to stdout (for piping)",
+				"  --locale <lang>     Force results language (en, de, fr, etc.)",
+				"",
+				"Environment:",
+				"  GREEDY_SEARCH_LOCALE    Default locale (default: en)",
+				"  GREEDY_SEARCH_VISIBLE   Set to 1 to show Chrome window",
 				"",
 				"Examples:",
 				'  node search.mjs all "Node.js streams"           # Default: sources + synthesis',
@@ -92,13 +113,17 @@ async function main() {
 	// --deep-research / --deep flags map to deep mode (backward compat)
 	if (args.includes("--deep-research")) {
 		depth = "standard";
-		process.stderr.write("[greedysearch] --deep-research is deprecated; use --depth standard (now default)\n");
+		process.stderr.write(
+			"[greedysearch] --deep-research is deprecated; use --depth standard (now default)\n",
+		);
 	}
 	if (args.includes("--deep")) {
 		depth = "deep";
 	}
 	if (args.includes("--synthesize")) {
-		process.stderr.write("[greedysearch] --synthesize is deprecated; synthesis is now default for multi-engine\n");
+		process.stderr.write(
+			"[greedysearch] --synthesize is deprecated; synthesis is now default for multi-engine\n",
+		);
 	}
 
 	const full = args.includes("--full");
@@ -107,6 +132,20 @@ async function main() {
 	const inline = args.includes("--inline");
 	const outIdx = args.indexOf("--out");
 	const outFile = outIdx !== -1 ? args[outIdx + 1] : null;
+
+	// Locale handling: CLI flag > env var > config file > default (en)
+	const localeIdx = args.indexOf("--locale");
+	const envLocale = process.env.GREEDY_SEARCH_LOCALE;
+	const userConfig = loadUserConfig();
+	let locale = "en"; // Default to English
+
+	if (localeIdx !== -1 && args[localeIdx + 1]) {
+		locale = args[localeIdx + 1];
+	} else if (envLocale) {
+		locale = envLocale;
+	} else if (userConfig.locale) {
+		locale = userConfig.locale;
+	}
 	const rest = args.filter(
 		(a, i) =>
 			a !== "--full" &&
@@ -140,7 +179,7 @@ async function main() {
 		try {
 			const results = await Promise.allSettled(
 				ALL_ENGINES.map((e, i) =>
-					runExtractor(ENGINES[e], query, engineTabs[i], short)
+					runExtractor(ENGINES[e], query, engineTabs[i], short, null, locale)
 						.then((r) => {
 							process.stderr.write(`PROGRESS:${e}:done\n`);
 							return { engine: e, ...r };
@@ -236,7 +275,7 @@ async function main() {
 	}
 
 	try {
-		const result = await runExtractor(script, query, null, short);
+		const result = await runExtractor(script, query, null, short, null, locale);
 		if (fetchSource && result.sources?.length > 0) {
 			result.topSource = await fetchTopSource(result.sources[0].url);
 		}
@@ -257,4 +296,93 @@ function pickTopSource(out) {
 	return null;
 }
 
-main();
+/**
+ * Minimize Chrome window via CDP after search completes.
+ * Called at the end of search to keep window minimized.
+ */
+async function minimizeChrome() {
+	if (process.env.GREEDY_SEARCH_VISIBLE === "1") return;
+
+	try {
+		const http = await import("node:http");
+		const version = await new Promise((resolve, reject) => {
+			http
+				.get(`http://localhost:9222/json/version`, (res) => {
+					let body = "";
+					res.on("data", (d) => (body += d));
+					res.on("end", () => resolve(JSON.parse(body)));
+				})
+				.on("error", reject);
+		});
+
+		const wsUrl = version.webSocketDebuggerUrl;
+		const WebSocket = globalThis.WebSocket;
+		if (!WebSocket) return;
+
+		const ws = new WebSocket(wsUrl);
+		let requestId = 0;
+		const pending = new Map();
+
+		ws.onopen = () => {
+			const id = ++requestId;
+			pending.set(id, {
+				resolve: (result) => {
+					const targets = result.targetInfos || [];
+					const pageTarget = targets.find((t) => t.type === "page");
+					if (!pageTarget) {
+						ws.close();
+						return;
+					}
+
+					const winId = ++requestId;
+					pending.set(winId, {
+						resolve: (winResult) => {
+							const windowId = winResult.windowId;
+							const minId = ++requestId;
+							pending.set(minId, { resolve: () => {}, reject: () => {} });
+							ws.send(
+								JSON.stringify({
+									id: minId,
+									method: "Browser.setWindowBounds",
+									params: { windowId, bounds: { windowState: "minimized" } },
+								}),
+							);
+							setTimeout(() => ws.close(), 500);
+						},
+						reject: () => ws.close(),
+					});
+					ws.send(
+						JSON.stringify({
+							id: winId,
+							method: "Browser.getWindowForTarget",
+							params: { targetId: pageTarget.targetId },
+						}),
+					);
+				},
+				reject: () => ws.close(),
+			});
+			ws.send(JSON.stringify({ id, method: "Target.getTargets", params: {} }));
+		};
+
+		ws.onmessage = (event) => {
+			const msg = JSON.parse(event.data);
+			if (msg.id && pending.has(msg.id)) {
+				const { resolve, reject } = pending.get(msg.id);
+				pending.delete(msg.id);
+				if (msg.error) reject?.(msg.error);
+				else resolve?.(msg.result);
+			}
+		};
+
+		setTimeout(() => ws.close(), 3000);
+	} catch {
+		// Best-effort
+	}
+}
+
+main().finally(async () => {
+	// Ensure window is minimized after search completes
+	await minimizeChrome();
+	// Give minimize time to complete before exit
+	await new Promise((r) => setTimeout(r, 1500));
+});