@mexty/cli 1.0.2 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mexty/cli",
-  "version": "1.0.2",
+  "version": "1.1.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/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/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));
   }
-} 
+}