howtofixcli 0.7.13 → 0.7.15

package/dist/dcp/middle-prune.js

@@ -1,76 +0,0 @@
-/**
- * Trim the middle of a large tool result instead of dropping the result.
- *
- * A build log or a test run is mostly noise in the middle: the command and its
- * first lines are at the top, the failure and the exit status are at the bottom.
- * Keeping both ends means the model still sees what it asked for and what went
- * wrong, at a fraction of the context. Dropping the whole result, which is what
- * happens once pruning starts, loses both.
- */
-export const MIDDLE_PRUNE_DEFAULTS = {
-    thresholdChars: 8192,
-    headChars: 4096,
-    tailChars: 1024,
-};
-/** Cut the middle out of one text, leaving a marker that says how much went. */
-export function pruneMiddle(text, options = {}) {
-    const threshold = options.thresholdChars ?? MIDDLE_PRUNE_DEFAULTS.thresholdChars;
-    const headChars = options.headChars ?? MIDDLE_PRUNE_DEFAULTS.headChars;
-    const tailChars = options.tailChars ?? MIDDLE_PRUNE_DEFAULTS.tailChars;
-    if (text.length <= threshold || headChars + tailChars >= text.length) {
-        return { text, prunedChars: 0 };
-    }
-    // A cut in the middle of a surrogate pair produces a broken character, and the
-    // provider rejects the request for it. Step back one unit when the cut would
-    // split a pair.
-    let headEnd = headChars;
-    const headCode = text.charCodeAt(headEnd - 1);
-    if (headCode >= 0xd800 && headCode <= 0xdbff)
-        headEnd -= 1;
-    let tailStart = text.length - tailChars;
-    const tailCode = text.charCodeAt(tailStart);
-    if (tailCode >= 0xdc00 && tailCode <= 0xdfff)
-        tailStart += 1;
-    const head = text.slice(0, headEnd);
-    const tail = text.slice(tailStart);
-    const removed = tailStart - headEnd;
-    const marker = `\n\n[... ${removed} characters pruned from the middle ...]\n\n`;
-    return { text: head + marker + tail, prunedChars: removed - marker.length };
-}
-/**
- * Apply the middle prune to every tool result in a request.
- *
- * Returns new messages only where something was cut, so callers can keep using
- * the original array when nothing changed.
- */
-export function applyMiddlePrune(messages, options = {}) {
-    let savedChars = 0;
-    let prunedResults = 0;
-    let changed = false;
-    const out = messages.map((message) => {
-        const candidate = message;
-        if (candidate.role !== "toolResult" || !Array.isArray(candidate.content))
-            return message;
-        const messageContent = candidate.content;
-        let touched = false;
-        const content = messageContent.map((part) => {
-            if (!part || typeof part !== "object")
-                return part;
-            const candidate = part;
-            if (candidate.type !== "text" || typeof candidate.text !== "string")
-                return part;
-            const result = pruneMiddle(candidate.text, options);
-            if (result.prunedChars <= 0)
-                return part;
-            touched = true;
-            savedChars += result.prunedChars;
-            return { ...part, text: result.text };
-        });
-        if (!touched)
-            return message;
-        changed = true;
-        prunedResults += 1;
-        return { ...message, content };
-    });
-    return { messages: changed ? out : messages, savedChars, prunedResults };
-}

package/dist/dcp/prompts.js

@@ -1,68 +0,0 @@
-export function rangePrompt(format = "xml") {
-    const compact = format === "compact";
-    const message = compact ? "@4@" : "mNNNN";
-    const block = compact ? "@b1@" : "bN";
-    const placeholder = compact ? "@b1@" : "(bN)";
-    return `COMPRESSING A RANGE OF THIS CONVERSATION
-
-This is what the \`compress\` tool is for, and how a range must be summarised when it is used. Reach for it when the conversation has grown long enough that its older turns cost more than they are worth - never as a way to answer the user, and never on a range they did not ask about. Nothing here is a standing instruction to summarise: it is the contract the tool's output is held to.
-
-THE SUMMARY
-Your summary must be EXHAUSTIVE. Capture file paths, function signatures, decisions made, constraints discovered, key findings... EVERYTHING that maintains context integrity. This is not a brief note - it is an authoritative record so faithful that the original conversation adds no value.
-
-USER INTENT FIDELITY
-When the compressed range includes user messages, preserve the user's intent with extra care. Do not change scope, constraints, priorities, acceptance criteria, or requested outcomes.
-Directly quote user messages when they are short enough to include safely. Direct quotes are preferred when they best preserve exact meaning.
-
-Yet be LEAN. Strip away the noise: failed attempts that led nowhere, verbose tool outputs, back-and-forth exploration. What remains should be pure signal - golden nuggets of detail that preserve full understanding with zero ambiguity.
-
-COMPRESSED BLOCK PLACEHOLDERS
-When the selected range includes previously compressed blocks, use this exact placeholder format when referencing one:
-
-- \`${placeholder}\`
-
-Compressed block sections in context are clearly marked with a header:
-
-- \`[Compressed conversation section]\`
-
-${compact ? "Compressed block IDs look like `@b1@`, distinct from raw message IDs like `@4@`." : "Compressed block IDs always use the `bN` form (never `mNNNN`) and are represented in the same XML metadata tag format."}
-
-Rules:
-
-- Include every required block placeholder exactly once.
-- Do not invent placeholders for blocks outside the selected range.
-- Treat \`${placeholder}\` placeholders as RESERVED TOKENS. Do not emit \`${placeholder}\` text anywhere except intentional placeholders.
-- If you need to mention a block in prose, use plain text like \`compressed ${compact ? "block 1" : "bN"}\` (not as a placeholder).
-- Preflight check before finalizing: the set of \`${placeholder}\` placeholders in your summary must exactly match the required set, with no duplicates.
-
-These placeholders are semantic references. They will be replaced with the full stored compressed block content when the tool processes your output.
-
-FLOW PRESERVATION WITH PLACEHOLDERS
-When you use compressed block placeholders, write the surrounding summary text so it still reads correctly AFTER placeholder expansion.
-
-- Treat each placeholder as a stand-in for a full conversation segment, not a short label.
-- Ensure transitions before and after each placeholder preserve chronology and causality.
-- Do not write text that depends on the placeholder staying literal (for example, "as noted in \`${compact ? "@b2@" : "(b2)"}\`").
-- Your final meaning must be coherent once each placeholder is replaced with its full compressed block content.
-
-BOUNDARY IDS
-You specify boundaries by ID using the injected IDs visible in the conversation:
-
-- \`${message}\` IDs identify raw messages
-- \`${block}\` IDs identify previously compressed blocks
-
-${compact ? "Each message has an ID like `@4@`. Copy the whole marker, including both `@` characters, into `startId` and `endId`." : "Each message has an ID inside XML metadata tags like `<dcp-message-id>...</dcp-message-id>`."}
-The same ID tag appears in every tool output of the message it belongs to — each unique ID identifies one complete message.
-Treat these tags as boundary metadata only, not as tool result content.
-
-Rules:
-
-- Pick \`startId\` and \`endId\` directly from injected IDs in context.
-- IDs must exist in the current visible context.
-- \`startId\` must appear before \`endId\`.
-- Do not invent IDs. Use only IDs that are present in context.
-
-BATCHING
-When multiple independent ranges are ready and their boundaries do not overlap, include all of them as separate entries in the \`content\` array of a single tool call. Each entry should have its own \`startId\`, \`endId\`, and \`summary\`.
-`;
-}

package/dist/dcp/protected-content.js

@@ -1,221 +0,0 @@
-import { refIndicesOf } from "./ids.js";
-import { activeCompressedRanges, estimateSummaryTokens } from "./compress-state.js";
-import { HARD_EXCEPTION_TOOLS, isToolProtected } from "./protected.js";
-/**
- * The shared predicate, once: selection members in transcript order, minus
- * the ones an active block already covers, resolved to array positions.
- *
- * `exceptBlockId` is the block this append is FOR. At render time that block is
- * already active and covers exactly the window being appended, so leaving it in
- * the skip set makes every append a no-op — silently, with a stored summary that
- * looks correct and has lost the user's own words. The caller that renders a
- * block's summary passes its id; a caller doing anything else omits it.
- */
-function unprotectedPositions(selection, source, state, exceptBlockId) {
-    // No ref state (a transcript that was never tagged): nothing resolves, so
-    // every append is a no-op rather than an error — the compaction case.
-    const posByRef = new Map();
-    if (source.idState) {
-        const refs = refIndicesOf(source.idState, source.messages);
-        for (let position = 0; position < refs.length; position++) {
-            const ref = refs[position];
-            if (ref !== null)
-                posByRef.set(ref, position);
-        }
-    }
-    const covered = new Set();
-    for (const range of activeCompressedRanges(state)) {
-        if (exceptBlockId !== undefined && range.blockId === exceptBlockId)
-            continue;
-        for (const index of range.coveredIndices) {
-            covered.add(index);
-        }
-    }
-    const positions = [];
-    if (source.idState) {
-        for (const ref of selection.indices) {
-            if (covered.has(ref))
-                continue;
-            const position = posByRef.get(ref);
-            if (position === undefined)
-                continue;
-            positions.push(position);
-        }
-    }
-    return positions;
-}
-/** Every non-empty text of a user message; the content may be a bare string. */
-function userTextParts(message) {
-    if (typeof message.content === "string") {
-        return message.content.trim() ? [message.content] : [];
-    }
-    const texts = [];
-    for (const part of message.content) {
-        if (part.type === "text" && part.text.trim()) {
-            texts.push(part.text);
-        }
-    }
-    return texts;
-}
-/**
- * Append the first non-empty text of every selected user message that is not
- * already covered by an active block. Byte-identical no-op when `enabled` is
- * false or nothing qualifies — a heading with no body would be worse than
- * nothing, it reads as a bug to the model.
- */
-export function appendProtectedUserMessages(summary, selection, source, state, enabled, forBlockId) {
-    if (!enabled)
-        return summary;
-    const userTexts = [];
-    for (const position of unprotectedPositions(selection, source, state, forBlockId)) {
-        const message = source.messages[position];
-        if (!message || message.role !== "user")
-            continue;
-        const first = userTextParts(message)[0];
-        if (first !== undefined) {
-            userTexts.push(first);
-        }
-    }
-    if (userTexts.length === 0)
-        return summary;
-    const heading = "\n\nThe following user messages were sent in this conversation verbatim:";
-    const body = userTexts.map((text) => `\n${text}`).join("");
-    return summary + heading + body;
-}
-/**
- * Append every `<protect>...</protect>` capture from the selected user
- * messages that is not already covered by an active block. Same no-op rule
- * as the user-message path.
- */
-export function appendProtectedPromptInfo(summary, selection, source, state, enabled, forBlockId) {
-    if (!enabled)
-        return summary;
-    const protectedTexts = [];
-    for (const position of unprotectedPositions(selection, source, state, forBlockId)) {
-        const message = source.messages[position];
-        if (!message || message.role !== "user")
-            continue;
-        for (const text of userTextParts(message)) {
-            protectedTexts.push(...extractProtectedPromptInfo(text));
-        }
-    }
-    if (protectedTexts.length === 0)
-        return summary;
-    const heading = "\n\nThe following protected prompt information was included in this conversation verbatim:";
-    const body = protectedTexts.map((text) => `\n${text}`).join("");
-    return summary + heading + body;
-}
-/** Every `<protect>...</protect>` capture in `text`, trimmed, empties dropped. */
-export function extractProtectedPromptInfo(text) {
-    const protectedTexts = [];
-    const protectTagRegex = /<protect>([\s\S]*?)<\/protect>/gi;
-    for (const match of text.matchAll(protectTagRegex)) {
-        const captured = match[1]?.trim();
-        if (captured) {
-            protectedTexts.push(captured);
-        }
-    }
-    return protectedTexts;
-}
-/**
- * Append the outputs of protected tools from the selection window. A tool is
- * protected when its name matches the hard exceptions, the configured list,
- * or a configured file pattern matches a path in its arguments.
- *
- * The window is also the pairing scope: an output whose call sits outside the
- * window has no arguments to inspect, so it falls back to name-based
- * protection (`isToolProtected` with an undefined input).
- */
-export function appendProtectedTools(summary, selection, source, state, protectedTools = [], protectedFilePatterns = [], forBlockId) {
-    const argsByCallId = new Map();
-    const outputs = [];
-    for (const position of unprotectedPositions(selection, source, state, forBlockId)) {
-        const message = source.messages[position];
-        if (!message)
-            continue;
-        if (message.role === "assistant") {
-            for (const part of message.content) {
-                if (part.type === "toolCall") {
-                    argsByCallId.set(part.id, part.arguments);
-                }
-            }
-            continue;
-        }
-        if (message.role === "toolResult") {
-            // Error outputs are prune candidates, not keepsakes; the reference only
-            // ever preserved completed output.
-            if (message.isError)
-                continue;
-            const text = message.content
-                .filter((part) => part.type === "text")
-                .map((part) => part.text)
-                .join("");
-            if (text.trim()) {
-                outputs.push({ toolCallId: message.toolCallId, toolName: message.toolName, text });
-            }
-        }
-    }
-    if (outputs.length === 0)
-        return summary;
-    const toolNames = [...new Set([...HARD_EXCEPTION_TOOLS, ...protectedTools])];
-    const filePatterns = [...protectedFilePatterns];
-    const blocks = [];
-    for (const output of outputs) {
-        const input = argsByCallId.get(output.toolCallId);
-        if (!isToolProtected(output.toolName, input, toolNames, filePatterns))
-            continue;
-        blocks.push(`\n### Tool: ${output.toolName}\n${output.text}`);
-    }
-    if (blocks.length === 0)
-        return summary;
-    const heading = "\n\nThe following protected tools were used in this conversation as well:";
-    return summary + heading + blocks.join("");
-}
-/**
- * Store-side enrichment: layer a block's window's protected content onto its
- * stored summary in one mutation.
- *
- * This is the only path that carries the text, and the handler calls it once
- * per active block on every request. It runs here rather than in the compress
- * tool because the tool's `messages()` is a ref snapshot, not the transcript —
- * the appends resolve refs to messages, so only a caller holding both can do
- * this at all.
- *
- * Contract rules, each observable in `check-dcp.mjs`:
- *
- * 1. The selection is the block's own coverage — min/max bound it, the
- *    indices enumerate it.
- * 2. `forBlockId` is passed on every append: the block is active and covers
- *    its window, so without the self-exclusion everything no-ops silently.
- * 3. The result is written back with `summaryTokens` recomputed through the
- *    same estimator creation uses — stale tokens would lie about the savings.
- * 4. Idempotent via `protectedEnriched`: a re-run on a resumed session never
- *    duplicates the user's words. The flag lives on the block, not in the
- *    text, so a nested block whose body inherits an enriched summary still
- *    enriches its own window.
- * 5. A transcript that no longer holds the covered refs simply resolves to
- *    no messages: nothing is appended, nothing throws.
- *
- * `state` must carry the ref assignment (`DcpState.messageIds`); typed as an
- * intersection so this module does not depend on the store that depends on
- * `compress-state.ts`.
- */
-export function enrichBlockSummary(state, block, messages) {
-    if (block.protectedEnriched)
-        return;
-    const covered = block.coveredIndices;
-    if (covered.length > 0) {
-        const selection = {
-            startIdx: Math.min(...covered),
-            endIdx: Math.max(...covered),
-            indices: [...covered],
-            requiredBlockIds: [],
-            tokenByIndex: new Map(),
-        };
-        const source = { messages, idState: state.messageIds };
-        const enriched = appendProtectedTools(appendProtectedPromptInfo(appendProtectedUserMessages(block.summary, selection, source, state, true, block.blockId), selection, source, state, true, block.blockId), selection, source, state, [], [], block.blockId);
-        block.summary = enriched;
-        block.summaryTokens = estimateSummaryTokens(enriched);
-    }
-    block.protectedEnriched = true;
-}

package/dist/dcp/protected.js

@@ -1,161 +0,0 @@
-/**
- * Static protection layer: which tools and which file paths are never pruned.
- *
- * Ported from Opencode-DCP `lib/protected-patterns.ts`. `normalizePath`,
- * `matchesGlob` (`*`, `?`, `**`), `getFilePathsFromParameters` (`path`,
- * `filePath`, `patchText`, `multiedit`), `isFilePathProtected`,
- * `isToolNameProtected`, and `isToolProtected` keep DCP's behaviour; the only
- * divergence is typed access — the port uses `unknown` narrowing instead of the
- * original's `any`.
- *
- * The keep-set (goal/plan/notes aware) is the other, dynamic protection layer
- * and lives in `prune.ts`; this module is pure pattern matching.
- */
-/** Collapse Windows separators so paths compare across platforms. */
-export function normalizePath(input) {
-    // A single backslash. In source, "\\" is the one-character string; the
-    // previous "\\\\" was a *two*-character string, so it only ever matched a
-    // doubled separator -- which a real Windows path does not contain. The
-    // normalisation was therefore a no-op on the only platform that needs it.
-    return input.replaceAll("\\", "/");
-}
-function escapeRegExpChar(ch) {
-    return /[\\.^$+{}()|\[\]]/.test(ch) ? `\\${ch}` : ch;
-}
-/**
- * Glob match supporting `*` (no `/`), `?` (one non-`/`), and `**`
- * (`**` before a slash = zero or more directories, bare `**` = anything).
- */
-export function matchesGlob(inputPath, pattern) {
-    if (!pattern)
-        return false;
-    const input = normalizePath(inputPath);
-    const pat = normalizePath(pattern);
-    let regex = "^";
-    for (let i = 0; i < pat.length; i++) {
-        const ch = pat[i];
-        if (ch === "*") {
-            const next = pat[i + 1];
-            if (next === "*") {
-                const after = pat[i + 2];
-                if (after === "/") {
-                    // A doubled star before a slash: zero or more directories
-                    regex += "(?:.*/)?";
-                    i += 2;
-                    continue;
-                }
-                // **
-                regex += ".*";
-                i++;
-                continue;
-            }
-            // *
-            regex += "[^/]*";
-            continue;
-        }
-        if (ch === "?") {
-            regex += "[^/]";
-            continue;
-        }
-        if (ch === "/") {
-            regex += "/";
-            continue;
-        }
-        regex += escapeRegExpChar(ch);
-    }
-    regex += "$";
-    return new RegExp(regex).test(input);
-}
-/**
- * Extract file paths from a tool call's parameters:
- * - `apply_patch`/`patch` → paths embedded in `patchText`
- * - `multiedit` → top-level `filePath` plus each edit's `filePath`
- * - any tool → a string `filePath`
- * - `read`/`write`/`edit` → their V2 `path` parameter
- * Returns unique non-empty paths.
- */
-export function getFilePathsFromParameters(tool, parameters) {
-    if (typeof parameters !== "object" || parameters === null) {
-        return [];
-    }
-    const paths = [];
-    const params = parameters;
-    // 1. apply_patch uses patchText with embedded paths
-    if ((tool === "apply_patch" || tool === "patch") && typeof params.patchText === "string") {
-        const pathRegex = /\*\*\* (?:Add|Delete|Update) File: ([^\n\r]+)/g;
-        let match;
-        while ((match = pathRegex.exec(params.patchText)) !== null) {
-            paths.push(match[1].trim());
-        }
-    }
-    // 2. multiedit uses top-level filePath and nested edits array
-    if (tool === "multiedit") {
-        if (typeof params.filePath === "string") {
-            paths.push(params.filePath);
-        }
-        if (Array.isArray(params.edits)) {
-            for (const edit of params.edits) {
-                if (edit && typeof edit === "object" && typeof edit.filePath === "string") {
-                    paths.push(edit.filePath);
-                }
-            }
-        }
-    }
-    // 3. Default check for common filePath parameter (read, write, edit, etc)
-    if (typeof params.filePath === "string") {
-        paths.push(params.filePath);
-    }
-    // V2 file tools use path rather than filePath.
-    if (["read", "write", "edit"].includes(tool) && typeof params.path === "string") {
-        paths.push(params.path);
-    }
-    // Unique, non-empty
-    return [...new Set(paths)].filter((p) => p.length > 0);
-}
-export function isFilePathProtected(filePaths, patterns) {
-    if (filePaths.length === 0)
-        return false;
-    if (patterns.length === 0)
-        return false;
-    return filePaths.some((path) => patterns.some((pattern) => matchesGlob(path, pattern)));
-}
-const GLOB_CHARS = /[*?]/;
-/**
- * Tools that are never pruned, deduped, or compressed — their results carry
- * state the session replays from (todo/plan), or steer the run (goal/context/task).
- * Spec §3.4 hard exceptions; the default protection list for dedup and prune.
- */
-export const HARD_EXCEPTION_TOOLS = ["todo", "goal", "context", "task"];
-export function isToolNameProtected(toolName, patterns) {
-    if (!toolName || patterns.length === 0)
-        return false;
-    const exactPatterns = new Set();
-    const globPatterns = [];
-    for (const pattern of patterns) {
-        if (GLOB_CHARS.test(pattern)) {
-            globPatterns.push(pattern);
-        }
-        else {
-            exactPatterns.add(pattern);
-        }
-    }
-    if (exactPatterns.has(toolName))
-        return true;
-    return globPatterns.some((pattern) => matchesGlob(toolName, pattern));
-}
-/**
- * True when the tool name matches `tools` or any of its file paths match
- * `files`. `metadata.toolCalls` (V2 code-mode nested calls) is checked too:
- * one combined output is protected when any nested call matches.
- */
-export function isToolProtected(tool, input, tools, files, metadata) {
-    const calls = [{ tool, input }];
-    if (tool === "execute" && Array.isArray(metadata?.toolCalls)) {
-        for (const call of metadata.toolCalls) {
-            if (call && typeof call === "object" && typeof call.tool === "string") {
-                calls.push({ tool: call.tool, input: call.input });
-            }
-        }
-    }
-    return calls.some((call) => isToolNameProtected(call.tool, tools) || isFilePathProtected(getFilePathsFromParameters(call.tool, call.input), files));
-}