@pie-element/cli 0.1.1

package/src/commands/upstream/check.ts

@@ -0,0 +1,228 @@
+import { Command, Flags } from '@oclif/core';
+import { existsSync } from 'node:fs';
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { getCurrentCommit, getFileModifiedDate } from '../../utils/git.js';
+import { Logger } from '../../utils/logger.js';
+import { DEFAULT_PATHS } from '../../lib/upstream/sync-constants.js';
+import { formatRepoNotFound } from '../../lib/upstream/repo-utils.js';
+
+interface CheckConfig {
+  pieElements: string;
+  pieLib: string;
+  pieElementsNg: string;
+  elements?: string[];
+  verbose: boolean;
+}
+
+interface FileChange {
+  element: string;
+  file: string;
+  upstreamPath: string;
+  localPath: string;
+  upstreamModified: Date;
+  localModified: Date;
+  upstreamSize: number;
+  localSize: number;
+}
+
+interface CheckResult {
+  elementsChecked: number;
+  filesChecked: number;
+  potentialChanges: FileChange[];
+  errors: string[];
+  warnings: string[];
+}
+
+export default class Check extends Command {
+  static override description = 'Check for changes in upstream pie-elements repository';
+
+  static override examples = [
+    '<%= config.bin %> <%= command.id %>',
+    '<%= config.bin %> <%= command.id %> --verbose',
+    '<%= config.bin %> <%= command.id %> --element multiple-choice',
+  ];
+
+  static override flags = {
+    verbose: Flags.boolean({
+      char: 'v',
+      description: 'Show detailed output',
+      default: false,
+    }),
+    element: Flags.string({
+      description: 'Check only specified element',
+    }),
+  };
+
+  private logger!: Logger;
+
+  public async run(): Promise<void> {
+    const { flags } = await this.parse(Check);
+
+    this.logger = new Logger(flags.verbose);
+
+    const config: CheckConfig = {
+      pieElements: DEFAULT_PATHS.PIE_ELEMENTS,
+      pieLib: DEFAULT_PATHS.PIE_LIB,
+      pieElementsNg: DEFAULT_PATHS.PIE_ELEMENTS_NG,
+      elements: flags.element ? [flags.element] : undefined,
+      verbose: flags.verbose,
+    };
+
+    const result = await this.checkUpstream(config);
+
+    // Display results
+    this.displayResults(result);
+
+    if (result.errors.length > 0) {
+      this.error('Check completed with errors');
+    }
+  }
+
+  private async checkUpstream(config: CheckConfig): Promise<CheckResult> {
+    const result: CheckResult = {
+      elementsChecked: 0,
+      filesChecked: 0,
+      potentialChanges: [],
+      errors: [],
+      warnings: [],
+    };
+
+    this.logger.info('🔍 Checking upstream changes...');
+    this.logger.info(`   pie-elements: ${config.pieElements}`);
+    this.logger.info(`   pie-lib: ${config.pieLib}`);
+    this.logger.info(`   pie-elements-ng: ${config.pieElementsNg}\n`);
+
+    // Verify upstream repos exist
+    if (!existsSync(config.pieElements)) {
+      result.errors.push(formatRepoNotFound('pie-elements', config.pieElements));
+      return result;
+    }
+    if (!existsSync(config.pieLib)) {
+      result.errors.push(formatRepoNotFound('pie-lib', config.pieLib));
+      return result;
+    }
+
+    // Get commit info
+    const pieElementsCommit = getCurrentCommit(config.pieElements);
+    const pieLibCommit = getCurrentCommit(config.pieLib);
+    const pieElementsNgCommit = getCurrentCommit(config.pieElementsNg);
+
+    this.logger.info('📊 Repository Commits:');
+    this.logger.info(`   pie-elements: ${pieElementsCommit.substring(0, 8)}`);
+    this.logger.info(`   pie-lib: ${pieLibCommit.substring(0, 8)}`);
+    this.logger.info(`   pie-elements-ng: ${pieElementsNgCommit.substring(0, 8)}\n`);
+
+    // Check controllers
+    await this.checkControllers(config, result);
+
+    return result;
+  }
+
+  private async checkControllers(config: CheckConfig, result: CheckResult): Promise<void> {
+    this.logger.info('📦 Checking controllers...\n');
+
+    const upstreamElementsDir = join(config.pieElements, 'packages');
+    const localElementsDir = join(config.pieElementsNg, 'packages/elements-react');
+
+    // Get list of elements that exist in both repos
+    const upstreamPackages = await readdir(upstreamElementsDir);
+    const localPackages = existsSync(localElementsDir) ? await readdir(localElementsDir) : [];
+
+    for (const pkg of upstreamPackages) {
+      // Skip if filtering by element
+      if (config.elements && !config.elements.includes(pkg)) {
+        continue;
+      }
+
+      // Skip if not in local repo
+      if (!localPackages.includes(pkg)) {
+        this.logger.debug(`   Skipping ${pkg} (not in local repo)`);
+        continue;
+      }
+
+      result.elementsChecked++;
+
+      // Check controller file
+      const upstreamController = join(upstreamElementsDir, pkg, 'controller/src/index.js');
+      const localController = join(localElementsDir, pkg, 'src/controller/index.ts');
+
+      if (!existsSync(upstreamController)) {
+        this.logger.debug(`   No controller found for ${pkg}`);
+        continue;
+      }
+
+      if (!existsSync(localController)) {
+        result.warnings.push(`Local controller missing for ${pkg}`);
+        continue;
+      }
+
+      result.filesChecked++;
+
+      // Compare modification dates
+      const upstreamDate = getFileModifiedDate(upstreamController, config.pieElements);
+      const localDate = getFileModifiedDate(localController, config.pieElementsNg);
+
+      if (upstreamDate > localDate) {
+        const stat = await import('node:fs/promises').then((m) => m.stat);
+        const upstreamStat = await stat(upstreamController);
+        const localStat = await stat(localController);
+
+        result.potentialChanges.push({
+          element: pkg,
+          file: 'controller',
+          upstreamPath: upstreamController,
+          localPath: localController,
+          upstreamModified: upstreamDate,
+          localModified: localDate,
+          upstreamSize: upstreamStat.size,
+          localSize: localStat.size,
+        });
+      }
+    }
+  }
+
+  private displayResults(result: CheckResult): void {
+    this.logger.section('\n📋 Check Results');
+
+    this.logger.info(`   Elements checked: ${result.elementsChecked}`);
+    this.logger.info(`   Files checked: ${result.filesChecked}`);
+    this.logger.info(`   Potential changes: ${result.potentialChanges.length}`);
+
+    if (result.potentialChanges.length > 0) {
+      this.logger.section('\n⚠️  Potential Changes');
+      for (const change of result.potentialChanges) {
+        this.logger.info(`\n   ${change.element} - ${change.file}`);
+        this.logger.info(`      Upstream: ${change.upstreamModified.toISOString()}`);
+        this.logger.info(`      Local:    ${change.localModified.toISOString()}`);
+        this.logger.info(`      Size diff: ${change.upstreamSize - change.localSize} bytes`);
+      }
+
+      this.logger.section('\n💡 Next Steps');
+      this.logger.info('   Review the changes with:');
+      for (const change of result.potentialChanges.slice(0, 3)) {
+        this.logger.info(
+          `   git log --oneline --since="${change.localModified.toISOString()}" -- packages/${change.element}/controller/src/index.js`
+        );
+      }
+      this.logger.info('\n   Then sync with:');
+      this.logger.info(`   bun run cli upstream:sync --element <element-name>\n`);
+    } else {
+      this.logger.success('\n✅ No changes detected - all elements are up to date\n');
+    }
+
+    if (result.warnings.length > 0) {
+      this.logger.section('\n⚠️  Warnings');
+      for (const warning of result.warnings) {
+        this.logger.warn(`   ${warning}`);
+      }
+    }
+
+    if (result.errors.length > 0) {
+      this.logger.section('\n❌ Errors');
+      for (const error of result.errors) {
+        this.logger.error(`   ${error}`);
+      }
+    }
+  }
+}

package/src/commands/upstream/deps.ts

@@ -0,0 +1,222 @@
+import { Command, Flags } from '@oclif/core';
+import { Logger } from '../../utils/logger.js';
+import { loadPackageJson, type PackageJson } from '../../utils/package-json.js';
+import { existsSync } from 'node:fs';
+
+interface DependencyReport {
+  library: string;
+  pieElements?: string;
+  pieLib?: string;
+  pieElementsNg?: string;
+  status: 'ok' | 'outdated' | 'missing' | 'newer' | 'not-used-upstream';
+  recommendation?: string;
+}
+
+// Libraries we care about tracking
+const TRACKED_DEPS = [
+  // Math rendering
+  'mathjax-full',
+  'mathlive',
+
+  // Sanitization
+  'dompurify',
+
+  // Rich text
+  '@tiptap/core',
+  '@tiptap/pm',
+  '@tiptap/starter-kit',
+  '@tiptap/extension-image',
+  '@tiptap/extension-link',
+  '@tiptap/extension-table',
+  '@tiptap/extension-task-list',
+
+  // PIE framework
+  '@pie-framework/pie-player-events',
+  '@pie-framework/pie-configure-events',
+
+  // Utilities (note: lodash is replaced with lodash-es during sync)
+  'lodash-es',
+  'uuid',
+];
+
+export default class Deps extends Command {
+  static override description = 'Compare dependencies with upstream and suggest updates';
+
+  static override examples = ['<%= config.bin %> <%= command.id %>'];
+
+  static override flags = {
+    verbose: Flags.boolean({
+      char: 'v',
+      description: 'Show detailed output',
+      default: false,
+    }),
+  };
+
+  private logger = new Logger();
+
+  public async run(): Promise<void> {
+    const { flags } = await this.parse(Deps);
+
+    this.logger = new Logger(flags.verbose);
+
+    this.logger.section('📦 Dependency Check Report');
+
+    // Read all package.json files
+    const pieElementsPkg = await this.loadPackage('../pie-elements/package.json');
+    const pieLibPkg = await this.loadPackage('../pie-lib/package.json');
+    const pieElementsNgPkg = await this.loadPackage('./package.json');
+
+    if (!pieElementsPkg) {
+      this.error('Could not load pie-elements package.json');
+    }
+    if (!pieLibPkg) {
+      this.error('Could not load pie-lib package.json');
+    }
+    if (!pieElementsNgPkg) {
+      this.error('Could not load pie-elements-ng package.json');
+    }
+
+    const reports: DependencyReport[] = [];
+
+    for (const dep of TRACKED_DEPS) {
+      const report: DependencyReport = {
+        library: dep,
+        pieElements: this.getDep(pieElementsPkg, dep),
+        pieLib: this.getDep(pieLibPkg, dep),
+        pieElementsNg: this.getDep(pieElementsNgPkg, dep),
+        status: 'ok',
+      };
+
+      // Determine status
+      const upstreamVersion = report.pieElements || report.pieLib;
+      const currentVersion = report.pieElementsNg;
+
+      if (!upstreamVersion && !currentVersion) {
+        report.status = 'not-used-upstream';
+        continue; // Skip reporting
+      }
+
+      if (!currentVersion && upstreamVersion) {
+        report.status = 'missing';
+        report.recommendation = `Install ${dep}@${upstreamVersion}`;
+      } else if (currentVersion && upstreamVersion && currentVersion !== upstreamVersion) {
+        const comparison = this.compareVersions(currentVersion, upstreamVersion);
+        if (comparison < 0) {
+          report.status = 'outdated';
+          report.recommendation = `Update from ${currentVersion} to ${upstreamVersion}`;
+        } else if (comparison > 0) {
+          report.status = 'newer';
+          report.recommendation = `Already on newer version (${currentVersion} > ${upstreamVersion})`;
+        } else {
+          report.status = 'ok';
+        }
+      }
+
+      reports.push(report);
+    }
+
+    // Print summary table
+    this.log(
+      '┌─────────────────────────────────────────┬──────────────┬──────────────┬──────────────┬──────────┐'
+    );
+    this.log(
+      '│ Library                                 │ pie-elements │ pie-lib      │ pie-elem-ng  │ Status   │'
+    );
+    this.log(
+      '├─────────────────────────────────────────┼──────────────┼──────────────┼──────────────┼──────────┤'
+    );
+
+    for (const r of reports) {
+      if (r.status === 'not-used-upstream') continue;
+
+      const lib = r.library.padEnd(39);
+      const pe = (r.pieElements || '-').padEnd(12);
+      const pl = (r.pieLib || '-').padEnd(12);
+      const peng = (r.pieElementsNg || '-').padEnd(12);
+
+      let statusIcon = '✅';
+      if (r.status === 'outdated') statusIcon = '⚠️ ';
+      else if (r.status === 'missing') statusIcon = '❌';
+      else if (r.status === 'newer') statusIcon = '🆙';
+
+      this.log(`│ ${lib} │ ${pe} │ ${pl} │ ${peng} │ ${statusIcon}      │`);
+    }
+
+    this.log(
+      '└─────────────────────────────────────────┴──────────────┴──────────────┴──────────────┴──────────┘'
+    );
+
+    // Print actionable recommendations
+    const actionable = reports.filter(
+      (r) => r.recommendation && r.status !== 'ok' && r.status !== 'newer'
+    );
+
+    if (actionable.length > 0) {
+      this.logger.section('\n🔧 Recommended Actions');
+      for (const r of actionable) {
+        this.logger.info(`  ${r.recommendation}`);
+      }
+      this.log('');
+    }
+
+    const newer = reports.filter((r) => r.status === 'newer');
+    if (newer.length > 0) {
+      this.logger.info('ℹ️  Libraries where pie-elements-ng is ahead:\n');
+      for (const r of newer) {
+        this.logger.info(
+          `  ${r.library}: ${r.pieElementsNg} (upstream: ${r.pieElements || r.pieLib || '-'})`
+        );
+      }
+      this.log('');
+    }
+
+    const allOk = reports.filter((r) => r.status === 'ok');
+    if (actionable.length === 0 && newer.length === 0) {
+      this.logger.success('\n✅ All dependencies in sync!');
+    } else {
+      this.logger.info(
+        `\n📊 Summary: ${allOk.length} in sync, ${actionable.length} need updates, ${newer.length} ahead\n`
+      );
+    }
+  }
+
+  private async loadPackage(path: string): Promise<PackageJson | null> {
+    try {
+      if (!existsSync(path)) {
+        return null;
+      }
+      return await loadPackageJson(path);
+    } catch (error) {
+      this.logger.error(`Error loading ${path}: ${error}`);
+      return null;
+    }
+  }
+
+  private getDep(pkg: PackageJson | null, name: string): string | undefined {
+    if (!pkg) return undefined;
+    return pkg.dependencies?.[name] || pkg.devDependencies?.[name];
+  }
+
+  private cleanVersion(version: string): string {
+    // Remove ^, ~, >=, etc. for comparison
+    return version.replace(/^[\^~>=<]+/, '');
+  }
+
+  private compareVersions(v1: string, v2: string): number {
+    const clean1 = this.cleanVersion(v1);
+    const clean2 = this.cleanVersion(v2);
+
+    const parts1 = clean1.split('.').map(Number);
+    const parts2 = clean2.split('.').map(Number);
+
+    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+      const n1 = parts1[i] || 0;
+      const n2 = parts2[i] || 0;
+
+      if (n1 > n2) return 1;
+      if (n1 < n2) return -1;
+    }
+
+    return 0;
+  }
+}

package/src/commands/upstream/sync-mathquill.ts

@@ -0,0 +1,108 @@
+import { Command, Flags } from '@oclif/core';
+import { Logger } from '../../utils/logger.js';
+import { syncMathQuill } from '../../lib/upstream/sync-mathquill.js';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+
+export default class SyncMathQuill extends Command {
+  static description = `Sync MathQuill fork from upstream
+
+Syncs the PIE MathQuill fork sources from ../mathquill to packages/shared/mathquill
+and regenerates the concatenated bundle.
+
+This command:
+1. Copies source files (JS, CSS, fonts) from upstream
+2. Regenerates the legacy/mathquill-bundle.js from sources
+3. Copies documentation files (README, CHANGELOG)
+
+After running this command, you should:
+1. Review changes in packages/shared/mathquill
+2. Update version in package.json if needed
+3. Run: bun run build (in mathquill package)
+4. Test with consuming packages (math-input, math-inline)
+`;
+
+  static examples = [
+    '$ pie upstream:sync-mathquill',
+    '$ pie upstream:sync-mathquill --upstream-path /path/to/mathquill',
+    '$ pie upstream:sync-mathquill --dry-run',
+  ];
+
+  static flags = {
+    'upstream-path': Flags.string({
+      description: 'Path to upstream mathquill repository',
+      default: '../mathquill',
+    }),
+    'dry-run': Flags.boolean({
+      description: 'Show what would be synced without making changes',
+      default: false,
+    }),
+    verbose: Flags.boolean({
+      char: 'v',
+      description: 'Show detailed output',
+      default: false,
+    }),
+  };
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(SyncMathQuill);
+    const logger = new Logger(flags.verbose);
+
+    // Resolve paths
+    const workspaceRoot = process.cwd();
+    const upstreamMathQuillPath = join(workspaceRoot, flags['upstream-path']);
+    const sharedMathQuillPath = join(workspaceRoot, 'packages/shared/mathquill');
+
+    // Validate paths
+    if (!existsSync(upstreamMathQuillPath)) {
+      logger.error(`❌ Upstream MathQuill not found at: ${upstreamMathQuillPath}`);
+      logger.info(`   Specify the correct path with --upstream-path`);
+      this.exit(1);
+    }
+
+    if (!existsSync(sharedMathQuillPath)) {
+      logger.error(`❌ Shared MathQuill package not found at: ${sharedMathQuillPath}`);
+      logger.info(`   Run this command from the workspace root`);
+      this.exit(1);
+    }
+
+    logger.section('🔄 Syncing MathQuill from Upstream');
+    logger.info(`   Upstream: ${upstreamMathQuillPath}`);
+    logger.info(`   Target:   ${sharedMathQuillPath}\n`);
+
+    if (flags['dry-run']) {
+      logger.warn('🏃 DRY RUN MODE - No changes will be made\n');
+      logger.info('Would sync:');
+      logger.info('  • Core JavaScript files (intro.js, outro.js, tree.js, etc.)');
+      logger.info('  • Service modules (services/)');
+      logger.info('  • Command modules (commands/)');
+      logger.info('  • CSS stylesheets (css/)');
+      logger.info('  • Font files (fonts/)');
+      logger.info('  • Documentation (README.md, CHANGELOG.md)');
+      logger.info('\nWould regenerate:');
+      logger.info('  • src/legacy/mathquill-bundle.js (concatenated IIFE bundle)');
+      return;
+    }
+
+    // Perform sync
+    const success = await syncMathQuill({
+      upstreamMathQuillPath,
+      sharedMathQuillPath,
+      logger,
+    });
+
+    if (!success) {
+      logger.error('\n❌ MathQuill sync failed');
+      this.exit(1);
+    }
+
+    // Success message
+    logger.section('✅ MathQuill Sync Complete');
+    logger.info('\nNext steps:');
+    logger.info('  1. Review changes: git diff packages/shared/mathquill');
+    logger.info('  2. Update version: packages/shared/mathquill/package.json');
+    logger.info('  3. Build package: cd packages/shared/mathquill && bun run build');
+    logger.info('  4. Test packages: bun run build (in math-input, math-inline, math-templated)');
+    logger.info('  5. Commit changes: git add packages/shared/mathquill && git commit');
+  }
+}