@babelize/engine 0.0.0-stage → 0.1.0

package/dist/utils/key-usage.js

@@ -0,0 +1,247 @@
+"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.scanKeyReferences = scanKeyReferences;
+exports.findKeyUsage = findKeyUsage;
+exports.reportKeyUsage = reportKeyUsage;
+const path = __importStar(require("path"));
+const types_1 = require("../runtime/types");
+const logger_1 = require("./logger");
+const file_utils_1 = require("./file-utils");
+const ast_helpers_1 = require("./ast-helpers");
+const CALL_RE = /(?:\$t|\bt(?:\.(?:rich|markup|raw|has))?)\(\s*/g;
+/**
+ * Names the translator is bound to in a file besides `t` — the injector uses
+ * an alias (`tr`, `tr2`) where `t` is taken: `const tr = useTranslations()`,
+ * `const tr = await getTranslations()`, `const { t: tr } = useTranslation()`.
+ */
+const HOOK_ALIAS_RE = /\bconst\s+([A-Za-z_$][\w$]*)\s*=\s*(?:await\s+)?(?:useTranslations|getTranslations)\(/g;
+const DESTRUCTURED_ALIAS_RE = /\bconst\s*\{[^}]*?\bt\s*:\s*([A-Za-z_$][\w$]*)[^}]*\}\s*=\s*useTranslation\(/g;
+function translatorNames(content) {
+    const names = new Set(['t']);
+    for (const m of content.matchAll(HOOK_ALIAS_RE))
+        names.add(m[1]);
+    for (const m of content.matchAll(DESTRUCTURED_ALIAS_RE))
+        names.add(m[1]);
+    return [...names];
+}
+function callPattern(names) {
+    const escaped = names.map((n) => n.replace(/[$]/g, '\\$')).join('|');
+    // Same shape as CALL_RE (`i18n.t(` still counts), with the aliases added.
+    return new RegExp(`(?:\\$t|(?<![\\w$])(?:${escaped})(?:\\.(?:rich|markup|raw|has))?)\\(\\s*`, 'g');
+}
+const LITERAL_ARG_RE = /^(['"`])((?:(?!\1)[^\\$\n]|\\.)*)\1/;
+const ATTR_RE = /(?:\bi18nKey|\bdata-i18n(?:-[\w-]+)?)\s*=\s*(?:\{\s*)?(['"`])([^'"`$]+)\1/g;
+const NAMESPACE_RE = /\b(?:useTranslations|getTranslations)\(\s*(?:(['"`])([^'"`$]+)\1|\{[^}]*?\bnamespace\s*:\s*(['"`])([^'"`$]+)\3)/g;
+/** Data attributes that are configuration, not keys. */
+const NON_KEY_ATTRS = /^data-i18n-(?:args|html)$/;
+function scanKeyReferences(content) {
+    const keys = [];
+    let dynamic = false;
+    const namespaces = [];
+    for (const m of content.matchAll(NAMESPACE_RE))
+        namespaces.push(m[2] ?? m[4]);
+    const names = translatorNames(content);
+    let nonLiteral = false;
+    for (const m of content.matchAll(names.length > 1 ? callPattern(names) : CALL_RE)) {
+        const rest = content.slice((m.index ?? 0) + m[0].length);
+        if (rest.startsWith(')'))
+            continue; // t() — not a lookup
+        const literal = LITERAL_ARG_RE.exec(rest);
+        if (literal) {
+            keys.push(literal[2]);
+        }
+        else {
+            nonLiteral = true;
+        }
+    }
+    if (nonLiteral) {
+        // `t(tab)` over a module constant the injector rewrote to keys is not
+        // dynamic: its keys are the constant's string literals.
+        const resolved = resolveConstantKeys(content, names);
+        if (resolved)
+            keys.push(...resolved);
+        else
+            dynamic = true;
+    }
+    for (const m of content.matchAll(ATTR_RE)) {
+        const attr = m[0].split(/\s*=/)[0];
+        if (NON_KEY_ATTRS.test(attr))
+            continue;
+        keys.push(m[2]);
+    }
+    const withNamespaces = [...keys];
+    for (const ns of namespaces)
+        for (const k of keys)
+            withNamespaces.push(`${ns}.${k}`);
+    return { keys: withNamespaces, dynamic };
+}
+async function findKeyUsage(workspace) {
+    const referenced = new Set();
+    const dynamicFiles = [];
+    const seen = new Set();
+    for (const dir of workspace.sourceDirs) {
+        const files = await (0, file_utils_1.findFiles)(path.join(workspace.path, dir), types_1.SUPPORTED_EXTENSIONS, types_1.EXCLUDED_PATTERNS);
+        for (const file of files) {
+            if (seen.has(file))
+                continue;
+            seen.add(file);
+            const content = await (0, file_utils_1.readFile)(file).catch(() => '');
+            const { keys, dynamic } = scanKeyReferences(content);
+            for (const k of keys)
+                referenced.add(k);
+            if (dynamic)
+                dynamicFiles.push(path.relative(workspace.path, file).split(path.sep).join('/'));
+        }
+    }
+    return { referenced, dynamicFiles };
+}
+/**
+ * Keys of translator calls whose argument comes from a module-level constant
+ * of string literals (`CONST.map((x) => t(x))`, `t(x.label)`, `t(CONST.prop)`,
+ * `t(CONST[0])`). Null when any non-literal call can't be resolved that way
+ * (or the file doesn't parse): the file is dynamic.
+ */
+function resolveConstantKeys(content, names) {
+    let ast;
+    try {
+        ast = (0, ast_helpers_1.parseCode)(content);
+    }
+    catch {
+        return null;
+    }
+    const keys = [];
+    let unresolved = false;
+    const literalsOf = (init) => {
+        if (!init)
+            return null;
+        const out = [];
+        const take = (node) => {
+            if (ast_helpers_1.t.isStringLiteral(node)) {
+                out.push(node.value);
+                return true;
+            }
+            if (ast_helpers_1.t.isObjectExpression(node)) {
+                for (const p of node.properties)
+                    if (ast_helpers_1.t.isObjectProperty(p) && ast_helpers_1.t.isStringLiteral(p.value))
+                        out.push(p.value.value);
+                return true;
+            }
+            return false;
+        };
+        if (ast_helpers_1.t.isArrayExpression(init)) {
+            for (const e of init.elements)
+                if (!e || !take(e))
+                    return null;
+            return out;
+        }
+        return ast_helpers_1.t.isObjectExpression(init) && take(init) ? out : null;
+    };
+    /** The module-level `const` an identifier refers to, if any. */
+    const moduleConst = (p, name) => {
+        const binding = p.scope.getBinding(name);
+        if (!binding || binding.kind !== 'const' || binding.scope.block.type !== 'Program' || !binding.path.isVariableDeclarator())
+            return null;
+        return binding.path.node.init ?? null;
+    };
+    /** `x` where x is the item parameter of `CONST.map(...)`. */
+    const mapItemSource = (p, name) => {
+        const binding = p.scope.getBinding(name);
+        if (!binding || binding.kind !== 'param')
+            return null;
+        const fn = binding.path.parentPath;
+        const call = fn?.parentPath;
+        if (!fn || !call?.isCallExpression() || call.node.arguments[0] !== fn.node)
+            return null;
+        const callee = call.node.callee;
+        if (!ast_helpers_1.t.isMemberExpression(callee) || !ast_helpers_1.t.isIdentifier(callee.property, { name: 'map' }) || !ast_helpers_1.t.isIdentifier(callee.object))
+            return null;
+        return moduleConst(call, callee.object.name);
+    };
+    (0, ast_helpers_1.traverse)(ast, {
+        CallExpression(p) {
+            const callee = p.node.callee;
+            const isTranslator = (ast_helpers_1.t.isIdentifier(callee) && (names.includes(callee.name) || callee.name === '$t')) ||
+                (ast_helpers_1.t.isMemberExpression(callee) && !callee.computed && ast_helpers_1.t.isIdentifier(callee.property) &&
+                    (callee.property.name === 't' ||
+                        (ast_helpers_1.t.isIdentifier(callee.object) && names.includes(callee.object.name) && ['rich', 'markup', 'raw', 'has'].includes(callee.property.name))));
+            if (!isTranslator)
+                return;
+            const arg = p.node.arguments[0];
+            if (!arg || ast_helpers_1.t.isStringLiteral(arg) || (ast_helpers_1.t.isTemplateLiteral(arg) && arg.expressions.length === 0))
+                return;
+            let source = null;
+            if (ast_helpers_1.t.isIdentifier(arg))
+                source = mapItemSource(p, arg.name);
+            else if (ast_helpers_1.t.isMemberExpression(arg) && ast_helpers_1.t.isIdentifier(arg.object))
+                source = mapItemSource(p, arg.object.name) ?? moduleConst(p, arg.object.name);
+            const literals = literalsOf(source);
+            if (literals)
+                keys.push(...literals);
+            else
+                unresolved = true;
+        },
+    });
+    return unresolved ? null : keys;
+}
+const PLURAL_SUFFIX = /_(?:zero|one|two|few|many|other)$/;
+/** A source key looks used if referenced as-is, by its plural base, or under a referenced subtree. */
+function isKeyReferenced(key, referenced) {
+    if (referenced.has(key))
+        return true;
+    const base = key.replace(PLURAL_SUFFIX, '');
+    if (base !== key && referenced.has(base))
+        return true;
+    const parts = key.split('.');
+    for (let i = parts.length - 1; i > 0; i--) {
+        if (referenced.has(parts.slice(0, i).join('.')))
+            return true;
+    }
+    return false;
+}
+/** Report-only: source keys with no t() reference found. Never used to skip or drop anything. */
+async function reportKeyUsage(workspace, sourceKeys, extractedNow) {
+    try {
+        const usage = await findKeyUsage(workspace);
+        if (usage.dynamicFiles.length > 0)
+            return { unused: [], dynamicFiles: usage.dynamicFiles };
+        const unused = Object.keys(sourceKeys).filter((k) => !extractedNow.has(k) && !isKeyReferenced(k, usage.referenced));
+        return { unused: unused.sort(), dynamicFiles: [] };
+    }
+    catch (err) {
+        logger_1.engineLogger.warn('Key usage scan failed', { error: err instanceof Error ? err.message : String(err) });
+        return { unused: [], dynamicFiles: [] };
+    }
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Engine logging. The engine has no logging backend of its own: hosts call
+ * setEngineLogger() to route engine logs into theirs (the backend passes its
+ * structured logger). Until then, warnings and errors go to the console and
+ * info/debug are dropped, so library users (CLI, tests) aren't flooded.
+ */
+export interface LogContext {
+    [key: string]: any;
+}
+export interface EngineLogger {
+    debug(message: string, context?: LogContext): void;
+    info(message: string, context?: LogContext): void;
+    warn(message: string, context?: LogContext): void;
+    error(message: string, context?: LogContext): void;
+}
+/** Process-wide default logger (the backend's structured logger). */
+export declare function setEngineLogger(logger: EngineLogger): void;
+/**
+ * Run `fn` with `logger` receiving every engine log made inside it (including
+ * across awaits), without touching the process-wide logger. Concurrent runs
+ * in one process (a long-lived MCP server) each keep their own logs.
+ */
+export declare function runWithEngineLogger<T>(logger: EngineLogger, fn: () => T): T;
+export declare const engineLogger: EngineLogger;

package/dist/utils/logger.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.engineLogger = void 0;
+exports.setEngineLogger = setEngineLogger;
+exports.runWithEngineLogger = runWithEngineLogger;
+const async_hooks_1 = require("async_hooks");
+const consoleLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: (message, context) => console.warn(`[engine] ${message}`, context ?? ''),
+    error: (message, context) => console.error(`[engine] ${message}`, context ?? ''),
+};
+let impl = consoleLogger;
+const scoped = new async_hooks_1.AsyncLocalStorage();
+/** Process-wide default logger (the backend's structured logger). */
+function setEngineLogger(logger) {
+    impl = logger;
+}
+/**
+ * Run `fn` with `logger` receiving every engine log made inside it (including
+ * across awaits), without touching the process-wide logger. Concurrent runs
+ * in one process (a long-lived MCP server) each keep their own logs.
+ */
+function runWithEngineLogger(logger, fn) {
+    return scoped.run(logger, fn);
+}
+const current = () => scoped.getStore() ?? impl;
+exports.engineLogger = {
+    debug: (message, context) => current().debug(message, context),
+    info: (message, context) => current().info(message, context),
+    warn: (message, context) => current().warn(message, context),
+    error: (message, context) => current().error(message, context),
+};

package/dist/utils/metadata.d.ts

@@ -0,0 +1,80 @@
+/**
+ * .babelize Metadata Utilities (engine v2).
+ *
+ * Moved from v1 engine utils so the v1 engine can be deleted cleanly while
+ * workers/controllers keep using the same metadata behaviors.
+ */
+export interface BabelHistoryEntry {
+    id: string;
+    timestamp: string;
+    duration: number;
+    status: 'success' | 'failed' | 'partial';
+    targetLocales: string[];
+    stats: {
+        filesProcessed: number;
+        stringsExtracted: number;
+        stringsTranslated: number;
+        errors: number;
+    };
+    error?: string;
+}
+export interface ExtractedStringEntry {
+    key: string;
+    originalText: string;
+    sourceFile: string;
+    line: number;
+    context?: string;
+    lastUpdated: string;
+}
+export interface BabelizeConfig {
+    sourceLocale: string;
+    targetLocales: string[];
+    confidenceThreshold: number;
+    excludePatterns: string[];
+    customTranslations: Record<string, Record<string, string>>;
+}
+export type FrameworkType = 'react' | 'nextjs' | 'vue' | 'angular' | 'svelte' | 'astro' | 'remix' | 'gatsby' | 'nuxt' | 'static' | 'unknown';
+export type PackageManagerType = 'npm' | 'yarn' | 'pnpm' | 'bun';
+export interface ProjectInfo {
+    framework: FrameworkType;
+    frameworks?: FrameworkType[];
+    frameworkVersion?: string;
+    packageManager: PackageManagerType | 'unknown';
+    packageManagers: PackageManagerType[];
+    nodeVersion?: string;
+    projectVersion?: string;
+    projectName?: string;
+    dependencies: {
+        react?: string;
+        next?: string;
+        vue?: string;
+        angular?: string;
+        svelte?: string;
+        astro?: string;
+        remix?: string;
+        gatsby?: string;
+        nuxt?: string;
+        'react-i18next'?: string;
+    };
+    detectedAt: string;
+}
+export declare function getBabelizeDir(workspacePath: string): string;
+export declare function ensureBabelizeDir(workspacePath: string): Promise<string>;
+export declare function getBabelHistory(workspacePath: string): Promise<BabelHistoryEntry[]>;
+export declare function addBabelToHistory(workspacePath: string, babel: BabelHistoryEntry): Promise<void>;
+export declare function getLastSuccessfulBabel(workspacePath: string): Promise<BabelHistoryEntry | null>;
+export declare function getCachedStrings(workspacePath: string): Promise<ExtractedStringEntry[]>;
+export declare function saveCachedStrings(workspacePath: string, strings: ExtractedStringEntry[]): Promise<void>;
+export declare function clearCachedStrings(workspacePath: string): Promise<void>;
+export declare function getProjectConfig(workspacePath: string): Promise<BabelizeConfig>;
+export declare function saveProjectConfig(workspacePath: string, config: Partial<BabelizeConfig>): Promise<void>;
+export declare function getBabelizeSummary(workspacePath: string): Promise<{
+    hasHistory: boolean;
+    babelCount: number;
+    lastBabel: BabelHistoryEntry | null;
+    lastSuccessfulBabel: BabelHistoryEntry | null;
+    cachedStringsCount: number;
+    config: BabelizeConfig;
+}>;
+export declare function detectProjectInfo(workspacePath: string): Promise<ProjectInfo>;
+export declare function getProjectInfo(workspacePath: string): Promise<ProjectInfo | null>;

package/dist/utils/metadata.js

@@ -0,0 +1,255 @@
+"use strict";
+/**
+ * .babelize Metadata Utilities (engine v2).
+ *
+ * Moved from v1 engine utils so the v1 engine can be deleted cleanly while
+ * workers/controllers keep using the same metadata behaviors.
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBabelizeDir = getBabelizeDir;
+exports.ensureBabelizeDir = ensureBabelizeDir;
+exports.getBabelHistory = getBabelHistory;
+exports.addBabelToHistory = addBabelToHistory;
+exports.getLastSuccessfulBabel = getLastSuccessfulBabel;
+exports.getCachedStrings = getCachedStrings;
+exports.saveCachedStrings = saveCachedStrings;
+exports.clearCachedStrings = clearCachedStrings;
+exports.getProjectConfig = getProjectConfig;
+exports.saveProjectConfig = saveProjectConfig;
+exports.getBabelizeSummary = getBabelizeSummary;
+exports.detectProjectInfo = detectProjectInfo;
+exports.getProjectInfo = getProjectInfo;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const logger_1 = require("./logger");
+const DEFAULT_CONFIG = {
+    sourceLocale: 'en',
+    targetLocales: [],
+    confidenceThreshold: 80,
+    excludePatterns: ['node_modules/**', '.git/**', 'dist/**', 'build/**'],
+    customTranslations: {},
+};
+function getBabelizeDir(workspacePath) {
+    return path.join(workspacePath, '.babelize');
+}
+async function ensureBabelizeDir(workspacePath) {
+    const babelizeDir = getBabelizeDir(workspacePath);
+    await fs.ensureDir(babelizeDir);
+    return babelizeDir;
+}
+async function getBabelHistory(workspacePath) {
+    const historyPath = path.join(getBabelizeDir(workspacePath), 'babel-history.json');
+    if (await fs.pathExists(historyPath)) {
+        try {
+            return await fs.readJson(historyPath);
+        }
+        catch {
+            return [];
+        }
+    }
+    return [];
+}
+async function addBabelToHistory(workspacePath, babel) {
+    await ensureBabelizeDir(workspacePath);
+    const historyPath = path.join(getBabelizeDir(workspacePath), 'babel-history.json');
+    const history = await getBabelHistory(workspacePath);
+    history.unshift(babel);
+    const trimmedHistory = history.slice(0, 50);
+    await fs.writeJson(historyPath, trimmedHistory, { spaces: 2 });
+}
+async function getLastSuccessfulBabel(workspacePath) {
+    const history = await getBabelHistory(workspacePath);
+    return history.find((r) => r.status === 'success') || null;
+}
+async function getCachedStrings(workspacePath) {
+    const cachePath = path.join(getBabelizeDir(workspacePath), 'extracted-strings.json');
+    if (await fs.pathExists(cachePath)) {
+        try {
+            return await fs.readJson(cachePath);
+        }
+        catch {
+            return [];
+        }
+    }
+    return [];
+}
+async function saveCachedStrings(workspacePath, strings) {
+    await ensureBabelizeDir(workspacePath);
+    const cachePath = path.join(getBabelizeDir(workspacePath), 'extracted-strings.json');
+    await fs.writeJson(cachePath, strings, { spaces: 2 });
+}
+async function clearCachedStrings(workspacePath) {
+    const cachePath = path.join(getBabelizeDir(workspacePath), 'extracted-strings.json');
+    if (await fs.pathExists(cachePath))
+        await fs.remove(cachePath);
+}
+async function getProjectConfig(workspacePath) {
+    const configPath = path.join(getBabelizeDir(workspacePath), 'config.json');
+    if (await fs.pathExists(configPath)) {
+        try {
+            const config = await fs.readJson(configPath);
+            return { ...DEFAULT_CONFIG, ...config };
+        }
+        catch {
+            return DEFAULT_CONFIG;
+        }
+    }
+    return DEFAULT_CONFIG;
+}
+async function saveProjectConfig(workspacePath, config) {
+    await ensureBabelizeDir(workspacePath);
+    const configPath = path.join(getBabelizeDir(workspacePath), 'config.json');
+    const existingConfig = await getProjectConfig(workspacePath);
+    const mergedConfig = { ...existingConfig, ...config };
+    await fs.writeJson(configPath, mergedConfig, { spaces: 2 });
+}
+async function getBabelizeSummary(workspacePath) {
+    const history = await getBabelHistory(workspacePath);
+    const cachedStrings = await getCachedStrings(workspacePath);
+    const config = await getProjectConfig(workspacePath);
+    return {
+        hasHistory: history.length > 0,
+        babelCount: history.length,
+        lastBabel: history[0] || null,
+        lastSuccessfulBabel: history.find((r) => r.status === 'success') || null,
+        cachedStringsCount: cachedStrings.length,
+        config,
+    };
+}
+function detectPackageManagers(workspacePath) {
+    const detected = [];
+    if (fs.existsSync(path.join(workspacePath, 'bun.lockb')) || fs.existsSync(path.join(workspacePath, 'bun.lock'))) {
+        detected.push('bun');
+    }
+    if (fs.existsSync(path.join(workspacePath, 'pnpm-lock.yaml')))
+        detected.push('pnpm');
+    if (fs.existsSync(path.join(workspacePath, 'yarn.lock')))
+        detected.push('yarn');
+    if (fs.existsSync(path.join(workspacePath, 'package-lock.json')))
+        detected.push('npm');
+    return detected;
+}
+async function detectProjectInfo(workspacePath) {
+    await ensureBabelizeDir(workspacePath);
+    const packageJsonPath = path.join(workspacePath, 'package.json');
+    let packageJson = {};
+    if (await fs.pathExists(packageJsonPath)) {
+        try {
+            packageJson = await fs.readJson(packageJsonPath);
+        }
+        catch (err) {
+            logger_1.engineLogger.warn('Failed to read package.json', {
+                path: packageJsonPath,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    const frameworks = [];
+    let primaryFramework = 'unknown';
+    let frameworkVersion;
+    const frameworkChecks = [
+        { name: 'nextjs', dep: 'next' },
+        { name: 'nuxt', dep: 'nuxt' },
+        { name: 'gatsby', dep: 'gatsby' },
+        { name: 'remix', dep: '@remix-run/react' },
+        { name: 'astro', dep: 'astro' },
+        { name: 'vue', dep: 'vue' },
+        { name: 'svelte', dep: 'svelte' },
+        { name: 'angular', dep: '@angular/core' },
+        { name: 'react', dep: 'react' },
+    ];
+    for (const check of frameworkChecks) {
+        if (deps[check.dep]) {
+            frameworks.push(check.name);
+            if (primaryFramework === 'unknown') {
+                primaryFramework = check.name;
+                frameworkVersion = deps[check.dep];
+            }
+        }
+    }
+    if (primaryFramework === 'unknown' && frameworks.length === 0) {
+        const htmlFiles = await (0, fast_glob_1.default)('**/*.html', { cwd: workspacePath, onlyFiles: true, deep: 3 });
+        if (htmlFiles.length > 0) {
+            primaryFramework = 'static';
+            frameworks.push('static');
+            logger_1.engineLogger.info('Detected static HTML/CSS/JS project', { workspacePath });
+        }
+    }
+    const packageManagers = detectPackageManagers(workspacePath);
+    const primaryPackageManager = packageManagers.length > 0 ? packageManagers[0] : 'unknown';
+    const projectInfo = {
+        framework: primaryFramework,
+        frameworks: frameworks.length > 0 ? frameworks : undefined,
+        frameworkVersion,
+        packageManager: primaryPackageManager,
+        packageManagers,
+        projectVersion: packageJson.version,
+        projectName: packageJson.name,
+        dependencies: {
+            react: deps['react'],
+            next: deps['next'],
+            vue: deps['vue'],
+            angular: deps['@angular/core'],
+            svelte: deps['svelte'] || deps['@sveltejs/kit'],
+            astro: deps['astro'],
+            remix: deps['@remix-run/react'] || deps['remix'],
+            gatsby: deps['gatsby'],
+            nuxt: deps['nuxt'],
+            'react-i18next': deps['react-i18next'],
+        },
+        detectedAt: new Date().toISOString(),
+    };
+    const infoPath = path.join(getBabelizeDir(workspacePath), 'project-info.json');
+    await fs.writeJson(infoPath, projectInfo, { spaces: 2 });
+    return projectInfo;
+}
+async function getProjectInfo(workspacePath) {
+    const infoPath = path.join(getBabelizeDir(workspacePath), 'project-info.json');
+    if (await fs.pathExists(infoPath)) {
+        try {
+            return await fs.readJson(infoPath);
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}

package/dist/utils/module-constants.d.ts

@@ -0,0 +1,30 @@
+import type { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+/**
+ * UI copy in module-level constants, rendered inside components:
+ *
+ *   const TABS = ["Overview", "Settings"];
+ *   export default function Page() {
+ *     return <nav>{TABS.map((tab) => <a key={tab}>{tab}</a>)}</nav>;
+ *   }
+ *
+ * There's no hook at module level, so the strings can't be replaced in
+ * place. When every use of the copy is provably a render (a JSX child, a
+ * translatable attribute, or a React `key`), the constant's strings become
+ * translation keys and each render becomes `t(tab)`. Otherwise — the values
+ * are also data (compared, sent, used in URLs) — nothing is rewritten and the
+ * strings are reported, so a run doesn't claim everything was translated.
+ */
+export interface ModuleConstantPlan {
+    name: string;
+    /** Every use of the copy is a render: safe to rewrite. */
+    provable: boolean;
+    /** The UI strings that are rendered (rewritten to keys when provable). */
+    literals: Array<NodePath<t.StringLiteral>>;
+    /** Expressions that render a string (`tab`, `item.label`), wrapped in `t()` when provable. */
+    renderSites: Array<NodePath<t.Expression>>;
+    /** Why it isn't provable, when it isn't. */
+    reason?: string;
+}
+/** Plans for a file's module-level UI constants that are rendered in components. */
+export declare function analyzeModuleConstants(ast: t.File): ModuleConstantPlan[];