generate-ui-cli 2.1.7 → 2.3.0

package/dist/commands/angular.js

@@ -7,83 +7,578 @@ exports.angular = angular;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const feature_generator_1 = require("../generators/angular/feature.generator");
+const feature_generator_2 = require("../generators/angular/feature.generator");
 const routes_generator_1 = require("../generators/angular/routes.generator");
+const menu_generator_1 = require("../generators/angular/menu.generator");
 const telemetry_1 = require("../telemetry");
 const user_config_1 = require("../runtime/user-config");
+const permissions_1 = require("../license/permissions");
+const logger_1 = require("../runtime/logger");
+const project_config_1 = require("../runtime/project-config");
 async function angular(options) {
     void (0, telemetry_1.trackCommand)('angular', options.telemetryEnabled);
-    const featuresRoot = resolveFeaturesRoot(options.featuresPath);
-    const schemasRoot = resolveSchemasRoot(options.schemasPath, featuresRoot);
+    let intelligentEnabled = false;
+    let subscriptionReason = '';
+    try {
+        const permissions = await (0, permissions_1.getPermissions)();
+        intelligentEnabled = Boolean(permissions.features.intelligentGeneration);
+        subscriptionReason = String(permissions.subscription.reason ?? '').trim();
+    }
+    catch {
+        intelligentEnabled = false;
+        subscriptionReason = '';
+    }
+    const projectConfig = (0, project_config_1.findProjectConfig)(process.cwd());
+    const configuredFeatures = (0, project_config_1.pickConfiguredPath)(projectConfig.config, 'features');
+    const configuredSchemas = (0, project_config_1.pickConfiguredPath)(projectConfig.config, 'schemas') ??
+        (0, project_config_1.pickConfiguredPath)(projectConfig.config, 'output');
+    const featuresRoot = resolveFeaturesRoot(options.featuresPath, configuredFeatures, projectConfig.configPath);
+    const generatedFeaturesRoot = path_1.default.join(featuresRoot, 'generated');
+    const overridesFeaturesRoot = path_1.default.join(featuresRoot, 'overrides');
+    const schemasRoot = resolveSchemasRoot(options.schemasPath, configuredSchemas, projectConfig.configPath, featuresRoot);
+    (0, logger_1.logStep)(`Features output: ${featuresRoot}`);
+    (0, logger_1.logDebug)(`Generated features: ${generatedFeaturesRoot}`);
+    (0, logger_1.logDebug)(`Overrides: ${overridesFeaturesRoot}`);
+    (0, logger_1.logStep)(`Schemas input: ${schemasRoot}`);
     /**
      * Onde estão os schemas
      * Ex: generate-ui
      */
+    if (options.schemasPath && !fs_1.default.existsSync(schemasRoot)) {
+        fs_1.default.mkdirSync(schemasRoot, { recursive: true });
+        console.log(`ℹ Created generate-ui folder at ${schemasRoot}`);
+    }
     const overlaysDir = path_1.default.join(schemasRoot, 'overlays');
-    if (!fs_1.default.existsSync(overlaysDir)) {
-        throw new Error(`Overlays directory not found: ${overlaysDir}`);
+    await generateAngularOnce({
+        overlaysDir,
+        featuresRoot,
+        generatedFeaturesRoot,
+        overridesFeaturesRoot,
+        schemasRoot,
+        intelligentEnabled,
+        subscriptionReason
+    });
+    if (!options.watch) {
+        (0, logger_1.logTip)('Run with --dev to see detailed logs and file paths.');
+        return;
+    }
+    console.log(`👀 Watching ${overlaysDir} for .screen.json changes...`);
+    let debounceTimer = null;
+    const rerun = (fileName) => {
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(async () => {
+            console.log(`↻ Change detected: ${fileName}`);
+            try {
+                await generateAngularOnce({
+                    overlaysDir,
+                    featuresRoot,
+                    generatedFeaturesRoot,
+                    overridesFeaturesRoot,
+                    schemasRoot,
+                    intelligentEnabled,
+                    subscriptionReason
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Unexpected error';
+                console.error(message);
+            }
+        }, 180);
+    };
+    const watcher = fs_1.default.watch(overlaysDir, (event, fileName) => {
+        if (!fileName)
+            return;
+        if (!String(fileName).endsWith('.screen.json'))
+            return;
+        if (event !== 'change' && event !== 'rename')
+            return;
+        rerun(String(fileName));
+    });
+    const closeWatcher = () => {
+        watcher.close();
+        console.log('\nStopped screen watch.');
+        process.exit(0);
+    };
+    process.on('SIGINT', closeWatcher);
+    process.on('SIGTERM', closeWatcher);
+}
+async function generateAngularOnce(options) {
+    if (!fs_1.default.existsSync(options.overlaysDir)) {
+        throw new Error(`Overlays directory not found: ${options.overlaysDir}\n` +
+            'Run `generate-ui generate` first to create overlays.\n' +
+            'If needed, configure "openapi", "schemas", and "features" in generateui-config.json.');
     }
+    (0, logger_1.logDebug)(`Overlays dir: ${options.overlaysDir}`);
     const screens = fs_1.default
-        .readdirSync(overlaysDir)
+        .readdirSync(options.overlaysDir)
         .filter(f => f.endsWith('.screen.json'));
-    /**
-     * Onde gerar as features Angular
-     */
-    fs_1.default.mkdirSync(featuresRoot, { recursive: true });
+    (0, logger_1.logDebug)(`Screens found: ${screens.length}`);
+    if (screens.length === 0) {
+        throw new Error(`No .screen.json files found in: ${options.overlaysDir}\n` +
+            'Run `generate-ui generate` and then `generate-ui angular`.\n' +
+            'If needed, set "schemas" (or "paths.schemas") in generateui-config.json.');
+    }
+    fs_1.default.mkdirSync(options.featuresRoot, { recursive: true });
+    fs_1.default.mkdirSync(options.generatedFeaturesRoot, { recursive: true });
+    fs_1.default.mkdirSync(options.overridesFeaturesRoot, { recursive: true });
     const routes = [];
+    const schemas = [];
+    const appRoot = path_1.default.resolve(options.featuresRoot, '..');
+    const configInfo = findConfig(appRoot);
+    const views = configInfo.config?.views ?? {};
+    const generatedSchemasDir = path_1.default.join(options.schemasRoot, 'generated');
     for (const file of screens) {
-        const schema = JSON.parse(fs_1.default.readFileSync(path_1.default.join(overlaysDir, file), 'utf-8'));
-        const route = (0, feature_generator_1.generateFeature)(schema, featuresRoot, schemasRoot);
+        let schema = JSON.parse(fs_1.default.readFileSync(path_1.default.join(options.overlaysDir, file), 'utf-8'));
+        const generatedPath = path_1.default.join(generatedSchemasDir, file);
+        if (fs_1.default.existsSync(generatedPath)) {
+            try {
+                const generatedSchema = JSON.parse(fs_1.default.readFileSync(generatedPath, 'utf-8'));
+                const normalized = enforceScreenShape(schema, generatedSchema);
+                schema = normalized.schema;
+                for (const warning of normalized.warnings) {
+                    console.warn(warning);
+                }
+            }
+            catch {
+                // Ignore malformed generated schema and keep overlay as source.
+            }
+        }
+        schemas.push({ file, schema });
+    }
+    const schemaByOpId = new Map();
+    for (const { schema } of schemas) {
+        const opId = schema?.api?.operationId;
+        if (opId)
+            schemaByOpId.set(opId, schema);
+    }
+    for (const { schema } of schemas) {
+        const opId = schema?.api?.operationId;
+        const view = opId ? views[opId] : undefined;
+        if (view) {
+            schema.meta = {
+                ...(schema.meta ?? {}),
+                view
+            };
+        }
+        if (schema?.meta?.intelligent?.kind === 'adminList') {
+            if (!options.intelligentEnabled) {
+                const reason = String(options.subscriptionReason ?? '').trim();
+                (0, logger_1.logTip)(reason
+                    ? `Intelligent generation is disabled: ${reason}`
+                    : 'Intelligent generation is disabled. Login and an active subscription are required to generate admin list screens.');
+                continue;
+            }
+            const adminRoute = (0, feature_generator_2.generateAdminFeature)(schema, schemaByOpId, options.featuresRoot, options.generatedFeaturesRoot, options.schemasRoot);
+            routes.push(adminRoute);
+            continue;
+        }
+        const route = (0, feature_generator_1.generateFeature)(schema, options.featuresRoot, options.generatedFeaturesRoot, options.schemasRoot);
         routes.push(route);
     }
-    (0, routes_generator_1.generateRoutes)(routes, featuresRoot, schemasRoot);
-    console.log(`✔ Angular features generated at ${featuresRoot}`);
+    migrateLegacyFeatures(routes, options.featuresRoot, options.generatedFeaturesRoot, options.overridesFeaturesRoot);
+    syncOverrides(routes, options.generatedFeaturesRoot, options.overridesFeaturesRoot);
+    (0, routes_generator_1.generateRoutes)(routes, options.generatedFeaturesRoot, options.overridesFeaturesRoot, options.schemasRoot);
+    (0, menu_generator_1.generateMenu)(options.schemasRoot);
+    applyAppLayout(options.featuresRoot, options.schemasRoot);
+    console.log(`✔ Angular features generated at ${options.featuresRoot}`);
+    const overrides = findOverrides(routes, options.overridesFeaturesRoot, options.generatedFeaturesRoot);
+    if (overrides.length) {
+        console.log('');
+        console.log('ℹ Overrides with differences detected:');
+        console.log('  Use merge to compare generated (left) vs overrides (right).');
+        console.log('  Keep your changes in the right file (overrides).');
+        for (const override of overrides) {
+            console.log(`  - ${override.component} -> generate-ui merge --feature ${override.folder} --file all`);
+        }
+        console.log('');
+    }
 }
-function resolveSchemasRoot(value, featuresRoot) {
-    if (value) {
-        return path_1.default.resolve(process.cwd(), value);
+function enforceScreenShape(overlay, generated) {
+    const warnings = [];
+    const next = overlay ?? {};
+    const generatedType = generated?.screen?.type;
+    const overlayType = next?.screen?.type;
+    if (generatedType &&
+        overlayType &&
+        String(overlayType) !== String(generatedType)) {
+        next.screen = { ...(next.screen ?? {}), type: generatedType };
+        warnings.push(`⚠ Ignored overlay change: screen.type is fixed by generation (${generatedType}).`);
     }
-    const config = (0, user_config_1.loadUserConfig)();
-    if (config?.lastSchemasPath) {
-        const resolved = path_1.default.resolve(config.lastSchemasPath);
-        if (fs_1.default.existsSync(path_1.default.join(resolved, 'overlays'))) {
-            return resolved;
-        }
+    const generatedMode = generated?.screen?.mode;
+    const overlayMode = next?.screen?.mode;
+    if (generatedMode &&
+        overlayMode &&
+        String(overlayMode) !== String(generatedMode)) {
+        next.screen = { ...(next.screen ?? {}), mode: generatedMode };
+        warnings.push(`⚠ Ignored overlay change: screen.mode is fixed by generation (${generatedMode}).`);
+    }
+    const generatedMethod = generated?.api?.method;
+    const overlayMethod = next?.api?.method;
+    if (generatedMethod &&
+        overlayMethod &&
+        String(overlayMethod).toLowerCase() !==
+            String(generatedMethod).toLowerCase()) {
+        next.api = { ...(next.api ?? {}), method: generatedMethod };
+        warnings.push(`⚠ Ignored overlay change: api.method is fixed by generation (${generatedMethod}).`);
+    }
+    const generatedOpId = generated?.api?.operationId;
+    const overlayOpId = next?.api?.operationId;
+    if (generatedOpId &&
+        overlayOpId &&
+        String(overlayOpId) !== String(generatedOpId)) {
+        next.api = { ...(next.api ?? {}), operationId: generatedOpId };
+        warnings.push(`⚠ Ignored overlay change: api.operationId is fixed by generation (${generatedOpId}).`);
+    }
+    return { schema: next, warnings };
+}
+function resolveSchemasRoot(value, configured, configPath, featuresRoot) {
+    const fromConfig = (0, project_config_1.resolveOptionalPath)(value, configured, configPath);
+    if (fromConfig) {
+        return fromConfig;
     }
     const inferred = inferSchemasRootFromFeatures(featuresRoot);
     if (inferred)
         return inferred;
     return resolveDefaultSchemasRoot();
 }
-function resolveFeaturesRoot(value) {
-    if (value) {
-        const resolved = path_1.default.resolve(process.cwd(), value);
-        const isSrcApp = path_1.default.basename(resolved) === 'app' &&
-            path_1.default.basename(path_1.default.dirname(resolved)) === 'src';
-        if (isSrcApp) {
-            return path_1.default.join(resolved, 'features');
-        }
-        return resolved;
+function resolveFeaturesRoot(value, configured, configPath) {
+    const fromConfig = (0, project_config_1.resolveOptionalPath)(value, configured, configPath);
+    if (fromConfig) {
+        return normalizeFeaturesRoot(fromConfig);
     }
     const srcAppRoot = path_1.default.resolve(process.cwd(), 'src', 'app');
-    if (!fs_1.default.existsSync(srcAppRoot)) {
-        throw new Error('Default features path not found: ./src/app. Provide --features /path/to/src/app (or /path/to/src/app/features)');
+    if (fs_1.default.existsSync(srcAppRoot)) {
+        return path_1.default.join(srcAppRoot, 'features');
     }
-    return path_1.default.join(srcAppRoot, 'features');
+    throw new Error('Default features path not found.\n' +
+        'Use --features <path> or set "features" (or "paths.features") in generateui-config.json.');
 }
 function inferSchemasRootFromFeatures(featuresRoot) {
-    const candidate = path_1.default.resolve(featuresRoot, '../../..', 'generate-ui');
-    if (fs_1.default.existsSync(path_1.default.join(candidate, 'overlays'))) {
-        return candidate;
+    const srcCandidate = path_1.default.resolve(featuresRoot, '..', '..', 'generate-ui');
+    if (fs_1.default.existsSync(path_1.default.join(srcCandidate, 'overlays'))) {
+        return srcCandidate;
+    }
+    const rootCandidate = path_1.default.resolve(featuresRoot, '../../..', 'generate-ui');
+    if (fs_1.default.existsSync(path_1.default.join(rootCandidate, 'overlays'))) {
+        return rootCandidate;
     }
     return null;
 }
 function resolveDefaultSchemasRoot() {
+    const userConfig = (0, user_config_1.loadUserConfig)();
+    if (userConfig?.lastSchemasPath &&
+        fs_1.default.existsSync(path_1.default.join(userConfig.lastSchemasPath, 'overlays'))) {
+        return userConfig.lastSchemasPath;
+    }
     const cwd = process.cwd();
     if (fs_1.default.existsSync(path_1.default.join(cwd, 'src'))) {
         return path_1.default.join(cwd, 'src', 'generate-ui');
     }
-    if (fs_1.default.existsSync(path_1.default.join(cwd, 'frontend', 'src'))) {
-        return path_1.default.join(cwd, 'frontend', 'src', 'generate-ui');
-    }
     return path_1.default.join(cwd, 'generate-ui');
 }
+function normalizeFeaturesRoot(value) {
+    const isSrcApp = path_1.default.basename(value) === 'app' &&
+        path_1.default.basename(path_1.default.dirname(value)) === 'src';
+    if (isSrcApp)
+        return path_1.default.join(value, 'features');
+    return value;
+}
+function findOverrides(routes, overridesRoot, generatedRoot) {
+    const results = [];
+    for (const route of routes) {
+        const overridePath = path_1.default.join(overridesRoot, route.folder, `${route.fileBase}.component.ts`);
+        const generatedPath = path_1.default.join(generatedRoot, route.folder, `${route.fileBase}.component.ts`);
+        if (!fs_1.default.existsSync(overridePath))
+            continue;
+        if (!fs_1.default.existsSync(generatedPath))
+            continue;
+        const overrideRaw = fs_1.default.readFileSync(overridePath, 'utf-8');
+        const generatedRaw = fs_1.default.readFileSync(generatedPath, 'utf-8');
+        if (overrideRaw !== generatedRaw) {
+            results.push({
+                folder: route.folder,
+                component: route.component,
+                generatedPath,
+                overridePath
+            });
+        }
+    }
+    return results;
+}
+function syncOverrides(routes, generatedRoot, overridesRoot) {
+    const overridesEmpty = fs_1.default.existsSync(overridesRoot) &&
+        fs_1.default.readdirSync(overridesRoot).length === 0;
+    if (overridesEmpty && fs_1.default.existsSync(generatedRoot)) {
+        fs_1.default.cpSync(generatedRoot, overridesRoot, { recursive: true });
+        console.log('ℹ Seeded overrides from generated (initial sync).');
+        return;
+    }
+    for (const route of routes) {
+        const sourceDir = path_1.default.join(generatedRoot, route.folder);
+        const targetDir = path_1.default.join(overridesRoot, route.folder);
+        if (!fs_1.default.existsSync(sourceDir))
+            continue;
+        if (fs_1.default.existsSync(targetDir))
+            continue;
+        fs_1.default.mkdirSync(path_1.default.dirname(targetDir), { recursive: true });
+        fs_1.default.cpSync(sourceDir, targetDir, { recursive: true });
+    }
+}
+function migrateLegacyFeatures(routes, featuresRoot, generatedRoot, overridesRoot) {
+    let migrated = false;
+    for (const route of routes) {
+        const legacyDir = path_1.default.join(featuresRoot, route.folder);
+        const generatedDir = path_1.default.join(generatedRoot, route.folder);
+        const overrideDir = path_1.default.join(overridesRoot, route.folder);
+        if (!fs_1.default.existsSync(legacyDir))
+            continue;
+        if (fs_1.default.existsSync(generatedDir) || fs_1.default.existsSync(overrideDir)) {
+            continue;
+        }
+        fs_1.default.mkdirSync(path_1.default.dirname(generatedDir), { recursive: true });
+        fs_1.default.cpSync(legacyDir, generatedDir, { recursive: true });
+        fs_1.default.cpSync(legacyDir, overrideDir, { recursive: true });
+        migrated = true;
+    }
+    if (migrated) {
+        console.log('ℹ Legacy feature folders detected. Seeded generated/overrides.');
+    }
+}
+function applyAppLayout(featuresRoot, schemasRoot) {
+    const appRoot = path_1.default.resolve(featuresRoot, '..');
+    const configInfo = findConfig(appRoot);
+    const config = configInfo.config;
+    if (configInfo.configPath) {
+        (0, logger_1.logDebug)(`Config path: ${configInfo.configPath}`);
+    }
+    if (config) {
+        const resolvedTitle = config.appTitle ?? 'Generate UI';
+        const resolvedRoute = config.defaultRoute ?? '(not set)';
+        const resolvedInject = config.menu?.autoInject !== false;
+        console.log('✅ GenerateUI config detected');
+        console.log('');
+        console.log(`  🏷️  appTitle: "${resolvedTitle}"`);
+        console.log(`  ➡️  defaultRoute: ${resolvedRoute}`);
+        console.log(`  🧭 menu.autoInject: ${resolvedInject}`);
+        console.log('  ✍️  Edit generateui-config.json before running `generate-ui generate` when you want to change title, route, views, or menu behavior.');
+        console.log('  🧩 menu overrides: edit generate-ui/menu.overrides.json to customize labels, groups, and order');
+        console.log('     (this file is created once and never overwritten)');
+        console.log('');
+    }
+    else {
+        console.log('ℹ️  No generateui-config.json found. Using defaults.');
+        console.log('');
+        console.log('  ✨ To customize, create/edit generateui-config.json at your project root before running `generate-ui generate`.');
+        console.log('  🧩 To customize the menu, edit generate-ui/menu.overrides.json (created on first generate).');
+        console.log('');
+    }
+    if (config?.defaultRoute) {
+        injectDefaultRoute(appRoot, config.defaultRoute);
+    }
+    ensureBaseStyles(appRoot);
+    const autoInject = config?.menu?.autoInject !== false;
+    if (autoInject) {
+        const appTitle = config?.appTitle || 'Generate UI';
+        injectMenuLayout(appRoot, appTitle, schemasRoot);
+    }
+}
+function findConfig(startDir) {
+    let dir = startDir;
+    let config = null;
+    let configPath = null;
+    const root = path_1.default.parse(dir).root;
+    while (true) {
+        const candidate = path_1.default.join(dir, 'generateui-config.json');
+        if (!config && fs_1.default.existsSync(candidate)) {
+            try {
+                config = JSON.parse(fs_1.default.readFileSync(candidate, 'utf-8'));
+                configPath = candidate;
+            }
+            catch {
+                config = null;
+            }
+        }
+        if (dir === root)
+            break;
+        dir = path_1.default.dirname(dir);
+    }
+    return { config, configPath };
+}
+function injectDefaultRoute(appRoot, value) {
+    const routesPath = path_1.default.join(appRoot, 'app.routes.ts');
+    if (!fs_1.default.existsSync(routesPath)) {
+        (0, logger_1.logDebug)(`Skip defaultRoute: ${routesPath} not found`);
+        return;
+    }
+    let content = fs_1.default.readFileSync(routesPath, 'utf-8');
+    const route = normalizeRoutePath(value);
+    const insertion = `  { path: '', pathMatch: 'full', redirectTo: '${route}' },\n`;
+    if (!content.trim().length) {
+        const template = `import { Routes } from '@angular/router'\nimport { generatedRoutes } from '../generate-ui/routes.gen'\n\nexport const routes: Routes = [\n${insertion}  ...generatedRoutes\n]\n`;
+        fs_1.default.writeFileSync(routesPath, template);
+        (0, logger_1.logDebug)(`Default route injected (created): ${routesPath}`);
+        return;
+    }
+    if (!content.match(/export const routes\s*:\s*Routes\s*=/)) {
+        if (!content.match(/import\s+\{\s*Routes\s*\}\s+from\s+['"]@angular\/router['"]/)) {
+            content = `import { Routes } from '@angular/router'\n${content}`;
+        }
+        content = content.replace(/export const routes\s*=/, 'export const routes: Routes =');
+    }
+    if (content.includes('generatedRoutes') &&
+        !content.match(/import\s+\{\s*generatedRoutes\s*\}\s+from\s+['"].*generate-ui\/routes\.gen['"]/)) {
+        content =
+            `import { generatedRoutes } from '../generate-ui/routes.gen'\n` +
+                content;
+    }
+    content = content.replace(/export const routes\s*=\s*\[/, match => `${match}\n${insertion}`);
+    const emptyRedirect = /path:\s*['"]\s*['"]\s*,\s*pathMatch:\s*['"]full['"]\s*,\s*redirectTo:\s*['"]\s*['"]/;
+    if (emptyRedirect.test(content)) {
+        content = content.replace(emptyRedirect, `path: '', pathMatch: 'full', redirectTo: '${route}'`);
+    }
+    fs_1.default.writeFileSync(routesPath, content);
+    (0, logger_1.logDebug)(`Default route injected (updated): ${routesPath}`);
+}
+function injectMenuLayout(appRoot, appTitle, schemasRoot) {
+    const appHtmlPath = path_1.default.join(appRoot, 'app.html');
+    const appCssPath = path_1.default.join(appRoot, 'app.css');
+    const appTsPath = path_1.default.join(appRoot, 'app.ts');
+    if (!fs_1.default.existsSync(appHtmlPath) ||
+        !fs_1.default.existsSync(appCssPath) ||
+        !fs_1.default.existsSync(appTsPath)) {
+        (0, logger_1.logDebug)('Skip menu injection: app.html/app.css/app.ts not found');
+        return;
+    }
+    const htmlRaw = fs_1.default.readFileSync(appHtmlPath, 'utf-8');
+    if (htmlRaw.includes('<ui-menu')) {
+        let updatedHtml = htmlRaw;
+        updatedHtml = updatedHtml.replace(/<ui-menu(?![^>]*\[\s*title\s*\])[\\s>]/, '<ui-menu [title]="appTitle()">');
+        if (updatedHtml !== htmlRaw) {
+            fs_1.default.writeFileSync(appHtmlPath, updatedHtml);
+            (0, logger_1.logDebug)(`Updated ui-menu title binding: ${appHtmlPath}`);
+        }
+    }
+    else {
+        const normalized = htmlRaw.replace(/\s+/g, '');
+        const isDefaultOutlet = normalized === '<router-outlet></router-outlet>' ||
+            normalized === '<router-outlet/>' ||
+            normalized === '<router-outlet/>';
+        if (!isDefaultOutlet)
+            return;
+        const newHtml = `<div class="app-shell">\n  <ui-menu [title]="appTitle()"></ui-menu>\n  <main class="app-content">\n    <router-outlet></router-outlet>\n  </main>\n</div>\n`;
+        fs_1.default.writeFileSync(appHtmlPath, newHtml);
+        (0, logger_1.logDebug)(`Injected menu layout into: ${appHtmlPath}`);
+    }
+    const cssRaw = fs_1.default.readFileSync(appCssPath, 'utf-8');
+    if (!cssRaw.includes('.app-shell')) {
+        const shellCss = `:host {\n  display: block;\n  min-height: 100vh;\n  color: #0f172a;\n  background: linear-gradient(180deg, #f8fafc 0%, #f1f5f9 100%);\n}\n\n.app-shell {\n  display: grid;\n  grid-template-columns: 260px 1fr;\n  gap: 24px;\n  padding: 24px;\n  align-items: start;\n}\n\n.app-content {\n  min-width: 0;\n}\n\n@media (max-width: 900px) {\n  .app-shell {\n    grid-template-columns: 1fr;\n  }\n}\n`;
+        fs_1.default.writeFileSync(appCssPath, cssRaw.trim().length ? `${cssRaw.trim()}\n\n${shellCss}` : shellCss);
+        (0, logger_1.logDebug)(`Injected menu shell styles into: ${appCssPath}`);
+    }
+    let tsRaw = fs_1.default.readFileSync(appTsPath, 'utf-8');
+    if (!tsRaw.includes('UiMenuComponent')) {
+        tsRaw = tsRaw.replace(/import\s+\{\s*([^}]+)\s*\}\s+from\s+['"]@angular\/router['"];/, (match) => `${match}\nimport { UiMenuComponent } from './ui/ui-menu/ui-menu.component';`);
+    }
+    if (tsRaw.includes('imports: [')) {
+        tsRaw = tsRaw.replace(/imports:\s*\[/, match => `${match}RouterOutlet, UiMenuComponent, `);
+        tsRaw = tsRaw.replace(/UiMenuComponent,\s*UiMenuComponent,\s*/g, 'UiMenuComponent, ');
+        tsRaw = tsRaw.replace(/RouterOutlet,\s*RouterOutlet,\s*/g, 'RouterOutlet, ');
+        tsRaw = tsRaw.replace(/UiMenuComponent,\s*RouterOutlet,\s*UiMenuComponent,/g, 'UiMenuComponent, ');
+    }
+    if (tsRaw.includes('appTitle')) {
+        tsRaw = tsRaw.replace(/appTitle\s*=\s*signal\('([^']*)'\)/, `appTitle = signal('${escapeString(appTitle)}')`);
+    }
+    else {
+        if (!tsRaw.match(/import\s+\{\s*[^}]*\bsignal\b[^}]*\}\s+from\s+['"]@angular\/core['"]/)) {
+            tsRaw = tsRaw.replace(/import\s+\{\s*([^}]+)\s*\}\s+from\s+['"]@angular\/core['"];?/, (match, imports) => {
+                if (imports.includes('signal'))
+                    return match;
+                return `import { ${imports.trim()}, signal } from '@angular/core';`;
+            });
+        }
+        tsRaw = tsRaw.replace(/export class App\s*\{\s*/, match => `${match}\n  protected readonly appTitle = signal('${escapeString(appTitle)}');\n`);
+    }
+    // Remove legacy runtime config loader if present.
+    if (tsRaw.includes('loadRuntimeConfig')) {
+        tsRaw = tsRaw.replace(/\\s*constructor\\(\\)\\s*\\{[\\s\\S]*?\\}\\s*/m, '\n');
+        tsRaw = tsRaw.replace(/\\s*private\\s+loadRuntimeConfig\\(\\)\\s*\\{[\\s\\S]*?\\}\\s*/m, '\n');
+    }
+    fs_1.default.writeFileSync(appTsPath, tsRaw);
+    (0, logger_1.logDebug)(`Updated app title/menu imports: ${appTsPath}`);
+    const menuComponentPath = path_1.default.join(appRoot, 'ui', 'ui-menu', 'ui-menu.component.ts');
+    if (fs_1.default.existsSync(menuComponentPath)) {
+        // Touch to keep consistent in case it was generated before config title existed.
+        void schemasRoot;
+    }
+}
+function ensureBaseStyles(appRoot) {
+    const workspaceRoot = findAngularWorkspaceRoot(appRoot) ?? path_1.default.resolve(appRoot, '..');
+    const stylesPath = path_1.default.join(workspaceRoot, 'src', 'styles.css');
+    if (fs_1.default.existsSync(stylesPath))
+        return;
+    if (fs_1.default.existsSync(path_1.default.join(workspaceRoot, 'src', 'styles.scss')))
+        return;
+    const styles = `@import url('https://fonts.googleapis.com/css2?family=DM+Sans:wght@400;500;600;700&family=Instrument+Serif:ital@0;1&display=swap');
+
+:root {
+  --bg-page: #f8fafc;
+  --bg-surface: #ffffff;
+  --bg-ink: #0f172a;
+  --color-text: #0f172a;
+  --color-muted: #64748b;
+  --color-border: #d1d5db;
+  --color-primary: #3b82f6;
+  --color-primary-strong: #1d4ed8;
+  --color-primary-soft: rgba(59, 130, 246, 0.14);
+  --color-accent: #0ea5e9;
+  --color-accent-strong: #0284c7;
+  --color-accent-soft: rgba(14, 165, 233, 0.14);
+  --shadow-card: 0 4px 16px rgba(15, 23, 42, 0.08);
+}
+
+body {
+  margin: 0;
+  background: var(--bg-page);
+  color: var(--color-text);
+  font-family: "DM Sans", "Segoe UI", sans-serif;
+}
+`;
+    fs_1.default.writeFileSync(stylesPath, styles);
+}
+function findAngularWorkspaceRoot(startDir) {
+    let dir = startDir;
+    const root = path_1.default.parse(dir).root;
+    while (true) {
+        const candidate = path_1.default.join(dir, 'angular.json');
+        if (fs_1.default.existsSync(candidate))
+            return dir;
+        if (dir === root)
+            return null;
+        dir = path_1.default.dirname(dir);
+    }
+}
+function escapeString(value) {
+    return String(value).replace(/'/g, "\\'");
+}
+function normalizeRoutePath(value) {
+    const trimmed = String(value ?? '').trim();
+    if (!trimmed)
+        return trimmed;
+    if (trimmed.includes('/'))
+        return trimmed.replace(/^\//, '');
+    const pascal = toPascalCase(trimmed);
+    return toRouteSegment(pascal);
+}
+function toRouteSegment(value) {
+    if (!value)
+        return value;
+    return value[0].toLowerCase() + value.slice(1);
+}
+function toPascalCase(value) {
+    return String(value)
+        .split(/[^a-zA-Z0-9]+/)
+        .filter(Boolean)
+        .map(part => part[0].toUpperCase() + part.slice(1))
+        .join('');
+}