@mexty/cli 1.0.1 → 1.1.0

package/README.md

@@ -30,7 +30,7 @@ npm install -g mexty
 
 - Node.js 16+ installed
 - Git installed and configured
-- MEXT server running (default: http://localhost:3001)
+- MEXT server running (default: https://api.v2.mext.app)
 - GitHub access for repository operations
 
 ## Commands
@@ -193,7 +193,7 @@ After publishing or syncing, you can use components with full type safety:
 
 ```tsx
 // Full TypeScript support with IntelliSense
-import { MyAmazingBlock } from 'mextblock';
+import { MyAmazingBlock } from '@mexty/block';
 
 // Props are fully typed - you get autocompletion and error checking
 <MyAmazingBlock 
@@ -252,7 +252,7 @@ mexty publish  # Automatically parses props and syncs registry locally
 mexty sync
 
 # Then use in your React app with full TypeScript support
-import { TeamComponent } from 'mextblock';
+import { TeamComponent } from '@mexty/block';
 
 <TeamComponent 
   props={{
@@ -307,7 +307,7 @@ Gets converted to JSON schema automatically for runtime validation and type gene
 For advanced use cases, you can create strongly typed components:
 
 ```tsx
-import { createTypedBlock } from 'mextblock';
+import { createTypedBlock } from '@mexty/block';
 
 interface GameProps {
   level: number;
@@ -333,7 +333,7 @@ const TypedGame = createTypedBlock<GameProps>('VirtualGame', {
 
 The CLI uses the following default settings:
 
-- **Server URL**: http://localhost:3001
+- **Server URL**: https://api.v2.mext.app
 - **Timeout**: 30 seconds for API requests
 - **Props Parsing**: Automatic on publish/push
 - **Type Generation**: Automatic on sync

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mexty/cli",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "MEXT CLI for managing blocks and repositories",
   "main": "dist/index.js",
   "bin": {
@@ -12,9 +12,11 @@
     "start": "node dist/index.js"
   },
   "dependencies": {
-    "commander": "^11.1.0",
+    "@types/inquirer": "^9.0.8",
     "axios": "^1.6.0",
     "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "inquirer": "^12.6.3",
     "simple-git": "^3.20.0"
   },
   "devDependencies": {

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

@@ -30,7 +30,7 @@ export async function syncCommand(): Promise<void> {
 
     // Fetch registry from server
     console.log(chalk.yellow('📡 Fetching registry from server...'));
-    const response = await fetch('http://localhost:3001/api/blocks/registry');
+    const response = await fetch('https://api.v2.mext.app/api/blocks/registry');
     
     if (!response.ok) {
       throw new Error(`Server responded with ${response.status}: ${response.statusText}`);
@@ -114,7 +114,7 @@ function findMextBlockPath(): string | null {
     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 === 'mextblock') {
+        if (packageJson.name === '@mexty/block' || packageJson.name === '@mexty/block') {
           return possiblePath;
         }
       } catch (error) {