@babelize/engine 0.0.0-stage → 0.1.0

package/dist/modules/vue/template-scan.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanTemplate = scanTemplate;
+const compiler_dom_1 = require("@vue/compiler-dom");
+const TRANSLATABLE_ATTRS = new Set([
+    'alt',
+    'title',
+    'placeholder',
+    'aria-label',
+    'aria-description',
+    'label',
+    'text',
+]);
+const ATTR_DENY_LIST = new Set([
+    'class',
+    'style',
+    'id',
+    'key',
+    'ref',
+    'src',
+    'href',
+    'to',
+    'target',
+    'rel',
+    'type',
+    'width',
+    'height',
+    'rows',
+    'cols',
+    'data-testid',
+    'role',
+    'as',
+    'name',
+    'value',
+    'disabled',
+    'required',
+    'checked',
+    'multiple',
+    'hidden',
+    'tabindex',
+    'autofocus',
+    'accesskey',
+    'contenteditable',
+    'draggable',
+    'translate',
+    'dir',
+    'lang',
+    'slot',
+    'is',
+]);
+function hasVPre(node) {
+    return node.props.some((p) => p.type === compiler_dom_1.NodeTypes.ATTRIBUTE && p.name === 'v-pre');
+}
+function hasVHtml(node) {
+    return node.props.some((p) => p.type === compiler_dom_1.NodeTypes.DIRECTIVE && p.name === 'html');
+}
+function isInsideI18nT(node, ancestors) {
+    return ancestors.some((a) => a.tag === 'i18n-t' && a.tagType === compiler_dom_1.ElementTypes.ELEMENT);
+}
+function hasDollarTBinding(node) {
+    return node.props.some((p) => p.type === compiler_dom_1.NodeTypes.ATTRIBUTE &&
+        p.value?.content.includes('$t('));
+}
+function locToOffset(loc, templateOffset) {
+    return templateOffset + loc.start.offset;
+}
+function locToLine(loc) {
+    return loc.start.line;
+}
+function isTranslatableAttr(name) {
+    if (ATTR_DENY_LIST.has(name))
+        return false;
+    if (TRANSLATABLE_ATTRS.has(name))
+        return true;
+    if (/^(aria-|data-)/.test(name))
+        return false;
+    return true;
+}
+function extractBoundLiteralString(dir) {
+    const exp = dir.exp;
+    if (!exp)
+        return null;
+    if (exp.type !== compiler_dom_1.NodeTypes.SIMPLE_EXPRESSION)
+        return null;
+    const raw = exp.content.trim();
+    // Matches: 'string' or "string"
+    const match = raw.match(/^['"](.*)['"]$/);
+    if (match)
+        return match[1];
+    return null;
+}
+function extractTextContent(node) {
+    if (node.type === compiler_dom_1.NodeTypes.TEXT) {
+        return node.content;
+    }
+    return null;
+}
+function isStaticAttribute(prop) {
+    return prop.type === compiler_dom_1.NodeTypes.ATTRIBUTE;
+}
+function processElement(node, templateContent, templateOffset, filePath, hashFn, ancestors, skippedElements) {
+    const units = [];
+    if (hasVPre(node)) {
+        skippedElements.push(`${node.tag}:v-pre`);
+        return units;
+    }
+    if (hasVHtml(node)) {
+        skippedElements.push(`${node.tag}:v-html`);
+        return units;
+    }
+    if (isInsideI18nT(node, ancestors)) {
+        skippedElements.push(`${node.tag}:inside-i18n-t`);
+        return units;
+    }
+    if (hasDollarTBinding(node)) {
+        skippedElements.push(`${node.tag}:already-translated`);
+        return units;
+    }
+    // Process text children — merge adjacent text nodes and interpolations
+    const textRuns = buildTextRuns(node);
+    for (const run of textRuns) {
+        const runText = run.map((n) => extractTextContent(n)).join('');
+        if (!runText.trim())
+            continue;
+        const firstNode = run[0];
+        const lastNode = run[run.length - 1];
+        const offset = locToOffset(firstNode.loc, templateOffset);
+        const length = locToOffset(lastNode.loc, templateOffset) +
+            lastNode.loc.source.length -
+            offset;
+        const line = locToLine(firstNode.loc);
+        const id = `${filePath}:${line}:${hashFn(runText)}`;
+        units.push({
+            type: 'text',
+            text: runText,
+            line,
+            offset,
+            end: offset + length,
+            length,
+            id,
+            confidence: 1.0,
+        });
+    }
+    // Process attributes
+    for (const prop of node.props) {
+        if (isStaticAttribute(prop)) {
+            const name = prop.name.toLowerCase();
+            if (!isTranslatableAttr(name))
+                continue;
+            if (!prop.value)
+                continue;
+            const text = prop.value.content;
+            if (!text.trim())
+                continue;
+            const offset = locToOffset(prop.value.loc, templateOffset);
+            const length = prop.value.loc.source.length;
+            const line = locToLine(prop.value.loc);
+            const id = `${filePath}:${line}:${hashFn(text)}`;
+            units.push({
+                type: 'attr',
+                text,
+                line,
+                offset,
+                end: offset + length,
+                length,
+                id,
+                confidence: 1.0,
+                attrName: prop.name,
+                tagName: node.tag,
+                attrBoundLiteral: false,
+            });
+        }
+        else if (prop.type === compiler_dom_1.NodeTypes.DIRECTIVE &&
+            prop.name === 'bind' &&
+            prop.arg &&
+            prop.arg.type === compiler_dom_1.NodeTypes.SIMPLE_EXPRESSION &&
+            prop.arg.isStatic &&
+            !prop.modifiers.length) {
+            const attrName = prop.arg.content;
+            if (!isTranslatableAttr(attrName))
+                continue;
+            const literal = extractBoundLiteralString(prop);
+            if (literal === null)
+                continue;
+            const offset = locToOffset(prop.loc, templateOffset);
+            const length = prop.loc.source.length;
+            const line = locToLine(prop.loc);
+            const id = `${filePath}:${line}:${hashFn(literal)}`;
+            units.push({
+                type: 'attr',
+                text: literal,
+                line,
+                offset,
+                end: offset + length,
+                length,
+                id,
+                confidence: 1.0,
+                attrName,
+                tagName: node.tag,
+                attrBoundLiteral: true,
+            });
+        }
+        else if (prop.type === compiler_dom_1.NodeTypes.DIRECTIVE &&
+            prop.name === 'text') {
+            // v-text is dynamic — skip
+            skippedElements.push(`${node.tag}:v-text`);
+        }
+    }
+    return units;
+}
+function buildTextRuns(node) {
+    const runs = [];
+    let currentRun = [];
+    for (const child of node.children) {
+        if (child.type === compiler_dom_1.NodeTypes.TEXT ||
+            child.type === compiler_dom_1.NodeTypes.INTERPOLATION ||
+            child.type === compiler_dom_1.NodeTypes.COMPOUND_EXPRESSION) {
+            currentRun.push(child);
+        }
+        else {
+            if (currentRun.length > 0) {
+                runs.push(currentRun);
+                currentRun = [];
+            }
+        }
+    }
+    if (currentRun.length > 0) {
+        runs.push(currentRun);
+    }
+    return runs;
+}
+function walkNode(node, templateContent, templateOffset, filePath, hashFn, units, skippedElements, ancestors) {
+    if (node.type === compiler_dom_1.NodeTypes.ELEMENT) {
+        const element = node;
+        ancestors.push(element);
+        const elementUnits = processElement(element, templateContent, templateOffset, filePath, hashFn, ancestors, skippedElements);
+        units.push(...elementUnits);
+        for (const child of element.children) {
+            walkNode(child, templateContent, templateOffset, filePath, hashFn, units, skippedElements, ancestors);
+        }
+        ancestors.pop();
+    }
+    else if (node.type === compiler_dom_1.NodeTypes.IF) {
+        for (const branch of node.branches) {
+            for (const child of branch.children) {
+                walkNode(child, templateContent, templateOffset, filePath, hashFn, units, skippedElements, ancestors);
+            }
+        }
+    }
+    else if (node.type === compiler_dom_1.NodeTypes.FOR) {
+        for (const child of node.children) {
+            walkNode(child, templateContent, templateOffset, filePath, hashFn, units, skippedElements, ancestors);
+        }
+    }
+}
+function scanTemplate(templateContent, filePath, templateOffset, hashFn) {
+    const units = [];
+    const skippedElements = [];
+    const root = (0, compiler_dom_1.parse)(templateContent);
+    for (const child of root.children) {
+        walkNode(child, templateContent, templateOffset, filePath, hashFn, units, skippedElements, []);
+    }
+    return { units, skippedElements };
+}

package/dist/modules/workspace/index.d.ts

@@ -0,0 +1 @@
+export { validateWorkspace } from './validate';

package/dist/modules/workspace/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateWorkspace = void 0;
+var validate_1 = require("./validate");
+Object.defineProperty(exports, "validateWorkspace", { enumerable: true, get: function () { return validate_1.validateWorkspace; } });

package/dist/modules/workspace/validate.d.ts

@@ -0,0 +1,13 @@
+import type { EngineConfigV2, Phase0Result } from '../../runtime/types';
+interface PackageJson {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    [key: string]: unknown;
+}
+export declare function validateWorkspace(config: EngineConfigV2): Promise<Phase0Result>;
+export declare function checkI18nDependencies(packageJson: PackageJson, framework?: string): Promise<{
+    hasReactI18next: boolean;
+    hasI18next: boolean;
+    recommendation: string | null;
+}>;
+export {};

package/dist/modules/workspace/validate.js

@@ -0,0 +1,298 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateWorkspace = validateWorkspace;
+exports.checkI18nDependencies = checkI18nDependencies;
+const path = __importStar(require("path"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const types_1 = require("@babelize/types");
+const logger_1 = require("../../utils/logger");
+const file_utils_1 = require("../../utils/file-utils");
+// Python/Django detection — runs BEFORE the static fallback
+async function detectPythonFramework(workspacePath) {
+    // Check for manage.py (Django)
+    if (await (0, file_utils_1.pathExists)(path.join(workspacePath, 'manage.py'))) {
+        return 'django';
+    }
+    // Check for Django in requirements/pyproject
+    const configFiles = ['pyproject.toml', 'requirements.txt', 'Pipfile'];
+    for (const file of configFiles) {
+        const content = await (0, file_utils_1.readFile)(path.join(workspacePath, file)).catch(() => '');
+        if (content && /django/i.test(content)) {
+            return 'django';
+        }
+    }
+    // Check for settings.py
+    const settingsFiles = await (0, fast_glob_1.default)('**/settings.py', { cwd: workspacePath, onlyFiles: true, deep: 4 });
+    if (settingsFiles.length > 0) {
+        return 'django';
+    }
+    return null;
+}
+async function validateWorkspace(config) {
+    const { workspacePath } = config;
+    if (!(await (0, file_utils_1.pathExists)(workspacePath))) {
+        throw new Error(`Workspace path does not exist: ${workspacePath}`);
+    }
+    if (!(await (0, file_utils_1.isDirectory)(workspacePath))) {
+        throw new Error(`Workspace path is not a directory: ${workspacePath}`);
+    }
+    const packageJsonPath = path.join(workspacePath, 'package.json');
+    let packageJson = await (0, file_utils_1.readJsonFile)(packageJsonPath);
+    let framework = 'unknown';
+    let isStatic = false;
+    if (config.framework && types_1.SUPPORTED_FRAMEWORKS.includes(config.framework)) {
+        framework = config.framework;
+        logger_1.engineLogger.info('Using explicit framework override', { framework });
+    }
+    if (!framework || framework === 'unknown') {
+        const pythonFramework = await detectPythonFramework(workspacePath);
+        if (pythonFramework) {
+            framework = pythonFramework;
+            logger_1.engineLogger.info('Detected Python framework', { framework });
+        }
+    }
+    if (!packageJson) {
+        const htmlFiles = await (0, fast_glob_1.default)('**/*.html', { cwd: workspacePath, onlyFiles: true, deep: 6 });
+        if (htmlFiles.length > 0) {
+            // Check for server-template markers
+            let hasServerTemplates = false;
+            for (const file of htmlFiles.slice(0, 10)) {
+                const content = await (0, file_utils_1.readFile)(path.join(workspacePath, file)).catch(() => '');
+                if (/\{%|<\?php|<%=/.test(content)) {
+                    hasServerTemplates = true;
+                    logger_1.engineLogger.warn('Found server-template markers, refusing static classification', { file });
+                    break;
+                }
+            }
+            if (!hasServerTemplates && framework === 'unknown') {
+                framework = 'static';
+                packageJson = {};
+                isStatic = true;
+                logger_1.engineLogger.info('Detected static HTML/CSS/JS project');
+            }
+        }
+        else if (framework === 'unknown') {
+            throw new Error('Babelize currently supports only React, Next.js, Vue, and plain HTML/CSS/JS projects. ' +
+                'No package.json or HTML files found.');
+        }
+    }
+    else if (framework === 'unknown') {
+        framework = detectFramework(packageJson);
+    }
+    if (framework === 'unknown' && !isStatic) {
+        const workspacePatterns = getWorkspacePatterns(packageJson);
+        if (workspacePatterns.length > 0) {
+            const matchedDirs = await (0, fast_glob_1.default)(workspacePatterns, { cwd: workspacePath, onlyDirectories: true, deep: 3, absolute: true });
+            for (const dir of matchedDirs) {
+                const subPkgPath = path.join(dir, 'package.json');
+                const subPkg = await (0, file_utils_1.readJsonFile)(subPkgPath);
+                if (subPkg) {
+                    const subFramework = detectFramework(subPkg);
+                    if (subFramework !== 'unknown') {
+                        framework = subFramework;
+                        packageJson = subPkg;
+                        logger_1.engineLogger.info('Framework detected in workspace', { workspaceDir: path.relative(workspacePath, dir), framework });
+                        break;
+                    }
+                }
+            }
+        }
+        if (framework === 'unknown' && !isStatic) {
+            const entries = await (0, file_utils_1.readDir)(workspacePath);
+            for (const entry of entries) {
+                if (entry.startsWith('.'))
+                    continue;
+                const subDirPath = path.join(workspacePath, entry);
+                if (await (0, file_utils_1.isDirectory)(subDirPath)) {
+                    const subPkgPath = path.join(subDirPath, 'package.json');
+                    const subPkg = await (0, file_utils_1.readJsonFile)(subPkgPath);
+                    if (subPkg) {
+                        const subFramework = detectFramework(subPkg);
+                        if (subFramework !== 'unknown') {
+                            framework = subFramework;
+                            packageJson = subPkg;
+                            logger_1.engineLogger.info('Framework detected in subdirectory', { subDir: entry, framework });
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (!types_1.SUPPORTED_FRAMEWORKS.includes(framework)) {
+        throw new Error('Babelize currently supports only React, Next.js, Vue, and plain HTML/CSS/JS projects. ' +
+            'Other frameworks are not supported yet.');
+    }
+    const sourceDirs = await findSourceDirectories(workspacePath);
+    if (sourceDirs.length === 0) {
+        logger_1.engineLogger.info('No standard source directories found, defaulting to root');
+        sourceDirs.push('.');
+    }
+    const frameworkConfig = types_1.FRAMEWORK_CONFIGS[framework] || types_1.FRAMEWORK_CONFIGS['unknown'];
+    const localeFormat = frameworkConfig.localeFormat;
+    const existingLocales = [];
+    let hasLocalesDir = false;
+    if (localeFormat === 'po') {
+        // Django: check locale/<lang>/LC_MESSAGES/django.po structure
+        const djangoLocaleDir = path.join(workspacePath, 'locale');
+        hasLocalesDir = await (0, file_utils_1.isDirectory)(djangoLocaleDir);
+        if (hasLocalesDir) {
+            const langDirs = await (0, file_utils_1.readDir)(djangoLocaleDir);
+            for (const langDir of langDirs) {
+                const poFile = path.join(djangoLocaleDir, langDir, 'LC_MESSAGES', 'django.po');
+                if (await (0, file_utils_1.pathExists)(poFile)) {
+                    existingLocales.push(langDir);
+                }
+            }
+        }
+    }
+    else {
+        const localesDir = path.join(workspacePath, 'locales');
+        hasLocalesDir = await (0, file_utils_1.isDirectory)(localesDir);
+        const localeExt = (0, file_utils_1.localeExtension)(localeFormat);
+        if (hasLocalesDir) {
+            const localeFiles = await (0, file_utils_1.readDir)(localesDir);
+            for (const file of localeFiles) {
+                if (file.endsWith(localeExt))
+                    existingLocales.push(file.replace(localeExt, ''));
+            }
+        }
+    }
+    let publicDir = 'public';
+    if (sourceDirs.length > 0 && sourceDirs[0] !== '.') {
+        const firstSourceDir = sourceDirs[0];
+        const parts = firstSourceDir.split(/[\\/]/);
+        if (parts.length > 1) {
+            parts.pop();
+            publicDir = path.join(...parts, 'public');
+        }
+    }
+    if (framework === 'static') {
+        sourceDirs.length = 0;
+        sourceDirs.push('.');
+        publicDir = '.';
+    }
+    const babelizeDir = path.join(workspacePath, '.babelize');
+    await (0, file_utils_1.ensureDir)(babelizeDir);
+    const workspace = {
+        path: workspacePath,
+        framework,
+        localeFormat,
+        sourceDirs,
+        hasLocalesDir,
+        existingLocales,
+        publicDir,
+        packageJson: packageJson,
+        formatConfig: config.formatConfig,
+    };
+    return { workspace };
+}
+function getWorkspacePatterns(packageJson) {
+    const ws = packageJson?.workspaces;
+    if (Array.isArray(ws))
+        return ws;
+    if (ws && typeof ws === 'object' && Array.isArray(ws.packages))
+        return ws.packages;
+    return [];
+}
+function detectFramework(packageJson) {
+    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    if (deps['next'])
+        return 'nextjs';
+    if (deps['nuxt'])
+        return 'vue';
+    if (deps['vue'])
+        return 'vue';
+    const reactBasedFrameworks = ['gatsby', '@remix-run/react', 'astro'];
+    for (const dep of reactBasedFrameworks) {
+        if (deps[dep])
+            return 'react';
+    }
+    if (deps['react'])
+        return 'react';
+    const reactIndicators = [
+        'react-dom',
+        'react-icons',
+        'react-router-dom',
+        'react-router',
+        'react-scripts',
+        '@vitejs/plugin-react',
+        'react-modal',
+        'react-toastify',
+        'react-i18next',
+    ];
+    if (reactIndicators.some((pkg) => deps[pkg]))
+        return 'react';
+    return 'unknown';
+}
+async function findSourceDirectories(workspacePath) {
+    const possibleDirs = ['src', 'app', 'pages', 'components', 'features', 'modules', 'lib'];
+    const foundDirs = [];
+    for (const dir of possibleDirs) {
+        const fullPath = path.join(workspacePath, dir);
+        if (await (0, file_utils_1.isDirectory)(fullPath))
+            foundDirs.push(dir);
+    }
+    return foundDirs;
+}
+async function checkI18nDependencies(packageJson, framework) {
+    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    const hasReactI18next = !!deps['react-i18next'];
+    const hasI18next = !!deps['i18next'];
+    let recommendation = null;
+    if (framework === 'static') {
+        recommendation = null; // Static HTML projects do not require npm packages
+    }
+    else if (framework === 'nextjs') {
+        if (!deps['next-intl'])
+            recommendation = 'Run: bun install next-intl';
+    }
+    else if (framework === 'vue') {
+        if (!deps['vue-i18n'])
+            recommendation = 'Run: bun install vue-i18n';
+    }
+    else {
+        // React / vanilla / unknown
+        if (!hasI18next)
+            recommendation = 'Run: bun install i18next react-i18next';
+        else if (!hasReactI18next)
+            recommendation = 'Run: bun install react-i18next';
+    }
+    return { hasReactI18next, hasI18next, recommendation };
+}

package/dist/orchestrator.d.ts

@@ -0,0 +1,8 @@
+import type { EngineConfigV2, EngineResultV2 } from './runtime/types';
+/**
+ * Engine v2 Orchestrator (backend runtime)
+ *
+ * This is the single, clean wiring layer for the pipeline.
+ * Workers/controllers call `runEngineV2()`.
+ */
+export declare function runEngineV2(config: EngineConfigV2): Promise<EngineResultV2>;