@mexty/cli 1.1.0 → 1.3.0

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/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();