@babelize/engine 0.0.0-stage → 0.1.2

package/dist/modules/workspace/validate.js

@@ -0,0 +1,333 @@
+"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");
+const stack_1 = require("../../detection/stack");
+const django_finalize_1 = require("../finalization/django-finalize");
+const locale_names_1 = require("../../django/locale-names");
+const PY_IGNORE = ['**/node_modules/**', '**/.venv/**', '**/venv/**', '**/site-packages/**', '**/.git/**'];
+/**
+ * The Django project root (directory of the shallowest manage.py), relative
+ * to the workspace, or null when this isn't a Django project. A root-level
+ * package.json with a supported JS framework wins over a nested manage.py.
+ */
+async function detectDjangoRoot(workspacePath, rootJsFramework) {
+    if (await (0, file_utils_1.pathExists)(path.join(workspacePath, 'manage.py')))
+        return '.';
+    if (rootJsFramework !== 'unknown')
+        return null;
+    const manage = await (0, fast_glob_1.default)('**/manage.py', { cwd: workspacePath, onlyFiles: true, deep: 4, ignore: PY_IGNORE });
+    if (manage.length > 0) {
+        const shallowest = manage.sort((a, b) => a.split('/').length - b.split('/').length || a.localeCompare(b))[0];
+        return path.posix.dirname(shallowest) || '.';
+    }
+    const depFiles = ['pyproject.toml', 'requirements.txt', 'Pipfile', 'setup.py', 'setup.cfg'];
+    for (const file of depFiles) {
+        const content = await (0, file_utils_1.readFile)(path.join(workspacePath, file)).catch(() => '');
+        if (content && (0, stack_1.mentionsPythonPackage)(content, 'django'))
+            return '.';
+    }
+    return null;
+}
+const SUPPORTED_LIST = 'React, Next.js, Vue, Django and plain HTML/CSS/JS';
+/** The clearest "not supported" message for a workspace we couldn't classify. */
+async function unsupportedMessage(workspacePath, fallback) {
+    try {
+        const stack = await (0, stack_1.detectStack)(await (0, stack_1.localRepoFiles)(workspacePath));
+        if (stack.unsupported)
+            return stack.message;
+    }
+    catch {
+        // fall through
+    }
+    return fallback;
+}
+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 });
+    }
+    let djangoRoot = null;
+    if (!framework || framework === 'unknown' || framework === 'django') {
+        djangoRoot = await detectDjangoRoot(workspacePath, packageJson ? detectFramework(packageJson) : 'unknown');
+        if (djangoRoot !== null) {
+            framework = 'django';
+            logger_1.engineLogger.info('Detected Django project', { djangoRoot });
+        }
+        else if (framework === 'django') {
+            throw new Error('This project was set up as Django, but no manage.py or Django dependency was found.');
+        }
+    }
+    if (!packageJson && framework !== 'django') {
+        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(await unsupportedMessage(workspacePath, `Babelize supports ${SUPPORTED_LIST} projects. No package.json, manage.py or HTML files were found.`));
+        }
+    }
+    else if (framework === 'unknown' && packageJson) {
+        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(await unsupportedMessage(workspacePath, `Babelize supports ${SUPPORTED_LIST} projects. This project's framework isn't supported yet.`));
+    }
+    if (framework === 'static') {
+        // A stray HTML file in a Rails/Laravel/Flutter repo doesn't make it a static site.
+        const stack = await (0, stack_1.detectStack)(await (0, stack_1.localRepoFiles)(workspacePath)).catch(() => null);
+        if (stack?.unsupported)
+            throw new Error(stack.message);
+    }
+    // Django: the whole project is scanned (templates/ and apps live anywhere).
+    const sourceDirs = framework === 'django' ? ['.'] : 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;
+    let localeDirRel = '';
+    if (localeFormat === 'po') {
+        // Django: <LOCALE_PATHS[0]>/<lang>/LC_MESSAGES/django.po (default <BASE_DIR>/locale)
+        localeDirRel = await (0, django_finalize_1.resolveDjangoLocaleDir)(workspacePath, djangoRoot ?? '.');
+        const djangoLocaleDir = path.join(workspacePath, localeDirRel);
+        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((0, locale_names_1.localeFromDjangoName)(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 = '.';
+    }
+    if (localeFormat === 'po') {
+        // For gettext projects publicDir is the locale directory.
+        publicDir = localeDirRel;
+    }
+    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,
+        ...(framework === 'django' ? { djangoRoot: djangoRoot ?? '.' } : {}),
+    };
+    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,13 @@
+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()`.
+ */
+/** Thrown at a progress checkpoint once the run's AbortSignal has fired. */
+export declare class RunAbortedError extends Error {
+    readonly reason: string;
+    constructor(reason: string);
+}
+export declare function runEngineV2(config: EngineConfigV2): Promise<EngineResultV2>;