howtofixcli 0.7.13 → 0.7.15

package/dist/prompt-files.js

@@ -1,103 +0,0 @@
-/**
- * Standing instructions the user can add without rebuilding the CLI.
- *
- * The CLI ships its own rules (`brand.ts` SYSTEM_APPEND). A user who wants a
- * standing rule of their own — a house convention, a language to answer in, a
- * command that must never run — otherwise has to edit the source or repeat
- * themselves every session.
- *
- * So: `APPEND_SYSTEM.md` in the user's config root, appended after the built-in
- * rules.
- *
- *   <AGENT_DIR>/APPEND_SYSTEM.md
- *
- * **User scope only, deliberately.** A project-scoped file was written first and
- * then removed, for two reasons that both held:
- *
- * - It would break prompt caching. The SDK renders `addendum` *before*
- *   `project_context`, and `project_context` is where the provider's cache
- *   breakpoint lands. A cwd-dependent file inside `addendum` therefore gives
- *   every worktree a different cached prefix — exactly the cost the ordering
- *   its blocks to avoid.
- * - It would duplicate `AGENTS.md`, which the SDK already discovers per project
- *   and renders into `project_context`. Two files for one job means two sets of
- *   rules that can disagree, with no way to tell which won.
- *
- * Also deliberately NOT implemented: a file that *replaces* the prompt. The SDK's
- * `customPrompt` swaps out the whole `preamble` section, and that section carries
- * the tool list, the per-tool rules and the docs block — so a user file could
- * silently take the agent's tools away with it. Replacing is a bigger contract
- * than it looks. The append route has no such failure mode: it can only add.
- */
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { AGENT_DIR } from "./paths.js";
-/** The user-scoped file. Named here so the check script and the docs agree. */
-export const USER_PROMPT_FILE = join(AGENT_DIR, "APPEND_SYSTEM.md");
-/**
- * Stated to the model only when no one can answer it.
- *
- * A bundled skill resolves its mode by asking the user and stopping until they
- * reply. In a terminal that is the right behaviour. Under `--print` there is no
- * one to reply, so the question becomes a dead end: the model asked, the run
- * ended, and the task it was given was never started. The skill cannot know the
- * difference and the prompt never said, so the run looks successful — exit 0,
- * no error — while producing nothing.
- *
- * This block closes that gap. It names the tools that stop and wait, so the
- * model takes the sensible default instead of asking, and it says why, so it
- * does not read the instruction to ask as one it should follow anyway.
- */
-export const NON_INTERACTIVE_BLOCK = [
-    "<non-interactive>",
-    "This run has no user attached: it was started with --print, and there is nobody to answer a question. Anything that stops and waits for a reply — `ask`, a confirmation, a skill that resolves a mode by asking which mode to use — will simply end the run with the task unfinished.",
-    "So do not ask. Where an instruction tells you to ask the user and wait, take the default it describes and continue, and say which default you took and why in your final answer. The user reads that answer; they cannot answer mid-run.",
-    "Where a skill offers a choice of modes, prefer the one that applies the rules while you work over the one that audits afterwards: this is the mode for building something now, and the audit mode can still be run later by the same person who reads your answer.",
-    "</non-interactive>",
-].join("\n");
-/**
- * A user file is prose, not a payload. One pasted log or a stray directory dump
- * would otherwise ride along in every single request; past this size the file is
- * skipped rather than truncated, because half a rule is a different rule.
- */
-const MAX_BYTES = 16 * 1024;
-/**
- * Read the file, or `undefined`. Never throws: an unreadable or oversized file
- * must not stop a session from opening, and a permissions error is the user's to
- * fix rather than a reason to refuse to work.
- */
-export function readPromptFile(path) {
-    try {
-        if (!existsSync(path))
-            return undefined;
-        const text = readFileSync(path, "utf8").trim();
-        if (!text)
-            return undefined;
-        if (Buffer.byteLength(text, "utf8") > MAX_BYTES)
-            return undefined;
-        return text;
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * The append blocks for a session: the built-in rules, then the user's file.
- *
- * The file gets a heading naming its origin, because a rule whose source is
- * invisible is a rule nobody can find again.
- *
- * `interactive` decides whether the first block also states that nobody can
- * answer a question. The bundled skills include one that resolves a mode by
- * asking the user and waiting, which is right in a terminal and fatal in
- * `--print`: the model asks, nothing answers, and the task it was given never
- * runs. The prompt said nothing either way, so the model could not tell the two
- * apart. Pass the real value; a wrong one is worse than none.
- */
-export function promptAppendBlocks(builtIn, interactive) {
-    const blocks = [interactive ? builtIn : `${builtIn}\n\n${NON_INTERACTIVE_BLOCK}`];
-    const user = readPromptFile(USER_PROMPT_FILE);
-    if (user)
-        blocks.push(`# Standing instructions from ${USER_PROMPT_FILE}\n${user}`);
-    return blocks;
-}

package/dist/prompt-text.js

@@ -1,41 +0,0 @@
-/**
- * Read and write the text of a message whose content may be a string or a parts
- * array.
- *
- * The prompt has to be edited in place on the leading system message: a provider
- * reads the prompt and the initial tool declarations from that one message, so
- * appending a second system message would not reach it. Both prompt extensions
- * need the same two operations, and doing it in one place keeps the
- * `unknown`-typed SDK content out of their bodies.
- */
-/** Flatten a message's content to plain text. */
-export function readMessageText(content) {
-    if (typeof content === "string")
-        return content;
-    if (Array.isArray(content)) {
-        return content
-            .map((part) => {
-            const candidate = part;
-            return candidate.type === "text" && typeof candidate.text === "string" ? candidate.text : "";
-        })
-            .join("\n");
-    }
-    return content == null ? "" : String(content);
-}
-/** Write text back into a message's content, preserving its original shape. */
-export function writeMessageText(content, text) {
-    if (Array.isArray(content)) {
-        const parts = content.map((part) => ({ ...part }));
-        const texts = parts.filter((part) => part.type === "text");
-        if (texts.length > 0) {
-            // Collapse into the first text part; any others would otherwise duplicate
-            // or contradict the text we just wrote.
-            texts[0].text = text;
-            for (const extra of texts.slice(1))
-                extra.text = "";
-            return parts;
-        }
-        return [...parts, { type: "text", text }];
-    }
-    return text;
-}

package/dist/proxy.js

@@ -1,137 +0,0 @@
-/**
- * Routing the CLI's own requests through a proxy.
- *
- * HowToFix talks to one upstream, `api.howtofix.id`, and that is the traffic
- * this affects: the provider calls, the sign-in exchange, the release check. A
- * user behind a corporate gateway, or on a network where that host is reachable
- * only through one, otherwise cannot use the CLI at all.
- *
- * Two sources:
- *
- *  1. `httpsProxy` in `<agent dir>/settings.json` — what `/proxy` writes, and
- *     the only one that applies to this CLI alone. Set, it wins outright.
- *  2. `HTTPS_PROXY` / `HTTP_PROXY` / `ALL_PROXY`, with `NO_PROXY` honoured —
- *     the conventional variables, read exactly the way Node reads them.
- *
- * The request is routed with an undici dispatcher rather than by replacing
- * `fetch`, because the SDK's provider adapters call `globalThis.fetch` and
- * swapping that out would be a monkey-patch of a dependency's dependency. The
- * dispatcher is what Node uses underneath, so the behaviour is the platform's,
- * not an imitation of it.
- */
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { EnvHttpProxyAgent, ProxyAgent, getGlobalDispatcher, setGlobalDispatcher } from "undici";
-/** Where the setting lives, and what it is called. */
-export const PROXY_SETTING_KEY = "httpsProxy";
-/** The proxy named in settings.json, if there is a usable one there. */
-export function configuredProxy(agentDir) {
-    let parsed;
-    try {
-        parsed = JSON.parse(readFileSync(join(agentDir, "settings.json"), "utf8"));
-    }
-    catch {
-        // A missing or unparseable settings file is "no proxy configured": routing
-        // must never be the thing that stops the CLI from starting.
-        return undefined;
-    }
-    const value = parsed[PROXY_SETTING_KEY];
-    if (typeof value !== "string")
-        return undefined;
-    const trimmed = value.trim();
-    // `/proxy off` clears the key; an empty string means the same thing.
-    return trimmed === "" ? undefined : trimmed;
-}
-/** Whether the conventional environment variables name a proxy. */
-export function environmentProxy() {
-    const value = process.env.HTTPS_PROXY ?? process.env.HTTP_PROXY ?? process.env.ALL_PROXY;
-    const trimmed = value?.trim();
-    return trimmed ? trimmed : undefined;
-}
-/** A URL this CLI can actually dial, or the reason it cannot. */
-export function validateProxyUrl(raw) {
-    const value = raw.trim();
-    if (value === "")
-        return { ok: false, problem: "empty" };
-    let parsed;
-    try {
-        parsed = new URL(value);
-    }
-    catch {
-        return { ok: false, problem: `"${value}" is not a URL` };
-    }
-    const scheme = parsed.protocol.replace(/:$/, "").toLowerCase();
-    // Only what the runtime can dial without another dependency: a typo is refused
-    // where it is typed, not at the next request.
-    if (scheme !== "http" && scheme !== "https") {
-        return { ok: false, problem: `unsupported scheme "${scheme}"; use http:// or https://` };
-    }
-    if (!parsed.hostname)
-        return { ok: false, problem: "no host in the proxy URL" };
-    return { ok: true, url: value };
-}
-/**
- * The dispatcher this process started with, captured before the first override.
- *
- * Kept so "no proxy" can restore the exact object the runtime began with rather
- * than a new one that merely behaves the same. Captured lazily, on the first
- * call, which is always before any override — so it is the pristine default.
- */
-let defaultDispatcher;
-/**
- * Route this process's outbound requests through the configured proxy.
- *
- * Called once, before any session exists, and again whenever the setting
- * changes. Returns what it did, so the caller can say it in one line — a proxy
- * that is silently in force is a support question waiting to happen.
- *
- * Every path sets a dispatcher, including the "none" one, and that is the point:
- * a function that only ever installs a proxy cannot undo one. Turning the proxy
- * off used to write the setting and leave the dispatcher in place, so the rest
- * of that session kept dialling a host the user had just removed — the turn hung
- * with nothing on screen to say why, and only a restart fixed it.
- *
- * A settings value is dialled directly, because the user named one host and
- * meant it. Environment variables go through `EnvHttpProxyAgent`, which applies
- * `NO_PROXY` and the lowercase spellings the way the platform does; matching
- * those rules by hand is how the exceptions get subtly wrong.
- */
-export function installProxy(agentDir) {
-    const restore = () => {
-        if (defaultDispatcher === undefined)
-            defaultDispatcher = getGlobalDispatcher();
-        setGlobalDispatcher(defaultDispatcher);
-    };
-    const fromSettings = configuredProxy(agentDir);
-    if (fromSettings) {
-        const valid = validateProxyUrl(fromSettings);
-        // A malformed value is reported through `source`, not thrown: the direct
-        // route is still worth trying, and a stack trace at startup is worse than
-        // one line naming the bad URL.
-        if (!valid.ok)
-            return { source: "settings" };
-        try {
-            setGlobalDispatcher(new ProxyAgent(valid.url));
-        }
-        catch {
-            restore();
-            return { source: "settings" };
-        }
-        return { url: valid.url, source: "settings" };
-    }
-    const fromEnv = environmentProxy();
-    if (fromEnv) {
-        try {
-            setGlobalDispatcher(new EnvHttpProxyAgent());
-        }
-        catch {
-            restore();
-            return { source: "env" };
-        }
-        return { url: fromEnv, source: "env" };
-    }
-    // No proxy anywhere: put the original dispatcher back, so a session that had
-    // one and then did not is genuinely direct rather than apparently direct.
-    restore();
-    return { source: "none" };
-}

package/dist/quality/ast.js

@@ -1,196 +0,0 @@
-/**
- * TypeScript AST wrapper: parse a set of files into walkable source files.
- *
- * Why `typescript/unstable/*`: TypeScript 7.0 ships NO stable programmatic API —
- * the package's `.` export resolves to a version string, `createSourceFile` /
- * `createProgram` / `forEachChild` are gone, and `unstable/ast` has no parser at
- * all (scanner + node types only). Parsing lives in the native binary and is
- * reachable only through the unstable session API, which spawns it over a pipe;
- * a stable API is expected back in 7.1. `package.json` pins `typescript` to an
- * exact version (no caret) precisely so a bump through `unstable/` is a reviewed
- * upgrade, not a silent metric change. `scripts/check-quality.mjs` asserts both
- * the pin and this comment.
- *
- * Two properties matter more than speed here (the spec's §4 regression):
- *
- * 1. Every requested file lands in the returned `Map<path, ParsedFile>` — a
- *    file that cannot be read or parsed becomes an explicit `{ ok: false }`
- *    entry, never a missing key. Analysis results are paired to files by path,
- *    never by array position, so one broken file cannot shift the rest.
- * 2. Nested functions are separate units: the metric walkers stop at a
- *    function boundary and report the inner function on its own.
- */
-import { API } from "typescript/unstable/async";
-import { SyntaxKind, visitEachChild } from "typescript/unstable/ast";
-/** Kinds that make a function its own analysis unit. */
-export const FUNCTION_KINDS = new Set([SyntaxKind.FunctionDeclaration, SyntaxKind.FunctionExpression, SyntaxKind.ArrowFunction, SyntaxKind.MethodDeclaration, SyntaxKind.Constructor, SyntaxKind.GetAccessor, SyntaxKind.SetAccessor]);
-export function isFunctionLike(kind) {
-    return FUNCTION_KINDS.has(kind);
-}
-/** `&&`, `||`, `??` — one decision point each in cyclomatic, +1 flat in cognitive. */
-export const LOGICAL_OPERATORS = new Set([SyntaxKind.AmpersandAmpersandToken, SyntaxKind.BarBarToken, SyntaxKind.QuestionQuestionToken]);
-/**
- * A `BinaryExpression` that tests with `&&` / `||` / `??`. TypeScript's AST has
- * no `LogicalExpression` (that is an estree name); the operator is a child
- * token, so it is looked up by name through {@link childNode}.
- */
-export function isLogicalBinary(node) {
-    if (node.kind !== SyntaxKind.BinaryExpression)
-        return false;
-    const operator = childNode(node, "operatorToken");
-    return operator !== undefined && LOGICAL_OPERATORS.has(operator.kind);
-}
-/**
- * Read a named child off a node.
- *
- * The generated node interfaces are per-kind, so generic code cannot touch
- * `thenStatement` without a cast per kind; every metric child access goes
- * through here instead, which also keeps `no any` intact.
- */
-export function childNode(node, key) {
-    const value = node[key];
-    if (value && typeof value === "object" && typeof value.kind === "number") {
-        return value;
-    }
-    return undefined;
-}
-/** The node list stored under a key (`parameters`, `statements`, …), or `[]`. */
-export function childNodes(node, key) {
-    const value = node[key];
-    return Array.isArray(value) ? value : [];
-}
-/** Whether the node's modifier list contains the given modifier keyword kind. */
-export function hasModifier(node, kind) {
-    return childNodes(node, "modifiers").some((modifier) => modifier.kind === kind);
-}
-/** The `.text` of an identifier-like node, or `undefined` when there is none. */
-export function nodeText(node) {
-    if (!node)
-        return undefined;
-    const text = node["text"];
-    return typeof text === "string" ? text : undefined;
-}
-/** 1-based line of a position in the file. Three call sites share the +1. */
-export function lineOf(sourceFile, position) {
-    return sourceFile.getLineAndCharacterOfPosition(position).line + 1;
-}
-/**
- * Span of a node for reporting: `getStart` skips leading trivia, so a JSDoc
- * block does not inflate the printed `L88-142` or the SARIF region, and every
- * consumer (the function units and `report.ts`'s findings) computes the same
- * four numbers in one place.
- */
-export function nodeSpan(sourceFile, node) {
-    const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
-    const end = sourceFile.getLineAndCharacterOfPosition(node.end);
-    return {
-        startLine: start.line + 1,
-        startColumn: start.character + 1,
-        endLine: end.line + 1,
-        endColumn: end.character + 1,
-    };
-}
-/**
- * Depth-first walk over a node and all of its descendants, nested functions
- * included — this is how a file's function units are collected, because every
- * nested function is its own unit.
- */
-export function walk(root, visit) {
-    visit(root);
-    visitEachChild(root, (child) => {
-        walk(child, visit);
-        return child;
-    });
-}
-/**
- * Walk a function's body for ITS metrics: the body node itself is visited,
- * but a nested function child is not entered — it is a separate unit with its
- * own report entry, and counting it twice would make every metric a lie.
- */
-export function walkOwn(root, visit) {
-    visit(root);
-    visitEachChild(root, (child) => {
-        if (isFunctionLike(child.kind))
-            return child;
-        walkOwn(child, visit);
-        return child;
-    });
-}
-const BREAK_AT_FUNCTION = FUNCTION_KINDS;
-/**
- * Name for a function-like node. Declarations and methods carry one directly;
- * an arrow or function expression takes the name of the variable, property, or
- * parameter it is being assigned to, climbing only up to the enclosing function
- * so a `return () =>` does not borrow its parent's name.
- */
-export function functionName(node) {
-    const own = nodeText(childNode(node, "name"));
-    if (own)
-        return own;
-    let parent = childNode(node, "parent");
-    while (parent && !BREAK_AT_FUNCTION.has(parent.kind)) {
-        if (parent.kind === SyntaxKind.VariableDeclaration || parent.kind === SyntaxKind.PropertyAssignment) {
-            const name = nodeText(childNode(parent, "name"));
-            if (name)
-                return name;
-        }
-        parent = childNode(parent, "parent");
-    }
-    return "<anonymous>";
-}
-function collectFunctions(sourceFile) {
-    const units = [];
-    walk(sourceFile, (node) => {
-        if (!isFunctionLike(node.kind))
-            return;
-        const span = nodeSpan(sourceFile, node);
-        units.push({ name: functionName(node), node, startLine: span.startLine, endLine: span.endLine });
-    });
-    return units;
-}
-/**
- * Parse every file into the Map, keyed by the path it was asked for.
- *
- * A file that fails to read, resolves to no project, or has syntactic
- * diagnostics becomes an error entry — explicit, attributed, and never
- * dropped. One session serves the whole batch; an empty batch never spawns
- * the native compiler at all (an empty directory is a valid analysis).
- */
-export async function parseFiles(paths) {
-    const results = new Map();
-    if (paths.length === 0)
-        return results;
-    const api = new API({ cwd: process.cwd() });
-    try {
-        const snapshot = await api.updateSnapshot({ openFiles: [...paths] });
-        for (const path of paths) {
-            try {
-                const project = await snapshot.getDefaultProjectForFile(path);
-                if (!project) {
-                    results.set(path, { ok: false, error: "no TypeScript project contains this file" });
-                    continue;
-                }
-                const sourceFile = await project.program.getSourceFile(path);
-                if (!sourceFile) {
-                    results.set(path, { ok: false, error: "the compiler could not read this file" });
-                    continue;
-                }
-                const diagnostics = await project.program.getSyntacticDiagnostics(path);
-                if (diagnostics.length > 0) {
-                    const first = diagnostics[0];
-                    const where = lineOf(sourceFile, first.pos);
-                    results.set(path, { ok: false, error: `line ${where}: ${first.text} (TS${first.code})` });
-                    continue;
-                }
-                results.set(path, { ok: true, sourceFile, functions: collectFunctions(sourceFile) });
-            }
-            catch (err) {
-                results.set(path, { ok: false, error: err instanceof Error ? err.message : String(err) });
-            }
-        }
-    }
-    finally {
-        await api.close();
-    }
-    return results;
-}

package/dist/quality/cognitive.js

@@ -1,83 +0,0 @@
-/**
- * Cognitive complexity (Sonar method, simplified) — spec §3.2.
- *
- * What separates this from cyclomatic, and why both exist:
- *
- * 1. **The nesting penalty.** A structural construct costs `1 + depth`, where
- *    depth is how many structural constructs enclose it. Three sibling `if`s
- *    cost 3; three nested `if`s cost 1 + 2 + 3 = 6. `scripts/check-quality.mjs`
- *    asserts both numbers — without the asymmetry this metric is just a second
- *    cyclomatic.
- * 2. **Flat increments.** `else` / `else if` add 1 with no nesting penalty, and
- *    `&&` / `||` / `??` add 1 flat. A ternary adds nothing here (cyclomatic
- *    counts it instead).
- *
- * A chained `else if` is one flat `+1` for the chain link — it does not get a
- * second structural count on top (the parent already paid the marker), and it
- * does not deepen the block it guards: code under `if / else if / else` sits at
- * the same level regardless of how many links the chain has.
- *
- * Nested functions are not entered: they are separate units, reported on
- * their own.
- */
-import { SyntaxKind, visitEachChild } from "typescript/unstable/ast";
-import { childNode, isFunctionLike, isLogicalBinary } from "./ast.js";
-/** Nodes that add `1 + depth` and deepen their children. `try` is deliberately absent (spec §3.2). */
-const STRUCTURAL_KINDS = new Set([
-    SyntaxKind.IfStatement,
-    SyntaxKind.SwitchStatement,
-    SyntaxKind.ForStatement,
-    SyntaxKind.ForInStatement,
-    SyntaxKind.ForOfStatement,
-    SyntaxKind.WhileStatement,
-    SyntaxKind.DoStatement,
-    SyntaxKind.CatchClause,
-]);
-export function cognitive(body) {
-    let score = 0;
-    const enterNode = (node, depth) => {
-        if (isFunctionLike(node.kind))
-            return;
-        if (node.kind === SyntaxKind.IfStatement) {
-            enterIf(node, depth, false);
-            return;
-        }
-        if (STRUCTURAL_KINDS.has(node.kind)) {
-            score += 1 + depth;
-            visitEachChild(node, (child) => {
-                enterNode(child, depth + 1);
-                return child;
-            });
-            return;
-        }
-        // `&&` / `||` / `??` add 1 flat; everything else descends unchanged.
-        if (isLogicalBinary(node))
-            score += 1;
-        visitEachChild(node, (child) => {
-            enterNode(child, depth);
-            return child;
-        });
-    };
-    const enterIf = (node, depth, chained) => {
-        // A chained `else if` was already counted as its parent's flat marker.
-        if (!chained)
-            score += 1 + depth;
-        const condition = childNode(node, "expression");
-        if (condition)
-            enterNode(condition, depth);
-        const then = childNode(node, "thenStatement");
-        if (then)
-            enterNode(then, depth + 1);
-        const alternate = childNode(node, "alternate");
-        if (!alternate)
-            return;
-        // `else` and `else if` both add exactly 1, flat (spec §3.2).
-        score += 1;
-        if (alternate.kind === SyntaxKind.IfStatement)
-            enterIf(alternate, depth, true);
-        else
-            enterNode(alternate, depth + 1);
-    };
-    enterNode(body, 0);
-    return score;
-}

package/dist/quality/cyclomatic.js

@@ -1,30 +0,0 @@
-/**
- * Cyclomatic complexity (McCabe) — spec §3.1.
- *
- * `1 + number of decision points`. A decision point is an `if`, a ternary, a
- * `&&` / `||` / `??` test, a `case` (never `default`, which tests nothing), a
- * loop of any shape, or a `catch`. The walk starts at the function body and
- * stops at nested function boundaries: those are their own units and would
- * otherwise be counted twice.
- */
-import { SyntaxKind } from "typescript/unstable/ast";
-import { isLogicalBinary, walkOwn } from "./ast.js";
-const DECISION_KINDS = new Set([
-    SyntaxKind.IfStatement,
-    SyntaxKind.ConditionalExpression,
-    SyntaxKind.WhileStatement,
-    SyntaxKind.DoStatement,
-    SyntaxKind.ForStatement,
-    SyntaxKind.ForInStatement,
-    SyntaxKind.ForOfStatement,
-    SyntaxKind.CatchClause,
-    SyntaxKind.CaseClause, // DefaultClause is a different kind and is not counted
-]);
-export function cyclomatic(body) {
-    let complexity = 1;
-    walkOwn(body, (node) => {
-        if (DECISION_KINDS.has(node.kind) || isLogicalBinary(node))
-            complexity += 1;
-    });
-    return complexity;
-}

package/dist/quality/halstead.js

@@ -1,83 +0,0 @@
-/**
- * Halstead volume — spec §3.5.
- *
- * `V = N × log2(n)` where `n` is the number of distinct operators and
- * operands and `N` their total occurrences. Volume feeds the Maintainability
- * Index and stands alone as a signal: high volume with low branching is a long
- * but straight function — a helper-extraction candidate.
- *
- * The walk starts at the function body and stops at nested function
- * boundaries, so an inner function's vocabulary is not charged to its parent.
- * An empty body has no vocabulary at all: volume is defined as 0 there, never
- * `log2(0)` — the degenerate-input case `check-quality` pins.
- */
-import { SyntaxKind } from "typescript/unstable/ast";
-import { childNode, nodeText, walkOwn } from "./ast.js";
-/**
- * Kinds Halstead counts as operators. Mapped from the reference implementation
- * (estree names) onto TypeScript's AST: estree's `MemberExpression` is
- * `PropertyAccessExpression` + `ElementAccessExpression` here, and its
- * `LogicalExpression` / `AssignmentExpression` are both `BinaryExpression`,
- * distinguished by the operator token in the key.
- */
-const OPERATOR_KINDS = new Set([
-    SyntaxKind.BinaryExpression,
-    SyntaxKind.PrefixUnaryExpression,
-    SyntaxKind.PostfixUnaryExpression,
-    SyntaxKind.ConditionalExpression,
-    SyntaxKind.CallExpression,
-    SyntaxKind.NewExpression,
-    SyntaxKind.PropertyAccessExpression,
-    SyntaxKind.ElementAccessExpression,
-    SyntaxKind.AwaitExpression,
-    SyntaxKind.YieldExpression,
-    SyntaxKind.SpreadElement,
-    SyntaxKind.IfStatement,
-    SyntaxKind.WhileStatement,
-    SyntaxKind.DoStatement,
-    SyntaxKind.ForStatement,
-    SyntaxKind.ForInStatement,
-    SyntaxKind.ForOfStatement,
-    SyntaxKind.SwitchStatement,
-    SyntaxKind.ReturnStatement,
-    SyntaxKind.ThrowStatement,
-    SyntaxKind.TryStatement,
-    SyntaxKind.BreakStatement,
-    SyntaxKind.ContinueStatement,
-]);
-/**
- * Literal kinds counted as operands. `true` / `false` / `null` are keyword
- * tokens in this AST and carry no stored text, so they are deliberately not in
- * the set rather than listed and silently skipped.
- */
-const LITERAL_KINDS = new Set([SyntaxKind.StringLiteral, SyntaxKind.NumericLiteral, SyntaxKind.BigIntLiteral, SyntaxKind.RegularExpressionLiteral, SyntaxKind.NoSubstitutionTemplateLiteral]);
-function count(into, key) {
-    into.set(key, (into.get(key) ?? 0) + 1);
-}
-export function halsteadVolume(body) {
-    const operators = new Map();
-    const operands = new Map();
-    walkOwn(body, (node) => {
-        if (OPERATOR_KINDS.has(node.kind)) {
-            const operator = childNode(node, "operatorToken");
-            count(operators, SyntaxKind[node.kind] + (operator ? `:${SyntaxKind[operator.kind]}` : ""));
-            return;
-        }
-        const text = nodeText(node);
-        if (text === undefined)
-            return;
-        if (node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.PrivateIdentifier)
-            count(operands, `id:${text}`);
-        else if (LITERAL_KINDS.has(node.kind))
-            count(operands, `lit:${text}`);
-    });
-    const vocabulary = operators.size + operands.size;
-    if (vocabulary === 0)
-        return 0;
-    let total = 0;
-    for (const seen of operators.values())
-        total += seen;
-    for (const seen of operands.values())
-        total += seen;
-    return Math.round(total * Math.log2(vocabulary) * 100) / 100;
-}