@pie-element/cli 0.1.1 → 0.1.2-next.0

package/dist/commands/upstream/sync.js

@@ -1,11 +1,12 @@
 import { Command, Flags } from '@oclif/core';
 import { Logger } from '../../utils/logger.js';
-import { loadCompatibilityReport } from '../../utils/compatibility.js';
+import { formatCompatibilityReportLastAnalyzed, loadCompatibilityReport, } from '../../utils/compatibility.js';
 import { getCurrentCommit } from '../../utils/git.js';
 import { printSyncSummary, createEmptySummary } from '../../lib/upstream/sync-summary.js';
-import { loadPackageJson } from '../../utils/package-json.js';
+import { loadPackageJson, writePackageJson } from '../../utils/package-json.js';
 import { spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
+import { readFile, stat as fsStat, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { readdir } from '../../lib/upstream/sync-filesystem.js';
 import { getAllDeps } from '../../lib/upstream/sync-package-json.js';
@@ -14,7 +15,9 @@ import { ReactComponentsStrategy } from '../../lib/upstream/sync-react-strategy.
 import { PieLibStrategy } from '../../lib/upstream/sync-pielib-strategy.js';
 import { DEFAULT_PATHS, COMPATIBILITY_FILE, WORKSPACE } from '../../lib/upstream/sync-constants.js';
 import { assertReposExist } from '../../lib/upstream/repo-utils.js';
-import { addDevelopmentExports } from '../../lib/upstream/sync-dev-exports.js';
+import { rewriteRelativeSpecifiersForNodeEsm } from '../../lib/upstream/sync-imports.js';
+import { analyzePackageDependencyIntegrity, collectWorkspacePackageDirs, } from '../../utils/dependency-integrity.js';
+import { getPostSyncTextPatches } from '../../lib/upstream/sync-presets.js';
 export default class Sync extends Command {
     static description = 'Synchronize code from upstream pie-elements repository';
     static examples = [
@@ -39,6 +42,7 @@ export default class Sync extends Command {
     logger = new Logger();
     touchedElementPackages = new Set();
     touchedPieLibPackages = new Set();
+    preSyncProblemIntegrityByImport = new Map();
     async run() {
         const { flags } = await this.parse(Sync);
         this.logger = new Logger(flags.verbose);
@@ -78,6 +82,7 @@ export default class Sync extends Command {
         // Reset touched packages for this run
         this.touchedElementPackages = new Set();
         this.touchedPieLibPackages = new Set();
+        this.preSyncProblemIntegrityByImport = new Map();
         this.logger.section('🔄 Syncing from upstream');
         this.logger.info(`   Source:      ${config.pieElements}`);
         this.logger.info(`   Destination: ${config.pieElementsNg}/packages/`);
@@ -128,6 +133,31 @@ export default class Sync extends Command {
             this.logger.error(error instanceof Error ? error.message : String(error));
             this.error('Sync failed', { exit: 1 });
         }
+        if (config.dryRun) {
+            this.logger.section('🧪 Dry run');
+            this.logger.info('   No files will be modified.');
+            const elementsPlanned = config.syncReactComponents
+                ? await this.listElementPackages(config)
+                : [];
+            const pieLibPlanned = config.syncPieLibPackages && config.pieLibPackages ? [...config.pieLibPackages] : [];
+            syncSummary.controllersSync = config.syncControllers ? elementsPlanned.length : 0;
+            syncSummary.reactComponentsSynced = elementsPlanned.length;
+            syncSummary.pieLibPackagesSynced = pieLibPlanned.length;
+            syncSummary.totalPackagesSynced = elementsPlanned.length + pieLibPlanned.length;
+            syncSummary.syncedPackageNames = [
+                ...elementsPlanned,
+                ...pieLibPlanned.map((pkg) => `@pie-lib/${pkg}`),
+            ];
+            if (compatibilityReport) {
+                syncSummary.blockedElements = Object.keys(compatibilityReport.blockedElements).length;
+                syncSummary.blockedPieLib = Object.values(compatibilityReport.pieLibDetails).filter((d) => !d.compatible).length;
+            }
+            printSyncSummary(syncSummary, compatibilityReport, config.pieElementsNg, this.logger);
+            return;
+        }
+        // Capture current dependency integrity gaps before sync so we only fail on new regressions.
+        this.preSyncProblemIntegrityByImport =
+            await this.captureCurrentProblemIntegrityBaseline(config);
         // Clean target directories first (ensures a clean slate for full syncs)
         await this.cleanTargetDirectories(config);
         // Execute sync strategies
@@ -146,6 +176,7 @@ export default class Sync extends Command {
                 syncPieLib: config.syncPieLibPackages,
                 pieLibPackages: config.pieLibPackages,
                 skipDemos: true,
+                dryRun: config.dryRun,
                 upstreamCommit: getCurrentCommit(config.pieElements),
             },
             logger: this.logger,
@@ -194,12 +225,36 @@ export default class Sync extends Command {
         if (!config.dryRun) {
             await this.rewriteWorkspaceDependencies(config);
         }
-        // Add development export conditions for HMR support
-        if (!config.dryRun && this.touchedElementPackages.size > 0) {
-            await this.addDevelopmentExportsToPackages(config);
+        // Auto-fix missing direct dependency declarations in touched package manifests.
+        // This makes sync resilient to upstream package.json drift.
+        {
+            const autoFix = await this.autoFixTouchedPackageDependencyDeclarations(config);
+            if (autoFix.unresolved.length > 0) {
+                for (const unresolved of autoFix.unresolved) {
+                    result.warnings.push(`Could not infer version for ${unresolved.dependency} in ${unresolved.packageName}`);
+                }
+            }
+        }
+        // Apply targeted post-sync source patches for known declaration-emit issues.
+        if (!config.dryRun) {
+            await this.applyPostSyncBuildStabilizers(config);
+        }
+        // Normalize relative ESM specifiers to explicit .js paths for NodeNext.
+        if (!config.dryRun) {
+            await this.applyNodeEsmSpecifierRewrites(config);
+        }
+        // Verify synced packages for dependency integrity regressions (broken/hoist-reliant imports).
+        // This catches runtime failures like unresolved "prop-types" and newly introduced hoist reliance.
+        {
+            const integrityRegressions = await this.verifyTouchedPackageDependencyIntegrity(config);
+            if (integrityRegressions.length > 0) {
+                for (const issue of integrityRegressions) {
+                    result.errors.push(`${issue.packageName} (${issue.packagePath}) has new ${issue.status} dependency: ${issue.dependency}`);
+                }
+            }
         }
         // Build by default (unless dry-run or explicitly skipped)
-        if (!config.dryRun && !config.skipBuild) {
+        if (!config.dryRun && !config.skipBuild && result.errors.length === 0) {
             await this.buildTouchedPackages(config, result);
         }
         // Add blocked package counts from compatibility report
@@ -211,6 +266,13 @@ export default class Sync extends Command {
         // and managed directly in this repository (not synced from upstream)
         // Print summary and handle errors
         printSyncSummary(syncSummary, compatibilityReport, config.pieElementsNg, this.logger);
+        if (result.warnings.length > 0) {
+            this.logger.warn('Sync completed with warnings:');
+            for (const warning of result.warnings) {
+                this.logger.warn(`  - ${warning}`);
+            }
+            this.log('');
+        }
         if (result.errors.length > 0) {
             this.error('Sync completed with errors', { exit: 1 });
         }
@@ -233,7 +295,7 @@ export default class Sync extends Command {
             return null;
         }
         this.logger.info(`📋 Using ESM compatibility filter from ${config.compatibilityFile}`);
-        this.logger.info(`   Last analyzed: ${new Date(report.lastAnalyzed).toLocaleString()}`);
+        this.logger.info(`   Last analyzed: ${formatCompatibilityReportLastAnalyzed(report)}`);
         this.logger.info(`   Compatible elements: ${report.elements.length}`);
         this.logger.info(`   Compatible pie-lib packages: ${report.pieLibPackages.length}`);
         if (Object.keys(report.blockedElements).length > 0) {
@@ -346,6 +408,299 @@ export default class Sync extends Command {
             });
         });
     }
+    async verifyTouchedPackageDependencyIntegrity(config) {
+        this.logger.section('🔎 Verifying dependency integrity regressions');
+        const packageDirs = [];
+        for (const element of this.touchedElementPackages) {
+            packageDirs.push(join(config.pieElementsNg, 'packages/elements-react', element));
+        }
+        for (const pieLib of this.touchedPieLibPackages) {
+            packageDirs.push(join(config.pieElementsNg, 'packages/lib-react', pieLib));
+        }
+        if (packageDirs.length === 0) {
+            this.logger.info('   No touched packages to verify\n');
+            return [];
+        }
+        const regressions = [];
+        let existingIssuesIgnored = 0;
+        for (const packageDir of packageDirs) {
+            const analysis = await analyzePackageDependencyIntegrity(packageDir);
+            if (!analysis) {
+                continue;
+            }
+            for (const issue of analysis.issues) {
+                if (issue.status !== 'broken' && issue.status !== 'hoist') {
+                    continue;
+                }
+                const key = this.integrityIssueKey(analysis.packageName, issue.dependency);
+                const previous = this.preSyncProblemIntegrityByImport.get(key);
+                if (previous === issue.status) {
+                    existingIssuesIgnored++;
+                    continue;
+                }
+                regressions.push({
+                    packageName: analysis.packageName,
+                    packagePath: analysis.packagePath,
+                    dependency: issue.dependency,
+                    status: issue.status,
+                });
+            }
+        }
+        if (regressions.length === 0) {
+            if (existingIssuesIgnored > 0) {
+                this.logger.info(`   ✓ No new broken/hoist regressions (ignored ${existingIssuesIgnored} pre-existing issue(s))\n`);
+            }
+            else {
+                this.logger.info(`   ✓ No broken/hoist dependency integrity regressions\n`);
+            }
+            return [];
+        }
+        this.logger.error(`   Found ${regressions.length} new dependency integrity regression(s):\n`);
+        for (const regression of regressions) {
+            this.logger.error(`   - ${regression.packageName}: ${regression.status} -> ${regression.dependency}`);
+        }
+        this.log('');
+        return regressions;
+    }
+    async captureCurrentProblemIntegrityBaseline(config) {
+        const baseline = new Map();
+        const packageDirs = await collectWorkspacePackageDirs(config.pieElementsNg);
+        for (const packageDir of packageDirs) {
+            const analysis = await analyzePackageDependencyIntegrity(packageDir);
+            if (!analysis) {
+                continue;
+            }
+            for (const issue of analysis.issues) {
+                if (issue.status === 'broken' || issue.status === 'hoist') {
+                    baseline.set(this.integrityIssueKey(analysis.packageName, issue.dependency), issue.status);
+                }
+            }
+        }
+        return baseline;
+    }
+    integrityIssueKey(packageName, dependency) {
+        return `${packageName}::${dependency}`;
+    }
+    async autoFixTouchedPackageDependencyDeclarations(config) {
+        this.logger.section('🛠️  Auto-fixing dependency declarations');
+        const packageDirs = this.getTouchedPackageDirs(config);
+        if (packageDirs.length === 0) {
+            this.logger.info('   No touched packages to auto-fix\n');
+            return { packagesUpdated: 0, dependenciesAdded: 0, unresolved: [] };
+        }
+        const catalog = await this.buildDependencyVersionCatalog(config.pieElementsNg);
+        let packagesUpdated = 0;
+        let dependenciesAdded = 0;
+        const unresolved = [];
+        for (const packageDir of packageDirs) {
+            const analysis = await analyzePackageDependencyIntegrity(packageDir);
+            if (!analysis)
+                continue;
+            const pkgJsonPath = join(packageDir, 'package.json');
+            const pkgJson = (await loadPackageJson(pkgJsonPath));
+            if (!pkgJson)
+                continue;
+            const declared = new Set([
+                ...Object.keys(pkgJson.dependencies || {}),
+                ...Object.keys(pkgJson.devDependencies || {}),
+                ...Object.keys(pkgJson.peerDependencies || {}),
+                ...Object.keys(pkgJson.optionalDependencies || {}),
+            ]);
+            let modified = false;
+            if (!pkgJson.dependencies) {
+                pkgJson.dependencies = {};
+            }
+            for (const issue of analysis.issues) {
+                const dep = issue.dependency;
+                if (declared.has(dep)) {
+                    continue;
+                }
+                const version = this.resolveDependencyVersion(config, dep, catalog);
+                if (!version) {
+                    unresolved.push({ packageName: analysis.packageName, dependency: dep });
+                    continue;
+                }
+                pkgJson.dependencies[dep] = version;
+                declared.add(dep);
+                modified = true;
+                dependenciesAdded++;
+            }
+            if (modified) {
+                await writePackageJson(pkgJsonPath, pkgJson);
+                packagesUpdated++;
+            }
+        }
+        if (dependenciesAdded === 0 && unresolved.length === 0) {
+            this.logger.info('   ✓ No missing declarations detected in touched packages\n');
+            return { packagesUpdated, dependenciesAdded, unresolved };
+        }
+        if (dependenciesAdded > 0) {
+            this.logger.info(`   ✓ Added ${dependenciesAdded} dependency declaration(s) in ${packagesUpdated} package(s)`);
+        }
+        if (unresolved.length > 0) {
+            this.logger.warn(`   Could not infer ${unresolved.length} dependency version(s)`);
+        }
+        this.log('');
+        return { packagesUpdated, dependenciesAdded, unresolved };
+    }
+    getTouchedPackageDirs(config) {
+        const dirs = [];
+        for (const element of this.touchedElementPackages) {
+            dirs.push(join(config.pieElementsNg, 'packages/elements-react', element));
+        }
+        for (const pieLib of this.touchedPieLibPackages) {
+            dirs.push(join(config.pieElementsNg, 'packages/lib-react', pieLib));
+        }
+        return dirs.sort();
+    }
+    async buildDependencyVersionCatalog(rootDir) {
+        const catalog = new Map();
+        const addVersions = (record) => {
+            if (!record)
+                return;
+            for (const [name, version] of Object.entries(record)) {
+                if (!catalog.has(name)) {
+                    catalog.set(name, version);
+                }
+            }
+        };
+        // Root package.json has the canonical versions we prefer.
+        const rootPkgPath = join(rootDir, 'package.json');
+        if (existsSync(rootPkgPath)) {
+            const rootPkg = (await loadPackageJson(rootPkgPath));
+            if (rootPkg) {
+                addVersions(rootPkg.dependencies);
+                addVersions(rootPkg.devDependencies);
+            }
+        }
+        // Add versions seen across workspace package manifests as fallback.
+        const workspacePackageDirs = await collectWorkspacePackageDirs(rootDir);
+        for (const packageDir of workspacePackageDirs) {
+            const pkgPath = join(packageDir, 'package.json');
+            if (!existsSync(pkgPath))
+                continue;
+            const pkg = (await loadPackageJson(pkgPath));
+            if (!pkg)
+                continue;
+            addVersions(pkg.dependencies);
+            addVersions(pkg.devDependencies);
+            addVersions(pkg.peerDependencies);
+            addVersions(pkg.optionalDependencies);
+        }
+        return catalog;
+    }
+    resolveDependencyVersion(config, dep, catalog) {
+        const fallbackVersions = {
+            'js-combinatorics': '^2.1.2',
+            '@testing-library/react': '^16.3.0',
+            '@testing-library/dom': '^10.4.1',
+            '@tiptap/extensions': '^3.20.0',
+            '@tiptap/extension-list': '^3.20.0',
+            '@tiptap/extension-code-block': '^3.20.0',
+            'nested-property': '^4.0.0',
+            'prosemirror-state': '^1.4.4',
+            'react-is': '^19.2.0',
+            pluralize: '^8.0.0',
+        };
+        // Internal workspace packages should stay workspace-linked.
+        if (dep.startsWith('@pie-lib/')) {
+            const libName = dep.replace('@pie-lib/', '');
+            const localPath = join(config.pieElementsNg, 'packages/lib-react', libName, 'package.json');
+            if (existsSync(localPath)) {
+                return 'workspace:*';
+            }
+        }
+        if (dep.startsWith('@pie-element/')) {
+            const elementName = dep.replace('@pie-element/', '');
+            const elementPath = join(config.pieElementsNg, 'packages/elements-react', elementName, 'package.json');
+            if (existsSync(elementPath)) {
+                return 'workspace:*';
+            }
+            // Shared packages map @pie-element/shared-foo -> packages/shared/foo.
+            if (elementName.startsWith('shared-')) {
+                const sharedName = elementName.replace('shared-', '');
+                const sharedPath = join(config.pieElementsNg, 'packages/shared', sharedName, 'package.json');
+                if (existsSync(sharedPath)) {
+                    return 'workspace:*';
+                }
+            }
+        }
+        return catalog.get(dep) || fallbackVersions[dep] || null;
+    }
+    async applyPostSyncBuildStabilizers(config) {
+        let appliedPatches = 0;
+        const patchFile = async (filePath, replacements, label) => {
+            if (!existsSync(filePath)) {
+                return false;
+            }
+            let content = await readFile(filePath, 'utf-8');
+            let changed = false;
+            for (const replacement of replacements) {
+                if (content.includes(replacement.from)) {
+                    content = content.replace(replacement.from, replacement.to);
+                    changed = true;
+                }
+            }
+            if (changed) {
+                await writeFile(filePath, content, 'utf-8');
+                this.logger.info(`   ✓ Applied post-sync patch: ${label}`);
+            }
+            return changed;
+        };
+        const patches = getPostSyncTextPatches(config.pieElementsNg);
+        for (const patch of patches) {
+            if (await patchFile(patch.file, patch.replacements, patch.label)) {
+                appliedPatches++;
+            }
+        }
+        if (appliedPatches === 0) {
+            this.logger.info('   ✓ No post-sync stabilizer patches needed');
+        }
+    }
+    async applyNodeEsmSpecifierRewrites(config) {
+        this.logger.section('🔧 Rewriting relative ESM specifiers');
+        const packageDirs = this.getTouchedPackageDirs(config);
+        if (packageDirs.length === 0) {
+            this.logger.info('   No touched packages to rewrite\n');
+            return;
+        }
+        let checkedFiles = 0;
+        let rewrittenFiles = 0;
+        for (const packageDir of packageDirs) {
+            const sourceDir = join(packageDir, 'src');
+            const sourceFiles = await this.collectTypeScriptSourceFiles(sourceDir);
+            for (const filePath of sourceFiles) {
+                checkedFiles++;
+                if (await rewriteRelativeSpecifiersForNodeEsm(filePath)) {
+                    rewrittenFiles++;
+                }
+            }
+        }
+        if (rewrittenFiles === 0) {
+            this.logger.info(`   ✓ Specifiers already normalized (${checkedFiles} file(s) checked)\n`);
+            return;
+        }
+        this.logger.info(`   ✓ Rewrote ${rewrittenFiles} file(s) out of ${checkedFiles} checked\n`);
+    }
+    async collectTypeScriptSourceFiles(dir) {
+        if (!existsSync(dir)) {
+            return [];
+        }
+        const files = [];
+        const items = await readdir(dir);
+        for (const item of items) {
+            const fullPath = join(dir, item);
+            const stats = await fsStat(fullPath);
+            if (stats.isDirectory()) {
+                files.push(...(await this.collectTypeScriptSourceFiles(fullPath)));
+                continue;
+            }
+            if (item.endsWith('.ts') || item.endsWith('.tsx')) {
+                files.push(fullPath);
+            }
+        }
+        return files;
+    }
     async rewriteWorkspaceDependencies(config) {
         this.logger.section('🔧 Rewriting workspace dependencies');
         // Discover available packages in the workspace
@@ -405,7 +760,7 @@ export default class Sync extends Command {
         for (const pkgPath of packagesToCheck) {
             const pkgJsonPath = join(pkgPath, 'package.json');
             const pkgJson = (await loadPackageJson(pkgJsonPath));
-            if (!pkgJson || !pkgJson.dependencies) {
+            if (!pkgJson?.dependencies) {
                 continue;
             }
             const pkgName = pkgJson.name || pkgPath;
@@ -474,22 +829,6 @@ export default class Sync extends Command {
             this.logger.info('   ✓ bun install completed successfully\n');
         }
     }
-    async addDevelopmentExportsToPackages(config) {
-        this.logger.section('🔧 Adding development export conditions');
-        const elementsDir = join(config.pieElementsNg, 'packages/elements-react');
-        const packageNames = Array.from(this.touchedElementPackages);
-        if (packageNames.length === 0) {
-            this.logger.debug('   No element packages to process');
-            return;
-        }
-        const updated = await addDevelopmentExports(elementsDir, packageNames, this.logger);
-        if (updated > 0) {
-            this.logger.info(`   ✓ Added development exports to ${updated} package(s)\n`);
-        }
-        else {
-            this.logger.debug('   → No changes needed\n');
-        }
-    }
     async buildTouchedPackages(config, result) {
         const rootPkgPath = join(config.pieElementsNg, 'package.json');
         const rootPkg = (await loadPackageJson(rootPkgPath));