@mjasnikovs/pi-task 0.38.13 → 0.38.14

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.38.13",
+    "version": "0.38.14",
     "description": "Deterministic task planning and spec-orchestration for local models — crash-safe /task pipelines with verify/enforce gates, a real-time remote web view, and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",
@@ -12,7 +12,7 @@
         "LICENSE"
     ],
     "scripts": {
-        "build": "tsc -p tsconfig.build.json",
+        "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.build.json",
         "lint": "prettier --log-level warn --write 'src/**/*.ts' && eslint --fix . && tsc --noEmit && tsc -p scripts/tsconfig.json --noEmit",
         "test": "cross-env AGENT=1 bun test --isolate src/ scripts/",
         "prepublishOnly": "bun run build"

package/dist/remote/state.d.ts

@@ -1,2 +0,0 @@
-export declare function isAgentIdle(): boolean;
-export declare function setAgentIdle(idle: boolean): void;

package/dist/remote/state.js

@@ -1,7 +0,0 @@
-let _isAgentIdle = true;
-export function isAgentIdle() {
-    return _isAgentIdle;
-}
-export function setAgentIdle(idle) {
-    _isAgentIdle = idle;
-}

package/dist/thinking/compress.d.ts

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

package/dist/thinking/compress.js

@@ -1,118 +0,0 @@
-import { getConfig } from '../config/config.js';
-import { collectCompressible, MIN_THINKING_CHARS, rebuildWithCompressed } from './rewrite.js';
-/** Hard cap so a stuck model request can never wedge a turn. */
-const REQUEST_TIMEOUT_MS = 120_000;
-const STATUS_KEY = 'pi-task-thinking';
-const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-const PROMPT = 'Compress this reasoning. Keep every decision/conclusion/constraint/fact relied on later. '
-    + 'Drop restated questions, false starts, self-talk. Output only the compressed reasoning. /no_think';
-async function compressOne(text, model, auth) {
-    const headers = { 'Content-Type': 'application/json', ...auth.headers };
-    if (auth.apiKey)
-        headers.Authorization = `Bearer ${auth.apiKey}`;
-    const res = await fetch(`${model.baseUrl}/chat/completions`, {
-        method: 'POST',
-        headers,
-        body: JSON.stringify({
-            model: model.id,
-            messages: [{ role: 'user', content: `${PROMPT}\n\n---\n\n${text}` }],
-            temperature: 0,
-            stream: false
-        }),
-        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
-    });
-    if (!res.ok)
-        throw new Error(`compress HTTP ${res.status}`);
-    const data = (await res.json());
-    const raw = data.choices?.[0]?.message?.content ?? '';
-    return raw.replaceAll('<think>', '').replaceAll('</think>', '').trim();
-}
-/** Animated footer loader. Safe in any mode — `setStatus` is a no-op outside the
- *  TUI. Each tick reports which block is compressing and its size. */
-class Loader {
-    ui;
-    timer = null;
-    frame = 0;
-    constructor(ui) {
-        this.ui = ui;
-    }
-    start(label) {
-        this.stop();
-        const tick = () => {
-            this.ui.setStatus(STATUS_KEY, `${SPINNER[this.frame % SPINNER.length]} ${label()}`);
-            this.frame++;
-        };
-        tick();
-        this.timer = setInterval(tick, 120);
-    }
-    /** Show a final, non-animated line, then clear it after a short beat. */
-    finish(text) {
-        this.stop();
-        this.ui.setStatus(STATUS_KEY, text);
-        if (text !== undefined) {
-            setTimeout(() => this.ui.setStatus(STATUS_KEY, undefined), 4000);
-        }
-    }
-    stop() {
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
-    }
-}
-async function resolveAuth(ctx, model) {
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument -- ctx.model is Model<any>; the registry wants Model<Api>
-        const r = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-        return r.ok ? { apiKey: r.apiKey, headers: r.headers } : {};
-    }
-    catch {
-        return {};
-    }
-}
-const pct = (from, to) => Math.round((100 * (from - to)) / from);
-export function registerThinkingCompression(pi) {
-    pi.on('message_end', async (event, ctx) => {
-        if (!getConfig().compressReasoning)
-            return;
-        const message = event.message;
-        const targets = collectCompressible(message, MIN_THINKING_CHARS);
-        if (targets.length === 0)
-            return;
-        const model = ctx.model;
-        if (!model)
-            return;
-        const loader = new Loader(ctx.ui);
-        const auth = await resolveAuth(ctx, model);
-        const modelRef = { id: model.id, baseUrl: model.baseUrl };
-        const replacements = new Map();
-        let origTotal = 0;
-        let newTotal = 0;
-        for (let i = 0; i < targets.length; i++) {
-            const t = targets[i];
-            const n = i + 1;
-            loader.start(() => targets.length > 1 ?
-                `compressing reasoning ${n}/${targets.length} (${t.text.length}c)…`
-                : `compressing reasoning (${t.text.length}c)…`);
-            try {
-                const compressed = await compressOne(t.text, modelRef, auth);
-                if (compressed.length > 0 && compressed.length < t.text.length) {
-                    replacements.set(t.index, compressed);
-                    origTotal += t.text.length;
-                    newTotal += compressed.length;
-                }
-            }
-            catch {
-                // Leave this block verbatim; move on to the next.
-            }
-        }
-        if (replacements.size === 0) {
-            loader.finish(undefined);
-            return;
-        }
-        loader.finish(`✓ reasoning ${origTotal}→${newTotal}c (−${pct(origTotal, newTotal)}%)`);
-        // Cast back to the concrete AgentMessage type: the helpers work on a
-        // structural view, but the rewrite only swaps thinking-block text.
-        return { message: rebuildWithCompressed(message, replacements) };
-    });
-}

package/dist/thinking/rewrite.d.ts

@@ -1,29 +0,0 @@
-/** Minimal structural view of a thinking content block. Kept structural (rather
- *  than importing pi-ai's `ThinkingContent`) so these helpers stay pure and are
- *  trivially unit-testable with plain objects. */
-export interface ThinkingBlock {
-    type: 'thinking';
-    thinking: string;
-    thinkingSignature?: string;
-    redacted?: boolean;
-}
-export interface AssistantMessageLike {
-    role?: string;
-    content?: unknown;
-}
-export interface CompressTarget {
-    index: number;
-    text: string;
-}
-/** Thinking blocks shorter than this aren't worth a model round-trip. */
-export declare const MIN_THINKING_CHARS = 120;
-export declare function isThinkingBlock(b: unknown): b is ThinkingBlock;
-export declare function isCompressible(b: ThinkingBlock, minChars: number): boolean;
-/** Compressible thinking blocks of an assistant message, with their positions. */
-export declare function collectCompressible(message: AssistantMessageLike, minChars: number): CompressTarget[];
-/** Rebuild an assistant message with compressed text swapped into the given
- *  block indices. The block `type` and `thinkingSignature` are preserved so the
- *  local provider still replays the (now shorter) reasoning, and a replacement is
- *  only applied when it actually shrinks the block. Returns the same object when
- *  nothing changed. */
-export declare function rebuildWithCompressed<T extends AssistantMessageLike>(message: T, byIndex: ReadonlyMap<number, string>): T;

package/dist/thinking/rewrite.js

@@ -1,53 +0,0 @@
-/** Thinking blocks shorter than this aren't worth a model round-trip. */
-export const MIN_THINKING_CHARS = 120;
-/** In `openai-completions` (llama.cpp/local) the "signature" is a field *name*
- *  (`reasoning_content`) the reasoning is replayed under — not a crypto
- *  signature — so rewriting the text is safe. A long, non-sentinel signature is
- *  Anthropic-style extended thinking, where the signature cryptographically
- *  signs the original text and the block feeds the next turn's continuation;
- *  rewriting it would break that, so those blocks are skipped. */
-const SENTINEL_SIGNATURES = new Set(['', 'reasoning_content', 'reasoning', 'reasoning_text']);
-export function isThinkingBlock(b) {
-    return (typeof b === 'object'
-        && b !== null
-        && b.type === 'thinking'
-        && typeof b.thinking === 'string');
-}
-export function isCompressible(b, minChars) {
-    if (b.redacted)
-        return false;
-    if (!SENTINEL_SIGNATURES.has(b.thinkingSignature ?? ''))
-        return false;
-    return b.thinking.trim().length >= minChars;
-}
-/** Compressible thinking blocks of an assistant message, with their positions. */
-export function collectCompressible(message, minChars) {
-    if (message.role !== 'assistant' || !Array.isArray(message.content))
-        return [];
-    const out = [];
-    message.content.forEach((b, index) => {
-        if (isThinkingBlock(b) && isCompressible(b, minChars))
-            out.push({ index, text: b.thinking });
-    });
-    return out;
-}
-/** Rebuild an assistant message with compressed text swapped into the given
- *  block indices. The block `type` and `thinkingSignature` are preserved so the
- *  local provider still replays the (now shorter) reasoning, and a replacement is
- *  only applied when it actually shrinks the block. Returns the same object when
- *  nothing changed. */
-export function rebuildWithCompressed(message, byIndex) {
-    if (byIndex.size === 0 || !Array.isArray(message.content))
-        return message;
-    let changed = false;
-    const content = message.content.map((b, index) => {
-        const compressed = byIndex.get(index);
-        if (compressed === undefined || !isThinkingBlock(b))
-            return b;
-        if (compressed.length >= b.thinking.length)
-            return b;
-        changed = true;
-        return { ...b, thinking: compressed };
-    });
-    return changed ? { ...message, content } : message;
-}