@babelize/engine 0.0.0-stage → 0.1.2

package/dist/local/workspace-copy.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Directories never copied into the temp workspace and never diffed back.
+ * Dependencies and VCS/tool caches are skipped at any depth.
+ */
+export declare const EXCLUDED_DIRS_ANY_DEPTH: ReadonlySet<string>;
+/**
+ * Build output, skipped only at the project root: the same names deeper down
+ * are often real source (a Next.js route like `app/build/page.tsx`).
+ */
+export declare const EXCLUDED_DIRS_AT_ROOT: ReadonlySet<string>;
+/** Always copied, even when gitignored: it holds the lockfile that makes reruns incremental. */
+export declare const BABELIZE_DIR = ".babelize";
+export declare function isExcluded(rel: string): boolean;
+/** Regular files under `root/dir`, relative to `root`. Symlinks are never followed. */
+export declare function walk(root: string, dir?: string, out?: string[]): Promise<string[]>;
+/**
+ * Tracked + untracked-but-not-ignored files under `dir`, relative to it, or
+ * null when `dir` is not in a git work tree (or git is missing).
+ */
+export declare function listGitFiles(dir: string): Promise<string[] | null>;
+export interface TempWorkspace {
+    dir: string;
+    cleanup(): Promise<void>;
+}
+/**
+ * Copy the project into a fresh private temp dir. `files` (paths relative to
+ * `projectDir`, e.g. from `git ls-files`) limits the copy; without it the
+ * whole tree is walked. `.babelize/` is always included (it is often
+ * gitignored, but the lockfile in it is what keeps reruns incremental).
+ */
+export declare function createTempCopy(projectDir: string, opts?: {
+    files?: string[];
+    tmpRoot?: string;
+}): Promise<TempWorkspace>;
+/** Relative path → sha256 for every regular file under `root` (excluded dirs skipped). */
+export declare function snapshot(root: string): Promise<Map<string, string>>;
+export interface WorkspaceChanges {
+    added: string[];
+    modified: string[];
+    deleted: string[];
+}
+export declare function diffSnapshots(before: Map<string, string>, after: Map<string, string>): WorkspaceChanges;
+export declare function changeCount(changes: WorkspaceChanges): number;
+/**
+ * Project files that no longer match what the run started from: a file the
+ * run would overwrite or delete was edited (or removed) meanwhile, or a file
+ * it would create now exists (created during the run, or never copied
+ * because it is gitignored). Applying over those would lose the user's work.
+ */
+export declare function findConflicts(changes: WorkspaceChanges, baseline: Map<string, string>, projectDir: string): Promise<string[]>;
+/** File operations used by applyChanges; injectable so tests can simulate a failing disk. */
+export interface ApplyIo {
+    copyFile(src: string, dest: string): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
+    unlink(file: string): Promise<void>;
+    /** Used to restore originals on rollback. */
+    writeFile(file: string, data: Buffer): Promise<void>;
+    /** Used to remove new files on rollback. */
+    remove(file: string): Promise<void>;
+}
+/**
+ * applyChanges failed. When `rolledBack` is true the project is exactly as it
+ * was before; otherwise `changedFiles` lists what is still different.
+ */
+export declare class ApplyError extends Error {
+    readonly cause: unknown;
+    readonly rolledBack: boolean;
+    readonly changedFiles: string[];
+    constructor(message: string, cause: unknown, rolledBack: boolean, changedFiles: string[]);
+}
+/**
+ * Apply the engine's changes from the temp copy to the project, as one
+ * transaction: originals of every file about to be overwritten or deleted are
+ * read into memory first, each write goes through temp file + rename, and on
+ * any failure every file already touched is restored (new files removed).
+ */
+export declare function applyChanges(changes: WorkspaceChanges, fromDir: string, toDir: string, io?: ApplyIo): Promise<void>;
+/** Unified diff (git-style a/ b/ headers) of what applyChanges would do. */
+export declare function renderUnifiedDiff(changes: WorkspaceChanges, beforeDir: string, afterDir: string): Promise<string>;
+export interface FileDiffStat {
+    file: string;
+    kind: 'added' | 'modified' | 'deleted';
+    /** Lines added / removed (numstat semantics). */
+    added: number;
+    removed: number;
+}
+/**
+ * Lines added/removed per changed file, from the files' old and new content
+ * (never from a rendered diff). Unreadable files count as empty.
+ */
+export declare function diffStats(changes: WorkspaceChanges, beforeDir: string, afterDir: string): Promise<FileDiffStat[]>;

package/dist/local/workspace-copy.js

@@ -0,0 +1,355 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplyError = exports.BABELIZE_DIR = exports.EXCLUDED_DIRS_AT_ROOT = exports.EXCLUDED_DIRS_ANY_DEPTH = void 0;
+exports.isExcluded = isExcluded;
+exports.walk = walk;
+exports.listGitFiles = listGitFiles;
+exports.createTempCopy = createTempCopy;
+exports.snapshot = snapshot;
+exports.diffSnapshots = diffSnapshots;
+exports.changeCount = changeCount;
+exports.findConflicts = findConflicts;
+exports.applyChanges = applyChanges;
+exports.renderUnifiedDiff = renderUnifiedDiff;
+exports.diffStats = diffStats;
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const diff_1 = require("diff");
+const fsp = __importStar(require("node:fs/promises"));
+const node_os_1 = require("node:os");
+const path = __importStar(require("node:path"));
+const node_util_1 = require("node:util");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+/**
+ * Directories never copied into the temp workspace and never diffed back.
+ * Dependencies and VCS/tool caches are skipped at any depth.
+ */
+exports.EXCLUDED_DIRS_ANY_DEPTH = new Set(['node_modules', '.git', '.next', '.turbo']);
+/**
+ * Build output, skipped only at the project root: the same names deeper down
+ * are often real source (a Next.js route like `app/build/page.tsx`).
+ */
+exports.EXCLUDED_DIRS_AT_ROOT = new Set(['dist', 'build', 'coverage']);
+/** Always copied, even when gitignored: it holds the lockfile that makes reruns incremental. */
+exports.BABELIZE_DIR = '.babelize';
+/** Engine scratch files that must never be applied back (lockfile write lock / temp). */
+function isEngineScratch(rel) {
+    if (!rel.startsWith(`${exports.BABELIZE_DIR}/`))
+        return false;
+    return /babelize-lock\.json\.(lock|tmp)(\/|$)/.test(rel);
+}
+function toPosix(rel) {
+    return rel.split(path.sep).join('/');
+}
+function isExcluded(rel) {
+    const parts = rel.split('/');
+    if (parts.length > 1 && exports.EXCLUDED_DIRS_AT_ROOT.has(parts[0]))
+        return true;
+    return parts.slice(0, -1).some((part) => exports.EXCLUDED_DIRS_ANY_DEPTH.has(part));
+}
+/** Resolve `rel` under `root`, refusing anything that escapes it. */
+function safeJoin(root, rel) {
+    const abs = path.resolve(root, rel);
+    const relBack = path.relative(root, abs);
+    if (relBack.startsWith('..') || path.isAbsolute(relBack)) {
+        throw new Error(`Refusing to touch a path outside the project: ${rel}`);
+    }
+    return abs;
+}
+/** Regular files under `root/dir`, relative to `root`. Symlinks are never followed. */
+async function walk(root, dir = '', out = []) {
+    const entries = await fsp.readdir(path.join(root, dir), { withFileTypes: true }).catch((err) => {
+        if (err.code === 'ENOENT')
+            return [];
+        throw err;
+    });
+    for (const entry of entries) {
+        const rel = dir ? `${dir}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+            if (exports.EXCLUDED_DIRS_ANY_DEPTH.has(entry.name))
+                continue;
+            if (!dir && exports.EXCLUDED_DIRS_AT_ROOT.has(entry.name))
+                continue;
+            await walk(root, rel, out);
+        }
+        else if (entry.isFile()) {
+            out.push(rel);
+        }
+    }
+    return out;
+}
+/**
+ * Tracked + untracked-but-not-ignored files under `dir`, relative to it, or
+ * null when `dir` is not in a git work tree (or git is missing).
+ */
+async function listGitFiles(dir) {
+    try {
+        const { stdout } = await execFileAsync('git', ['ls-files', '-z', '--cached', '--others', '--exclude-standard', '--', '.'], {
+            cwd: dir,
+            maxBuffer: 256 * 1024 * 1024,
+        });
+        return stdout.split('\0').filter(Boolean);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Copy the project into a fresh private temp dir. `files` (paths relative to
+ * `projectDir`, e.g. from `git ls-files`) limits the copy; without it the
+ * whole tree is walked. `.babelize/` is always included (it is often
+ * gitignored, but the lockfile in it is what keeps reruns incremental).
+ */
+async function createTempCopy(projectDir, opts = {}) {
+    const dir = await fsp.mkdtemp(path.join(opts.tmpRoot ?? (0, node_os_1.tmpdir)(), 'babelize-translate-'));
+    const cleanup = () => fsp.rm(dir, { recursive: true, force: true });
+    try {
+        const listed = opts.files ? opts.files.map(toPosix) : await walk(projectDir);
+        const files = new Set([...listed, ...(await walk(projectDir, exports.BABELIZE_DIR))]);
+        for (const rel of files) {
+            if (isExcluded(rel) || isEngineScratch(rel))
+                continue;
+            const src = safeJoin(projectDir, rel);
+            const st = await fsp.lstat(src).catch(() => null);
+            if (!st || !st.isFile())
+                continue; // deleted-but-tracked, symlink, or dir
+            const dest = safeJoin(dir, rel);
+            await fsp.mkdir(path.dirname(dest), { recursive: true });
+            await fsp.copyFile(src, dest);
+        }
+    }
+    catch (err) {
+        await cleanup();
+        throw err;
+    }
+    return { dir, cleanup };
+}
+/** Relative path → sha256 for every regular file under `root` (excluded dirs skipped). */
+async function snapshot(root) {
+    const result = new Map();
+    for (const rel of await walk(root)) {
+        const content = await fsp.readFile(path.join(root, rel));
+        result.set(rel, (0, node_crypto_1.createHash)('sha256').update(content).digest('hex'));
+    }
+    return result;
+}
+function diffSnapshots(before, after) {
+    const added = [];
+    const modified = [];
+    const deleted = [];
+    for (const [rel, hash] of after) {
+        if (isEngineScratch(rel))
+            continue;
+        const prev = before.get(rel);
+        if (prev === undefined)
+            added.push(rel);
+        else if (prev !== hash)
+            modified.push(rel);
+    }
+    for (const rel of before.keys()) {
+        if (!after.has(rel) && !isEngineScratch(rel))
+            deleted.push(rel);
+    }
+    return { added: added.sort(), modified: modified.sort(), deleted: deleted.sort() };
+}
+function changeCount(changes) {
+    return changes.added.length + changes.modified.length + changes.deleted.length;
+}
+/**
+ * Project files that no longer match what the run started from: a file the
+ * run would overwrite or delete was edited (or removed) meanwhile, or a file
+ * it would create now exists (created during the run, or never copied
+ * because it is gitignored). Applying over those would lose the user's work.
+ */
+async function findConflicts(changes, baseline, projectDir) {
+    const conflicts = [];
+    const hashOf = async (rel) => {
+        try {
+            return (0, node_crypto_1.createHash)('sha256').update(await fsp.readFile(safeJoin(projectDir, rel))).digest('hex');
+        }
+        catch (err) {
+            if (err.code === 'ENOENT')
+                return null;
+            throw err;
+        }
+    };
+    for (const rel of [...changes.modified, ...changes.deleted]) {
+        if ((await hashOf(rel)) !== baseline.get(rel))
+            conflicts.push(rel);
+    }
+    for (const rel of changes.added) {
+        if ((await hashOf(rel)) !== null)
+            conflicts.push(rel);
+    }
+    return conflicts.sort();
+}
+const defaultIo = {
+    copyFile: (s, d) => fsp.copyFile(s, d),
+    rename: (a, b) => fsp.rename(a, b),
+    unlink: (f) => fsp.unlink(f),
+    writeFile: (f, d) => fsp.writeFile(f, d),
+    remove: (f) => fsp.rm(f, { force: true }),
+};
+/**
+ * applyChanges failed. When `rolledBack` is true the project is exactly as it
+ * was before; otherwise `changedFiles` lists what is still different.
+ */
+class ApplyError extends Error {
+    constructor(message, cause, rolledBack, changedFiles) {
+        super(message);
+        this.cause = cause;
+        this.rolledBack = rolledBack;
+        this.changedFiles = changedFiles;
+        this.name = 'ApplyError';
+    }
+}
+exports.ApplyError = ApplyError;
+/**
+ * Apply the engine's changes from the temp copy to the project, as one
+ * transaction: originals of every file about to be overwritten or deleted are
+ * read into memory first, each write goes through temp file + rename, and on
+ * any failure every file already touched is restored (new files removed).
+ */
+async function applyChanges(changes, fromDir, toDir, io = defaultIo) {
+    const backups = new Map();
+    for (const rel of [...changes.modified, ...changes.deleted]) {
+        const abs = safeJoin(toDir, rel);
+        const content = await fsp.readFile(abs).catch((err) => {
+            if (err.code === 'ENOENT')
+                return null;
+            throw err;
+        });
+        if (content)
+            backups.set(rel, content);
+    }
+    const touched = [];
+    try {
+        for (const rel of [...changes.added, ...changes.modified]) {
+            const src = safeJoin(fromDir, rel);
+            const dest = safeJoin(toDir, rel);
+            await fsp.mkdir(path.dirname(dest), { recursive: true });
+            const staging = `${dest}.babelize-tmp-${process.pid}`;
+            try {
+                await io.copyFile(src, staging);
+                await io.rename(staging, dest);
+                touched.push(rel);
+            }
+            finally {
+                await fsp.rm(staging, { force: true });
+            }
+        }
+        for (const rel of changes.deleted) {
+            await io.unlink(safeJoin(toDir, rel)).catch((err) => {
+                if (err.code !== 'ENOENT')
+                    throw err;
+            });
+            touched.push(rel);
+        }
+    }
+    catch (err) {
+        const notRestored = [];
+        for (const rel of touched.reverse()) {
+            const abs = safeJoin(toDir, rel);
+            try {
+                const original = backups.get(rel);
+                if (original)
+                    await io.writeFile(abs, original);
+                else
+                    await io.remove(abs);
+            }
+            catch {
+                notRestored.push(rel);
+            }
+        }
+        const reason = err?.message ?? String(err);
+        if (notRestored.length === 0) {
+            throw new ApplyError(`Writing changes failed (${reason}); all changes were rolled back.`, err, true, []);
+        }
+        throw new ApplyError(`Writing changes failed (${reason}) and ${notRestored.length} file(s) could not be restored.`, err, false, notRestored.sort());
+    }
+}
+/** Unified diff (git-style a/ b/ headers) of what applyChanges would do. */
+async function renderUnifiedDiff(changes, beforeDir, afterDir) {
+    const read = (root, rel) => fsp.readFile(safeJoin(root, rel), 'utf8');
+    const patches = [];
+    const all = [
+        ...changes.added.map((rel) => ({ rel, kind: 'added' })),
+        ...changes.modified.map((rel) => ({ rel, kind: 'modified' })),
+        ...changes.deleted.map((rel) => ({ rel, kind: 'deleted' })),
+    ].sort((a, b) => a.rel.localeCompare(b.rel));
+    for (const { rel, kind } of all) {
+        const oldText = kind === 'added' ? '' : await read(beforeDir, rel);
+        const newText = kind === 'deleted' ? '' : await read(afterDir, rel);
+        const header = `diff --git a/${rel} b/${rel}\n` +
+            (kind === 'added' ? 'new file\n' : kind === 'deleted' ? 'deleted file\n' : '');
+        const patch = (0, diff_1.createPatch)(rel, oldText, newText, '', '', { context: 3 })
+            // createPatch emits "Index: x\n===\n--- x\n+++ x"; rewrite to git's a/ b/ form.
+            .replace(/^Index: .*\n=+\n/, '')
+            .replace(/^--- .*$/m, kind === 'added' ? '--- /dev/null' : `--- a/${rel}`)
+            .replace(/^\+\+\+ .*$/m, kind === 'deleted' ? '+++ /dev/null' : `+++ b/${rel}`);
+        patches.push(header + patch);
+    }
+    return patches.join('');
+}
+function lineCount(text) {
+    if (!text)
+        return 0;
+    return text.split('\n').length - (text.endsWith('\n') ? 1 : 0);
+}
+/**
+ * Lines added/removed per changed file, from the files' old and new content
+ * (never from a rendered diff). Unreadable files count as empty.
+ */
+async function diffStats(changes, beforeDir, afterDir) {
+    const read = (root, rel) => fsp.readFile(safeJoin(root, rel), 'utf8').catch(() => '');
+    const out = [];
+    for (const file of changes.added)
+        out.push({ file, kind: 'added', added: lineCount(await read(afterDir, file)), removed: 0 });
+    for (const file of changes.deleted)
+        out.push({ file, kind: 'deleted', added: 0, removed: lineCount(await read(beforeDir, file)) });
+    for (const file of changes.modified) {
+        let added = 0;
+        let removed = 0;
+        for (const part of (0, diff_1.diffLines)(await read(beforeDir, file), await read(afterDir, file))) {
+            if (part.added)
+                added += part.count ?? lineCount(part.value);
+            else if (part.removed)
+                removed += part.count ?? lineCount(part.value);
+        }
+        out.push({ file, kind: 'modified', added, removed });
+    }
+    return out.sort((a, b) => a.file.localeCompare(b.file));
+}

package/dist/modules/extractor/extract.d.ts

@@ -0,0 +1,20 @@
+import type { ExtractedString, Phase1Result, Warning, WorkspaceInfo } from '../../runtime/types';
+import type { NotInjectedString } from '../../runtime/types';
+export interface ExtractOptions {
+    /**
+     * Group JSX sentences into one message. Off when the runtime can't format
+     * ICU (react-i18next without i18next-icu). Default: on for React/Next.js.
+     */
+    sentences?: boolean;
+    /** Generate ICU plurals in sentences ("{count} items"). Needs an LLM translator. Default true. */
+    plurals?: boolean;
+}
+export declare function extractStrings(workspace: WorkspaceInfo, filesToProcess?: string[], extractOptions?: ExtractOptions): Promise<Phase1Result>;
+export declare function extractStringsFromFile(content: string, filePath: string, detectFormats?: boolean, options?: {
+    relaxComponentGuard?: boolean;
+    framework?: string;
+} & ExtractOptions): Promise<{
+    strings: ExtractedString[];
+    warnings: Warning[];
+    notInjected?: NotInjectedString[];
+}>;