@tianmucreations/jeeves 0.2.1 → 0.3.0

package/dist/agent/expert-chat.js

@@ -0,0 +1,33 @@
+import { generateText } from 'ai';
+import { session } from '../state/session.js';
+import { getOpenRouterKey, serviceKey } from '../providers/index.js';
+import { openrouterChat } from '../tools/web/openrouterChat.js';
+import { isDirectService } from '../providers/direct-services.js';
+import { modelFactory } from '../providers/direct.js';
+import { estimateCost, priceOf } from '../providers/catalogue.js';
+import { reportSpend } from './spending.js';
+export const expertChat = async (model, messages, maxTokens) => {
+    const providerId = session.providerId;
+    if (providerId === 'openrouter') {
+        const key = getOpenRouterKey();
+        if (!key)
+            throw new Error('the expert needs an OpenRouter key');
+        return (await openrouterChat(key, { model, messages, max_tokens: maxTokens })).text;
+    }
+    if (isDirectService(providerId)) {
+        const key = serviceKey(providerId);
+        if (!key)
+            throw new Error('the expert needs a key for this service');
+        const result = await generateText({
+            model: modelFactory(providerId, key)(model),
+            instructions: messages.filter((m) => m.role === 'system').map((m) => m.content).join('\n\n') || undefined,
+            messages: messages.filter((m) => m.role === 'user').map((m) => ({ role: 'user', content: m.content })),
+            // Thinking models spend part of the allowance before answering, so it is larger here.
+            maxOutputTokens: maxTokens * 4,
+            abortSignal: AbortSignal.timeout(120_000),
+        });
+        reportSpend(estimateCost(priceOf(providerId, model), result.usage), true);
+        return result.text.trim();
+    }
+    throw new Error('no expert is available for this service');
+};

package/dist/agent/housekeeping.js

@@ -0,0 +1,55 @@
+// Quiet housekeeping that keeps the conversation small, because every message
+// re-sends the whole conversation. Modelled on Anthropic's published context
+// editing (platform.claude.com/docs/en/build-with-claude/context-editing): old
+// tool results are cleared first - they are the bulk, and a file can simply be
+// read again - keeping the most recent 3, and only when enough is freed to be
+// worth losing the prompt-cache discount for one message. The trigger and minimum
+// are the figures from Anthropic's own worked example (30,000 and 5,000 tokens);
+// their default trigger is 100,000, which is where summarising starts.
+export const CLEAR_TRIGGER_TOKENS = 30_000;
+export const CLEAR_AT_LEAST_TOKENS = 5_000;
+export const KEEP_RECENT_TOOL_RESULTS = 3;
+export const SUMMARY_TRIGGER_TOKENS = 100_000;
+export const CLEARED_PLACEHOLDER = '[Earlier output removed to keep the conversation small. Run the tool again if it is needed.]';
+// The same rough measure used elsewhere in the app: about 4 characters per token.
+export function estimateTokens(value) {
+    return Math.ceil(JSON.stringify(value).length / 4);
+}
+export function clearOldToolResults(messages) {
+    if (estimateTokens(messages) < CLEAR_TRIGGER_TOKENS)
+        return { messages, freedTokens: 0 };
+    const positions = [];
+    messages.forEach((message, messageIndex) => {
+        if (message.role !== 'tool' || !Array.isArray(message.content))
+            return;
+        message.content.forEach((part, partIndex) => {
+            if (part.type === 'tool-result')
+                positions.push({ message: messageIndex, part: partIndex });
+        });
+    });
+    const older = positions.slice(0, Math.max(0, positions.length - KEEP_RECENT_TOOL_RESULTS));
+    let freed = 0;
+    const copy = messages.map((message) => message.role === 'tool' && Array.isArray(message.content) ? { ...message, content: [...message.content] } : message);
+    for (const { message, part } of older) {
+        const content = copy[message].content;
+        const result = content[part];
+        if (result.output?.type === 'text' && result.output.value === CLEARED_PLACEHOLDER)
+            continue;
+        const before = estimateTokens(result.output);
+        const replacement = { type: 'text', value: CLEARED_PLACEHOLDER };
+        freed += before - estimateTokens(replacement);
+        content[part] = { ...result, output: replacement };
+    }
+    if (freed < CLEAR_AT_LEAST_TOKENS)
+        return { messages, freedTokens: 0 };
+    return { messages: copy, freedTokens: freed };
+}
+// Anthropic's structured summary (the five parts of their compaction prompt), so a
+// summary keeps what matters for carrying on with the job.
+export const SUMMARY_INSTRUCTIONS = `Summarise the conversation so far so the work can continue from the summary alone. Use exactly these headings:
+1. Task overview - what the person asked for and what counts as done.
+2. Current state - what has been completed, which files were changed or created.
+3. Important discoveries - facts checked, decisions made, errors met and how they were resolved, approaches that failed.
+4. Next steps - what remains, in order, and anything blocking it.
+5. Context to preserve - the person's preferences, how they like to be addressed, promises made.
+Be specific: keep exact file names, figures, and quoted facts. Reply with only the summary.`;

package/dist/agent/loop.js

@@ -1,12 +1,29 @@
 import { session } from '../state/session.js';
 import { getActiveProvider, refreshCredit } from '../providers/index.js';
 import { getTools } from '../tools/index.js';
-import { buildTurnMessages } from './context.js';
+import { buildTurnMessages, getSystemPrompt, contextLimitFor, summaryDue, summariseHistory } from './context.js';
 import { plainError } from './errors.js';
 import { toggleVerbose } from '../commands/verbose.js';
 import { openModelPicker } from '../commands/model.js';
 import { clearConversation } from '../commands/clear.js';
+import { openAddressPrompt } from '../commands/address.js';
 import { isToolCapable } from '../models/filter.js';
+import { autoCatalogue } from './auto.js';
+import { isAuto, workingModelId, workerModel, expertModel, topModel, AUTO_NOTE, shouldTakeOver, createAskExpertTool, newAutoTurnState, topModelPriceRatio, topModelQuestion, REVIEW_FINISHED_JOBS } from './auto.js';
+import { jobNeedsReview, reviewJob, fixRequest, startReproducing, stopReproducing, UNCHECKED_NOTICE } from './review.js';
+import { requestApproval } from './permissions.js';
+import { clearOldToolResults } from './housekeeping.js';
+import { startJob, endJob, reportStepCost, withinLimits } from './spending.js';
+import { getAddress } from '../platform/config.js';
+import { startTurnCheckpoints, undoLastChange } from '../checkpoints/index.js';
+import { noteSkipRequest } from './research-gate.js';
+// Added to the rulebook when the chosen model cannot use tools, so a task request
+// gets a plain answer instead of a pretend attempt.
+export const CHAT_ONLY_NOTE = `
+
+Chat-Only Model
+
+The model currently selected can only chat. For now you have no tools: you cannot read files, write files, list folders, or run commands, whatever the sections above say. If you are asked to do something that needs them, say plainly that the model in use can only chat, and suggest typing /model to choose one that can do tasks. Never pretend to have done it.`;
 const DISCONNECTING = new Set(['auth', 'network', 'payment']);
 export async function runTurn(input) {
     if (input.startsWith('/') && input.length > 1 && !input.startsWith('/ ')) {
@@ -22,6 +39,27 @@ export async function runTurn(input) {
         else if (input === '/verbose') {
             session.addNotice(toggleVerbose());
         }
+        else if (input === '/address') {
+            openAddressPrompt();
+        }
+        else if (input === '/undo') {
+            if (session.status === 'working') {
+                session.addNotice('Undo works between tasks - wait for this one to finish, then type /undo.');
+            }
+            else {
+                try {
+                    const outcome = await undoLastChange();
+                    session.addNotice(outcome.message);
+                    if (outcome.historyNote)
+                        session.pendingContextNote = outcome.historyNote;
+                }
+                catch (error) {
+                    session.addError("Undo didn't work this time - nothing was changed. Please try /undo again.");
+                    if (session.verbose)
+                        session.addNotice(`Technical details: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
         else if (input === '/clear') {
             clearConversation();
         }
@@ -29,24 +67,87 @@ export async function runTurn(input) {
             session.requestExit();
         }
         else {
-            session.addNotice('Unknown command. Try /help.');
+            session.addNotice("I don't know that command - type /help to see them all.");
         }
         return;
     }
     session.addUser(input);
+    // "Skip the research" must come from the person, so it is read from their own words.
+    const skipped = noteSkipRequest(input);
+    if (skipped)
+        session.addNotice(skipped);
+    startTurnCheckpoints(input);
+    startJob();
+    // Nothing is sent once today's limit is reached, unless the person agrees.
+    if (!(await withinLimits())) {
+        endJob();
+        session.addNotice('Stopped - nothing was sent.');
+        return;
+    }
+    // Quiet housekeeping: old tool output is cleared, and a long conversation summarised.
+    const cleared = clearOldToolResults(session.history);
+    if (cleared.freedTokens > 0)
+        session.setHistory(cleared.messages);
+    const modelId = workingModelId(session.model);
+    if (summaryDue(session.estimateContextTokens(), contextLimitFor(modelId, session.models))) {
+        await summariseHistory();
+    }
+    const auto = isAuto(session.model);
+    const autoState = newAutoTurnState();
+    session.setActiveModel(auto ? workerModel() : null);
+    const stop = new AbortController();
+    let countedSteps = 0;
     session.beginTurn();
     session.setStatus('working');
+    const turnStart = session.transcript.length;
     let assistantId = null;
     try {
         const provider = getActiveProvider();
-        const messages = buildTurnMessages(session.history, input);
+        // A note from /undo travels with the next message, so the model knows files changed back.
+        const note_ = session.pendingContextNote;
+        session.pendingContextNote = null;
+        const messages = buildTurnMessages(session.history, note_ ? `${note_}\n\n${input}` : input);
         // Models without tool support get a tool-free chat mode automatically (spec 4.2).
-        const currentModel = session.models.find((model) => model.id === session.model);
-        const tools = !currentModel || isToolCapable(currentModel) ? getTools() : {};
-        const result = await provider.stream({
-            modelId: session.model,
+        const currentModel = session.models.find((model) => model.id === modelId);
+        const toolCapable = !currentModel || isToolCapable(currentModel);
+        const tools = toolCapable ? { ...getTools(), ...(auto ? { askExpert: createAskExpertTool(autoState) } : {}) } : {};
+        const note = !toolCapable ? CHAT_ONLY_NOTE : auto ? AUTO_NOTE.replaceAll('{{ADDRESS}}', getAddress() ?? 'Sir') : '';
+        const streamOptions = {
+            modelId,
             messages,
             tools,
+            instructions: getSystemPrompt() + note,
+            abortSignal: stop.signal,
+            beforeStep: async ({ stepFailures, stepCosts, messages: stepMessages }) => {
+                for (const cost of stepCosts.slice(countedSteps))
+                    reportStepCost(cost);
+                countedSteps = stepCosts.length;
+                if (!(await withinLimits())) {
+                    stop.abort();
+                    return {};
+                }
+                // In Auto mode the expert takes over the rest of a job the worker keeps failing.
+                // If the expert keeps failing too, Jeeves asks before trying the strongest model.
+                let stepModel;
+                const expert = expertModel();
+                const strongest = topModel();
+                if (auto && expert && !autoState.expertTookOver && shouldTakeOver(stepFailures))
+                    autoState.expertTookOver = true;
+                // (The expert can also take over by saying so when consulted.)
+                if (autoState.expertTookOver && autoState.takeoverStep < 0)
+                    autoState.takeoverStep = stepFailures.length;
+                if (auto && strongest && autoState.expertTookOver && !autoState.askedAboutTop && shouldTakeOver(stepFailures.slice(autoState.takeoverStep))) {
+                    autoState.askedAboutTop = true;
+                    session.addNotice(topModelQuestion(getAddress() ?? 'Sir', topModelPriceRatio(autoCatalogue())));
+                    autoState.onTopModel = await requestApproval();
+                }
+                if (auto && autoState.expertTookOver && expert) {
+                    stepModel = autoState.onTopModel && strongest ? strongest : expert;
+                    session.setActiveModel(stepModel);
+                }
+                const tidied = clearOldToolResults(stepMessages);
+                return { modelId: stepModel, messages: tidied.freedTokens > 0 ? tidied.messages : undefined };
+            },
             onToken: (token) => {
                 if (assistantId === null)
                     assistantId = session.startAssistant();
@@ -57,28 +158,83 @@ export async function runTurn(input) {
                     session.appendReasoning(delta);
             },
             onToolCall: () => {
-                // Hide pre-tool chatter so only the final answer stays visible (spec 2.3).
-                if (assistantId !== null)
+                // Hide pre-tool chatter so only the final answer stays visible (spec 2.3). The
+                // entry is removed, not just emptied, so the final answer appears below the
+                // actions it reports on rather than above them.
+                if (assistantId !== null) {
                     session.setAssistantText(assistantId, '');
+                    session.finishAssistant(assistantId);
+                    assistantId = null;
+                }
                 session.closeReasoningEntry();
             },
-        });
+        };
+        let uncheckedNotice = false;
+        let result = await provider.stream(streamOptions);
+        let allMessages = [...messages, ...result.messages];
+        // Auto's double-check, once, when this job changed a program or wrote a document
+        // (where the cheap worker's mistakes were measured - see review.ts).
+        if (auto && REVIEW_FINISHED_JOBS && jobNeedsReview(session.transcript.slice(turnStart)) && !stop.signal.aborted) {
+            for (const cost of (result.stepCosts ?? []).slice(countedSteps))
+                reportStepCost(cost);
+            countedSteps = result.stepCosts?.length ?? countedSteps;
+            const review = await reviewJob(allMessages);
+            if (review.kind === 'unavailable') {
+                uncheckedNotice = true;
+            }
+            else if (review.kind === 'problems') {
+                countedSteps = 0;
+                if (assistantId !== null)
+                    session.setAssistantText(assistantId, '');
+                const fixMessages = [...allMessages, { role: 'user', content: fixRequest(review.problems) }];
+                // Changing files waits until the worker has reproduced a problem.
+                startReproducing();
+                try {
+                    result = await provider.stream({ ...streamOptions, messages: fixMessages });
+                }
+                finally {
+                    stopReproducing();
+                }
+                allMessages = [...fixMessages, ...result.messages];
+            }
+        }
         if (assistantId === null)
             assistantId = session.startAssistant();
         session.setAssistantText(assistantId, result.text);
         session.finishAssistant(assistantId);
-        session.setHistory([...messages, ...result.messages]);
+        if (uncheckedNotice)
+            session.addNotice(UNCHECKED_NOTICE);
+        session.setHistory(allMessages);
         session.setLastReasoning(result.reasoning);
         session.addUsage(result.usage.input, result.usage.output, result.cost, result.usage.cached ?? 0);
         session.setRateLimit(result.rateLimit);
         void refreshCredit();
+        for (const cost of (result.stepCosts ?? []).slice(countedSteps))
+            reportStepCost(cost);
+        session.setPlanResetAt(null);
+        session.setActiveModel(auto ? workerModel() : null);
+        endJob();
         session.setStatus('idle');
     }
     catch (error) {
-        const plain = plainError(error);
+        endJob();
+        session.setActiveModel(auto ? workerModel() : null);
+        if (stop.signal.aborted) {
+            if (assistantId !== null)
+                session.finishAssistant(assistantId);
+            session.addNotice('Stopped, as you asked - nothing more will be spent on this.');
+            session.setStatus('idle');
+            return;
+        }
+        const plain = plainError(error, session.providerId);
         if (assistantId !== null)
             session.finishAssistant(assistantId);
         session.addError(plain.message);
+        if (plain.resetAt !== undefined)
+            session.setPlanResetAt(plain.resetAt);
+        // The technical text stays off screen unless /verbose is on.
+        if (session.verbose && plain.detail)
+            session.addNotice(`Technical details: ${plain.detail}`);
         session.setStatus(DISCONNECTING.has(plain.kind) ? 'disconnected' : 'idle');
     }
 }

package/dist/agent/permissions.js

@@ -1,4 +1,171 @@
 import { session } from '../state/session.js';
+// Pure-output commands that never require permission (the rule: harmless
+// output must never prompt). A command is auto-approved only when every stage of
+// it - across pipes, && and || - is one of the commands below, and the only
+// redirection anywhere is to /dev/null. Anything that writes, deletes, installs,
+// or reaches the network still prompts.
+const READ_ONLY_COMMANDS = new Set([
+    'yes',
+    'head',
+    'tail',
+    'cat',
+    'ls',
+    'pwd',
+    'wc',
+    'file',
+    'which',
+    'whoami',
+    'date',
+    'echo',
+    'printf',
+    'seq',
+    'sort',
+    'uniq',
+    'tr',
+    'grep',
+    'awk',
+    'sed',
+    'cut',
+    'fold',
+    'column',
+]);
+// Multi-word commands where the words themselves are the read-only form.
+const READ_ONLY_TWO_WORD_COMMANDS = new Set([
+    'git status',
+    'git log',
+    'git diff',
+    'node --version',
+    'npm --version',
+]);
+// git branch lists branches when nothing but flags follows; any name argument
+// would create, delete, or modify a branch, so only the listing form is allowed.
+function isReadOnlyGitBranch(rest) {
+    return rest.every((token) => token.startsWith('-'));
+}
+// sed with -n only prints (the p command); -i edits files in place, and the w
+// command writes files. The whole argument string is checked for a 'w' because
+// scanning sed script syntax reliably is not worth the risk - a false "ask" is
+// safe, a false "allow" is not.
+function isReadOnlySed(rest) {
+    return rest.includes('-n') && !rest.some((token) => token === '-i' || token.startsWith('-i')) && !rest.join(' ').includes('w');
+}
+// awk reads input unless the program itself writes a file or runs a command;
+// a | inside the program pipes to a command, so it disqualifies too.
+function isReadOnlyAwk(rest) {
+    const program = rest.join(' ');
+    return !program.includes('system(') && !program.includes('>') && !program.includes('|') && !program.includes('getline');
+}
+function isReadOnlyStage(tokens, isFinalStage) {
+    if (tokens.length === 0)
+        return false;
+    const command = tokens[0];
+    const rest = tokens.slice(1);
+    if (command === 'git') {
+        if (rest.length === 0)
+            return false;
+        if (READ_ONLY_TWO_WORD_COMMANDS.has(`git ${rest[0]}`))
+            return true;
+        if (rest[0] === 'branch')
+            return isReadOnlyGitBranch(rest.slice(1));
+        return false;
+    }
+    if (command === 'node' || command === 'npm') {
+        return rest.length === 1 && rest[0] === '--version';
+    }
+    if (command === 'sed')
+        return isReadOnlySed(rest);
+    if (command === 'awk')
+        return isReadOnlyAwk(rest);
+    if (command === 'yes') {
+        // yes on its own streams forever; it qualifies only feeding a pipe that ends.
+        return !isFinalStage;
+    }
+    return READ_ONLY_COMMANDS.has(command);
+}
+// One pipe stage: tokens with any /dev/null redirection stripped. Redirection to
+// any other target disqualifies the whole command.
+function parseStage(stage) {
+    const tokens = [];
+    const parts = stage.trim().split(/\s+/).filter((part) => part.length > 0);
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        // Forms: > /dev/null, 2> /dev/null, &> /dev/null, < /dev/null, and the
+        // no-space variants. Redirection to any other target disqualifies.
+        if (/^(\d*)>$|^&>$|^<$/.test(part) || /^(?:\d*>|&>|<)\/dev\/null$/.test(part)) {
+            const target = /^(?:\d*>|&>|<)\/dev\/null$/.test(part) ? part.replace(/^(?:\d*>|&>|<)/, '') : parts[++i];
+            if (target !== '/dev/null')
+                return null;
+            continue;
+        }
+        // Any other redirect or input form is a write or an unknown - disqualify.
+        if (/[<>]/.test(part))
+            return null;
+        tokens.push(part);
+    }
+    return { tokens };
+}
+// Splits on a separator character, ignoring quoted text, so a pipe inside quotes
+// (awk '{print $1 | "sort"}') never counts as a shell pipe.
+function splitOutsideQuotes(text, separator) {
+    const parts = [];
+    let current = '';
+    let quote = null;
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        if (quote) {
+            current += char;
+            if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            current += char;
+            continue;
+        }
+        if (text.startsWith(separator, i)) {
+            parts.push(current);
+            current = '';
+            i += separator.length - 1;
+            continue;
+        }
+        current += char;
+    }
+    parts.push(current);
+    return parts;
+}
+// True when the command is composed entirely of read-only stages: pipes, && and
+// || chains of allowlisted commands, with redirection to /dev/null only. Anything
+// else - writes, deletes, installs, network, substitutions, semicolons - is false.
+export function isReadOnlyBashCommand(command) {
+    const trimmed = command.trim();
+    if (trimmed.length === 0)
+        return false;
+    // Substitution constructs can turn any read into a write - and "$(...)" inside
+    // double quotes still executes - so any of these disqualifies outright.
+    if (trimmed.includes('`') || trimmed.includes('$('))
+        return false;
+    if (/[;\n]/.test(stripQuotes(trimmed)))
+        return false;
+    for (const chain of splitOutsideQuotes(trimmed, '&&')) {
+        for (const alternative of splitOutsideQuotes(chain, '||')) {
+            const stages = splitOutsideQuotes(alternative, '|');
+            for (let i = 0; i < stages.length; i++) {
+                const parsed = parseStage(stages[i]);
+                if (parsed === null)
+                    return false;
+                if (!isReadOnlyStage(parsed.tokens, i === stages.length - 1))
+                    return false;
+            }
+        }
+    }
+    return true;
+}
+// Replaces quoted spans with empty quoted strings, so metacharacter checks see
+// only what the shell will actually interpret. Shared with the runBash tool.
+export function stripQuotes(text) {
+    return text.replace(/"[^"]*"/g, '""').replace(/'[^']*'/g, "''");
+}
 // Approvals are queued so that parallel tool calls never overwrite each other's prompt.
 // The amber transcript prompt itself is rendered by the tool line in 'awaiting' state.
 const queue = [];