@smeltjs/core 0.1.0

package/dist/cli/args.js

@@ -0,0 +1,308 @@
+import { parseArgs } from 'node:util';
+import { SUPPORTED_LANGUAGES } from '../detect.js';
+import { CliUsageError } from '../errors.js';
+import { isStrategy, STRATEGIES } from '../plan/planners.js';
+import { STRUCTURAL_LANGUAGES } from '../plan/structural.js';
+/** The command people type. Independent of the package name. */
+export const CLI_NAME = 'smelt';
+/**
+ * Argument parsing on `node:util.parseArgs` — stable since Node 20, which `engines`
+ * already requires.
+ *
+ * The CLI ships as a `bin` on the library rather than as a second package, and this
+ * import is the reason that is free: it adds no dependency, so the argument the second
+ * package existed to win — keeping the library's dependency tree small — is already won.
+ *
+ * @throws {CliUsageError} on anything the user got wrong. Never guesses.
+ */
+export function parseSmeltArgs(argv) {
+    let parsed;
+    try {
+        parsed = parseArgs({
+            args: [...argv],
+            allowPositionals: true,
+            strict: true,
+            options: {
+                budget: { type: 'string' },
+                focus: { type: 'string', multiple: true },
+                language: { type: 'string' },
+                strategy: { type: 'string' },
+                ignore: { type: 'string', multiple: true },
+                cache: { type: 'string' },
+                json: { type: 'boolean' },
+                reconstruct: { type: 'boolean' },
+                help: { type: 'boolean', short: 'h' },
+                version: { type: 'boolean' },
+            },
+        });
+    }
+    catch (cause) {
+        throw new CliUsageError(`${CLI_NAME}: ${cause instanceof Error ? cause.message : String(cause)}\n` +
+            `Run \`${CLI_NAME} --help\`.`);
+    }
+    const { values, positionals } = parsed;
+    if (values.help === true)
+        return { mode: 'help', focus: [], json: false };
+    if (values.version === true) {
+        return { mode: 'version', focus: [], json: false };
+    }
+    if (positionals[0] === 'init') {
+        // `smelt init` is a subcommand, so a file literally named `init` needs `./init`.
+        if (positionals.length > 1) {
+            throw new CliUsageError(`${CLI_NAME}: init takes no further arguments.`);
+        }
+        const flags = Object.entries(values).filter(([, value]) => value !== undefined);
+        if (flags.length > 0) {
+            throw new CliUsageError(`${CLI_NAME}: init is interactive and takes no flags ` +
+                `(got --${flags.map(([name]) => name).join(', --')}). It asks instead.`);
+        }
+        return { mode: 'init', focus: [], json: false };
+    }
+    if (positionals[0] === 'map') {
+        // `smelt map` is a subcommand, so a file literally named `map` needs `./map`.
+        return parseMapArgs(values, positionals);
+    }
+    if (positionals[0] === 'retrieve') {
+        // A subcommand, like map and init — a file literally named `retrieve` needs `./retrieve`.
+        return parseRetrieveArgs(values, positionals);
+    }
+    if (positionals[0] === 'stats') {
+        return parseStatsArgs(values, positionals);
+    }
+    // These two belong to `smelt map` alone; silently ignoring a flag the user typed
+    // would be a setting they believed was in force.
+    if (values.ignore !== undefined || values.cache !== undefined) {
+        throw new CliUsageError(`${CLI_NAME}: --ignore and --cache belong to \`${CLI_NAME} map\`. A single-blob ` +
+            `run reads one file or stdin; there is no tree to walk and nothing to cache.`);
+    }
+    if (positionals.length > 1) {
+        throw new CliUsageError(`${CLI_NAME}: expected at most one file, got ${String(positionals.length)} ` +
+            `(${positionals.join(', ')}). smelt reads one blob at a time.`);
+    }
+    const file = positionals[0];
+    if (values.reconstruct === true) {
+        if (values.budget !== undefined) {
+            throw new CliUsageError(`${CLI_NAME}: --budget makes no sense with --reconstruct. Reconstruction puts ` +
+                `every byte back; there is nothing to fit.`);
+        }
+        return {
+            mode: 'reconstruct',
+            ...(file === undefined ? {} : { file }),
+            focus: [],
+            json: false,
+        };
+    }
+    const budgetBytes = parseBudget(values.budget);
+    const chosenStrategy = strategy(values.strategy);
+    return {
+        mode: 'smelt',
+        ...(file === undefined ? {} : { file }),
+        ...(budgetBytes === undefined ? {} : { budgetBytes }),
+        focus: values.focus ?? [],
+        ...(values.language === undefined ? {} : { language: language(values.language) }),
+        ...(chosenStrategy === undefined ? {} : { strategy: chosenStrategy }),
+        json: values.json === true,
+    };
+}
+/**
+ * The `map` subcommand's own validation: exactly one directory, the map-only flags,
+ * and the same budget rules as everything else — a missing `--budget` is not an
+ * error *here* (the config may carry `defaultBudgetBytes`), a malformed one always is.
+ */
+function parseMapArgs(values, positionals) {
+    if (positionals.length < 2) {
+        throw new CliUsageError(`${CLI_NAME}: map needs the directory to read.\n` +
+            `  ${CLI_NAME} map <dir> --budget <bytes> [--focus <term>]...`);
+    }
+    if (positionals.length > 2) {
+        throw new CliUsageError(`${CLI_NAME}: map takes exactly one directory, got ` +
+            `${String(positionals.length - 1)} (${positionals.slice(1).join(', ')}).`);
+    }
+    if (values.reconstruct === true) {
+        throw new CliUsageError(`${CLI_NAME}: --reconstruct makes no sense with map. A map elides nothing, so ` +
+            `there is nothing to put back.`);
+    }
+    if (values.language !== undefined || values.strategy !== undefined) {
+        throw new CliUsageError(`${CLI_NAME}: --language and --strategy apply to single-blob runs. map reads a ` +
+            `whole tree, detects each file's language itself, and is not a planner ` +
+            `strategy — it returns a map, not an elision plan.`);
+    }
+    const budgetBytes = parseBudget(values.budget);
+    return {
+        mode: 'map',
+        dir: positionals[1],
+        ...(budgetBytes === undefined ? {} : { budgetBytes }),
+        focus: values.focus ?? [],
+        ignore: values.ignore ?? [],
+        ...(values.cache === undefined ? {} : { cacheDir: values.cache }),
+        json: values.json === true,
+    };
+}
+/**
+ * `retrieve` takes the hash and nothing else. Every flag is refused rather than
+ * ignored — the command prints the exact original bytes on stdout and nothing more,
+ * so a flag that changed the output would break the one contract it has, and a flag
+ * silently dropped would be a setting the user believed was in force. In particular
+ * there is no `--json`: the bytes ARE the output, and wrapping them would re-encode
+ * what the command exists to hand back verbatim.
+ */
+function parseRetrieveArgs(values, positionals) {
+    const flags = Object.entries(values).filter(([, value]) => value !== undefined);
+    if (flags.length > 0) {
+        throw new CliUsageError(`${CLI_NAME}: retrieve takes no flags (got --${flags.map(([name]) => name).join(', --')}). ` +
+            `It prints the exact original bytes for one hash, nothing else — even --json ` +
+            `would wrap what must come back verbatim.`);
+    }
+    if (positionals.length !== 2) {
+        throw new CliUsageError(`${CLI_NAME}: retrieve needs exactly one hash — the one a marker printed.\n` +
+            `  ${CLI_NAME} retrieve 84998967370f38bc`);
+    }
+    return { mode: 'retrieve', hash: positionals[1] };
+}
+/** `stats` reads counters; `--json` is its only flag, everything else is refused. */
+function parseStatsArgs(values, positionals) {
+    if (positionals.length > 1) {
+        throw new CliUsageError(`${CLI_NAME}: stats takes no further arguments, got ` +
+            `${positionals.slice(1).join(', ')}. It reports on the one configured store.`);
+    }
+    const flags = Object.entries(values).filter(([name, value]) => value !== undefined && name !== 'json');
+    if (flags.length > 0) {
+        throw new CliUsageError(`${CLI_NAME}: stats takes only --json ` +
+            `(got --${flags.map(([name]) => name).join(', --')}). It reads counters; there ` +
+            `is nothing to budget, focus or plan.`);
+    }
+    return { mode: 'stats', json: values['json'] === true };
+}
+/**
+ * `--budget` has no built-in default, for the same reason `smelt()` has none: a budget
+ * smelt invented would be smelt deciding how much of the caller's context to throw
+ * away, silently, at a number nobody chose. A *missing* flag is not an error here,
+ * though — `smelt.config.json` may carry a `defaultBudgetBytes` the user chose
+ * explicitly, and the runner errors only when neither exists. A malformed value is
+ * always an error.
+ */
+function parseBudget(raw) {
+    if (raw === undefined)
+        return undefined;
+    if (!/^\d+$/.test(raw)) {
+        throw new CliUsageError(`${CLI_NAME}: --budget must be a whole number of bytes, got "${raw}".`);
+    }
+    const value = Number(raw);
+    if (value <= 0) {
+        throw new CliUsageError(`${CLI_NAME}: --budget must be greater than zero, got "${raw}".`);
+    }
+    return value;
+}
+function language(raw) {
+    const known = [...SUPPORTED_LANGUAGES, 'unknown'];
+    if (!known.includes(raw)) {
+        throw new CliUsageError(`${CLI_NAME}: unknown --language "${raw}". Known: ${known.join(', ')}.`);
+    }
+    return raw;
+}
+/** Membership in the {@link PLANNERS} registry is the whole validation. */
+function strategy(raw) {
+    if (raw === undefined)
+        return undefined;
+    if (!isStrategy(raw)) {
+        throw new CliUsageError(`${CLI_NAME}: unknown --strategy "${raw}". Known: ${STRATEGIES.join(', ')}.`);
+    }
+    return raw;
+}
+/** The help text. Also the closest thing the CLI has to documentation. */
+export function cliUsage() {
+    return `${CLI_NAME} — shrink text for a model, without lying about what was removed.
+
+USAGE
+  ${CLI_NAME} <file> --budget <bytes> [--focus <term>]...
+  ${CLI_NAME} --budget <bytes> [--focus <term>]... < input
+  ${CLI_NAME} map <dir> --budget <bytes> [--focus <term>]... [--ignore <entry>]... [--cache <dir>]
+  ${CLI_NAME} retrieve <hash>
+  ${CLI_NAME} stats [--json]
+  ${CLI_NAME} --reconstruct <result.json>
+  ${CLI_NAME} --reconstruct < result.json
+  ${CLI_NAME} init
+
+Smelted text goes to stdout and the report goes to stderr, so the two can be piped
+apart:  ${CLI_NAME} big.log --budget 4000 > small.log
+
+CONFIG
+  ${CLI_NAME} init walks you through writing a smelt.config.json (and optional typed
+  stubs), one question at a time; nothing is written until a final confirm. Runs read
+  the nearest smelt.config.json, walking up from the working directory, for DEFAULTS
+  only — budget, strategy, store. An explicit flag always wins, and a malformed config
+  is a usage error, never silently ignored.
+
+MAP
+  ${CLI_NAME} map <dir> renders a ranked symbol map of a whole repository — modelled
+  on Aider's repo-map (aider.chat/docs/repomap.html, design by Paul Gauthier) — to
+  stdout, with a short report on stderr. Local files only: symlinks are never
+  followed, binary files are skipped, and the map writes nothing to disk unless
+  --cache names a directory. Every included symbol carries a receipt: its
+  definition site and the measured reference counts that ranked it. Unlike a
+  smelt run, map never exits
+  1: a plan can come back over budget because ${CLI_NAME} refuses to cut regions you
+  asked to keep, but the map fits itself to the budget by construction — symbols
+  are appended in rank order until the next line would not fit.
+
+RETRIEVE & STATS
+  Every marker carries the hash of the bytes it replaced — <<smelt/v1: … —
+  retrieve("hash")>> — and the marker's retrieve("hash") is this command:
+  ${CLI_NAME} retrieve <hash> prints the exact original bytes on stdout, byte for
+  byte, nothing else. That closes the loop from pure shell: an agent that got a
+  marker asks for the bytes back with a command instead of a tool call, and the
+  retrieval is counted — asking for material back is exactly what the expansion
+  rate measures. An unknown hash and damaged bytes are distinct refusals (exit 3):
+  "never elided" and "the store was corrupted" call for different responses.
+
+  ${CLI_NAME} stats prints the same store's counters, one \`name value\` per line —
+  elisionsStored, bytesStored, retrieveCalls, uniqueRetrieved, expansionRate,
+  allElisionsRetrieved — and reading them is NOT counted as a retrieval. --json
+  emits the RetrieveStats verbatim in its own versioned envelope.
+
+  Both need somewhere for elisions to outlive the run that made them: a
+  smelt.config.json with a directory store (\`${CLI_NAME} init\` writes one). With a
+  memory store — or no config — every run's store dies with its process, so there
+  is nothing to retrieve across runs, and that is a usage error rather than a
+  quiet empty answer.
+
+OPTIONS
+  --budget <bytes>     Required, unless smelt.config.json sets defaultBudgetBytes.
+                       Soft ceiling for the output, in UTF-8 bytes (for map: a hard
+                       ceiling, met by construction). No built-in default: a budget
+                       ${CLI_NAME} invented would decide for you.
+  --focus <term>       What you were looking for. Repeatable. Matching regions and
+                       their context survive; the runs between them collapse. For
+                       map: symbols matching a term (by name or path) are promoted
+                       to the front of the fill order, ranks unchanged.
+  --language <id>      Override detection. One of: ${[...SUPPORTED_LANGUAGES, 'unknown'].join(', ')}.
+  --strategy <id>      ${STRATEGIES.join(' or ')}. Defaults to lexical, unless
+                       smelt.config.json says otherwise. structural parses
+                       ${STRUCTURAL_LANGUAGES.join(', ')};
+                       any other language is refused, never approximated.
+  --ignore <entry>     map only. Repeatable. Replaces the default ignore list
+                       (.git, node_modules): a bare name matches any path segment,
+                       an entry containing / is a root-relative prefix.
+  --cache <dir>        map only. Directory for the tags cache, keyed by content
+                       hash. Only when given does the map write to disk at all.
+  --json               Print a JSON envelope on stdout instead of the text:
+                       { format, result, elided } for a smelt run — \`result\` is
+                       the SmeltResult verbatim, \`elided\` carries the bytes, so
+                       the envelope can be reconstructed; feed it back with
+                       --reconstruct. For map: { format, map }, the RepoMap
+                       structure verbatim.
+  --reconstruct        Read a --json envelope and print the original text, byte for
+                       byte. This is Law 3 you can run from a shell.
+  -h, --help           This text.
+  --version            The package version.
+
+EXIT CODES
+  0  under budget (map is always under budget by construction)
+  1  over budget — the plan did not fit, and the report says so. Never silent.
+     map never exits 1; see MAP above.
+  2  usage error
+  3  smelt refused (a SmeltError: an unbuilt planner, an unknown hash, a corrupt store)
+  4  unexpected internal error
+`;
+}
+//# sourceMappingURL=args.js.map

package/dist/cli/args.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"args.js","sourceRoot":"","sources":["../../src/cli/args.ts"],"names":[],"mappings":"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"}

package/dist/cli/bin.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=bin.d.ts.map

package/dist/cli/bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../../src/cli/bin.ts"],"names":[],"mappings":""}

package/dist/cli/bin.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+import { readFileSync, readSync } from 'node:fs';
+import { isatty } from 'node:tty';
+import process from 'node:process';
+import { EXIT, runCli } from './run.js';
+/**
+ * The `smelt` binary: the thinnest possible shell around {@link runCli}.
+ *
+ * Everything decidable lives in `run.ts`, which returns an exit code instead of
+ * calling `exit`, so the whole CLI is testable in-process. This file owns only the
+ * things that cannot be tested without a real process: the shebang, stdin on fd 0, and
+ * the exit code itself. `test/cli-bin.test.ts` spawns the *built* binary for exactly
+ * those things — an in-process suite cannot see them.
+ *
+ * Two deliberate subtleties around fd 0:
+ *
+ *  - **fd 0 may be non-blocking, and must still be read to EOF.** Two separate ways
+ *    that happens in the wild: merely accessing `process.stdin` (even `.isTTY`) makes
+ *    Node flip fd 0 into non-blocking mode, and a parent that spawned this process
+ *    with piped stdio may hand over a socketpair that was *born* non-blocking. Either
+ *    way a one-shot `readFileSync(0)` throws `EAGAIN` whenever the producer is slower
+ *    than Node's startup — `(sleep 1; echo hi) | smelt --budget 100` used to die with
+ *    an internal error. So: the TTY check is `tty.isatty(0)` (a plain syscall, no
+ *    stream initialization), `process.stdin` is only handed over lazily to the one
+ *    mode that needs a stream (`init`), and the read itself retries `EAGAIN` with a
+ *    synchronous back-off until EOF.
+ *  - **Bytes that are not UTF-8 are refused, never mangled.** Decoding invalid bytes
+ *    would silently replace them with U+FFFD, and the result would still smelt,
+ *    round-trip, and verify — of the wrong bytes. That violates the reversibility
+ *    story at its root, so the binary refuses (exit code {@link EXIT.refused}) and
+ *    names the first offending byte offset instead.
+ */
+/** Reading fd 0 synchronously is the whole of "works in a pipe", with no stream plumbing. */
+function readStdin() {
+    if (isatty(0)) {
+        process.stderr.write('smelt: no input. Pass a file, or pipe text in:\n' +
+            '  smelt src/server.ts --budget 4000\n' +
+            '  smelt --budget 4000 --focus TypeError < build.log\n');
+        process.exit(EXIT.usage);
+    }
+    const bytes = readAllOfFd0();
+    const offset = firstInvalidUtf8Offset(bytes);
+    if (offset !== -1) {
+        process.stderr.write(`smelt: stdin is not valid UTF-8 — first invalid byte at offset ${String(offset)} ` +
+            `(0x${bytes[offset].toString(16).padStart(2, '0')}). Decoding it would silently ` +
+            `replace bytes with U+FFFD, and the "original" smelt could then reconstruct would ` +
+            `not be your original. Refusing instead.\n`);
+        process.exit(EXIT.refused);
+    }
+    return bytes.toString('utf8');
+}
+/** `Atomics.wait` is the only dependency-free synchronous sleep Node offers. */
+const sleeper = new Int32Array(new SharedArrayBuffer(4));
+/**
+ * Every byte of fd 0, to EOF, whether the descriptor is blocking (a shell pipe, a
+ * redirected file) or non-blocking (a socketpair from a spawning parent). `EAGAIN`
+ * means "no bytes yet, not EOF" — wait briefly and try again; only a zero-byte read
+ * (or Windows' `EOF` on a closed pipe) ends the loop.
+ */
+function readAllOfFd0() {
+    const chunks = [];
+    const chunk = Buffer.alloc(1 << 16);
+    for (;;) {
+        let bytesRead;
+        try {
+            bytesRead = readSync(0, chunk, 0, chunk.length, null);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 'EAGAIN') {
+                Atomics.wait(sleeper, 0, 0, 10); // producer not ready — 10ms, then retry
+                continue;
+            }
+            if (code === 'EOF')
+                break; // Windows raises EOF instead of returning 0
+            throw error;
+        }
+        if (bytesRead === 0)
+            break;
+        chunks.push(Buffer.from(chunk.subarray(0, bytesRead)));
+    }
+    return Buffer.concat(chunks);
+}
+/**
+ * The byte offset where `bytes` stops being well-formed UTF-8, or `-1` when it is
+ * well-formed throughout. Implements the WHATWG/Unicode table exactly: continuation
+ * ranges tightened for E0/ED/F0/F4 so overlongs, surrogates and > U+10FFFF are
+ * invalid — the same sequences `Buffer.prototype.toString` would fold into U+FFFD.
+ */
+function firstInvalidUtf8Offset(bytes) {
+    let i = 0;
+    while (i < bytes.length) {
+        const lead = bytes[i];
+        if (lead <= 0x7f) {
+            i += 1;
+            continue;
+        }
+        let length;
+        let firstLow = 0x80;
+        let firstHigh = 0xbf;
+        if (lead >= 0xc2 && lead <= 0xdf) {
+            length = 2;
+        }
+        else if (lead >= 0xe0 && lead <= 0xef) {
+            length = 3;
+            if (lead === 0xe0)
+                firstLow = 0xa0; // overlong
+            if (lead === 0xed)
+                firstHigh = 0x9f; // UTF-16 surrogates
+        }
+        else if (lead >= 0xf0 && lead <= 0xf4) {
+            length = 4;
+            if (lead === 0xf0)
+                firstLow = 0x90; // overlong
+            if (lead === 0xf4)
+                firstHigh = 0x8f; // above U+10FFFF
+        }
+        else {
+            return i; // a bare continuation byte, or C0/C1/F5–FF — invalid as a lead
+        }
+        if (i + length > bytes.length)
+            return i; // truncated sequence
+        for (let k = 1; k < length; k += 1) {
+            const continuation = bytes[i + k];
+            const low = k === 1 ? firstLow : 0x80;
+            const high = k === 1 ? firstHigh : 0xbf;
+            if (continuation < low || continuation > high)
+                return i;
+        }
+        i += length;
+    }
+    return -1;
+}
+/** `--version` should agree with the manifest, not with a second copy of the number. */
+function packageVersion() {
+    const manifest = readFileSync(new URL('../../package.json', import.meta.url), 'utf8');
+    const parsed = JSON.parse(manifest);
+    return parsed.version ?? '0.0.0';
+}
+try {
+    process.exitCode = await runCli(process.argv.slice(2), {
+        stdout: (text) => void process.stdout.write(text),
+        stderr: (text) => void process.stderr.write(text),
+        stdin: readStdin,
+        version: packageVersion(),
+        cwd: process.cwd(),
+        // `smelt init` reads answers line by line, so it gets the stream, not readStdin's
+        // one-shot slurp of fd 0. A *getter*, because touching `process.stdin` at all
+        // flips fd 0 into non-blocking mode and breaks readStdin's readFileSync(0) for
+        // every other mode — only the `init` branch of runCli ever reads this property.
+        get initInput() {
+            return process.stdin;
+        },
+    });
+}
+catch (error) {
+    process.stderr.write(`smelt: unexpected internal error — this is a bug, please report it.\n` +
+        `${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`);
+    process.exitCode = EXIT.unexpected;
+}
+//# sourceMappingURL=bin.js.map

package/dist/cli/bin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.js","sourceRoot":"","sources":["../../src/cli/bin.ts"],"names":[],"mappings":"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"}

package/dist/cli/config.d.ts

@@ -0,0 +1,73 @@
+import type { Strategy } from '../plan/planners.ts';
+/**
+ * `smelt.config.json` — CLI defaults, and nothing more.
+ *
+ * This file exists so `smelt` can be run without retyping the same flags, and it is
+ * deliberately a *CLI* concern: the programmatic API never reads it. A library that
+ * reads config files off the caller's disk is a library whose behaviour depends on
+ * where it was invoked from, which is exactly the class of invisible input smelt
+ * refuses. `createSmelter()` takes explicit arguments; the CLI translates this file
+ * into those arguments, and explicit flags always win over it.
+ *
+ * The schema is versioned (`"smeltConfig": 1`) for the same reason the marker and the
+ * `--json` envelope are: files outlive the binaries that wrote them, and a mismatch
+ * must be identifiable rather than half-understood. Parsing is strict — an unknown
+ * key, a wrong type, or an unknown version is a {@link CliUsageError}, never a shrug.
+ * A config the CLI silently ignored would be a budget the user *thought* they set.
+ */
+/** The file name looked for, from the working directory upward. */
+export declare const CONFIG_FILE_NAME = "smelt.config.json";
+/** The schema version this build reads and writes. */
+export declare const CONFIG_VERSION = 1;
+/** Where the CLI's elision store lives between runs. */
+export type SmeltConfigStore = {
+    readonly kind: 'memory';
+} | {
+    readonly kind: 'directory';
+    /** Resolved relative to the directory holding the config file, not the cwd. */
+    readonly path: string;
+};
+/** The parsed shape of `smelt.config.json`. Every field beyond the version is optional. */
+export interface SmeltConfig {
+    readonly smeltConfig: typeof CONFIG_VERSION;
+    /** Used when a `smelt` run omits `--budget`. UTF-8 bytes, like every smelt budget. */
+    readonly defaultBudgetBytes?: number;
+    /** Used when a run omits `--strategy`. Validated against the {@link PLANNERS} registry. */
+    readonly strategy?: Strategy;
+    /** Used for every run; there is no store flag. Defaults to memory when absent. */
+    readonly store?: SmeltConfigStore;
+}
+/** A config plus where it was found — the path matters for resolving `store.path`. */
+export interface LoadedConfig {
+    readonly path: string;
+    readonly config: SmeltConfig;
+}
+/**
+ * The nearest `smelt.config.json`, walking up from `cwd` to the filesystem root —
+ * the same discovery shape as `package.json`, so a config at a repo root covers the
+ * whole tree. `undefined` when there is none, which is not an error: flags alone are
+ * a complete interface.
+ */
+export declare function findConfigFile(cwd: string): string | undefined;
+/**
+ * Find and parse the nearest config. `undefined` when no file exists; a file that
+ * exists but is malformed **throws** — see {@link parseConfig}. The distinction is the
+ * point: "no config" is a fine state, "a config you cannot have meant" is not.
+ *
+ * @throws {CliUsageError} when a config file exists and is malformed.
+ */
+export declare function loadNearestConfig(cwd: string): LoadedConfig | undefined;
+/**
+ * Parse and validate one config file, strictly.
+ *
+ * Strict means: unknown keys are refused, not skipped. A typo'd `defaultBudgetByte`
+ * that parsed cleanly would leave the user believing a default was set while every
+ * run ignored it — a config error whose failure mode is *silence*, which is the one
+ * failure shape this project refuses everywhere else too.
+ *
+ * @throws {CliUsageError} naming the file and the exact problem.
+ */
+export declare function parseConfig(text: string, path: string): SmeltConfig;
+/** `store.path` is relative to the config file, so the config works from any cwd. */
+export declare function resolveStorePath(loaded: LoadedConfig, path: string): string;
+//# sourceMappingURL=config.d.ts.map

package/dist/cli/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/cli/config.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAIpD;;;;;;;;;;;;;;;GAeG;AAEH,mEAAmE;AACnE,eAAO,MAAM,gBAAgB,sBAAsB,CAAC;AAEpD,sDAAsD;AACtD,eAAO,MAAM,cAAc,IAAI,CAAC;AAEhC,wDAAwD;AACxD,MAAM,MAAM,gBAAgB,GACxB;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAC3B;IACE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,CAAC;AAEN,2FAA2F;AAC3F,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,WAAW,EAAE,OAAO,cAAc,CAAC;IAC5C,sFAAsF;IACtF,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IACrC,2FAA2F;IAC3F,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAC7B,kFAAkF;IAClF,QAAQ,CAAC,KAAK,CAAC,EAAE,gBAAgB,CAAC;CACnC;AAED,sFAAsF;AACtF,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;CAC9B;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAS9D;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAIvE;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,WAAW,CA6DnE;AA6BD,qFAAqF;AACrF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE3E"}