@mjasnikovs/pi-task 0.13.5 → 0.13.7

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

@@ -7,7 +7,7 @@ import { formatNpmVersionSection } from './npm-version.js';
 import { runChild, CHILD_BASE_ARGS } from '../shared/child-process.js';
 import { parseChildOutput, isExcerptInContent } from '../shared/child-output.js';
 import { getPiInvocation } from '../shared/pi-invocation.js';
-import { textResult } from './shared.js';
+import { formatChildFailure, makeWorkerTool } from './shared.js';
 import { projectDocsRaw, buildProjectPrompt } from './docs-project.js';
 const CHILD_ARGS = [...CHILD_BASE_ARGS, '--no-tools'];
 const RENDER_QUERY_MAX = 100;
@@ -20,7 +20,7 @@ const Params = Type.Object({
     })
 });
 export function registerPiWorkerDocs(pi, internals = {}) {
-    pi.registerTool({
+    makeWorkerTool(pi, {
         name: 'pi-worker-docs',
         label: 'Pi Worker Docs',
         description: 'Look up an INSTALLED npm package and return a focused, version-pinned '
@@ -56,8 +56,7 @@ export function registerPiWorkerDocs(pi, internals = {}) {
             + 'Skip when:\n'
             + '- You need docs for a specific newer version than what is installed — use pi-worker-fetch on the upstream docs site',
         parameters: Params,
-        executionMode: 'parallel',
-        async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        async run(params, signal, ctx) {
             const spawn = internals.spawn
                 ?? (globalThis.Bun !== undefined ?
                     globalThis.Bun.spawn
@@ -74,18 +73,24 @@ export function registerPiWorkerDocs(pi, internals = {}) {
                     cacheError = err instanceof Error ? err.message : String(err);
                 }
                 if (!cache) {
-                    return textResult(`Project docs unavailable: cache open failed (${cacheError}).`, {});
+                    return {
+                        text: `Project docs unavailable: cache open failed (${cacheError}).`,
+                        details: {}
+                    };
                 }
                 const retrieveChunks = internals.retrieveChunks ?? defaultRetrieveChunks;
                 const projectResult = projectDocsRaw(cache, ctx.cwd, params.query, retrieveChunks);
                 if (projectResult.kind === 'error') {
-                    return textResult(`Project docs error: ${projectResult.message}`, {});
+                    return { text: `Project docs error: ${projectResult.message}`, details: {} };
                 }
                 if (projectResult.kind === 'no_chunks') {
-                    return textResult(`Project "${projectResult.projectName}" has no .ts/.tsx files indexed.`, {
-                        hitCache: projectResult.hitCache,
-                        indexedFiles: projectResult.filesIngested
-                    });
+                    return {
+                        text: `Project "${projectResult.projectName}" has no .ts/.tsx files indexed.`,
+                        details: {
+                            hitCache: projectResult.hitCache,
+                            indexedFiles: projectResult.filesIngested
+                        }
+                    };
                 }
                 const { projectName, chunks, hitCache, filesIngested, indexingMs } = projectResult;
                 const baseDetails = {
@@ -98,19 +103,16 @@ export function registerPiWorkerDocs(pi, internals = {}) {
                 const prompt = buildProjectPrompt(projectName, params.query, concatenated);
                 const invocation = getPiInvocation([...CHILD_ARGS, prompt]);
                 const child = await runChild(spawn, invocation, ctx.cwd, signal);
-                if (child.aborted) {
-                    return textResult('Project docs lookup aborted.', {
-                        ...baseDetails,
-                        aborted: true,
-                        childExitCode: child.exitCode
-                    });
-                }
-                if (child.exitCode !== 0) {
-                    const tail = child.stderr.trim().slice(-500) || '(no stderr)';
-                    return textResult(`Worker exited ${child.exitCode}.\n${tail}`, {
-                        ...baseDetails,
-                        childExitCode: child.exitCode
-                    });
+                const failure = formatChildFailure(child, 'Project docs lookup aborted.');
+                if (failure !== null) {
+                    return {
+                        text: failure,
+                        details: {
+                            ...baseDetails,
+                            ...(child.aborted ? { aborted: true } : {}),
+                            childExitCode: child.exitCode
+                        }
+                    };
                 }
                 const parsed = parseChildOutput(child.stdout);
                 const verified = parsed.excerpt ? isExcerptInContent(parsed.excerpt, concatenated) : undefined;
@@ -121,11 +123,14 @@ export function registerPiWorkerDocs(pi, internals = {}) {
                     entryDts: null,
                     readme: null
                 }, parsed, verified);
-                return textResult(text, {
-                    ...baseDetails,
-                    childExitCode: 0,
-                    excerptVerified: verified
-                });
+                return {
+                    text,
+                    details: {
+                        ...baseDetails,
+                        childExitCode: 0,
+                        excerptVerified: verified
+                    }
+                };
             }
             // ── npm package lookup (existing path) ──────────────────────────
             const rawResult = await docsRaw({
@@ -157,22 +162,28 @@ export function registerPiWorkerDocs(pi, internals = {}) {
                     autoInstalled: rawResult.autoInstalled,
                     ...npmDetails
                 };
-                return textResult(npmHeader + rawResult.message, details);
+                return { text: npmHeader + rawResult.message, details };
             }
             if (rawResult.kind === 'not_installed') {
-                return textResult(npmHeader
-                    + `Package "${rawResult.pkg}" is not installed and auto-install failed.`, { resolveError: 'not_installed', ...npmDetails });
+                return {
+                    text: npmHeader
+                        + `Package "${rawResult.pkg}" is not installed and auto-install failed.`,
+                    details: { resolveError: 'not_installed', ...npmDetails }
+                };
             }
             if (rawResult.kind === 'no_chunks') {
-                return textResult(npmHeader
-                    + `Package ${rawResult.pkg.name}@${rawResult.pkg.version} has no .d.ts files or README. Use pi-worker to read source directly.`, {
-                    version: rawResult.pkg.version,
-                    hitCache: rawResult.hitCache,
-                    indexedFiles: rawResult.indexedFiles ?? 0,
-                    cacheError: rawResult.cacheError,
-                    autoInstalled: rawResult.autoInstalled,
-                    ...npmDetails
-                });
+                return {
+                    text: npmHeader
+                        + `Package ${rawResult.pkg.name}@${rawResult.pkg.version} has no .d.ts files or README. Use pi-worker to read source directly.`,
+                    details: {
+                        version: rawResult.pkg.version,
+                        hitCache: rawResult.hitCache,
+                        indexedFiles: rawResult.indexedFiles ?? 0,
+                        cacheError: rawResult.cacheError,
+                        autoInstalled: rawResult.autoInstalled,
+                        ...npmDetails
+                    }
+                };
             }
             // kind === 'ok'
             const { pkg, chunks, hitCache, indexingMs, cacheError, autoInstalled } = rawResult;
@@ -189,28 +200,28 @@ export function registerPiWorkerDocs(pi, internals = {}) {
             const prompt = buildPrompt(pkg, params.query, concatenated);
             const invocation = getPiInvocation([...CHILD_ARGS, prompt]);
             const child = await runChild(spawn, invocation, ctx.cwd, signal);
-            if (child.aborted) {
-                return textResult(npmHeader + 'Docs lookup aborted.', {
-                    ...baseDetails,
-                    aborted: true,
-                    childExitCode: child.exitCode
-                });
-            }
-            if (child.exitCode !== 0) {
-                const tail = child.stderr.trim().slice(-500) || '(no stderr)';
-                return textResult(npmHeader + `Worker exited ${child.exitCode}.\n${tail}`, {
-                    ...baseDetails,
-                    childExitCode: child.exitCode
-                });
+            const failure = formatChildFailure(child, 'Docs lookup aborted.');
+            if (failure !== null) {
+                return {
+                    text: npmHeader + failure,
+                    details: {
+                        ...baseDetails,
+                        ...(child.aborted ? { aborted: true } : {}),
+                        childExitCode: child.exitCode
+                    }
+                };
             }
             const parsed = parseChildOutput(child.stdout);
             const verified = parsed.excerpt ? isExcerptInContent(parsed.excerpt, concatenated) : undefined;
             const text = npmHeader + formatResultText(pkg, parsed, verified);
-            return textResult(text, {
-                ...baseDetails,
-                childExitCode: 0,
-                excerptVerified: verified
-            });
+            return {
+                text,
+                details: {
+                    ...baseDetails,
+                    childExitCode: 0,
+                    excerptVerified: verified
+                }
+            };
         },
         renderCall(args, theme) {
             const query = args.query.replace(/\s+/g, ' ').trim();

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

@@ -2,7 +2,7 @@ import { Type } from '@sinclair/typebox';
 import { Text } from '@earendil-works/pi-tui';
 import { FetchAndCleanError } from './html-clean.js';
 import { fetchFocused, formatResultText } from './fetch-core.js';
-import { textResult } from './shared.js';
+import { formatChildFailure, makeWorkerTool } from './shared.js';
 const RENDER_QUERY_MAX = 100;
 const Params = Type.Object({
     url: Type.String({ description: 'URL to fetch. Must be http or https.' }),
@@ -11,7 +11,7 @@ const Params = Type.Object({
     })
 });
 export function registerPiWorkerFetch(pi, internals = {}) {
-    pi.registerTool({
+    makeWorkerTool(pi, {
         name: 'pi-worker-fetch',
         label: 'Pi Worker Fetch',
         description: 'Fetch a web page or text resource (HTML, markdown, plain text, JSON, '
@@ -20,13 +20,12 @@ export function registerPiWorkerFetch(pi, internals = {}) {
             + 'focused answer. Use after `pi-worker-search` (or with a known URL) to '
             + 'avoid stuffing raw content into the main context.',
         parameters: Params,
-        executionMode: 'parallel',
-        async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        async run(params, signal, ctx) {
             try {
                 new URL(params.url);
             }
             catch {
-                return textResult(`Invalid URL: ${params.url}`, {});
+                return { text: `Invalid URL: ${params.url}`, details: {} };
             }
             try {
                 const result = await fetchFocused({
@@ -37,28 +36,33 @@ export function registerPiWorkerFetch(pi, internals = {}) {
                     fetchAndClean: internals.fetchAndClean,
                     spawn: internals.spawn
                 });
-                if (result.aborted) {
-                    return textResult('Fetch aborted.', { childExitCode: result.childExitCode });
-                }
-                if (result.childExitCode !== 0) {
-                    const tail = result.stderr.trim().slice(-500) || '(no stderr)';
-                    return textResult(`Worker exited ${result.childExitCode}.\n${tail}`, {
-                        childExitCode: result.childExitCode
-                    });
+                const failure = formatChildFailure({
+                    aborted: result.aborted,
+                    exitCode: result.childExitCode,
+                    stderr: result.stderr
+                }, 'Fetch aborted.');
+                if (failure !== null) {
+                    return { text: failure, details: { childExitCode: result.childExitCode } };
                 }
                 const text = formatResultText({ answer: result.answer, excerpt: result.excerpt }, result.excerptVerified) || '(no output)';
-                return textResult(text, {
-                    childExitCode: 0,
-                    answer: result.answer,
-                    excerpt: result.excerpt,
-                    excerptVerified: result.excerptVerified
-                });
+                return {
+                    text,
+                    details: {
+                        childExitCode: 0,
+                        answer: result.answer,
+                        excerpt: result.excerpt,
+                        excerptVerified: result.excerptVerified
+                    }
+                };
             }
             catch (err) {
                 if (err instanceof FetchAndCleanError) {
-                    return textResult(err.message, {});
+                    return { text: err.message, details: {} };
                 }
-                return textResult(`Could not fetch ${params.url}: ${err instanceof Error ? err.message : String(err)}`, {});
+                return {
+                    text: `Could not fetch ${params.url}: ${err instanceof Error ? err.message : String(err)}`,
+                    details: {}
+                };
             }
         },
         renderCall(args, theme) {

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

@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox';
 import { Text } from '@earendil-works/pi-tui';
 import { search } from './search-core.js';
-import { textResult } from './shared.js';
+import { makeWorkerTool } from './shared.js';
 const Params = Type.Object({
     query: Type.String({ description: 'Search query.' }),
     count: Type.Optional(Type.Integer({
@@ -11,7 +11,7 @@ const Params = Type.Object({
     }))
 });
 export function registerPiWorkerSearch(pi, internals = {}) {
-    pi.registerTool({
+    makeWorkerTool(pi, {
         name: 'pi-worker-search',
         label: 'Pi Worker Search',
         description: 'Search the live web via Brave Search. CALL THIS BEFORE ANSWERING any '
@@ -24,8 +24,7 @@ export function registerPiWorkerSearch(pi, internals = {}) {
             + 'call `pi-worker-fetch` on the URL you want to read. '
             + 'Requires BRAVE_SEARCH_API_KEY env var.',
         parameters: Params,
-        executionMode: 'parallel',
-        async execute(_toolCallId, params, signal) {
+        async run(params, signal) {
             const result = await search({
                 query: params.query,
                 count: params.count,
@@ -33,20 +32,15 @@ export function registerPiWorkerSearch(pi, internals = {}) {
                 getEnv: internals.getEnv,
                 braveSearch: internals.braveSearch
             });
-            if (result.kind === 'no_key') {
-                return textResult(result.message, { resultCount: 0 });
-            }
-            if (result.kind === 'error') {
-                return textResult(result.message, { resultCount: 0 });
+            if (result.kind === 'no_key' || result.kind === 'error') {
+                return { text: result.message, details: { resultCount: 0 } };
             }
             const { results } = result;
             if (results.length === 0) {
-                return textResult(`No results for: ${params.query}`, {
-                    resultCount: 0
-                });
+                return { text: `No results for: ${params.query}`, details: { resultCount: 0 } };
             }
             const lines = results.map((r, i) => `${i + 1}. [${r.title}](${r.url}) — ${r.description}`);
-            return textResult(lines.join('\n'), { resultCount: results.length });
+            return { text: lines.join('\n'), details: { resultCount: results.length } };
         },
         renderCall(args, theme) {
             let text = theme.fg('toolTitle', theme.bold('pi-worker-search '));

package/dist/workers/pi-worker.js

@@ -9,13 +9,13 @@
 import { Text } from '@earendil-works/pi-tui';
 import { Type } from '@sinclair/typebox';
 import { runWorker } from './pi-worker-core.js';
-import { textResult } from './shared.js';
+import { formatChildFailure, makeWorkerTool } from './shared.js';
 const RENDER_PROMPT_MAX = 120;
 const WorkerParams = Type.Object({
     prompt: Type.String({ description: 'Task for the worker to perform.' })
 });
 export function registerPiWorker(pi) {
-    pi.registerTool({
+    makeWorkerTool(pi, {
         name: 'pi-worker',
         label: 'Pi Worker',
         description: 'Dispatch an isolated child Pi to investigate and return its CONCLUSION — '
@@ -37,19 +37,13 @@ export function registerPiWorker(pi) {
             + '- The task needs writes/edits (worker is read-only)\n'
             + '- The task needs the web — use `pi-worker-search` / `pi-worker-fetch`',
         parameters: WorkerParams,
-        executionMode: 'parallel',
-        async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        async run(params, signal, ctx) {
             const result = await runWorker({ prompt: params.prompt, cwd: ctx.cwd, signal });
-            if (result.aborted) {
-                return textResult('Worker aborted.', { exitCode: result.exitCode });
-            }
-            if (result.exitCode !== 0) {
-                const tail = result.stderr.slice(-500) || '(no stderr)';
-                return textResult(`Worker exited ${result.exitCode}.\n${tail}`, {
-                    exitCode: result.exitCode
-                });
-            }
-            return textResult(result.text || '(no output)', { exitCode: result.exitCode });
+            const details = { exitCode: result.exitCode };
+            const failure = formatChildFailure(result, 'Worker aborted.');
+            if (failure !== null)
+                return { text: failure, details };
+            return { text: result.text || '(no output)', details };
         },
         renderCall(args, theme) {
             const prompt = args.prompt.replace(/\s+/g, ' ').trim();

package/dist/workers/shared.d.ts

@@ -1,3 +1,43 @@
+import type { Static, TSchema } from '@sinclair/typebox';
 import type { AgentToolResult } from '@earendil-works/pi-agent-core';
+import type { ExtensionAPI, ExtensionContext, Theme } from '@earendil-works/pi-coding-agent';
+import type { Text } from '@earendil-works/pi-tui';
 /** Build a plain-text AgentToolResult. */
 export declare function textResult<T>(text: string, details: T): AgentToolResult<T>;
+/**
+ * The slice of a child-process result a worker needs to decide failure.
+ * `exitCode` is normalised here — `fetch-core` exposes it as `childExitCode`,
+ * the others as `exitCode`; callers map to this single name.
+ */
+export interface ChildOutcome {
+    aborted: boolean;
+    exitCode: number;
+    stderr: string;
+}
+/**
+ * The one place worker child-failure is turned into a user-facing message.
+ * Returns `null` when the child succeeded (caller proceeds to format output),
+ * otherwise the standard abort/exit message. Concentrating this here keeps the
+ * stderr-tail rule identical across every worker — it had already drifted
+ * (`pi-worker` skipped the `.trim()` the others applied).
+ */
+export declare function formatChildFailure(child: ChildOutcome, abortedMessage: string): string | null;
+/**
+ * What a worker tool is, minus the registration ritual: a name/label/schema,
+ * a `run` that produces the focused text + structured details, and a `renderCall`
+ * for the TUI. `makeWorkerTool` owns `registerTool`, the parallel execution mode,
+ * and wrapping the result in `textResult`.
+ */
+export interface WorkerToolSpec<TParams extends TSchema, TDetails> {
+    name: string;
+    label: string;
+    description: string;
+    parameters: TParams;
+    run(params: Static<TParams>, signal: AbortSignal | undefined, ctx: ExtensionContext): Promise<{
+        text: string;
+        details: TDetails;
+    }>;
+    renderCall(args: Static<TParams>, theme: Theme): Text;
+}
+/** Register a worker tool from its spec, supplying the shared registration ritual. */
+export declare function makeWorkerTool<TParams extends TSchema, TDetails>(pi: ExtensionAPI, spec: WorkerToolSpec<TParams, TDetails>): void;

package/dist/workers/shared.js

@@ -2,3 +2,34 @@
 export function textResult(text, details) {
     return { content: [{ type: 'text', text }], details };
 }
+/**
+ * The one place worker child-failure is turned into a user-facing message.
+ * Returns `null` when the child succeeded (caller proceeds to format output),
+ * otherwise the standard abort/exit message. Concentrating this here keeps the
+ * stderr-tail rule identical across every worker — it had already drifted
+ * (`pi-worker` skipped the `.trim()` the others applied).
+ */
+export function formatChildFailure(child, abortedMessage) {
+    if (child.aborted)
+        return abortedMessage;
+    if (child.exitCode !== 0) {
+        const tail = child.stderr.trim().slice(-500) || '(no stderr)';
+        return `Worker exited ${child.exitCode}.\n${tail}`;
+    }
+    return null;
+}
+/** Register a worker tool from its spec, supplying the shared registration ritual. */
+export function makeWorkerTool(pi, spec) {
+    pi.registerTool({
+        name: spec.name,
+        label: spec.label,
+        description: spec.description,
+        parameters: spec.parameters,
+        executionMode: 'parallel',
+        async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+            const { text, details } = await spec.run(params, signal, ctx);
+            return textResult(text, details);
+        },
+        renderCall: (args, theme) => spec.renderCall(args, theme)
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.13.5",
+    "version": "0.13.7",
     "description": "Deterministic spec-orchestration for local models, with a bundled real-time remote web view and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",