@mexty/cli 1.0.1 → 1.1.0

package/src/utils/api.ts

@@ -1,240 +1,242 @@
-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;
-  blockType: string;
-  title: string;
-  description: string;
-  gitUrl?: string;
-  courseId?: string;
-  courseName?: string;
-  allowedBrickTypes: string[];
-  allowedBlockTypes?: string[];
-  scope: ('library' | 'user-store' | 'published-store')[];
-  content: any[];
-  bundlePath?: string;
-  federationUrl?: string;
-  buildStatus?: 'pending' | 'building' | 'success' | 'failed';
-  buildError?: string;
-  lastBuilt?: Date;
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-export interface CreateBlockRequest {
-  blockType: string;
-  title: string;
-  description: string;
-  gitUrl?: string;
-  courseId?: string;
-  courseName?: string;
-  allowedBrickTypes: string[];
-  allowedBlockTypes?: string[];
-  scope: string[];
-  content?: any[];
-}
-
-export interface ForkBlockRequest {
-  blockId: string;
-  title?: string;
-  description?: string;
-}
-
-export interface SaveAndBundleRequest {
-  blockId: string;
-}
-
-export interface AuthResponse {
-  success: boolean;
-  message: string;
-  token?: string;
-  user?: {
-    id: string;
-    email: string;
-    fullName?: string;
-    occupation?: string;
-    isProfileComplete: boolean;
-  };
-}
-
-export interface LoginRequest {
-  email: string;
-  otp: string;
-}
-
-class ApiClient {
-  private client: AxiosInstance;
-  private baseUrl: string;
-  private tokenPath: string;
-
-  constructor(baseUrl: string = 'http://localhost:3001') {
-    this.baseUrl = baseUrl;
-    this.tokenPath = path.join(os.homedir(), '.mext', 'auth.json');
-    
-    this.client = axios.create({
-      baseURL: baseUrl,
-      timeout: 30000,
-      headers: {
-        'Content-Type': 'application/json',
-      },
-    });
-
-    // Add request interceptor to include auth token
-    this.client.interceptors.request.use(
-      (config) => {
-        const token = this.getStoredToken();
-        if (token) {
-          config.headers.Authorization = `Bearer ${token}`;
-        }
-        return config;
-      },
-      (error) => Promise.reject(error)
-    );
-
-    // Add response interceptor for error handling
-    this.client.interceptors.response.use(
-      (response) => response,
-      (error) => {
-        if (error.response?.status === 401) {
-          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}`));
-        } 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}`));
-        } else {
-          console.error(chalk.red(`Request Error: ${error.message}`));
-        }
-        throw error;
-      }
-    );
-  }
-
-  private getStoredToken(): string | null {
-    try {
-      if (fs.existsSync(this.tokenPath)) {
-        const authData = JSON.parse(fs.readFileSync(this.tokenPath, 'utf8'));
-        return authData.token || null;
-      }
-    } catch (error) {
-      // Ignore errors reading token file
-    }
-    return null;
-  }
-
-  private storeToken(token: string, user: any): void {
-    try {
-      const authDir = path.dirname(this.tokenPath);
-      if (!fs.existsSync(authDir)) {
-        fs.mkdirSync(authDir, { recursive: true });
-      }
-      
-      const authData = {
-        token,
-        user,
-        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}`));
-    }
-  }
-
-  private clearStoredToken(): void {
-    try {
-      if (fs.existsSync(this.tokenPath)) {
-        fs.unlinkSync(this.tokenPath);
-      }
-    } catch (error) {
-      // Ignore errors clearing token file
-    }
-  }
-
-  public isAuthenticated(): boolean {
-    return this.getStoredToken() !== null;
-  }
-
-  public getStoredUser(): any {
-    try {
-      if (fs.existsSync(this.tokenPath)) {
-        const authData = JSON.parse(fs.readFileSync(this.tokenPath, 'utf8'));
-        return authData.user || null;
-      }
-    } catch (error) {
-      // Ignore errors reading user data
-    }
-    return null;
-  }
-
-  async createBlock(data: CreateBlockRequest): Promise<Block> {
-    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);
-    return response.data;
-  }
-
-  async deleteBlock(blockId: string): Promise<void> {
-    await this.client.delete(`/api/blocks/${blockId}`);
-  }
-
-  async getBlock(blockId: string): Promise<Block> {
-    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);
-    return response.data;
-  }
-
-  async healthCheck(): Promise<boolean> {
-    try {
-      await this.client.get('/api/health');
-      return true;
-    } catch (error) {
-      return false;
-    }
-  }
-
-  async requestOTP(email: string): Promise<AuthResponse> {
-    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 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');
-    } catch (error) {
-      // Ignore logout errors
-    } finally {
-      this.clearStoredToken();
-    }
-  }
-
-  setBaseUrl(url: string): void {
-    this.baseUrl = url;
-    this.client.defaults.baseURL = url;
-  }
-}
-
+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;
+  blockType: string;
+  title: string;
+  description: string;
+  gitUrl?: string;
+  courseId?: string;
+  courseName?: string;
+  allowedBrickTypes: string[];
+  allowedBlockTypes?: string[];
+  scope: ('library' | 'user-store' | 'published-store')[];
+  content: any[];
+  // Fork tracking
+  forkedId?: string;
+  bundlePath?: string;
+  federationUrl?: string;
+  buildStatus?: 'pending' | 'building' | 'success' | 'failed';
+  buildError?: string;
+  lastBuilt?: Date;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface CreateBlockRequest {
+  blockType: string;
+  title: string;
+  description: string;
+  gitUrl?: string;
+  courseId?: string;
+  courseName?: string;
+  allowedBrickTypes: string[];
+  allowedBlockTypes?: string[];
+  scope: string[];
+  content?: any[];
+}
+
+export interface ForkBlockRequest {
+  blockId: string;
+  title?: string;
+  description?: string;
+}
+
+export interface SaveAndBundleRequest {
+  blockId: string;
+}
+
+export interface AuthResponse {
+  success: boolean;
+  message: string;
+  token?: string;
+  user?: {
+    id: string;
+    email: string;
+    fullName?: string;
+    occupation?: string;
+    isProfileComplete: boolean;
+  };
+}
+
+export interface LoginRequest {
+  email: string;
+  otp: string;
+}
+
+class ApiClient {
+  private client: AxiosInstance;
+  private baseUrl: string;
+  private tokenPath: string;
+
+  constructor(baseUrl: string = 'https://api.v2.mext.app') {
+    this.baseUrl = baseUrl;
+    this.tokenPath = path.join(os.homedir(), '.mext', 'auth.json');
+    
+    this.client = axios.create({
+      baseURL: baseUrl,
+      timeout: 30000,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+
+    // Add request interceptor to include auth token
+    this.client.interceptors.request.use(
+      (config) => {
+        const token = this.getStoredToken();
+        if (token) {
+          config.headers.Authorization = `Bearer ${token}`;
+        }
+        return config;
+      },
+      (error) => Promise.reject(error)
+    );
+
+    // Add response interceptor for error handling
+    this.client.interceptors.response.use(
+      (response) => response,
+      (error) => {
+        if (error.response?.status === 401) {
+          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}`));
+        } 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}`));
+        } else {
+          console.error(chalk.red(`Request Error: ${error.message}`));
+        }
+        throw error;
+      }
+    );
+  }
+
+  private getStoredToken(): string | null {
+    try {
+      if (fs.existsSync(this.tokenPath)) {
+        const authData = JSON.parse(fs.readFileSync(this.tokenPath, 'utf8'));
+        return authData.token || null;
+      }
+    } catch (error) {
+      // Ignore errors reading token file
+    }
+    return null;
+  }
+
+  private storeToken(token: string, user: any): void {
+    try {
+      const authDir = path.dirname(this.tokenPath);
+      if (!fs.existsSync(authDir)) {
+        fs.mkdirSync(authDir, { recursive: true });
+      }
+      
+      const authData = {
+        token,
+        user,
+        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}`));
+    }
+  }
+
+  private clearStoredToken(): void {
+    try {
+      if (fs.existsSync(this.tokenPath)) {
+        fs.unlinkSync(this.tokenPath);
+      }
+    } catch (error) {
+      // Ignore errors clearing token file
+    }
+  }
+
+  public isAuthenticated(): boolean {
+    return this.getStoredToken() !== null;
+  }
+
+  public getStoredUser(): any {
+    try {
+      if (fs.existsSync(this.tokenPath)) {
+        const authData = JSON.parse(fs.readFileSync(this.tokenPath, 'utf8'));
+        return authData.user || null;
+      }
+    } catch (error) {
+      // Ignore errors reading user data
+    }
+    return null;
+  }
+
+  async createBlock(data: CreateBlockRequest): Promise<Block> {
+    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);
+    return response.data;
+  }
+
+  async deleteBlock(blockId: string): Promise<void> {
+    await this.client.delete(`/api/blocks/${blockId}`);
+  }
+
+  async getBlock(blockId: string): Promise<Block> {
+    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);
+    return response.data;
+  }
+
+  async healthCheck(): Promise<boolean> {
+    try {
+      await this.client.get('/api/health');
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  async requestOTP(email: string): Promise<AuthResponse> {
+    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 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');
+    } catch (error) {
+      // Ignore logout errors
+    } finally {
+      this.clearStoredToken();
+    }
+  }
+
+  setBaseUrl(url: string): void {
+    this.baseUrl = url;
+    this.client.defaults.baseURL = url;
+  }
+}
+
 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));
   }
-} 
+}

package/dist/commands/create.d.ts

@@ -1,7 +0,0 @@
-interface CreateOptions {
-    description?: string;
-    type?: string;
-}
-export declare function createCommand(name: string, options: CreateOptions): Promise<void>;
-export {};
-//# sourceMappingURL=create.d.ts.map

package/dist/commands/create.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/commands/create.ts"],"names":[],"mappings":"AAMA,UAAU,aAAa;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAmBD,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CA8DvF"}