monomind 2.7.12 → 2.7.14

package/packages/@monomind/cli/dist/src/parser.js

@@ -1,651 +0,0 @@
-/**
- * CLI Command Parser
- * Advanced argument parsing with validation and type coercion
- */
-export class CommandParser {
-    options;
-    commands = new Map();
-    globalOptions = [];
-    constructor(options = {}) {
-        this.options = {
-            stopAtFirstNonFlag: false,
-            allowUnknownFlags: false,
-            ...options
-        };
-        this.initializeGlobalOptions();
-    }
-    initializeGlobalOptions() {
-        this.globalOptions = [
-            {
-                name: 'help',
-                short: 'h',
-                description: 'Show help information',
-                type: 'boolean',
-                default: false
-            },
-            {
-                name: 'version',
-                short: 'V',
-                description: 'Show version number',
-                type: 'boolean',
-                default: false
-            },
-            {
-                name: 'verbose',
-                short: 'v',
-                description: 'Enable verbose output',
-                type: 'boolean',
-                default: false
-            },
-            {
-                name: 'quiet',
-                short: 'Q',
-                description: 'Suppress non-essential output',
-                type: 'boolean',
-                default: false
-            },
-            {
-                name: 'config',
-                short: 'c',
-                description: 'Path to configuration file',
-                type: 'string'
-            },
-            {
-                name: 'format',
-                // Note: removed global short flag 'f' — it collides with 50+ subcommand
-                // flags (force, follow, file, feature, full) causing unpredictable behavior
-                // depending on parser resolution order (#1425). Use --format instead.
-                description: 'Output format (text, json, table)',
-                type: 'string',
-                default: 'text',
-                choices: ['text', 'json', 'table']
-            },
-            {
-                name: 'color',
-                description: 'Enable colored output (use --no-color to disable)',
-                type: 'boolean',
-                default: true
-            },
-            {
-                name: 'interactive',
-                short: 'i',
-                description: 'Enable interactive mode',
-                type: 'boolean',
-                default: true
-            },
-            {
-                name: 'update',
-                description: 'Check for updates on startup (use --no-update to disable)',
-                type: 'boolean',
-                default: true
-            }
-        ];
-    }
-    registerCommand(command) {
-        this.commands.set(command.name, command);
-        if (command.aliases) {
-            for (const alias of command.aliases) {
-                this.commands.set(alias, command);
-            }
-        }
-    }
-    getCommand(name) {
-        return this.commands.get(name);
-    }
-    getAllCommands() {
-        // Return unique commands (filter out aliases)
-        const seen = new Set();
-        return Array.from(this.commands.values()).filter(cmd => {
-            if (seen.has(cmd))
-                return false;
-            seen.add(cmd);
-            return true;
-        });
-    }
-    /**
-     * Reserved keys that would either pollute the prototype chain (`__proto__`,
-     * `constructor`, `prototype`) or shadow `Object.prototype` methods that
-     * downstream consumers commonly call (`hasOwnProperty`, `toString`,
-     * `valueOf`, `isPrototypeOf`, `propertyIsEnumerable`). All are rejected.
-     */
-    static RESERVED_FLAG_KEYS = new Set([
-        '__proto__', 'constructor', 'prototype',
-        'hasOwnProperty', 'toString', 'valueOf', 'isPrototypeOf', 'propertyIsEnumerable',
-    ]);
-    setFlagSafe(flags, key, value) {
-        if (CommandParser.RESERVED_FLAG_KEYS.has(key))
-            return;
-        flags[key] = value;
-    }
-    /**
-     * Merge a single parsed flag (or set of `_` positionals) into the
-     * accumulated result flags, collecting repeats into an array instead of
-     * overwriting. Declared `type: 'array'` options always end up as an array
-     * (even a single occurrence); any other repeated flag also becomes an
-     * array on its second occurrence rather than silently dropping the first
-     * value.
-     */
-    mergeParsedFlags(into, from, arrayFlags, booleanFlags) {
-        for (const key of Object.keys(from)) {
-            if (key === '_') {
-                into._.push(...from._);
-                continue;
-            }
-            if (CommandParser.RESERVED_FLAG_KEYS.has(key))
-                continue;
-            const incoming = from[key];
-            if (Array.isArray(into[key])) {
-                into[key].push(...[].concat(incoming).map(String));
-            }
-            else if (into[key] !== undefined && booleanFlags?.has(key)) {
-                // Declared boolean flag repeated (e.g. `--dry-run --dry-run`) — last
-                // value wins instead of promoting to an array. Callers throughout the
-                // codebase check booleans with `flags['x'] === true`; an array value
-                // would silently fail that check (e.g. guidance.ts's --dry-run,
-                // which guards a destructive write).
-                into[key] = incoming;
-            }
-            else if (into[key] !== undefined) {
-                // Repeated flag not previously an array — promote to array so the
-                // earlier value isn't lost.
-                into[key] = [String(into[key]), String(incoming)];
-            }
-            else if (arrayFlags.has(key)) {
-                // First occurrence of a declared array flag — still wrap in an array.
-                into[key] = [String(incoming)];
-            }
-            else {
-                into[key] = incoming;
-            }
-        }
-    }
-    parse(args) {
-        const result = {
-            command: [],
-            flags: { _: [] },
-            positional: [],
-            raw: [...args]
-        };
-        // Pass 1: Identify the command and its subcommand chain (skip flags).
-        //
-        // This walks the WHOLE tree, not just one subcommand level. It used to
-        // stop after depth 1 (`resolvedCmd` + `resolvedSub`), so options declared
-        // on a subcommand nested 2+ levels deep were invisible to the alias and
-        // boolean scans below: `hooks worker run -n audit` resolved `-n` from the
-        // global last-write-wins alias pool (where it happened to mean `--limit`)
-        // instead of `run`'s own `-n, --name`, and the command then failed with
-        // "Worker name is required" while `--name audit` worked.
-        const scopeChain = [];
-        let resolvedCmd;
-        for (const arg of args) {
-            if (arg.startsWith('-'))
-                continue;
-            if (!resolvedCmd) {
-                const top = this.commands.get(arg);
-                if (top) {
-                    resolvedCmd = top;
-                    scopeChain.push(top);
-                }
-                continue;
-            }
-            const next = resolvedCmd.subcommands?.find(sc => sc.name === arg || sc.aliases?.includes(arg));
-            if (next) {
-                resolvedCmd = next;
-                scopeChain.push(next);
-            }
-        }
-        // Pass 2: Build aliases scoped to the resolved subcommand chain.
-        // Subcommand-specific aliases take priority over global ones, and the
-        // deepest subcommand wins over its ancestors. The top-level command is
-        // excluded when it has a resolved subcommand (preserving the previous
-        // `resolvedSub || resolvedCmd` precedence exactly for depth <= 1).
-        const scope = scopeChain.length > 1 ? scopeChain.slice(1) : scopeChain;
-        const aliases = this.buildScopedAliases(scope);
-        const booleanFlags = this.getScopedBooleanFlags(scope);
-        const arrayFlags = this.getScopedArrayFlags(scope);
-        let i = 0;
-        let parsingFlags = true;
-        // Once a non-flag token has been seen that is NOT a registered command,
-        // no later token may be promoted to "the command". Without this, an
-        // unrecognised first token was silently discarded and the SECOND token
-        // dispatched instead — `monomind typo status` ran `status`. A mistyped
-        // command must never run something the user did not ask for.
-        let commandSearchClosed = false;
-        while (i < args.length) {
-            const arg = args[i];
-            // Check for end of flags marker
-            if (arg === '--') {
-                parsingFlags = false;
-                i++;
-                continue;
-            }
-            // Handle flags
-            if (parsingFlags && arg.startsWith('-')) {
-                const parseResult = this.parseFlag(args, i, aliases, booleanFlags);
-                // Merge into result flags. A plain Object.assign here would silently
-                // drop earlier values whenever the same flag is passed more than once
-                // (`-p a=1 -p b=2` kept only `b=2`) — options declared `type: 'array'`
-                // (e.g. browse-action.ts's --params/-p, swarm.ts) are meant to
-                // collect every occurrence, and even a flag NOT declared array
-                // shouldn't silently lose data on repetition.
-                this.mergeParsedFlags(result.flags, parseResult.flags, arrayFlags, booleanFlags);
-                i = parseResult.nextIndex;
-                continue;
-            }
-            // Handle positional arguments
-            if (result.command.length === 0 && !commandSearchClosed && this.commands.has(arg)) {
-                // This is a command
-                result.command.push(arg);
-                // Check for subcommand (level 1)
-                const cmd = this.commands.get(arg);
-                resolvedCmd = cmd;
-                if (cmd?.subcommands && i + 1 < args.length) {
-                    const nextArg = args[i + 1];
-                    const subCmd = cmd.subcommands.find(sc => sc.name === nextArg || sc.aliases?.includes(nextArg));
-                    if (subCmd) {
-                        result.command.push(nextArg);
-                        resolvedCmd = subCmd;
-                        i++;
-                        // Check for nested subcommand (level 2)
-                        if (subCmd.subcommands && i + 1 < args.length) {
-                            const nestedArg = args[i + 1];
-                            const nestedCmd = subCmd.subcommands.find(sc => sc.name === nestedArg || sc.aliases?.includes(nestedArg));
-                            if (nestedCmd) {
-                                result.command.push(nestedArg);
-                                resolvedCmd = nestedCmd;
-                                i++;
-                                // Check for deeply nested subcommand (level 3)
-                                if (nestedCmd.subcommands && i + 1 < args.length) {
-                                    const deepArg = args[i + 1];
-                                    const deepCmd = nestedCmd.subcommands.find(sc => sc.name === deepArg || sc.aliases?.includes(deepArg));
-                                    if (deepCmd) {
-                                        result.command.push(deepArg);
-                                        resolvedCmd = deepCmd;
-                                        i++;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            else {
-                // Positional argument. If we haven't resolved a command yet, this
-                // token was the user's attempt at one — close the search so a later
-                // token can't be silently dispatched in its place.
-                if (result.command.length === 0)
-                    commandSearchClosed = true;
-                result.positional.push(arg);
-                result.flags._.push(arg);
-            }
-            i++;
-        }
-        // Apply defaults — the resolved (sub)command's own option definitions
-        // shadow same-name global options (e.g. `browse screenshot --format` is an
-        // image format, not the global text|json|table output format).
-        this.applyDefaults(result.flags, resolvedCmd);
-        // Dual-write flag keys: every flag ends up stored under BOTH its
-        // camelCase form (`keepConfig`) and its original kebab-case form
-        // (`keep-config`). Historically only the camelCase key was ever set,
-        // but dozens of command action functions across the codebase read
-        // `ctx.flags['kebab-case']` directly — which was always `undefined`,
-        // silently disabling those flags (see AUDIT-BACKLOG P0-10). Running
-        // this as a single pass over the fully-merged flags object (long
-        // flags, `--no-x` negation, short-flag aliases, and defaults are all
-        // merged into `result.flags` by this point) covers every entry point
-        // in one place instead of touching each call site individually.
-        this.mirrorFlagKeys(result.flags);
-        return result;
-    }
-    /**
-     * Convert a camelCase key to kebab-case (inverse of normalizeKey).
-     */
-    camelToKebab(key) {
-        return key.replace(/[A-Z]/g, (letter) => '-' + letter.toLowerCase());
-    }
-    /**
-     * Ensure every flag is reachable under both its camelCase and
-     * kebab-case spelling. Runs once, after all flags (including
-     * defaults) have been merged into the result.
-     */
-    mirrorFlagKeys(flags) {
-        for (const key of Object.keys(flags)) {
-            if (key === '_' || CommandParser.RESERVED_FLAG_KEYS.has(key))
-                continue;
-            const camelKey = this.normalizeKey(key);
-            if (camelKey !== key && flags[camelKey] === undefined && !CommandParser.RESERVED_FLAG_KEYS.has(camelKey)) {
-                flags[camelKey] = flags[key];
-            }
-            const kebabKey = this.camelToKebab(key);
-            if (kebabKey !== key && flags[kebabKey] === undefined && !CommandParser.RESERVED_FLAG_KEYS.has(kebabKey)) {
-                flags[kebabKey] = flags[key];
-            }
-        }
-    }
-    /**
-     * True when `value` looks like a space-separated negative number
-     * (`-0.5`, `-42`) rather than a new flag. Scoped narrowly to "leading `-`
-     * immediately followed by a digit" — a legitimate flag name never starts
-     * with a digit, so this can't misfire on a genuine following flag while
-     * still letting `--threshold -0.5` consume `-0.5` as the value instead of
-     * being misparsed as a new (bogus) flag.
-     */
-    looksLikeNegativeNumber(value) {
-        return /^-\d/.test(value);
-    }
-    parseFlag(args, index, aliases, booleanFlags) {
-        const flags = { _: [] };
-        const arg = args[index];
-        let nextIndex = index + 1;
-        if (arg.startsWith('--')) {
-            // Long flag
-            const equalIndex = arg.indexOf('=');
-            if (equalIndex !== -1) {
-                // --flag=value
-                const key = arg.slice(2, equalIndex);
-                const value = arg.slice(equalIndex + 1);
-                this.setFlagSafe(flags, this.normalizeKey(key), this.parseValue(value));
-            }
-            else if (arg.startsWith('--no-')) {
-                // --no-flag (boolean negation) — only accept for declared boolean flags
-                // so attackers can't covertly toggle off arbitrary security controls
-                // (--no-verify-signature, --no-confirm, etc.) when the underlying flag
-                // doesn't exist as a boolean option. Unknown --no-X is treated as a
-                // string flag passed verbatim, which validation can then reject.
-                const key = arg.slice(5);
-                const normalizedKey = this.normalizeKey(key);
-                if (booleanFlags.has(normalizedKey)) {
-                    this.setFlagSafe(flags, normalizedKey, false);
-                }
-                else {
-                    // Record under the prefixed name so it surfaces as unknown rather
-                    // than silently downgrading any flag the user happens to spell.
-                    this.setFlagSafe(flags, this.normalizeKey('no-' + key), true);
-                }
-            }
-            else {
-                const key = arg.slice(2);
-                const normalizedKey = this.normalizeKey(key);
-                if (booleanFlags.has(normalizedKey)) {
-                    this.setFlagSafe(flags, normalizedKey, true);
-                }
-                else if (nextIndex < args.length &&
-                    (!args[nextIndex].startsWith('-') || this.looksLikeNegativeNumber(args[nextIndex]))) {
-                    this.setFlagSafe(flags, normalizedKey, this.parseValue(args[nextIndex]));
-                    nextIndex++;
-                }
-                else {
-                    this.setFlagSafe(flags, normalizedKey, true);
-                }
-            }
-        }
-        else if (arg.startsWith('-')) {
-            // Short flag(s)
-            const chars = arg.slice(1);
-            if (chars.length === 1) {
-                // Single short flag
-                const key = aliases[chars] || chars;
-                const normalizedKey = this.normalizeKey(key);
-                if (booleanFlags.has(normalizedKey)) {
-                    this.setFlagSafe(flags, normalizedKey, true);
-                }
-                else if (nextIndex < args.length &&
-                    (!args[nextIndex].startsWith('-') || this.looksLikeNegativeNumber(args[nextIndex]))) {
-                    this.setFlagSafe(flags, normalizedKey, this.parseValue(args[nextIndex]));
-                    nextIndex++;
-                }
-                else {
-                    this.setFlagSafe(flags, normalizedKey, true);
-                }
-            }
-            else {
-                // Multiple short flags combined (e.g., -abc)
-                for (const char of chars) {
-                    const key = aliases[char] || char;
-                    this.setFlagSafe(flags, this.normalizeKey(key), true);
-                }
-            }
-        }
-        return { flags, nextIndex };
-    }
-    parseValue(value) {
-        // Boolean
-        if (value.toLowerCase() === 'true')
-            return true;
-        if (value.toLowerCase() === 'false')
-            return false;
-        // Number — only coerce if the string is unambiguously a canonical number.
-        // The previous code coerced any numeric-looking string, which silently
-        // dropped leading zeros ("00042" → 42), mangled IDs/tokens above
-        // Number.MAX_SAFE_INTEGER, and could cause tenant/identity mix-ups when
-        // downstream consumers strict-equal-compared against stored strings.
-        if (value.trim() !== '' && /^-?(0|[1-9]\d*)(\.\d+)?([eE][+-]?\d+)?$/.test(value)) {
-            const num = Number(value);
-            if (Number.isFinite(num) && Number.isSafeInteger(num) || (!Number.isInteger(num) && Number.isFinite(num))) {
-                return num;
-            }
-        }
-        // String
-        return value;
-    }
-    normalizeKey(key) {
-        // Convert kebab-case to camelCase
-        return key.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
-    }
-    buildAliases() {
-        const aliases = {};
-        // Add aliases from all commands and subcommands first (lowest priority) —
-        // any command's own options may still be re-applied by buildScopedAliases()
-        // once the resolved command is known.
-        for (const cmd of this.commands.values()) {
-            if (cmd.options) {
-                for (const opt of cmd.options) {
-                    if (opt.short) {
-                        aliases[opt.short] = opt.name;
-                    }
-                }
-            }
-            // Also include subcommands' options
-            if (cmd.subcommands) {
-                for (const sub of cmd.subcommands) {
-                    if (sub.options) {
-                        for (const opt of sub.options) {
-                            if (opt.short) {
-                                aliases[opt.short] = opt.name;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        // Global options are applied last so an unrelated command's short flag
-        // (e.g. "security scan --quick, -Q") can't silently shadow a global flag
-        // of the same letter (e.g. global "-Q, --quiet") for every other command.
-        for (const opt of this.globalOptions) {
-            if (opt.short) {
-                aliases[opt.short] = opt.name;
-            }
-        }
-        return { ...aliases, ...this.options.aliases };
-    }
-    /**
-     * Build aliases scoped to a specific command/subcommand.
-     * The resolved command's short flags take priority over global ones,
-     * fixing collisions where multiple subcommands use the same short flag (e.g. -t).
-     */
-    buildScopedAliases(scope) {
-        // Start with global aliases as base
-        const aliases = this.buildAliases();
-        // Override with the resolved chain's own options (these take priority);
-        // deepest subcommand last, so it wins over its ancestors.
-        for (const cmd of CommandParser.asChain(scope)) {
-            for (const opt of cmd.options ?? []) {
-                if (opt.short) {
-                    aliases[opt.short] = opt.name;
-                }
-            }
-        }
-        return aliases;
-    }
-    /** Normalize a single command or a resolved chain into an array. */
-    static asChain(scope) {
-        if (!scope)
-            return [];
-        return Array.isArray(scope) ? scope : [scope];
-    }
-    /**
-     * Get boolean flags scoped to a specific command/subcommand chain.
-     */
-    getScopedBooleanFlags(scope) {
-        const flags = this.getBooleanFlags();
-        for (const cmd of CommandParser.asChain(scope)) {
-            for (const opt of cmd.options ?? []) {
-                if (opt.type === 'boolean') {
-                    flags.add(this.normalizeKey(opt.name));
-                }
-            }
-        }
-        return flags;
-    }
-    /**
-     * Get flags declared `type: 'array'`, scoped to a specific command/subcommand chain.
-     */
-    getScopedArrayFlags(scope) {
-        const flags = new Set();
-        for (const cmd of CommandParser.asChain(scope)) {
-            for (const opt of cmd.options ?? []) {
-                if (opt.type === 'array') {
-                    flags.add(this.normalizeKey(opt.name));
-                }
-            }
-        }
-        return flags;
-    }
-    getBooleanFlags() {
-        const flags = new Set();
-        for (const opt of this.globalOptions) {
-            if (opt.type === 'boolean') {
-                flags.add(this.normalizeKey(opt.name));
-            }
-        }
-        // Add boolean flags from all commands and subcommands
-        for (const cmd of this.commands.values()) {
-            if (cmd.options) {
-                for (const opt of cmd.options) {
-                    if (opt.type === 'boolean') {
-                        flags.add(this.normalizeKey(opt.name));
-                    }
-                }
-            }
-            // Also include subcommands' boolean flags
-            if (cmd.subcommands) {
-                for (const sub of cmd.subcommands) {
-                    if (sub.options) {
-                        for (const opt of sub.options) {
-                            if (opt.type === 'boolean') {
-                                flags.add(this.normalizeKey(opt.name));
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        if (this.options.booleanFlags) {
-            for (const flag of this.options.booleanFlags) {
-                flags.add(this.normalizeKey(flag));
-            }
-        }
-        return flags;
-    }
-    applyDefaults(flags, resolvedCmd) {
-        // The resolved command's own options shadow same-name globals: apply the
-        // command's defaults and suppress the global default for those names.
-        const shadowed = new Set();
-        if (resolvedCmd?.options) {
-            for (const opt of resolvedCmd.options) {
-                const key = this.normalizeKey(opt.name);
-                shadowed.add(key);
-                if (flags[key] === undefined && opt.default !== undefined) {
-                    flags[key] = opt.default;
-                }
-            }
-        }
-        // Apply global option defaults
-        for (const opt of this.globalOptions) {
-            const key = this.normalizeKey(opt.name);
-            if (shadowed.has(key))
-                continue;
-            if (flags[key] === undefined && opt.default !== undefined) {
-                flags[key] = opt.default;
-            }
-        }
-        // Apply custom defaults
-        if (this.options.defaults) {
-            for (const [key, value] of Object.entries(this.options.defaults)) {
-                const normalizedKey = this.normalizeKey(key);
-                if (flags[normalizedKey] === undefined) {
-                    flags[normalizedKey] = value;
-                }
-            }
-        }
-    }
-    validateFlags(flags, command) {
-        const errors = [];
-        // Command options shadow same-name globals — validate against the
-        // command's definition (its choices/validators), not the global's.
-        const byName = new Map();
-        for (const opt of this.globalOptions)
-            byName.set(opt.name, opt);
-        if (command?.options) {
-            for (const opt of command.options)
-                byName.set(opt.name, opt);
-        }
-        const allOptions = [...byName.values()];
-        // Check required flags
-        for (const opt of allOptions) {
-            const key = this.normalizeKey(opt.name);
-            if (opt.required && (flags[key] === undefined || flags[key] === '')) {
-                errors.push(`Required option missing: --${opt.name}`);
-            }
-            // Check choices
-            if (opt.choices && flags[key] !== undefined) {
-                const value = String(flags[key]);
-                if (!opt.choices.includes(value)) {
-                    errors.push(`Invalid value for --${opt.name}: ${value}. Must be one of: ${opt.choices.join(', ')}`);
-                }
-            }
-            // Run custom validator
-            if (opt.validate && flags[key] !== undefined) {
-                const result = opt.validate(flags[key]);
-                if (result !== true) {
-                    errors.push(typeof result === 'string' ? result : `Invalid value for --${opt.name}`);
-                }
-            }
-        }
-        // Check for unknown flags if not allowed
-        if (!this.options.allowUnknownFlags) {
-            // Include both the camelCase and original (kebab-case) spelling of
-            // each option name — parse() now mirrors flags under both forms, so
-            // validation must recognize both or the mirrored key would be
-            // flagged as an unknown option.
-            const knownFlags = new Set();
-            for (const opt of allOptions) {
-                knownFlags.add(this.normalizeKey(opt.name));
-                knownFlags.add(opt.name);
-            }
-            knownFlags.add('_'); // Positional args
-            for (const key of Object.keys(flags)) {
-                if (!knownFlags.has(key) && key !== '_') {
-                    errors.push(`Unknown option: --${key}`);
-                }
-            }
-        }
-        return errors;
-    }
-    getGlobalOptions() {
-        return [...this.globalOptions];
-    }
-}
-// Export singleton parser instance
-export const commandParser = new CommandParser({ allowUnknownFlags: true });
-//# sourceMappingURL=parser.js.map

package/packages/@monomind/cli/dist/src/pricing/model-pricing.d.ts

@@ -1,41 +0,0 @@
-/**
- * Single source-of-truth for Claude and third-party model pricing.
- *
- * All values are cost PER TOKEN:
- *   in  — input tokens
- *   out — output tokens
- *   cw  — cache-write tokens
- *   cr  — cache-read tokens
- *
- * Consumers: src/ui/collector.mjs and src/ui/server.mjs both
- * derive their inline pricing tables from this canonical list.
- */
-export interface ModelPrice {
-    in: number;
-    out: number;
-    cw: number;
-    cr: number;
-}
-/** Canonical pricing map — union of all models from collector + server tables. */
-export declare const MODEL_PRICING: Record<string, ModelPrice>;
-/**
- * Canonical default model IDs — single source of truth for code that needs
- * to reference a specific tier without hard-coding a string literal.
- *
- * Consumers should import these instead of writing raw model-id strings so
- * that a model upgrade only requires editing this one object.
- */
-export declare const MODEL_DEFAULTS: {
-    /** Fast/cheap routing model (Tier 2). */
-    readonly haiku: string;
-    /** Balanced capability model (Tier 3 default). */
-    readonly sonnet: string;
-    /** Most capable model (Tier 3 high). */
-    readonly opus: string;
-};
-/**
- * Resolve a raw model string (may include date suffix or @version) to its
- * pricing entry.  Returns `null` when the model is unknown.
- */
-export declare function getModelPrice(modelId: string): ModelPrice | null;
-//# sourceMappingURL=model-pricing.d.ts.map