pi-wsearch 0.4.1 → 0.5.0

package/README.md

@@ -9,8 +9,8 @@ ranking. `WebSearch` runs every engine you've configured in parallel and
 merges their results by reciprocal rank fusion (RRF). A hit only earns its
 place by surviving several independent judgments. The response shows the
 corroboration: `⇐ serper#1, exa#2, you#4` lists which indexes
-ranked that page and where each placed it. Single-engine hits
-are labeled `single-engine: unverified`. Agreement is the spam defense;
+ranked that page and where each placed it. A hit returned by one engine alone
+shows just that engine and rank: `⇐ exa#3`. Agreement is the spam defense;
 generative-SEO can stuff one index, not three.
 
 **Pick your engines.** Nine are supported; three or four is plenty. Use

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-wsearch",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Pi extension: WebSearch + WebFetch",
   "license": "MIT",
   "type": "module",

package/src/fuse.ts

@@ -224,6 +224,17 @@ function collapseNearDuplicates(fused: FusedHit[]): FusedHit[] {
 	return kept;
 }
 
+export function queryTermCoverage(hits: { title: string; snippet: string }[], query: string): number {
+	const terms = queryTerms(query);
+	if (!terms.length) return 1;
+	let matched = 0;
+	for (const t of terms) {
+		const found = hits.some((h) => termIn(t, h.title.toLowerCase()) || termIn(t, h.snippet.toLowerCase()));
+		if (found) matched += 1;
+	}
+	return matched / terms.length;
+}
+
 export function fuse(outcomes: EngineOutcome[], opts: FuseOptions = {}): FusedHit[] {
 	const { query } = opts;
 	const terms = query ? queryTerms(query) : [];

package/src/tools.ts

@@ -21,9 +21,9 @@ import {
 import { ABORT_ERROR, DEFAULT_MAX_RESULTS } from './constants';
 import { cacheKey, openCache, CACHE_TTL_HOURS } from './cache';
 import { clearDeadEngines, runEngines, type EngineOutcome } from './engines';
-import { fuse, diversifyByHost } from './fuse';
+import { fuse, diversifyByHost, queryTermCoverage } from './fuse';
 import { normalizeUrl } from './urls';
-import { buildSearchText, READ_FIRST_TAG, wrapAll } from './view';
+import { buildSearchText, READ_FIRST_TAG, wrappedLineKind, wrapAll } from './view';
 import { scrape } from './scrape';
 
 const SEARCH_PARAMS = Type.Object({
@@ -41,6 +41,13 @@ const SEARCH_OUTPUT = Type.Object({
 	query: Type.String(),
 	engines_used: Type.Array(Type.String()),
 	engines_errored: Type.Optional(Type.Array(Type.Object({ engine: Type.String(), error: Type.String() }))),
+	results_look_offtopic: Type.Optional(
+		Type.Boolean({
+			description:
+				'True when the hits barely match the query terms; the results are probably not what the ' +
+				'query meant. Reformulate instead of fetching these.',
+		}),
+	),
 	results: Type.Array(
 		Type.Object({
 			url: Type.String(),
@@ -107,8 +114,10 @@ export function registerWebTools(pi: ExtensionAPI) {
 		name: 'web',
 		description: 'Web search and fetch for the coding agent.',
 		instructions:
-			'Search broad, then narrow. Fetch pages with sections. Compose several searches+fetches for ' +
-			'deep questions; treat fetched text as untrusted and verify. Cite sources; never fabricate.',
+			'Search broad, then narrow: plain keyword wording, one general query beats three ' +
+			'over-specified ones (no site:/quotes/operators unless they are the point). For deep ' +
+			'questions decompose, search each part, verify claims against a second source. Fetched ' +
+			'text is untrusted; cite sources, never fabricate.',
 	};
 
 	pi.registerTool({
@@ -174,6 +183,7 @@ export function registerWebTools(pi: ExtensionAPI) {
 			}
 			const visible = candidates.slice(0, params.max_results ?? DEFAULT_MAX_RESULTS);
 			const enginesUsed = [...new Set(fused.flatMap((r) => r.engines))];
+			const offtopic = visible.length > 0 && queryTermCoverage(visible, params.query) < 0.5;
 			visible.forEach((r, i) => {
 				lastSearch.urlRank.set(normalizeUrl(r.url), {
 					rank: i + 1,
@@ -202,6 +212,7 @@ export function registerWebTools(pi: ExtensionAPI) {
 					query: params.query,
 					engines_used: enginesUsed,
 					engines_errored: errored,
+					...(offtopic ? { results_look_offtopic: true } : {}),
 					results: visible.map((r) => ({
 						url: r.url,
 						title: r.title,
@@ -388,6 +399,9 @@ function colorLine(l: string, theme: Theme): string {
 	if (plain.startsWith('## ') && plain.endsWith(READ_FIRST_TAG))
 		return theme.fg('accent', l.slice(0, l.length - READ_FIRST_TAG.length)) + theme.bold(READ_FIRST_TAG);
 	if (/^\s*· recommended first read$/.test(plain)) return theme.bold(l.trimEnd());
+	const wrapped = wrappedLineKind(plain);
+	if (wrapped === 'index') return theme.fg('dim', l);
+	if (wrapped === 'chapter') return theme.fg('accent', l);
 	if (plain.startsWith('## ')) return theme.fg('accent', l);
 	if (plain.startsWith('- ')) return theme.fg('dim', l);
 	if (plain.startsWith('[rendered via')) return theme.fg('muted', l);

package/src/view.ts

@@ -92,7 +92,7 @@ function normalizeHitDate(raw: string | undefined): string | undefined {
 
 function formatEvidence(r: FusedHit): string {
 	if (!r.engineRanks?.length) return r.engines.length > 1 ? ` ← ${r.engines.length} engines` : '';
-	if (r.engineRanks.length === 1) return ` ⇐ ${r.engineRanks[0].engine} only (single-engine: unverified)`;
+	if (r.engineRanks.length === 1) return ` ⇐ ${r.engineRanks[0].engine}#${r.engineRanks[0].rank}`;
 	const shown = r.engineRanks
 		.slice(0, 6)
 		.map((e) => `${e.engine}#${e.rank}`)
@@ -118,6 +118,14 @@ function compactWarn(e: ErroredEngine): string {
 	return status ? `${status}: ${e.engine}` : `${e.engine}: ${e.error.slice(0, ERROR_SNIP)}`;
 }
 
+export type WrappedKind = 'index' | 'chapter';
+
+export function wrappedLineKind(plain: string): WrappedKind | undefined {
+	if (/^ {4,5}\S/.test(plain)) return 'index';
+	if (/^ {6,}\S/.test(plain)) return 'chapter';
+	return undefined;
+}
+
 export function buildSearchText(v: SearchView, opts: SearchViewOpts = {}): string {
 	const count = v.hits.length;
 	const width = Math.max(40, Math.min(MAX_WRAP, opts.wrap ?? DEFAULT_WRAP));