@mexty/cli 1.0.2 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mexty/cli",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "description": "MEXT CLI for managing blocks and repositories",
   "main": "dist/index.js",
   "bin": {

package/src/commands/create.ts

@@ -1,97 +1,165 @@
-import chalk from 'chalk';
-import path from 'path';
-import { apiClient, CreateBlockRequest } from '../utils/api';
-import { GitManager } from '../utils/git';
-import { createInterface } from 'readline';
-import { requireAuthentication, getAuthenticatedUser } from '../utils/auth';
+import chalk from "chalk";
+import path from "path";
+import { apiClient, CreateBlockRequest } from "../utils/api";
+import { GitManager } from "../utils/git";
+import { createInterface } from "readline";
+import { requireAuthentication, getAuthenticatedUser } from "../utils/auth";
 
 interface CreateOptions {
   description?: string;
   type?: string;
+  name?: string;
+  category?: string;
 }
 
 // Simple prompt function to replace inquirer
-async function prompt(question: string, defaultValue?: string): Promise<string> {
+async function prompt(
+  question: string,
+  defaultValue?: string
+): Promise<string> {
   return new Promise((resolve) => {
     const rl = createInterface({
       input: process.stdin,
-      output: process.stdout
+      output: process.stdout,
     });
 
-    const promptText = defaultValue ? `${question} (${defaultValue}): ` : `${question}: `;
-    
+    const promptText = defaultValue
+      ? `${question} (${defaultValue}): `
+      : `${question}: `;
+
     rl.question(promptText, (answer) => {
       rl.close();
-      resolve(answer.trim() || defaultValue || '');
+      resolve(answer.trim() || defaultValue || "");
     });
   });
 }
 
-export async function createCommand(name: string, options: CreateOptions): Promise<void> {
+export async function createCommand(
+  subcommand?: string,
+  options: CreateOptions = {}
+): Promise<void> {
   try {
     // Check authentication first
     requireAuthentication();
-    
+
     const user = getAuthenticatedUser();
-    console.log(chalk.blue(`🚀 Creating new block: ${name}`));
-    console.log(chalk.gray(`   User: ${user?.fullName || user?.email || 'Unknown'}`));
 
-    // Get description if not provided
-    let description = options.description;
-    if (!description) {
-      description = await prompt('Enter a description for the block', `Custom block: ${name}`);
+    // Handle both old and new syntax
+    let blockName: string;
+    let blockDescription: string;
+    let blockType: string;
+
+    if (subcommand === "block") {
+      // New syntax: mexty create block --name "..." --description "..." --category "..."
+      if (!options.name) {
+        console.error(
+          chalk.red('❌ --name is required when using "mexty create block"')
+        );
+        console.log(
+          chalk.yellow(
+            '   Usage: mexty create block --name "Block Name" --description "Description" --category "category"'
+          )
+        );
+        process.exit(1);
+      }
+
+      blockName = options.name;
+      blockDescription = options.description || `Custom block: ${blockName}`;
+      blockType = options.category || options.type || "custom";
+    } else {
+      // Old syntax: mexty create "Block Name" --description "..." --type "..."
+      if (!subcommand) {
+        console.error(chalk.red("❌ Block name is required"));
+        console.log(
+          chalk.yellow('   Usage: mexty create "Block Name" [options]')
+        );
+        console.log(
+          chalk.yellow(
+            '   Or: mexty create block --name "Block Name" [options]'
+          )
+        );
+        process.exit(1);
+      }
+
+      blockName = subcommand;
+      blockDescription = options.description || `Custom block: ${blockName}`;
+      blockType = options.type || "custom";
     }
 
+    console.log(chalk.blue(`🚀 Creating new block: ${blockName}`));
+    console.log(
+      chalk.gray(`   User: ${user?.fullName || user?.email || "Unknown"}`)
+    );
+    console.log(chalk.gray(`   Category: ${blockType}`));
+
     // Prepare block data
     const blockData: CreateBlockRequest = {
-      blockType: options.type || 'custom',
-      title: name,
-      description: description,
-      allowedBrickTypes: ['text', 'image', 'video', 'code', 'quiz'], // Default allowed types
-      scope: ['user-store'], // Default scope for CLI-created blocks
-      content: []
+      blockType: blockType,
+      title: blockName,
+      description: blockDescription,
+      allowedBrickTypes: ["text", "image", "video", "code", "quiz"], // Default allowed types
+      scope: ["user-store"], // Default scope for CLI-created blocks
+      content: [],
     };
 
-    console.log(chalk.yellow('📡 Creating block on server...'));
-    
+    console.log(chalk.yellow("📡 Creating block on server..."));
+
     // Create the block
     const block = await apiClient.createBlock(blockData);
-    
+
     console.log(chalk.green(`✅ Block created successfully!`));
     console.log(chalk.gray(`   Block ID: ${block._id}`));
     console.log(chalk.gray(`   Block Type: ${block.blockType}`));
-    
+
     if (block.gitUrl) {
       console.log(chalk.gray(`   GitHub URL: ${block.gitUrl}`));
-      
+
       // Clone the repository
       const repoName = GitManager.extractRepoName(block.gitUrl);
       const targetDir = path.join(process.cwd(), repoName);
-      
+
       console.log(chalk.yellow(`📦 Cloning repository to ./${repoName}...`));
-      
+
       try {
         const gitManager = new GitManager();
         await gitManager.cloneRepository(block.gitUrl, targetDir);
-        
-        console.log(chalk.green(`🎉 Block created and repository cloned successfully!`));
+
+        console.log(
+          chalk.green(`🎉 Block created and repository cloned successfully!`)
+        );
         console.log(chalk.blue(`\nNext steps:`));
         console.log(chalk.gray(`  1. cd ${repoName}`));
         console.log(chalk.gray(`  2. Make your changes`));
-        console.log(chalk.gray(`  3. git add . && git commit -m "Your changes"`));
-        console.log(chalk.gray(`  4. mexty publish`));
-        
+        console.log(chalk.gray(`  3. mexty save`));
+
+        // Change to the cloned directory
+        try {
+          process.chdir(targetDir);
+          console.log(chalk.green(`📁 Changed to directory: ${repoName}`));
+        } catch (chdirError: any) {
+          console.warn(
+            chalk.yellow(
+              `⚠️  Could not change to directory: ${chdirError.message}`
+            )
+          );
+          console.log(chalk.gray(`   Please manually run: cd ${repoName}`));
+        }
       } catch (cloneError: any) {
-        console.error(chalk.red(`❌ Failed to clone repository: ${cloneError.message}`));
+        console.error(
+          chalk.red(`❌ Failed to clone repository: ${cloneError.message}`)
+        );
         console.log(chalk.yellow(`You can manually clone it later:`));
         console.log(chalk.gray(`  git clone ${block.gitUrl}`));
       }
     } else {
-      console.log(chalk.yellow('⚠️  No GitHub repository was created (GitHub not configured)'));
+      console.log(
+        chalk.yellow(
+          "⚠️  No GitHub repository was created (GitHub not configured)"
+        )
+      );
     }
-
   } catch (error: any) {
     console.error(chalk.red(`❌ Failed to create block: ${error.message}`));
     process.exit(1);
   }
-} 
+}

package/src/commands/save.ts

@@ -0,0 +1,213 @@
+import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+import { apiClient } from "../utils/api";
+import { GitManager } from "../utils/git";
+import { createInterface } from "readline";
+import { requireAuthentication, getAuthenticatedUser } from "../utils/auth";
+
+// Simple prompt function
+async function prompt(
+  question: string,
+  defaultValue?: string
+): Promise<string> {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    const promptText = defaultValue
+      ? `${question} (${defaultValue}): `
+      : `${question}: `;
+
+    rl.question(promptText, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue || "");
+    });
+  });
+}
+
+// Extract block ID from package.json or git URL
+async function findBlockId(): Promise<string | null> {
+  const packageJsonPath = path.join(process.cwd(), "package.json");
+
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+
+      // Look for block ID in package.json name or description
+      if (packageJson.name && packageJson.name.startsWith("block-")) {
+        return packageJson.name.replace("block-", "");
+      }
+
+      // Look in description for block ID pattern
+      if (packageJson.description) {
+        const match = packageJson.description.match(
+          /block[:\s]+([a-f0-9]{24})/i
+        );
+        if (match) {
+          return match[1];
+        }
+      }
+    } catch (error) {
+      console.warn(chalk.yellow("⚠️  Could not parse package.json"));
+    }
+  }
+
+  // Try to extract from git remote URL
+  try {
+    const gitManager = new GitManager();
+    const remoteUrl = await gitManager.getRemoteUrl();
+
+    if (remoteUrl) {
+      const match = remoteUrl.match(/block-([a-f0-9]{24})/);
+      if (match) {
+        return match[1];
+      }
+    }
+  } catch (error) {
+    // Ignore git errors
+  }
+
+  return null;
+}
+
+export async function saveCommand(): Promise<void> {
+  try {
+    // Check authentication first
+    requireAuthentication();
+
+    const user = getAuthenticatedUser();
+    console.log(chalk.blue("💾 Saving and publishing block..."));
+    console.log(
+      chalk.gray(`   User: ${user?.fullName || user?.email || "Unknown"}`)
+    );
+
+    // Check if we're in a git repository
+    const gitManager = new GitManager();
+    const isGitRepo = await gitManager.isGitRepository();
+
+    if (!isGitRepo) {
+      console.error(
+        chalk.red(
+          "❌ Not a git repository. Please run this command from a block repository."
+        )
+      );
+      process.exit(1);
+    }
+
+    // Get repository information
+    const repoInfo = await gitManager.getRepositoryInfo();
+    console.log(chalk.gray(`   Current branch: ${repoInfo.branch}`));
+    console.log(chalk.gray(`   Remote URL: ${repoInfo.remoteUrl}`));
+
+    // Find block ID
+    const blockId = await findBlockId();
+    if (!blockId) {
+      console.error(
+        chalk.red("❌ Could not determine block ID from repository.")
+      );
+      console.error(
+        chalk.yellow(
+          "   Make sure you are in a block repository created with mexty"
+        )
+      );
+      process.exit(1);
+    }
+
+    console.log(chalk.gray(`   Block ID: ${blockId}`));
+
+    // Check if there are changes to commit
+    if (repoInfo.hasChanges) {
+      console.log(
+        chalk.yellow("📝 Found uncommitted changes, preparing to commit...")
+      );
+
+      // Get commit message from user
+      const commitMessage = await prompt(
+        "Enter commit message",
+        "Update block content"
+      );
+
+      if (!commitMessage.trim()) {
+        console.error(chalk.red("❌ Commit message cannot be empty"));
+        process.exit(1);
+      }
+
+      // Stage all changes
+      console.log(chalk.yellow("📋 Staging changes (git add .)..."));
+      try {
+        await gitManager.git.add(".");
+        console.log(chalk.green("✅ Changes staged successfully"));
+      } catch (addError: any) {
+        console.error(
+          chalk.red(`❌ Failed to stage changes: ${addError.message}`)
+        );
+        process.exit(1);
+      }
+
+      // Commit changes
+      console.log(chalk.yellow(`💬 Committing changes: "${commitMessage}"...`));
+      try {
+        await gitManager.git.commit(commitMessage);
+        console.log(chalk.green("✅ Changes committed successfully"));
+      } catch (commitError: any) {
+        console.error(
+          chalk.red(`❌ Failed to commit changes: ${commitError.message}`)
+        );
+        process.exit(1);
+      }
+    } else {
+      console.log(chalk.green("✅ No uncommitted changes found"));
+    }
+
+    // Push changes to remote
+    console.log(
+      chalk.yellow(`📤 Pushing changes to remote (${repoInfo.branch})...`)
+    );
+    try {
+      await gitManager.pushToRemote();
+      console.log(chalk.green("✅ Changes pushed successfully"));
+    } catch (pushError: any) {
+      console.error(
+        chalk.red(`❌ Failed to push changes: ${pushError.message}`)
+      );
+      console.log(
+        chalk.yellow(
+          "   Please check your network connection and GitHub permissions"
+        )
+      );
+      process.exit(1);
+    }
+
+    // Trigger save and bundle
+    console.log(chalk.yellow("🏗️  Triggering build and bundle process..."));
+
+    try {
+      const result = await apiClient.saveAndBundle({ blockId });
+
+      console.log(chalk.green("🎉 Block saved and published successfully!"));
+      console.log(chalk.gray(`   Bundle Path: ${result.bundlePath}`));
+      console.log(chalk.gray(`   Federation URL: ${result.federationUrl}`));
+
+      if (result.message) {
+        console.log(chalk.blue(`   ${result.message}`));
+      }
+
+      console.log(
+        chalk.blue("\n📋 Your block is now building in the background.")
+      );
+      console.log(
+        chalk.gray("   You can check the build status in the web interface.")
+      );
+    } catch (buildError: any) {
+      console.error(chalk.red(`❌ Build failed: ${buildError.message}`));
+      console.log(chalk.yellow("   Check the server logs for more details."));
+      process.exit(1);
+    }
+  } catch (error: any) {
+    console.error(chalk.red(`❌ Failed to save block: ${error.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/sync.ts

@@ -1,7 +1,7 @@
-import chalk from 'chalk';
-import fs from 'fs';
-import path from 'path';
-import { apiClient } from '../utils/api';
+import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+import { apiClient } from "../utils/api";
 
 interface BlockRegistryEntry {
   blockId: string;
@@ -26,14 +26,16 @@ interface AuthorNamespaceRegistry {
 
 export async function syncCommand(): Promise<void> {
   try {
-    console.log(chalk.blue('🔄 Syncing block registry...'));
+    console.log(chalk.blue("🔄 Syncing block registry..."));
 
     // Fetch registry from server
-    console.log(chalk.yellow('📡 Fetching registry from server...'));
-    const response = await fetch('https://api.v2.mext.app/api/blocks/registry');
-    
+    console.log(chalk.yellow("📡 Fetching registry from server..."));
+    const response = await fetch("https://api.mexty.ai/api/blocks/registry");
+
     if (!response.ok) {
-      throw new Error(`Server responded with ${response.status}: ${response.statusText}`);
+      throw new Error(
+        `Server responded with ${response.status}: ${response.statusText}`
+      );
     }
 
     const data = await response.json();
@@ -48,25 +50,43 @@ export async function syncCommand(): Promise<void> {
     console.log(chalk.gray(`   Last updated: ${meta.lastUpdated}`));
 
     if (Object.keys(registry).length === 0) {
-      console.log(chalk.yellow('⚠️  No components found in registry.'));
-      console.log(chalk.gray('   Make sure you have built some blocks first using "mexty publish"'));
+      console.log(chalk.yellow("⚠️  No components found in registry."));
+      console.log(
+        chalk.gray(
+          '   Make sure you have built some blocks first using "mexty publish"'
+        )
+      );
       return;
     }
 
     // Display available components
-    console.log(chalk.blue('\n📋 Available components (global namespace):'));
+    console.log(chalk.blue("\n📋 Available components (global namespace):"));
     for (const [componentName, entry] of Object.entries(registry)) {
-      console.log(chalk.green(`   ${componentName}${entry.author ? chalk.gray(` (by ${entry.author})`) : ''}`));
+      console.log(
+        chalk.green(
+          `   ${componentName}${
+            entry.author ? chalk.gray(` (by ${entry.author})`) : ""
+          }`
+        )
+      );
       console.log(chalk.gray(`      Block ID: ${entry.blockId}`));
       console.log(chalk.gray(`      Title: ${entry.title}`));
-      console.log(chalk.gray(`      Description: ${entry.description.substring(0, 60)}${entry.description.length > 60 ? '...' : ''}`));
-      console.log(chalk.gray(`      Tags: ${entry.tags?.join(', ') || 'none'}`));
-      console.log('');
+      console.log(
+        chalk.gray(
+          `      Description: ${entry.description.substring(0, 60)}${
+            entry.description.length > 60 ? "..." : ""
+          }`
+        )
+      );
+      console.log(
+        chalk.gray(`      Tags: ${entry.tags?.join(", ") || "none"}`)
+      );
+      console.log("");
     }
 
     // Display author namespaces
     if (Object.keys(authorRegistry).length > 0) {
-      console.log(chalk.blue('\n👤 Author namespaces:'));
+      console.log(chalk.blue("\n👤 Author namespaces:"));
       for (const [author, components] of Object.entries(authorRegistry)) {
         console.log(chalk.cyan(`   @${author}:`));
         for (const [componentName, entry] of Object.entries(components)) {
@@ -74,25 +94,30 @@ export async function syncCommand(): Promise<void> {
           console.log(chalk.gray(`        Block ID: ${entry.blockId}`));
           console.log(chalk.gray(`        Title: ${entry.title}`));
         }
-        console.log('');
+        console.log("");
       }
     }
 
     // Generate named exports file and author entry files
     const mextBlockPath = findMextBlockPath();
     if (mextBlockPath) {
-      console.log(chalk.blue('🔧 Updating mext-block exports...'));
+      console.log(chalk.blue("🔧 Updating mext-block exports..."));
       await generateNamedExports(mextBlockPath, registry, authorRegistry);
       await generateAuthorEntryFiles(mextBlockPath, authorRegistry);
       console.log(chalk.green(`✅ Exports updated in ${mextBlockPath}`));
-      console.log(chalk.gray(`   Generated ${Object.keys(authorRegistry).length} author entry files`));
+      console.log(
+        chalk.gray(
+          `   Generated ${
+            Object.keys(authorRegistry).length
+          } author entry files`
+        )
+      );
     } else {
-      console.log(chalk.yellow('⚠️  mext-block package not found locally.'));
-      console.log(chalk.gray('   Named exports file not generated.'));
+      console.log(chalk.yellow("⚠️  mext-block package not found locally."));
+      console.log(chalk.gray("   Named exports file not generated."));
     }
 
-    console.log(chalk.green('\n🎉 Registry sync completed!'));
-
+    console.log(chalk.green("\n🎉 Registry sync completed!"));
   } catch (error: any) {
     console.error(chalk.red(`❌ Failed to sync registry: ${error.message}`));
     process.exit(1);
@@ -105,16 +130,21 @@ export async function syncCommand(): Promise<void> {
 function findMextBlockPath(): string | null {
   // Look for mext-block in common locations
   const possiblePaths = [
-    path.join(process.cwd(), '..', 'mext-block'),
-    path.join(process.cwd(), 'mext-block'),
-    path.join(process.cwd(), '..', '..', 'mext-block'),
+    path.join(process.cwd(), "..", "mext-block"),
+    path.join(process.cwd(), "mext-block"),
+    path.join(process.cwd(), "..", "..", "mext-block"),
   ];
 
   for (const possiblePath of possiblePaths) {
-    if (fs.existsSync(path.join(possiblePath, 'package.json'))) {
+    if (fs.existsSync(path.join(possiblePath, "package.json"))) {
       try {
-        const packageJson = JSON.parse(fs.readFileSync(path.join(possiblePath, 'package.json'), 'utf8'));
-        if (packageJson.name === '@mexty/block' || packageJson.name === '@mexty/block') {
+        const packageJson = JSON.parse(
+          fs.readFileSync(path.join(possiblePath, "package.json"), "utf8")
+        );
+        if (
+          packageJson.name === "@mexty/block" ||
+          packageJson.name === "@mexty/block"
+        ) {
           return possiblePath;
         }
       } catch (error) {
@@ -129,9 +159,13 @@ function findMextBlockPath(): string | null {
 /**
  * Generate named exports file for the mext-block package
  */
-async function generateNamedExports(mextBlockPath: string, registry: BlockRegistry, authorRegistry: AuthorNamespaceRegistry): Promise<void> {
-  const namedExportsPath = path.join(mextBlockPath, 'src', 'namedExports.ts');
-  
+async function generateNamedExports(
+  mextBlockPath: string,
+  registry: BlockRegistry,
+  authorRegistry: AuthorNamespaceRegistry
+): Promise<void> {
+  const namedExportsPath = path.join(mextBlockPath, "src", "namedExports.ts");
+
   // Generate the file content
   const content = `// Auto-generated file - DO NOT EDIT MANUALLY
 // Generated on: ${new Date().toISOString()}
@@ -142,22 +176,27 @@ import { createNamedBlock } from './components/NamedBlock';
 import { createAuthorBlock } from './components/AuthorBlock';
 
 // ===== GLOBAL NAMESPACE COMPONENTS =====
-${Object.entries(registry).map(([componentName, entry]) => 
-`// ${entry.title}${entry.author ? ` (by ${entry.author})` : ''}
+${Object.entries(registry)
+  .map(
+    ([componentName, entry]) =>
+      `// ${entry.title}${entry.author ? ` (by ${entry.author})` : ""}
 // Block ID: ${entry.blockId}
 // Description: ${entry.description}
-// Tags: ${entry.tags?.join(', ') || 'none'}
+// Tags: ${entry.tags?.join(", ") || "none"}
 export const ${componentName} = createNamedBlock('${componentName}');`
-).join('\n\n')}
+  )
+  .join("\n\n")}
 
 // Export all global components as an object for convenience
 export const NamedComponents = {
-${Object.keys(registry).map(componentName => `  ${componentName},`).join('\n')}
+${Object.keys(registry)
+  .map((componentName) => `  ${componentName},`)
+  .join("\n")}
 };
 
 // Note: Author-specific components are now available via direct imports:
 // import { ComponentName } from '@mexty/block/authorname'
-// Available authors: ${Object.keys(authorRegistry).join(', ')}
+// Available authors: ${Object.keys(authorRegistry).join(", ")}
 
 // Registry metadata
 export const registryMetadata = {
@@ -165,31 +204,40 @@ export const registryMetadata = {
   totalAuthors: ${Object.keys(authorRegistry).length},
   lastGenerated: '${new Date().toISOString()}',
   components: {
-${Object.entries(registry).map(([componentName, entry]) => 
-`    ${componentName}: {
+${Object.entries(registry)
+  .map(
+    ([componentName, entry]) =>
+      `    ${componentName}: {
       blockId: '${entry.blockId}',
       title: '${entry.title}',
       description: '${entry.description.replace(/'/g, "\\'")}',
-      author: '${entry.author || ''}',
-      tags: [${entry.tags?.map(tag => `'${tag}'`).join(', ') || ''}],
+      author: '${entry.author || ""}',
+      tags: [${entry.tags?.map((tag) => `'${tag}'`).join(", ") || ""}],
       lastUpdated: '${entry.lastUpdated}'
     },`
-).join('\n')}
+  )
+  .join("\n")}
   },
   authors: {
-${Object.entries(authorRegistry).map(([author, components]) => 
-`    ${author}: {
-${Object.entries(components).map(([componentName, entry]) => 
-`      ${componentName}: {
+${Object.entries(authorRegistry)
+  .map(
+    ([author, components]) =>
+      `    ${author}: {
+${Object.entries(components)
+  .map(
+    ([componentName, entry]) =>
+      `      ${componentName}: {
         blockId: '${entry.blockId}',
         title: '${entry.title}',
         description: '${entry.description.replace(/'/g, "\\'")}',
-        tags: [${entry.tags?.map(tag => `'${tag}'`).join(', ') || ''}],
+        tags: [${entry.tags?.map((tag) => `'${tag}'`).join(", ") || ""}],
         lastUpdated: '${entry.lastUpdated}'
       },`
-).join('\n')}
+  )
+  .join("\n")}
     },`
-).join('\n')}
+  )
+  .join("\n")}
   }
 };
 `;
@@ -201,17 +249,18 @@ ${Object.entries(components).map(([componentName, entry]) =>
   }
 
   // Write the file
-  fs.writeFileSync(namedExportsPath, content, 'utf8');
+  fs.writeFileSync(namedExportsPath, content, "utf8");
 
   // Update the main index.ts to include these exports
-  const indexPath = path.join(mextBlockPath, 'src', 'index.ts');
+  const indexPath = path.join(mextBlockPath, "src", "index.ts");
   if (fs.existsSync(indexPath)) {
-    let indexContent = fs.readFileSync(indexPath, 'utf8');
-    
+    let indexContent = fs.readFileSync(indexPath, "utf8");
+
     // Add export for named exports if not already present
-    if (!indexContent.includes('export * from \'./namedExports\'')) {
-      indexContent += '\n// Auto-generated named exports\nexport * from \'./namedExports\';\n';
-      fs.writeFileSync(indexPath, indexContent, 'utf8');
+    if (!indexContent.includes("export * from './namedExports'")) {
+      indexContent +=
+        "\n// Auto-generated named exports\nexport * from './namedExports';\n";
+      fs.writeFileSync(indexPath, indexContent, "utf8");
     }
   }
 }
@@ -219,24 +268,27 @@ ${Object.entries(components).map(([componentName, entry]) =>
 /**
  * Generate author-specific entry files for direct imports
  */
-async function generateAuthorEntryFiles(mextBlockPath: string, authorRegistry: AuthorNamespaceRegistry): Promise<void> {
-  const authorsDir = path.join(mextBlockPath, 'src', 'authors');
-  
+async function generateAuthorEntryFiles(
+  mextBlockPath: string,
+  authorRegistry: AuthorNamespaceRegistry
+): Promise<void> {
+  const authorsDir = path.join(mextBlockPath, "src", "authors");
+
   // Clean up existing author files
   if (fs.existsSync(authorsDir)) {
     fs.rmSync(authorsDir, { recursive: true, force: true });
   }
-  
+
   // Create authors directory
   fs.mkdirSync(authorsDir, { recursive: true });
-  
+
   // Generate an entry file for each author
   for (const [author, components] of Object.entries(authorRegistry)) {
     const authorDir = path.join(authorsDir, author);
     fs.mkdirSync(authorDir, { recursive: true });
-    
-    const authorEntryPath = path.join(authorDir, 'index.ts');
-    
+
+    const authorEntryPath = path.join(authorDir, "index.ts");
+
     // Generate the author's entry file content
     const content = `// Auto-generated author entry file for ${author}
 // Generated on: ${new Date().toISOString()}
@@ -244,17 +296,22 @@ async function generateAuthorEntryFiles(mextBlockPath: string, authorRegistry: A
 
 import { createAuthorBlock } from '../../components/AuthorBlock';
 
-${Object.entries(components).map(([componentName, entry]) => 
-`// ${entry.title}
+${Object.entries(components)
+  .map(
+    ([componentName, entry]) =>
+      `// ${entry.title}
 // Block ID: ${entry.blockId}
 // Description: ${entry.description}
-// Tags: ${entry.tags?.join(', ') || 'none'}
+// Tags: ${entry.tags?.join(", ") || "none"}
 export const ${componentName} = createAuthorBlock('${author}', '${componentName}');`
-).join('\n\n')}
+  )
+  .join("\n\n")}
 
 // Export all components as default for convenience
 export default {
-${Object.keys(components).map(componentName => `  ${componentName},`).join('\n')}
+${Object.keys(components)
+  .map((componentName) => `  ${componentName},`)
+  .join("\n")}
 };
 
 // Author metadata
@@ -263,22 +320,31 @@ export const authorMetadata = {
   totalComponents: ${Object.keys(components).length},
   lastGenerated: '${new Date().toISOString()}',
   components: {
-${Object.entries(components).map(([componentName, entry]) => 
-`    ${componentName}: {
+${Object.entries(components)
+  .map(
+    ([componentName, entry]) =>
+      `    ${componentName}: {
       blockId: '${entry.blockId}',
       title: '${entry.title}',
       description: '${entry.description.replace(/'/g, "\\'")}',
-      tags: [${entry.tags?.map(tag => `'${tag}'`).join(', ') || ''}],
+      tags: [${entry.tags?.map((tag) => `'${tag}'`).join(", ") || ""}],
       lastUpdated: '${entry.lastUpdated}'
     },`
-).join('\n')}
+  )
+  .join("\n")}
   }
 };
 `;
 
     // Write the author entry file
-    fs.writeFileSync(authorEntryPath, content, 'utf8');
-    
-    console.log(chalk.gray(`   Created entry file for ${author} (${Object.keys(components).length} components)`));
+    fs.writeFileSync(authorEntryPath, content, "utf8");
+
+    console.log(
+      chalk.gray(
+        `   Created entry file for ${author} (${
+          Object.keys(components).length
+        } components)`
+      )
+    );
   }
-} 
+}

package/src/index.ts

@@ -1,77 +1,91 @@
 #!/usr/bin/env node
 
-import { Command } from 'commander';
-import chalk from 'chalk';
-import { loginCommand } from './commands/login';
-import { createCommand } from './commands/create';
-import { forkCommand } from './commands/fork';
-import { deleteCommand } from './commands/delete';
-import { publishCommand } from './commands/publish';
-import { syncCommand } from './commands/sync';
-import { apiClient } from './utils/api';
+import { Command } from "commander";
+import chalk from "chalk";
+import { loginCommand } from "./commands/login";
+import { createCommand } from "./commands/create";
+import { forkCommand } from "./commands/fork";
+import { deleteCommand } from "./commands/delete";
+import { publishCommand } from "./commands/publish";
+import { syncCommand } from "./commands/sync";
+import { saveCommand } from "./commands/save";
+import { apiClient } from "./utils/api";
 
 const program = new Command();
 
 // CLI Configuration
 program
-  .name('mexty')
-  .description('MEXT CLI for managing React microfrontend blocks and components')
-  .version('1.0.0');
+  .name("mexty")
+  .description(
+    "MEXT CLI for managing React microfrontend blocks and components"
+  )
+  .version("1.0.0");
 
 // Add commands
 program
-  .command('login')
-  .description('Authenticate with MEXT')
+  .command("login")
+  .description("Authenticate with MEXT")
   .action(loginCommand);
 
 program
-  .command('logout')
-  .description('Logout from MEXT')
+  .command("logout")
+  .description("Logout from MEXT")
   .action(async () => {
     try {
       if (!apiClient.isAuthenticated()) {
-        console.log(chalk.yellow('⚠️  You are not logged in'));
+        console.log(chalk.yellow("⚠️  You are not logged in"));
         return;
       }
-      
+
       await apiClient.logout();
-      console.log(chalk.green('✅ Logged out successfully'));
+      console.log(chalk.green("✅ Logged out successfully"));
     } catch (error: any) {
       console.error(chalk.red(`❌ Logout failed: ${error.message}`));
     }
   });
 
+// Support both old and new create syntax
 program
-  .command('create <name>')
-  .description('Create a new React microfrontend block')
-  .option('-d, --description <description>', 'Block description')
-  .option('-t, --type <type>', 'Block type', 'custom')
+  .command("create [subcommand]")
+  .description("Create a new React microfrontend block")
+  .option("-d, --description <description>", "Block description")
+  .option("-t, --type <type>", "Block type", "custom")
+  .option("-n, --name <name>", 'Block name (for "create block" syntax)')
+  .option(
+    "-c, --category <category>",
+    'Block category (for "create block" syntax)'
+  )
   .action(createCommand);
 
 program
-  .command('fork <blockId>')
-  .description('Fork an existing block and clone its repository')
+  .command("fork <blockId>")
+  .description("Fork an existing block and clone its repository")
   .action(forkCommand);
 
 program
-  .command('delete <blockId>')
-  .description('Delete a block (requires ownership)')
+  .command("delete <blockId>")
+  .description("Delete a block (requires ownership)")
   .action(deleteCommand);
 
 program
-  .command('publish')
-  .description('Publish current block with automatic bundling')
+  .command("publish")
+  .description("Publish current block with automatic bundling")
   .action(publishCommand);
 
 program
-  .command('sync')
-  .description('Sync block registry and update typed exports')
+  .command("sync")
+  .description("Sync block registry and update typed exports")
   .action(syncCommand);
 
+program
+  .command("save")
+  .description("Save current block (git add, commit, push, and trigger build)")
+  .action(saveCommand);
+
 // Error handling
-program.on('command:*', () => {
-  console.error(chalk.red(`Invalid command: ${program.args.join(' ')}`));
-  console.log(chalk.yellow('See --help for a list of available commands.'));
+program.on("command:*", () => {
+  console.error(chalk.red(`Invalid command: ${program.args.join(" ")}`));
+  console.log(chalk.yellow("See --help for a list of available commands."));
   process.exit(1);
 });
 
@@ -81,4 +95,4 @@ program.parse(process.argv);
 // Show help if no command provided
 if (!process.argv.slice(2).length) {
   program.outputHelp();
-} 
+}

package/src/utils/api.ts

@@ -1,8 +1,8 @@
-import axios, { AxiosInstance, AxiosResponse } from 'axios';
-import chalk from 'chalk';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
+import axios, { AxiosInstance, AxiosResponse } from "axios";
+import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+import os from "os";
 
 export interface Block {
   _id: string;
@@ -14,13 +14,13 @@ export interface Block {
   courseName?: string;
   allowedBrickTypes: string[];
   allowedBlockTypes?: string[];
-  scope: ('library' | 'user-store' | 'published-store')[];
+  scope: ("library" | "user-store" | "published-store")[];
   content: any[];
   // Fork tracking
   forkedId?: string;
   bundlePath?: string;
   federationUrl?: string;
-  buildStatus?: 'pending' | 'building' | 'success' | 'failed';
+  buildStatus?: "pending" | "building" | "success" | "failed";
   buildError?: string;
   lastBuilt?: Date;
   createdAt: Date;
@@ -73,15 +73,15 @@ class ApiClient {
   private baseUrl: string;
   private tokenPath: string;
 
-  constructor(baseUrl: string = 'https://api.v2.mext.app') {
+  constructor(baseUrl: string = "https://api.mexty.ai") {
     this.baseUrl = baseUrl;
-    this.tokenPath = path.join(os.homedir(), '.mext', 'auth.json');
-    
+    this.tokenPath = path.join(os.homedir(), ".mext", "auth.json");
+
     this.client = axios.create({
       baseURL: baseUrl,
       timeout: 30000,
       headers: {
-        'Content-Type': 'application/json',
+        "Content-Type": "application/json",
       },
     });
 
@@ -102,13 +102,27 @@ class ApiClient {
       (response) => response,
       (error) => {
         if (error.response?.status === 401) {
-          console.error(chalk.red('Authentication required. Please login first: mexty login'));
+          console.error(
+            chalk.red(
+              "Authentication required. Please login first: mexty login"
+            )
+          );
           this.clearStoredToken();
         } else if (error.response) {
-          console.error(chalk.red(`API Error ${error.response.status}: ${error.response.data?.error || error.message}`));
+          console.error(
+            chalk.red(
+              `API Error ${error.response.status}: ${
+                error.response.data?.error || error.message
+              }`
+            )
+          );
         } else if (error.request) {
-          console.error(chalk.red('Network Error: Could not reach MEXT server'));
-          console.error(chalk.yellow(`Make sure the server is running at ${this.baseUrl}`));
+          console.error(
+            chalk.red("Network Error: Could not reach MEXT server")
+          );
+          console.error(
+            chalk.yellow(`Make sure the server is running at ${this.baseUrl}`)
+          );
         } else {
           console.error(chalk.red(`Request Error: ${error.message}`));
         }
@@ -120,7 +134,7 @@ class ApiClient {
   private getStoredToken(): string | null {
     try {
       if (fs.existsSync(this.tokenPath)) {
-        const authData = JSON.parse(fs.readFileSync(this.tokenPath, 'utf8'));
+        const authData = JSON.parse(fs.readFileSync(this.tokenPath, "utf8"));
         return authData.token || null;
       }
     } catch (error) {
@@ -135,16 +149,18 @@ class ApiClient {
       if (!fs.existsSync(authDir)) {
         fs.mkdirSync(authDir, { recursive: true });
       }
-      
+
       const authData = {
         token,
         user,
-        timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
       };
-      
+
       fs.writeFileSync(this.tokenPath, JSON.stringify(authData, null, 2));
     } catch (error: any) {
-      console.warn(chalk.yellow(`Warning: Could not store auth token: ${error.message}`));
+      console.warn(
+        chalk.yellow(`Warning: Could not store auth token: ${error.message}`)
+      );
     }
   }
 
@@ -165,7 +181,7 @@ class ApiClient {
   public getStoredUser(): any {
     try {
       if (fs.existsSync(this.tokenPath)) {
-        const authData = JSON.parse(fs.readFileSync(this.tokenPath, 'utf8'));
+        const authData = JSON.parse(fs.readFileSync(this.tokenPath, "utf8"));
         return authData.user || null;
       }
     } catch (error) {
@@ -175,12 +191,18 @@ class ApiClient {
   }
 
   async createBlock(data: CreateBlockRequest): Promise<Block> {
-    const response: AxiosResponse<Block> = await this.client.post('/api/blocks', data);
+    const response: AxiosResponse<Block> = await this.client.post(
+      "/api/blocks",
+      data
+    );
     return response.data;
   }
 
   async forkBlock(data: ForkBlockRequest): Promise<Block> {
-    const response: AxiosResponse<Block> = await this.client.post('/api/blocks/fork', data);
+    const response: AxiosResponse<Block> = await this.client.post(
+      "/api/blocks/fork",
+      data
+    );
     return response.data;
   }
 
@@ -189,18 +211,23 @@ class ApiClient {
   }
 
   async getBlock(blockId: string): Promise<Block> {
-    const response: AxiosResponse<Block> = await this.client.get(`/api/blocks/${blockId}`);
+    const response: AxiosResponse<Block> = await this.client.get(
+      `/api/blocks/${blockId}`
+    );
     return response.data;
   }
 
   async saveAndBundle(data: SaveAndBundleRequest): Promise<any> {
-    const response = await this.client.post('/api/blocks/save-and-bundle', data);
+    const response = await this.client.post(
+      "/api/blocks/save-and-bundle",
+      data
+    );
     return response.data;
   }
 
   async healthCheck(): Promise<boolean> {
     try {
-      await this.client.get('/api/health');
+      await this.client.get("/api/health");
       return true;
     } catch (error) {
       return false;
@@ -208,24 +235,30 @@ class ApiClient {
   }
 
   async requestOTP(email: string): Promise<AuthResponse> {
-    const response: AxiosResponse<AuthResponse> = await this.client.post('/api/auth/request-otp', { email });
+    const response: AxiosResponse<AuthResponse> = await this.client.post(
+      "/api/auth/request-otp",
+      { email }
+    );
     return response.data;
   }
 
   async verifyOTP(email: string, otp: string): Promise<AuthResponse> {
-    const response: AxiosResponse<AuthResponse> = await this.client.post('/api/auth/verify-otp', { email, otp });
+    const response: AxiosResponse<AuthResponse> = await this.client.post(
+      "/api/auth/verify-otp",
+      { email, otp }
+    );
     const data = response.data;
-    
+
     if (data.success && data.token && data.user) {
       this.storeToken(data.token, data.user);
     }
-    
+
     return data;
   }
 
   async logout(): Promise<void> {
     try {
-      await this.client.post('/api/auth/logout');
+      await this.client.post("/api/auth/logout");
     } catch (error) {
       // Ignore logout errors
     } finally {
@@ -239,4 +272,4 @@ class ApiClient {
   }
 }
 
-export const apiClient = new ApiClient(); 
+export const apiClient = new ApiClient();

package/src/utils/git.ts

@@ -1,13 +1,13 @@
-import simpleGit, { SimpleGit } from 'simple-git';
-import path from 'path';
-import fs from 'fs';
-import chalk from 'chalk';
+import simpleGit, { SimpleGit } from "simple-git";
+import path from "path";
+import fs from "fs";
+import chalk from "chalk";
 
 // Simple spinner implementation since ora v5 has import issues
 class SimpleSpinner {
   private message: string;
   private interval: NodeJS.Timeout | null = null;
-  private frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  private frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
   private currentFrame = 0;
 
   constructor(message: string) {
@@ -17,7 +17,9 @@ class SimpleSpinner {
   start(): this {
     process.stdout.write(this.message);
     this.interval = setInterval(() => {
-      process.stdout.write(`\r${this.frames[this.currentFrame]} ${this.message}`);
+      process.stdout.write(
+        `\r${this.frames[this.currentFrame]} ${this.message}`
+      );
       this.currentFrame = (this.currentFrame + 1) % this.frames.length;
     }, 80);
     return this;
@@ -38,7 +40,7 @@ class SimpleSpinner {
       clearInterval(this.interval);
       this.interval = null;
     }
-    process.stdout.write('\r');
+    process.stdout.write("\r");
   }
 }
 
@@ -47,7 +49,7 @@ function ora(message: string): SimpleSpinner {
 }
 
 export class GitManager {
-  private git: SimpleGit;
+  public git: SimpleGit;
 
   constructor(cwd?: string) {
     this.git = simpleGit(cwd);
@@ -68,7 +70,7 @@ export class GitManager {
 
       // Clone the repository
       await this.git.clone(repoUrl, targetDir);
-      
+
       spinner.succeed(chalk.green(`Repository cloned to ${targetDir}`));
     } catch (error: any) {
       spinner.fail(chalk.red(`Failed to clone repository: ${error.message}`));
@@ -96,7 +98,7 @@ export class GitManager {
     try {
       const git = dir ? simpleGit(dir) : this.git;
       const remotes = await git.getRemotes(true);
-      const origin = remotes.find(remote => remote.name === 'origin');
+      const origin = remotes.find((remote) => remote.name === "origin");
       return origin?.refs?.fetch || null;
     } catch (error) {
       return null;
@@ -120,23 +122,23 @@ export class GitManager {
    * Push current branch to remote
    */
   async pushToRemote(dir?: string): Promise<void> {
-    const spinner = ora('Pushing changes to remote repository...').start();
+    const spinner = ora("Pushing changes to remote repository...").start();
 
     try {
       const git = dir ? simpleGit(dir) : this.git;
-      
+
       // Get current branch
       const status = await git.status();
       const currentBranch = status.current;
 
       if (!currentBranch) {
-        throw new Error('No current branch found');
+        throw new Error("No current branch found");
       }
 
       // Push to remote
-      await git.push('origin', currentBranch);
-      
-      spinner.succeed(chalk.green('Changes pushed to remote repository'));
+      await git.push("origin", currentBranch);
+
+      spinner.succeed(chalk.green("Changes pushed to remote repository"));
     } catch (error: any) {
       spinner.fail(chalk.red(`Failed to push changes: ${error.message}`));
       throw error;
@@ -152,14 +154,14 @@ export class GitManager {
     hasChanges: boolean;
   }> {
     const git = dir ? simpleGit(dir) : this.git;
-    
+
     const status = await git.status();
     const remoteUrl = await this.getRemoteUrl(dir);
-    
+
     return {
-      branch: status.current || 'unknown',
+      branch: status.current || "unknown",
       remoteUrl,
-      hasChanges: !status.isClean()
+      hasChanges: !status.isClean(),
     };
   }
 
@@ -172,10 +174,10 @@ export class GitManager {
     if (match) {
       return match[1];
     }
-    
+
     // Fallback: use the last part of the URL
-    const parts = gitUrl.split('/');
-    return parts[parts.length - 1].replace('.git', '');
+    const parts = gitUrl.split("/");
+    return parts[parts.length - 1].replace(".git", "");
   }
 
   /**
@@ -186,9 +188,9 @@ export class GitManager {
       /^https:\/\/github\.com\/[\w\-\.]+\/[\w\-\.]+(?:\.git)?$/,
       /^git@github\.com:[\w\-\.]+\/[\w\-\.]+(?:\.git)?$/,
       /^https:\/\/gitlab\.com\/[\w\-\.]+\/[\w\-\.]+(?:\.git)?$/,
-      /^git@gitlab\.com:[\w\-\.]+\/[\w\-\.]+(?:\.git)?$/
+      /^git@gitlab\.com:[\w\-\.]+\/[\w\-\.]+(?:\.git)?$/,
     ];
 
-    return patterns.some(pattern => pattern.test(url));
+    return patterns.some((pattern) => pattern.test(url));
   }
-} 
+}