howtofixcli 0.7.13 → 0.7.15

package/dist/repo-map.js

@@ -1,292 +0,0 @@
-import { readdirSync, readFileSync, statSync } from "node:fs";
-import { extname, join, relative, resolve, sep } from "node:path";
-import { Type } from "@netrodev/hxf-ai";
-import { defineTool } from "@netrodev/hxf-coding-agent";
-/**
- * A ranked outline of the repository, built without a parser dependency.
- *
- * The model cannot read a large tree, and listing every file is worse than
- * useless: it spends the budget evenly on files that matter and files that do
- * not. This walks the tree, pulls the declarations out of each file, follows the
- * relative imports between them, and ranks by how much of the code depends on a
- * file — the same idea as a tree-sitter repo map, done with regexes so it works
- * on any machine without native builds.
- *
- * The ranking is the point. A file that ten others import is more likely to be
- * the one worth reading than a file nobody mentions, and a symbol outline says
- * what is in it before a single line is opened.
- */
-const SKIP_DIRS = new Set([
-    "node_modules",
-    ".git",
-    "dist",
-    "build",
-    "out",
-    "coverage",
-    "vendor",
-    "target",
-    "__pycache__",
-    ".venv",
-    "venv",
-    ".next",
-    ".turbo",
-    ".cache",
-]);
-const LANGUAGES = {
-    ".ts": {
-        kind: "ts",
-        patterns: [
-            /^\s*export\s+(?:default\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)/gm,
-            /^\s*export\s+(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)/gm,
-            /^\s*export\s+(?:interface|type)\s+([A-Za-z_$][\w$]*)/gm,
-            /^\s*export\s+const\s+([A-Za-z_$][\w$]*)/gm,
-            /^\s*(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)/gm,
-            /^\s*(?:export\s+)?class\s+([A-Za-z_$][\w$]*)/gm,
-        ],
-    },
-    ".tsx": { kind: "tsx", patterns: [] },
-    ".js": { kind: "js", patterns: [] },
-    ".mjs": { kind: "js", patterns: [] },
-    ".go": {
-        kind: "go",
-        patterns: [
-            /^func\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)/gm,
-            /^type\s+([A-Za-z_]\w*)\s+(?:struct|interface)/gm,
-        ],
-    },
-    ".py": {
-        kind: "py",
-        patterns: [/^(?:async\s+)?def\s+([A-Za-z_]\w*)/gm, /^class\s+([A-Za-z_]\w*)/gm],
-    },
-    ".rs": {
-        kind: "rs",
-        patterns: [
-            /^\s*(?:pub\s+)?(?:async\s+)?fn\s+([A-Za-z_]\w*)/gm,
-            /^\s*(?:pub\s+)?(?:struct|enum|trait)\s+([A-Za-z_]\w*)/gm,
-        ],
-    },
-};
-// TSX/JS share the TypeScript patterns; declared separately so the table reads
-// as "which extensions are walked", not "which extensions have a parser".
-LANGUAGES[".tsx"].patterns = LANGUAGES[".ts"].patterns;
-LANGUAGES[".js"].patterns = LANGUAGES[".ts"].patterns;
-LANGUAGES[".mjs"].patterns = LANGUAGES[".ts"].patterns;
-const MAX_FILE_BYTES = 512 * 1024;
-const MAX_DEPTH = 12;
-/** Declarations in one file, deduplicated and in source order. */
-export function extractSymbols(text, ext) {
-    const language = LANGUAGES[ext];
-    if (!language)
-        return [];
-    const seen = new Set();
-    const out = [];
-    for (const pattern of language.patterns) {
-        pattern.lastIndex = 0;
-        for (const match of text.matchAll(pattern)) {
-            const name = match[1];
-            if (name && !seen.has(name)) {
-                seen.add(name);
-                out.push(name);
-            }
-        }
-    }
-    return out;
-}
-/** Relative import specifiers, as written in the file. */
-export function extractImports(text, ext) {
-    const found = new Set();
-    const add = (spec) => {
-        if (spec && (spec.startsWith("./") || spec.startsWith("../")))
-            found.add(spec);
-    };
-    if (ext === ".ts" || ext === ".tsx" || ext === ".js" || ext === ".mjs") {
-        for (const match of text.matchAll(/(?:from|require\()\s*["']([^"']+)["']/g))
-            add(match[1]);
-        for (const match of text.matchAll(/^\s*import\s+["']([^"']+)["']/gm))
-            add(match[1]);
-    }
-    else if (ext === ".go") {
-        for (const match of text.matchAll(/^\s*(?:[\w.]+\s+)?"([^"]+)"/gm))
-            add(match[1]);
-    }
-    else if (ext === ".py") {
-        for (const match of text.matchAll(/^\s*from\s+(\.+[\w.]*)\s+import/gm)) {
-            const spec = match[1].replace(/\./g, "/");
-            add(spec.startsWith("/") ? `.${spec}` : `./${spec}`);
-        }
-    }
-    else if (ext === ".rs") {
-        for (const match of text.matchAll(/^\s*use\s+(?:crate|super|self)::([\w:]+)/gm)) {
-            add(`./${match[1].split("::").join("/")}`);
-        }
-    }
-    return [...found];
-}
-/** Resolve an import specifier to a file that is in the walked set. */
-function resolveImport(fromPath, spec, known) {
-    const base = fromPath.split("/").slice(0, -1).join("/");
-    const target = join(base, spec).split(sep).join("/").replace(/^\.\//, "");
-    const candidates = [
-        target,
-        `${target}.ts`,
-        `${target}.tsx`,
-        `${target}.js`,
-        `${target}.mjs`,
-        `${target}.go`,
-        `${target}.py`,
-        `${target}.rs`,
-        `${target}/index.ts`,
-        `${target}/index.tsx`,
-        `${target}/index.js`,
-        `${target}/mod.rs`,
-        `${target}.py`,
-    ];
-    return candidates.find((candidate) => known.has(candidate));
-}
-/** Walk the tree, skipping the directories nobody wants in a map. */
-export function collectFiles(root, subdir = ".") {
-    const files = [];
-    const walk = (dir, depth) => {
-        if (depth > MAX_DEPTH)
-            return;
-        let entries;
-        try {
-            entries = readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            const full = join(dir, entry.name);
-            if (entry.isDirectory()) {
-                if (SKIP_DIRS.has(entry.name) || entry.name.startsWith("."))
-                    continue;
-                walk(full, depth + 1);
-                continue;
-            }
-            const ext = extname(entry.name);
-            if (!LANGUAGES[ext])
-                continue;
-            try {
-                if (statSync(full).size > MAX_FILE_BYTES)
-                    continue;
-                const text = readFileSync(full, "utf8");
-                const rel = relative(root, full).split(sep).join("/");
-                files.push({ path: rel, symbols: extractSymbols(text, ext), imports: extractImports(text, ext) });
-            }
-            catch {
-                // An unreadable file is not a reason to fail the map.
-            }
-        }
-    };
-    walk(resolve(root, subdir), 0);
-    return files;
-}
-/**
- * Rank files by how much of the tree depends on them.
- *
- * PageRank over the import graph, with a small personalisation toward files
- * that mention the query. Twenty iterations is far past convergence for a
- * repository of this size and keeps the call cheap.
- */
-export function rankFiles(files, query) {
-    if (files.length === 0)
-        return [];
-    const known = new Set(files.map((file) => file.path));
-    const index = new Map(files.map((file, i) => [file.path, i]));
-    const out = files.map(() => []);
-    const incoming = files.map(() => []);
-    files.forEach((file, i) => {
-        for (const spec of file.imports) {
-            const target = resolveImport(file.path, spec, known);
-            if (!target || target === file.path)
-                continue;
-            const j = index.get(target);
-            if (j === undefined)
-                continue;
-            out[i].push(j);
-            incoming[j].push(i);
-        }
-    });
-    const n = files.length;
-    const needle = query?.trim().toLowerCase();
-    const personal = files.map((file) => {
-        if (!needle)
-            return 1 / n;
-        const haystack = `${file.path} ${file.symbols.join(" ")}`.toLowerCase();
-        return haystack.includes(needle) ? 4 / n : 1 / n;
-    });
-    const personalTotal = personal.reduce((sum, value) => sum + value, 0);
-    let rank = files.map((_, i) => personal[i] / personalTotal);
-    for (let iteration = 0; iteration < 20; iteration++) {
-        const next = files.map((_, i) => 0.15 * (personal[i] / personalTotal));
-        for (let i = 0; i < n; i++) {
-            if (out[i].length === 0) {
-                // A file that imports nothing spreads its weight over the whole tree,
-                // which is what keeps a leaf-only repository from collapsing to zero.
-                for (let j = 0; j < n; j++)
-                    next[j] += (0.85 * rank[i]) / n;
-                continue;
-            }
-            for (const j of out[i])
-                next[j] += (0.85 * rank[i]) / out[i].length;
-        }
-        rank = next;
-    }
-    return files
-        .map((file, i) => ({
-        file,
-        score: rank[i],
-        // A query is a statement about what the caller is looking for, so a file
-        // that names it is worth more than any amount of graph weight: the ranking
-        // still orders the matches among themselves.
-        match: needle ? `${file.path} ${file.symbols.join(" ")}`.toLowerCase().includes(needle) : false,
-    }))
-        .sort((a, b) => Number(b.match) - Number(a.match) || b.score - a.score || a.file.path.localeCompare(b.file.path))
-        .map((entry) => entry.file);
-}
-/** Render a ranked map inside a character budget (roughly 4 chars per token). */
-export function renderRepoMap(files, options = {}) {
-    const budget = Math.max(200, Math.min(8000, options.budget ?? 1200));
-    const chars = budget * 4;
-    const ranked = rankFiles(files, options.query);
-    const lines = [];
-    let used = 0;
-    for (const file of ranked) {
-        const symbols = file.symbols.slice(0, 8).join(", ");
-        const line = symbols ? `${file.path}: ${symbols}` : `${file.path}`;
-        if (used + line.length + 1 > chars)
-            break;
-        lines.push(line);
-        used += line.length + 1;
-    }
-    if (lines.length === 0)
-        return "(no source files found)";
-    const omitted = ranked.length - lines.length;
-    if (omitted > 0)
-        lines.push(`… ${omitted} more file${omitted === 1 ? "" : "s"} not shown`);
-    return lines.join("\n");
-}
-let projectRoot;
-/** The session's project directory, supplied by the caller for the same reason
- * claims take one: a tool cannot know which project the process is in. */
-export function setRepoRoot(next) {
-    projectRoot = next;
-}
-export const repoMapTool = defineTool({
-    name: "repo_map",
-    label: "repo_map",
-    description: "A ranked outline of the repository: files by importance with their top declarations. Use it to find where something lives before reading files, instead of listing directories.",
-    promptSnippet: "repo_map: ranked file outline of the project",
-    parameters: Type.Object({
-        path: Type.Optional(Type.String({ description: "Subdirectory to map, relative to the project root" })),
-        query: Type.Optional(Type.String({ description: "Keyword to bias the ranking, e.g. 'billing'" })),
-        budget: Type.Optional(Type.Number({ description: "Token budget, default 1200" })),
-    }),
-    async execute(_toolCallId, params) {
-        const root = projectRoot?.() ?? process.cwd();
-        const files = collectFiles(root, params.path ?? ".");
-        const text = renderRepoMap(files, { budget: params.budget, query: params.query });
-        return { content: [{ type: "text", text }], details: { files: files.length } };
-    },
-});

package/dist/rtk.js

@@ -1,193 +0,0 @@
-/**
- * Output compression for tool results (the "read the tool, keep the token" layer).
- *
- * A coding agent spends most of its context on tool output, and most of that output is
- * not information: a `git diff` where one line in forty changed, a `grep` that matched
- * the same import in fifty files, an `ls -R` of a `node_modules` nobody asked about.
- * Paying full price for it shortens the effective context and, on a metered gateway,
- * costs money for text the model will never reason about.
- *
- * This runs as a `tool_result` handler, which is the right seam: the result has already
- * been produced and stored, so compression changes only what the model is asked to read,
- * never what the tool actually returned. That distinction matters — a `bash` command that
- * wrote a file must never be re-run or altered because its *report* was shortened.
- *
- * Two rules keep it honest:
- *
- *  - **Never invent content.** Every line the model sees came from the tool. A summary
- *    says how many lines were dropped and where they went; it never paraphrases them.
- *  - **Never hide a failure.** An error result, or a result the tool marked truncated,
- *    is passed through untouched. Losing the one line that explains why a command failed
- *    costs far more than the tokens it saves.
- *
- * Off by default. Compression is a trade the caller makes with knowledge of their task:
- * a search whose whole point is a count needs every line, and a run that is skimming a
- * large diff does not want any.
- */
-/** Tools whose output is worth compressing. Reads and writes are already exact. */
-const COMPRESSIBLE = new Set(["bash", "grep", "find", "ls", "bash_output", "powershell"]);
-/**
- * Tools whose lines are *progress* rather than *findings*, and so may be run-collapsed.
- *
- * The distinction is what the numbers mean. In `Compiling module 10 done in 30ms` the
- * numbers are a counter and the lines are interchangeable — keeping two loses nothing.
- * In `src/auth.ts:42: const x = 1` the numbers identify *which* finding this is, and
- * collapsing a hundred of them into a notice deletes the answer to the search the user
- * just ran. A grep must therefore keep every line it matched; only its redundant blanks
- * and an elision of the middle may go.
- */
-const RUN_COLLAPSIBLE = new Set(["bash", "bash_output", "powershell"]);
-/** Below this many lines there is nothing worth summarising. */
-export const MIN_LINES = 40;
-/** How many lines of a long run to keep at each end. */
-export const KEEP_HEAD = 12;
-export const KEEP_TAIL = 8;
-/** A run must be at least this long before it is worth collapsing. */
-export const MIN_RUN = 6;
-/**
- * True when a line carries no information beyond its neighbours' shape.
- *
- * Deliberately narrow. A "useful" test that guessed would eventually drop the one line
- * that mattered, so only plainly redundant lines qualify: repeats of the line above,
- * separators, and blank runs.
- */
-function isRedundant(line, previous) {
-    const trimmed = line.trim();
-    if (trimmed === "")
-        return true;
-    // A rule of only punctuation or dashes is a separator, not content.
-    if (/^[-=*_~+#]{3,}$/.test(trimmed))
-        return true;
-    if (previous !== undefined && line === previous)
-        return true;
-    return false;
-}
-/**
- * The shape of a line, with every number run replaced by a placeholder.
- *
- * Numbers move; the text around them is what makes two lines the same kind of line. A
- * trailing-only match misses the common case — `Compiling module 10 done in 30ms` has
- * its counter in the middle, so every line looked unique and none were collapsed.
- *
- * Collapsing is defensible for tool output in a way it is not for, say, a claim: the
- * output is *reproducible*. The tool can be run again, and the notice below always says
- * how many lines went and what shape they had, so nothing is lost that cannot be
- * recovered by re-running the command.
- */
-function shapeOf(line) {
-    return line.replace(/\d+/g, "#").trimEnd();
-}
-function collapseNumericRuns(lines) {
-    const out = [];
-    let collapsed = 0;
-    let i = 0;
-    while (i < lines.length) {
-        const key = shapeOf(lines[i]);
-        // A line with no digits has no counter to move, so a run of them is content that
-        // happens to repeat — not progress. Only a changing number makes a run collapsible.
-        if (key === "" || !/\d/.test(lines[i])) {
-            out.push(lines[i]);
-            i += 1;
-            continue;
-        }
-        let j = i + 1;
-        while (j < lines.length && shapeOf(lines[j]) === key && /\d/.test(lines[j]))
-            j += 1;
-        const run = j - i;
-        if (run >= MIN_RUN) {
-            out.push(lines[i]);
-            out.push(`  … ${run - 2} more line${run - 2 === 1 ? "" : "s"} of the same shape …`);
-            out.push(lines[j - 1]);
-            collapsed += 1;
-        }
-        else {
-            for (let k = i; k < j; k += 1)
-                out.push(lines[k]);
-        }
-        i = j;
-    }
-    return { out, collapsed };
-}
-/**
- * Compress one tool result, or return undefined to leave it exactly as it was.
- *
- * Returning `undefined` rather than the original content is the difference between
- * "nothing to do" and "replace it with itself": the handler contract treats an omitted
- * field as untouched, and re-sending identical content burns the work for no gain.
- */
-export function compressToolResult(text, details, options = {}) {
-    // A result the tool already truncated has been shaped by a rule that understands the
-    // tool; second-guessing it here only risks dropping the tail it deliberately kept.
-    if (details?.truncated)
-        return undefined;
-    const lines = text.split("\n");
-    if (lines.length < MIN_LINES)
-        return undefined;
-    // 1. Drop plainly redundant lines, keeping count so the notice can be truthful.
-    const kept = [];
-    let droppedRedundant = 0;
-    for (let i = 0; i < lines.length; i += 1) {
-        if (isRedundant(lines[i], kept[kept.length - 1])) {
-            // Keep one blank line as a paragraph break; collapse only the runs.
-            if (lines[i].trim() === "" && kept[kept.length - 1]?.trim() !== "") {
-                kept.push("");
-                continue;
-            }
-            droppedRedundant += 1;
-            continue;
-        }
-        kept.push(lines[i]);
-    }
-    // 2. Collapse repeated-shape runs — but only for tools whose numbers are progress
-    //    rather than content. A grep's line numbers identify findings; collapsing them
-    //    would delete the answer. See RUN_COLLAPSIBLE.
-    const mayCollapseRuns = options.toolName === undefined || RUN_COLLAPSIBLE.has(options.toolName);
-    const { out: collapsedLines, collapsed } = mayCollapseRuns ? collapseNumericRuns(kept) : { out: kept, collapsed: 0 };
-    // 3. Keep both ends if it is still too long. The head carries the command and its
-    //    first results; the tail carries the failure or the summary, which is usually
-    //    why anyone reads a long output at all.
-    const head = options.head ?? KEEP_HEAD;
-    const tail = options.tail ?? KEEP_TAIL;
-    let final = collapsedLines;
-    let elided = 0;
-    if (collapsedLines.length > head + tail + MIN_RUN) {
-        elided = collapsedLines.length - head - tail;
-        final = [...collapsedLines.slice(0, head), `  … ${elided} line${elided === 1 ? "" : "s"} omitted (${head} kept from the top, ${tail} from the end) …`, ...collapsedLines.slice(collapsedLines.length - tail)];
-    }
-    const saved = droppedRedundant + collapsed;
-    if (saved === 0 && elided === 0)
-        return undefined;
-    return {
-        text: final.join("\n"),
-        stats: { before: lines.length, after: final.length, collapsed },
-    };
-}
-/**
- * Build the extension that applies compression to tool results.
- *
- * `enabled` is read per call rather than captured, so toggling it mid-session takes
- * effect on the next tool result instead of the next process.
- */
-export function createRtkExtension(options) {
-    return (hxf) => {
-        hxf.on("tool_result", (event) => {
-            if (!options.enabled())
-                return undefined;
-            // A failure is never compressed. The line that explains it is exactly the
-            // line a heuristic is most likely to decide is redundant.
-            if (event.isError)
-                return undefined;
-            if (!COMPRESSIBLE.has(event.toolName))
-                return undefined;
-            const textPart = event.content.find((c) => c.type === "text");
-            if (!textPart || textPart.type !== "text")
-                return undefined;
-            const details = event.details;
-            const result = compressToolResult(textPart.text, details, { toolName: event.toolName });
-            if (!result)
-                return undefined;
-            const content = event.content.map((c) => (c === textPart ? { type: "text", text: result.text } : c));
-            return { content };
-        });
-    };
-}

package/dist/sandbox.js

@@ -1,105 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { accessSync, constants } from "node:fs";
-import { join } from "node:path";
-function isExecutable(path) {
-    try {
-        accessSync(path, constants.X_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/** Which sandbox this machine can actually provide, if any. */
-export function detectSandbox(platform = process.platform, pathEnv = process.env.PATH ?? "") {
-    const dirs = pathEnv.split(":").filter(Boolean);
-    const find = (name) => dirs.map((dir) => join(dir, name)).find(isExecutable);
-    if (platform === "linux") {
-        const bwrap = find("bwrap");
-        // Installed is not the same as usable: a container or a kernel with
-        // unprivileged user namespaces disabled has the binary and still refuses to
-        // create a namespace. Probing costs a few milliseconds and turns a confusing
-        // runtime failure into an honest "not available here".
-        if (!bwrap)
-            return undefined;
-        const probe = spawnSync(bwrap, ["--ro-bind", "/", "/", "--", "true"], { stdio: "ignore", timeout: 3000 });
-        return probe.status === 0 ? "bubblewrap" : undefined;
-    }
-    if (platform === "darwin")
-        return find("sandbox-exec") ? "seatbelt" : undefined;
-    return undefined;
-}
-/**
- * The argv that re-runs `argv` inside the sandbox.
- *
- * The bind list is the security boundary: `/` is mounted read-only, then the
- * project and the CLI's state directory are mounted writable over it. `/tmp` is
- * a fresh tmpfs, so a build cannot leave anything behind outside the project.
- * Network stays on — a coding agent that cannot reach a registry is not usable —
- * and `--unshare-pid` is left off because some toolchains need to see the
- * process tree.
- */
-export function sandboxArgv(kind, paths) {
-    if (kind === "bubblewrap") {
-        return [
-            "bwrap",
-            "--die-with-parent",
-            "--new-session",
-            "--ro-bind",
-            "/",
-            "/",
-            "--dev",
-            "/dev",
-            "--proc",
-            "/proc",
-            "--tmpfs",
-            "/tmp",
-            "--bind",
-            paths.cwd,
-            paths.cwd,
-            "--bind",
-            paths.agentDir,
-            paths.agentDir,
-            "--chdir",
-            paths.cwd,
-            "--",
-            ...paths.argv,
-        ];
-    }
-    const profile = [
-        "(version 1)",
-        "(deny default)",
-        "(allow process*)",
-        "(allow signal)",
-        "(allow sysctl-read)",
-        "(allow mach-lookup)",
-        "(allow network*)",
-        "(allow file-read*)",
-        `(allow file-write* (subpath "${paths.cwd}") (subpath "${paths.agentDir}") (subpath "/tmp") (subpath "/private/tmp") (subpath "/private/var/folders"))`,
-        "",
-    ].join("\n");
-    return ["sandbox-exec", "-p", profile, ...paths.argv];
-}
-/** A sentence for the banner, so the mode is never a secret. */
-export function describeSandbox(kind) {
-    return kind === "bubblewrap"
-        ? "sandbox: bubblewrap — project writable, rest of the filesystem read-only"
-        : "sandbox: seatbelt — project writable, rest of the filesystem read-only";
-}
-/**
- * Re-execute this process inside the sandbox and return its exit code.
- *
- * Called once, before any session exists, and guarded by HOWTOFIX_SANDBOXED so
- * the re-executed process does not try to wrap itself again.
- */
-export function enterSandbox(kind, paths) {
-    const result = spawnSync(sandboxArgv(kind, paths)[0], sandboxArgv(kind, paths).slice(1), {
-        stdio: "inherit",
-        env: { ...process.env, HOWTOFIX_SANDBOXED: "1" },
-    });
-    if (result.error) {
-        console.error(`sandbox: could not start ${kind}: ${result.error.message}`);
-        return 1;
-    }
-    return result.status ?? 1;
-}