generate-ui-cli 2.1.7 → 2.2.0

package/README.md

@@ -92,6 +92,7 @@ What happens after this command:
   - a typed API service
   - DTO/types files
   - route definitions
+  - `menu.json` and `menu.gen.ts` (if present in `generate-ui/`)
 
 What you should review now:
 
@@ -107,6 +108,52 @@ Defaults:
 - `--schemas` defaults to the last generated path (stored in `~/.generateui/config.json`), otherwise `./src/generate-ui` (or `./frontend/src/generate-ui` / `./generate-ui`)
 - `--features` defaults to `./src/app/features` when `./src/app` exists; otherwise it errors and asks for `--features`
 
+### generateui-config.json (optional)
+
+GenerateUI creates a `generateui-config.json` at your project root on first `generate`. You can edit it to:
+
+- inject a sidebar menu layout automatically (when `menu.autoInject` is not `false`)
+- add a default redirect for `/` using `defaultRoute`
+- show a custom app title in the menu (`appTitle`)
+
+Example:
+
+```json
+{
+  "appTitle": "Rick & Morty Admin",
+  "defaultRoute": "GetCharacter",
+  "menu": {
+    "autoInject": true
+  }
+}
+```
+
+Notes:
+- If `menu.autoInject` is `false`, the menu layout is not injected.
+- `defaultRoute` must match a path in `routes.gen.ts` (the same path used by the router).
+- You can provide either the final route path or an `operationId`; the generator normalizes it to the correct path.
+- You can override the menu by adding `menu.overrides.json` inside your `generate-ui/` folder (it replaces the generated menu entirely).
+
+Example `menu.overrides.json`:
+
+```json
+{
+  "groups": [
+    {
+      "id": "cadastros",
+      "label": "Cadastros",
+      "items": [
+        { "id": "GetCharacter", "label": "Personagens", "route": "getCharacter" },
+        { "id": "GetLocation", "label": "Localizações", "route": "getLocation" }
+      ]
+    }
+  ],
+  "ungrouped": [
+    { "id": "GetEpisode", "label": "Episódios", "route": "getEpisode" }
+  ]
+}
+```
+
 Optional paths:
 
 ```bash

package/dist/commands/angular.js

@@ -8,23 +8,49 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const feature_generator_1 = 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 logger_1 = require("../runtime/logger");
 async function angular(options) {
     void (0, telemetry_1.trackCommand)('angular', options.telemetryEnabled);
     const featuresRoot = resolveFeaturesRoot(options.featuresPath);
     const schemasRoot = resolveSchemasRoot(options.schemasPath, featuresRoot);
+    (0, logger_1.logStep)(`Features output: ${featuresRoot}`);
+    (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}`);
+        const example = [
+            'generate-ui angular \\',
+            '  --schemas /path/to/generate-ui \\',
+            '  --features /path/to/src/app/features'
+        ].join('\n');
+        throw new Error(`Overlays directory not found: ${overlaysDir}\n` +
+            'Run `generate-ui generate --openapi <path> --output <schemas>` first to create overlays.\n' +
+            `Example:\n${example}`);
     }
+    (0, logger_1.logDebug)(`Overlays dir: ${overlaysDir}`);
     const screens = fs_1.default
         .readdirSync(overlaysDir)
         .filter(f => f.endsWith('.screen.json'));
+    (0, logger_1.logDebug)(`Screens found: ${screens.length}`);
+    if (screens.length === 0) {
+        const example = [
+            'generate-ui angular \\',
+            '  --schemas /path/to/generate-ui \\',
+            '  --features /path/to/src/app/features'
+        ].join('\n');
+        throw new Error(`No .screen.json files found in: ${overlaysDir}\n` +
+            'Run again with --schemas pointing to your generate-ui folder.\n' +
+            `Example:\n${example}`);
+    }
     /**
      * Onde gerar as features Angular
      */
@@ -36,19 +62,15 @@ async function angular(options) {
         routes.push(route);
     }
     (0, routes_generator_1.generateRoutes)(routes, featuresRoot, schemasRoot);
+    (0, menu_generator_1.generateMenu)(schemasRoot);
+    applyAppLayout(featuresRoot, schemasRoot);
     console.log(`✔ Angular features generated at ${featuresRoot}`);
+    (0, logger_1.logTip)('Run with --dev to see detailed logs and file paths.');
 }
 function resolveSchemasRoot(value, featuresRoot) {
     if (value) {
         return path_1.default.resolve(process.cwd(), value);
     }
-    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 inferred = inferSchemasRootFromFeatures(featuresRoot);
     if (inferred)
         return inferred;
@@ -71,9 +93,13 @@ function resolveFeaturesRoot(value) {
     return path_1.default.join(srcAppRoot, 'features');
 }
 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;
 }
@@ -87,3 +113,186 @@ function resolveDefaultSchemasRoot() {
     }
     return path_1.default.join(cwd, 'generate-ui');
 }
+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('  🧩 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, add generateui-config.json at your project root.');
+        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);
+    }
+    const autoInject = config?.menu?.autoInject !== false;
+    if (!autoInject)
+        return;
+    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 =');
+    }
+    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:\n    radial-gradient(circle at top left, rgba(14, 116, 144, 0.14), transparent 55%),\n    radial-gradient(circle at bottom right, rgba(59, 130, 246, 0.12), transparent 50%),\n    linear-gradient(180deg, #f8fafc 0%, #eef2f7 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 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('');
+}

package/dist/commands/generate.js

@@ -13,6 +13,7 @@ const permissions_1 = require("../license/permissions");
 const device_1 = require("../license/device");
 const telemetry_1 = require("../telemetry");
 const user_config_1 = require("../runtime/user-config");
+const logger_1 = require("../runtime/logger");
 async function generate(options) {
     void (0, telemetry_1.trackCommand)('generate', options.telemetryEnabled);
     /**
@@ -20,16 +21,21 @@ async function generate(options) {
      * Ex: /Users/.../generateui-playground/realWorldOpenApi.yaml
      */
     const openApiPath = path_1.default.resolve(process.cwd(), options.openapi);
+    (0, logger_1.logStep)(`OpenAPI: ${openApiPath}`);
     /**
      * Raiz do playground (onde está o YAML)
      */
     const projectRoot = path_1.default.dirname(openApiPath);
+    (0, logger_1.logDebug)(`Project root: ${projectRoot}`);
     /**
      * Onde o Angular consome os arquivos
      */
     const generateUiRoot = resolveGenerateUiRoot(projectRoot, options.output);
+    (0, logger_1.logStep)(`Schemas output: ${generateUiRoot}`);
     const generatedDir = path_1.default.join(generateUiRoot, 'generated');
     const overlaysDir = path_1.default.join(generateUiRoot, 'overlays');
+    (0, logger_1.logDebug)(`Generated dir: ${generatedDir}`);
+    (0, logger_1.logDebug)(`Overlays dir: ${overlaysDir}`);
     (0, user_config_1.updateUserConfig)(config => ({
         ...config,
         lastSchemasPath: generateUiRoot
@@ -43,17 +49,20 @@ async function generate(options) {
     const usedOperationIds = new Set();
     const permissions = await (0, permissions_1.getPermissions)();
     const device = (0, device_1.loadDeviceIdentity)();
+    (0, logger_1.logDebug)(`License: maxGenerations=${permissions.features.maxGenerations}, overrides=${permissions.features.uiOverrides}, safeRegen=${permissions.features.safeRegeneration}`);
     if (permissions.features.maxGenerations > -1 &&
         device.freeGenerationsUsed >= permissions.features.maxGenerations) {
         throw new Error('🔒 Você já utilizou sua geração gratuita.\n' +
             'O plano Dev libera gerações ilimitadas, regeneração segura e UI inteligente.\n' +
-            '👉 Execute `generate-ui login` para continuar.');
+            '👉 Execute `generate-ui login` para continuar.\n' +
+            'Se você já fez login e ainda vê esta mensagem, tente novamente com a mesma versão do CLI e verifique a conexão com a API.');
     }
     /**
      * Parse do OpenAPI (já com $refs resolvidos)
      */
     const api = await (0, load_openapi_1.loadOpenApi)(openApiPath);
     const paths = api.paths ?? {};
+    (0, logger_1.logDebug)(`OpenAPI paths: ${Object.keys(paths).length}`);
     /**
      * Itera por todos os endpoints
      */
@@ -117,16 +126,58 @@ async function generate(options) {
              */
             routes.push({
                 path: operationId,
-                operationId
+                operationId,
+                label: toLabel(screenSchema.entity
+                    ? String(screenSchema.entity)
+                    : operationId),
+                group: inferRouteGroup(op, pathKey)
             });
             console.log(`✔ Generated ${operationId}`);
         }
     }
+    (0, logger_1.logStep)(`Screens generated: ${routes.length}`);
     /**
      * 4️⃣ Gera arquivo de rotas
      */
     const routesPath = path_1.default.join(generateUiRoot, 'routes.json');
     fs_1.default.writeFileSync(routesPath, JSON.stringify(routes, null, 2));
+    (0, logger_1.logDebug)(`Routes written: ${routesPath}`);
+    /**
+     * 4.3️⃣ Gera generateui-config.json (não sobrescreve)
+     */
+    const configPath = path_1.default.join(generateUiRoot, '..', '..', 'generateui-config.json');
+    if (!fs_1.default.existsSync(configPath)) {
+        const defaultConfig = {
+            appTitle: 'Generate UI',
+            defaultRoute: '',
+            menu: {
+                autoInject: true
+            }
+        };
+        fs_1.default.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2));
+        (0, logger_1.logDebug)(`Config created: ${configPath}`);
+    }
+    else {
+        (0, logger_1.logDebug)(`Config found: ${configPath}`);
+    }
+    /**
+     * 4.1️⃣ Gera menu inicial (override possível via menu.overrides.json)
+     */
+    const menuPath = path_1.default.join(generateUiRoot, 'menu.json');
+    const menu = buildMenuFromRoutes(routes);
+    fs_1.default.writeFileSync(menuPath, JSON.stringify(menu, null, 2));
+    (0, logger_1.logDebug)(`Menu written: ${menuPath}`);
+    /**
+     * 4.2️⃣ Gera menu.overrides.json (não sobrescreve)
+     */
+    const menuOverridesPath = path_1.default.join(generateUiRoot, 'menu.overrides.json');
+    if (!fs_1.default.existsSync(menuOverridesPath)) {
+        fs_1.default.writeFileSync(menuOverridesPath, JSON.stringify(menu, null, 2));
+        (0, logger_1.logDebug)(`Menu overrides created: ${menuOverridesPath}`);
+    }
+    else {
+        (0, logger_1.logDebug)(`Menu overrides found: ${menuOverridesPath}`);
+    }
     /**
      * 5️⃣ Remove overlays órfãos (endpoint removido)
      */
@@ -146,6 +197,15 @@ async function generate(options) {
         (0, device_1.incrementFreeGeneration)();
     }
     console.log('✔ Routes generated');
+    console.log('');
+    console.log('🎉 Next steps');
+    console.log('  1) Generate Angular code:');
+    console.log('     generate-ui angular --schemas <your-generate-ui> --features <your-app>/src/app/features');
+    console.log('  2) Customize screens in generate-ui/overlays/');
+    console.log('  3) Customize menu in generate-ui/menu.overrides.json (created once, never overwritten)');
+    console.log('  4) Edit generateui-config.json to set appTitle/defaultRoute/menu.autoInject');
+    console.log('');
+    (0, logger_1.logTip)('Run with --dev to see detailed logs and file paths.');
 }
 function resolveGenerateUiRoot(projectRoot, output) {
     if (output) {
@@ -199,6 +259,64 @@ function buildOperationId(method, pathKey, usedOperationIds) {
     usedOperationIds.add(candidate);
     return candidate;
 }
+function inferRouteGroup(op, pathKey) {
+    const tag = Array.isArray(op?.tags) && op.tags.length
+        ? String(op.tags[0]).trim()
+        : '';
+    if (tag)
+        return tag;
+    const segment = String(pathKey || '')
+        .split('/')
+        .map(part => part.trim())
+        .filter(Boolean)
+        .find(part => !part.startsWith('{') && !part.endsWith('}'));
+    return segment ? segment : null;
+}
+function buildMenuFromRoutes(routes) {
+    const groups = [];
+    const ungrouped = [];
+    const groupMap = new Map();
+    for (const route of routes) {
+        const item = {
+            id: route.operationId,
+            label: toLabel(route.label || route.operationId),
+            route: route.path
+        };
+        const rawGroup = route.group ? String(route.group) : '';
+        if (!rawGroup) {
+            ungrouped.push(item);
+            continue;
+        }
+        const groupId = toKebab(rawGroup);
+        let group = groupMap.get(groupId);
+        if (!group) {
+            group = {
+                id: groupId,
+                label: toLabel(rawGroup),
+                items: []
+            };
+            groupMap.set(groupId, group);
+            groups.push(group);
+        }
+        group.items.push(item);
+    }
+    return {
+        groups,
+        ungrouped
+    };
+}
+function toKebab(value) {
+    return String(value)
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/[_\s]+/g, '-')
+        .toLowerCase();
+}
+function toLabel(value) {
+    return String(value)
+        .replace(/[_-]/g, ' ')
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .replace(/\b\w/g, char => char.toUpperCase());
+}
 function httpVerbToPrefix(verb) {
     switch (verb) {
         case 'get':

package/dist/commands/login.js

@@ -6,25 +6,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.login = login;
 const http_1 = __importDefault(require("http"));
 const url_1 = require("url");
-const promises_1 = require("readline/promises");
+const child_process_1 = require("child_process");
 const config_1 = require("../runtime/config");
 const user_config_1 = require("../runtime/user-config");
 const open_browser_1 = require("../runtime/open-browser");
 const token_1 = require("../license/token");
 const permissions_1 = require("../license/permissions");
 const telemetry_1 = require("../telemetry");
+const logger_1 = require("../runtime/logger");
 const LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
 async function login(options) {
     void (0, telemetry_1.trackCommand)('login', options.telemetryEnabled);
+    (0, logger_1.logStep)('Starting login flow');
     const token = await waitForLogin();
     (0, token_1.saveToken)(token);
+    (0, logger_1.logDebug)('Token saved');
+    let permissionsLoaded = false;
     try {
         await (0, permissions_1.fetchPermissions)();
+        permissionsLoaded = true;
     }
     catch {
-        // Cached permissions will be refreshed on next online command.
+        console.warn('⚠ Não foi possível validar a licença agora. Verifique sua conexão e rode o comando novamente se necessário.');
     }
-    const email = await promptEmail();
+    const email = resolveLoginEmail();
     if (email) {
         (0, user_config_1.updateUserConfig)((config) => ({
             ...config,
@@ -32,22 +37,27 @@ async function login(options) {
         }));
     }
     await (0, telemetry_1.trackLogin)(email, options.telemetryEnabled);
-    console.log('✔ Login completo');
+    console.log(permissionsLoaded
+        ? '✔ Login completo'
+        : '✔ Login completo (verificação pendente)');
 }
-async function promptEmail() {
-    if (!process.stdin.isTTY)
-        return null;
-    const rl = (0, promises_1.createInterface)({
-        input: process.stdin,
-        output: process.stdout
-    });
+function resolveLoginEmail() {
+    const envEmail = process.env.GIT_AUTHOR_EMAIL ||
+        process.env.GIT_COMMITTER_EMAIL ||
+        process.env.EMAIL;
+    if (envEmail && envEmail.trim().length) {
+        return envEmail.trim();
+    }
     try {
-        const value = await rl.question('Email (optional): ');
-        const trimmed = value.trim();
-        return trimmed.length ? trimmed : null;
+        const output = (0, child_process_1.execSync)('git config --get user.email', {
+            stdio: ['ignore', 'pipe', 'ignore']
+        })
+            .toString()
+            .trim();
+        return output.length ? output : null;
     }
-    finally {
-        rl.close();
+    catch {
+        return null;
     }
 }
 async function waitForLogin() {
@@ -68,7 +78,7 @@ async function waitForLogin() {
                 res.end('Missing access token');
                 return;
             }
-            const expiresAt = expiresAtParam ||
+            const expiresAt = normalizeExpiresAt(expiresAtParam) ||
                 new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString();
             res.writeHead(200, { 'Content-Type': 'text/html' });
             res.end(`<!doctype html>
@@ -158,7 +168,24 @@ async function waitForLogin() {
             url.searchParams.set('api_base', (0, config_1.getApiBaseUrl)());
             loginUrl = url.toString();
             console.log(`Open this URL to finish login: ${loginUrl}`);
+            (0, logger_1.logDebug)(`Login callback listening on ${redirectUri}`);
             (0, open_browser_1.openBrowser)(loginUrl);
         });
     });
 }
+function normalizeExpiresAt(value) {
+    if (!value)
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed.length)
+        return null;
+    const asNumber = Number(trimmed);
+    if (Number.isFinite(asNumber)) {
+        const ms = asNumber < 1e12 ? asNumber * 1000 : asNumber;
+        return new Date(ms).toISOString();
+    }
+    const parsed = new Date(trimmed);
+    if (Number.isNaN(parsed.getTime()))
+        return null;
+    return parsed.toISOString();
+}

package/dist/generate-ui/routes.gen.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatedRoutes = void 0;
+exports.generatedRoutes = [];