@mjasnikovs/pi-task 0.2.0

package/dist/workers/docs-retrieve.js

@@ -0,0 +1,91 @@
+const DEFAULT_LIMIT = 8;
+const DEFAULT_BUDGET = 24_000;
+const MIN_TOKEN_LEN = 2;
+const FALLBACK_DTS_CHARS = 12_000;
+const FALLBACK_README_CHARS = 4_000;
+function tokenize(query) {
+    return query
+        .split(/\s+/)
+        .map(t => t.replace(/[^a-zA-Z0-9_]/g, ''))
+        .filter(t => t.length >= MIN_TOKEN_LEN);
+}
+function buildFtsQuery(tokens) {
+    return tokens.map(t => `"${t}"`).join(' OR ');
+}
+function fallbackChunks(cache, name, version) {
+    const dts = cache.db
+        .prepare('SELECT file_path, kind, content, 0 AS rank FROM chunks WHERE name = ? AND version = ? AND kind = \'dts\' ORDER BY file_path, id LIMIT 1')
+        .all(name, version);
+    const readme = cache.db
+        .prepare('SELECT file_path, kind, content, 0 AS rank FROM chunks WHERE name = ? AND version = ? AND kind = \'readme\' ORDER BY id LIMIT 1')
+        .all(name, version);
+    const out = [];
+    for (const r of dts) {
+        out.push({
+            filePath: r.file_path,
+            kind: r.kind,
+            content: r.content.slice(0, FALLBACK_DTS_CHARS),
+            rank: 0
+        });
+    }
+    for (const r of readme) {
+        out.push({
+            filePath: r.file_path,
+            kind: r.kind,
+            content: r.content.slice(0, FALLBACK_README_CHARS),
+            rank: 0
+        });
+    }
+    return out;
+}
+function enforceBudget(chunks, budget) {
+    if (!chunks.length)
+        return chunks;
+    const out = [];
+    let total = 0;
+    for (const c of chunks) {
+        if (out.length === 0) {
+            out.push(c);
+            total += c.content.length;
+            continue;
+        }
+        if (total + c.content.length > budget)
+            break;
+        out.push(c);
+        total += c.content.length;
+    }
+    return out;
+}
+export function retrieveChunks(cache, opts) {
+    const limit = opts.limit ?? DEFAULT_LIMIT;
+    const budget = opts.contentBudget ?? DEFAULT_BUDGET;
+    const tokens = tokenize(opts.query);
+    if (tokens.length === 0) {
+        return enforceBudget(fallbackChunks(cache, opts.name, opts.version), budget);
+    }
+    const ftsQuery = buildFtsQuery(tokens);
+    let rows;
+    try {
+        rows = cache.db
+            .prepare(`SELECT c.file_path, c.kind, c.content, bm25(chunks_fts) AS rank
+                 FROM chunks_fts
+                 JOIN chunks c ON c.id = chunks_fts.rowid
+                 WHERE c.name = ?1 AND c.version = ?2 AND chunks_fts MATCH ?3
+                 ORDER BY rank
+                 LIMIT ?4`)
+            .all(opts.name, opts.version, ftsQuery, limit);
+    }
+    catch {
+        return enforceBudget(fallbackChunks(cache, opts.name, opts.version), budget);
+    }
+    if (rows.length === 0) {
+        return enforceBudget(fallbackChunks(cache, opts.name, opts.version), budget);
+    }
+    const mapped = rows.map(r => ({
+        filePath: r.file_path,
+        kind: r.kind,
+        content: r.content,
+        rank: r.rank
+    }));
+    return enforceBudget(mapped, budget);
+}

package/dist/workers/fetch-core.d.ts

@@ -0,0 +1,35 @@
+import { fetchAndClean as defaultFetchAndClean } from './html-clean.js';
+import { type SpawnFn } from '../shared/child-process.js';
+export interface FetchRawInput {
+    url: string;
+    signal?: AbortSignal;
+    fetchAndClean?: typeof defaultFetchAndClean;
+}
+export interface FetchRawResult {
+    markdown: string;
+    finalUrl: string;
+    title: string;
+}
+export declare function fetchRaw(input: FetchRawInput): Promise<FetchRawResult>;
+export interface FetchFocusedInput {
+    url: string;
+    query: string;
+    cwd: string;
+    signal?: AbortSignal;
+    fetchAndClean?: typeof defaultFetchAndClean;
+    spawn?: SpawnFn;
+}
+export interface FetchFocusedResult {
+    answer: string;
+    excerpt?: string;
+    excerptVerified?: boolean;
+    childExitCode: number;
+    aborted: boolean;
+    stderr: string;
+    stdout: string;
+}
+export declare function fetchFocused(input: FetchFocusedInput): Promise<FetchFocusedResult>;
+export declare function formatResultText(parsed: {
+    answer: string;
+    excerpt?: string;
+}, verified: boolean | undefined): string;

package/dist/workers/fetch-core.js

@@ -0,0 +1,91 @@
+import { spawn as defaultSpawn } from 'node:child_process';
+import { fetchAndClean as defaultFetchAndClean } from './html-clean.js';
+import { getPiInvocation } from '../shared/pi-invocation.js';
+import { CHILD_BASE_ARGS, runChild } from '../shared/child-process.js';
+import { parseChildOutput, isExcerptInContent, formatResultText as formatResultTextShared } from '../shared/child-output.js';
+const CONTENT_BUDGET = 30_000;
+const HEAD_CHARS = 25_000;
+const TAIL_CHARS = 5_000;
+const TRUNCATION_MARKER = '\n\n[...page continues, truncated...]\n\n';
+const CHILD_ARGS = [...CHILD_BASE_ARGS, '--no-tools'];
+export async function fetchRaw(input) {
+    const fetchAndCleanFn = input.fetchAndClean ?? defaultFetchAndClean;
+    const cleaned = await fetchAndCleanFn(input.url, { signal: input.signal });
+    return { markdown: cleaned.markdown, finalUrl: cleaned.finalUrl, title: cleaned.title };
+}
+export async function fetchFocused(input) {
+    const fetchAndCleanFn = input.fetchAndClean ?? defaultFetchAndClean;
+    const spawnFn = input.spawn ?? defaultSpawn;
+    const cleaned = await fetchAndCleanFn(input.url, { signal: input.signal });
+    const truncated = truncate(cleaned.markdown);
+    const prompt = buildPrompt({
+        query: input.query,
+        url: cleaned.finalUrl,
+        title: cleaned.title,
+        content: truncated
+    });
+    const invocation = getPiInvocation([...CHILD_ARGS, prompt]);
+    const childResult = await runChild(spawnFn, invocation, input.cwd, input.signal);
+    if (childResult.aborted) {
+        return {
+            answer: '',
+            childExitCode: childResult.exitCode,
+            aborted: true,
+            stderr: childResult.stderr,
+            stdout: childResult.stdout
+        };
+    }
+    if (childResult.exitCode !== 0) {
+        return {
+            answer: '',
+            childExitCode: childResult.exitCode,
+            aborted: false,
+            stderr: childResult.stderr,
+            stdout: childResult.stdout
+        };
+    }
+    const parsed = parseChildOutput(childResult.stdout);
+    const excerptVerified = parsed.excerpt ? isExcerptInContent(parsed.excerpt, cleaned.markdown) : undefined;
+    return {
+        answer: parsed.answer,
+        excerpt: parsed.excerpt,
+        excerptVerified,
+        childExitCode: 0,
+        aborted: false,
+        stderr: childResult.stderr,
+        stdout: childResult.stdout
+    };
+}
+function truncate(md) {
+    if (md.length <= CONTENT_BUDGET)
+        return md;
+    return md.slice(0, HEAD_CHARS) + TRUNCATION_MARKER + md.slice(md.length - TAIL_CHARS);
+}
+function buildPrompt(args) {
+    return (`You extract a single piece of information from a web page to answer one question.\n`
+        + `\n`
+        + `Rules:\n`
+        + `1. Output ONLY two tags, in this order, with NO text outside them:\n`
+        + `   <answer>...your answer...</answer>\n`
+        + `   <excerpt>...verbatim quote from <page-content>...</excerpt>\n`
+        + `2. The <excerpt> MUST be copied character-for-character from <page-content>.\n`
+        + `   Do not paraphrase, translate, or summarise inside <excerpt>.\n`
+        + `3. Distinguish content from UI: button labels, player widgets, status indicators,\n`
+        + `   navigation, breadcrumbs, and footers are NOT the answer unless the question is\n`
+        + `   specifically about page UI.\n`
+        + `4. If the page is not in English, write the <answer> in English (translate key\n`
+        + `   non-English terms) and keep the original-language text in <excerpt>.\n`
+        + `5. If the answer is unclear, ambiguous, or absent from <page-content>, write\n`
+        + `   exactly: <answer>unclear from this page</answer> and put the closest related\n`
+        + `   text in <excerpt>. Do not guess.\n`
+        + `6. Be terse. One short paragraph in <answer> max.\n`
+        + `\n`
+        + `<question>${args.query}</question>\n`
+        + `<url>${args.url}</url>\n`
+        + `<page-title>${args.title}</page-title>\n`
+        + `<page-content>\n${args.content}\n</page-content>\n`);
+}
+// ─── Thin wrapper: fetch-core formatResultText (no header) ───────────────────
+export function formatResultText(parsed, verified) {
+    return formatResultTextShared('', parsed, verified);
+}

package/dist/workers/html-clean.d.ts

@@ -0,0 +1,17 @@
+export interface CleanResult {
+    title: string;
+    markdown: string;
+    finalUrl: string;
+}
+export declare function cleanHtml(html: string, baseUrl: string): CleanResult;
+export declare class FetchAndCleanError extends Error {
+    readonly kind: 'invalid-url' | 'http-error' | 'not-html' | 'too-large' | 'network' | 'aborted';
+    readonly cause?: unknown | undefined;
+    constructor(message: string, kind: 'invalid-url' | 'http-error' | 'not-html' | 'too-large' | 'network' | 'aborted', cause?: unknown | undefined);
+}
+export interface FetchAndCleanOpts {
+    timeoutMs?: number;
+    maxBytes?: number;
+    signal?: AbortSignal;
+}
+export declare function fetchAndClean(url: string, opts?: FetchAndCleanOpts): Promise<CleanResult>;

package/dist/workers/html-clean.js

@@ -0,0 +1,142 @@
+import { JSDOM } from 'jsdom';
+import { Readability } from '@mozilla/readability';
+import TurndownService from 'turndown';
+const turndown = new TurndownService({
+    codeBlockStyle: 'fenced',
+    headingStyle: 'atx',
+    bulletListMarker: '-'
+});
+export function cleanHtml(html, baseUrl) {
+    const dom = new JSDOM(html, { url: baseUrl });
+    const reader = new Readability(dom.window.document);
+    const parsed = reader.parse();
+    if (parsed && parsed.content) {
+        return {
+            title: parsed.title || dom.window.document.title || new URL(baseUrl).hostname,
+            markdown: turndown.turndown(parsed.content).trim(),
+            finalUrl: baseUrl
+        };
+    }
+    // Fallback: turndown the body
+    const body = dom.window.document.body;
+    const bodyHtml = body ? body.innerHTML : '';
+    const markdown = turndown.turndown(bodyHtml).trim();
+    return {
+        title: dom.window.document.title || new URL(baseUrl).hostname,
+        markdown,
+        finalUrl: baseUrl
+    };
+}
+const DEFAULT_TIMEOUT_MS = 15_000;
+const DEFAULT_MAX_BYTES = 2 * 1024 * 1024; // 2 MB
+const PKG_VERSION = '0.2.0'; // bump in lockstep with package.json on release
+const USER_AGENT = `pi-worker/${PKG_VERSION} (+https://npmjs.com/package/@mjasnikovs/pi-worker)`;
+export class FetchAndCleanError extends Error {
+    kind;
+    cause;
+    constructor(message, kind, cause) {
+        super(message);
+        this.kind = kind;
+        this.cause = cause;
+        this.name = 'FetchAndCleanError';
+    }
+}
+export async function fetchAndClean(url, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const maxBytes = opts.maxBytes ?? DEFAULT_MAX_BYTES;
+    const internalController = new AbortController();
+    let sizeExceeded = false;
+    let userAborted = false;
+    const timeoutHandle = setTimeout(() => internalController.abort(), timeoutMs);
+    const onUserAbort = () => {
+        userAborted = true;
+        internalController.abort();
+    };
+    if (opts.signal) {
+        if (opts.signal.aborted)
+            onUserAbort();
+        else
+            opts.signal.addEventListener('abort', onUserAbort, { once: true });
+    }
+    try {
+        let response;
+        try {
+            response = await fetch(url, {
+                headers: { 'user-agent': USER_AGENT },
+                redirect: 'follow',
+                signal: internalController.signal
+            });
+        }
+        catch (err) {
+            if (userAborted) {
+                throw new FetchAndCleanError('Fetch aborted.', 'aborted', err);
+            }
+            throw new FetchAndCleanError(`Could not fetch ${url}: ${describeError(err)}`, 'network', err);
+        }
+        if (!response.ok) {
+            throw new FetchAndCleanError(`Fetch failed: HTTP ${response.status} ${response.statusText} for ${url}`, 'http-error');
+        }
+        const contentType = response.headers.get('content-type') ?? '';
+        if (!contentType.toLowerCase().includes('text/html')) {
+            throw new FetchAndCleanError(`${url} is ${contentType || 'unknown content type'}, not HTML. pi-worker-fetch only reads HTML pages.`, 'not-html');
+        }
+        const reader = response.body?.getReader();
+        if (!reader) {
+            throw new FetchAndCleanError(`Could not fetch ${url}: empty response body`, 'network');
+        }
+        const decoder = new TextDecoder('utf-8', { fatal: false });
+        let html = '';
+        let bytesRead = 0;
+        try {
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                if (value) {
+                    bytesRead += value.byteLength;
+                    if (bytesRead > maxBytes) {
+                        sizeExceeded = true;
+                        internalController.abort();
+                        break;
+                    }
+                    html += decoder.decode(value, { stream: true });
+                }
+            }
+            html += decoder.decode();
+        }
+        catch (err) {
+            if (sizeExceeded) {
+                // fall through to throw outside the catch
+            }
+            else if (userAborted) {
+                throw new FetchAndCleanError('Fetch aborted.', 'aborted', err);
+            }
+            else {
+                throw new FetchAndCleanError(`Could not fetch ${url}: ${describeError(err)}`, 'network', err);
+            }
+        }
+        if (sizeExceeded) {
+            throw new FetchAndCleanError(`${url} exceeds ${formatBytes(maxBytes)} size cap. Try a more specific URL.`, 'too-large');
+        }
+        const finalUrl = response.url || url;
+        const cleaned = cleanHtml(html, finalUrl);
+        return cleaned;
+    }
+    finally {
+        clearTimeout(timeoutHandle);
+        if (opts.signal)
+            opts.signal.removeEventListener('abort', onUserAbort);
+    }
+}
+function describeError(err) {
+    if (err instanceof Error)
+        return err.message;
+    return String(err);
+}
+function formatBytes(n) {
+    if (n >= 1024 * 1024)
+        return `${(n / 1024 / 1024).toFixed(1)} MB`;
+    if (n >= 1024)
+        return `${(n / 1024).toFixed(0)} KB`;
+    return `${n} B`;
+}

package/dist/workers/index.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+export declare function registerWorkers(pi: ExtensionAPI): void;

package/dist/workers/index.js

@@ -0,0 +1,10 @@
+import { registerPiWorker } from './pi-worker.js';
+import { registerPiWorkerSearch } from './pi-worker-search.js';
+import { registerPiWorkerFetch } from './pi-worker-fetch.js';
+import { registerPiWorkerDocs } from './pi-worker-docs.js';
+export function registerWorkers(pi) {
+    registerPiWorker(pi);
+    registerPiWorkerSearch(pi);
+    registerPiWorkerFetch(pi);
+    registerPiWorkerDocs(pi);
+}

package/dist/workers/npm-version.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Live npm registry version lookup.
+ *
+ * Solves a real failure mode: the auto-answer/research workers have no live
+ * source for "what's the latest published version of X", so they answer from
+ * training data, which goes stale. TASK_0005 hit this — the worker said
+ * "18.3.1, the latest stable React" when React 19.x had shipped months earlier.
+ *
+ * This module fetches the npm registry's metadata endpoint and returns just
+ * enough to anchor the worker in current reality: the dist-tag 'latest', a
+ * short list of recent versions, and the publish date of latest.
+ */
+export interface NpmVersionInfo {
+    pkg: string;
+    latest: string;
+    recent: string[];
+    publishedAt?: string;
+}
+export interface NpmVersionOpts {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    registry?: string;
+}
+/**
+ * Fetch the latest version + recent version list for an npm package.
+ * Returns `null` (never throws) on any failure — registry down, package not
+ * found, network error, malformed response. The caller treats null as "no
+ * fresh data available" and continues without it.
+ */
+export declare function npmVersionLookup(pkg: string, opts?: NpmVersionOpts): Promise<NpmVersionInfo | null>;
+/** Format an NpmVersionInfo as a short Markdown block for EXTERNAL CONTEXT. */
+export declare function formatNpmVersionSection(info: NpmVersionInfo): string;

package/dist/workers/npm-version.js

@@ -0,0 +1,102 @@
+/**
+ * Live npm registry version lookup.
+ *
+ * Solves a real failure mode: the auto-answer/research workers have no live
+ * source for "what's the latest published version of X", so they answer from
+ * training data, which goes stale. TASK_0005 hit this — the worker said
+ * "18.3.1, the latest stable React" when React 19.x had shipped months earlier.
+ *
+ * This module fetches the npm registry's metadata endpoint and returns just
+ * enough to anchor the worker in current reality: the dist-tag 'latest', a
+ * short list of recent versions, and the publish date of latest.
+ */
+const REGISTRY_BASE = 'https://registry.npmjs.org';
+const DEFAULT_TIMEOUT_MS = 3000;
+const RECENT_VERSIONS_LIMIT = 10;
+/**
+ * Fetch the latest version + recent version list for an npm package.
+ * Returns `null` (never throws) on any failure — registry down, package not
+ * found, network error, malformed response. The caller treats null as "no
+ * fresh data available" and continues without it.
+ */
+export async function npmVersionLookup(pkg, opts = {}) {
+    if (!isValidPackageName(pkg))
+        return null;
+    const base = opts.registry ?? REGISTRY_BASE;
+    const url = `${base}/${encodePackageName(pkg)}`;
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const internalController = new AbortController();
+    const timeoutHandle = setTimeout(() => internalController.abort(), timeoutMs);
+    const onUserAbort = () => internalController.abort();
+    if (opts.signal) {
+        if (opts.signal.aborted)
+            onUserAbort();
+        else
+            opts.signal.addEventListener('abort', onUserAbort, { once: true });
+    }
+    try {
+        let response;
+        try {
+            response = await fetch(url, {
+                method: 'GET',
+                headers: { accept: 'application/vnd.npm.install-v1+json, application/json' },
+                signal: internalController.signal
+            });
+        }
+        catch {
+            return null;
+        }
+        if (!response.ok)
+            return null;
+        let body;
+        try {
+            body = (await response.json());
+        }
+        catch {
+            return null;
+        }
+        const latest = body['dist-tags']?.latest;
+        if (typeof latest !== 'string' || latest.length === 0)
+            return null;
+        const allVersions = Object.keys(body.versions ?? {});
+        const recent = allVersions.slice(-RECENT_VERSIONS_LIMIT).reverse();
+        const publishedAtRaw = body.time?.[latest];
+        const publishedAt = typeof publishedAtRaw === 'string' ? publishedAtRaw : undefined;
+        return { pkg, latest, recent, publishedAt };
+    }
+    finally {
+        clearTimeout(timeoutHandle);
+        if (opts.signal)
+            opts.signal.removeEventListener('abort', onUserAbort);
+    }
+}
+/** Format an NpmVersionInfo as a short Markdown block for EXTERNAL CONTEXT. */
+export function formatNpmVersionSection(info) {
+    const lines = [`### npm: ${info.pkg}`, `latest: ${info.latest}`];
+    if (info.publishedAt) {
+        const date = info.publishedAt.slice(0, 10);
+        lines[1] += ` (published ${date})`;
+    }
+    if (info.recent.length > 0) {
+        lines.push(`recent: ${info.recent.join(', ')}`);
+    }
+    return lines.join('\n');
+}
+function isValidPackageName(pkg) {
+    if (pkg.length === 0 || pkg.length > 214)
+        return false;
+    if (pkg.startsWith('.') || pkg.startsWith('_'))
+        return false;
+    return /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/i.test(pkg);
+}
+function encodePackageName(pkg) {
+    if (pkg.startsWith('@')) {
+        const slash = pkg.indexOf('/');
+        if (slash > 0) {
+            return (encodeURIComponent(pkg.slice(0, slash))
+                + '/'
+                + encodeURIComponent(pkg.slice(slash + 1)));
+        }
+    }
+    return encodeURIComponent(pkg);
+}

package/dist/workers/pi-worker-core.d.ts

@@ -0,0 +1,28 @@
+import { type SpawnFn } from '../shared/child-process.js';
+export interface RunWorkerInput {
+    prompt: string;
+    cwd: string;
+    signal?: AbortSignal;
+    spawn?: SpawnFn;
+    /** Comma-separated tool whitelist passed to `pi --tools`. Defaults to read,grep,find,ls. */
+    tools?: string;
+}
+export interface RunWorkerResult {
+    text: string;
+    exitCode: number;
+    stderr: string;
+    aborted: boolean;
+    /**
+     * Milliseconds between spawn and the child's first stdout chunk. When
+     * multiple workers run concurrently and the upstream model API queues at
+     * some concurrency cap, this is the queue-wait portion of the run.
+     */
+    waitMs: number;
+    /**
+     * Milliseconds between first stdout chunk and process exit — the
+     * generation/tool-call portion, independent of queue wait. Equals total
+     * elapsed when the child never produced output.
+     */
+    workMs: number;
+}
+export declare function runWorker(input: RunWorkerInput): Promise<RunWorkerResult>;

package/dist/workers/pi-worker-core.js

@@ -0,0 +1,29 @@
+import { getPiInvocation } from '../shared/pi-invocation.js';
+import { CHILD_BASE_ARGS, runChildDefault } from '../shared/child-process.js';
+// `--mode json` makes pi emit structured events as they happen instead of
+// buffering the assistant text and flushing on exit. That matters for the
+// wait/work timing split: in text mode the first stdout chunk only arrives at
+// the very end, so onFirstByte fires moments before close and workMs is
+// effectively zero. With JSON events the first byte lands as soon as the
+// model starts producing — making waitMs the real queue/cold-start cost and
+// workMs the real generation+tool-call cost.
+const DEFAULT_TOOLS = 'read,grep,find,ls';
+export async function runWorker(input) {
+    const tools = input.tools ?? DEFAULT_TOOLS;
+    const childArgs = [...CHILD_BASE_ARGS, '--mode', 'json', '--tools', tools];
+    const invocation = getPiInvocation([...childArgs, input.prompt]);
+    const tStart = Date.now();
+    let tFirstByte = null;
+    const result = await runChildDefault(invocation, input.cwd, input.signal, { mode: 'json-events', onFirstByte: () => (tFirstByte = Date.now()) }, input.spawn);
+    const tEnd = Date.now();
+    const waitMs = tFirstByte === null ? tEnd - tStart : tFirstByte - tStart;
+    const workMs = tFirstByte === null ? 0 : tEnd - tFirstByte;
+    return {
+        text: result.text ?? '',
+        exitCode: result.exitCode,
+        stderr: result.stderr.trim(),
+        aborted: result.aborted,
+        waitMs,
+        workMs
+    };
+}

package/dist/workers/pi-worker-docs.d.ts

@@ -0,0 +1,16 @@
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { openCache as defaultOpenCache } from './docs-cache.js';
+import { ensureIndexed as defaultEnsureIndexed } from './docs-index.js';
+import { resolvePackage as defaultResolvePackage } from './docs-resolve.js';
+import { retrieveChunks as defaultRetrieveChunks } from './docs-retrieve.js';
+import { npmVersionLookup as defaultNpmVersionLookup } from './npm-version.js';
+import { type SpawnFn } from '../shared/child-process.js';
+export interface PiWorkerDocsInternals {
+    resolvePackage?: typeof defaultResolvePackage;
+    ensureIndexed?: typeof defaultEnsureIndexed;
+    retrieveChunks?: typeof defaultRetrieveChunks;
+    openCache?: typeof defaultOpenCache;
+    spawn?: SpawnFn;
+    npmVersionLookup?: typeof defaultNpmVersionLookup;
+}
+export declare function registerPiWorkerDocs(pi: ExtensionAPI, internals?: PiWorkerDocsInternals): void;