@researchdatabox/redbox-dev-tools 0.0.1-beta.8936

package/dist/utils/config-helper.js

@@ -0,0 +1,574 @@
+"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.updateModelIndex = updateModelIndex;
+exports.updateControllerIndex = updateControllerIndex;
+exports.updateServiceIndex = updateServiceIndex;
+exports.updateRoutes = updateRoutes;
+exports.updateAuth = updateAuth;
+exports.updateNavigationConfig = updateNavigationConfig;
+exports.updateLanguageDefaults = updateLanguageDefaults;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const ts_morph_1 = require("ts-morph");
+async function updateModelIndex(params) {
+    const indexPath = path.join(params.paths.coreTypes, 'src', 'waterline-models', 'index.ts');
+    if (!fs.existsSync(indexPath))
+        return;
+    const sourceFile = params.project.addSourceFileAtPath(indexPath);
+    const wlDefName = `${params.modelName}WLDef`;
+    const importPath = `./${params.modelName}`;
+    // 1. Add export * from './ModelName' if not exists
+    const hasExportAll = sourceFile.getExportDeclarations().some(d => d.getModuleSpecifierValue() === importPath && d.isNamespaceExport());
+    if (!hasExportAll) {
+        // Find the last export * line and insert after it
+        const exportAllDeclarations = sourceFile.getExportDeclarations().filter(d => d.isNamespaceExport());
+        if (exportAllDeclarations.length > 0) {
+            const lastExportAll = exportAllDeclarations[exportAllDeclarations.length - 1];
+            sourceFile.insertExportDeclaration(lastExportAll.getChildIndex() + 1, {
+                moduleSpecifier: importPath
+            });
+        }
+        else {
+            sourceFile.addExportDeclaration({
+                moduleSpecifier: importPath
+            });
+        }
+    }
+    // 2. Add named import for the WLDef if not exists  
+    const existingImport = sourceFile.getImportDeclaration(d => d.getModuleSpecifierValue() === importPath);
+    if (!existingImport) {
+        // Find where the WLDef imports are and add there
+        const wlDefImports = sourceFile.getImportDeclarations().filter(d => {
+            const namedImports = d.getNamedImports();
+            return namedImports.some(n => n.getName().endsWith('WLDef'));
+        });
+        if (wlDefImports.length > 0) {
+            const lastWlDefImport = wlDefImports[wlDefImports.length - 1];
+            sourceFile.insertImportDeclaration(lastWlDefImport.getChildIndex() + 1, {
+                namedImports: [wlDefName],
+                moduleSpecifier: importPath
+            });
+        }
+        else {
+            sourceFile.addImportDeclaration({
+                namedImports: [wlDefName],
+                moduleSpecifier: importPath
+            });
+        }
+    }
+    // 3. Add to WaterlineModels object if not exists
+    const wlModelsVar = sourceFile.getVariableDeclaration('WaterlineModels');
+    if (wlModelsVar) {
+        const initializer = wlModelsVar.getInitializerIfKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+        if (initializer && !initializer.getProperty(params.modelName)) {
+            initializer.addPropertyAssignment({
+                name: params.modelName,
+                initializer: wlDefName
+            });
+        }
+    }
+    sourceFile.formatText();
+    if (!params.dryRun) {
+        await sourceFile.save();
+        console.log(`  [UPDATE] ${path.relative(params.root, indexPath)}`);
+    }
+}
+async function updateControllerIndex(params) {
+    const indexPath = path.join(params.paths.coreTypes, 'src', 'controllers', 'index.ts');
+    if (!fs.existsSync(indexPath))
+        return;
+    const sourceFile = params.project.addSourceFileAtPath(indexPath);
+    const moduleName = params.webservice ? `WS${params.className}ControllerModule` : `${params.className}ControllerModule`;
+    const importPath = params.webservice ? `./webservice/${params.className}Controller` : `./${params.className}Controller`;
+    // 1. Add import if not exists
+    if (!sourceFile.getImportDeclaration(d => d.getModuleSpecifierValue() === importPath)) {
+        sourceFile.addImportDeclaration({
+            namespaceImport: moduleName,
+            moduleSpecifier: importPath
+        });
+    }
+    // 2. Add to ControllerExports or WebserviceControllerExports
+    const exportVarName = params.webservice ? 'WebserviceControllerExports' : 'ControllerExports';
+    const exportVar = sourceFile.getVariableDeclaration(exportVarName);
+    if (exportVar) {
+        const initializer = exportVar.getInitializerIfKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+        if (initializer && !initializer.getProperty(params.controllerName)) {
+            const cachePrefix = params.webservice ? 'WS_' : '';
+            initializer.addGetAccessor({
+                name: params.controllerName,
+                returnType: 'any',
+                statements: `return getOrCreate('${cachePrefix}${params.controllerName}', () => new ${moduleName}.Controllers.${params.className}().exports());`
+            });
+        }
+    }
+    // 3. Add to ControllerNames or WebserviceControllerNames
+    const namesVarName = params.webservice ? 'WebserviceControllerNames' : 'ControllerNames';
+    const namesVar = sourceFile.getVariableDeclaration(namesVarName);
+    if (namesVar) {
+        const initializer = namesVar.getInitializerIfKind(ts_morph_1.SyntaxKind.ArrayLiteralExpression);
+        if (initializer && !initializer.getElements().some((e) => e.getText() === `'${params.controllerName}'`)) {
+            initializer.addElement(`'${params.controllerName}'`);
+            // Sort elements
+            const elements = initializer.getElements().map((e) => e.getText());
+            elements.sort();
+            // Re-add all elements sorted
+            while (initializer.getElements().length > 0) {
+                initializer.removeElement(0);
+            }
+            elements.forEach(el => initializer.addElement(el));
+        }
+    }
+    sourceFile.formatText();
+    if (!params.dryRun) {
+        await sourceFile.save();
+        console.log(`  [UPDATE] ${path.relative(params.root, indexPath)}`);
+    }
+}
+async function updateServiceIndex(params) {
+    const indexPath = path.join(params.paths.coreTypes, 'src', 'services', 'index.ts');
+    if (!fs.existsSync(indexPath))
+        return;
+    const sourceFile = params.project.addSourceFileAtPath(indexPath);
+    const moduleName = `${params.className}ServiceModule`;
+    const importPath = `./${params.serviceName}`;
+    // 1. Add import if not exists
+    if (!sourceFile.getImportDeclaration(d => d.getModuleSpecifierValue() === importPath)) {
+        sourceFile.addImportDeclaration({
+            namespaceImport: moduleName,
+            moduleSpecifier: importPath
+        });
+    }
+    // 2. Add re-export if not exists
+    const exportDeclaration = sourceFile.getExportDeclaration(d => d.getModuleSpecifierValue() === importPath);
+    if (!exportDeclaration) {
+        sourceFile.addExportDeclaration({
+            namedExports: [{ name: moduleName, alias: params.serviceName }],
+            moduleSpecifier: importPath
+        });
+    }
+    // 3. Add to ServiceExports
+    const exportVar = sourceFile.getVariableDeclaration('ServiceExports');
+    if (exportVar) {
+        const initializer = exportVar.getInitializerIfKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+        if (initializer && !initializer.getProperty(params.serviceName)) {
+            initializer.addGetAccessor({
+                name: params.serviceName,
+                statements: `return getOrCreateService('${params.serviceName}', () => new ${moduleName}.Services.${params.className}().exports());`
+            });
+        }
+    }
+    sourceFile.formatText();
+    if (!params.dryRun) {
+        await sourceFile.save();
+        console.log(`  [UPDATE] ${path.relative(params.root, indexPath)}`);
+    }
+}
+async function updateRoutes(params) {
+    const routesPath = path.join(params.paths.coreTypes, 'src', 'config', 'routes.config.ts');
+    if (!fs.existsSync(routesPath))
+        return;
+    const sourceFile = params.project.addSourceFileAtPath(routesPath);
+    const routesVar = sourceFile.getVariableDeclaration('routes');
+    if (!routesVar)
+        return;
+    const initializer = routesVar.getInitializerIfKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+    if (!initializer)
+        return;
+    let routeKey = params.route;
+    if (!routeKey.includes(' ')) {
+        routeKey = `get ${routeKey}`;
+    }
+    if (!initializer.getProperty(`'${routeKey}'`) && !initializer.getProperty(`"${routeKey}"`)) {
+        const target = params.webservice ? `webservice/${params.controllerName}` : params.controllerName;
+        const csrf = typeof params.csrf === 'boolean' ? params.csrf : (params.webservice ? false : undefined);
+        if (params.webservice || typeof csrf === 'boolean') {
+            const props = [
+                `controller: '${target}'`,
+                `action: '${params.action}'`,
+                ...(typeof csrf === 'boolean' ? [`csrf: ${csrf}`] : [])
+            ];
+            initializer.addPropertyAssignment({
+                name: `'${routeKey}'`,
+                initializer: `{ ${props.join(', ')} }`
+            });
+        }
+        else {
+            initializer.addPropertyAssignment({
+                name: `'${routeKey}'`,
+                initializer: `'${target}.${params.action}'`
+            });
+        }
+    }
+    sourceFile.formatText();
+    if (!params.dryRun) {
+        await sourceFile.save();
+        console.log(`  [UPDATE] ${path.relative(params.root, routesPath)}`);
+    }
+}
+async function updateAuth(params) {
+    const authPath = path.join(params.paths.coreTypes, 'src', 'config', 'auth.config.ts');
+    if (!fs.existsSync(authPath))
+        return;
+    const sourceFile = params.project.addSourceFileAtPath(authPath);
+    const authVar = sourceFile.getVariableDeclaration('auth');
+    if (!authVar)
+        return;
+    const initializer = authVar.getInitializerIfKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+    if (!initializer)
+        return;
+    const rulesProp = initializer.getProperty('rules');
+    if (!rulesProp || !rulesProp.asKind(ts_morph_1.SyntaxKind.PropertyAssignment))
+        return;
+    const rulesArray = rulesProp.asKind(ts_morph_1.SyntaxKind.PropertyAssignment).getInitializerIfKind(ts_morph_1.SyntaxKind.ArrayLiteralExpression);
+    if (!rulesArray)
+        return;
+    // Check existing roles for warning
+    const authRolesProp = initializer.getProperty('roles');
+    let existingRoles = [];
+    if (authRolesProp && authRolesProp.asKind(ts_morph_1.SyntaxKind.PropertyAssignment)) {
+        const rolesArray = authRolesProp.asKind(ts_morph_1.SyntaxKind.PropertyAssignment).getInitializerIfKind(ts_morph_1.SyntaxKind.ArrayLiteralExpression);
+        if (rolesArray) {
+            existingRoles = rolesArray.getElements().map((el) => {
+                if (el.getKind() === ts_morph_1.SyntaxKind.ObjectLiteralExpression) {
+                    return el.asKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression).getProperty('name')?.asKind(ts_morph_1.SyntaxKind.PropertyAssignment)?.getInitializer()?.getText().replace(/['"]/g, '') || '';
+                }
+                return '';
+            }).filter(r => r !== '');
+        }
+    }
+    const trimmedRoute = params.route.trim();
+    if (!trimmedRoute) {
+        throw new Error('Route cannot be empty or whitespace.');
+    }
+    const routePath = trimmedRoute.split(' ').pop();
+    if (!routePath) {
+        throw new Error(`Route is missing a path segment: '${trimmedRoute}'.`);
+    }
+    for (const role of params.auth) {
+        if (existingRoles.length > 0 && !existingRoles.includes(role)) {
+            console.warn(`Warning: Role '${role}' not found in auth.roles. It will still be added to rules, but may not function as expected.`);
+        }
+        // Check if rule already exists or is covered by a wildcard
+        const isCovered = rulesArray.getElements().some((el) => {
+            if (el.getKind() === ts_morph_1.SyntaxKind.ObjectLiteralExpression) {
+                const obj = el.asKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+                const existingPathRaw = obj.getProperty('path')?.asKind(ts_morph_1.SyntaxKind.PropertyAssignment)?.getInitializer()?.getText();
+                const existingRoleRaw = obj.getProperty('role')?.asKind(ts_morph_1.SyntaxKind.PropertyAssignment)?.getInitializer()?.getText();
+                if (!existingPathRaw || !existingRoleRaw)
+                    return false;
+                const existingPath = existingPathRaw.replace(/['"]/g, '');
+                const existingRole = existingRoleRaw.replace(/['"]/g, '');
+                if (existingRole !== role)
+                    return false;
+                // Check path coverage
+                let covered = false;
+                if (existingPath === routePath) {
+                    covered = true;
+                }
+                else if (existingPath.endsWith('(/*)') || existingPath.endsWith('/*')) {
+                    const baseUrl = existingPath.replace(/(\(\/\*\)|\/\*)$/, '');
+                    if (routePath.startsWith(baseUrl)) {
+                        covered = true;
+                    }
+                }
+                if (!covered)
+                    return false;
+                // Check permissions
+                const verb = trimmedRoute.includes(' ') ? trimmedRoute.split(' ')[0].toLowerCase() : 'get';
+                const requestedAccess = verb === 'get' ? 'read' : 'update';
+                const canUpdate = obj.getProperty('can_update')?.asKind(ts_morph_1.SyntaxKind.PropertyAssignment)?.getInitializer()?.getText() === 'true';
+                const canRead = obj.getProperty('can_read')?.asKind(ts_morph_1.SyntaxKind.PropertyAssignment)?.getInitializer()?.getText() === 'true';
+                if (requestedAccess === 'read') {
+                    return canRead || canUpdate;
+                }
+                else {
+                    return canUpdate;
+                }
+            }
+            return false;
+        });
+        if (!isCovered) {
+            const verb = trimmedRoute.includes(' ') ? trimmedRoute.split(' ')[0].toLowerCase() : 'get';
+            const permission = verb === 'get' ? 'can_read: true' : 'can_update: true';
+            console.log(`  [AUTH] Adding rule for ${role} -> ${routePath} (${permission})`);
+            rulesArray.addElement(`{ path: '${routePath}', role: '${role}', ${permission} }`);
+        }
+        else {
+            console.log(`  [AUTH] Rule for ${role} -> ${routePath} already covered by existing rule`);
+        }
+    }
+    sourceFile.formatText();
+    if (!params.dryRun) {
+        await sourceFile.save();
+        console.log(`  [UPDATE] ${path.relative(params.root, authPath)}`);
+    }
+}
+function getStringProp(obj, name) {
+    const prop = obj.getProperty(name);
+    if (!prop || !prop.asKind(ts_morph_1.SyntaxKind.PropertyAssignment))
+        return undefined;
+    const initializer = prop.asKind(ts_morph_1.SyntaxKind.PropertyAssignment).getInitializer();
+    return initializer ? initializer.getText().replace(/['"]/g, '') : undefined;
+}
+function getArrayProp(obj, name) {
+    const prop = obj.getProperty(name);
+    if (!prop || !prop.asKind(ts_morph_1.SyntaxKind.PropertyAssignment))
+        return undefined;
+    return prop.asKind(ts_morph_1.SyntaxKind.PropertyAssignment).getInitializerIfKind(ts_morph_1.SyntaxKind.ArrayLiteralExpression) || undefined;
+}
+function addNavItemToArray(array, item) {
+    const hasDuplicate = array.getElements().some((el) => {
+        if (el.getKind() !== ts_morph_1.SyntaxKind.ObjectLiteralExpression)
+            return false;
+        const obj = el.asKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+        const existingId = getStringProp(obj, 'id');
+        const existingHref = getStringProp(obj, 'href');
+        if (item.itemId && existingId === item.itemId)
+            return true;
+        if (item.href && existingHref === item.href)
+            return true;
+        return false;
+    });
+    if (hasDuplicate)
+        return false;
+    const props = [];
+    if (item.itemId)
+        props.push(`id: '${item.itemId}'`);
+    props.push(`labelKey: '${item.labelKey}'`);
+    if (item.href)
+        props.push(`href: '${item.href}'`);
+    array.addElement(`{ ${props.join(', ')} }`);
+    return true;
+}
+function findMenuItemById(array, id) {
+    for (const el of array.getElements()) {
+        if (el.getKind() !== ts_morph_1.SyntaxKind.ObjectLiteralExpression)
+            continue;
+        const obj = el.asKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+        const itemId = getStringProp(obj, 'id');
+        if (itemId === id)
+            return obj;
+        const childrenArray = getArrayProp(obj, 'children');
+        if (childrenArray) {
+            const nested = findMenuItemById(childrenArray, id);
+            if (nested)
+                return nested;
+        }
+    }
+    return undefined;
+}
+function normalizeNavHref(routePath) {
+    if (!routePath)
+        return routePath;
+    return routePath.replace(/^\/:branding\/:portal(\/|$)/, '/');
+}
+async function updateNavigationConfig(params) {
+    const mapping = { ...params.mapping };
+    if (mapping.href) {
+        mapping.href = normalizeNavHref(mapping.href);
+    }
+    if (mapping.target === 'menu' || mapping.target === 'menuRoot') {
+        const menuPath = path.join(params.paths.coreTypes, 'src', 'configmodels', 'MenuConfig.ts');
+        if (!fs.existsSync(menuPath))
+            return;
+        const sourceFile = params.project.addSourceFileAtPath(menuPath);
+        const defaultVar = sourceFile.getVariableDeclaration('DEFAULT_MENU_CONFIG');
+        if (!defaultVar)
+            return;
+        const initializer = defaultVar.getInitializerIfKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+        if (!initializer)
+            return;
+        const itemsArray = getArrayProp(initializer, 'items');
+        if (!itemsArray)
+            return;
+        let targetArray = itemsArray;
+        if (mapping.target === 'menu' && mapping.containerId) {
+            const parent = findMenuItemById(itemsArray, mapping.containerId);
+            if (!parent) {
+                console.warn(`  [NAV] Menu parent '${mapping.containerId}' not found. Skipping.`);
+                return;
+            }
+            let childrenArray = getArrayProp(parent, 'children');
+            if (!childrenArray) {
+                parent.addPropertyAssignment({ name: 'children', initializer: '[]' });
+                childrenArray = getArrayProp(parent, 'children');
+            }
+            if (!childrenArray)
+                return;
+            targetArray = childrenArray;
+        }
+        const added = addNavItemToArray(targetArray, mapping);
+        if (added) {
+            sourceFile.formatText();
+            if (!params.dryRun) {
+                await sourceFile.save();
+                console.log(`  [UPDATE] ${path.relative(params.root, menuPath)}`);
+            }
+        }
+        return;
+    }
+    if (mapping.target === 'homePanel') {
+        const homePanelPath = path.join(params.paths.coreTypes, 'src', 'configmodels', 'HomePanelConfig.ts');
+        if (!fs.existsSync(homePanelPath))
+            return;
+        const sourceFile = params.project.addSourceFileAtPath(homePanelPath);
+        const defaultVar = sourceFile.getVariableDeclaration('DEFAULT_HOME_PANEL_CONFIG');
+        if (!defaultVar)
+            return;
+        const initializer = defaultVar.getInitializerIfKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+        if (!initializer)
+            return;
+        const panelsArray = getArrayProp(initializer, 'panels');
+        if (!panelsArray)
+            return;
+        if (!mapping.containerId) {
+            console.warn('  [NAV] Home panel target requires containerId (panel id). Skipping.');
+            return;
+        }
+        const panel = panelsArray.getElements().find((el) => {
+            if (el.getKind() !== ts_morph_1.SyntaxKind.ObjectLiteralExpression)
+                return false;
+            const obj = el.asKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+            return getStringProp(obj, 'id') === mapping.containerId;
+        })?.asKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+        if (!panel) {
+            console.warn(`  [NAV] Home panel '${mapping.containerId}' not found. Skipping.`);
+            return;
+        }
+        const itemsArray = getArrayProp(panel, 'items');
+        if (!itemsArray)
+            return;
+        const added = addNavItemToArray(itemsArray, mapping);
+        if (added) {
+            sourceFile.formatText();
+            if (!params.dryRun) {
+                await sourceFile.save();
+                console.log(`  [UPDATE] ${path.relative(params.root, homePanelPath)}`);
+            }
+        }
+        return;
+    }
+    if (mapping.target === 'adminSection' || mapping.target === 'adminFooter') {
+        const adminPath = path.join(params.paths.coreTypes, 'src', 'configmodels', 'AdminSidebarConfig.ts');
+        if (!fs.existsSync(adminPath))
+            return;
+        const sourceFile = params.project.addSourceFileAtPath(adminPath);
+        const defaultVar = sourceFile.getVariableDeclaration('DEFAULT_ADMIN_SIDEBAR_CONFIG');
+        if (!defaultVar)
+            return;
+        const initializer = defaultVar.getInitializerIfKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+        if (!initializer)
+            return;
+        let targetArray;
+        if (mapping.target === 'adminFooter') {
+            targetArray = getArrayProp(initializer, 'footerLinks');
+        }
+        else {
+            const sectionsArray = getArrayProp(initializer, 'sections');
+            if (!sectionsArray)
+                return;
+            if (!mapping.containerId) {
+                console.warn('  [NAV] Admin section target requires containerId (section id). Skipping.');
+                return;
+            }
+            const section = sectionsArray.getElements().find((el) => {
+                if (el.getKind() !== ts_morph_1.SyntaxKind.ObjectLiteralExpression)
+                    return false;
+                const obj = el.asKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+                return getStringProp(obj, 'id') === mapping.containerId;
+            })?.asKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+            if (!section) {
+                console.warn(`  [NAV] Admin section '${mapping.containerId}' not found. Skipping.`);
+                return;
+            }
+            targetArray = getArrayProp(section, 'items');
+        }
+        if (!targetArray)
+            return;
+        const added = addNavItemToArray(targetArray, mapping);
+        if (added) {
+            sourceFile.formatText();
+            if (!params.dryRun) {
+                await sourceFile.save();
+                console.log(`  [UPDATE] ${path.relative(params.root, adminPath)}`);
+            }
+        }
+        return;
+    }
+}
+async function updateLanguageDefaults(params) {
+    const defaultsRoot = path.join(params.root, 'language-defaults');
+    if (!fs.existsSync(defaultsRoot))
+        return;
+    const entries = params.entries || [];
+    if (entries.length === 0)
+        return;
+    const languages = fs.readdirSync(defaultsRoot, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name)
+        .filter(lang => fs.existsSync(path.join(defaultsRoot, lang, 'translation.json')));
+    for (const entry of entries) {
+        const targetLangs = entry.language ? [entry.language] : languages;
+        for (const lang of targetLangs) {
+            const translationPath = path.join(defaultsRoot, lang, 'translation.json');
+            if (!fs.existsSync(translationPath))
+                continue;
+            const raw = fs.readFileSync(translationPath, 'utf8');
+            let json = {};
+            try {
+                json = JSON.parse(raw);
+            }
+            catch (err) {
+                console.warn(`  [LANG] Failed to parse ${translationPath}. Skipping.`);
+                continue;
+            }
+            if (Object.prototype.hasOwnProperty.call(json, entry.key)) {
+                continue;
+            }
+            const updated = { ...json, [entry.key]: entry.value };
+            const indentMatch = raw.match(/\n(\s+)"[^\"]+"\s*:/);
+            const indent = indentMatch ? indentMatch[1] : '  ';
+            const output = JSON.stringify(updated, null, indent) + '\n';
+            if (params.dryRun) {
+                console.log(`  [LANG] ${path.relative(params.root, translationPath)} (dry run)`);
+            }
+            else {
+                fs.writeFileSync(translationPath, output);
+                console.log(`  [UPDATE] ${path.relative(params.root, translationPath)}`);
+            }
+        }
+    }
+}

package/dist/utils/generator.d.ts

@@ -0,0 +1,10 @@
+export interface GeneratorOptions {
+    dryRun?: boolean;
+    root: string;
+}
+export declare abstract class Generator {
+    protected dryRun: boolean;
+    protected root: string;
+    constructor(options: GeneratorOptions);
+    protected writeFile(filePath: string, content: string): void;
+}

package/dist/utils/generator.js

@@ -0,0 +1,68 @@
+"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.Generator = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class Generator {
+    dryRun;
+    root;
+    constructor(options) {
+        this.dryRun = !!options.dryRun;
+        this.root = options.root;
+    }
+    writeFile(filePath, content) {
+        const relativePath = path.relative(this.root, filePath);
+        if (fs.existsSync(filePath)) {
+            const existingContent = fs.readFileSync(filePath, 'utf-8');
+            if (existingContent === content) {
+                console.log(`  [SKIP] ${relativePath} (no changes)`);
+                return;
+            }
+            console.log(`  [UPDATE] ${relativePath}${this.dryRun ? ' (dry run)' : ''}`);
+        }
+        else {
+            console.log(`  [CREATE] ${relativePath}${this.dryRun ? ' (dry run)' : ''}`);
+        }
+        if (!this.dryRun) {
+            const dir = path.dirname(filePath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(filePath, content, 'utf-8');
+        }
+    }
+}
+exports.Generator = Generator;

package/dist/utils/hook-tsconfig.d.ts

@@ -0,0 +1,9 @@
+type HookCompilerOptions = {
+    baseUrl: string;
+    paths: Record<string, string[]>;
+    typeRoots: string[];
+};
+export declare function createHookCompilerOptions(projectPath: string): HookCompilerOptions;
+export declare function createHookTsConfig(projectPath: string): string;
+export declare function cleanupHookTsConfig(tempTsconfigPath: string): void;
+export {};