howtofixcli 0.7.8 → 0.7.9

package/dist/anim.js

@@ -1,361 +0,0 @@
-/**
- * Micro-animation primitives.
- *
- * Every function here is pure in `(text, style, nowMs)`. The workbench already
- * repaints on a 90 ms timer while a run is live, so an "animation" is only a
- * different pixel for the same state: no timers, no per-frame state, and no
- * allocation beyond the strings that get painted anyway.
- *
- * The one rule that matters for cost is that the sweep is emitted as a handful
- * of painted *runs*, not one escape sequence per character — the band is
- * quantised into levels so consecutive characters of the same level share a
- * single `styleText` call, so the sweep costs one style computation per row.
- *
- * `HOWTOFIX_NO_MOTION=1` turns every effect into its static form. That is also
- * what a non-TTY gets.
- */
-import { mixColors, parseColor, styleText } from "@netrodev/hxf-tui";
-import { MODE } from "./theme.js";
-export const MOTION = process.env.HOWTOFIX_NO_MOTION !== "1";
-/** Milliseconds per character the sweep travels, unless a caller overrides it. */
-const DEFAULT_CHAR_MS = 45;
-/** Half-width of the bright band, in characters. */
-const BAND = 5;
-/** Off-screen padding, so the band enters and leaves instead of snapping. */
-const GAP = 8;
-/**
- * When the wait ramp starts and where it lands: a run that has produced nothing
- * for ten seconds is still plausibly thinking, one that has produced nothing for
- * a minute is worth interrupting.
- */
-const WARN_AFTER_MS = 10_000;
-const STALLED_AFTER_MS = 60_000;
-/** Levels the band is quantised into: runs, not per-character escapes. */
-const LEVELS = 3;
-/**
- * Off-word padding on each side of the glint's travel, in characters.
- *
- * The band enters from off the word and leaves past the far end, so the light is
- * seen crossing rather than appearing on top of the text. The value is a
- * compromise and was measured rather than guessed: a padding of ten — the width
- * a continuous shimmer loop can afford, because the dead travel is just the gap
- * before the next lap — left *nineteen of twenty-seven* frames with nothing lit,
- * so a keypress was followed by most of a second of nothing before the light
- * arrived. Four keeps the entry readable at roughly 200 ms and leaves the sweep
- * itself at 50 ms per character.
- */
-const GLIMMER_PAD = 4;
-export const clamp01 = (value) => (value < 0 ? 0 : value > 1 ? 1 : value);
-/** Blend between two palette colours; the terminal has no alpha, so this is "fade". */
-export function fade(from, to, amount) {
-    const t = clamp01(amount);
-    if (t >= 1)
-        return to;
-    if (t <= 0)
-        return from;
-    return mixColors(from, to, t);
-}
-/**
- * A meter that moves to its target instead of jumping to it.
- *
- * The workbench repaints on a timer, so this is stepped on each frame with the
- * real elapsed time rather than a fixed frame length: a dropped frame shortens
- * nothing and the meter arrives at the same time on a slow terminal. The step is
- * clamped, because a resume after a suspend would otherwise integrate seconds of
- * simulated time into one frame.
- *
- * Underneath it is a critically-damped spring: `velocity` accumulates toward the
- * remaining distance and is bled off, which gives the small overshoot at the end
- * that makes a number feel like it moved rather than teleported.
- */
-export class Spring {
-    value;
-    velocity = 0;
-    last = Date.now();
-    target;
-    constructor(value, target = value) {
-        this.value = value;
-        this.target = target;
-    }
-    /** Point the spring at a new target; it keeps its speed on the way. */
-    set(target) {
-        this.target = target;
-    }
-    /** True while it is still moving, so a caller can keep the clock alive. */
-    get moving() {
-        return Math.abs(this.target - this.value) > 0.15;
-    }
-    /** Jump to a value, discarding any motion. For a new baseline, not a target. */
-    snap(value) {
-        this.value = value;
-        this.target = value;
-        this.velocity = 0;
-        this.last = Date.now();
-    }
-    /** Advance to `now` and return the current value. */
-    step(now = Date.now()) {
-        // The clamp exists for a gap (suspend, a blocked event loop), and it has to
-        // sit above the real frame length: the workbench tick is 90 ms, so clamping
-        // at 64 ms would silently throw away a quarter of every frame and make the
-        // meter settle later here than on a faster machine.
-        const raw = Math.max(0, now - this.last);
-        const dt = Math.min(250, raw) / 1000;
-        this.last = now;
-        if (!MOTION) {
-            this.value = this.target;
-            this.velocity = 0;
-            return this.value;
-        }
-        // A gap longer than the clamp is time nobody saw: there were no frames
-        // between, so nothing moved on screen and there is no momentum to carry.
-        // Keeping the old velocity across a suspend would fling the value past the
-        // target on the first frame back, which reads as a glitch rather than as
-        // motion.
-        if (raw > 250)
-            this.velocity = 0;
-        // Critically-damped spring, integrated in fixed-duration sub-steps: a
-        // 90 ms workbench frame and a 16 ms frame integrate the same curve, so a
-        // meter move takes the same wall-clock time on any machine. The frame
-        // itself is clamped, so a gap (suspend, a blocked event loop) integrates
-        // as one frame instead of one enormous step.
-        const stiffness = 150;
-        const damping = 2 * Math.sqrt(stiffness);
-        const substeps = Math.max(1, Math.ceil(dt / 0.008));
-        const h = dt / substeps;
-        for (let sub = 0; sub < substeps; sub += 1) {
-            this.velocity += (this.target - this.value) * stiffness * h - this.velocity * damping * h;
-            this.value += this.velocity * h;
-        }
-        if (!this.moving) {
-            this.value = this.target;
-            this.velocity = 0;
-        }
-        return this.value;
-    }
-}
-/**
- * A status colour that says how long the agent has been waiting on the model.
- *
- * A long silence is not automatically a problem — a big prompt with thinking on
- * takes a while — so this is a ramp, not an alarm: it slides toward the warning
- * colour and reaches the error colour only after the wait has run long enough to
- * be worth interrupting. Claude Code does the same with its spinner gradient;
- * the point is that the colour carries information the text does not.
- */
-export function waitTone(waitedMs, calm, warning, stalled) {
-    if (!MOTION)
-        return calm;
-    if (waitedMs <= WARN_AFTER_MS)
-        return calm;
-    if (waitedMs >= STALLED_AFTER_MS)
-        return stalled;
-    return fade(warning, stalled, (waitedMs - WARN_AFTER_MS) / (STALLED_AFTER_MS - WARN_AFTER_MS));
-}
-/**
- * A one-shot entrance: 0 → 1 over `durationMs`, eased out, then it stays at 1.
- * Callers paint `fade(dim, final, entrance(age, duration))`. The terminal has no
- * alpha, so this is a colour move, and the text is never re-flowed by it.
- */
-export function entrance(ageMs, durationMs) {
-    // A negative age means the caller does not know when the item appeared (it
-    // came from the transcript, not from this session): draw it final.
-    if (!MOTION || durationMs <= 0 || ageMs < 0)
-        return 1;
-    return 1 - (1 - clamp01(ageMs / durationMs)) ** 3;
-}
-/** True while an entrance that began `ageMs` ago still needs repaints. */
-export function entering(ageMs, durationMs) {
-    return MOTION && ageMs >= 0 && ageMs < durationMs;
-}
-/** How long a newly appended feed item takes to become fully opaque. */
-export const ENTRANCE_MS = 260;
-/** Delay between consecutive detail lines of one result, so they cascade. */
-export const STAGGER_MS = 45;
-/**
- * How many lines of a block are visible `ageMs` after it appeared.
- *
- * A line that has not had its turn is not drawn at all — not drawn faint — so
- * the block grows into place instead of showing its final height with ghost
- * lines in it. `total` is returned once the cascade is over, and the cascade is
- * capped so a 200-line diff does not take nine seconds to appear.
- */
-export function revealedLines(ageMs, total, staggerMs = STAGGER_MS, maxDelayMs = 400) {
-    if (!MOTION || staggerMs <= 0 || ageMs < 0)
-        return total;
-    if (ageMs >= maxDelayMs)
-        return total;
-    return Math.min(total, Math.floor(ageMs / staggerMs) + 1);
-}
-/**
- * A slow oscillation between two colours, for a surface that is waiting on the
- * user. It is a triangle wave rather than a sine: it never skips a frame at the
- * turn, and the difference is invisible at this speed.
- */
-export function pulse(from, to, now = Date.now(), periodMs = 1400) {
-    if (!MOTION || periodMs <= 0)
-        return from;
-    const phase = (now % periodMs) / periodMs;
-    return fade(from, to, phase < 0.5 ? phase * 2 : (1 - phase) * 2);
-}
-/**
- * A band of light crossing plain text once, at `progress` through its travel.
- *
- * This is the level's change effect. It is a *glint*, not a gradient: the band is
- * three characters wide with a bright crest and two half-lit shoulders, and it
- * advances one character per tick. The first version blurred the light across
- * five characters with three blended levels and crossed the word in 320 ms, and
- * that is what made it read as a smear rather than as a highlight — a gradient
- * spread over a six-character word leaves almost no pixel at full strength, so
- * the eye gets a dim wobble instead of a moving point of light. Sharp is both
- * more legible and cheaper: fewer distinct runs to paint.
- *
- * The travel is deliberately unhurried. The band enters from off the word and
- * leaves past the far end, so it is seen crossing rather than appearing on top of
- * the word, and the padding on each side is wide enough for that entry to be
- * read. The caller owns the clock: `progress` runs 0 → 1 over the travel and a
- * render never depends on when it happened to be called.
- *
- * Motion is confined to the three to seven characters of the word itself. A
- * ripple that repainted the viewport would have to be painted onto a feed that is
- * also scrolling, and under `screen` — where every frame is a diffed repaint — a
- * large animated region is the exact case that tears.
- */
-export function ripple(text, style, progress) {
-    const rest = styleText(text, { fg: style.rest }, MODE);
-    if (!MOTION || text.length === 0)
-        return rest;
-    const t = clamp01(progress);
-    if (t >= 1)
-        return rest;
-    const band = style.band ?? 1;
-    // The crest starts and ends off the text, so the band is seen crossing rather
-    // than appearing on top of the word.
-    const span = text.length + GLIMMER_PAD * 2;
-    // Quantised to whole characters, and this is the detail that decides whether
-    // the effect reads as a glint or as a smear. Stepping the centre continuously
-    // means that for most frames it sits *between* two characters, so both are half
-    // lit and neither reaches full strength — the band looks dim and soft at every
-    // instant, which is exactly the blur this replaced. Advancing one character at a
-    // time keeps one character at the crest on every frame the band is visible.
-    const step = Math.min(span - 1, Math.floor(t * span));
-    const centre = step - GLIMMER_PAD;
-    const levelAt = (i) => {
-        const distance = Math.abs(i - centre);
-        if (distance > band)
-            return 0;
-        return 1 - distance / (band + 1);
-    };
-    let out = "";
-    let runStart = 0;
-    let runLevel = null;
-    let offset = 0;
-    let index = 0;
-    for (const char of text) {
-        const level = levelAt(index);
-        if (runLevel === null) {
-            runLevel = level;
-        }
-        else if (level !== runLevel) {
-            out += styleText(text.slice(runStart, offset), { fg: fade(style.rest, style.lit, runLevel) }, MODE);
-            runStart = offset;
-            runLevel = level;
-        }
-        offset += char.length;
-        index += 1;
-    }
-    return out + styleText(text.slice(runStart), { fg: fade(style.rest, style.lit, runLevel ?? 0) }, MODE);
-}
-/**
- * Paint text with a travelling band of a colour ramp: a spectrum that flows
- * across the word and never sits on a single flat colour.
- *
- * This is what the top of the effort ladder looks like. The ramp is the one the
- * levels themselves are drawn from, so the highest setting carries every colour
- * below it — the word is a picture of the ladder rather than a badge for its top
- * rung. It runs continuously, which is the one animation here that does: a
- * ceiling is a standing fact about the session, and a still word would say
- * nothing about being at the limit.
- *
- * `charMs` is milliseconds per character the spectrum advances, so the flow
- * speed is independent of the word's length and of the frame rate.
- */
-export function spectrum(text, ramp, now = Date.now(), charMs = 90) {
-    const first = ramp[0] ?? parseColor("#e6e6e6");
-    if (ramp.length === 0 || text.length === 0)
-        return styleText(text, { fg: first }, MODE);
-    if (!MOTION || charMs <= 0)
-        return styleText(text, { fg: ramp[ramp.length - 1] ?? first }, MODE);
-    // One lap per `ramp.length * charMs`, each character offset by one step, so the
-    // band is exactly one ramp long and wraps without a seam.
-    const lap = ramp.length * charMs;
-    const step = ((now % lap) + lap) % lap;
-    let out = "";
-    let runStart = 0;
-    let runColor = null;
-    let offset = 0;
-    let index = 0;
-    const colourAt = (i) => {
-        const pos = (((step + i * charMs) / lap) % 1) * ramp.length;
-        const from = Math.floor(pos) % ramp.length;
-        const to = (from + 1) % ramp.length;
-        return fade(ramp[from] ?? first, ramp[to] ?? first, pos - Math.floor(pos));
-    };
-    for (const char of text) {
-        const colour = colourAt(index);
-        if (runColor === null) {
-            runColor = colour;
-        }
-        else if (colour !== runColor) {
-            out += styleText(text.slice(runStart, offset), { fg: runColor }, MODE);
-            runStart = offset;
-            runColor = colour;
-        }
-        offset += char.length;
-        index += 1;
-    }
-    return out + styleText(text.slice(runStart), { fg: runColor ?? first }, MODE);
-}
-/** Distance from the band centre, quantised so the sweep emits a few runs. */
-function bandLevel(index, centre) {
-    const distance = Math.abs(index - centre);
-    if (distance >= BAND)
-        return 0;
-    return Math.ceil((1 - distance / BAND) * LEVELS) / LEVELS;
-}
-/**
- * Sweep a brightness band across plain text.
- *
- * `text` must be plain — no escape sequences — because the band is painted from
- * code points. Visible width is preserved exactly: only colour codes are added.
- * The band starts off-screen and ends off-screen, so a looping sweep never
- * strobes at the boundary.
- */
-export function shimmer(text, style, now = Date.now()) {
-    const charMs = style.charMs ?? DEFAULT_CHAR_MS;
-    if (!MOTION || text.length === 0 || charMs <= 0)
-        return styleText(text, { fg: style.base }, MODE);
-    const span = text.length + GAP * 2;
-    const centre = ((now / charMs) % span) - GAP;
-    const paint = (run, level) => styleText(run, { fg: fade(style.base, style.bright, level) }, MODE);
-    let out = "";
-    let runStart = 0;
-    let runLevel = null;
-    let offset = 0;
-    let index = 0;
-    // Code-point iteration with code-unit offsets: a surrogate pair crosses the
-    // band as one character and is never split between two runs.
-    for (const char of text) {
-        const level = bandLevel(index, centre);
-        if (runLevel === null) {
-            runLevel = level;
-        }
-        else if (level !== runLevel) {
-            out += paint(text.slice(runStart, offset), runLevel);
-            runStart = offset;
-            runLevel = level;
-        }
-        offset += char.length;
-        index += 1;
-    }
-    return out + paint(text.slice(runStart), runLevel ?? 0);
-}

package/dist/args.js

@@ -1,228 +0,0 @@
-import { APP_TITLE, APP_VERSION } from "./brand.js";
-const THINKING = { off: true, minimal: true, low: true, medium: true, high: true, xhigh: true, max: true };
-const APPROVAL = { suggest: true, "auto-edit": true, "full-auto": true };
-/**
- * `text` is for a person. `json` writes only the final result record, which is
- * what a script that just wants the answer and the cost reaches for.
- * `stream-json` writes every event as it happens, which is what a progress UI
- * or a CI log needs. The split matches the contract scripts already expect.
- */
-const OUTPUT_FORMATS = { text: true, json: true, "stream-json": true };
-function parseBudget(raw) {
-    const dollars = Number(raw);
-    if (!Number.isFinite(dollars) || dollars <= 0) {
-        throw new Error(`--max-budget-usd needs a positive number of dollars, got '${raw}'`);
-    }
-    return dollars;
-}
-function takeValue(argv, index, flag) {
-    const inline = argv[index];
-    if (inline?.includes("="))
-        return inline.slice(inline.indexOf("=") + 1);
-    const next = argv[index + 1];
-    if (!next || next.startsWith("-")) {
-        throw new Error(`${flag} needs a value`);
-    }
-    argv.splice(index + 1, 1);
-    return next;
-}
-export function parseArgs(argv) {
-    const args = {
-        print: false,
-        continueSession: false,
-        noSession: false,
-        help: false,
-        version: false,
-        update: false,
-        checkUpdate: false,
-        outputFormat: "text",
-        dangerouslySkipPermissions: false,
-        sandbox: false,
-        prompt: "",
-    };
-    const rest = [];
-    const tokens = [...argv];
-    for (let i = 0; i < tokens.length; i++) {
-        const token = tokens[i] ?? "";
-        if (token === "--") {
-            rest.push(...tokens.slice(i + 1));
-            break;
-        }
-        if (token === "-h" || token === "--help")
-            args.help = true;
-        else if (token === "-v" || token === "--version")
-            args.version = true;
-        else if (token === "-p" || token === "--print")
-            args.print = true;
-        else if (token === "-c" || token === "--continue")
-            args.continueSession = true;
-        else if (token === "--no-session")
-            args.noSession = true;
-        else if (token === "--sandbox")
-            args.sandbox = true;
-        else if (token === "--update")
-            args.update = true;
-        else if (token === "--check-update")
-            args.checkUpdate = true;
-        else if (token === "-r" || token === "--resume")
-            args.continueSession = true;
-        else if (token === "--session" || token.startsWith("--session=")) {
-            args.sessionPath = takeValue(tokens, i, "--session");
-        }
-        else if (token === "-m" || token === "--model" || token.startsWith("--model=")) {
-            args.model = takeValue(tokens, i, "--model");
-        }
-        else if (token === "--thinking" || token.startsWith("--thinking=")) {
-            args.thinking = takeValue(tokens, i, "--thinking");
-        }
-        else if (token === "--approval" || token.startsWith("--approval=")) {
-            args.approval = takeValue(tokens, i, "--approval");
-        }
-        else if (token === "--output-format" || token.startsWith("--output-format=")) {
-            args.outputFormat = takeValue(tokens, i, "--output-format");
-        }
-        else if (token === "--max-budget-usd" || token.startsWith("--max-budget-usd=")) {
-            args.maxBudgetUsd = parseBudget(takeValue(tokens, i, "--max-budget-usd"));
-        }
-        else if (token === "--dangerously-skip-permissions") {
-            args.dangerouslySkipPermissions = true;
-        }
-        else if (token.startsWith("-")) {
-            throw new Error(`unknown option ${token}`);
-        }
-        else {
-            rest.push(token);
-        }
-    }
-    if (args.thinking && !THINKING[args.thinking]) {
-        throw new Error(`thinking must be one of: ${Object.keys(THINKING).join(", ")}`);
-    }
-    if (args.approval && !APPROVAL[args.approval]) {
-        throw new Error(`approval must be one of: ${Object.keys(APPROVAL).join(", ")}`);
-    }
-    if (!OUTPUT_FORMATS[args.outputFormat]) {
-        throw new Error(`output-format must be one of: ${Object.keys(OUTPUT_FORMATS).join(", ")}`);
-    }
-    if (args.outputFormat !== "text" && !args.print) {
-        throw new Error(`--output-format ${args.outputFormat} is a machine contract; it needs --print`);
-    }
-    // `--max-budget-usd` used to demand `--print` here, on the theory that only
-    // a one-shot run has an end to stop at. The workbench has ends too — every
-    // turn settles — and it reads the same `getSessionStats().cost` that `/stats`
-    // shows, so the cap is enforced there as well (see spend-cap.ts). No guard.
-    if (args.dangerouslySkipPermissions && !args.print) {
-        throw new Error("--dangerously-skip-permissions is for unattended runs; it needs --print. " +
-            "interactively, pick an approval mode instead (/approval, or --approval)");
-    }
-    // Assigned before the guards: a guard that reads `args.prompt` while it is
-    // still empty never fires, which is how `--update "do something"` sailed past.
-    args.prompt = rest.join(" ").trim();
-    if (args.update && args.checkUpdate) {
-        throw new Error("--update installs; --check-update only looks. pick one");
-    }
-    if ((args.update || args.checkUpdate) && (args.print || args.continueSession || args.sessionPath || args.prompt)) {
-        throw new Error("--update and --check-update act on the installation, not a session; they take no prompt");
-    }
-    if (args.continueSession && args.noSession) {
-        throw new Error("--continue and --no-session cannot be combined");
-    }
-    if (args.sessionPath && args.noSession) {
-        throw new Error("--session and --no-session cannot be combined");
-    }
-    if (args.sessionPath && args.continueSession) {
-        throw new Error("--session and --continue cannot be combined");
-    }
-    if (args.print && (args.continueSession || args.sessionPath)) {
-        throw new Error("--print runs one prompt in a throwaway session; it cannot be combined with --continue or --session");
-    }
-    if (args.sessionPath && !args.sessionPath.endsWith(".jsonl")) {
-        throw new Error(`--session expects a session file, got '${args.sessionPath}'`);
-    }
-    return args;
-}
-export function helpText() {
-    return `${APP_TITLE} ${APP_VERSION}
-coding agent. layout is a workbench, not a chat log.
-
-usage:
-  howtofix [options] [prompt]
-  howtofix -p "explain this repo"
-  howtofix preset new|check|pack     author a preset
-  howtofix doctor|models|sessions    inspect the installation
-  howtofix sessions --search <text> find a session by what was said in it
-  howtofix sessions --export <n>    print session n from the list as markdown
-
-options:
-  -p, --print          run one prompt and print the answer
-  -c, --continue       resume the latest session in this folder
-  -r, --resume         alias for --continue
-      --session <file> run inside a specific saved session file
-      --no-session     do not write a session file
-  -m, --model <id>     provider/model, or a fuzzy model id
-      --thinking <lv>  off | minimal | low | medium | high | xhigh | max
-      --approval <m>   suggest | auto-edit | full-auto
-      --output-format <f>  text | json | stream-json
-                       text for a person; json writes the final result only;
-                       stream-json writes every event as it happens
-      --max-budget-usd <n> stop the run once it has spent n dollars
-      --sandbox        run the whole session inside a filesystem sandbox:
-                       the project is writable, the rest is read-only.
-                       needs bubblewrap (Linux) or sandbox-exec (macOS)
-      --dangerously-skip-permissions
-                       run everything, including commands otherwise refused.
-                       unattended runs only; pairs with --print
-      --update         install the newest release and exit
-      --check-update   say whether a newer release exists
-  -h, --help
-  -v, --version
-
-keys:
-  enter                send
-  shift+enter          new line
-  ctrl+c               stop the run, or quit when idle
-  ctrl+d               quit
-  ctrl+l               jump to the latest line
-  ctrl+o               clear the screen (history is kept)
-  ctrl+t               raise the thinking level (wraps to off)
-  ctrl+shift+t         lower the thinking level
-  esc                  clear the draft
-  ctrl+v               paste from the clipboard
-  pgup / pgdn          scroll the transcript a page
-  home / end           jump to the top / back to the latest line
-  wheel                scroll the transcript
-
-commands:
-  /init /model /providers /thinking /approval /login /connect /logout /new
-  /resume /compact /name /stats /rtk /diff /commit /undo /rewind /review /tools /export
-  /copy /agents /goal /plan /workflow /session /help /quit /exit
-  /dcp /context /decompress /sweep
-  /update /usage /sync
-  /skills /preset /settings /proxy /roblox
-
-/stats shows session tokens, cost, and the prompt-cache hit rate; a high read
-total alone hides re-billed context, so the rate is what tells you the truth.
-/rtk compresses long tool output (logs, diffs, greps) before the model reads it.
-Off by default: /rtk on to save tokens when skimming, /rtk off to keep every line.
-Nothing is invented by it — it drops redundant lines and says how many it dropped,
-and never touches a failed command or one already truncated.
-
-/preset lists skills bundled with this build and skills from the registry, by
-category; picking one downloads it into the project and loads it as a skill.
-An integration preset installs disabled: its skills and MCP server stay dormant
-until /preset enable <name>, and /preset disable <name> takes the server back
-out of the live session. /roblox reports that state for RoToolbox in one line.
-/skills lists what is loaded now.
-
-/proxy <url> routes requests through a proxy, /proxy off stops, /proxy env uses
-HTTPS_PROXY / HTTP_PROXY / ALL_PROXY; /proxy alone shows what is set.
-
-/agents <id> <message> messages a parked agent; /agents <id> shows one.
-
-a line starting with ! runs in the project shell.
-
-an npm install checks for a newer release at startup and can install it itself;
-/update does it on demand. config and sessions live in ~/.howtofix/agent.
-/connect signs in to howtofix.id in your browser, and falls back to a pasted
-token; /login takes another provider's key.
-`;
-}

package/dist/at-file.js

@@ -1,28 +0,0 @@
-import { readFileSync, statSync } from "node:fs";
-import { isAbsolute, resolve } from "node:path";
-/** Files larger than this are referenced but not inlined. */
-const MAX_INLINE_BYTES = 64 * 1024;
-/**
- * Expand `@path` tokens into `<file>` blocks, the way aider, gemini-cli, and
- * codex do. Unknown or binary-looking paths are left untouched for the model
- * to read with its own tools.
- */
-export function expandFileReferences(text, cwd) {
-    return text.replace(/(^|\s)@([^\s]+)/g, (match, lead, raw) => {
-        const token = raw.replace(/[),.;:]+$/, "");
-        const trailing = raw.slice(token.length);
-        const target = isAbsolute(token) ? token : resolve(cwd, token);
-        try {
-            const stats = statSync(target);
-            if (!stats.isFile() || stats.size === 0 || stats.size > MAX_INLINE_BYTES)
-                return match;
-            const content = readFileSync(target);
-            if (content.includes(0))
-                return match;
-            return `${lead}<file name="${target}">\n${content.toString("utf8").trimEnd()}\n</file>${trailing}`;
-        }
-        catch {
-            return match;
-        }
-    });
-}