localewarden 0.1.1 → 0.3.0

package/dist/engine/sources.d.ts

@@ -0,0 +1,13 @@
+import type { Config } from '../config.js';
+import { type LocaleFile } from '../files.js';
+import type { PluginHost } from '../plugins.js';
+import type { Scope } from '../scope.js';
+import type { Logger } from './context.js';
+import type { SourceFile } from './planner.js';
+/**
+ * The source files of a group, without excluded ones, in the order plugins choose (they may
+ * also leave files out, e.g. blog posts scheduled for a later date).
+ */
+export declare function listFiles(config: Config, scope: Scope, plugins: PluginHost): LocaleFile[];
+/** Reads and parses the source files; unreadable ones are reported and skipped. */
+export declare function loadSources(config: Config, files: LocaleFile[], log: Logger): SourceFile[];

package/dist/engine/sources.js

@@ -0,0 +1,40 @@
+import path from 'node:path';
+import { findSourceFiles, parseDoc, readText, stringLeaves } from '../files.js';
+/**
+ * The source files of a group, without excluded ones, in the order plugins choose (they may
+ * also leave files out, e.g. blog posts scheduled for a later date).
+ */
+export function listFiles(config, scope, plugins) {
+    const files = findSourceFiles(config.root, config.files, config.sourceLanguage).filter(file => !scope.isExcluded(file));
+    const byId = new Map(files.map(file => [file.id, file]));
+    return plugins
+        .order(files.map(file => ({ id: file.id, sourcePath: file.pathFor(config.sourceLanguage) })), config.name)
+        .map(info => byId.get(info.id))
+        .filter((file) => file !== undefined);
+}
+/** Reads and parses the source files; unreadable ones are reported and skipped. */
+export function loadSources(config, files, log) {
+    const sources = [];
+    for (const file of files) {
+        const sourceRel = file.pathFor(config.sourceLanguage);
+        const text = readText(path.join(config.root, sourceRel));
+        if (text === null)
+            continue;
+        try {
+            const doc = parseDoc(sourceRel, text);
+            const leaves = stringLeaves(doc);
+            // {"a.b": …} next to {"a": {"b": …}} flatten to the same key; only one would be kept.
+            const seen = new Set();
+            for (const leaf of leaves) {
+                if (seen.has(leaf.key))
+                    log.warn(`${sourceRel}: key "${leaf.key}" exists twice (as a dotted and a nested key); rename one of them.`);
+                seen.add(leaf.key);
+            }
+            sources.push({ file, doc, text, leaves });
+        }
+        catch (error) {
+            log.error(`${sourceRel} is not valid JSON (${error.message}); skipped.`);
+        }
+    }
+    return sources;
+}

package/dist/engine/translator.d.ts

@@ -0,0 +1,29 @@
+import type { Checker } from '../checks.js';
+import type { Config } from '../config.js';
+import type { Client } from '../llm.js';
+import { type PromptItem } from '../prompt.js';
+import type { RunContext } from './context.js';
+/**
+ * Turns prompt items into checked translations: batches strings into JSON-array requests,
+ * falls back to one request per string, splits very long texts at paragraph breaks, cleans
+ * and post-processes answers, and retries a defective answer once on its own.
+ */
+export declare class Translator {
+    private readonly ctx;
+    private readonly config;
+    private readonly checker;
+    private readonly client;
+    constructor(ctx: RunContext, config: Config, checker: Checker, client: Client);
+    private timeoutFor;
+    /** Model answer cleaned and run through plugin post-processing. */
+    private finish;
+    private notes;
+    /** One string as plain text; very long new strings go paragraph by paragraph. */
+    translateOne(lang: string, item: PromptItem, extra?: string): Promise<string | null>;
+    /** Splits items into batches by count and size; list markup and long texts go alone. */
+    private batches;
+    /** Translates items; returns the ones that passed the output checks. */
+    translateItems(lang: string, items: PromptItem[]): Promise<Map<PromptItem, string>>;
+    /** Output checks for one answer, with one retry on its own; null when it is not written. */
+    private accept;
+}

package/dist/engine/translator.js

@@ -0,0 +1,156 @@
+import { isUnchangedProse } from '../checks.js';
+import { cleanOutput, parseArray, splitLongText } from '../output.js';
+import { batchPrompt, singlePrompt } from '../prompt.js';
+import { baseLanguage } from '../util.js';
+// Scripts whose output costs many tokens per character; smaller batches avoid timeouts.
+const SLOW_LANGUAGES = new Set(['ar', 'fa', 'ur', 'he', 'hi', 'mr', 'ne', 'bn', 'th', 'ta', 'te', 'kn', 'ml', 'gu', 'pa', 'si', 'my', 'km', 'lo', 'am', 'ka', 'hy']);
+const MAX_BATCH_CHARS = 6000;
+const rank = (d) => (d.hard ? 2 : d.soft ? 1 : 0);
+/**
+ * Turns prompt items into checked translations: batches strings into JSON-array requests,
+ * falls back to one request per string, splits very long texts at paragraph breaks, cleans
+ * and post-processes answers, and retries a defective answer once on its own.
+ */
+export class Translator {
+    ctx;
+    config;
+    checker;
+    client;
+    constructor(ctx, config, checker, client) {
+        this.ctx = ctx;
+        this.config = config;
+        this.checker = checker;
+        this.client = client;
+    }
+    timeoutFor(lang) {
+        return SLOW_LANGUAGES.has(baseLanguage(lang)) ? 240_000 : 120_000;
+    }
+    /** Model answer cleaned and run through plugin post-processing. */
+    finish(lang, item, raw) {
+        const text = cleanOutput(item.source, raw);
+        return this.ctx.plugins.postProcess({ lang, key: item.key, file: item.file ?? '', source: item.source, text });
+    }
+    notes(lang, items) {
+        return this.ctx.plugins.promptNotes(lang, items.map(i => ({ key: i.key, source: i.source })));
+    }
+    /** One string as plain text; very long new strings go paragraph by paragraph. */
+    async translateOne(lang, item, extra = '') {
+        if (this.ctx.stopped)
+            return null;
+        const notes = this.notes(lang, [item]);
+        try {
+            if (!extra && !item.previous && item.source.length > this.config.chunkChars) {
+                const { parts, separators } = splitLongText(item.source, this.config.chunkChars);
+                let out = '';
+                for (const [i, part] of parts.entries()) {
+                    const piece = await this.client.complete(singlePrompt(this.config, lang, { ...item, source: part }, notes), part, this.timeoutFor(lang));
+                    out += cleanOutput(part, piece) + (separators[i] ?? '');
+                }
+                return this.finish(lang, item, out);
+            }
+            const raw = await this.client.complete(singlePrompt(this.config, lang, item, extra + notes), item.source, this.timeoutFor(lang));
+            return this.finish(lang, item, raw);
+        }
+        catch (error) {
+            this.ctx.handleError(error, lang);
+            return null;
+        }
+    }
+    /** Splits items into batches by count and size; list markup and long texts go alone. */
+    batches(lang, items) {
+        const size = SLOW_LANGUAGES.has(baseLanguage(lang)) ? Math.min(5, this.config.batchSize) : this.config.batchSize;
+        const batches = [];
+        let current = [];
+        let chars = 0;
+        const flush = () => {
+            if (current.length > 0)
+                batches.push(current);
+            current = [];
+            chars = 0;
+        };
+        for (const item of items) {
+            // Models split list markup into several array elements; send it alone.
+            const alone = /<li\b/i.test(item.source) || item.source.length > MAX_BATCH_CHARS / 2;
+            if (alone || current.length >= size || chars + item.source.length > MAX_BATCH_CHARS)
+                flush();
+            current.push(item);
+            chars += item.source.length;
+            if (alone)
+                flush();
+        }
+        flush();
+        return batches;
+    }
+    /** Translates items; returns the ones that passed the output checks. */
+    async translateItems(lang, items) {
+        const results = new Map();
+        for (const batch of this.batches(lang, items)) {
+            if (this.ctx.stopped)
+                break;
+            let candidates = null;
+            if (batch.length > 1) {
+                try {
+                    const raw = await this.client.complete(batchPrompt(this.config, lang, batch, this.notes(lang, batch)), JSON.stringify(batch.map(i => i.source)), this.timeoutFor(lang));
+                    const parsed = parseArray(raw, batch.length);
+                    candidates = parsed ? parsed.map((text, i) => (text === null ? null : this.finish(lang, batch[i], text))) : null;
+                    // An element the model left empty (null) gets its own request.
+                    if (candidates)
+                        for (const [i, text] of candidates.entries())
+                            if (text === null)
+                                candidates[i] = await this.translateOne(lang, batch[i]);
+                    if (!candidates)
+                        this.ctx.log.warn(`[${lang}] batch answer was not a matching JSON array; translating one by one`);
+                }
+                catch (error) {
+                    this.ctx.handleError(error, lang);
+                    if (this.ctx.stopped)
+                        break;
+                }
+            }
+            if (!candidates) {
+                candidates = [];
+                for (const item of batch)
+                    candidates.push(await this.translateOne(lang, item));
+            }
+            for (const [i, item] of batch.entries()) {
+                const text = await this.accept(lang, item, candidates[i], batch.length > 1);
+                if (text !== null)
+                    results.set(item, text);
+            }
+        }
+        return results;
+    }
+    /** Output checks for one answer, with one retry on its own; null when it is not written. */
+    async accept(lang, item, candidate, fromBatch) {
+        if (candidate === null)
+            return null;
+        let text = candidate;
+        let defect = this.checker.defect(lang, item.key, item.source, text, item.file);
+        const echoed = isUnchangedProse(item.source, text, this.checker.placeholderRe);
+        if (defect.soft && (fromBatch || echoed)) {
+            const retry = await this.translateOne(lang, item);
+            if (retry !== null) {
+                const retryDefect = this.checker.defect(lang, item.key, item.source, retry, item.file);
+                if (rank(retryDefect) < rank(defect)) {
+                    text = retry;
+                    defect = retryDefect;
+                }
+                else if (echoed && isUnchangedProse(item.source, retry, this.checker.placeholderRe)) {
+                    // Asked twice, the model keeps the source text: names and product lists are often
+                    // the same in every language. Accept it instead of retrying on every run.
+                    defect = { hard: null, soft: 'identical to the source (accepted after a retry)' };
+                }
+            }
+        }
+        if (defect.hard) {
+            this.ctx.log.warn(`[${lang}] ${item.key}: ${defect.hard}; not written`);
+            return null;
+        }
+        const long = this.checker.tooLong(item.key, text);
+        if (long)
+            this.ctx.log.warn(`[${lang}] ${item.key}: ${long}; written, shorten it by hand or run --fix-flagged`);
+        else if (defect.soft)
+            this.ctx.log.debug?.(`[${lang}] ${item.key}: ${defect.soft} (kept)`);
+        return text;
+    }
+}

package/dist/engine/writer.d.ts

@@ -0,0 +1,13 @@
+import { type JsonValue } from '../files.js';
+import type { PromptItem } from '../prompt.js';
+import type { RunContext } from './context.js';
+import type { Plan } from './planner.js';
+/** JSON with object keys sorted, to compare content regardless of key order and formatting. */
+export declare function canonical(value: JsonValue): string;
+/** Puts the translations that passed into the plan's values and records them in the state. */
+export declare function applyTranslations(ctx: RunContext, plan: Plan, translated: Map<PromptItem, string>): void;
+/**
+ * Builds the target document in the source's shape and writes it, unless its content is the
+ * same as on disk (formatting and key order of the existing file are then left alone).
+ */
+export declare function writePlan(ctx: RunContext, plan: Plan): void;

package/dist/engine/writer.js

@@ -0,0 +1,63 @@
+import { muchShorter } from '../checks.js';
+import { buildTarget, detectFormat, serializeDoc, setAt, writeText } from '../files.js';
+import { reviewId } from '../state.js';
+import { hash, today } from '../util.js';
+/** JSON with object keys sorted, to compare content regardless of key order and formatting. */
+export function canonical(value) {
+    return JSON.stringify(value, (_, v) => v && typeof v === 'object' && !Array.isArray(v) ? Object.fromEntries(Object.entries(v).sort(([a], [b]) => (a < b ? -1 : 1))) : v);
+}
+/** Puts the translations that passed into the plan's values and records them in the state. */
+export function applyTranslations(ctx, plan, translated) {
+    const { state, log } = ctx;
+    const { lang, file, values, counts } = plan;
+    for (const item of plan.work) {
+        const text = translated.get(item);
+        if (text === undefined) {
+            counts.failed++;
+            continue;
+        }
+        if (item.completing && item.previous && muchShorter(lang, item.source, text)) {
+            // Still missing content: keep the old text and do not spend tokens on it again.
+            state.repairFailures[reviewId(lang, file.id, item.key)] = {
+                valueHash: hash(item.previous),
+                date: today(),
+                problems: ['content missing'],
+                reason: 'revision still much shorter than the source',
+                attempted: text,
+            };
+            log.warn(`[${lang}] ${item.key}: could not complete the missing content; listed in repair-failures.json`);
+            counts.failed++;
+            continue;
+        }
+        values.set(item.key, text);
+        plan.pending.push({ key: item.key, source: item.source, value: text });
+        if (item.previous)
+            counts.revised++;
+        else
+            counts.translated++;
+    }
+}
+/**
+ * Builds the target document in the source's shape and writes it, unless its content is the
+ * same as on disk (formatting and key order of the existing file are then left alone).
+ */
+export function writePlan(ctx, plan) {
+    const { targetRel, targetFile, targetText, targetDoc, values, sourceDoc, sourceText, pluralExtras } = plan;
+    plan.counts.removed += plan.removed.length;
+    const built = buildTarget(sourceDoc, values) ?? {};
+    for (const leaf of pluralExtras) {
+        const value = values.get(leaf.key);
+        if (value !== undefined)
+            setAt(built, leaf.path, value);
+    }
+    const unchanged = targetDoc !== null && canonical(built) === canonical(targetDoc);
+    const text = serializeDoc(targetRel, built, detectFormat(targetText ?? sourceText));
+    if (!unchanged && text !== null && text !== targetText && !(targetText === null && Object.keys(built).length === 0)) {
+        writeText(targetFile, text);
+        ctx.summary.filesWritten.push(targetRel);
+    }
+    // The file now holds these translations: record them (see Plan.pending).
+    for (const { key, source, value } of plan.pending)
+        ctx.state.set(plan.lang, plan.file.id, key, source, value);
+    plan.pending = [];
+}

package/dist/files.d.ts

@@ -10,6 +10,18 @@ export interface LocaleFile {
  * Supported: {lang} (once or more), * within one path segment, and **\/ for any depth.
  */
 export declare function findSourceFiles(root: string, pattern: string, sourceLanguage: string): LocaleFile[];
+/**
+ * Key pattern -> RegExp. "*" matches within one segment, "**" any number of segments. A
+ * pattern without a dot matches the last segment anywhere ("id" matches "steps.2.id").
+ */
+export declare function keyPattern(pattern: string): RegExp;
+/** Path pattern -> RegExp ("*" within a folder, "**" across folders, {lang} as written). */
+export declare function pathPattern(pattern: string): RegExp;
+/**
+ * Values that are not text and stay as they are in every language: URLs, email addresses,
+ * file paths and plain numbers or codes without spaces.
+ */
+export declare function isLiteralValue(value: string): boolean;
 export type JsonValue = string | number | boolean | null | JsonValue[] | {
     [key: string]: JsonValue;
 };
@@ -44,9 +56,27 @@ export declare function setAt(doc: JsonValue, segments: PathSegment[], value: st
 export interface JsonFormat {
     indent: string;
     finalNewline: boolean;
+    /** Line ending of the existing file ("\r\n" on Windows checkouts). */
+    eol: '\n' | '\r\n';
+    /** The existing file starts with a byte order mark. */
+    bom: boolean;
 }
 /** Indentation and final newline of an existing JSON text (2 spaces by default). */
+/** Indentation, final newline, line ending and BOM of an existing text (2 spaces, LF by default). */
 export declare function detectFormat(text: string | null): JsonFormat;
 export declare function serialize(value: JsonValue, format: JsonFormat): string;
+/**
+ * Parses a locale file. A .txt file (fastlane metadata: description.txt, keywords.txt) is one
+ * string, keyed by its file name, so maxLength patterns like "keywords" apply to it.
+ */
+export declare function parseDoc(rel: string, text: string): JsonValue;
+/** Flutter ARB metadata ("@@locale", "@title": { description, placeholders }): not text. */
+export declare const isArbMetadata: (rel: string, key: string) => boolean;
+/** Text of a locale file, or null when a .txt file has no value to write. */
+export declare function serializeDoc(rel: string, doc: JsonValue, format: JsonFormat): string | null;
 export declare function readText(file: string): string | null;
+/**
+ * Writes via a temporary file and a rename, so an interrupted run never leaves a half-written
+ * locale file behind.
+ */
 export declare function writeText(file: string, text: string): void;

package/dist/files.js

@@ -16,21 +16,45 @@ function tokenize(pattern) {
     });
 }
 const SKIP_DIRS = new Set(['node_modules', '.git', '.localewarden']);
-function walk(root, dir, out) {
+/** Lists files below `dir`, following symbolic links once (a link loop is not followed again). */
+function walk(root, dir, out, seen = new Set()) {
+    const full = path.join(root, dir);
+    let real;
+    try {
+        real = fs.realpathSync(full);
+    }
+    catch {
+        return;
+    }
+    if (seen.has(real))
+        return;
+    seen.add(real);
     let entries;
     try {
-        entries = fs.readdirSync(path.join(root, dir), { withFileTypes: true });
+        entries = fs.readdirSync(full, { withFileTypes: true });
     }
     catch {
         return;
     }
     for (const entry of entries) {
         const rel = dir ? `${dir}/${entry.name}` : entry.name;
-        if (entry.isDirectory()) {
+        let isDir = entry.isDirectory();
+        let isFile = entry.isFile();
+        if (entry.isSymbolicLink()) {
+            try {
+                const stat = fs.statSync(path.join(root, rel));
+                isDir = stat.isDirectory();
+                isFile = stat.isFile();
+            }
+            catch {
+                continue; // broken link
+            }
+        }
+        if (isDir) {
             if (!SKIP_DIRS.has(entry.name))
-                walk(root, rel, out);
+                walk(root, rel, out, seen);
         }
-        else if (entry.isFile()) {
+        else if (isFile) {
             out.push(rel);
         }
     }
@@ -87,7 +111,7 @@ export function findSourceFiles(root, pattern, sourceLanguage) {
     };
     const files = [];
     for (const rel of all.sort()) {
-        if (!rel.endsWith('.json'))
+        if (!/\.(json|arb|txt)$/.test(rel))
             continue;
         const match = matcher.exec(rel);
         if (!match || match.groups?.lang !== sourceLanguage)
@@ -99,6 +123,38 @@ export function findSourceFiles(root, pattern, sourceLanguage) {
     }
     return files;
 }
+/**
+ * Key pattern -> RegExp. "*" matches within one segment, "**" any number of segments. A
+ * pattern without a dot matches the last segment anywhere ("id" matches "steps.2.id").
+ */
+export function keyPattern(pattern) {
+    const body = pattern
+        .split(/(\*\*|\*)/)
+        .map(part => (part === '**' ? '.*' : part === '*' ? '[^.]*' : escapeRegExp(part)))
+        .join('');
+    return new RegExp(pattern.includes('.') ? `^${body}$` : `(?:^|\\.)${body}$`);
+}
+/** Path pattern -> RegExp ("*" within a folder, "**" across folders, {lang} as written). */
+export function pathPattern(pattern) {
+    const body = pattern
+        .replace(/\\/g, '/')
+        .replace(/^\.\//, '')
+        .split(/(\*\*\/?|\*)/)
+        .map(part => (part.startsWith('**') ? '(?:.*/)?' : part === '*' ? '[^/]*' : escapeRegExp(part)))
+        .join('');
+    return new RegExp(`^${body}$`);
+}
+/**
+ * Values that are not text and stay as they are in every language: URLs, email addresses,
+ * file paths and plain numbers or codes without spaces.
+ */
+export function isLiteralValue(value) {
+    const v = value.trim();
+    return (/^(?:https?:\/\/|mailto:|tel:)\S+$/i.test(v) ||
+        /^[\w.+-]+@[\w-]+(?:\.[\w-]+)+$/.test(v) ||
+        /^(?:\.{0,2}\/)?[\w@.-]+(?:\/[\w@.-]+)*\.(?:png|jpe?g|gif|svg|webp|avif|ico|mp3|mp4|webm|wav|pdf|json|css|js|html?)$/i.test(v) ||
+        /^[\d\s.,:%+\-–/×x#]+$/.test(v));
+}
 export const keyOf = (segments) => segments.join('.');
 /** All string values of a parsed JSON document, in document order. */
 export function stringLeaves(value, prefix = [], out = []) {
@@ -142,7 +198,8 @@ export function buildTarget(source, values, prefix = []) {
             if (built && typeof built === 'object' && !Array.isArray(built) && Object.keys(built).length === 0) {
                 continue;
             }
-            result[key] = built;
+            // defineProperty: a key named "__proto__" stays a key instead of setting the prototype.
+            Object.defineProperty(result, key, { value: built, enumerable: true, writable: true, configurable: true });
         }
         return result;
     }
@@ -202,12 +259,44 @@ export function setAt(doc, segments, value) {
     Object.assign(node, Object.fromEntries(entries));
 }
 /** Indentation and final newline of an existing JSON text (2 spaces by default). */
+/** Indentation, final newline, line ending and BOM of an existing text (2 spaces, LF by default). */
 export function detectFormat(text) {
-    const indent = text?.match(/^[{[]\s*\n([ \t]+)\S/)?.[1] ?? '  ';
-    return { indent, finalNewline: text === null ? true : text.endsWith('\n') };
+    const indent = text?.match(/^\uFEFF?[{[][ \t]*\r?\n([ \t]+)\S/)?.[1] ?? '  ';
+    return {
+        indent,
+        finalNewline: text === null ? true : text.endsWith('\n'),
+        eol: text?.includes('\r\n') ? '\r\n' : '\n',
+        bom: text?.startsWith('\uFEFF') ?? false,
+    };
+}
+/** Line endings, final newline and BOM applied to text written with "\n". */
+function applyFormat(text, format) {
+    const body = format.eol === '\r\n' ? text.replace(/\r?\n/g, '\r\n') : text;
+    return (format.bom ? '\uFEFF' : '') + body + (format.finalNewline ? format.eol : '');
 }
 export function serialize(value, format) {
-    return JSON.stringify(value, null, format.indent) + (format.finalNewline ? '\n' : '');
+    // JSON.stringify escapes newlines inside strings, so every raw "\n" is structural.
+    return applyFormat(JSON.stringify(value, null, format.indent), format);
+}
+const txtKey = (rel) => path.posix.basename(rel.replace(/\\/g, '/'), '.txt');
+/**
+ * Parses a locale file. A .txt file (fastlane metadata: description.txt, keywords.txt) is one
+ * string, keyed by its file name, so maxLength patterns like "keywords" apply to it.
+ */
+export function parseDoc(rel, text) {
+    const body = text.replace(/^\uFEFF/, '');
+    if (rel.endsWith('.txt'))
+        return { [txtKey(rel)]: body.replace(/\r?\n$/, '').replace(/\r\n/g, '\n') };
+    return JSON.parse(body);
+}
+/** Flutter ARB metadata ("@@locale", "@title": { description, placeholders }): not text. */
+export const isArbMetadata = (rel, key) => rel.endsWith('.arb') && key.startsWith('@');
+/** Text of a locale file, or null when a .txt file has no value to write. */
+export function serializeDoc(rel, doc, format) {
+    if (!rel.endsWith('.txt'))
+        return serialize(doc, format);
+    const value = doc[txtKey(rel)];
+    return typeof value === 'string' ? applyFormat(value, format) : null;
 }
 export function readText(file) {
     try {
@@ -219,7 +308,31 @@ export function readText(file) {
         throw error;
     }
 }
+/**
+ * Writes via a temporary file and a rename, so an interrupted run never leaves a half-written
+ * locale file behind.
+ */
 export function writeText(file, text) {
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, text, 'utf8');
+    // A symbolic link is written through (the link stays a link), with the file's own mode.
+    let target = file;
+    let mode;
+    try {
+        target = fs.realpathSync(file);
+        mode = fs.statSync(target).mode & 0o7777;
+    }
+    catch {
+        // does not exist yet
+    }
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    const tmp = `${target}.${process.pid}.localewarden-tmp`;
+    try {
+        fs.writeFileSync(tmp, text, { encoding: 'utf8', ...(mode !== undefined ? { mode } : {}) });
+        if (mode !== undefined)
+            fs.chmodSync(tmp, mode);
+        fs.renameSync(tmp, target);
+    }
+    catch (error) {
+        fs.rmSync(tmp, { force: true });
+        throw error;
+    }
 }

package/dist/index.d.ts

@@ -1,6 +1,9 @@
-export { loadConfig, resolveConfig, ConfigError, DEFAULTS, type Config, type Register } from './config.js';
+export { loadConfig, resolveConfig, groupsOf, ConfigError, DEFAULTS, type Config, type Register } from './config.js';
 export { run, consoleLogger, type RunOptions, type RunSummary, type LanguageSummary, type Logger } from './translate.js';
-export { checkProject, summaryTable, type Finding } from './project.js';
-export { Checker, CHECKS, type CheckName, type Issue } from './checks.js';
+export { checkProject, fixPlaceholders, summaryTable, type CheckOptions, type Finding } from './project.js';
+export { Checker, CHECKS, isError, isFixable, type CheckName, type Issue } from './checks.js';
 export { listReview, updateReview, type ReviewItem } from './review.js';
 export { OpenAICompatibleModel, type Model, type Completion } from './llm.js';
+export { Budget, BudgetExceededError } from './budget.js';
+export { loadPlugins, type Plugin, type PluginIssue, type PluginSpec, type StringContext, type FileInfo } from './plugins.js';
+export { startUi, type UiOptions, type UiServer } from './ui/server.js';

package/dist/index.js

@@ -1,6 +1,9 @@
-export { loadConfig, resolveConfig, ConfigError, DEFAULTS } from './config.js';
+export { loadConfig, resolveConfig, groupsOf, ConfigError, DEFAULTS } from './config.js';
 export { run, consoleLogger } from './translate.js';
-export { checkProject, summaryTable } from './project.js';
-export { Checker, CHECKS } from './checks.js';
+export { checkProject, fixPlaceholders, summaryTable } from './project.js';
+export { Checker, CHECKS, isError, isFixable } from './checks.js';
 export { listReview, updateReview } from './review.js';
 export { OpenAICompatibleModel } from './llm.js';
+export { Budget, BudgetExceededError } from './budget.js';
+export { loadPlugins } from './plugins.js';
+export { startUi } from './ui/server.js';

package/dist/llm.d.ts

@@ -1,4 +1,6 @@
 import type { Config } from './config.js';
+import type { Budget } from './budget.js';
+export { BudgetExceededError } from './budget.js';
 export interface Completion {
     text: string;
     tokens: number;
@@ -27,26 +29,21 @@ export declare class OpenAICompatibleModel implements Model {
         timeoutMs: number;
     }): Promise<Completion>;
 }
-export declare class BudgetExceededError extends Error {
-}
 /**
- * Wraps a Model with retries, spacing between requests and the per-run token budget.
+ * Wraps a Model with retries, spacing between requests and the shared token budget.
  * The budget is checked before each request; the request that crosses it still completes.
  */
 export declare class Client {
     private readonly model;
-    private readonly maxTokens;
+    readonly budget: Budget;
     private readonly options;
-    tokens: number;
-    requests: number;
     private lastStart;
     private queue;
-    constructor(model: Model, maxTokens: number, options?: {
+    constructor(model: Model, budget: Budget, options?: {
         retries?: number;
         minSpacingMs?: number;
         onRetry?: (message: string) => void;
     });
-    get budgetExceeded(): boolean;
     /** Enforces a minimum gap between request starts across all parallel workers. */
     private spacing;
     complete(system: string, user: string, timeoutMs: number): Promise<string>;