@bacnh85/pi-web 0.4.5 → 0.5.0

package/README.md

@@ -1,4 +1,4 @@
-# pi-web v0.4
+# pi-web v0.5
 
 Pi extension for **unified web search, content extraction, site crawling, and page capture**.
 

package/extensions/index.ts

@@ -38,15 +38,13 @@ const sharedControlSchema = {
 };
 
 const firecrawlControlSchema = {
-	firecrawl_api_key: Type.Optional(Type.String({ description: "Firecrawl API key override. Prefer FIRECRAWL_API_KEY." })),
-	firecrawl_api_url: Type.Optional(Type.String({ description: "Firecrawl API URL override. Defaults to FIRECRAWL_API_URL or hosted." })),
-	timeout_ms: Type.Optional(Type.Number({ description: "Request timeout in milliseconds." })),
+	firecrawl_api_key: Type.Optional(Type.String({ description: "Override $FIRECRAWL_API_KEY." })),
+	firecrawl_api_url: Type.Optional(Type.String({ description: "Override $FIRECRAWL_API_URL." })),
 };
 
 const crawl4aiControlSchema = {
-	crawl4ai_api_url: Type.Optional(Type.String({ description: "Crawl4AI API URL override. Defaults to CRAWL4AI_API_URL or http://172.30.55.22:11235." })),
-	crawl4ai_api_token: Type.Optional(Type.String({ description: "Crawl4AI API token override. Prefer CRAWL4AI_API_TOKEN." })),
-	timeout_ms: Type.Optional(Type.Number({ description: "Request timeout in milliseconds." })),
+	crawl4ai_api_url: Type.Optional(Type.String({ description: "Override $CRAWL4AI_API_URL." })),
+	crawl4ai_api_token: Type.Optional(Type.String({ description: "Override $CRAWL4AI_API_TOKEN." })),
 };
 
 
@@ -82,29 +80,26 @@ export default function piWebExtension(pi: ExtensionAPI) {
 		name: "web_search",
 		label: "Web Search",
 		description:
-			"Search the web. Auto-selects backends adaptively: SearXNG, Brave, Firecrawl.",
+			"Search the web. Auto-selects backends: SearXNG, Brave, Firecrawl.",
 		promptSnippet: "Search current web results",
 		promptGuidelines: [
-			"Use web_search for source discovery, documentation lookup, current facts, and general web search.",
-			"Backend auto-selection is adaptive: broad discovery uses SearXNG first; precision queries, site: searches, docs/source lookups, and include_content use Brave first; Firecrawl is last resort.",
-			"If auto-selection returns poor-quality results, force backend: 'brave' or backend: 'searxng' for a different search index.",
-			"Use the backend parameter to force a specific search engine (e.g., backend: 'brave').",
-			"Use engines parameter for SearXNG tuning (e.g., engines: 'google,github' for technical queries).",
-			"include_content prefers Brave automatically because only Brave search fetches inline page content; for other result URLs, use web_extract.",
-			"Note: Firecrawl Search has poor semantic accuracy on domain-specific/ambiguous queries; prefer SearXNG or Brave for precision.",
-			"Cite result URLs when web results materially support the answer.",
+			"Source discovery, docs, facts, and general search.",
+			"Broad discovery uses SearXNG; precision/site/docs use Brave; Firecrawl is fallback.",
+			"Force backend via backend:'brave'|'searxng' for poor auto results.",
+			"Use engines='google,github' for SearXNG tuning.",
+			"Cite source URLs.",
 		],
 		parameters: Type.Object({
 			query: Type.String(),
 			count: Type.Optional(Type.Number({ default: 5 })),
-			freshness: Type.Optional(Type.String({ description: "Time filter: e.g., 'pw' (past week), 'pm' (past month), 'py' (past year), or a date range like '2024-01-01to2024-06-30'." })),
+			freshness: Type.Optional(Type.String({ description: "Time filter: pw/pm/py or YYYY-MM-DDtoYYYY-MM-DD." })),
 			country: Type.Optional(Type.String({ default: "US" })),
 			backend: Type.Optional(Type.Union(
 				[Type.Literal("auto"), Type.Literal("searxng"), Type.Literal("brave"), Type.Literal("firecrawl")],
-				{ default: "auto", description: "Search backend: auto (default), searxng, brave, or firecrawl." },
+				{ default: "auto", description: "auto, searxng, brave, firecrawl." },
 			)),
-			engines: Type.Optional(Type.String({ description: "SearXNG engine override (e.g., 'google,github' for technical queries). Only used when backend is searxng or auto." })),
-			include_content: Type.Optional(Type.Boolean({ default: false, description: "Fetch page content alongside search results. Slower but provides inline content." })),
+			engines: Type.Optional(Type.String({ description: "SearXNG engine list (google,github). Only for searxng/auto backend." })),
+			include_content: Type.Optional(Type.Boolean({ default: false, description: "Fetch inline page content (slower)." })),
 			content_chars: Type.Optional(Type.Number({ default: 5000 })),
 			...sharedControlSchema,
 		}),
@@ -133,30 +128,27 @@ export default function piWebExtension(pi: ExtensionAPI) {
 		name: "web_extract",
 		label: "Web Content Extraction",
 		description:
-			"Extract readable content from a URL. Auto backend: static \u2192 dynamic \u2192 full.",
+			"Extract readable content from a URL. Auto mode: static\u2192dynamic\u2192full.",
 		promptSnippet: "Extract readable webpage content as markdown",
 		promptGuidelines: [
-			"Use web_extract to get clean markdown content from a known URL.",
-			"Use mode: 'static' for simple static pages (fast, no API key needed, uses JSDOM+Readability).",
-			"Use mode: 'dynamic' for JavaScript-rendered pages (uses Firecrawl Scrape).",
-			"Use mode: 'full' for pages that need Crawl4AI rendering when other modes fail (resource-intensive).",
-			"Default mode 'auto' tries static → dynamic → full. Successive fallbacks are noted in output.",
-			"⚠️ Dynamic mode (Firecrawl Scrape) may fail on bot-protected sites (Ansible docs, CDN-backed doc sites). Full mode (Crawl4AI) handles more sites but is heavier.",
-			"If all extraction modes fail, try web_screenshot for a visual snapshot, or the page may require interactive login.",
-			"Use the prompt and schema parameters for structured JSON extraction (dynamic mode only); structured JSON is returned in details and text when available.",
-			"Cite the source URL when using extracted content in an answer.",
+			"Clean markdown from a known URL.",
+			"mode: 'static' (no API key, JSDOM), 'dynamic' (Firecrawl JS), 'full' (Crawl4AI).",
+			"'auto' tries static\u2192dynamic\u2192full; see diagnostics for fallback chain.",
+			"Use prompt+schema for structured JSON extraction (dynamic mode only).",
+			"Cite the source URL.",
 		],
 		parameters: Type.Object({
 			url: Type.String(),
 			mode: Type.Optional(Type.Union(
 				[Type.Literal("auto"), Type.Literal("static"), Type.Literal("dynamic"), Type.Literal("full")],
-				{ default: "auto", description: "Extraction mode: auto (default), static, dynamic, or full." },
+				{ default: "auto", description: "auto, static, dynamic, full." },
 			)),
 			prompt: Type.Optional(Type.String({ description: "Prompt for structured JSON extraction (dynamic mode only)." })),
 			schema: Type.Optional(Type.Any({ description: "JSON schema for structured extraction (dynamic mode only)." })),
 			content_chars: Type.Optional(Type.Number({ default: 20000 })),
-			wait_for: Type.Optional(Type.Number({ description: "Milliseconds to wait for Firecrawl dynamic rendering before extraction. Full mode uses Crawl4AI /md and may ignore this." })),
-			mobile: Type.Optional(Type.Boolean({ default: false, description: "Emulate mobile viewport (dynamic mode only)." })),
+			wait_for: Type.Optional(Type.Number({ description: "Ms to wait for Firecrawl render before extraction." })),
+			mobile: Type.Optional(Type.Boolean({ default: false, description: "Mobile viewport (dynamic mode only)." })),
+			...crawl4aiControlSchema,
 			...sharedControlSchema,
 		}),
 		async execute(_id: string, params: Record<string, unknown>, signal: AbortSignal, _onUpdate: unknown, ctx: any) {
@@ -169,6 +161,8 @@ export default function piWebExtension(pi: ExtensionAPI) {
 				timeout_ms: params.timeout_ms as number | undefined,
 				wait_for: params.wait_for as number | undefined,
 				mobile: params.mobile as boolean | undefined,
+				crawl4ai_api_token: params.crawl4ai_api_token as string | undefined,
+				crawl4ai_api_url: params.crawl4ai_api_url as string | undefined,
 				signal,
 				_ctx: ctx,
 			});
@@ -184,24 +178,23 @@ export default function piWebExtension(pi: ExtensionAPI) {
 		name: "web_map",
 		label: "Site URL Discovery",
 		description:
-			"Discover URLs from a site using Firecrawl Map.",
+			"Discover site URLs via Firecrawl Map.",
 		promptSnippet: "Map site URLs",
 		promptGuidelines: [
-			"Use web_map to discover URLs from a site before crawling or targeted extraction.",
-			"Works best on base domains (e.g., https://example.com). Returns fewer results on sub-paths; use sitemap: 'only' for sitemap-only discovery on sub-paths.",
-			"Use sitemap: 'only' for sitemap-only discovery.",
-			"Use mapped URLs with web_extract for targeted extraction instead of web_crawl when only a few pages are needed.",
-			"Keep limits small unless broad site discovery is explicitly requested.",
+			"Discover site URLs before crawling. Prefer web_extract for small jobs.",
+			"Best on base domains. sitemap:'only' for sub-path discovery.",
+			"Keep limits small unless broad discovery is requested.",
 		],
 		parameters: Type.Object({
 			url: Type.String(),
 			limit: Type.Optional(Type.Number({ default: 100 })),
 			include_subdomains: Type.Optional(Type.Boolean({ default: false })),
-			search: Type.Optional(Type.String({ description: "Optional search query to guide URL discovery (semantic map)." })),
-			sitemap: Type.Optional(Type.Union([Type.Literal("only"), Type.Literal("include"), Type.Literal("skip")], { description: "Sitemap mode: include (default), only (sitemap-only), or skip." })),
-			use_index: Type.Optional(Type.Boolean({ default: true, description: "Whether to use the Firecrawl search index for URL discovery." })),
-			ignore_cache: Type.Optional(Type.Boolean({ default: false, description: "Ignore cached map results." })),
+			search: Type.Optional(Type.String({ description: "Search query to guide URL discovery (semantic map)." })),
+			sitemap: Type.Optional(Type.Union([Type.Literal("only"), Type.Literal("include"), Type.Literal("skip")], { description: "only, include(default), skip." })),
+			use_index: Type.Optional(Type.Boolean({ default: true, description: "Use Firecrawl index for discovery." })),
+			ignore_cache: Type.Optional(Type.Boolean({ default: false, description: "Ignore cached results." })),
 			...firecrawlControlSchema,
+			...sharedControlSchema,
 		}),
 		async execute(_id: string, params: Record<string, unknown>, signal: AbortSignal, _onUpdate: unknown, ctx: any) {
 			const body: Record<string, unknown> = {
@@ -228,30 +221,27 @@ export default function piWebExtension(pi: ExtensionAPI) {
 		name: "web_crawl",
 		label: "Site Crawl",
 		description:
-			"Crawl site pages. Firecrawl 'light' or Crawl4AI 'full' headless mode.",
+			"Crawl pages. Firecrawl 'light' or Crawl4AI 'full' headless mode.",
 		promptSnippet: "Crawl a small site section",
 		promptGuidelines: [
-			"Use web_crawl only when multiple pages from a site are truly needed; prefer web_map + web_extract for small numbers of pages.",
-			"Use mode: 'light' (default) for conservative Firecrawl crawling of docs/sites.",
-			"Use mode: 'full' for Crawl4AI crawling with full rendered data (JS, media, links). More resource-intensive.",
-			"For Firecrawl mode ('light'), use the url parameter with optional include_paths/exclude_paths.",
-			"For Crawl4AI mode ('full'), use the urls (array) parameter for batch crawling up to 100 URLs.",
-			"Keep limits conservative (default 10) unless the user explicitly requests large crawls.",
-			"Try web_map first to identify candidate URLs and pass them to web_extract before resorting to a full crawl.",
+			"Prefer web_map + web_extract over crawl for small jobs.",
+			"'light'=Firecrawl (url param), 'full'=Crawl4AI (urls[] param).",
+			"Keep limit low (default 10).",
 		],
 		parameters: Type.Object({
-			url: Type.Optional(Type.String({ description: "URL for Firecrawl-style single-page crawl (mode: 'light')." })),
-			urls: Type.Optional(Type.Array(Type.String(), { description: "URLs for Crawl4AI-style multi-URL crawl (mode: 'full'), up to 100." })),
-			mode: Type.Optional(Type.Union([Type.Literal("light"), Type.Literal("full")], { default: "light", description: "Crawl mode: 'light' (Firecrawl, conservative) or 'full' (Crawl4AI, rendered data)." })),
+			url: Type.Optional(Type.String({ description: "URL for Firecrawl-style crawl (mode:'light')." })),
+			urls: Type.Optional(Type.Array(Type.String(), { description: "URLs for Crawl4AI-style crawl (mode:'full'), up to 100." })),
+			mode: Type.Optional(Type.Union([Type.Literal("light"), Type.Literal("full")], { default: "light", description: "'light'(Firecrawl) or 'full'(Crawl4AI)." })),
 			limit: Type.Optional(Type.Number({ default: 10 })),
-			include_paths: Type.Optional(Type.String({ description: "Comma-separated path patterns to include (Firecrawl mode only)." })),
-			exclude_paths: Type.Optional(Type.String({ description: "Comma-separated path patterns to exclude (Firecrawl mode only)." })),
-			poll: Type.Optional(Type.Boolean({ default: false, description: "Poll for crawl completion (Firecrawl mode only)." })),
-			browser_config: Type.Optional(Type.Any({ description: "Optional BrowserConfig JSON object (Crawl4AI mode only)." })),
-			crawler_config: Type.Optional(Type.Any({ description: "Optional CrawlerRunConfig JSON object (Crawl4AI mode only)." })),
+			include_paths: Type.Optional(Type.String({ description: "Comma-separated paths to include (Firecrawl mode)." })),
+			exclude_paths: Type.Optional(Type.String({ description: "Comma-separated paths to exclude (Firecrawl mode)." })),
+			poll: Type.Optional(Type.Boolean({ default: false, description: "Poll for completion (Firecrawl mode)." })),
+			browser_config: Type.Optional(Type.Any({ description: "BrowserConfig JSON (full mode only)." })),
+			crawler_config: Type.Optional(Type.Any({ description: "CrawlerRunConfig JSON (full mode only)." })),
 			content_chars: Type.Optional(Type.Number({ default: 20000 })),
 			...firecrawlControlSchema,
 			...crawl4aiControlSchema,
+			...sharedControlSchema,
 		}),
 		async execute(_id: string, params: Record<string, unknown>, signal: AbortSignal, _onUpdate: unknown, ctx: any) {
 			const mode = (params.mode as string) || "light";
@@ -319,19 +309,18 @@ export default function piWebExtension(pi: ExtensionAPI) {
 		name: "web_screenshot",
 		label: "Web Page Screenshot",
 		description:
-			"Capture a full-page PNG screenshot via Crawl4AI headless browser.",
+			"Full-page PNG screenshot via Crawl4AI.",
 		promptSnippet: "Screenshot a webpage",
 		promptGuidelines: [
-			"Use web_screenshot when a visual snapshot of a rendered page is needed, or when web_extract fails on a heavily JS-dependent or bot-protected page.",
-			"The screenshot is returned as a base64-encoded PNG string.",
-			"Use wait_for to delay capture for dynamic content to render (default 2 seconds).",
-			"Use wait_for_images to ensure images are loaded before capture.",
+			"Use when web_extract fails on JS-heavy or bot-protected pages.",
+			"wait_for (default 2s) delays capture for dynamic content.",
 		],
 		parameters: Type.Object({
 			url: Type.String(),
-			wait_for: Type.Optional(Type.Number({ default: 2, description: "Seconds to wait before capturing screenshot." })),
-			wait_for_images: Type.Optional(Type.Boolean({ default: false, description: "Wait for images to load before capture." })),
+			wait_for: Type.Optional(Type.Number({ default: 2, description: "Seconds to wait before capture." })),
+			wait_for_images: Type.Optional(Type.Boolean({ default: false, description: "Wait for images before capture." })),
 			...crawl4aiControlSchema,
+			...sharedControlSchema,
 		}),
 		async execute(_id: string, params: Record<string, unknown>, signal: AbortSignal, _onUpdate: unknown, ctx: any) {
 			const config = loadCrawl4aiConfig(params as Record<string, unknown>, cwdFromContext(ctx), includeProjectEnv(ctx));
@@ -360,15 +349,16 @@ export default function piWebExtension(pi: ExtensionAPI) {
 		name: "web_pdf",
 		label: "Web Page PDF",
 		description:
-			"Generate a PDF document via Crawl4AI headless browser.",
+			"PDF document via Crawl4AI.",
 		promptSnippet: "PDF a webpage",
 		promptGuidelines: [
-			"Use web_pdf when a printable or archivable snapshot of a page is needed.",
-			"The PDF is returned as a base64-encoded string.",
+			"Printable or archivable page snapshot.",
+			"Returns base64 PDF string.",
 		],
 		parameters: Type.Object({
 			url: Type.String(),
 			...crawl4aiControlSchema,
+			...sharedControlSchema,
 		}),
 		async execute(_id: string, params: Record<string, unknown>, signal: AbortSignal, _onUpdate: unknown, ctx: any) {
 			const config = loadCrawl4aiConfig(params as Record<string, unknown>, cwdFromContext(ctx), includeProjectEnv(ctx));
@@ -389,14 +379,12 @@ export default function piWebExtension(pi: ExtensionAPI) {
 		name: "web_status",
 		label: "Web Provider Status",
 		description:
-			"Show web provider configuration status without printing secrets.",
-		promptSnippet: "Check web provider configuration and server status",
+			"Show web provider config status without printing secrets.",
+		promptSnippet: "Check web provider config and server status",
 		promptGuidelines: [
-			"Use web_status when web tools fail due to missing credentials/config or to verify which backends are available.",
-			"The output shows which backends are configured; if a backend is missing, configure its env vars.",
-			"Never print API key values; this tool reports only presence and source.",
-			"Shows Crawl4AI server health, version, and auth status when the server is reachable.",
-			"For Firecrawl, `apiKeyFound: false` is normal for self-hosted instances without auth. Use the `ready` field to check whether Firecrawl is actually usable.",
+			"Check which backends are configured and their server status.",
+			"Never prints secrets — reports only presence and source.",
+			"apiKeyFound:false is normal for self-hosted Firecrawl; check ready field.",
 		],
 		parameters: Type.Object({}),
 		async execute(_id: string, _params: Record<string, unknown>, signal: AbortSignal, _onUpdate: unknown, ctx: any) {

package/extensions/lib/extract.ts

@@ -24,6 +24,8 @@ export interface ExtractParams {
 	timeout_ms?: number;
 	wait_for?: number;
 	mobile?: boolean;
+	crawl4ai_api_token?: string;
+	crawl4ai_api_url?: string;
 	signal?: AbortSignal;
 	/** Internal: caller-provided ctx for env lookup. */
 	_ctx?: Record<string, unknown>;
@@ -126,7 +128,11 @@ async function extractDynamic(params: ExtractParams, ctx?: Record<string, unknow
 async function extractFull(params: ExtractParams, ctx?: Record<string, unknown>): Promise<ExtractResult | null> {
 	let c4aiConfig: Crawl4aiConfig;
 	try {
-		c4aiConfig = loadCrawl4aiConfig({}, cwdFromContext(ctx ?? {}), includeProjectEnv(ctx ?? {}));
+		c4aiConfig = loadCrawl4aiConfig(
+		{ crawl4ai_api_token: params.crawl4ai_api_token, crawl4ai_api_url: params.crawl4ai_api_url },
+		cwdFromContext(ctx ?? {}),
+		includeProjectEnv(ctx ?? {}),
+	);
 	} catch (e) {
 		throw new Error(`Crawl4AI configuration unavailable: ${sanitizeError(e)}`);
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bacnh85/pi-web",
-  "version": "0.4.5",
+  "version": "0.5.0",
   "description": "Pi extension for web search, page extraction, Firecrawl scraping/crawling, and Crawl4AI headless browser crawling.",
   "type": "module",
   "license": "MIT",
@@ -28,7 +28,9 @@
   },
   "files": [
     "README.md",
-    "extensions/",
+    "extensions/index.ts",
+    "extensions/lib/",
+    "extensions/types.d.ts",
     "skills/"
   ],
   "pi": {

package/extensions/.mocharc.yml

@@ -1,5 +0,0 @@
-require:
-  - tsx
-spec:
-  - test/**/*.test.ts
-timeout: 10000

package/extensions/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "module"
-}

package/extensions/test/unit/config.test.ts

@@ -1,309 +0,0 @@
-/**
- * Unit tests for pi-web config module.
- */
-
-import { expect } from "chai";
-import {
-	stripInlineComment,
-	parseDotenvValue,
-	parseDotenvFile,
-	piConfigDirs,
-	envFileCandidates,
-	findEnvValue,
-	normalizeSearxngBaseUrl,
-	normalizeFirecrawlBaseUrl,
-	normalizeCrawl4aiApiUrl,
-	loadCrawl4aiConfig,
-	DEFAULT_SEARXNG_BASE_URL,
-	DEFAULT_CRAWL4AI_API_URL,
-	HOSTED_FIRECRAWL_BASE_URL,
-} from "../../lib/config";
-
-describe("stripInlineComment", () => {
-	it("returns full value when no comment", () => {
-		expect(stripInlineComment("hello")).to.equal("hello");
-		expect(stripInlineComment("")).to.equal("");
-	});
-
-	it("strips comment after space", () => {
-		expect(stripInlineComment("hello # world")).to.equal("hello ");
-		expect(stripInlineComment("value #comment")).to.equal("value ");
-	});
-
-	it("preserves # inside single quotes", () => {
-		expect(stripInlineComment("'hello # world'")).to.equal("'hello # world'");
-	});
-
-	it("preserves # inside double quotes", () => {
-		expect(stripInlineComment('"hello # world"')).to.equal('"hello # world"');
-	});
-
-	it("handles escaped characters inside quotes", () => {
-		expect(stripInlineComment('"hello \\" world" # comment')).to.equal(
-			'"hello \\" world" ',
-		);
-	});
-
-	it("strips comment when # is first character", () => {
-		expect(stripInlineComment("# comment")).to.equal("");
-	});
-
-	it("handles mixed quoted and unquoted content", () => {
-		expect(stripInlineComment("key='val' # comment")).to.equal("key='val' ");
-	});
-
-	it("handles escaped # with backslash", () => {
-		expect(stripInlineComment("hello \\# not a comment")).to.equal(
-			"hello \\# not a comment",
-		);
-	});
-});
-
-describe("parseDotenvValue", () => {
-	it("trims and returns unquoted value", () => {
-		expect(parseDotenvValue("  hello  ")).to.equal("hello");
-	});
-
-	it("strips double quotes", () => {
-		expect(parseDotenvValue('"hello"')).to.equal("hello");
-	});
-
-	it("strips single quotes", () => {
-		expect(parseDotenvValue("'hello'")).to.equal("hello");
-	});
-
-	it("handles escape sequences in double-quoted values", () => {
-		expect(parseDotenvValue('"hello\\nworld"')).to.equal("hello\nworld");
-		expect(parseDotenvValue('"path\\tto\\truby"')).to.equal("path\tto\truby");
-	});
-
-	it("trims whitespace in unquoted values", () => {
-		expect(parseDotenvValue("  hello world  ")).to.equal("hello world");
-	});
-
-	it("refuses to remove double quotes from single-quoted value", () => {
-		expect(parseDotenvValue("'hello\"'")).to.equal('hello"');
-	});
-
-	it("strips inline comment from unquoted value", () => {
-		expect(parseDotenvValue("hello # comment")).to.equal("hello");
-	});
-});
-
-describe("parseDotenvFile", () => {
-	it("returns null for non-existent file", () => {
-		const result = parseDotenvFile("/tmp/nonexistent-file-12345.env");
-		expect(result).to.be.null;
-	});
-
-	it("parses a simple env file content via temp testing", async () => {
-		const fs = await import("node:fs");
-		const path = await import("node:path");
-		const tmpDir = fs.mkdtempSync("/tmp/pi-web-test-");
-		const testFile = path.join(tmpDir, ".env");
-		fs.writeFileSync(
-			testFile,
-			"FOO=bar\nBAZ=qux # inline comment\n# FULL LINE COMMENT\nEMPTY=\n",
-			"utf8",
-		);
-		try {
-			const result = parseDotenvFile(testFile);
-			expect(result).to.deep.equal({ FOO: "bar", BAZ: "qux", EMPTY: "" });
-		} finally {
-			fs.rmSync(tmpDir, { recursive: true, force: true });
-		}
-	});
-});
-
-describe("piConfigDirs", () => {
-	const origEnv = process.env.PI_CODING_AGENT_DIR;
-
-	afterEach(() => {
-		if (origEnv === undefined) {
-			delete process.env.PI_CODING_AGENT_DIR;
-		} else {
-			process.env.PI_CODING_AGENT_DIR = origEnv;
-		}
-	});
-
-	it("returns custom dir when PI_CODING_AGENT_DIR is set", () => {
-		process.env.PI_CODING_AGENT_DIR = "/custom/pi";
-		const dirs = piConfigDirs();
-		expect(dirs).to.deep.equal(["/custom/pi"]);
-	});
-
-	it("returns default dir when PI_CODING_AGENT_DIR is not set", () => {
-		delete process.env.PI_CODING_AGENT_DIR;
-		const dirs = piConfigDirs();
-		expect(dirs).to.have.length(1);
-		expect(dirs[0]).to.include(".pi/agent");
-	});
-});
-
-describe("envFileCandidates", () => {
-	it("includes cwd files and pi config dirs", () => {
-		const candidates = envFileCandidates("/test/project", true);
-		expect(candidates[0]).to.equal("/test/project/.env.local");
-		expect(candidates[1]).to.equal("/test/project/.env");
-	});
-
-	it("omits cwd files when includeCwd is false", () => {
-		const candidates = envFileCandidates("/test/project", false);
-		expect(candidates[0]).not.to.include("/test/project");
-	});
-
-	it("returns pi config dir entries", () => {
-		const candidates = envFileCandidates("/test/project", true);
-		expect(candidates.length).to.be.at.least(2); // cwd .env.local, cwd .env
-	});
-});
-
-describe("normalizeSearxngBaseUrl", () => {
-	it("returns default when nothing provided", () => {
-		expect(normalizeSearxngBaseUrl()).to.equal(DEFAULT_SEARXNG_BASE_URL);
-	});
-
-	it("preserves full URL with scheme", () => {
-		expect(normalizeSearxngBaseUrl("https://search.example.com")).to.equal(
-			"https://search.example.com",
-		);
-	});
-
-	it("adds http for localhost", () => {
-		expect(normalizeSearxngBaseUrl("localhost:8888")).to.equal(
-			"http://localhost:8888",
-		);
-	});
-
-	it("adds http for private IP", () => {
-		expect(normalizeSearxngBaseUrl("192.168.1.1:8888")).to.equal(
-			"http://192.168.1.1:8888",
-		);
-	});
-
-	it("adds https for public hostname", () => {
-		expect(normalizeSearxngBaseUrl("search.example.com")).to.equal(
-			"https://search.example.com",
-		);
-	});
-
-	it("removes trailing slashes", () => {
-		expect(normalizeSearxngBaseUrl("http://localhost:8888/")).to.equal(
-			"http://localhost:8888",
-		);
-	});
-});
-
-describe("normalizeFirecrawlBaseUrl", () => {
-	it("returns hosted default when nothing provided", () => {
-		expect(normalizeFirecrawlBaseUrl()).to.equal(HOSTED_FIRECRAWL_BASE_URL);
-	});
-
-	it("appends /v2 if no version segment", () => {
-		expect(
-			normalizeFirecrawlBaseUrl("http://localhost:3002"),
-		).to.equal("http://localhost:3002/v2");
-	});
-
-	it("preserves existing version segment", () => {
-		expect(
-			normalizeFirecrawlBaseUrl("http://localhost:3002/v1"),
-		).to.equal("http://localhost:3002/v1");
-	});
-
-	it("removes trailing slash before appending version", () => {
-		expect(
-			normalizeFirecrawlBaseUrl("http://localhost:3002/"),
-		).to.equal("http://localhost:3002/v2");
-	});
-});
-
-describe("findEnvValue", () => {
-	it("reads from process.env first", () => {
-		process.env.TEST_PI_WEB_VAR = "from_process";
-		try {
-			const result = findEnvValue("TEST_PI_WEB_VAR", "/tmp", false);
-			expect(result.value).to.equal("from_process");
-			expect(result.source).to.equal("process.env");
-		} finally {
-			delete process.env.TEST_PI_WEB_VAR;
-		}
-	});
-
-	it("returns undefined when not found", () => {
-		const result = findEnvValue("THIS_VAR_DOES_NOT_EXIST_12345", "/tmp", false);
-		expect(result.value).to.be.undefined;
-		expect(result.source).to.equal("");
-	});
-});
-
-describe("normalizeCrawl4aiApiUrl", () => {
-	it("returns default when nothing provided", () => {
-		expect(normalizeCrawl4aiApiUrl()).to.equal(DEFAULT_CRAWL4AI_API_URL);
-	});
-
-	it("preserves full URL with scheme", () => {
-		expect(normalizeCrawl4aiApiUrl("https://crawl.example.com")).to.equal(
-			"https://crawl.example.com",
-		);
-	});
-
-	it("adds http for private IP", () => {
-		expect(normalizeCrawl4aiApiUrl("172.30.55.22:11235")).to.equal(
-			"http://172.30.55.22:11235",
-		);
-	});
-
-	it("adds https for public hostname", () => {
-		expect(normalizeCrawl4aiApiUrl("crawl.example.com")).to.equal(
-			"https://crawl.example.com",
-		);
-	});
-
-	it("removes trailing slashes", () => {
-		expect(normalizeCrawl4aiApiUrl("http://localhost:11235/")).to.equal(
-			"http://localhost:11235",
-		);
-	});
-
-	it("does not append /v2 like Firecrawl", () => {
-		expect(normalizeCrawl4aiApiUrl("http://localhost:11235")).to.equal(
-			"http://localhost:11235",
-		);
-	});
-});
-
-describe("loadCrawl4aiConfig", () => {
-	it("returns default config from defaults", () => {
-		const config = loadCrawl4aiConfig({}, "/tmp", false);
-		expect(config.baseUrl).to.equal(DEFAULT_CRAWL4AI_API_URL);
-		expect(config.timeoutMs).to.equal(60000);
-	});
-
-	it("accepts explicit API URL from params", () => {
-		const config = loadCrawl4aiConfig(
-			{ crawl4ai_api_url: "http://custom:12345" },
-			"/tmp",
-			false,
-		);
-		expect(config.baseUrl).to.equal("http://custom:12345");
-	});
-
-	it("accepts explicit API token from params", () => {
-		const config = loadCrawl4aiConfig(
-			{ crawl4ai_api_token: "my-token" },
-			"/tmp",
-			false,
-		);
-		expect(config.apiToken).to.equal("my-token");
-	});
-
-	it("reads timeout from params", () => {
-		const config = loadCrawl4aiConfig({ timeout_ms: 30000 }, "/tmp", false);
-		expect(config.timeoutMs).to.equal(30000);
-	});
-
-	it("throws on invalid timeout", () => {
-		expect(() => loadCrawl4aiConfig({ timeout_ms: 500 }, "/tmp", false)).to.throw();
-	});
-});

package/extensions/test/unit/crawl4ai.test.ts

@@ -1,69 +0,0 @@
-/**
- * Unit tests for pi-web Crawl4AI client.
- */
-
-import { expect } from "chai";
-import { Crawl4aiHttpError } from "../../lib/crawl4ai";
-
-describe("Crawl4aiHttpError", () => {
-	it("formats error message with status and text", () => {
-		const err = new Crawl4aiHttpError(401, "Unauthorized", '{"detail":"bad token"}');
-		expect(err.status).to.equal(401);
-		expect(err.message).to.include("HTTP 401: Unauthorized");
-		expect(err.message).to.include('{"detail":"bad token"}');
-	});
-
-	it("handles empty response text", () => {
-		const err = new Crawl4aiHttpError(500, "Internal Server Error", "");
-		expect(err.status).to.equal(500);
-		expect(err.message).to.equal("HTTP 500: Internal Server Error");
-	});
-
-	it("is instance of Error", () => {
-		const err = new Crawl4aiHttpError(403, "Forbidden", "rate limit");
-		expect(err).to.be.instanceOf(Error);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Config + format integration: verify imported functions exist with correct sigs
-// ---------------------------------------------------------------------------
-
-import type { Crawl4aiConfig } from "../../lib/config";
-
-describe("Crawl4aiConfig interface", () => {
-	it("has expected shape", () => {
-		const config: Crawl4aiConfig = {
-			baseUrl: "http://localhost:11235",
-			apiToken: "token123",
-			timeoutMs: 30000,
-		};
-		expect(config.baseUrl).to.equal("http://localhost:11235");
-		expect(config.apiToken).to.equal("token123");
-		expect(config.timeoutMs).to.equal(30000);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// Verify client exports exist
-// ---------------------------------------------------------------------------
-
-import {
-	fetchCrawl4aiMarkdown,
-	fetchCrawl4aiCrawl,
-	fetchCrawl4aiScreenshot,
-	fetchCrawl4aiPdf,
-	fetchCrawl4aiHealth,
-	crawl4aiRequest,
-} from "../../lib/crawl4ai";
-
-describe("Crawl4AI client exports", () => {
-	it("exports all expected functions", () => {
-		expect(fetchCrawl4aiMarkdown).to.be.a("function");
-		expect(fetchCrawl4aiCrawl).to.be.a("function");
-		expect(fetchCrawl4aiScreenshot).to.be.a("function");
-		expect(fetchCrawl4aiPdf).to.be.a("function");
-		expect(fetchCrawl4aiHealth).to.be.a("function");
-		expect(crawl4aiRequest).to.be.a("function");
-	});
-});

package/extensions/test/unit/extract.test.ts

@@ -1,134 +0,0 @@
-import { expect } from "chai";
-
-import {
-	extractWithDiagnostics,
-	type ExtractMode,
-	type ExtractParams,
-	type ExtractResult,
-} from "../../lib/extract";
-
-const ORIGINAL_ENV = { ...process.env };
-const ORIGINAL_FETCH = globalThis.fetch;
-
-function jsonResponse(body: unknown, status = 200): Response {
-	return new Response(JSON.stringify(body), {
-		status,
-		headers: { "content-type": "application/json" },
-	});
-}
-
-function htmlResponse(body: string, status = 200): Response {
-	return new Response(body, {
-		status,
-		headers: { "content-type": "text/html" },
-	});
-}
-
-function installMockFetch(handler: (url: string, init?: RequestInit) => Response | Promise<Response>): string[] {
-	const calls: string[] = [];
-	globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
-		const url = String(input);
-		calls.push(url);
-		return handler(url, init);
-	}) as typeof fetch;
-	return calls;
-}
-
-function restoreEnv(): void {
-	process.env = { ...ORIGINAL_ENV };
-}
-
-describe("ExtractParams and ExtractResult types", () => {
-	it("accept expected fields", () => {
-		const modes: ExtractMode[] = ["auto", "static", "dynamic", "full"];
-		const params: ExtractParams = { url: "https://example.com", mode: modes[0], wait_for: 1000, mobile: true };
-		const result: ExtractResult = { title: "Title", markdown: "Content", backend: "static", structured: { ok: true } };
-		expect(params.mode).to.equal("auto");
-		expect(result.structured).to.deep.equal({ ok: true });
-	});
-});
-
-describe("extractWithDiagnostics", () => {
-	beforeEach(() => {
-		restoreEnv();
-		process.env.FIRECRAWL_API_URL = "http://firecrawl.test/v2";
-		process.env.CRAWL4AI_API_URL = "http://crawl4ai.test";
-	});
-
-	afterEach(() => {
-		globalThis.fetch = ORIGINAL_FETCH;
-		restoreEnv();
-	});
-
-	it("uses static extraction when it returns useful content", async () => {
-		installMockFetch((url) => {
-			if (url === "https://example.com/static") {
-				return htmlResponse("<html><head><title>Static</title></head><body><main><h1>Static</h1><p>This static article has enough readable text to pass the useful-content threshold in auto mode without falling back.</p><p>Additional words make it reliably longer than the minimum threshold.</p></main></body></html>");
-			}
-			throw new Error(`unexpected fetch ${url}`);
-		});
-
-		const diagnostics = await extractWithDiagnostics({ url: "https://example.com/static" });
-		expect(diagnostics.selectedMode).to.equal("static");
-		expect(diagnostics.fallbackUsed).to.be.false;
-		expect(diagnostics.result.markdown).to.include("static article");
-	});
-
-	it("falls through from short static content to dynamic extraction", async () => {
-		const calls = installMockFetch((url) => {
-			if (url === "https://example.com/short") return htmlResponse("<html><body><main>short</main></body></html>");
-			if (url === "http://firecrawl.test/v2/scrape") {
-				return jsonResponse({ data: { markdown: "# Dynamic\n\nDynamic content from Firecrawl after static extraction was too short.", metadata: { title: "Dynamic", sourceURL: "https://example.com/short" } } });
-			}
-			throw new Error(`unexpected fetch ${url}`);
-		});
-
-		const diagnostics = await extractWithDiagnostics({ url: "https://example.com/short" });
-		expect(diagnostics.selectedMode).to.equal("dynamic");
-		expect(diagnostics.fallbackUsed).to.be.true;
-		expect(diagnostics.attempts.map((a) => a.mode)).to.deep.equal(["static", "dynamic"]);
-		expect(diagnostics.result.markdown).to.include("fell back to Firecrawl");
-		expect(calls).to.deep.equal(["https://example.com/short", "http://firecrawl.test/v2/scrape"]);
-	});
-
-	it("explicit static mode does not fall through", async () => {
-		installMockFetch((url) => {
-			if (url === "https://example.com/short") return htmlResponse("<html><body><main>short</main></body></html>");
-			throw new Error(`unexpected fetch ${url}`);
-		});
-
-		const diagnostics = await extractWithDiagnostics({ url: "https://example.com/short", mode: "static" });
-		expect(diagnostics.selectedMode).to.equal("static");
-		expect(diagnostics.result.markdown).to.include("short");
-	});
-
-	it("dynamic mode includes structured JSON output when present", async () => {
-		installMockFetch((url, init) => {
-			if (url === "http://firecrawl.test/v2/scrape") {
-				const body = JSON.parse(String(init?.body));
-				expect(body.formats).to.deep.include({ type: "json", prompt: "Extract title" });
-				return jsonResponse({ data: { markdown: "# Dynamic\n\nBody", json: { title: "Structured" }, metadata: { title: "Dynamic" } } });
-			}
-			throw new Error(`unexpected fetch ${url}`);
-		});
-
-		const diagnostics = await extractWithDiagnostics({ url: "https://example.com/dynamic", mode: "dynamic", prompt: "Extract title" });
-		expect(diagnostics.result.structured).to.deep.equal({ title: "Structured" });
-		expect(diagnostics.result.markdown).to.include("## Structured extraction");
-	});
-
-	it("falls through to full mode when static and dynamic fail", async () => {
-		installMockFetch((url) => {
-			if (url === "https://example.com/full") return htmlResponse("<html><body><main>tiny</main></body></html>");
-			if (url === "http://firecrawl.test/v2/scrape") return jsonResponse({ error: "blocked" }, 500);
-			if (url === "http://crawl4ai.test/md") return jsonResponse({ success: true, markdown: "# Full\n\nCrawl4AI markdown content" });
-			throw new Error(`unexpected fetch ${url}`);
-		});
-
-		const diagnostics = await extractWithDiagnostics({ url: "https://example.com/full" });
-		expect(diagnostics.selectedMode).to.equal("full");
-		expect(diagnostics.attempts.map((a) => a.mode)).to.deep.equal(["static", "dynamic", "full"]);
-		expect(diagnostics.result.markdown).to.include("Crawl4AI");
-	});
-
-});

package/extensions/test/unit/format.test.ts

@@ -1,194 +0,0 @@
-/**
- * Unit tests for pi-web format module.
- */
-
-import { expect } from "chai";
-import {
-	sanitizeSnippet,
-	truncateText,
-	formatFirecrawlScrape,
-	formatCrawl4aiResult,
-	type SearchResultItem,
-} from "../../lib/format";
-
-const OUTPUT_MAX_BYTES = 50 * 1024;
-const OUTPUT_MAX_LINES = 2_000;
-
-describe("sanitizeSnippet", () => {
-	it("returns empty string for empty input", () => {
-		expect(sanitizeSnippet()).to.equal("");
-		expect(sanitizeSnippet("")).to.equal("");
-	});
-
-	it("strips HTML tags", () => {
-		expect(sanitizeSnippet("<b>hello</b> world")).to.equal("hello world");
-	});
-
-	it("decodes HTML entities", () => {
-		expect(sanitizeSnippet("foo &amp; bar")).to.equal("foo & bar");
-		expect(sanitizeSnippet("&lt;tag&gt;")).to.equal("<tag>");
-		expect(sanitizeSnippet("&quot;quoted&quot;")).to.equal('"quoted"');
-		expect(sanitizeSnippet("hello&nbsp;world")).to.equal("hello world");
-	});
-
-	it("decodes numeric HTML entities", () => {
-		expect(sanitizeSnippet("&#65;")).to.equal("A");
-		expect(sanitizeSnippet("&#x41;")).to.equal("A");
-	});
-
-	it("collapses whitespace", () => {
-		expect(sanitizeSnippet("hello   world")).to.equal("hello world");
-		expect(sanitizeSnippet("  hello  ")).to.equal("hello");
-	});
-});
-
-describe("truncateText", () => {
-	it("returns short text as-is", () => {
-		const text = "hello world";
-		expect(truncateText(text)).to.equal(text);
-	});
-
-	it("truncates by line count when exceeding OUTPUT_MAX_LINES", () => {
-		const lines = Array.from({ length: OUTPUT_MAX_LINES + 10 }, (_, i) => `line ${i}`);
-		const text = lines.join("\n");
-		const result = truncateText(text);
-		expect(result).to.include("[Web output truncated to");
-		expect(result.split("\n").length).to.be.lessThan(OUTPUT_MAX_LINES + 15);
-	});
-
-	it("truncates by byte count when exceeding OUTPUT_MAX_BYTES", () => {
-		const text = "x".repeat(OUTPUT_MAX_BYTES + 50000);
-		const result = truncateText(text);
-		expect(result).to.include("[Web output truncated to");
-	});
-
-	it("handles empty string", () => {
-		expect(truncateText("")).to.equal("");
-	});
-});
-
-describe("formatFirecrawlScrape", () => {
-	it("formats scrape data with metadata", () => {
-		const data = {
-			data: {
-				metadata: {
-					title: "Test Page",
-					sourceURL: "https://example.com",
-					statusCode: 200,
-				},
-				markdown: "# Hello\n\nThis is content.",
-			},
-		};
-		const output = formatFirecrawlScrape(data);
-		expect(output).to.include("# Test Page");
-		expect(output).to.include("Source: https://example.com");
-		expect(output).to.include("Status: 200");
-		expect(output).to.include("# Hello");
-		expect(output).to.include("This is content.");
-	});
-
-	it("resolves data at top level when no nested data", () => {
-		const data = {
-			metadata: { title: "Direct" },
-			markdown: "Content",
-		};
-		const output = formatFirecrawlScrape(data);
-		expect(output).to.include("# Direct");
-		expect(output).to.include("Content");
-	});
-
-	it("includes warning when present", () => {
-		const data = { data: { markdown: "x" }, warning: "Rate limited" };
-		const output = formatFirecrawlScrape(data);
-		expect(output).to.include("Warning: Rate limited");
-	});
-
-	it("includes links when present", () => {
-		const data = {
-			data: {
-				markdown: "body",
-				links: ["https://a.com", "https://b.com"],
-			},
-		};
-		const output = formatFirecrawlScrape(data);
-		expect(output).to.include("## Links");
-		expect(output).to.include("- https://a.com");
-	});
-
-	it("returns JSON stringify fallback for empty data", () => {
-		const data = { foo: "bar" };
-		const output = formatFirecrawlScrape(data);
-		expect(output).to.include("foo");
-	});
-});
-
-describe("formatCrawl4aiResult", () => {
-	it("formats a single successful crawl result with markdown", () => {
-		const data = {
-			url: "https://example.com",
-			success: true,
-			status_code: 200,
-			markdown: { fit_markdown: "# Hello\n\nWorld content." },
-		};
-		const output = formatCrawl4aiResult(data);
-		expect(output).to.include("URL: https://example.com");
-		expect(output).to.include("Status: 200");
-		expect(output).to.include("# Hello");
-	});
-
-	it("shows error for failed crawl", () => {
-		const data = {
-			url: "https://example.com/404",
-			success: false,
-			error_message: "Not Found",
-		};
-		const output = formatCrawl4aiResult(data);
-		expect(output).to.include("Error: Not Found");
-		expect(output).to.include("URL: https://example.com/404");
-	});
-
-	it("formats multiple results from wrapped response", () => {
-		const data = {
-			results: [
-				{ url: "https://a.com", success: true, markdown: { raw_markdown: "Page A" } },
-				{ url: "https://b.com", success: true, markdown: { raw_markdown: "Page B" } },
-			],
-		};
-		const output = formatCrawl4aiResult(data);
-		expect(output).to.include("=== Result 1 ===");
-		expect(output).to.include("=== Result 2 ===");
-		expect(output).to.include("Page A");
-		expect(output).to.include("Page B");
-	});
-
-	it("falls back to raw_markdown when fit_markdown is absent", () => {
-		const data = {
-			url: "https://example.com",
-			success: true,
-			markdown: { raw_markdown: "Raw content only" },
-		};
-		const output = formatCrawl4aiResult(data);
-		expect(output).to.include("Raw content only");
-	});
-
-	it("includes links when present", () => {
-		const data = {
-			url: "https://example.com",
-			success: true,
-			markdown: { fit_markdown: "body" },
-			links: {
-				internal: [{ href: "https://example.com/about" }],
-				external: [{ href: "https://other.com" }],
-			},
-		};
-		const output = formatCrawl4aiResult(data);
-		expect(output).to.include("Links");
-		expect(output).to.include("https://example.com/about");
-	});
-
-	it("returns fallback for empty data", () => {
-		expect(formatCrawl4aiResult({})).to.equal("(No data)");
-	});
-});
-
-

package/extensions/test/unit/search.test.ts

@@ -1,147 +0,0 @@
-import { expect } from "chai";
-
-import {
-	searchWithDiagnostics,
-	selectSearchBackendOrder,
-	type SearchParams,
-	type SearchResult,
-} from "../../lib/search";
-
-const ORIGINAL_ENV = { ...process.env };
-const ORIGINAL_FETCH = globalThis.fetch;
-
-function jsonResponse(body: unknown, status = 200): Response {
-	return new Response(JSON.stringify(body), {
-		status,
-		headers: { "content-type": "application/json" },
-	});
-}
-
-function htmlResponse(body: string, status = 200): Response {
-	return new Response(body, {
-		status,
-		headers: { "content-type": "text/html" },
-	});
-}
-
-function installMockFetch(handler: (url: string, init?: RequestInit) => Response | Promise<Response>): string[] {
-	const calls: string[] = [];
-	globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
-		const url = String(input);
-		calls.push(url);
-		return handler(url, init);
-	}) as typeof fetch;
-	return calls;
-}
-
-function restoreEnv(): void {
-	process.env = { ...ORIGINAL_ENV };
-}
-
-describe("SearchParams and SearchResult types", () => {
-	it("accept expected fields", () => {
-		const params: SearchParams = { query: "test", backend: "auto", signal: new AbortController().signal };
-		const result: SearchResult = { title: "T", url: "https://example.com", snippet: "S", age: "", content: "", backend: "brave" };
-		expect(params.backend).to.equal("auto");
-		expect(result.backend).to.equal("brave");
-	});
-});
-
-describe("selectSearchBackendOrder", () => {
-	it("selects Brave first for include_content", () => {
-		expect(selectSearchBackendOrder({ query: "homelab ansible", include_content: true })).to.deep.equal(["brave", "searxng", "firecrawl"]);
-	});
-
-	it("selects Brave first for site: and precision queries", () => {
-		expect(selectSearchBackendOrder({ query: "site:docs.ansible.com podman quadlet" })).to.deep.equal(["brave", "searxng", "firecrawl"]);
-		expect(selectSearchBackendOrder({ query: '"exact phrase" release notes' })).to.deep.equal(["brave", "searxng", "firecrawl"]);
-	});
-
-	it("keeps SearXNG first for broad discovery and explicit engines", () => {
-		expect(selectSearchBackendOrder({ query: "homelab ansible ideas" })).to.deep.equal(["searxng", "brave", "firecrawl"]);
-		expect(selectSearchBackendOrder({ query: "docs api", engines: "google,github" })).to.deep.equal(["searxng", "brave", "firecrawl"]);
-	});
-
-	it("honors explicit backend", () => {
-		expect(selectSearchBackendOrder({ query: "test", backend: "firecrawl" })).to.deep.equal(["firecrawl"]);
-	});
-});
-
-describe("searchWithDiagnostics", () => {
-	beforeEach(() => {
-		restoreEnv();
-		process.env.BRAVE_API_KEY = "test-brave-key";
-		process.env.SEARXNG_BASE_URL = "http://searxng.test";
-		process.env.FIRECRAWL_API_URL = "http://firecrawl.test/v2";
-	});
-
-	afterEach(() => {
-		globalThis.fetch = ORIGINAL_FETCH;
-		restoreEnv();
-	});
-
-	it("uses Brave first for include_content and fetches inline content", async () => {
-		const calls = installMockFetch((url) => {
-			if (url.startsWith("https://api.search.brave.com/")) {
-				return jsonResponse({ web: { results: [{ title: "Brave", url: "https://example.com/page", description: "Snippet" }] } });
-			}
-			if (url === "https://example.com/page") {
-				return htmlResponse("<html><head><title>Page</title></head><body><main><h1>Page</h1><p>This is long enough readable content for the inline content fetch test.</p></main></body></html>");
-			}
-			throw new Error(`unexpected fetch ${url}`);
-		});
-
-		const result = await searchWithDiagnostics({ query: "homelab ansible", include_content: true });
-		expect(result.selectedBackend).to.equal("brave");
-		expect(result.backendOrder[0]).to.equal("brave");
-		expect(result.results[0].content).to.include("readable content");
-		expect(calls[0]).to.include("api.search.brave.com");
-	});
-
-	it("uses SearXNG first for broad discovery", async () => {
-		const calls = installMockFetch((url) => {
-			if (url.startsWith("http://searxng.test/search")) {
-				return jsonResponse({ results: [{ title: "SearXNG", url: "https://example.com", content: "Snippet" }] });
-			}
-			throw new Error(`unexpected fetch ${url}`);
-		});
-
-		const result = await searchWithDiagnostics({ query: "homelab ansible ideas" });
-		expect(result.selectedBackend).to.equal("searxng");
-		expect(result.attempts).to.deep.include({ backend: "searxng", status: "success", message: "Selected searxng", resultCount: 1 });
-		expect(calls[0]).to.include("searxng.test");
-	});
-
-	it("captures backend errors and falls through to Firecrawl last", async () => {
-		installMockFetch((url) => {
-			if (url.startsWith("http://searxng.test/search")) return jsonResponse({ results: [] });
-			if (url.startsWith("https://api.search.brave.com/")) return jsonResponse({ error: "rate limited" }, 429);
-			if (url.startsWith("http://firecrawl.test/v2/search")) {
-				return jsonResponse({ data: { web: [{ title: "Fire", url: "https://fire.example", description: "Fallback" }] } });
-			}
-			throw new Error(`unexpected fetch ${url}`);
-		});
-
-		const result = await searchWithDiagnostics({ query: "homelab ansible ideas" });
-		expect(result.selectedBackend).to.equal("firecrawl");
-		expect(result.attempts.map((a) => a.backend)).to.deep.equal(["searxng", "brave", "firecrawl"]);
-		expect(result.attempts[1].status).to.equal("error");
-		expect(result.attempts[1].message).not.to.include("test-brave-key");
-	});
-
-	it("explicit backend tries only that backend", async () => {
-		const calls = installMockFetch((url) => {
-			if (url.startsWith("http://searxng.test/search")) return jsonResponse({ results: [] });
-			throw new Error(`unexpected fetch ${url}`);
-		});
-
-		try {
-			await searchWithDiagnostics({ query: "nothing", backend: "searxng" });
-			expect.fail("expected search to fail");
-		} catch (e: any) {
-			expect(e.message).to.include("searxng: empty");
-			expect(calls).to.have.length(1);
-		}
-	});
-
-});