@mjasnikovs/pi-task 0.8.1 → 0.9.0

package/dist/index.js

@@ -2,11 +2,11 @@ import { registerTask } from './task/orchestrator.js';
 import { registerTaskAuto } from './task/auto-orchestrator.js';
 import { registerWorkers } from './workers/index.js';
 import { registerRemote } from './remote/register.js';
-import { registerContextCompression } from './context/compress.js';
+import { registerThinkingCompression } from './thinking/compress.js';
 export default function (pi) {
     registerTask(pi);
     registerTaskAuto(pi);
     registerWorkers(pi);
     registerRemote(pi);
-    registerContextCompression(pi);
+    registerThinkingCompression(pi);
 }

package/dist/thinking/compress.d.ts

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

package/dist/thinking/compress.js

@@ -0,0 +1,115 @@
+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) => {
+        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

@@ -0,0 +1,29 @@
+/** 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

@@ -0,0 +1,53 @@
+/** 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;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.8.1",
+    "version": "0.9.0",
     "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",

package/dist/context/cache.d.ts

@@ -1,18 +0,0 @@
-/** Stable content hash for a thinking block. Determinism of the compressor at
- *  temperature 0 (validated against the local model) makes this a safe cache
- *  key: identical reasoning compresses to identical output, so each unique
- *  block is sent to the model exactly once, ever. */
-export declare function hashText(text: string): string;
-/** Disk-backed `hash -> compressed text` store. The on-disk file lets the
- *  "compress once" guarantee survive process restarts, not just jiti reloads. */
-export declare class CompressionCache {
-    private readonly file;
-    private mem;
-    private loaded;
-    constructor(file: string);
-    private load;
-    get(hash: string): string | undefined;
-    has(hash: string): boolean;
-    set(hash: string, compressed: string): void;
-    get size(): number;
-}

package/dist/context/cache.js

@@ -1,56 +0,0 @@
-import { createHash } from 'node:crypto';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-/** Stable content hash for a thinking block. Determinism of the compressor at
- *  temperature 0 (validated against the local model) makes this a safe cache
- *  key: identical reasoning compresses to identical output, so each unique
- *  block is sent to the model exactly once, ever. */
-export function hashText(text) {
-    return createHash('sha256').update(text).digest('hex');
-}
-/** Disk-backed `hash -> compressed text` store. The on-disk file lets the
- *  "compress once" guarantee survive process restarts, not just jiti reloads. */
-export class CompressionCache {
-    file;
-    mem = new Map();
-    loaded = false;
-    constructor(file) {
-        this.file = file;
-    }
-    load() {
-        if (this.loaded)
-            return;
-        this.loaded = true;
-        try {
-            const obj = JSON.parse(fs.readFileSync(this.file, 'utf8'));
-            for (const [k, v] of Object.entries(obj))
-                this.mem.set(k, v);
-        }
-        catch {
-            // No cache file yet (or unreadable) — start empty.
-        }
-    }
-    get(hash) {
-        this.load();
-        return this.mem.get(hash);
-    }
-    has(hash) {
-        this.load();
-        return this.mem.has(hash);
-    }
-    set(hash, compressed) {
-        this.load();
-        this.mem.set(hash, compressed);
-        try {
-            fs.mkdirSync(path.dirname(this.file), { recursive: true });
-            fs.writeFileSync(this.file, JSON.stringify(Object.fromEntries(this.mem)));
-        }
-        catch {
-            // Best-effort persistence; the in-memory copy still serves this run.
-        }
-    }
-    get size() {
-        this.load();
-        return this.mem.size;
-    }
-}

package/dist/context/compress.d.ts

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

package/dist/context/compress.js

@@ -1,153 +0,0 @@
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { CompressionCache } from './cache.js';
-import { applyRewrites, selectCandidates } from './rewrite.js';
-/** Keep the most-recent messages verbatim — recent reasoning is most likely to
- *  be relied on next turn, and compressing it would chase a moving target. */
-const KEEP_LAST = 8;
-/** Only compress sizeable blocks. Validation against the real session corpus
- *  (median thinking block 127 chars) showed small blocks barely shrink yet still
- *  cost ~5-15s on the local model — net-negative. Big blocks compress ~5x. */
-const MIN_CHARS = 1500;
-/** Hard cap so a stuck request can never wedge the background queue. */
-const REQUEST_TIMEOUT_MS = 120_000;
-/** Poll interval while the agent is busy — see the GPU note in `drain`. */
-const IDLE_BACKOFF_MS = 750;
-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';
-const OPTS = { keepLast: KEEP_LAST, minChars: MIN_CHARS };
-const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
-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();
-}
-/** Owns the compression cache and a serial background queue. Persisted on
- *  globalThis so it survives the jiti module re-evaluation that happens on every
- *  `/new` (mirrors the pattern in remote/register.ts). */
-class ThinkingCompressor {
-    cache;
-    pending = [];
-    inflight = new Set();
-    draining = false;
-    model = null;
-    isIdle = () => true;
-    resolveAuth = () => Promise.resolve({});
-    auth = null;
-    authModelId = null;
-    constructor(cacheFile) {
-        this.cache = new CompressionCache(cacheFile);
-    }
-    /** Refresh per-call context (model, idleness, auth resolver) from the latest
-     *  `context` event. Cheap and synchronous — no blocking work on this path. */
-    bind(model, isIdle, resolveAuth) {
-        this.model = model;
-        this.isIdle = isIdle;
-        this.resolveAuth = resolveAuth;
-        if (this.authModelId !== model.id) {
-            // Model changed — invalidate cached auth so it is re-resolved lazily.
-            this.auth = null;
-            this.authModelId = model.id;
-        }
-    }
-    enqueue(hash, text) {
-        if (this.cache.has(hash) || this.inflight.has(hash))
-            return;
-        if (this.pending.some(p => p.hash === hash))
-            return;
-        this.pending.push({ hash, text });
-        void this.drain();
-    }
-    async getAuth() {
-        if (this.auth)
-            return this.auth;
-        try {
-            this.auth = await this.resolveAuth();
-        }
-        catch {
-            this.auth = {};
-        }
-        return this.auth;
-    }
-    async drain() {
-        if (this.draining)
-            return;
-        this.draining = true;
-        try {
-            while (this.pending.length > 0) {
-                const model = this.model;
-                if (!model)
-                    break;
-                // The local model is a single-GPU llama.cpp server: a compression
-                // request fired mid-turn would queue behind (and stall) the user's
-                // turn. So compression only runs while the agent is idle.
-                if (!this.isIdle()) {
-                    await delay(IDLE_BACKOFF_MS);
-                    continue;
-                }
-                const job = this.pending.shift();
-                if (this.cache.has(job.hash))
-                    continue;
-                this.inflight.add(job.hash);
-                try {
-                    const compressed = await compressOne(job.text, model, await this.getAuth());
-                    // Only cache a genuine shrink; otherwise leave the block verbatim
-                    // (a later turn will re-enqueue and retry).
-                    if (compressed.length > 0 && compressed.length < job.text.length) {
-                        this.cache.set(job.hash, compressed);
-                    }
-                }
-                catch {
-                    // Transient (model busy/down) — drop the job; re-enqueued next turn.
-                }
-                finally {
-                    this.inflight.delete(job.hash);
-                }
-            }
-        }
-        finally {
-            this.draining = false;
-        }
-    }
-}
-export function registerContextCompression(pi) {
-    const cacheFile = path.join(os.homedir(), '.pi', 'agent', 'cache', 'pi-task', 'thinking-compression.json');
-    const g = globalThis;
-    const compressor = g.__piThinkingCompressor ?? new ThinkingCompressor(cacheFile);
-    g.__piThinkingCompressor = compressor;
-    pi.on('context', (event, ctx) => {
-        const model = ctx.model;
-        if (!model)
-            return;
-        compressor.bind({ id: model.id, baseUrl: model.baseUrl }, () => ctx.isIdle(), async () => {
-            // 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 } : {};
-        });
-        // Background: ensure every eligible block is queued for one-time compression.
-        for (const c of selectCandidates(event.messages, OPTS)) {
-            compressor.enqueue(c.hash, c.text);
-        }
-        // Critical path: apply only what is already cached. Pure + synchronous.
-        const { messages, rewritten } = applyRewrites(event.messages, OPTS, h => compressor.cache.get(h));
-        if (rewritten === 0)
-            return;
-        return { messages };
-    });
-}

package/dist/context/rewrite.d.ts

@@ -1,39 +0,0 @@
-/** Minimal structural view of a thinking content block. We avoid importing the
- *  exact pi-ai `ThinkingContent` type so these helpers stay pure and trivially
- *  unit-testable with plain objects. */
-export interface ThinkingBlock {
-    type: 'thinking';
-    thinking: string;
-    thinkingSignature?: string;
-    redacted?: boolean;
-}
-/** Minimal structural view of an AgentMessage. `AgentMessage[]` is assignable
- *  to `Msg[]`, so the `context` handler passes pi's real messages straight in. */
-export interface Msg {
-    role?: string;
-    content?: unknown;
-}
-export interface Candidate {
-    hash: string;
-    text: string;
-}
-export interface SelectOptions {
-    /** Number of most-recent messages to leave completely untouched. */
-    keepLast: number;
-    /** Minimum trimmed thinking length worth compressing. */
-    minChars: number;
-}
-export declare function isThinkingBlock(b: unknown): b is ThinkingBlock;
-export declare function isRewritable(b: ThinkingBlock, minChars: number): boolean;
-/** Eligible thinking blocks older than the keep-last window. May contain
- *  duplicates (the same reasoning across turns) — callers dedupe by hash. */
-export declare function selectCandidates(messages: readonly Msg[], opts: SelectOptions): Candidate[];
-/** Return a copy of `messages` with cached compressions swapped into eligible
- *  thinking blocks. Unchanged messages keep their identity. `thinkingSignature`
- *  and block `type` are preserved so the local provider still replays the (now
- *  shorter) reasoning. A compression is only applied when it actually shrinks
- *  the block, so this can never expand context. */
-export declare function applyRewrites<T extends Msg>(messages: readonly T[], opts: SelectOptions, lookup: (hash: string) => string | undefined): {
-    messages: T[];
-    rewritten: number;
-};

package/dist/context/rewrite.js

@@ -1,63 +0,0 @@
-import { hashText } from './cache.js';
-/** In `openai-completions` (llama.cpp/local), the "signature" is a field *name*
- *  (`reasoning_content`) the prior reasoning is replayed under — not a crypto
- *  signature — so rewriting the text is safe. A long, non-sentinel signature
- *  means Anthropic-style extended thinking, where the signature cryptographically
- *  signs the original text; rewriting it would be rejected, so we skip those. */
-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 isRewritable(b, minChars) {
-    if (b.redacted)
-        return false;
-    if (!SENTINEL_SIGNATURES.has(b.thinkingSignature ?? ''))
-        return false;
-    return b.thinking.trim().length >= minChars;
-}
-/** Eligible thinking blocks older than the keep-last window. May contain
- *  duplicates (the same reasoning across turns) — callers dedupe by hash. */
-export function selectCandidates(messages, opts) {
-    const cutoff = messages.length - opts.keepLast;
-    const out = [];
-    for (let i = 0; i < cutoff; i++) {
-        const m = messages[i];
-        if (m.role !== 'assistant' || !Array.isArray(m.content))
-            continue;
-        for (const b of m.content) {
-            if (isThinkingBlock(b) && isRewritable(b, opts.minChars)) {
-                out.push({ hash: hashText(b.thinking), text: b.thinking });
-            }
-        }
-    }
-    return out;
-}
-/** Return a copy of `messages` with cached compressions swapped into eligible
- *  thinking blocks. Unchanged messages keep their identity. `thinkingSignature`
- *  and block `type` are preserved so the local provider still replays the (now
- *  shorter) reasoning. A compression is only applied when it actually shrinks
- *  the block, so this can never expand context. */
-export function applyRewrites(messages, opts, lookup) {
-    const cutoff = messages.length - opts.keepLast;
-    let rewritten = 0;
-    const out = messages.map((m, i) => {
-        if (i >= cutoff || m.role !== 'assistant' || !Array.isArray(m.content))
-            return m;
-        let changed = false;
-        const content = m.content.map(b => {
-            if (!isThinkingBlock(b) || !isRewritable(b, opts.minChars))
-                return b;
-            const compressed = lookup(hashText(b.thinking));
-            if (compressed === undefined || compressed.length >= b.thinking.length)
-                return b;
-            changed = true;
-            rewritten++;
-            return { ...b, thinking: compressed };
-        });
-        return changed ? { ...m, content } : m;
-    });
-    return { messages: out, rewritten };
-}