@qvac/harness 0.2.7 → 0.2.9

package/dist-lib/lib/tools/skills/skill-settings.js

@@ -1,4 +1,4 @@
-import { scopeKey } from "./scope-key.js";
+import { scopeKey } from './scope-key.js';
 function setupFields(entry) {
     return (entry.setup?.routes ?? []).flatMap((route) => route.fields ?? []);
 }

package/dist-lib/lib/tools/skills/skill-state-constants.d.ts

@@ -1,12 +1,12 @@
 export declare const SKILL_STATE: {
-    readonly ready: "ready";
-    readonly needsSetup: "needs-setup";
-    readonly disconnected: "disconnected";
-    readonly unsupported: "unsupported";
-    readonly disabled: "disabled";
-    readonly outdated: "outdated";
-    readonly incompatibleModel: "incompatible-model";
-    readonly failed: "failed";
+    readonly ready: 'ready';
+    readonly needsSetup: 'needs-setup';
+    readonly disconnected: 'disconnected';
+    readonly unsupported: 'unsupported';
+    readonly disabled: 'disabled';
+    readonly outdated: 'outdated';
+    readonly incompatibleModel: 'incompatible-model';
+    readonly failed: 'failed';
 };
 export type SkillState = (typeof SKILL_STATE)[keyof typeof SKILL_STATE];
 export declare function isAvailableState(state: SkillState): boolean;

package/dist-lib/lib/tools/skills/skill-state.js

@@ -1,12 +1,12 @@
-import { credentialRecord, isCredentialExpired } from "./auth-resolver.js";
-import { parseToolGrant } from "./tool-grants.js";
-import { missingBins } from "./bin-check.js";
-import { credentialSlots } from "./credential-slots.js";
-import { requiredSettings } from "./skill-settings.js";
-import { isCredentialRejected } from "./credential-health.js";
-import { isObsidianVaultPath, isSandboxedWorkbenchInstall, OBSIDIAN_SKILL_NAME, OBSIDIAN_VAULT_PATH_CREDENTIAL_KEY, obsidianCliState, obsidianInstallState } from "./obsidian-readiness.js";
-import { isCapabilityProfile, meetsMinCapabilityProfile } from "../../models/model-catalog.js";
-import { SKILL_STATE, isAvailableState } from "./skill-state-constants.js";
+import { credentialRecord, isCredentialExpired } from './auth-resolver.js';
+import { parseToolGrant } from './tool-grants.js';
+import { missingBins } from './bin-check.js';
+import { credentialSlots } from './credential-slots.js';
+import { requiredSettings } from './skill-settings.js';
+import { isCredentialRejected } from './credential-health.js';
+import { isObsidianVaultPath, isSandboxedWorkbenchInstall, OBSIDIAN_SKILL_NAME, OBSIDIAN_VAULT_PATH_CREDENTIAL_KEY, obsidianCliState, obsidianInstallState } from './obsidian-readiness.js';
+import { isCapabilityProfile, meetsMinCapabilityProfile } from '../../models/model-catalog.js';
+import { SKILL_STATE, isAvailableState } from './skill-state-constants.js';
 export { SKILL_STATE, isAvailableState };
 export function isStub(entry) {
     return entry.stub === true;

package/dist-lib/lib/tools/toolsets.d.ts

@@ -1,4 +1,4 @@
-export declare const TOOLSETS: readonly ["web-search", "knowledge", "files", "exec", "http-request", "mcp-call"];
+export declare const TOOLSETS: readonly ['web-search', 'knowledge', 'files', 'exec', 'http-request', 'mcp-call'];
 export type Toolset = (typeof TOOLSETS)[number];
 export declare function asToolset(value?: string | null): Toolset | null;
 export interface ToolsetScoped {

package/dist-lib/lib/tools/url-guard.js

@@ -1,5 +1,5 @@
-import { AbortedError, raceAbort } from "../helpers/race-abort.js";
-import { isPrivateOrBlocked, stripIPv6Brackets } from "./private-ip.js";
+import { AbortedError, raceAbort } from '../helpers/race-abort.js';
+import { isPrivateOrBlocked, stripIPv6Brackets } from './private-ip.js';
 const LITERAL_IPV4 = /^\d{1,3}(\.\d{1,3}){3}$/;
 export function checkOutboundHost(url) {
     const host = stripIPv6Brackets(url.hostname);

package/dist-lib/lib/tools/weather-lookup/place.d.ts

@@ -0,0 +1,11 @@
+export interface ResolvedPlace {
+    readonly area: string;
+    readonly region: string;
+    readonly country: string;
+}
+export declare function fold(value: string): string;
+export declare function describePlace(place: ResolvedPlace): string;
+export declare function qualifierOf(location: string): string | null;
+export declare function cityMatches(location: string, place: ResolvedPlace): boolean;
+export type QualifierVerdict = 'match' | 'unverifiable' | 'contradiction';
+export declare function checkQualifier(qualifier: string, place: ResolvedPlace): QualifierVerdict;

package/dist-lib/lib/tools/weather-lookup/place.js

@@ -0,0 +1,152 @@
+const QUALIFIER_ALIASES = [
+    ['united states of america', 'united states of america'],
+    ['united states', 'united states of america'],
+    ['u.s.a.', 'united states of america'],
+    ['u.s.', 'united states of america'],
+    ['usa', 'united states of america'],
+    ['us', 'united states of america'],
+    ['united kingdom', 'united kingdom'],
+    ['great britain', 'united kingdom'],
+    ['england', 'united kingdom'],
+    ['scotland', 'united kingdom'],
+    ['wales', 'united kingdom'],
+    ['northern ireland', 'united kingdom'],
+    ['u.k.', 'united kingdom'],
+    ['uk', 'united kingdom'],
+    ['gb', 'united kingdom'],
+    ['united arab emirates', 'united arab emirates'],
+    ['uae', 'united arab emirates'],
+    ['holland', 'netherlands'],
+    ['deutschland', 'germany'],
+    ['espana', 'spain'],
+    ['italia', 'italy']
+];
+const OTHER_SUBDIVISIONS = {
+    ab: 'alberta',
+    bc: 'british columbia',
+    mb: 'manitoba',
+    nb: 'new brunswick',
+    nl: 'newfoundland',
+    ns: 'nova scotia',
+    on: 'ontario',
+    pe: 'prince edward island',
+    qc: 'quebec',
+    sk: 'saskatchewan',
+    nsw: 'new south wales',
+    vic: 'victoria',
+    qld: 'queensland',
+    wa: 'western australia',
+    sa: 'south australia',
+    tas: 'tasmania',
+    nt: 'northern territory',
+    act: 'australian capital territory'
+};
+const US_STATES = {
+    al: 'alabama',
+    ak: 'alaska',
+    az: 'arizona',
+    ar: 'arkansas',
+    ca: 'california',
+    co: 'colorado',
+    ct: 'connecticut',
+    de: 'delaware',
+    fl: 'florida',
+    ga: 'georgia',
+    hi: 'hawaii',
+    id: 'idaho',
+    il: 'illinois',
+    in: 'indiana',
+    ia: 'iowa',
+    ks: 'kansas',
+    ky: 'kentucky',
+    la: 'louisiana',
+    me: 'maine',
+    md: 'maryland',
+    ma: 'massachusetts',
+    mi: 'michigan',
+    mn: 'minnesota',
+    ms: 'mississippi',
+    mo: 'missouri',
+    mt: 'montana',
+    ne: 'nebraska',
+    nv: 'nevada',
+    nh: 'new hampshire',
+    nj: 'new jersey',
+    nm: 'new mexico',
+    ny: 'new york',
+    nc: 'north carolina',
+    nd: 'north dakota',
+    oh: 'ohio',
+    ok: 'oklahoma',
+    or: 'oregon',
+    pa: 'pennsylvania',
+    ri: 'rhode island',
+    sc: 'south carolina',
+    sd: 'south dakota',
+    tn: 'tennessee',
+    tx: 'texas',
+    ut: 'utah',
+    vt: 'vermont',
+    va: 'virginia',
+    wa: 'washington',
+    wv: 'west virginia',
+    wi: 'wisconsin',
+    wy: 'wyoming',
+    dc: 'district of columbia'
+};
+export function fold(value) {
+    return value
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, ' ')
+        .trim();
+}
+export function describePlace(place) {
+    return [place.area, place.region, place.country].filter((part) => part.length > 0).join(', ');
+}
+export function qualifierOf(location) {
+    const comma = location.indexOf(',');
+    if (comma === -1)
+        return null;
+    const qualifier = fold(location.slice(comma + 1));
+    return qualifier.length > 0 ? qualifier : null;
+}
+function expand(qualifier) {
+    const code = qualifier.replace(/ /g, '');
+    const subdivision = US_STATES[code] ?? OTHER_SUBDIVISIONS[code];
+    if (subdivision !== undefined)
+        return subdivision;
+    for (const [alias, full] of QUALIFIER_ALIASES) {
+        if (qualifier === fold(alias))
+            return full;
+    }
+    return qualifier;
+}
+function initialsOf(name) {
+    return name
+        .split(' ')
+        .map((word) => word[0] ?? '')
+        .join('');
+}
+const ABBREVIATION = /^[a-z]{1,3}$/;
+export function cityMatches(location, place) {
+    const city = fold(location.split(',')[0] ?? '');
+    return city.length > 0 && fold(describePlace(place)).includes(city);
+}
+export function checkQualifier(qualifier, place) {
+    const wanted = expand(qualifier);
+    const code = qualifier.replace(/ /g, '');
+    const opaque = wanted === qualifier && ABBREVIATION.test(code);
+    for (const candidate of [fold(place.region), fold(place.country)]) {
+        if (candidate.length === 0)
+            continue;
+        if (initialsOf(candidate) === code)
+            return 'match';
+        if (opaque)
+            continue;
+        if (candidate.includes(wanted) || wanted.includes(candidate))
+            return 'match';
+    }
+    return opaque ? 'unverifiable' : 'contradiction';
+}

package/dist-lib/lib/tools/weather-lookup/report.d.ts

@@ -0,0 +1,37 @@
+import { type ResolvedPlace } from './place.ts';
+interface Translated {
+    readonly value: string;
+}
+interface CurrentCondition {
+    readonly temp_C?: string;
+    readonly temp_F?: string;
+    readonly FeelsLikeC?: string;
+    readonly humidity?: string;
+    readonly windspeedKmph?: string;
+    readonly weatherDesc?: ReadonlyArray<Translated>;
+}
+interface HourlyEntry {
+    readonly time?: string;
+    readonly weatherDesc?: ReadonlyArray<Translated>;
+}
+interface DailyForecast {
+    readonly date?: string;
+    readonly maxtempC?: string;
+    readonly mintempC?: string;
+    readonly maxtempF?: string;
+    readonly mintempF?: string;
+    readonly hourly?: ReadonlyArray<HourlyEntry>;
+}
+interface NearestArea {
+    readonly areaName?: ReadonlyArray<Translated>;
+    readonly region?: ReadonlyArray<Translated>;
+    readonly country?: ReadonlyArray<Translated>;
+}
+export interface WeatherJson {
+    readonly nearest_area?: ReadonlyArray<NearestArea>;
+    readonly current_condition?: ReadonlyArray<CurrentCondition>;
+    readonly weather?: ReadonlyArray<DailyForecast>;
+}
+export declare function placeOf(json: WeatherJson): ResolvedPlace | null;
+export declare function renderReport(json: WeatherJson, place: ResolvedPlace, asked: string, verified: boolean): string;
+export {};

package/dist-lib/lib/tools/weather-lookup/report.js

@@ -0,0 +1,56 @@
+import { describePlace } from './place.js';
+const MAX_DAYS = 3;
+const DAY_LABELS = ['today', 'tomorrow'];
+const RANGE = '\u2013';
+const NOON = 4;
+function firstValue(values) {
+    return values?.[0]?.value?.trim() ?? '';
+}
+export function placeOf(json) {
+    const area = json.nearest_area?.[0];
+    if (area === undefined)
+        return null;
+    const place = {
+        area: firstValue(area.areaName),
+        region: firstValue(area.region),
+        country: firstValue(area.country)
+    };
+    return place.area || place.region || place.country ? place : null;
+}
+export function renderReport(json, place, asked, verified) {
+    const lines = [headline(place, asked, verified)];
+    const now = json.current_condition?.[0];
+    if (now !== undefined)
+        lines.push(currentLine(now));
+    const days = json.weather?.slice(0, MAX_DAYS) ?? [];
+    for (const [index, day] of days.entries())
+        lines.push(dailyLine(day, index));
+    return lines.join('\n');
+}
+function headline(place, asked, verified) {
+    const resolved = describePlace(place);
+    if (verified)
+        return resolved;
+    return `${resolved} (not "${asked}" — this is where it resolved)`;
+}
+function currentLine(now) {
+    const parts = [`Now: ${now.temp_C ?? '?'}°C / ${now.temp_F ?? '?'}°F`];
+    const desc = firstValue(now.weatherDesc);
+    if (desc)
+        parts.push(desc);
+    if (now.FeelsLikeC !== undefined)
+        parts.push(`feels like ${now.FeelsLikeC}°C`);
+    if (now.humidity !== undefined)
+        parts.push(`humidity ${now.humidity}%`);
+    if (now.windspeedKmph !== undefined)
+        parts.push(`wind ${now.windspeedKmph} km/h`);
+    return parts.join(', ');
+}
+function dailyLine(day, index) {
+    const label = DAY_LABELS[index];
+    const date = `${day.date ?? '?'}${label === undefined ? '' : ` (${label})`}`;
+    const celsius = `${day.mintempC ?? '?'}${RANGE}${day.maxtempC ?? '?'}°C`;
+    const fahrenheit = `${day.mintempF ?? '?'}${RANGE}${day.maxtempF ?? '?'}°F`;
+    const desc = firstValue(day.hourly?.[NOON]?.weatherDesc);
+    return `${date}: ${celsius} / ${fahrenheit}${desc ? `, ${desc}` : ''}`;
+}

package/dist-lib/lib/tools/weather-lookup.d.ts

@@ -0,0 +1,8 @@
+import type { ToolDefinition } from '../capabilities/completion.ts';
+import type { FetchFn } from './http-request.ts';
+import { type HostResolver } from './url-guard.ts';
+export interface WeatherLookupToolOptions {
+    fetch?: FetchFn;
+    resolveHost?: HostResolver;
+}
+export declare function createWeatherLookupTool({ fetch: fetchImpl, resolveHost }?: WeatherLookupToolOptions): ToolDefinition;

package/dist-lib/lib/tools/weather-lookup.js

@@ -0,0 +1,110 @@
+import defaultFetch from '#no-redirect-fetch';
+import { AbortController } from 'bare-abort-controller';
+import { lookupHost } from '../dns-lookup.js';
+import { isRedirectStatus } from './http-request/utils.js';
+import { resolveOutboundUrl } from './url-guard.js';
+import { checkQualifier, cityMatches, describePlace, qualifierOf } from './weather-lookup/place.js';
+import { placeOf, renderReport } from './weather-lookup/report.js';
+const WEATHER_HOST = 'wttr.in';
+const LOOKUP_TIMEOUT_MS = 15_000;
+const MAX_BODY_BYTES = 400_000;
+export function createWeatherLookupTool({ fetch: fetchImpl, resolveHost = lookupHost } = {}) {
+    return {
+        name: 'weather_lookup',
+        toolset: 'http-request',
+        skillGated: true,
+        autoApprove: true,
+        description: 'Look up the current weather and a three-day forecast for a place, via wttr.in. ' +
+            'Returns the place the service resolved on its first line, then the conditions now and ' +
+            'one line per day. Use it for any question about weather, temperature or forecast.',
+        parameters: {
+            type: 'object',
+            properties: {
+                location: {
+                    type: 'string',
+                    description: 'The place exactly as the user wrote it, including any country or state: ' +
+                        '"Nassau, Bahamas", "Paris, Texas", "London"'
+                }
+            },
+            required: ['location']
+        },
+        effect: () => 'read',
+        resource: () => ({ kind: 'host', label: WEATHER_HOST }),
+        async execute(args, ctx) {
+            const raw = args.location;
+            if (typeof raw !== 'string' || raw.trim().length === 0) {
+                return { error: 'location must be a non-empty string' };
+            }
+            const location = raw.trim();
+            if (ctx?.signal?.aborted)
+                return { error: 'weather_lookup cancelled' };
+            const url = new URL(`https://${WEATHER_HOST}/${encodeURIComponent(location)}?format=j1`);
+            const fetch = fetchImpl ?? defaultFetch;
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(undefined), LOOKUP_TIMEOUT_MS);
+            const onCallerAbort = () => controller.abort(undefined);
+            ctx?.signal?.addEventListener('abort', onCallerAbort);
+            try {
+                const check = await resolveOutboundUrl(url, resolveHost, ctx?.signal);
+                if (check.blocked)
+                    return { error: check.blocked };
+                const response = await fetch(url, {
+                    method: 'GET',
+                    headers: { Accept: 'application/json' },
+                    signal: controller.signal,
+                    redirect: 'manual',
+                    validatedAddresses: check.addresses,
+                    maxBytes: MAX_BODY_BYTES
+                });
+                if (isRedirectStatus(response.status)) {
+                    return { error: `${WEATHER_HOST} redirected the lookup for "${location}"` };
+                }
+                const body = await response.text();
+                if (/location not found/i.test(body))
+                    return { content: notFound(location) };
+                if (response.status !== 200) {
+                    return { error: unavailable(`it answered HTTP ${response.status}`) };
+                }
+                let json;
+                try {
+                    json = JSON.parse(body);
+                }
+                catch {
+                    return { error: unavailable('it did not return a forecast') };
+                }
+                const place = placeOf(json);
+                if (place === null)
+                    return { content: notFound(location) };
+                const qualifier = qualifierOf(location);
+                const verdict = qualifier === null ? null : checkQualifier(qualifier, place);
+                const named = cityMatches(location, place);
+                if (verdict === 'contradiction' && !named) {
+                    return {
+                        content: `No such place: "${location}". ${WEATHER_HOST} resolved it to ` +
+                            `${describePlace(place)}, which is somewhere else.`
+                    };
+                }
+                const verified = qualifier === null ? named : verdict === 'match';
+                return { content: renderReport(json, place, location, verified) };
+            }
+            catch (err) {
+                if (ctx?.signal?.aborted)
+                    return { error: 'weather_lookup cancelled' };
+                if (controller.signal.aborted) {
+                    return { error: `weather_lookup timed out after ${LOOKUP_TIMEOUT_MS} ms` };
+                }
+                return { error: unavailable(err instanceof Error ? err.message : String(err)) };
+            }
+            finally {
+                clearTimeout(timeout);
+                ctx?.signal?.removeEventListener('abort', onCallerAbort);
+            }
+        }
+    };
+}
+function unavailable(reason) {
+    return `The weather service could not be reached: ${reason}.`;
+}
+function notFound(location) {
+    return `No such place: "${location}". ${WEATHER_HOST} does not know it.`;
+}

package/dist-lib/lib/tools/web-fetch.js

@@ -1,15 +1,15 @@
 import defaultFetch from '#no-redirect-fetch';
 import { AbortController } from 'bare-abort-controller';
-import { lookupHost } from "../dns-lookup.js";
-import { AbortedError } from "../helpers/race-abort.js";
-import { extractEmbeddedState } from "../web-fetch/embedded-state.js";
-import { extractPageText, looksLikeHtml } from "../web-fetch/extract.js";
-import { imageFileName, pageImageUrls } from "../web-fetch/images.js";
-import { pageVideoRef } from "../web-fetch/video.js";
-import { MAX_HTML_CHARS } from "../web-search/fetch-html.js";
-import { BROWSER_UA } from "../web-search/user-agents.js";
-import { isRedirectStatus } from "./http-request/utils.js";
-import { resolveOutboundUrl } from "./url-guard.js";
+import { lookupHost } from '../dns-lookup.js';
+import { AbortedError } from '../helpers/race-abort.js';
+import { extractEmbeddedState } from '../web-fetch/embedded-state.js';
+import { extractPageText, looksLikeHtml } from '../web-fetch/extract.js';
+import { imageFileName, pageImageUrls } from '../web-fetch/images.js';
+import { pageVideoRef } from '../web-fetch/video.js';
+import { MAX_HTML_CHARS } from '../web-search/fetch-html.js';
+import { BROWSER_UA } from '../web-search/user-agents.js';
+import { isRedirectStatus } from './http-request/utils.js';
+import { resolveOutboundUrl } from './url-guard.js';
 const SMALL_CONTEXT_TOKENS = 12_288;
 const SMALL_CONTEXT_CHARS = 6_000;
 const LARGE_CONTEXT_CHARS = 16_000;

package/dist-lib/lib/tools/web-search.js

@@ -1,6 +1,6 @@
 import defaultFetch from '#fetch';
-import { formatResultsForPrompt } from "../web-search/format-results.js";
-import { searchWeb } from "../web-search/orchestrator.js";
+import { formatResultsForPrompt } from '../web-search/format-results.js';
+import { searchWeb } from '../web-search/orchestrator.js';
 const nodeFetch = async (url, init) => {
     const res = await defaultFetch(url, init);
     return { ok: res.ok, status: res.status, text: () => res.text() };

package/dist-lib/lib/transport.js

@@ -1,6 +1,6 @@
 import c from 'compact-encoding';
 import { Duplex } from 'streamx';
-export { settleOnClose } from "./rpc-session.js";
+export { settleOnClose } from './rpc-session.js';
 export function clientSessions(pipe) {
     let current = session(pipe);
     pipe.on('data', (chunk) => current.push(chunk));

package/dist-lib/lib/validating-lookup.js

@@ -1,4 +1,4 @@
-import { isPrivateOrBlocked } from "./tools/private-ip.js";
+import { isPrivateOrBlocked } from './tools/private-ip.js';
 export class BlockedAddressError extends Error {
     code = 'EBLOCKEDADDR';
     constructor(hostname, address) {

package/dist-lib/lib/web-fetch/embedded-state.js

@@ -1,4 +1,4 @@
-import { decodeHtmlEntities } from "../web-search/html-helpers.js";
+import { decodeHtmlEntities } from '../web-search/html-helpers.js';
 const LDJSON_SCRIPT = /<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
 const JSON_SCRIPT = /<script[^>]*type=["']application\/json["'][^>]*>([\s\S]*?)<\/script>/gi;
 const INLINE_SCRIPT = /<script\b(?![^>]*\bsrc=)(?![^>]*type=["']application\/(?:ld\+)?json["'])[^>]*>([\s\S]*?)<\/script>/gi;

package/dist-lib/lib/web-fetch/extract.js

@@ -1,4 +1,4 @@
-import { decodeHtmlEntities, stripHtmlTags } from "../web-search/html-helpers.js";
+import { decodeHtmlEntities, stripHtmlTags } from '../web-search/html-helpers.js';
 const NOISE_BLOCKS = [
     'script',
     'style',

package/dist-lib/lib/web-fetch/images.js

@@ -1,4 +1,4 @@
-import { decodeHtmlEntities } from "../web-search/html-helpers.js";
+import { decodeHtmlEntities } from '../web-search/html-helpers.js';
 const META_TAG = /<meta\s[^>]*>/gi;
 const IMAGE_ATTR = /(?:property|name)=["'](?:og:image(?::secure_url|:url)?|twitter:image)["']/i;
 const META_CONTENT = /content=["']([^"']+)["']/i;

package/dist-lib/lib/web-fetch/video.js

@@ -1,4 +1,4 @@
-import { decodeHtmlEntities } from "../web-search/html-helpers.js";
+import { decodeHtmlEntities } from '../web-search/html-helpers.js';
 const META_TAG = /<meta\s[^>]*>/gi;
 const VIDEO_ATTR = /(?:property|name)=["']og:video(?::secure_url|:url)?["']/i;
 const META_CONTENT = /content=["']([^"']+)["']/i;

package/dist-lib/lib/web-search/engine-registry.js

@@ -1,10 +1,10 @@
-import { searchAol } from "./engines/aol.js";
-import { searchBing } from "./engines/bing.js";
-import { searchBrave } from "./engines/brave.js";
-import { searchDuckDuckGo } from "./engines/duckduckgo.js";
-import { searchGoogle } from "./engines/google.js";
-import { searchWikipedia } from "./engines/wikipedia.js";
-import { searchYahoo } from "./engines/yahoo.js";
+import { searchAol } from './engines/aol.js';
+import { searchBing } from './engines/bing.js';
+import { searchBrave } from './engines/brave.js';
+import { searchDuckDuckGo } from './engines/duckduckgo.js';
+import { searchGoogle } from './engines/google.js';
+import { searchWikipedia } from './engines/wikipedia.js';
+import { searchYahoo } from './engines/yahoo.js';
 export const DEFAULT_MAX_RESULTS = 8;
 export const ENGINES = [
     { name: 'duckduckgo', fn: searchDuckDuckGo },

package/dist-lib/lib/web-search/engines/aol.js

@@ -1,6 +1,6 @@
-import { fetchHtml } from "../fetch-html.js";
-import { clean } from "../html-helpers.js";
-import { urlMatchesHost } from "../url-helpers.js";
+import { fetchHtml } from '../fetch-html.js';
+import { clean } from '../html-helpers.js';
+import { urlMatchesHost } from '../url-helpers.js';
 function decodeRuUrl(encoded) {
     try {
         const href = decodeURIComponent(encoded);

package/dist-lib/lib/web-search/engines/bing.js

@@ -1,7 +1,7 @@
-import { fetchHtml } from "../fetch-html.js";
-import { clean } from "../html-helpers.js";
-import { urlMatchesHost } from "../url-helpers.js";
-import { SAFARI_UA } from "../user-agents.js";
+import { fetchHtml } from '../fetch-html.js';
+import { clean } from '../html-helpers.js';
+import { urlMatchesHost } from '../url-helpers.js';
+import { SAFARI_UA } from '../user-agents.js';
 function isOrganicBingUrl(url) {
     return url.startsWith('http') && !urlMatchesHost(url, 'bing.com') && !url.includes('msockid=');
 }

package/dist-lib/lib/web-search/engines/brave.js

@@ -1,5 +1,5 @@
-import { fetchHtml } from "../fetch-html.js";
-import { clean } from "../html-helpers.js";
+import { fetchHtml } from '../fetch-html.js';
+import { clean } from '../html-helpers.js';
 function parseSnippetBlock(inner) {
     const urlMatch = inner.match(/<a[^>]*href="(https?:\/\/(?!imgs\.search\.brave)[^"]*)"[^>]*>/i);
     if (!urlMatch) {

package/dist-lib/lib/web-search/engines/duckduckgo.js

@@ -1,6 +1,6 @@
-import { fetchHtml } from "../fetch-html.js";
-import { clean } from "../html-helpers.js";
-import { urlMatchesHost } from "../url-helpers.js";
+import { fetchHtml } from '../fetch-html.js';
+import { clean } from '../html-helpers.js';
+import { urlMatchesHost } from '../url-helpers.js';
 function extractDdgUrl(raw) {
     if (raw.includes('uddg=')) {
         const m = raw.match(/uddg=([^&]+)/);

package/dist-lib/lib/web-search/engines/google.js

@@ -1,7 +1,7 @@
-import { fetchHtml } from "../fetch-html.js";
-import { clean } from "../html-helpers.js";
-import { urlMatchesHost } from "../url-helpers.js";
-import { GOOGLE_GSA_UA } from "../user-agents.js";
+import { fetchHtml } from '../fetch-html.js';
+import { clean } from '../html-helpers.js';
+import { urlMatchesHost } from '../url-helpers.js';
+import { GOOGLE_GSA_UA } from '../user-agents.js';
 function resolveGoogleUrl(rawUrl) {
     if (rawUrl.startsWith('/url?q=')) {
         return decodeURIComponent(rawUrl.slice(7).split('&')[0] || '');

package/dist-lib/lib/web-search/engines/wikipedia.js

@@ -1,5 +1,5 @@
-import { fetchJson } from "../fetch-html.js";
-import { clean } from "../html-helpers.js";
+import { fetchJson } from '../fetch-html.js';
+import { clean } from '../html-helpers.js';
 function extractSearchItems(data) {
     if (typeof data !== 'object' || data === null) {
         return [];

package/dist-lib/lib/web-search/engines/yahoo.js

@@ -1,6 +1,6 @@
-import { fetchHtml } from "../fetch-html.js";
-import { clean } from "../html-helpers.js";
-import { urlMatchesHost } from "../url-helpers.js";
+import { fetchHtml } from '../fetch-html.js';
+import { clean } from '../html-helpers.js';
+import { urlMatchesHost } from '../url-helpers.js';
 function decodeRuUrl(encoded) {
     try {
         const href = decodeURIComponent(encoded);

package/dist-lib/lib/web-search/fetch-html.js

@@ -1,5 +1,5 @@
 import { AbortController } from 'bare-abort-controller';
-import { BROWSER_UA } from "./user-agents.js";
+import { BROWSER_UA } from './user-agents.js';
 export const ENGINE_TIMEOUT_MS = 8000;
 export const MAX_HTML_CHARS = 2_000_000;
 export class TimeoutError extends Error {