@pie-element/cli 0.1.1

package/src/commands/dev/test-bundler.ts

@@ -0,0 +1,345 @@
+import { Command, Flags } from '@oclif/core';
+import { Logger } from '../../utils/logger.js';
+import {
+  mkDependencyHash,
+  generateEntries,
+  createWebpackConfig,
+  type BuildDependency,
+} from '@pie-element/bundler-shared';
+import webpack from 'webpack';
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync, rmSync, symlinkSync, mkdirSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+export default class TestBundler extends Command {
+  static override description = 'Test the PIE bundler service with local workspace packages';
+
+  static override examples = [
+    'bun run cli <%= command.id %>',
+    'bun cli <%= command.id %>',
+    '<%= config.bin %> <%= command.id %>',
+    'bun cli <%= command.id %> --element multiple-choice',
+    'bun cli <%= command.id %> --clean',
+  ];
+
+  static override flags = {
+    element: Flags.string({
+      char: 'e',
+      description: 'Test with specific element (default: multiple-choice)',
+      default: 'multiple-choice',
+    }),
+    clean: Flags.boolean({
+      description: 'Clean test workspace before running',
+      default: false,
+    }),
+    verbose: Flags.boolean({
+      char: 'v',
+      description: 'Show detailed output including webpack logs',
+      default: false,
+    }),
+    'keep-workspace': Flags.boolean({
+      description: 'Keep workspace directory after test (for debugging)',
+      default: false,
+    }),
+  };
+
+  private logger!: Logger;
+
+  public async run(): Promise<void> {
+    const { flags } = await this.parse(TestBundler);
+    this.logger = new Logger(flags.verbose);
+
+    this.logger.section('🚀 Testing PIE Bundler with Workspace Packages');
+
+    // Setup paths
+    const workspaceRoot = join(tmpdir(), 'pie-bundler-workspace-test');
+    const cacheDir = join(workspaceRoot, 'cache');
+    const outputDir = join(workspaceRoot, 'output');
+
+    if (flags.clean && existsSync(workspaceRoot)) {
+      this.logger.info('Cleaning old workspace...');
+      rmSync(workspaceRoot, { recursive: true, force: true });
+    }
+
+    mkdirSync(outputDir, { recursive: true });
+    mkdirSync(cacheDir, { recursive: true });
+
+    // Build local packages first
+    this.log('\n📦 Building local packages');
+    await this.buildLocalPackages(flags.element);
+
+    // Create workspace with local packages
+    this.log('\n🔗 Setting up test workspace');
+    const workspaceDir = await this.setupWorkspace(workspaceRoot, flags.element);
+
+    // Test the bundler - use workspaceDir instead of installing from NPM
+    this.log('\n⚙️  Running bundler test');
+
+    try {
+      this.logger.info(`Building bundle for @pie-element/${flags.element}...`);
+
+      // Call bundler directly without download step - workspace already has packages
+      const result = await this.buildFromWorkspace(workspaceDir, outputDir, flags.element);
+
+      if (flags.verbose) {
+        this.log('\nBuild Result:');
+        this.log(JSON.stringify(result, null, 2));
+      }
+
+      if (!result.success) {
+        this.logger.error('Build failed');
+        if (result.errors) {
+          this.log('\nErrors:');
+          for (const err of result.errors) {
+            this.log(`  - ${err}`);
+          }
+        }
+        this.error('Bundler test failed', { exit: 1 });
+      }
+
+      // Verify results
+      this.log('\n✓ Verifying bundles');
+      await this.verifyBundles(outputDir, result.hash);
+
+      // Summary
+      this.log(`\n${'='.repeat(60)}`);
+      this.log('✅ BUNDLER TEST PASSED');
+      this.log('='.repeat(60));
+      this.log(`Element:        @pie-element/${flags.element}`);
+      this.log(`Hash:           ${result.hash}`);
+      this.log(`Duration:       ${result.duration}ms`);
+      this.log(`Cached:         ${result.cached ? 'Yes' : 'No'}`);
+      this.log(`Bundle dir:     ${join(outputDir, result.hash)}`);
+
+      if (!flags['keep-workspace']) {
+        this.logger.info('\nCleaning up workspace...');
+        rmSync(workspaceRoot, { recursive: true, force: true });
+      } else {
+        this.log(`Workspace:      ${workspaceRoot}`);
+      }
+
+      this.log('='.repeat(60));
+      this.log('');
+    } catch (error: any) {
+      this.logger.error(`Test failed: ${error.message}`);
+      if (flags.verbose) {
+        this.log(error.stack);
+      }
+      this.error('Bundler test failed', { exit: 1 });
+    }
+  }
+
+  private async buildLocalPackages(element: string): Promise<void> {
+    const packages = ['packages/shared/mathquill', `packages/elements-react/${element}`];
+
+    for (const pkg of packages) {
+      if (!existsSync(pkg)) {
+        this.logger.warn(`Package not found: ${pkg}`);
+        continue;
+      }
+
+      this.logger.info(`Building ${pkg}...`);
+      try {
+        execSync('bun run build', {
+          cwd: pkg,
+          stdio: this.logger.isVerbose() ? 'inherit' : 'pipe',
+        });
+      } catch (error: any) {
+        this.logger.warn(`Build failed for ${pkg}: ${error.message}`);
+      }
+    }
+  }
+
+  private async setupWorkspace(workspaceRoot: string, element: string): Promise<string> {
+    const workspaceDir = join(workspaceRoot, 'workspace');
+    const packagesDir = join(workspaceDir, 'packages');
+
+    mkdirSync(packagesDir, { recursive: true });
+
+    // Create workspace package.json with bundler dependencies
+    writeFileSync(
+      join(workspaceDir, 'package.json'),
+      JSON.stringify(
+        {
+          name: 'pie-bundler-test-workspace',
+          private: true,
+          workspaces: [
+            'packages/*',
+            'packages/*/controller',
+            'packages/*/configure',
+            'packages/*/author',
+          ],
+          dependencies: {
+            'esbuild-loader': '^4.4.2',
+            'css-loader': '^7.1.2',
+            'style-loader': '^4.0.0',
+            'url-loader': '^4.1.1',
+          },
+        },
+        null,
+        2
+      )
+    );
+
+    // Symlink local packages
+    const localPackages = {
+      'shared-mathquill': 'packages/shared/mathquill',
+      [element]: `packages/elements-react/${element}`,
+    };
+
+    for (const [name, path] of Object.entries(localPackages)) {
+      if (!existsSync(path)) {
+        this.logger.warn(`Package not found: ${path}`);
+        continue;
+      }
+
+      const linkPath = join(packagesDir, name);
+      if (existsSync(linkPath)) {
+        rmSync(linkPath, { recursive: true, force: true });
+      }
+
+      this.logger.info(`Linking ${name} → ${path}`);
+      symlinkSync(join(process.cwd(), path), linkPath, 'dir');
+    }
+
+    // Install dependencies
+    this.logger.info('Installing workspace dependencies...');
+    try {
+      execSync('bun install', {
+        cwd: workspaceDir,
+        stdio: this.logger.isVerbose() ? 'inherit' : 'pipe',
+      });
+    } catch (error: any) {
+      this.logger.warn(`Workspace install had issues: ${error.message}`);
+    }
+
+    // Create symlinks in node_modules for @pie-element packages
+    const nodeModulesDir = join(workspaceDir, 'node_modules');
+    const pieElementDir = join(nodeModulesDir, '@pie-element');
+    mkdirSync(pieElementDir, { recursive: true });
+
+    // Link shared-mathquill
+    const mathquillLink = join(pieElementDir, 'shared-mathquill');
+    if (existsSync(mathquillLink)) {
+      rmSync(mathquillLink, { recursive: true, force: true });
+    }
+    symlinkSync(join(packagesDir, 'shared-mathquill'), mathquillLink, 'dir');
+    this.logger.info('Linked @pie-element/shared-mathquill in node_modules');
+
+    // Link element package
+    const elementLink = join(pieElementDir, element);
+    if (existsSync(elementLink)) {
+      rmSync(elementLink, { recursive: true, force: true });
+    }
+    symlinkSync(join(packagesDir, element), elementLink, 'dir');
+    this.logger.info(`Linked @pie-element/${element} in node_modules`);
+
+    return workspaceDir;
+  }
+
+  private async buildFromWorkspace(
+    workspaceDir: string,
+    outputDir: string,
+    element: string
+  ): Promise<any> {
+    const dependencies: BuildDependency[] = [{ name: `@pie-element/${element}`, version: '0.1.0' }];
+    const hash = mkDependencyHash(dependencies);
+    const startTime = Date.now();
+
+    this.logger.info(`Bundle hash: ${hash}`);
+
+    // Generate entry files
+    const entryDir = join(workspaceDir, 'entries');
+    mkdirSync(entryDir, { recursive: true });
+
+    const requestedBundles: Array<'player' | 'client-player' | 'editor'> = [
+      'player',
+      'client-player',
+      'editor',
+    ];
+    const entries = generateEntries(dependencies, workspaceDir, requestedBundles);
+
+    writeFileSync(join(entryDir, 'player.js'), entries.player || '');
+    writeFileSync(join(entryDir, 'client-player.js'), entries['client-player'] || '');
+    writeFileSync(join(entryDir, 'editor.js'), entries.editor || '');
+
+    // Create webpack config
+    const bundleOutputPath = join(outputDir, hash);
+    mkdirSync(bundleOutputPath, { recursive: true });
+
+    const webpackConfig = createWebpackConfig({
+      context: entryDir,
+      entry: {
+        player: join(entryDir, 'player.js'),
+        'client-player': join(entryDir, 'client-player.js'),
+        editor: join(entryDir, 'editor.js'),
+      },
+      outputPath: bundleOutputPath,
+      workspaceDir,
+      elements: dependencies.map((d) => d.name.split('/')[1]),
+    });
+
+    // Add repo's node_modules to webpack resolve paths for workspace testing
+    if (!webpackConfig.resolve) webpackConfig.resolve = {};
+    if (!webpackConfig.resolve.modules) webpackConfig.resolve.modules = [];
+    webpackConfig.resolve.modules.push(join(process.cwd(), 'node_modules'));
+
+    // Run webpack
+    return new Promise((resolve, reject) => {
+      webpack(webpackConfig, (err: any, stats: any) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+
+        if (stats?.hasErrors()) {
+          const errors = stats.toString({ colors: false, errorDetails: true });
+          reject(new Error(errors));
+          return;
+        }
+
+        resolve({
+          success: true,
+          hash,
+          bundles: {
+            player: `/bundles/${hash}/player.js`,
+            clientPlayer: `/bundles/${hash}/client-player.js`,
+            editor: `/bundles/${hash}/editor.js`,
+          },
+          duration: Date.now() - startTime,
+          cached: false,
+        });
+      });
+    });
+  }
+
+  private async verifyBundles(outputDir: string, hash: string): Promise<void> {
+    const bundleDir = join(outputDir, hash);
+    const files = ['player.js', 'client-player.js', 'editor.js'];
+
+    let allOk = true;
+
+    for (const file of files) {
+      const filePath = join(bundleDir, file);
+      if (!existsSync(filePath)) {
+        this.logger.error(`❌ ${file} not found`);
+        allOk = false;
+        continue;
+      }
+
+      const content = readFileSync(filePath, 'utf-8');
+      const size = (content.length / 1024).toFixed(1);
+      this.logger.success(`✅ ${file} (${size} KB)`);
+
+      // Verify IIFE format for player bundle
+      if (file === 'player.js' && !content.includes('window.pie')) {
+        this.logger.warn(`⚠️  ${file} doesn't contain window.pie`);
+      }
+    }
+
+    if (!allOk) {
+      this.error('Bundle verification failed', { exit: 1 });
+    }
+  }
+}

package/src/commands/mathquill/migrate.ts

@@ -0,0 +1,269 @@
+import { Command, Flags } from '@oclif/core';
+import { Logger } from '../../utils/logger.js';
+import { MigrationOrchestrator } from '../../lib/mathquill/migration-orchestrator.js';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+export default class MathQuillMigrate extends Command {
+  static override description = `Migrate MathQuill from PIE fork to Desmos fork with patches
+
+Automates the migration from PIE's 2015 MathQuill fork to the modern Desmos fork
+with Khan Academy patches, Learnosity features, and PIE extensions.
+
+This command:
+1. Clones Desmos, Khan, and Learnosity forks to temp directory
+2. Extracts features from each fork:
+   - Khan: Mobile keyboard fixes, i18n ARIA strings
+   - Learnosity: Recurring decimals, nless/ngtr symbols, empty() method
+   - PIE: Matrices (pmatrix, bmatrix, vmatrix), lrnexponent
+3. Generates TypeScript extension modules with source attribution
+4. Creates unified extension loader
+5. Updates package.json to use Desmos fork
+6. Runs automated tests
+
+The migration is repeatable - you can re-run it when forks update.
+
+After migration, review changes and test thoroughly before committing.
+`;
+
+  static override examples = [
+    {
+      description: 'Show what would be migrated (dry run)',
+      command: '<%= config.bin %> <%= command.id %> --dry-run',
+    },
+    {
+      description: 'Run full migration',
+      command: '<%= config.bin %> <%= command.id %>',
+    },
+    {
+      description: 'Verbose output with detailed progress',
+      command: '<%= config.bin %> <%= command.id %> --verbose',
+    },
+    {
+      description: 'Force migration (skip confirmations)',
+      command: '<%= config.bin %> <%= command.id %> --force',
+    },
+    {
+      description: 'Skip tests',
+      command: '<%= config.bin %> <%= command.id %> --skip-tests',
+    },
+  ];
+
+  static override flags = {
+    'dry-run': Flags.boolean({
+      description: 'Show what would be done without making changes',
+      default: false,
+    }),
+    force: Flags.boolean({
+      description: 'Skip confirmation prompts and continue on non-fatal errors',
+      default: false,
+    }),
+    verbose: Flags.boolean({
+      char: 'v',
+      description: 'Show detailed progress output',
+      default: false,
+    }),
+    'skip-tests': Flags.boolean({
+      description: 'Skip running tests after migration',
+      default: false,
+    }),
+    'temp-dir': Flags.string({
+      description: 'Temporary directory for cloning forks',
+      default: '/tmp/mathquill-migration',
+    }),
+    clean: Flags.boolean({
+      description: 'Clean temporary directory before starting',
+      default: false,
+    }),
+  };
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(MathQuillMigrate);
+    const logger = new Logger(flags.verbose);
+
+    // Validate workspace
+    const workspaceRoot = process.cwd();
+    const mathquillPath = join(workspaceRoot, 'packages/shared/mathquill');
+
+    if (!existsSync(mathquillPath)) {
+      logger.error('MathQuill package not found at: packages/shared/mathquill');
+      logger.info('This command must be run from the workspace root');
+      this.exit(1);
+    }
+
+    // Show banner
+    logger.section('🚀 MathQuill Migration');
+    logger.info('   Migrating from PIE fork to Desmos fork + patches\n');
+
+    if (flags['dry-run']) {
+      logger.warn('🏃 DRY RUN MODE - No changes will be made\n');
+    }
+
+    // Create orchestrator
+    const orchestrator = new MigrationOrchestrator({
+      workspaceRoot,
+      mathquillPath,
+      tempDir: flags['temp-dir'],
+      dryRun: flags['dry-run'],
+      force: flags.force,
+      skipTests: flags['skip-tests'],
+      clean: flags.clean,
+      logger,
+    });
+
+    // Show configuration
+    if (flags.verbose) {
+      logger.section('Configuration');
+      logger.info(`   Workspace:   ${workspaceRoot}`);
+      logger.info(`   MathQuill:   ${mathquillPath}`);
+      logger.info(`   Temp Dir:    ${flags['temp-dir']}`);
+      logger.info(`   Dry Run:     ${flags['dry-run']}`);
+      logger.info(`   Force:       ${flags.force}`);
+      logger.info(`   Skip Tests:  ${flags['skip-tests']}\n`);
+    }
+
+    // Confirm if not in dry-run or force mode
+    if (!flags['dry-run'] && !flags.force) {
+      logger.warn('⚠️  This will modify packages/shared/mathquill');
+      logger.info('   A git commit is recommended before proceeding.\n');
+
+      // In a real implementation, you'd use inquirer or similar
+      // For now, we'll just proceed
+      logger.info('   Proceeding with migration...\n');
+    }
+
+    try {
+      // Run migration
+      const result = await orchestrator.migrate();
+
+      if (flags['dry-run']) {
+        this.showDryRunSummary(result, logger);
+      } else {
+        this.showSuccessSummary(result, logger);
+      }
+
+      if (!result.success) {
+        this.exit(1);
+      }
+    } catch (error) {
+      logger.error('\n❌ Migration failed');
+
+      if (error instanceof Error) {
+        logger.error(`   ${error.message}`);
+        if (flags.verbose && error.stack) {
+          logger.debug(`\n${error.stack}`);
+        }
+      }
+
+      logger.info('\n💡 Troubleshooting:');
+      logger.info('   1. Check internet connectivity for git clones');
+      logger.info('   2. Ensure temp directory is writable');
+      logger.info('   3. Run with --verbose for detailed output');
+      logger.info('   4. Try --clean to remove cached forks');
+      logger.info('   5. Check docs/MATHQUILL_MIGRATION_CLI_PLAN.md');
+
+      this.exit(1);
+    }
+  }
+
+  private showDryRunSummary(result: any, logger: Logger): void {
+    logger.section('📋 Dry Run Summary');
+    logger.info('Would perform the following actions:\n');
+
+    logger.info('📂 Prepare environment:');
+    logger.info(`   • Create temp directory: ${result.tempDir}`);
+    logger.info('   • Create extension directories\n');
+
+    logger.info('🔄 Clone forks:');
+    logger.info('   • Desmos fork (desmosinc/mathquill)');
+    logger.info('   • Khan fork (Khan/mathquill v1.0.3)');
+    logger.info('   • Learnosity fork (Learnosity/mathquill)\n');
+
+    logger.info('📦 Extract features:');
+    logger.info('   Khan Academy:');
+    logger.info('     • mobile-keyboard.ts (Android keyboard fixes)');
+    logger.info('     • i18n-aria.ts (Internationalized ARIA strings)');
+    logger.info('   Learnosity:');
+    logger.info('     • recurring-decimal.ts (Recurring decimal dot)');
+    logger.info('     • not-symbols.ts (nless, ngtr symbols)');
+    logger.info('     • empty-method.ts (Check if field is empty)');
+    logger.info('   PIE:');
+    logger.info('     • matrices.ts (pmatrix, bmatrix, vmatrix)');
+    logger.info('     • lrn-exponent.ts (LRN exponent notation)\n');
+
+    logger.info('🔨 Generate:');
+    logger.info('   • Extension loader (src/extensions/index.ts)\n');
+
+    logger.info('📝 Update:');
+    logger.info('   • Install: mathquill@github:desmosinc/mathquill');
+    logger.info('   • Update: package.json with migration metadata\n');
+
+    logger.info('🧪 Test:');
+    logger.info('   • Run unit tests');
+    logger.info('   • Run integration tests\n');
+
+    logger.success('Dry run complete!');
+    logger.info('\nRun without --dry-run to execute migration.');
+  }
+
+  private showSuccessSummary(result: any, logger: Logger): void {
+    logger.section('✅ Migration Complete!');
+
+    logger.info('\n📊 Summary:');
+    logger.info(`   Base:         Desmos fork (${result.desmos?.commit || 'latest'})`);
+    logger.info(`   + Khan:       ${result.khan?.featuresCount || 0} patches applied`);
+    logger.info(`   + Learnosity: ${result.learnosity?.featuresCount || 0} features added`);
+    logger.info(`   + PIE:        ${result.pie?.featuresCount || 0} extensions ported`);
+
+    if (result.files && result.files.length > 0) {
+      logger.info('\n📂 Generated Files:');
+      logger.info('   packages/shared/mathquill/src/extensions/');
+      logger.info('   ├── khan/');
+      logger.info('   │   ├── mobile-keyboard.ts');
+      logger.info('   │   └── i18n-aria.ts');
+      logger.info('   ├── learnosity/');
+      logger.info('   │   ├── recurring-decimal.ts');
+      logger.info('   │   ├── not-symbols.ts');
+      logger.info('   │   └── empty-method.ts');
+      logger.info('   ├── pie/');
+      logger.info('   │   ├── matrices.ts');
+      logger.info('   │   └── lrn-exponent.ts');
+      logger.info('   └── index.ts (loader)');
+    }
+
+    if (result.tests) {
+      logger.info('\n🧪 Tests:');
+      if (result.tests.unit?.passed) {
+        logger.success(`   Unit tests: ${result.tests.unit.passed} passed`);
+      }
+      if (result.tests.integration?.passed) {
+        logger.success(`   Integration tests: ${result.tests.integration.passed} passed`);
+      }
+      if (result.tests.warnings && result.tests.warnings.length > 0) {
+        logger.warn(`   Warnings: ${result.tests.warnings.length}`);
+      }
+    }
+
+    logger.info('\n📝 Next Steps:');
+    logger.info('   1. Review changes:');
+    logger.info('      git diff packages/shared/mathquill');
+    logger.info('   2. Build package:');
+    logger.info('      cd packages/shared/mathquill && bun run build');
+    logger.info('   3. Test in demo:');
+    logger.info('      bun run dev:demo');
+    logger.info('   4. Verify migration:');
+    logger.info('      pie mathquill:status');
+    logger.info('   5. Run full test suite:');
+    logger.info('      bun test packages/lib-react/math-input');
+    logger.info('      bun test packages/elements-react/math-inline');
+    logger.info('   6. Commit changes:');
+    logger.info('      git add packages/shared/mathquill');
+    logger.info('      git commit -m "Migrate MathQuill to Desmos fork + patches"');
+
+    logger.info('\n💡 Tips:');
+    logger.info('   • Review docs/MATHQUILL_MIGRATION_PLAN.md for details');
+    logger.info('   • Check docs/MATHQUILL_FORK_ANALYSIS.md for fork comparison');
+    logger.info('   • Run "pie mathquill:status" to verify migration state');
+    logger.info('   • Keep /tmp/mathquill-migration for re-running migration\n');
+  }
+}