@alexlikevibe/pi-jev 0.2.0

package/dist/commands/extension.js

@@ -0,0 +1,58 @@
+import { completeJevArguments, setModelOptions } from './completions.js';
+import { modelsFromContext } from './models.js';
+import { runCli } from '../cli/main.js';
+import { defaultConfigPaths } from '../shared/config.js';
+/**
+ * Core of the `/jev` command: same engine as the `pi-jev` CLI. Split out so
+ * tests can drive it against temp config files.
+ */
+export function runJevCommand(rawArgs, io) {
+    const argv = rawArgs.trim().split(/\s+/).filter(Boolean);
+    if (argv[0] === 'config')
+        argv.shift(); // tolerate `/jev config ...`
+    return runCli(argv.length > 0 ? ['config', ...argv] : ['config'], io);
+}
+/**
+ * The command extension: `/jev` configures the suite from inside pi.
+ * Config is re-read by every hook, so changes apply without a restart.
+ *
+ *   /jev                      show resolved values + each value's source
+ *   /jev set <key> <value>    write a key (`-l` targets the project file)
+ *   /jev get <key>            /jev unset <key>   /jev keys   /jev path
+ */
+export default function (pi) {
+    pi.on('session_start', (_event, ctx) => {
+        setModelOptions(modelsFromContext(ctx));
+    });
+    pi.registerCommand('jev', {
+        description: 'Configure pi-jev: /jev [set|get|unset|keys|path] ...',
+        getArgumentCompletions: (prefix) => completeJevArguments(prefix),
+        handler: async (args, ctx) => {
+            const paths = defaultConfigPaths();
+            if (!(args ?? '').trim()) {
+                // Bare /jev opens the interactive settings menu (TUI mode only).
+                const { openJevSettingsMenu } = await import('./menu.js');
+                await openJevSettingsMenu(ctx, paths, {
+                    out: (text) => {
+                        ctx.ui.notify(text, 'info');
+                    },
+                });
+                return;
+            }
+            const lines = [];
+            const errs = [];
+            const code = runJevCommand(args ?? '', {
+                env: process.env,
+                ...defaultConfigPaths(),
+                out: (text) => {
+                    lines.push(text);
+                },
+                err: (text) => {
+                    errs.push(text);
+                },
+            });
+            const text = [...lines, ...errs].join('\n').trim();
+            ctx.ui.notify(text || '(no output)', code === 0 ? 'info' : 'error');
+        },
+    });
+}

package/dist/commands/menu.js

@@ -0,0 +1,245 @@
+import { defineMenu, runMenu } from '@narumitw/pi-tui-kit';
+import { CONFIG_KEYS, configFromEnv, mergeConfigFiles, readConfigFile, } from '../shared/config.js';
+import { coerce, keyMeta, readOrInit, saveFile, setPath, valueAt } from '../cli/main.js';
+import { VALUE_OPTIONS } from './completions.js';
+import { THINKING_LEVELS } from './models.js';
+function readFileTolerant(path) {
+    try {
+        return readConfigFile(path);
+    }
+    catch {
+        return undefined;
+    }
+}
+function merged(paths) {
+    return mergeConfigFiles(readFileTolerant(paths.globalPath), readFileTolerant(paths.projectPath));
+}
+/** Effective value of a key, tagged with where it comes from. */
+function displayValue(meta, paths) {
+    const config = configFromEnv(process.env, merged(paths));
+    const raw = valueAt(config, meta.path);
+    if (raw === undefined)
+        return 'unset';
+    const fromEnv = meta.env ? (process.env[meta.env] ?? '').trim() : '';
+    return `${String(raw)}${fromEnv ? ' [env]' : ''}`;
+}
+function groupKeys(prefix) {
+    return CONFIG_KEYS.filter((meta) => prefix === '' ? !meta.path.includes('.') : meta.path.startsWith(`${prefix}.`));
+}
+function groupScreen(screenId, title, paths) {
+    const prefix = screenId === 'general' ? '' : screenId;
+    const action = 'editKey';
+    return {
+        kind: 'settings',
+        title,
+        items: groupKeys(prefix).map((meta) => ({
+            id: meta.path,
+            label: meta.path,
+            description: meta.description,
+            currentValue: displayValue(meta, paths),
+            action,
+        })),
+    };
+}
+function writeKey(paths, scope, keyPath, value) {
+    const meta = keyMeta(keyPath);
+    if (!meta)
+        throw new Error(`unknown key "${keyPath}"`);
+    const targetPath = scope === 'project' ? paths.projectPath : paths.globalPath;
+    const file = readOrInit(targetPath);
+    setPath(file, meta.path, coerce(meta, value));
+    saveFile(targetPath, file);
+}
+/**
+ * Builds the interactive `/jev` settings menu on top of `@narumitw/pi-tui-kit`.
+ * `state` is mutated by actions (scope toggle, key being edited).
+ */
+export function buildJevMenu(paths, state, io, models = []) {
+    return defineMenu({
+        start: 'main',
+        screens: {
+            main: () => {
+                const config = configFromEnv(process.env, merged(paths));
+                const scopePath = state.scope === 'project' ? paths.projectPath : paths.globalPath;
+                return {
+                    kind: 'actions',
+                    title: 'pi-jev',
+                    lines: [`Scope: ${state.scope} (${scopePath}) — 'toggle scope' switches it`],
+                    items: [
+                        {
+                            id: 'toggleScope',
+                            label: `Toggle scope (currently ${state.scope})`,
+                            action: 'toggleScope',
+                        },
+                        {
+                            id: 'general',
+                            label: `General (provider ${config.provider})`,
+                            to: 'general',
+                        },
+                        {
+                            id: 'compaction',
+                            label: 'Compaction',
+                            to: 'compaction',
+                        },
+                        {
+                            id: 'routing',
+                            label: `Routing (${config.routing.cheap || config.routing.strong ? 'enabled' : 'disabled'})`,
+                            to: 'routing',
+                        },
+                        { id: 'showResolved', label: 'Show resolved config', action: 'showResolved' },
+                    ],
+                    hint: 'close',
+                };
+            },
+            general: () => groupScreen('general', 'pi-jev — General', paths),
+            compaction: () => groupScreen('compaction', 'pi-jev — Compaction', paths),
+            routing: () => groupScreen('routing', 'pi-jev — Routing', paths),
+            chooseModel: () => {
+                const current = displayValue(keyMeta(state.editingKey), paths);
+                const items = [
+                    ...(current !== 'unset' ? [{ id: '__unset__', label: '(unset)', description: 'clear this key' }] : []),
+                    ...models.map((model) => ({
+                        id: model.ref,
+                        label: model.name,
+                        description: `${model.provider}${model.image ? ' · images' : ''}${model.reasoning ? ' · thinking' : ''}${model.contextWindow ? ` · ${Math.round(model.contextWindow / 1000)}k ctx` : ''}`,
+                    })),
+                ];
+                return {
+                    kind: 'choice',
+                    title: `pi-jev — ${state.editingKey}`,
+                    lines: models.length === 0 ? ['No models found in pi (check provider auth).'] : [],
+                    items,
+                    action: 'pickModel',
+                    enableSearch: true,
+                    hint: 'back',
+                };
+            },
+            chooseThinking: () => {
+                const model = models.find((entry) => entry.modelRef === state.selectedModelRef);
+                return {
+                    kind: 'choice',
+                    title: `pi-jev — thinking level`,
+                    lines: [`${state.selectedModelRef ?? ''} (thinking optional — default keeps the model's own)`],
+                    items: [
+                        { id: '__default__', label: 'default', description: "no override (model default)" },
+                        ...(model?.reasoning !== false && model ? THINKING_LEVELS.map((level) => ({ id: level, label: level })) : []),
+                    ],
+                    action: 'pickThinking',
+                    initialItemId: '__default__',
+                    hint: 'back',
+                };
+            },
+            chooseValue: () => {
+                const options = VALUE_OPTIONS[state.editingKey] ?? [];
+                return {
+                    kind: 'choice',
+                    title: `pi-jev — ${state.editingKey}`,
+                    items: options.map((option) => ({
+                        id: option.label,
+                        label: option.label,
+                        description: option.description,
+                    })),
+                    action: 'setEnum',
+                    hint: 'back',
+                };
+            },
+            inputValue: () => {
+                const meta = keyMeta(state.editingKey);
+                return {
+                    kind: 'input',
+                    title: `pi-jev — set ${state.editingKey}`,
+                    lines: meta ? [meta.description] : [],
+                    placeholder: '(new value)',
+                    action: 'setValue',
+                    hint: 'back',
+                };
+            },
+        },
+        actions: {
+            toggleScope: () => {
+                state.scope = state.scope === 'global' ? 'project' : 'global';
+                return { kind: 'stay' };
+            },
+            editKey: ({ itemId }) => {
+                if (!keyMeta(itemId))
+                    return { kind: 'rejected', error: new Error(`unknown key "${itemId}"`) };
+                state.editingKey = itemId;
+                if (itemId === 'routing.cheap' || itemId === 'routing.strong')
+                    return { kind: 'to', screen: 'chooseModel' };
+                return VALUE_OPTIONS[itemId] ? { kind: 'to', screen: 'chooseValue' } : { kind: 'to', screen: 'inputValue' };
+            },
+            setEnum: ({ itemId }) => {
+                writeKey(paths, state.scope, state.editingKey, itemId);
+                return { kind: 'back' };
+            },
+            pickModel: ({ itemId }) => {
+                if (itemId === '__unset__') {
+                    const targetPath = state.scope === 'project' ? paths.projectPath : paths.globalPath;
+                    const file = readOrInit(targetPath);
+                    const [section, key] = state.editingKey.split('.');
+                    delete (file[section] ??= {})[key];
+                    if (Object.keys(file[section]).length === 0) {
+                        delete file[section];
+                    }
+                    saveFile(targetPath, file);
+                    return { kind: 'back' };
+                }
+                const model = models.find((entry) => entry.ref === itemId);
+                state.selectedModelRef = itemId;
+                state.selectedModelReasoning = model?.reasoning ?? false;
+                if (state.selectedModelReasoning)
+                    return { kind: 'to', screen: 'chooseThinking' };
+                writeKey(paths, state.scope, state.editingKey, itemId);
+                return { kind: 'back' };
+            },
+            pickThinking: ({ itemId }) => {
+                const ref = itemId === '__default__' ? state.selectedModelRef : `${state.selectedModelRef}:${itemId}`;
+                writeKey(paths, state.scope, state.editingKey, ref ?? '');
+                return { kind: 'back' };
+            },
+            setValue: ({ value }) => {
+                if (value === undefined || !value.trim())
+                    return { kind: 'rejected', error: new Error('empty value') };
+                try {
+                    writeKey(paths, state.scope, state.editingKey, value.trim());
+                }
+                catch (error) {
+                    return { kind: 'rejected', error };
+                }
+                return { kind: 'back' };
+            },
+            showResolved: () => {
+                const lines = [];
+                const global = readFileTolerant(paths.globalPath);
+                const project = readFileTolerant(paths.projectPath);
+                const config = configFromEnv(process.env, mergeConfigFiles(global, project));
+                for (const meta of CONFIG_KEYS) {
+                    lines.push(`${meta.path} = ${valueAt(config, meta.path) ?? 'unset'}`);
+                }
+                io.out(lines.join('\n'));
+                return { kind: 'close' };
+            },
+        },
+    });
+}
+/** Opens the interactive menu; falls back to text output outside TUI mode. */
+export async function openJevSettingsMenu(ctx, paths, io) {
+    if (ctx.mode !== 'tui' || !ctx.hasUI) {
+        io.out('/jev menu requires an interactive pi UI; use `/jev set <key> <value>` instead');
+        return;
+    }
+    const controller = new AbortController();
+    const state = { scope: 'global', editingKey: 'model' };
+    const { modelsFromContext } = await import('./models.js');
+    const menu = buildJevMenu(paths, state, io, modelsFromContext(ctx));
+    try {
+        await runMenu(ctx, menu, {
+            getState: () => state,
+            signal: controller.signal,
+            isCurrent: () => !controller.signal.aborted,
+        });
+    }
+    finally {
+        controller.abort();
+    }
+}

package/dist/commands/models.js

@@ -0,0 +1,23 @@
+/** pi thinking levels, lowest to highest. */
+export const THINKING_LEVELS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+function fromModel(model) {
+    const provider = String(model.provider);
+    const id = String(model.id);
+    return {
+        ref: `${provider}/${id}`,
+        modelRef: `${provider}/${id}`,
+        name: model.name ?? id,
+        provider,
+        reasoning: model.reasoning === true,
+        image: Array.isArray(model.input) ? model.input.includes('image') : false,
+        contextWindow: model.contextWindow ?? 0,
+    };
+}
+/** Models configured in pi: scoped models when set, otherwise the full available catalogue. */
+export function modelsFromContext(ctx) {
+    const scoped = ctx.scopedModels ?? [];
+    const raw = scoped.length > 0 ? scoped.map((entry) => entry.model) : (ctx.modelRegistry?.getAvailable?.() ?? []);
+    return raw
+        .map((model) => fromModel(model))
+        .sort((a, b) => (a.provider === b.provider ? a.name.localeCompare(b.name) : a.provider.localeCompare(b.provider)));
+}

package/dist/compaction/convert.js

@@ -0,0 +1,87 @@
+/** Extracts text from a string-or-content-blocks payload; images become a note. */
+function textOf(content) {
+    if (typeof content === 'string')
+        return content;
+    return content
+        .map(block => (block.type === 'text' && typeof block.text === 'string' ? block.text : '[image]'))
+        .join('\n');
+}
+/**
+ * Converts the span pi wants to summarize (any `AgentMessage`) into the
+ * Claude-Code-shaped `Message[]` fast-jev-compaction works with:
+ *
+ * - `toolResult` messages merge into synthetic user messages (consecutive
+ *   ones share one message), keeping their call order;
+ * - `bashExecution` messages become an assistant tool call (`bash`) paired
+ *   with a user tool result, so Jev can drop their outputs like any other;
+ * - assistant thinking is dropped (transient, never needed verbatim later);
+ * - `compactionSummary` / `branchSummary` are skipped: the hook receives the
+ *   previous summary separately (`previousSummary`);
+ * - images cannot be represented and render as `[image]`.
+ */
+export function convertMessages(messages) {
+    const out = [];
+    let pendingResults = [];
+    const flushResults = () => {
+        if (pendingResults.length > 0) {
+            out.push({ role: 'user', text: '', toolUses: [], toolResults: pendingResults });
+            pendingResults = [];
+        }
+    };
+    for (const message of messages) {
+        switch (message.role) {
+            case 'user': {
+                flushResults();
+                out.push({ role: 'user', text: textOf(message.content), toolUses: [], toolResults: [] });
+                break;
+            }
+            case 'assistant': {
+                flushResults();
+                const text = message.content
+                    .filter((block) => block.type === 'text')
+                    .map(block => block.text)
+                    .join('\n');
+                const toolUses = message.content
+                    .filter((block) => block.type === 'toolCall')
+                    .map(block => ({ tool_use_id: block.id, tool: block.name, input: block.arguments }));
+                out.push({ role: 'assistant', text, toolUses });
+                break;
+            }
+            case 'toolResult': {
+                pendingResults.push({
+                    tool_use_id: message.toolCallId,
+                    text: textOf(message.content),
+                    isError: message.isError,
+                });
+                break;
+            }
+            case 'bashExecution': {
+                flushResults();
+                if (message.excludeFromContext)
+                    break;
+                const id = `bashexec_${message.timestamp}`;
+                out.push({
+                    role: 'assistant',
+                    text: '',
+                    toolUses: [{ tool_use_id: id, tool: 'bash', input: { command: message.command } }],
+                });
+                pendingResults.push({
+                    tool_use_id: id,
+                    text: message.output,
+                    isError: message.cancelled || (message.exitCode !== undefined && message.exitCode !== 0),
+                });
+                break;
+            }
+            case 'custom': {
+                flushResults();
+                out.push({ role: 'user', text: textOf(message.content), toolUses: [], toolResults: [] });
+                break;
+            }
+            default:
+                // compactionSummary / branchSummary arrive via previousSummary instead
+                break;
+        }
+    }
+    flushResults();
+    return out;
+}

package/dist/compaction/decision.js

@@ -0,0 +1,195 @@
+import { estimateTokens, } from '../vendor/fast-jev-compaction/index.js';
+/** Ordered staleness levels for the per-result `score` question. */
+const STALENESS_LEVELS = ['needed', 'probably needed', 'uncertain', 'stale', 'very stale'];
+/** Tokens the request envelope (`model`, key names) adds around state and questions. */
+const REQUEST_OVERHEAD_TOKENS = 20;
+/**
+ * The three questions asked about one tool call: two `noul` questions (keep
+ * the call, keep its result verbatim) and one `score` question whose
+ * confident answer can rescue a borderline result.
+ */
+export function questionsFor(call) {
+    return {
+        [`call_${call.id}`]: {
+            type: 'noul',
+            instructions: `Tool call ${call.id} (${call.tool}) should stay in the history: knowing this call was made, with its input, still matters for what the assistant does next`,
+        },
+        [`result_${call.id}`]: {
+            type: 'noul',
+            instructions: `The full output of tool call ${call.id} (${call.tool}, ${call.resultChars} chars) should stay in the history verbatim: the assistant still needs its contents and re-running the tool would not do`,
+        },
+        [`staleness_${call.id}`]: {
+            type: 'score',
+            instructions: `Rate how stale the output of tool call ${call.id} (${call.tool}) is for the ongoing work: level 0 means its contents are still needed verbatim, level ${STALENESS_LEVELS.length - 1} means clearly obsolete`,
+            criteria: [...STALENESS_LEVELS],
+        },
+    };
+}
+/**
+ * Splits candidate calls into batches whose questions, together with the
+ * (always complete) state, fit one Jev request.
+ */
+export function batchCalls(calls, stateTokens, maxRequestTokens) {
+    const budget = maxRequestTokens - stateTokens - REQUEST_OVERHEAD_TOKENS;
+    const batches = [];
+    let current = [];
+    let currentTokens = 0;
+    for (const call of calls) {
+        const tokens = estimateTokens(JSON.stringify(questionsFor(call)));
+        if (current.length > 0 && currentTokens + tokens > budget) {
+            batches.push(current);
+            current = [];
+            currentTokens = 0;
+        }
+        if (current.length === 0 && tokens > budget) {
+            throw new Error(`state leaves no room for questions (~${stateTokens} of ${maxRequestTokens} tokens)`);
+        }
+        current.push(call);
+        currentTokens += tokens;
+    }
+    if (current.length > 0)
+        batches.push(current);
+    return batches;
+}
+function noulOr(answers, name) {
+    const answer = answers[name];
+    if (answer === null ||
+        typeof answer !== 'object' ||
+        !('noul' in answer) ||
+        typeof answer.noul !== 'number' ||
+        !Number.isFinite(answer.noul)) {
+        return undefined;
+    }
+    return answer.noul;
+}
+function scoreAnswer(answers, name) {
+    const answer = answers[name];
+    if (answer === null ||
+        typeof answer !== 'object' ||
+        !('score' in answer) ||
+        typeof answer.score !== 'number' ||
+        !Number.isFinite(answer.score)) {
+        return undefined;
+    }
+    const confidence = 'confidence' in answer && typeof answer.confidence === 'number'
+        ? answer.confidence
+        : 0;
+    return { score: answer.score, confidence };
+}
+/** Jev scores arrive either in [0, 1] or spread across the criteria levels. */
+function normalizedStaleness(score) {
+    return score <= 1 ? score : score / (STALENESS_LEVELS.length - 1);
+}
+/**
+ * Decides one call from Jev's answers: keep, truncate the result, or drop the
+ * call. A result whose keep probability falls just under the threshold is
+ * rescued when the staleness score is confidently low. Missing or malformed
+ * answers keep the call (conservative).
+ */
+export function decideCall(call, answers, options) {
+    if (call.pinned) {
+        return {
+            id: call.id,
+            tool: call.tool,
+            keepCall: 1,
+            keepResult: 1,
+            action: 'keep',
+            reason: 'pinned',
+            pinned: true,
+            guarded: false,
+            missing: false,
+        };
+    }
+    const keepCall = noulOr(answers, `call_${call.id}`);
+    const keepResult = noulOr(answers, `result_${call.id}`);
+    if (keepCall === undefined || keepResult === undefined) {
+        return {
+            id: call.id,
+            tool: call.tool,
+            keepCall: keepCall ?? 1,
+            keepResult: keepResult ?? 1,
+            action: 'keep',
+            reason: 'kept',
+            pinned: false,
+            guarded: false,
+            missing: true,
+        };
+    }
+    const base = { id: call.id, tool: call.tool, keepCall, keepResult, pinned: false, missing: false };
+    if (keepResult >= options.keepThreshold) {
+        return { ...base, action: 'keep', reason: 'kept', guarded: false };
+    }
+    const staleness = scoreAnswer(answers, `staleness_${call.id}`);
+    if (keepResult >= options.keepThreshold - options.borderline &&
+        staleness !== undefined &&
+        normalizedStaleness(staleness.score) <= 0.25 &&
+        staleness.confidence >= 0.5) {
+        return { ...base, action: 'keep', reason: 'kept', guarded: true };
+    }
+    if (keepCall >= options.keepThreshold) {
+        return { ...base, action: 'drop_result', reason: 'result_dropped', guarded: false };
+    }
+    return { ...base, action: 'drop_call', reason: 'call_dropped', guarded: false };
+}
+function truncatedResultText(text, isError, headChars) {
+    if (text.length <= headChars + 120)
+        return text;
+    const head = headChars > 0 ? `${text.slice(0, headChars)}\n` : '';
+    return `${head}[jev-compaction truncated ${text.length - headChars} chars of this tool result${isError ? ' (error)' : ''}; re-run the tool if needed]`;
+}
+/**
+ * Rebuilds the conversation from the decisions. A dropped call disappears
+ * together with its result; a dropped result keeps a bounded head and a note.
+ * Messages that lose all their content are removed; untouched messages are
+ * returned as the same objects they came in as.
+ */
+export function applyJevDecisions(messages, decisions, calls, headChars) {
+    const byId = new Map(calls.map(call => [call.id, call]));
+    const actionFor = new Map();
+    for (const decision of decisions) {
+        const call = byId.get(decision.id);
+        if (call && decision.action !== 'keep')
+            actionFor.set(call.tool_use_id, decision.action);
+    }
+    const kept = [];
+    for (const message of messages) {
+        const touched = message.toolUses.some(tool => actionFor.has(tool.tool_use_id)) ||
+            (message.toolResults ?? []).some(result => actionFor.has(result.tool_use_id));
+        if (!touched) {
+            kept.push(message);
+            continue;
+        }
+        const toolUses = message.toolUses
+            .filter(tool => actionFor.get(tool.tool_use_id) !== 'drop_call')
+            .map(tool => {
+            if (actionFor.get(tool.tool_use_id) !== 'drop_result' || tool.text === undefined)
+                return tool;
+            const text = truncatedResultText(tool.text, tool.isError ?? false, headChars);
+            return text === tool.text ? tool : { ...tool, text };
+        });
+        const toolResults = (message.toolResults ?? [])
+            .filter(result => actionFor.get(result.tool_use_id) !== 'drop_call')
+            .map(result => {
+            if (actionFor.get(result.tool_use_id) !== 'drop_result')
+                return result;
+            const text = truncatedResultText(result.text, result.isError ?? false, headChars);
+            return text === result.text ? result : { ...result, text };
+        });
+        const unchanged = toolUses.length === message.toolUses.length &&
+            toolUses.every((tool, index) => tool === message.toolUses[index]) &&
+            toolResults.length === (message.toolResults ?? []).length &&
+            toolResults.every((result, index) => result === message.toolResults?.[index]);
+        if (unchanged) {
+            kept.push(message);
+            continue;
+        }
+        if (message.text.trim().length === 0 && toolUses.length === 0 && toolResults.length === 0) {
+            continue;
+        }
+        const rebuilt = { role: message.role, text: message.text, toolUses };
+        if (toolResults.length > 0)
+            rebuilt.toolResults = toolResults;
+        kept.push(rebuilt);
+    }
+    return kept;
+}