generate-ui-cli 1.0.0

package/README.md

@@ -0,0 +1,32 @@
+# GenerateUI CLI
+
+Generate UI from OpenAPI locally. Free works offline with 1 generation per device; Dev unlocks unlimited generation, safe regeneration, and UI overrides.
+
+## Install
+```bash
+npm install -g generate-ui-cli
+```
+
+## Usage
+```bash
+generate-ui generate --openapi /path/to/openapi.yaml
+```
+
+Safe regeneration (Dev):
+```bash
+generate-ui regenerate --openapi /path/to/openapi.yaml
+```
+
+Login (Dev):
+```bash
+generate-ui login
+```
+
+Telemetry can be disabled with:
+```bash
+generate-ui --no-telemetry generate --openapi /path/to/openapi.yaml
+```
+
+## Local files
+- `~/.generateui/device.json`
+- `~/.generateui/token.json`

package/dist/commands/angular.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 routes_generator_1 = require("../generators/angular/routes.generator");
+const telemetry_1 = require("../telemetry");
+async function angular(options) {
+    /**
+     * Onde estão os schemas
+     * Ex: frontend/src/app/assets/generate-ui
+     */
+    const schemasRoot = path_1.default.resolve(process.cwd(), options.schemasPath);
+    const overlaysDir = path_1.default.join(schemasRoot, 'overlays');
+    if (!fs_1.default.existsSync(overlaysDir)) {
+        throw new Error(`Overlays directory not found: ${overlaysDir}`);
+    }
+    const screens = fs_1.default
+        .readdirSync(overlaysDir)
+        .filter(f => f.endsWith('.screen.json'));
+    /**
+     * Onde gerar as features Angular
+     */
+    const featuresRoot = path_1.default.resolve(process.cwd(), options.featuresPath);
+    fs_1.default.mkdirSync(featuresRoot, { recursive: true });
+    const routes = [];
+    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);
+        routes.push(route);
+    }
+    (0, routes_generator_1.generateRoutes)(routes, featuresRoot);
+    await (0, telemetry_1.sendTelemetry)('generate', options.telemetryEnabled);
+    console.log(`✔ Angular features generated at ${featuresRoot}`);
+}

package/dist/commands/generate.js

@@ -0,0 +1,207 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generate = generate;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const load_openapi_1 = require("../openapi/load-openapi");
+const screen_generator_1 = require("../generators/screen.generator");
+const screen_merge_1 = require("../generators/screen.merge");
+const permissions_1 = require("../license/permissions");
+const device_1 = require("../license/device");
+const guard_1 = require("../license/guard");
+const telemetry_1 = require("../telemetry");
+async function generate(options) {
+    /**
+     * Caminho absoluto do OpenAPI (YAML)
+     * Ex: /Users/.../generateui-playground/realWorldOpenApi.yaml
+     */
+    const openApiPath = path_1.default.resolve(process.cwd(), options.openapi);
+    /**
+     * Raiz do playground (onde está o YAML)
+     */
+    const projectRoot = path_1.default.dirname(openApiPath);
+    /**
+     * Onde o Angular consome os arquivos
+     */
+    const generateUiRoot = path_1.default.join(projectRoot, 'frontend', 'src', 'app', 'assets', 'generate-ui');
+    const generatedDir = path_1.default.join(generateUiRoot, 'generated');
+    const overlaysDir = path_1.default.join(generateUiRoot, 'overlays');
+    fs_1.default.mkdirSync(generatedDir, { recursive: true });
+    fs_1.default.mkdirSync(overlaysDir, { recursive: true });
+    /**
+     * Lista de rotas geradas automaticamente
+     */
+    const routes = [];
+    const usedOperationIds = new Set();
+    const permissions = await (0, permissions_1.getPermissions)();
+    const device = (0, device_1.loadDeviceIdentity)();
+    await (0, telemetry_1.sendTelemetry)(options.telemetryCommand, options.telemetryEnabled);
+    if (options.requireSafeRegeneration) {
+        (0, guard_1.requireFeature)(permissions.features, 'safeRegeneration', 'Regeneration requires safe regeneration.');
+    }
+    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.');
+    }
+    /**
+     * Parse do OpenAPI (já com $refs resolvidos)
+     */
+    const api = await (0, load_openapi_1.loadOpenApi)(openApiPath);
+    const paths = api.paths ?? {};
+    /**
+     * Itera por todos os endpoints
+     */
+    const operationIds = new Set();
+    for (const [pathKey, pathItem] of Object.entries(paths)) {
+        for (const [method, rawOp] of Object.entries(pathItem)) {
+            const op = rawOp;
+            if (!op)
+                continue;
+            const operationId = op.operationId ||
+                buildOperationId(method.toLowerCase(), pathKey, usedOperationIds);
+            operationIds.add(operationId);
+            const endpoint = {
+                operationId,
+                path: pathKey,
+                method: method.toLowerCase(),
+                parameters: mergeParameters(pathItem?.parameters, op?.parameters),
+                ...op
+            };
+            /**
+             * Gera o ScreenSchema completo
+             */
+            const screenSchema = (0, screen_generator_1.generateScreen)(endpoint, api);
+            const fileName = `${operationId}.screen.json`;
+            /**
+             * 1️⃣ generated → SEMPRE sobrescrito (base técnica)
+             */
+            const generatedPath = path_1.default.join(generatedDir, fileName);
+            const previousGenerated = fs_1.default.existsSync(generatedPath)
+                ? JSON.parse(fs_1.default.readFileSync(generatedPath, 'utf-8'))
+                : null;
+            fs_1.default.writeFileSync(generatedPath, JSON.stringify(screenSchema, null, 2));
+            /**
+             * 2️⃣ overlays → merge semântico (preserva decisões do usuário)
+             */
+            const overlayPath = path_1.default.join(overlaysDir, fileName);
+            const canOverride = permissions.features.uiOverrides;
+            const canRegenerateSafely = permissions.features.safeRegeneration;
+            if (canOverride && canRegenerateSafely) {
+                const overlay = fs_1.default.existsSync(overlayPath)
+                    ? JSON.parse(fs_1.default.readFileSync(overlayPath, 'utf-8'))
+                    : null;
+                const merged = (0, screen_merge_1.mergeScreen)(screenSchema, overlay, previousGenerated, {
+                    openapiVersion: api?.info?.version || 'unknown',
+                    debug: options.debug
+                });
+                fs_1.default.writeFileSync(overlayPath, JSON.stringify(merged.screen, null, 2));
+                if (options.debug && merged.debug.length) {
+                    console.log(`ℹ Merge ${operationId}`);
+                    for (const line of merged.debug) {
+                        console.log(`  - ${line}`);
+                    }
+                }
+            }
+            else {
+                fs_1.default.writeFileSync(overlayPath, JSON.stringify(screenSchema, null, 2));
+            }
+            /**
+             * 3️⃣ rota automática
+             * URL = operationId (MVP)
+             */
+            routes.push({
+                path: operationId,
+                operationId
+            });
+            console.log(`✔ Generated ${operationId}`);
+        }
+    }
+    /**
+     * 4️⃣ Gera arquivo de rotas
+     */
+    const routesPath = path_1.default.join(generateUiRoot, 'routes.json');
+    fs_1.default.writeFileSync(routesPath, JSON.stringify(routes, null, 2));
+    /**
+     * 5️⃣ Remove overlays órfãos (endpoint removido)
+     */
+    const overlayFiles = fs_1.default
+        .readdirSync(overlaysDir)
+        .filter(file => file.endsWith('.screen.json'));
+    for (const file of overlayFiles) {
+        const opId = file.replace(/\.screen\.json$/, '');
+        if (!operationIds.has(opId)) {
+            fs_1.default.rmSync(path_1.default.join(overlaysDir, file));
+            if (options.debug) {
+                console.log(`✖ Removed overlay ${opId}`);
+            }
+        }
+    }
+    if (permissions.features.maxGenerations > -1) {
+        (0, device_1.incrementFreeGeneration)();
+    }
+    console.log('✔ Routes generated');
+}
+function mergeParameters(pathParams, opParams) {
+    const all = [...(pathParams ?? []), ...(opParams ?? [])];
+    const seen = new Set();
+    const merged = [];
+    for (const param of all) {
+        const key = `${param?.in ?? ''}:${param?.name ?? ''}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        merged.push(param);
+    }
+    return merged;
+}
+function buildOperationId(method, pathKey, usedOperationIds) {
+    const verb = method.toLowerCase();
+    const prefix = httpVerbToPrefix(verb);
+    const parts = pathKey
+        .split('/')
+        .filter(Boolean)
+        .map(segment => {
+        if (segment.startsWith('{') && segment.endsWith('}')) {
+            const name = segment.slice(1, -1);
+            return `By${capitalize(name)}`;
+        }
+        return capitalize(segment);
+    });
+    let base = `${prefix}${parts.join('')}`;
+    if (!base)
+        base = `${prefix}Endpoint`;
+    let candidate = base;
+    let index = 2;
+    while (usedOperationIds.has(candidate)) {
+        candidate = `${base}${index}`;
+        index += 1;
+    }
+    usedOperationIds.add(candidate);
+    return candidate;
+}
+function httpVerbToPrefix(verb) {
+    switch (verb) {
+        case 'get':
+            return 'Get';
+        case 'post':
+            return 'Create';
+        case 'put':
+            return 'Update';
+        case 'patch':
+            return 'Patch';
+        case 'delete':
+            return 'Delete';
+        default:
+            return 'Call';
+    }
+}
+function capitalize(value) {
+    if (!value)
+        return value;
+    return value[0].toUpperCase() + value.slice(1);
+}

package/dist/commands/login.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.login = login;
+const http_1 = __importDefault(require("http"));
+const url_1 = require("url");
+const config_1 = require("../runtime/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 LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
+async function login(options) {
+    const token = await waitForLogin();
+    (0, token_1.saveToken)(token);
+    try {
+        await (0, permissions_1.fetchPermissions)();
+    }
+    catch {
+        // Cached permissions will be refreshed on next online command.
+    }
+    await (0, telemetry_1.sendTelemetry)('login', options.telemetryEnabled);
+    console.log('✔ Login completo');
+}
+async function waitForLogin() {
+    return new Promise((resolve, reject) => {
+        const server = http_1.default.createServer((req, res) => {
+            const requestUrl = req.url || '/';
+            if (!requestUrl.startsWith('/callback')) {
+                res.writeHead(404);
+                res.end('Not Found');
+                return;
+            }
+            const url = new url_1.URL(requestUrl, 'http://localhost');
+            const accessToken = url.searchParams.get('access_token');
+            const expiresAtParam = url.searchParams.get('expires_at');
+            if (!accessToken) {
+                res.writeHead(400);
+                res.end('Missing access token');
+                return;
+            }
+            const expiresAt = expiresAtParam ||
+                new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString();
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end(`<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>GenerateUI</title>
+    <style>
+      :root {
+        --bg: #f3e8ff;
+        --card: #ffffff;
+        --text: #2a1b3d;
+        --muted: #6b5b7a;
+        --primary: #7c3aed;
+        --glow: rgba(124, 58, 237, 0.22);
+      }
+      * {
+        box-sizing: border-box;
+        font-family: "IBM Plex Serif", "Georgia", serif;
+      }
+      body {
+        margin: 0;
+        min-height: 100vh;
+        display: grid;
+        place-items: center;
+        background: radial-gradient(circle at top, #f5ebff, #e9d5ff);
+        color: var(--text);
+      }
+      main {
+        background: var(--card);
+        padding: 52px 48px;
+        border-radius: 24px;
+        box-shadow: 0 24px 70px var(--glow);
+        width: min(460px, 92vw);
+        text-align: center;
+      }
+      h1 {
+        margin: 0 0 12px;
+        font-size: 30px;
+      }
+      p {
+        margin: 0 0 24px;
+        color: var(--muted);
+        font-size: 16px;
+      }
+      .pill {
+        display: inline-block;
+        background: #f5e9ff;
+        color: var(--primary);
+        padding: 8px 14px;
+        border-radius: 999px;
+        font-weight: 600;
+        letter-spacing: 0.2px;
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>Let's Generate UI</h1>
+      <p>Login completed successfully.</p>
+      <span class="pill">You can close this window</span>
+    </main>
+  </body>
+</html>`);
+            clearTimeout(timeout);
+            server.close();
+            resolve({ accessToken, expiresAt });
+        });
+        const timeout = setTimeout(() => {
+            server.close();
+            reject(new Error('Login timed out'));
+        }, LOGIN_TIMEOUT_MS);
+        server.listen(0, () => {
+            const address = server.address();
+            if (!address || typeof address === 'string') {
+                clearTimeout(timeout);
+                reject(new Error('Failed to start login server'));
+                return;
+            }
+            const redirectUri = `http://localhost:${address.port}/callback`;
+            const url = new url_1.URL((0, config_1.getWebAuthUrl)());
+            url.searchParams.set('redirect_uri', redirectUri);
+            url.searchParams.set('api_base', (0, config_1.getApiBaseUrl)());
+            (0, open_browser_1.openBrowser)(url.toString());
+        });
+    });
+}