generate-ui-cli 2.2.0 → 2.3.0

package/dist/generators/angular/menu.generator.js

@@ -108,7 +108,7 @@ function buildMenuFromRoutes(routes) {
             continue;
         const item = {
             id: String(route.operationId),
-            label: String(route.label ?? route.operationId),
+            label: toLabel(String(route.label ?? route.operationId)),
             route: normalizeRoutePath(String(route.path ?? route.operationId ?? ''))
         };
         const rawGroup = route.group ? String(route.group) : '';

package/dist/generators/angular/routes.generator.js

@@ -6,9 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateRoutes = generateRoutes;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-function generateRoutes(routes, featuresRoot, schemasRoot) {
+function generateRoutes(routes, generatedRoot, overridesRoot, schemasRoot) {
     const out = path_1.default.join(schemasRoot, 'routes.gen.ts');
-    const featuresImportBase = buildRelativeImportBase(schemasRoot, featuresRoot);
+    const generatedImportBase = buildRelativeImportBase(schemasRoot, generatedRoot);
+    const overridesImportBase = buildRelativeImportBase(schemasRoot, overridesRoot);
     fs_1.default.mkdirSync(path_1.default.dirname(out), { recursive: true });
     const content = `
 import { Routes } from '@angular/router'
@@ -16,7 +17,11 @@ import { Routes } from '@angular/router'
 export const generatedRoutes: Routes = [
 ${routes
         .flatMap(r => {
-        const baseImport = ensureRelativeImport(toPosixPath(path_1.default.join(featuresImportBase, r.folder, `${r.fileBase}.component`)));
+        const overridePath = path_1.default.join(overridesRoot, r.folder, `${r.fileBase}.component.ts`);
+        const importBase = fs_1.default.existsSync(overridePath)
+            ? overridesImportBase
+            : generatedImportBase;
+        const baseImport = ensureRelativeImport(toPosixPath(path_1.default.join(importBase, r.folder, `${r.fileBase}.component`)));
         const base = `  {
     path: '${r.path}',
     loadComponent: () =>

package/dist/generators/screen.generator.js

@@ -19,13 +19,13 @@ function inferScreen(method, hasInput) {
 }
 function inferActions(method, hasInput) {
     if (method === 'get' && hasInput) {
-        return { primary: { type: 'submit', label: 'Buscar' } };
+        return { primary: { type: 'submit', label: 'Search' } };
     }
     if (method === 'post') {
-        return { primary: { type: 'submit', label: 'Criar' } };
+        return { primary: { type: 'submit', label: 'Create' } };
     }
     if (method === 'put' || method === 'patch') {
-        return { primary: { type: 'submit', label: 'Salvar' } };
+        return { primary: { type: 'submit', label: 'Save' } };
     }
     return {};
 }
@@ -49,6 +49,15 @@ function generateScreen(endpoint, api) {
         pathParams.length > 0;
     const openapiVersion = api?.info?.version || 'unknown';
     const screenMeta = buildMeta(endpoint.operationId, 'api', openapiVersion);
+    const columnKeys = method === 'get'
+        ? inferResponseColumns(endpoint)
+        : [];
+    const responseFormat = inferResponseFormat(endpoint);
+    const columns = columnKeys.map(key => ({
+        key,
+        label: toLabel(key),
+        visible: true
+    }));
     return {
         meta: screenMeta,
         entity: endpoint.summary
@@ -70,9 +79,90 @@ function generateScreen(endpoint, api) {
         layout: { type: 'single' },
         fields: decorateFields(fields, 'body', openapiVersion),
         actions: inferActions(method, hasInput),
-        data: {}
+        response: responseFormat
+            ? { format: responseFormat }
+            : undefined,
+        data: {
+            table: {
+                columns
+            }
+        }
     };
 }
+function inferResponseColumns(endpoint) {
+    const schema = getPrimaryResponseSchema(endpoint);
+    if (!schema)
+        return [];
+    return inferColumnsFromSchema(schema);
+}
+function inferResponseFormat(endpoint) {
+    const schema = getPrimaryResponseSchema(endpoint);
+    if (!schema)
+        return null;
+    if (!hasResponseData(schema))
+        return null;
+    return 'table';
+}
+function getPrimaryResponseSchema(endpoint) {
+    const responses = endpoint?.responses ?? {};
+    const candidate = responses['200'] ||
+        responses['201'] ||
+        responses.default ||
+        Object.values(responses)[0];
+    return candidate?.content?.['application/json']?.schema ?? null;
+}
+function hasResponseData(schema) {
+    if (!schema)
+        return false;
+    if (Array.isArray(schema.allOf)) {
+        return schema.allOf.some((entry) => hasResponseData(entry));
+    }
+    if (Array.isArray(schema.anyOf)) {
+        return schema.anyOf.some((entry) => hasResponseData(entry));
+    }
+    if (Array.isArray(schema.oneOf)) {
+        return schema.oneOf.some((entry) => hasResponseData(entry));
+    }
+    if (schema.type === 'array')
+        return true;
+    if (schema.type === 'object' &&
+        (schema.properties || schema.additionalProperties)) {
+        return true;
+    }
+    return inferColumnsFromSchema(schema).length > 0;
+}
+function inferColumnsFromSchema(schema) {
+    if (!schema)
+        return [];
+    if (Array.isArray(schema.allOf)) {
+        for (const entry of schema.allOf) {
+            const columns = inferColumnsFromSchema(entry);
+            if (columns.length)
+                return columns;
+        }
+    }
+    if (schema.type === 'array') {
+        return inferColumnsFromSchema(schema.items);
+    }
+    if (schema.type === 'object' && schema.properties) {
+        const commonKeys = [
+            'data',
+            'items',
+            'results',
+            'list',
+            'records',
+            'products'
+        ];
+        for (const key of commonKeys) {
+            const nested = schema.properties[key];
+            const columns = inferColumnsFromSchema(nested);
+            if (columns.length)
+                return columns;
+        }
+        return Object.keys(schema.properties);
+    }
+    return [];
+}
 function extractQueryParams(endpoint, api) {
     const params = endpoint?.parameters ?? [];
     return params
@@ -110,11 +200,16 @@ function extractPathParams(path, api) {
     }));
 }
 function toLabel(value) {
-    return String(value)
+    return stripDiacritics(String(value))
         .replace(/[_-]/g, ' ')
         .replace(/([a-z])([A-Z])/g, '$1 $2')
         .replace(/\b\w/g, char => char.toUpperCase());
 }
+function stripDiacritics(value) {
+    return value
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '');
+}
 function buildMeta(id, source, openapiVersion) {
     return {
         id,

package/dist/generators/screen.merge.js

@@ -10,6 +10,10 @@ const PRESENTATION_KEYS = [
     'group',
     'hidden'
 ];
+const COLUMN_PRESENTATION_KEYS = [
+    'label',
+    'visible'
+];
 function mergeScreen(nextScreen, overlay, prevGenerated, options) {
     const debug = [];
     if (!overlay) {
@@ -25,7 +29,9 @@ function mergeScreen(nextScreen, overlay, prevGenerated, options) {
         entity: normalizedOverlay.entity ?? normalizedNext.entity,
         screen: normalizedOverlay.screen ?? normalizedNext.screen,
         layout: normalizedOverlay.layout ?? normalizedNext.layout,
-        actions: mergeActions(normalizedNext.actions, normalizedOverlay.actions)
+        actions: mergeActions(normalizedNext.actions, normalizedOverlay.actions),
+        response: mergeResponse(normalizedNext.response, normalizedOverlay.response),
+        data: mergeData(normalizedNext.data, normalizedOverlay.data)
     };
     merged.api = {
         ...normalizedNext.api,
@@ -46,6 +52,62 @@ function mergeActions(nextActions, overlayActions) {
     }
     return merged;
 }
+function mergeResponse(nextResponse, overlayResponse) {
+    if (!overlayResponse)
+        return nextResponse;
+    const allowed = ['table', 'cards', 'raw'];
+    const candidate = String(overlayResponse?.format || '')
+        .trim()
+        .toLowerCase();
+    if (!allowed.includes(candidate))
+        return nextResponse;
+    return {
+        ...(nextResponse || {}),
+        format: candidate
+    };
+}
+function mergeData(nextData, overlayData) {
+    const nextColumns = nextData?.table?.columns;
+    const overlayColumns = overlayData?.table?.columns;
+    if (!Array.isArray(nextColumns)) {
+        return nextData ?? {};
+    }
+    const overlayMap = new Map();
+    if (Array.isArray(overlayColumns)) {
+        for (const entry of overlayColumns) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const key = String(entry.key ?? entry.id ?? entry.column ?? '').trim();
+            if (!key)
+                continue;
+            overlayMap.set(key, entry);
+        }
+    }
+    const mergedColumns = nextColumns.map((entry) => {
+        if (!entry || typeof entry !== 'object')
+            return entry;
+        const key = String(entry.key ?? entry.id ?? entry.column ?? '').trim();
+        if (!key)
+            return entry;
+        const overlay = overlayMap.get(key);
+        if (!overlay)
+            return entry;
+        const merged = { ...entry };
+        for (const prop of COLUMN_PRESENTATION_KEYS) {
+            if (overlay[prop] !== undefined) {
+                merged[prop] = overlay[prop];
+            }
+        }
+        return merged;
+    });
+    return {
+        ...(nextData || {}),
+        table: {
+            ...(nextData?.table || {}),
+            columns: mergedColumns
+        }
+    };
+}
 function mergeFieldList(nextFields, overlayFields, prevFields, options, debug, scope) {
     const nextMap = indexById(nextFields, scope);
     const overlayMap = indexById(overlayFields, scope);
@@ -80,20 +142,6 @@ function mergeFieldList(nextFields, overlayFields, prevFields, options, debug, s
     for (const [id, nextField] of nextMap.entries()) {
         if (used.has(id))
             continue;
-        const prevField = prevMap.get(id);
-        if (prevField && !overlayMap.has(id)) {
-            result.push({
-                ...nextField,
-                hidden: true,
-                meta: {
-                    ...mergeMeta(nextField.meta, prevField.meta, options.openapiVersion),
-                    userRemoved: true,
-                    lastChangedBy: 'user'
-                }
-            });
-            debug.push(`USER_REMOVED_TOMBSTONE ${id}`);
-            continue;
-        }
         const autoAdded = !nextField.required;
         result.push({
             ...nextField,
@@ -127,6 +175,13 @@ function mergeField(nextField, overlayField, prevField, options, debug) {
     if (prevField && prevField.type !== nextField.type) {
         merged.ui = undefined;
         merged.options = nextField.options ?? null;
+        merged.defaultValue = nextField.defaultValue;
+        merged.hidden = nextField.hidden;
+        merged.meta = {
+            ...meta,
+            userRemoved: false,
+            lastChangedBy: 'api'
+        };
         debug.push(`TYPE_CHANGED ${meta.id}`);
     }
     const prevEnum = Array.isArray(prevField?.options);

package/dist/index.js

@@ -5,6 +5,7 @@ const commander_1 = require("commander");
 const generate_1 = require("./commands/generate");
 const angular_1 = require("./commands/angular");
 const login_1 = require("./commands/login");
+const merge_1 = require("./commands/merge");
 const config_1 = require("./runtime/config");
 const telemetry_1 = require("./telemetry");
 const logger_1 = require("./runtime/logger");
@@ -17,13 +18,45 @@ program
     .option('--dev', 'Enable verbose logs')
     .option('--verbose', 'Enable verbose logs (same as --dev)');
 /**
- * 1️⃣ OpenAPI → Screen schemas
+ * 1️⃣ Default flow: OpenAPI → Schemas → Angular
  */
 program
     .command('generate')
-    .description('Generate screen schemas from OpenAPI')
-    .requiredOption('-o, --openapi <path>', 'OpenAPI file')
-    .option('--output <path>', 'Output directory for generate-ui (default: ./src/generate-ui or ./generate-ui)')
+    .description('Generate schemas and Angular code (default flow)')
+    .option('-o, --openapi <path>', 'OpenAPI file (optional if configured in generateui-config.json)')
+    .option('--output <path>', 'Output directory for generate-ui (optional if configured in generateui-config.json)')
+    .option('-f, --features <path>', 'Angular features output directory (optional if configured in generateui-config.json)')
+    .option('-w, --watch', 'Keep watching .screen.json files after generation')
+    .option('-d, --debug', 'Explain merge decisions')
+    .action(async (options) => {
+    const { telemetry, dev, verbose } = program.opts();
+    (0, logger_1.setVerbose)(Boolean(dev || verbose));
+    try {
+        await (0, telemetry_1.trackGenerateCalled)();
+        await (0, generate_1.generate)({
+            openapi: options.openapi,
+            output: options.output,
+            debug: options.debug,
+            telemetryEnabled: telemetry
+        });
+        await (0, angular_1.angular)({
+            featuresPath: options.features,
+            watch: Boolean(options.watch),
+            telemetryEnabled: telemetry
+        });
+    }
+    catch (error) {
+        handleCliError(error);
+    }
+});
+/**
+ * 2️⃣ Advanced: OpenAPI → Screen schemas only
+ */
+program
+    .command('schema')
+    .description('Advanced: generate screen schemas only')
+    .option('-o, --openapi <path>', 'OpenAPI file (optional if configured in generateui-config.json)')
+    .option('--output <path>', 'Output directory for generate-ui (optional if configured in generateui-config.json)')
     .option('-d, --debug', 'Explain merge decisions')
     .action(async (options) => {
     const { telemetry, dev, verbose } = program.opts();
@@ -42,13 +75,15 @@ program
     }
 });
 /**
- * 2️⃣ Screen schemas → Angular code
+ * 3️⃣ Advanced: Screen schemas → Angular code
  */
 program
     .command('angular')
-    .description('Generate Angular code from screen schemas')
+    .description('Advanced: generate Angular code from screen schemas')
     .option('-s, --schemas <path>', 'Directory containing generate-ui (with overlays/)')
-    .option('-f, --features <path>', 'Angular features output directory')
+    .option('-f, --features <path>', 'Angular features output directory (optional if configured in generateui-config.json)')
+    .option('-w, --watch', 'Watch .screen.json files and regenerate Angular on changes (default)')
+    .option('--no-watch', 'Run Angular generation once and exit')
     .action(async (options) => {
     const { telemetry, dev, verbose } = program.opts();
     (0, logger_1.setVerbose)(Boolean(dev || verbose));
@@ -56,6 +91,7 @@ program
         await (0, angular_1.angular)({
             schemasPath: options.schemas,
             featuresPath: options.features,
+            watch: options.watch !== false,
             telemetryEnabled: telemetry
         });
     }
@@ -64,7 +100,7 @@ program
     }
 });
 /**
- * 3️⃣ Login (Dev plan)
+ * 4️⃣ Login (Dev plan)
  */
 program
     .command('login')
@@ -79,6 +115,31 @@ program
         handleCliError(error);
     }
 });
+/**
+ * 5️⃣ Compare generated vs overrides (interactive)
+ */
+program
+    .command('merge')
+    .description('Compare generated vs overrides with an interactive diff tool')
+    .requiredOption('--feature <name>', 'Feature folder or operationId')
+    .option('-f, --features <path>', 'Angular features output directory')
+    .option('--file <name>', 'File to compare: component.ts, component.html, component.scss, or all')
+    .option('--tool <name>', 'Diff tool (code, meld, kdiff3, bc, or any executable)')
+    .action(async (options) => {
+    const { telemetry, dev, verbose } = program.opts();
+    (0, logger_1.setVerbose)(Boolean(dev || verbose));
+    try {
+        await (0, merge_1.merge)({
+            featuresPath: options.features,
+            feature: options.feature,
+            file: options.file,
+            tool: options.tool
+        });
+    }
+    catch (error) {
+        handleCliError(error);
+    }
+});
 function handleCliError(error) {
     if (error instanceof Error) {
         console.error(error.message.replace(/\\n/g, '\n'));

package/dist/license/guard.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requireFeature = requireFeature;
+const config_1 = require("../runtime/config");
 function requireFeature(features, featureKey, reason) {
     if (!features[featureKey]) {
         const details = reason ? ` ${reason}` : '';
-        throw new Error(`Requires Dev plan.${details} Execute \`generate-ui login\` to continue.`);
+        throw new Error(`This feature requires an active paid subscription.${details} Upgrade: ${(0, config_1.getDevPlanUrl)()}`);
     }
 }

package/dist/license/permissions.js

@@ -14,12 +14,15 @@ const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.generateui');
 const PERMISSIONS_PATH = path_1.default.join(CONFIG_DIR, 'permissions.json');
 const DEV_OFFLINE_DAYS = 7;
 const FREE_DEFAULT = {
-    plan: 'free',
     features: {
         intelligentGeneration: false,
         safeRegeneration: false,
         uiOverrides: false,
-        maxGenerations: 1
+        maxGenerations: -1
+    },
+    subscription: {
+        status: 'anonymous',
+        reason: 'Login required to unlock paid features.'
     }
 };
 function ensureConfigDir() {
@@ -30,7 +33,7 @@ function readCache() {
         return null;
     try {
         const parsed = JSON.parse(fs_1.default.readFileSync(PERMISSIONS_PATH, 'utf-8'));
-        if (!parsed.plan || !parsed.features)
+        if (!parsed.features || !parsed.subscription?.status)
             return null;
         return parsed;
     }
@@ -52,9 +55,7 @@ function writeCache(response) {
 async function fetchPermissions() {
     const apiBase = (0, config_1.getApiBaseUrl)();
     const token = (0, token_1.loadToken)();
-    const headers = {
-        'Content-Type': 'application/json'
-    };
+    const headers = {};
     if (token?.accessToken) {
         headers.Authorization = `Bearer ${token.accessToken}`;
     }
@@ -65,10 +66,48 @@ async function fetchPermissions() {
     if (!response.ok) {
         throw new Error('Failed to fetch permissions');
     }
-    const data = (await response.json());
+    const raw = (await response.json());
+    const data = normalizePermissions(raw);
     writeCache(data);
     return data;
 }
+function normalizePermissions(raw) {
+    const features = normalizeFeatures(raw?.features);
+    const subscription = normalizeSubscription(raw);
+    return { features, subscription };
+}
+function normalizeFeatures(raw) {
+    const fallback = FREE_DEFAULT.features;
+    return {
+        intelligentGeneration: typeof raw?.intelligentGeneration === 'boolean'
+            ? raw.intelligentGeneration
+            : fallback.intelligentGeneration,
+        safeRegeneration: typeof raw?.safeRegeneration === 'boolean'
+            ? raw.safeRegeneration
+            : fallback.safeRegeneration,
+        uiOverrides: typeof raw?.uiOverrides === 'boolean'
+            ? raw.uiOverrides
+            : fallback.uiOverrides,
+        maxGenerations: typeof raw?.maxGenerations === 'number'
+            ? raw.maxGenerations
+            : fallback.maxGenerations
+    };
+}
+function normalizeSubscription(raw) {
+    const source = raw?.subscription ?? {};
+    const status = String(source?.status ??
+        (raw?.plan === 'dev' ? 'active' : 'inactive'));
+    const reasonValue = source?.reason;
+    const normalizedStatus = status.toLowerCase();
+    return {
+        status,
+        reason: typeof reasonValue === 'string' && reasonValue.trim().length
+            ? reasonValue
+            : normalizedStatus === 'active'
+                ? null
+                : `Assinatura inativa. Faça upgrade para o plano Dev: ${(0, config_1.getDevPlanUrl)()}`
+    };
+}
 function cacheIsValid(cache) {
     const expiresAt = new Date(cache.expiresAt).getTime();
     if (Number.isNaN(expiresAt))
@@ -81,9 +120,24 @@ async function getPermissions() {
     }
     catch {
         const tokenPresent = (0, token_1.tokenFileExists)();
+        const tokenState = (0, token_1.getTokenState)();
         const cache = readCache();
         if (cache && cacheIsValid(cache)) {
-            return { plan: cache.plan, features: cache.features };
+            return {
+                features: cache.features,
+                subscription: cache.subscription
+            };
+        }
+        // If the user is logged in but the API is temporarily unavailable,
+        // fallback to the last known permissions to avoid blocking generation.
+        if (tokenPresent && cache) {
+            return {
+                features: cache.features,
+                subscription: cache.subscription
+            };
+        }
+        if (tokenState === 'expired') {
+            throw new Error(`Sua sessão expirou. Faça login novamente: ${(0, config_1.getWebAuthUrl)()}`);
         }
         if (tokenPresent) {
             throw new Error('Login concluído, mas não foi possível validar sua licença agora. Verifique sua conexão com a API e tente novamente.');

package/dist/license/token.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tokenFileExists = tokenFileExists;
 exports.loadToken = loadToken;
+exports.getTokenState = getTokenState;
 exports.saveToken = saveToken;
 exports.clearToken = clearToken;
 const fs_1 = __importDefault(require("fs"));
@@ -38,6 +39,24 @@ function loadToken() {
         return null;
     }
 }
+function getTokenState() {
+    if (!tokenFileExists())
+        return 'missing';
+    try {
+        const parsed = JSON.parse(fs_1.default.readFileSync(TOKEN_PATH, 'utf-8'));
+        if (!parsed?.accessToken || !parsed?.expiresAt)
+            return 'invalid';
+        const expiresAt = normalizeExpiresAt(parsed.expiresAt);
+        if (!expiresAt)
+            return 'invalid';
+        if (expiresAt <= Date.now())
+            return 'expired';
+        return 'valid';
+    }
+    catch {
+        return 'invalid';
+    }
+}
 function normalizeExpiresAt(value) {
     const trimmed = String(value).trim();
     if (!trimmed.length)

package/dist/postinstall.js

@@ -3,6 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 const package_json_1 = __importDefault(require("../package.json"));
 const TELEMETRY_URL = process.env.GENERATEUI_TELEMETRY_URL?.trim() ||
     'https://generateuibackend-production.up.railway.app/events';
@@ -25,11 +27,49 @@ async function sendInstallEvent() {
         // Postinstall must never block installation.
     }
 }
+function seedProjectConfig() {
+    const isGlobalInstall = String(process.env.npm_config_global || '') === 'true';
+    if (isGlobalInstall)
+        return;
+    const initCwd = process.env.INIT_CWD;
+    if (!initCwd)
+        return;
+    const projectRoot = path_1.default.resolve(initCwd);
+    const packageJsonPath = path_1.default.join(projectRoot, 'package.json');
+    const srcAppPath = path_1.default.join(projectRoot, 'src', 'app');
+    if (!fs_1.default.existsSync(packageJsonPath) || !fs_1.default.existsSync(srcAppPath))
+        return;
+    const configPath = path_1.default.join(projectRoot, 'generateui-config.json');
+    if (fs_1.default.existsSync(configPath))
+        return;
+    const openApiCandidates = ['openapi.yaml', 'openapi.yml', 'openapi.json'];
+    const openapi = openApiCandidates.find(file => fs_1.default.existsSync(path_1.default.join(projectRoot, file))) || 'openapi.yaml';
+    const config = {
+        openapi,
+        schemas: 'src/generate-ui',
+        features: 'src/app/features',
+        appTitle: 'Store',
+        defaultRoute: '',
+        menu: {
+            autoInject: true
+        },
+        views: {
+            ProductsAdmin: 'cards'
+        }
+    };
+    try {
+        fs_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        console.log(`  Created ${path_1.default.basename(configPath)} in project root`);
+    }
+    catch {
+        // Postinstall must never block installation.
+    }
+}
 void sendInstallEvent();
+seedProjectConfig();
 console.log('');
 console.log('👋 GenerateUI CLI installed');
 console.log('  Quick start:');
-console.log('  1) generate-ui generate --openapi /path/to/openapi.yaml');
-console.log('  2) generate-ui angular --schemas /path/to/generate-ui --features /path/to/app/src/app/features');
+console.log('  1) generate-ui generate');
 console.log('  Tip: customize screens in generate-ui/overlays and menu in generate-ui/menu.overrides.json');
 console.log('');

package/dist/runtime/config.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCliVersion = getCliVersion;
 exports.getApiBaseUrl = getApiBaseUrl;
 exports.getWebAuthUrl = getWebAuthUrl;
+exports.getDevPlanUrl = getDevPlanUrl;
 const package_json_1 = __importDefault(require("../../package.json"));
 function getCliVersion() {
     return package_json_1.default.version || '0.0.0';
@@ -16,3 +17,6 @@ function getApiBaseUrl() {
 function getWebAuthUrl() {
     return ('https://generateuibackend-production.up.railway.app');
 }
+function getDevPlanUrl() {
+    return 'https://generate-ui.com/plan/dev';
+}