generate-ui-cli 2.2.0 → 2.3.0

package/dist/commands/merge.js

@@ -0,0 +1,201 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.merge = merge;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const logger_1 = require("../runtime/logger");
+const project_config_1 = require("../runtime/project-config");
+async function merge(options) {
+    const projectConfig = (0, project_config_1.findProjectConfig)(process.cwd());
+    const configuredFeatures = (0, project_config_1.pickConfiguredPath)(projectConfig.config, 'features');
+    const featuresRoot = resolveFeaturesRoot(options.featuresPath, configuredFeatures, projectConfig.configPath);
+    const generatedRoot = path_1.default.join(featuresRoot, 'generated');
+    const overridesRoot = path_1.default.join(featuresRoot, 'overrides');
+    if (!options.feature) {
+        throw new Error('Missing --feature. Example: generate-ui merge --feature ProductsAdmin');
+    }
+    const folder = resolveFeatureFolder(options.feature, generatedRoot, overridesRoot);
+    const files = resolveFiles(folder, options.file);
+    if (files.length === 0) {
+        throw new Error('No files selected to compare.');
+    }
+    const selectedTool = options.tool || 'code';
+    (0, logger_1.logStep)(`Generated: ${generatedRoot}`);
+    (0, logger_1.logStep)(`Overrides: ${overridesRoot}`);
+    (0, logger_1.logStep)(`Merge tool: ${selectedTool}${selectedTool === 'code'
+        ? ' (merge editor, recommended)'
+        : selectedTool === 'code-diff'
+            ? ' (red/green diff)'
+            : ''}`);
+    let compared = 0;
+    for (const fileName of files) {
+        const generatedPath = path_1.default.join(generatedRoot, folder, fileName);
+        const overridePath = path_1.default.join(overridesRoot, folder, fileName);
+        if (!fs_1.default.existsSync(generatedPath)) {
+            console.warn(`⚠ Missing generated file: ${generatedPath}`);
+            continue;
+        }
+        if (!fs_1.default.existsSync(overridePath)) {
+            fs_1.default.mkdirSync(path_1.default.dirname(overridePath), { recursive: true });
+            fs_1.default.copyFileSync(generatedPath, overridePath);
+            console.log(`ℹ Created override file: ${overridePath}`);
+        }
+        openMergeTool(selectedTool, generatedPath, overridePath);
+        compared += 1;
+    }
+    if (compared === 0) {
+        throw new Error(`No comparable files found for feature "${folder}".`);
+    }
+    (0, logger_1.logTip)('Save changes in the overrides file (right side) to keep custom edits.');
+}
+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)) {
+        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 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 resolveFeatureFolder(value, generatedRoot, overridesRoot) {
+    const folders = listFeatureFolders(generatedRoot, overridesRoot);
+    if (folders.length === 0) {
+        throw new Error(`No feature folders found under ${generatedRoot} or ${overridesRoot}.`);
+    }
+    const direct = normalizeFeatureKey(value);
+    const matches = folders.filter(folder => normalizeFeatureKey(folder) === direct);
+    if (matches.length === 1)
+        return matches[0];
+    const contains = folders.filter(folder => normalizeFeatureKey(folder).includes(direct));
+    if (contains.length === 1)
+        return contains[0];
+    if (contains.length > 1) {
+        throw new Error(`Feature "${value}" is ambiguous. Matches: ${contains.join(', ')}`);
+    }
+    const sample = folders.slice(0, 12).join(', ');
+    throw new Error(`Feature not found: ${value}.\n` +
+        `Available features: ${sample}${folders.length > 12 ? ', ...' : ''}`);
+}
+function listFeatureFolders(generatedRoot, overridesRoot) {
+    const set = new Set();
+    for (const root of [generatedRoot, overridesRoot]) {
+        if (!fs_1.default.existsSync(root))
+            continue;
+        for (const entry of fs_1.default.readdirSync(root, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            set.add(entry.name);
+        }
+    }
+    return [...set].sort((a, b) => a.localeCompare(b));
+}
+function normalizeFeatureKey(value) {
+    return String(value)
+        .trim()
+        .replace(/Component$/i, '')
+        .replace(/[^a-zA-Z0-9]/g, '')
+        .toLowerCase();
+}
+function resolveFiles(folder, raw) {
+    const key = String(raw || 'component.ts').trim();
+    if (key === 'all') {
+        return [
+            `${folder}.component.ts`,
+            `${folder}.component.html`,
+            `${folder}.component.scss`
+        ];
+    }
+    const normalized = key.startsWith('.')
+        ? key.slice(1)
+        : key;
+    const suffix = normalized.startsWith('component')
+        ? normalized
+        : `component.${normalized}`;
+    return [`${folder}.${suffix}`];
+}
+function openMergeTool(tool, generatedPath, overridePath) {
+    const run = (cmd, args) => {
+        try {
+            (0, child_process_1.execFileSync)(cmd, args, { stdio: 'inherit' });
+        }
+        catch (error) {
+            const message = String(error?.message || '');
+            if (error?.code === 'ENOENT') {
+                throw new Error(`Merge tool "${cmd}" not found in PATH.\n` +
+                    'Recommended: install VS Code command in PATH and use --tool code.\n' +
+                    "In VS Code run: 'Shell Command: Install code command in PATH'.\n" +
+                    'Or try one of these:\n' +
+                    '  --tool code\n' +
+                    '  --tool code-diff\n' +
+                    '  --tool vimdiff\n' +
+                    '  --tool diff');
+            }
+            if (cmd === 'opendiff' &&
+                message.includes('requires Xcode')) {
+                throw new Error('Tool "opendiff" requires full Xcode.\n' +
+                    'Use --tool vimdiff or --tool diff, or install full Xcode.');
+            }
+            throw error;
+        }
+    };
+    if (tool === 'code') {
+        openCodeMerge(run, generatedPath, overridePath);
+        return;
+    }
+    if (tool === 'code-diff') {
+        // Diff view: left = incoming generated, right = current overrides.
+        run('code', ['--wait', '--diff', generatedPath, overridePath]);
+        return;
+    }
+    if (tool === 'meld' || tool === 'kdiff3' || tool === 'bc') {
+        run('git', ['difftool', '--no-index', `--tool=${tool}`, generatedPath, overridePath]);
+        return;
+    }
+    run(tool, [generatedPath, overridePath]);
+}
+function openCodeMerge(run, generatedPath, overridePath) {
+    const ext = path_1.default.extname(overridePath) || '.txt';
+    const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'generate-ui-merge-'));
+    const currentPath = path_1.default.join(tempDir, `current${ext}`);
+    const incomingPath = path_1.default.join(tempDir, `incoming${ext}`);
+    const basePath = path_1.default.join(tempDir, `base${ext}`);
+    const resultPath = path_1.default.join(tempDir, `result${ext}`);
+    try {
+        fs_1.default.copyFileSync(overridePath, currentPath);
+        fs_1.default.copyFileSync(generatedPath, incomingPath);
+        fs_1.default.copyFileSync(generatedPath, basePath);
+        fs_1.default.copyFileSync(overridePath, resultPath);
+        // VS Code merge editor:
+        // - current: user's override
+        // - incoming: regenerated output
+        // - base: fallback ancestor (best effort, regenerated)
+        // - result: file that will be saved back to overrides
+        run('code', [
+            '--wait',
+            '--merge',
+            currentPath,
+            incomingPath,
+            basePath,
+            resultPath
+        ]);
+        fs_1.default.copyFileSync(resultPath, overridePath);
+    }
+    finally {
+        fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+    }
+}