pi-lean-dimension 0.2.1 → 0.2.3

package/node_modules/pi-lean-search/__tests__/web-search.test.ts

@@ -5,7 +5,7 @@
  * instance and are not included here.
  */
 
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import { readSearxngUrl } from "../search-config.js";
 import { webSearchTool } from "../web-search-tool.js";
 
@@ -150,4 +150,244 @@ describe("webSearchTool", () => {
 	it("has renderResult function", () => {
 		expect(typeof webSearchTool.renderResult).toBe("function");
 	});
+
+	describe("renderResult answer badge", () => {
+		it("shows 💡 badge when answerCount > 0 and no results", () => {
+			const mockTheme = {
+				fg: (_style: string, text: string) => text,
+			} as any;
+			const result = (webSearchTool.renderResult as any)(
+				{
+					content: [{ text: "" }],
+					details: { answerCount: 2, query: "weather" },
+				} as any,
+				{ expanded: false, isPartial: false },
+				mockTheme,
+				{} as any,
+			) as any;
+			expect(result.text).toContain("💡");
+			expect(result.text).toContain("2 answer(s)");
+			expect(result.text).toContain('"weather"');
+		});
+
+		it("shows 💡 badge alongside 🔍 when both answers and results present", () => {
+			const mockTheme = {
+				fg: (_style: string, text: string) => text,
+			} as any;
+			const result = (webSearchTool.renderResult as any)(
+				{
+					content: [{ text: "" }],
+					details: {
+						answerCount: 1,
+						resultCount: 3,
+						query: "test",
+						results: [
+							{ title: "A", url: "http://a.com", engine: "google" },
+							{ title: "B", url: "http://b.com", engine: "google" },
+							{ title: "C", url: "http://c.com", engine: "google" },
+						],
+					},
+				} as any,
+				{ expanded: false, isPartial: false },
+				mockTheme,
+				{} as any,
+			) as any;
+			expect(result.text).toContain("💡");
+			expect(result.text).toContain("1 answer(s)");
+			expect(result.text).toContain("🔍");
+			expect(result.text).toContain("3 result(s)");
+		});
+
+		it("shows answer text above results when expanded", () => {
+			const mockTheme = {
+				fg: (_style: string, text: string) => text,
+			} as any;
+			const result = (webSearchTool.renderResult as any)(
+				{
+					content: [{ text: "" }],
+					details: {
+						answerCount: 1,
+						resultCount: 1,
+						query: "weather berlin",
+						answers: [
+							{
+								template: "answer/weather.html",
+								text: "Berlin: 14°C, light rain",
+							},
+						],
+						results: [{ title: "A", url: "http://a.com" }],
+					},
+				} as any,
+				{ expanded: true, isPartial: false },
+				mockTheme,
+				{} as any,
+			) as any;
+			const answerIdx = result.text.indexOf("Berlin: 14°C, light rain");
+			const resultIdx = result.text.indexOf("A");
+			expect(answerIdx).toBeGreaterThan(-1);
+			expect(resultIdx).toBeGreaterThan(-1);
+			expect(answerIdx).toBeLessThan(resultIdx);
+		});
+
+		it("shows answer text when expanded with no results", () => {
+			const mockTheme = {
+				fg: (_style: string, text: string) => text,
+			} as any;
+			const result = (webSearchTool.renderResult as any)(
+				{
+					content: [{ text: "" }],
+					details: {
+						answerCount: 1,
+						query: "avg 1 2 3",
+						answers: [{ template: "answer/legacy.html", text: "2" }],
+					},
+				} as any,
+				{ expanded: true, isPartial: false },
+				mockTheme,
+				{} as any,
+			) as any;
+			expect(result.text).toContain("💡");
+			expect(result.text).toContain("2");
+		});
+	});
+});
+
+// ─── Execute answer rendering (mocked fetch) ─────────────────
+
+describe("execute answer rendering", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+		// Make readSearxngUrl return a valid URL
+		vi.mocked(existsSync).mockReturnValue(true);
+		vi.mocked(readFileSync).mockReturnValue(
+			JSON.stringify({ searxng: { url: "http://localhost:8888" } }),
+		);
+	});
+
+	afterEach(() => {
+		vi.unstubAllGlobals();
+	});
+
+	const mockFetch = (json: unknown) =>
+		vi.stubGlobal(
+			"fetch",
+			vi.fn().mockResolvedValue({
+				ok: true,
+				status: 200,
+				text: async () => JSON.stringify(json),
+			}),
+		);
+
+	it("legacy answer renders + bypasses empty-results early return", async () => {
+		mockFetch({
+			results: [],
+			answers: [{ template: "answer/legacy.html", answer: "614.24" }],
+			suggestions: [],
+		});
+
+		const result = await webSearchTool.execute(
+			"call-1",
+			{ query: "614.24" },
+			undefined,
+			undefined,
+			{} as any,
+		);
+		const r = result as any;
+		expect(r.content[0].text).toContain("614.24");
+		expect(r.content[0].text).not.toContain("No web search results found");
+		expect(r.content[0].text).toContain("No web results");
+	});
+
+	it("weather answer uses server summary", async () => {
+		mockFetch({
+			results: [],
+			answers: [
+				{
+					template: "answer/weather.html",
+					current: {
+						location: { name: "Berlin", latitude: 52.52, longitude: 13.405 },
+						temperature: { val: 14, unit: "°C" },
+						condition: "light rain",
+						summary: "Berlin: 14°C, light rain",
+						feels_like: { val: 12, unit: "°C" },
+						humidity: { val: 80, unit: "%" },
+						wind_speed: { val: 18, unit: "km/h" },
+						wind_from: { name: "NW" },
+					},
+					service: "open-meteo",
+				},
+			],
+			suggestions: [],
+		});
+
+		const result = await webSearchTool.execute(
+			"call-2",
+			{ query: "weather berlin" },
+			undefined,
+			undefined,
+			{} as any,
+		);
+		// Uses server-provided summary
+		const r = result as any;
+		expect(r.content[0].text).toContain("Berlin: 14°C, light rain");
+		// Secondary detail line
+		expect(r.content[0].text).toContain("feels like 12°C");
+		expect(r.content[0].text).toContain("humidity 80%");
+		expect(r.content[0].text).toContain("wind 18km/h");
+		// forecasts not rendered
+		expect(r.content[0].text).not.toContain("forecast");
+		// source
+		expect(r.content[0].text).toContain("open-meteo");
+	});
+
+	it("unknown template falls back to legacy heuristic", async () => {
+		mockFetch({
+			results: [],
+			answers: [{ template: "answer/future.html", answer: "x" }],
+			suggestions: [],
+		});
+
+		const result = await webSearchTool.execute(
+			"call-3",
+			{ query: "future" },
+			undefined,
+			undefined,
+			{} as any,
+		);
+		const r = result as any;
+		expect(r.content[0].text).toContain("x");
+	});
+
+	it("answers + results both present (primary success path)", async () => {
+		mockFetch({
+			results: [
+				{
+					title: "Result 1",
+					url: "http://example.com/1",
+					content: "First result",
+					engine: "google",
+					score: 0.95,
+				},
+			],
+			answers: [{ template: "answer/legacy.html", answer: "42" }],
+			suggestions: [],
+		});
+
+		const result = await webSearchTool.execute(
+			"call-5",
+			{ query: "answer of life" },
+			undefined,
+			undefined,
+			{} as any,
+		);
+		// Answer above results
+		const r = result as any;
+		const answerIdx = r.content[0].text.indexOf("42");
+		const resultIdx = r.content[0].text.indexOf("Result 1");
+		expect(answerIdx).toBeGreaterThanOrEqual(0);
+		expect(resultIdx).toBeGreaterThan(answerIdx);
+		// Both present
+		expect(r.content[0].text).toContain("42");
+		expect(r.content[0].text).toContain("Result 1");
+	});
 });

package/node_modules/pi-lean-search/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-lean-search",
-	"version": "0.2.1",
+	"version": "0.2.3",
 	"description": "Pi extension. SearXNG search tool for Pi — pairs with pi-lean-portal's /web toggle; search-only installs are valid, or add it to a portal install for the full web-tools suite.",
 	"keywords": [
 		"pi-package",

package/node_modules/pi-lean-search/web-search-tool.ts

@@ -18,12 +18,188 @@ interface SearXNGResult {
 	score?: number;
 }
 
+interface SearXNGAnswerLegacy {
+	template: "answer/legacy.html";
+	answer: string;
+	url?: string;
+	engine?: string;
+}
+
+interface SearXNGAnswerTranslationItem {
+	text: string;
+	transliteration?: string;
+	definitions?: string[];
+	synonyms?: string[];
+	examples?: string[];
+}
+
+interface SearXNGAnswerTranslations {
+	template: "answer/translations.html";
+	translations: SearXNGAnswerTranslationItem[];
+	url?: string;
+}
+
+interface SearXNGWeatherQuantity {
+	val: number | string;
+	unit: string;
+}
+
+interface SearXNGWeatherItem {
+	location?: { name: string; latitude?: number; longitude?: number };
+	temperature?: SearXNGWeatherQuantity;
+	condition?: string;
+	summary?: string;
+	feels_like?: SearXNGWeatherQuantity;
+	humidity?: SearXNGWeatherQuantity;
+	wind_speed?: SearXNGWeatherQuantity;
+	wind_from?: string | { name?: string };
+}
+
+interface SearXNGAnswerWeather {
+	template: "answer/weather.html";
+	current: SearXNGWeatherItem;
+	forecasts?: SearXNGWeatherItem[];
+	service?: string;
+}
+
+type SearXNGAnswer =
+	| SearXNGAnswerLegacy
+	| SearXNGAnswerTranslations
+	| SearXNGAnswerWeather;
+
 interface SearXNGResponse {
 	results: SearXNGResult[];
-	answers: string[];
+	answers: SearXNGAnswer[];
 	suggestions: string[];
 }
 
+// ─── Answer rendering ────────────────────────────────────────────
+
+// Box width (chars). Title row: `┌─ <title> ` + dashes to reach BOX_W.
+const BOX_W = 40;
+
+function box(title: string, lines: string[]): string {
+	const top = `┌─ ${title} ${"─".repeat(Math.max(0, BOX_W - title.length - 4))}`;
+	const bottom = `└${"─".repeat(BOX_W - 1)}`;
+	return `${top}\n${lines.map((l) => `│ ${l}`).join("\n")}\n${bottom}`;
+}
+
+function trunc(s: string, max: number): string {
+	return s.length > max ? s.slice(0, max) + "[…]" : s;
+}
+
+function windLine(c: SearXNGWeatherItem): string {
+	if (!c.wind_speed) return "";
+	let dir = "";
+	if (c.wind_from) {
+		dir =
+			typeof c.wind_from === "object" ? (c.wind_from?.name ?? "") : c.wind_from;
+	}
+	return `wind ${c.wind_speed.val}${c.wind_speed.unit}${dir ? ` ${dir}` : ""}`;
+}
+
+function renderAnswers(answers: SearXNGAnswer[]): string {
+	const blocks: string[] = [];
+
+	for (const a of answers.slice(0, 3)) {
+		let title: string;
+		let lines: string[];
+		switch (a.template) {
+			case "answer/legacy.html": {
+				title = "Answer";
+				lines = [trunc(a.answer, 500)];
+				if (a.url) lines.push(`source: ${a.url}`);
+				break;
+			}
+			case "answer/translations.html": {
+				const t = a.translations[0];
+				if (!t) continue;
+				title = "Translation";
+				lines = [t.text];
+				if (t.synonyms?.length) {
+					lines.push(
+						`  synonyms: ${t.synonyms.slice(0, 2).join(", ")}${t.synonyms.length > 2 ? ", …" : ""}`,
+					);
+				}
+				const more = a.translations.length - 1;
+				if (more > 0) {
+					lines.push(
+						`  ${more} more translation${more > 1 ? "s" : ""}${a.url ? ` (source: ${a.url})` : ""}`,
+					);
+				} else if (a.url) {
+					lines.push(`source: ${a.url}`);
+				}
+				break;
+			}
+			case "answer/weather.html": {
+				const c = a.current;
+				if (!c) continue;
+				title = "Weather";
+				const line1 =
+					c.summary ??
+					[
+						c.location?.name,
+						c.temperature ? `${c.temperature.val}${c.temperature.unit}` : "",
+						c.condition,
+					]
+						.filter(Boolean)
+						.join(": ");
+				lines = [line1];
+				const details: string[] = [];
+				if (c.feels_like)
+					details.push(`feels like ${c.feels_like.val}${c.feels_like.unit}`);
+				if (c.humidity)
+					details.push(`humidity ${c.humidity.val}${c.humidity.unit}`);
+				if (c.wind_speed) details.push(windLine(c));
+
+				if (details.length) lines.push(details.join(" · "));
+				if (a.service) lines.push(`source: ${a.service}`);
+				break;
+			}
+			default: {
+				const f = a as unknown as Record<string, unknown>;
+				if ("answer" in f && typeof f.answer === "string") {
+					title = "Answer";
+					lines = [trunc(f.answer as string, 500)];
+				} else {
+					blocks.push(`[answer: ${String(f.template ?? "?")}]`);
+					continue;
+				}
+			}
+		}
+		blocks.push(box(title, lines));
+	}
+
+	return blocks.join("\n\n");
+}
+
+function answerDetail(a: SearXNGAnswer): {
+	template: string;
+	text: string;
+	url?: string;
+} {
+	switch (a.template) {
+		case "answer/legacy.html":
+			return {
+				template: a.template,
+				text: a.answer,
+				...(a.url ? { url: a.url } : {}),
+			};
+		case "answer/translations.html":
+			return {
+				template: a.template,
+				text: a.translations?.[0]?.text ?? "",
+				...(a.url ? { url: a.url } : {}),
+			};
+		case "answer/weather.html":
+			return { template: a.template, text: a.current?.summary ?? "" };
+		default: {
+			const f = a as unknown as Record<string, unknown>;
+			return { template: String(f.template ?? "?"), text: "" };
+		}
+	}
+}
+
 // ─── URL building ─────────────────────────────────────────────────
 
 function buildSearchUrl(
@@ -70,6 +246,8 @@ export const webSearchTool = defineTool({
 	promptGuidelines: [
 		'Use when you need recent/current information not already known. Increase `count` for broad research; keep it small for quick lookups. Filter by time_range="day" for breaking news, category="news" for journalism. Set language to match the query (e.g. "de" for German, "es" for Spanish).',
 		"Use `pageno` (1-indexed) to fetch deeper pages when `count` results are not enough.",
+		"Instant answers (calculator, unit convert, random uuid, hashes, weather, translations) appear above results \u2014 phrase queries like `avg 1 2 3` or `weather berlin` to trigger them.",
+		'Target results precisely: prefix the query with a bang to route to a specific source \u2014 `!wp <term>` (Wikipedia), `!images <term>`, `!map <term>`, or `:<lang> !<bang> <term>` (e.g. `:fr !wp paris`). Use the `engines` param to restrict upstreams (e.g. engines="google,bing"). For site-scoped queries put the operator inside `query` \u2014 `site:github.com foo`, `inurl:`, `intitle:`, `filetype:pdf` \u2014 but note these only work with engines that support them (Google, Bing, DuckDuckGo) and are silently ignored by others.',
 	],
 
 	parameters: Type.Object({
@@ -317,7 +495,27 @@ export const webSearchTool = defineTool({
 			// Slice to requested count
 			const results = sortedResults.slice(0, Math.min(count, 100));
 
+			// Render answer blocks (before empty-results check so answers show even with zero web results)
+			const renderedAnswers = (data.answers ?? []).slice(0, 3);
+			const answerBlocks = renderAnswers(renderedAnswers);
+
 			if (results.length === 0) {
+				if (answerBlocks) {
+					return {
+						content: [
+							{
+								type: "text" as const,
+								text: answerBlocks + `\n\nNo web results for "${query}".`,
+							},
+						],
+						details: {
+							results: [],
+							query,
+							answers: renderedAnswers.map(answerDetail),
+							answerCount: renderedAnswers.length,
+						},
+					};
+				}
 				return {
 					content: [
 						{
@@ -331,7 +529,7 @@ export const webSearchTool = defineTool({
 
 			// Adaptive output formatting
 			const maxSnippetLen = count <= 3 ? 300 : 150;
-			let output = "";
+			let output = answerBlocks ? answerBlocks + "\n\n" : "";
 			for (const [i, r] of results.entries()) {
 				output += `${i + 1}. ${r.title}\n`;
 				output += `   ${r.url}\n`;
@@ -370,6 +568,8 @@ export const webSearchTool = defineTool({
 						engine: r.engine,
 						score: r.score,
 					})),
+					answers: renderedAnswers.map(answerDetail),
+					answerCount: renderedAnswers.length,
 				},
 			};
 		} catch (unexpectedErr) {
@@ -438,16 +638,37 @@ export const webSearchTool = defineTool({
 			| undefined;
 		const resultCount = details?.resultCount as number | undefined;
 		const query = details?.query as string | undefined;
+		const answerCount = details?.answerCount as number | undefined;
+		const answers = details?.answers as
+			| Array<{ template: string; text: string; url?: string }>
+			| undefined;
+
+		const answerTexts =
+			expanded && answers?.length
+				? answers.map((a) => theme.fg("accent", a.text)).join("\n")
+				: "";
+
+		if (answerCount && (!results || results.length === 0)) {
+			let msg = `${theme.fg("muted", `💡 ${answerCount} answer(s) for `)}${theme.fg("accent", `"${query ?? "?"}"`)}`;
+			if (answerTexts) msg += `\n${answerTexts}`;
+			return new Text(msg, 0, 0);
+		}
 
 		if (!results || results.length === 0) {
 			const msg = query ? `No results for "${query}"` : "No results";
 			return new Text(theme.fg("dim", msg), 0, 0);
 		}
 
+		const answerBadge = answerCount
+			? theme.fg("muted", `💡 ${answerCount} answer(s) · `)
+			: "";
 		let text =
+			answerBadge +
 			theme.fg("muted", `🔍 ${resultCount ?? results.length} result(s) for `) +
 			theme.fg("accent", `"${query ?? "?"}"`);
 
+		if (answerTexts) text += `\n${answerTexts}`;
+
 		const display = expanded ? results : results.slice(0, 5);
 
 		for (const r of display) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-lean-dimension",
-	"version": "0.2.1",
+	"version": "0.2.3",
 	"description": "Pi extension. The full Pi web-tools suite in one install — interactive browsing (pi-lean-portal) plus SearXNG search (pi-lean-search), unified under a /web toggle that removes the tools from context when switched off.",
 	"keywords": [
 		"pi-package",
@@ -32,8 +32,8 @@
 		]
 	},
 	"dependencies": {
-		"pi-lean-portal": "^0.2.1",
-		"pi-lean-search": "^0.2.1"
+		"pi-lean-portal": "^0.2.3",
+		"pi-lean-search": "^0.2.3"
 	},
 	"bundledDependencies": [
 		"pi-lean-portal",