howtofixcli 0.7.8 → 0.7.9

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));
-}