@pie-element/cli 0.1.1

package/src/commands/mathquill/status.ts

@@ -0,0 +1,267 @@
+import { Command, Flags } from '@oclif/core';
+import { Logger } from '../../utils/logger.js';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export default class MathQuillStatus extends Command {
+  static override description = `Show MathQuill migration status
+
+Displays the current state of the MathQuill migration:
+- Current version and source
+- Migration state (pending, in-progress, complete)
+- Installed fork versions (Desmos, Khan patches, Learnosity features)
+- Extracted features and extensions
+- Test results
+- Next steps
+
+Use this to verify migration success or check what needs to be done.
+`;
+
+  static override examples = [
+    {
+      description: 'Show migration status',
+      command: '<%= config.bin %> <%= command.id %>',
+    },
+    {
+      description: 'Verbose output with file details',
+      command: '<%= config.bin %> <%= command.id %> --verbose',
+    },
+  ];
+
+  static override flags = {
+    verbose: Flags.boolean({
+      char: 'v',
+      description: 'Show detailed information',
+      default: false,
+    }),
+  };
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(MathQuillStatus);
+    const logger = new Logger(flags.verbose);
+
+    const workspaceRoot = process.cwd();
+    const mathquillPath = join(workspaceRoot, 'packages/shared/mathquill');
+
+    if (!existsSync(mathquillPath)) {
+      logger.error('MathQuill package not found at: packages/shared/mathquill');
+      this.exit(1);
+    }
+
+    logger.section('📊 MathQuill Status');
+
+    // Read package.json
+    const pkgPath = join(mathquillPath, 'package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+
+    // Determine migration state
+    const isLegacy = existsSync(join(mathquillPath, 'src/legacy/mathquill-bundle.js'));
+    const hasExtensions = existsSync(join(mathquillPath, 'src/extensions'));
+    const hasLoader = existsSync(join(mathquillPath, 'src/extensions/index.ts'));
+    const migrationConfig = this.loadMigrationConfig(mathquillPath);
+
+    // Current state
+    this.log('\n📦 Current Configuration:');
+    this.log(`   Package: ${pkg.name}@${pkg.version}`);
+    this.log(`   Source:  ${this.detectSource(pkg, isLegacy, hasExtensions)}`);
+
+    if (pkg.dependencies?.mathquill) {
+      const dep = pkg.dependencies.mathquill;
+      if (dep.includes('desmosinc')) {
+        this.log(`   Fork:    Desmos (${dep})`);
+      } else if (dep.includes('Khan')) {
+        this.log(`   Fork:    Khan Academy (${dep})`);
+      } else if (dep.includes('Learnosity')) {
+        this.log(`   Fork:    Learnosity (${dep})`);
+      } else {
+        this.log(`   Fork:    ${dep}`);
+      }
+    }
+
+    // Migration state
+    this.log('\n🔄 Migration State:');
+    const migrationState = this.determineMigrationState(
+      isLegacy,
+      hasExtensions,
+      hasLoader,
+      migrationConfig
+    );
+    this.log(`   Status:  ${migrationState.status} ${migrationState.icon}`);
+    if (migrationState.detail) {
+      this.log(`   Detail:  ${migrationState.detail}`);
+    }
+
+    // Extension state
+    if (hasExtensions) {
+      this.log('\n🔧 Extensions:');
+      this.showExtensionStatus(mathquillPath, flags.verbose, logger);
+    }
+
+    // Migration metadata
+    if (migrationConfig) {
+      this.log('\n📋 Migration Metadata:');
+      this.showMigrationMetadata(migrationConfig);
+    }
+
+    // Next steps
+    this.log('\n📝 Next Steps:');
+    this.showNextSteps(migrationState.status, isLegacy, hasExtensions);
+
+    this.log('');
+  }
+
+  private detectSource(_pkg: any, isLegacy: boolean, hasExtensions: boolean): string {
+    if (hasExtensions && !isLegacy) {
+      return 'Desmos fork + patches (migrated)';
+    }
+    if (isLegacy) {
+      return 'PIE fork (legacy - needs migration)';
+    }
+    return 'Unknown';
+  }
+
+  private determineMigrationState(
+    isLegacy: boolean,
+    hasExtensions: boolean,
+    hasLoader: boolean,
+    _config: any
+  ): { status: string; icon: string; detail?: string } {
+    if (!isLegacy && hasExtensions && hasLoader) {
+      return {
+        status: 'Complete',
+        icon: '✅',
+        detail: 'Migration successful',
+      };
+    }
+
+    if (hasExtensions && !hasLoader) {
+      return {
+        status: 'In Progress',
+        icon: '⚠️',
+        detail: 'Extensions exist but loader missing',
+      };
+    }
+
+    if (isLegacy && !hasExtensions) {
+      return {
+        status: 'Pending',
+        icon: '📋',
+        detail: 'Legacy fork still in use',
+      };
+    }
+
+    if (isLegacy && hasExtensions) {
+      return {
+        status: 'Transitioning',
+        icon: '🔄',
+        detail: 'Both legacy and new extensions present',
+      };
+    }
+
+    return {
+      status: 'Unknown',
+      icon: '❓',
+      detail: 'Unexpected state',
+    };
+  }
+
+  private showExtensionStatus(mathquillPath: string, verbose: boolean, _logger: Logger): void {
+    const extensionDirs = [
+      { name: 'Khan', path: 'src/extensions/khan' },
+      { name: 'Learnosity', path: 'src/extensions/learnosity' },
+      { name: 'PIE', path: 'src/extensions/pie' },
+    ];
+
+    for (const ext of extensionDirs) {
+      const fullPath = join(mathquillPath, ext.path);
+      if (existsSync(fullPath)) {
+        const files = this.countTypeScriptFiles(fullPath);
+        this.log(`   ${ext.name}: ${files} file(s) ✓`);
+
+        if (verbose) {
+          const indexExists = existsSync(join(fullPath, 'index.ts'));
+          this.log(`     • index.ts: ${indexExists ? '✓' : '✗'}`);
+        }
+      } else {
+        this.log(`   ${ext.name}: Not found ✗`);
+      }
+    }
+
+    const loaderPath = join(mathquillPath, 'src/extensions/index.ts');
+    if (existsSync(loaderPath)) {
+      this.log(`   Loader:  ✓`);
+    } else {
+      this.log(`   Loader:  ✗ (Missing extension loader)`);
+    }
+  }
+
+  private countTypeScriptFiles(dir: string): number {
+    if (!existsSync(dir)) return 0;
+
+    try {
+      const { readdirSync } = require('node:fs');
+      const files = readdirSync(dir);
+      return files.filter((f: string) => f.endsWith('.ts') || f.endsWith('.tsx')).length;
+    } catch {
+      return 0;
+    }
+  }
+
+  private loadMigrationConfig(mathquillPath: string): any {
+    const configPath = join(mathquillPath, 'migration-config.json');
+    if (!existsSync(configPath)) {
+      return null;
+    }
+
+    try {
+      return JSON.parse(readFileSync(configPath, 'utf-8'));
+    } catch {
+      return null;
+    }
+  }
+
+  private showMigrationMetadata(config: any): void {
+    if (config.version) {
+      this.log(`   Version:      ${config.version}`);
+    }
+    if (config.lastMigration) {
+      this.log(`   Last run:     ${new Date(config.lastMigration).toLocaleString()}`);
+    }
+    if (config.base?.installed) {
+      this.log(`   Base fork:    ${config.base.fork}@${config.base.installed}`);
+    }
+    if (config.migrationState) {
+      this.log(`   State:        ${config.migrationState}`);
+    }
+  }
+
+  private showNextSteps(status: string, isLegacy: boolean, _hasExtensions: boolean): void {
+    if (status === 'Complete') {
+      this.log('   ✅ Migration complete!');
+      this.log('   • Build: cd packages/shared/mathquill && bun run build');
+      this.log('   • Test:  bun test packages/lib-react/math-input');
+      this.log('   • Demo:  bun run dev:demo');
+      return;
+    }
+
+    if (status === 'Pending' && isLegacy) {
+      this.log('   📋 Migration needed');
+      this.log('   1. Run: pie mathquill:migrate --dry-run');
+      this.log('   2. Review the migration plan');
+      this.log('   3. Run: pie mathquill:migrate');
+      this.log('   4. Test thoroughly before committing');
+      return;
+    }
+
+    if (status === 'In Progress' || status === 'Transitioning') {
+      this.log('   ⚠️  Migration incomplete');
+      this.log('   1. Check for errors: pie mathquill:migrate --verbose');
+      this.log('   2. Or re-run: pie mathquill:migrate --force');
+      return;
+    }
+
+    this.log('   ❓ Unknown state - check documentation');
+    this.log('   • See: docs/MATHQUILL_MIGRATION_PLAN.md');
+    this.log('   • See: docs/MATHQUILL_MIGRATION_CLI_PLAN.md');
+  }
+}

package/src/commands/packages/create-controllers.ts

@@ -0,0 +1,127 @@
+import { Command, Flags } from '@oclif/core';
+import { Logger } from '../../utils/logger.js';
+import { extractDependencies } from '../../utils/package-json.js';
+import { existsSync } from 'node:fs';
+import { readdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+const SHARED_DIR = 'packages/shared';
+
+export default class CreateControllers extends Command {
+  static override description = 'Create package.json files for synced controllers';
+
+  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(CreateControllers);
+
+    this.logger = new Logger(flags.verbose);
+
+    this.logger.section('📦 Creating package.json files for controllers');
+
+    const controllers = await readdir(SHARED_DIR);
+    let created = 0;
+    let skipped = 0;
+
+    for (const controller of controllers) {
+      const controllerDir = join(SHARED_DIR, controller);
+      const packageJsonPath = join(controllerDir, 'package.json');
+
+      // Skip if package.json already exists
+      if (existsSync(packageJsonPath)) {
+        this.logger.info(`  ⏭️  ${controller}: package.json already exists`);
+        skipped++;
+        continue;
+      }
+
+      // Scan for dependencies
+      const deps = await this.scanController(controllerDir);
+
+      // Generate package.json
+      const content = this.generatePackageJson(controller, deps);
+
+      // Write file
+      await writeFile(packageJsonPath, content, 'utf-8');
+      this.logger.success(`  ✅ ${controller}: Created package.json (${deps.length} dependencies)`);
+      created++;
+    }
+
+    this.logger.section(`\n📊 Summary: ${created} created, ${skipped} skipped`);
+  }
+
+  private async scanController(controllerDir: string): Promise<string[]> {
+    const srcDir = join(controllerDir, 'src');
+    const deps = new Set<string>();
+
+    if (!existsSync(srcDir)) {
+      return [];
+    }
+
+    const files = await readdir(srcDir);
+
+    for (const file of files) {
+      if (!file.endsWith('.ts')) continue;
+
+      const filePath = join(srcDir, file);
+      const content = await readFile(filePath, 'utf-8');
+      const fileDeps = extractDependencies(content);
+
+      for (const dep of fileDeps) deps.add(dep);
+    }
+
+    return Array.from(deps).sort();
+  }
+
+  private generatePackageJson(name: string, deps: string[]): string {
+    const dependencies: Record<string, string> = {};
+
+    for (const dep of deps) {
+      // Use * for external dependencies (they're in root package.json)
+      dependencies[dep] = '*';
+    }
+
+    const pkg = {
+      name: `@pie-element/${name}`,
+      version: '0.1.0',
+      description: `Framework-agnostic ${name.replace('-controller', '')} controller synced from pie-elements`,
+      type: 'module',
+      main: './src/index.ts',
+      types: './src/index.ts',
+      exports: {
+        '.': {
+          types: './src/index.ts',
+          default: './src/index.ts',
+        },
+      },
+      files: ['src'],
+      scripts: {
+        build: "echo 'Controllers are consumed as TypeScript source'",
+        lint: 'biome check .',
+        'lint:fix': 'biome check --write .',
+      },
+      dependencies: Object.keys(dependencies).length > 0 ? dependencies : undefined,
+      keywords: ['pie', 'pie-element', 'controller', name.replace('-controller', ''), 'assessment'],
+      license: 'ISC',
+      repository: {
+        type: 'git',
+        url: 'https://github.com/pie-framework/pie-elements-ng.git',
+        directory: `packages/shared/${name}`,
+      },
+    };
+
+    // Remove undefined fields
+    const cleaned = JSON.parse(JSON.stringify(pkg));
+
+    return `${JSON.stringify(cleaned, null, 2)}\n`;
+  }
+}

package/src/commands/packages/create-lib-react.ts

@@ -0,0 +1,279 @@
+import { Command, Flags } from '@oclif/core';
+import { Logger } from '../../utils/logger.js';
+import { loadPackageJson } from '../../utils/package-json.js';
+import { existsSync } from 'node:fs';
+import { mkdir, readdir, writeFile, stat as fsStat } from 'node:fs/promises';
+import { join } from 'node:path';
+
+interface PackageJson {
+  name: string;
+  version: string;
+  description: string;
+  type: string;
+  main: string;
+  types: string;
+  exports: Record<string, unknown>;
+  files: string[];
+  scripts: Record<string, string>;
+  dependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  keywords: string[];
+  license: string;
+  repository: {
+    type: string;
+    url: string;
+    directory: string;
+  };
+}
+
+export default class CreateLibReact extends Command {
+  static override description = 'Create package.json files for synced @pie-lib packages';
+
+  static override examples = [
+    '<%= config.bin %> <%= command.id %>',
+    '<%= config.bin %> <%= command.id %> --dry-run',
+  ];
+
+  static override flags = {
+    'dry-run': Flags.boolean({
+      description: 'Show what would be created without making changes',
+      default: false,
+    }),
+    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(CreateLibReact);
+
+    this.logger = new Logger(flags.verbose);
+
+    this.logger.section('📦 Creating package.json files for @pie-lib packages');
+    this.logger.info(`   Mode: ${flags['dry-run'] ? 'DRY RUN' : 'LIVE'}\n`);
+
+    const libReactDir = 'packages/lib-react';
+    const packages = await readdir(libReactDir);
+
+    let created = 0;
+    let skipped = 0;
+
+    for (const pkg of packages) {
+      const pkgPath = join(libReactDir, pkg);
+      const statResult = await fsStat(pkgPath);
+
+      if (!statResult.isDirectory() || pkg === 'node_modules') {
+        continue;
+      }
+
+      // Check if src directory exists
+      const srcPath = join(pkgPath, 'src');
+      if (!existsSync(srcPath)) {
+        continue;
+      }
+
+      try {
+        const packageJsonPath = join(pkgPath, 'package.json');
+        if (existsSync(packageJsonPath)) {
+          skipped++;
+          this.logger.info(`  ⏭️  ${pkg}: Already configured`);
+          continue;
+        }
+
+        await this.createPackageJson(pkg, flags['dry-run']);
+        await this.createViteConfig(pkg, flags['dry-run']);
+        await this.createTsConfig(pkg, flags['dry-run']);
+        created++;
+      } catch (error) {
+        this.logger.error(`  ❌ ${pkg}: Error - ${error}`);
+      }
+    }
+
+    this.logger.success(`\n✅ Created ${created} package configurations`);
+    this.logger.info(`⏭️  Skipped ${skipped} existing packages`);
+
+    if (!flags['dry-run'] && created > 0) {
+      this.logger.section('\n💡 Next steps');
+      this.logger.info('  1. Run: bun install (to link workspace packages)');
+      this.logger.info('  2. Run: bun run build --filter="@pie-lib/*" (to build all lib packages)');
+      this.logger.info('  3. Update React elements to use the new workspace dependencies\n');
+    }
+  }
+
+  private async getUpstreamPackageJson(pkgName: string): Promise<PackageJson | null> {
+    const upstreamPath = join('../pie-lib/packages', pkgName, 'package.json');
+    if (existsSync(upstreamPath)) {
+      return (await loadPackageJson(upstreamPath)) as unknown as PackageJson;
+    }
+    return null;
+  }
+
+  private convertDependencies(deps: Record<string, string> | undefined): Record<string, string> {
+    if (!deps) return {};
+
+    const converted: Record<string, string> = {};
+    for (const [name, version] of Object.entries(deps)) {
+      if (name.startsWith('@pie-lib/')) {
+        // Convert to workspace dependency
+        converted[name] = 'workspace:*';
+      } else {
+        // Keep external dependencies as-is
+        converted[name] = version;
+      }
+    }
+    return converted;
+  }
+
+  private async createPackageJson(pkgName: string, dryRun: boolean = false): Promise<void> {
+    const targetDir = join('packages/lib-react', pkgName);
+    const targetPath = join(targetDir, 'package.json');
+
+    // Skip if package.json already exists
+    if (existsSync(targetPath)) {
+      this.logger.info(`  ⏭️  ${pkgName}: package.json already exists`);
+      return;
+    }
+
+    // Get upstream package.json for dependencies
+    const upstream = await this.getUpstreamPackageJson(pkgName);
+
+    const packageJson: PackageJson = {
+      name: `@pie-lib/${pkgName}`,
+      version: '0.1.0',
+      description:
+        upstream?.description || `React implementation of @pie-lib/${pkgName} synced from pie-lib`,
+      type: 'module',
+      main: './dist/index.js',
+      types: './dist/index.d.ts',
+      exports: {
+        '.': {
+          types: './dist/index.d.ts',
+          default: './dist/index.js',
+        },
+      },
+      files: ['dist', 'src'],
+      scripts: {
+        build: 'vite build && tsc --emitDeclarationOnly',
+        lint: 'biome check .',
+        'lint:fix': 'biome check --write .',
+      },
+      keywords: ['pie', 'pie-lib', 'react', pkgName],
+      license: 'ISC',
+      repository: {
+        type: 'git',
+        url: 'https://github.com/pie-framework/pie-elements-ng.git',
+        directory: `packages/lib-react/${pkgName}`,
+      },
+    };
+
+    // Convert dependencies
+    if (upstream?.dependencies) {
+      packageJson.dependencies = this.convertDependencies(upstream.dependencies);
+    }
+
+    if (upstream?.peerDependencies) {
+      packageJson.peerDependencies = this.convertDependencies(upstream.peerDependencies);
+    }
+
+    // Add common devDependencies
+    packageJson.devDependencies = {
+      '@types/react': '^18.2.0',
+      '@types/react-dom': '^18.2.0',
+      '@vitejs/plugin-react': '^4.2.0',
+      typescript: '^5.9.3',
+      vite: '^6.0.0',
+    };
+
+    if (dryRun) {
+      this.logger.info(`  🔍 ${pkgName}: Would create package.json`);
+    } else {
+      await mkdir(targetDir, { recursive: true });
+      await writeFile(targetPath, `${JSON.stringify(packageJson, null, 2)}\n`, 'utf-8');
+      this.logger.success(`  ✨ ${pkgName}: Created package.json`);
+    }
+  }
+
+  private async createViteConfig(pkgName: string, dryRun: boolean = false): Promise<void> {
+    const targetDir = join('packages/lib-react', pkgName);
+    const targetPath = join(targetDir, 'vite.config.ts');
+
+    // Skip if vite.config.ts already exists
+    if (existsSync(targetPath)) {
+      return;
+    }
+
+    const viteConfig = `import react from '@vitejs/plugin-react';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  plugins: [react()],
+  build: {
+    lib: {
+      entry: './src/index.ts',
+      formats: ['es'],
+      fileName: () => 'index.js',
+    },
+    rollupOptions: {
+      external: [
+        'react',
+        'react-dom',
+        'react/jsx-runtime',
+        'prop-types',
+        'lodash',
+        'debug',
+        'classnames',
+        /^@pie-lib\\//,
+        /^@pie-framework\\//,
+        /^@pie-element\\//,
+        /^@mui\\//,
+        /^@emotion\\//,
+        /^@dnd-kit\\//,
+        /^react-transition-group/,
+      ],
+    },
+    outDir: 'dist',
+    emptyOutDir: true,
+  },
+});
+`;
+
+    if (dryRun) {
+      this.logger.info(`  🔍 ${pkgName}: Would create vite.config.ts`);
+    } else {
+      await writeFile(targetPath, viteConfig, 'utf-8');
+    }
+  }
+
+  private async createTsConfig(pkgName: string, dryRun: boolean = false): Promise<void> {
+    const targetDir = join('packages/lib-react', pkgName);
+    const targetPath = join(targetDir, 'tsconfig.json');
+
+    // Skip if tsconfig.json already exists
+    if (existsSync(targetPath)) {
+      return;
+    }
+
+    const tsConfig = {
+      extends: '../../../tsconfig.base.json',
+      compilerOptions: {
+        outDir: './dist',
+        rootDir: './src',
+        declaration: true,
+        emitDeclarationOnly: false,
+      },
+      include: ['src/**/*'],
+      exclude: ['node_modules', 'dist', '**/*.spec.ts', '**/*.spec.tsx'],
+    };
+
+    if (dryRun) {
+      this.logger.info(`  🔍 ${pkgName}: Would create tsconfig.json`);
+    } else {
+      await writeFile(targetPath, `${JSON.stringify(tsConfig, null, 2)}\n`, 'utf-8');
+    }
+  }
+}