mlgym-deploy 2.4.1 → 2.6.0

package/index.js

@@ -16,8 +16,8 @@ import crypto from 'crypto';
 
 const execAsync = promisify(exec);
 
-// Current version of this MCP server - INCREMENT FOR WORKFLOW FIX
-const CURRENT_VERSION = '2.4.1';
+// Current version of this MCP server - INCREMENT FOR PROJECT ANALYSIS
+const CURRENT_VERSION = '2.6.0';
 const PACKAGE_NAME = 'mlgym-deploy';
 
 // Version check state
@@ -353,6 +353,379 @@ async function authenticate(args) {
   };
 }
 
+// Analyze project to detect type, framework, and configuration
+async function analyzeProject(local_path = '.') {
+  const absolutePath = path.resolve(local_path);
+  const dirName = path.basename(absolutePath);
+
+  const analysis = {
+    project_type: 'unknown',
+    detected_files: [],
+    suggested_name: dirName.toLowerCase().replace(/[^a-z0-9-]/g, '-'),
+    has_dockerfile: false,
+    has_git: false,
+    framework: null,
+    build_command: null,
+    start_command: null,
+    package_manager: null
+  };
+
+  try {
+    // Check for git
+    try {
+      await execAsync('git status', { cwd: absolutePath });
+      analysis.has_git = true;
+    } catch {}
+
+    // Check for Dockerfile
+    try {
+      await fs.access(path.join(absolutePath, 'Dockerfile'));
+      analysis.has_dockerfile = true;
+      analysis.detected_files.push('Dockerfile');
+    } catch {}
+
+    // Check for Node.js project
+    try {
+      const packageJsonPath = path.join(absolutePath, 'package.json');
+      await fs.access(packageJsonPath);
+      const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+
+      analysis.project_type = 'nodejs';
+      analysis.detected_files.push('package.json');
+      analysis.suggested_name = packageJson.name || analysis.suggested_name;
+
+      // Detect package manager
+      try {
+        await fs.access(path.join(absolutePath, 'package-lock.json'));
+        analysis.package_manager = 'npm';
+        analysis.detected_files.push('package-lock.json');
+      } catch {
+        try {
+          await fs.access(path.join(absolutePath, 'yarn.lock'));
+          analysis.package_manager = 'yarn';
+          analysis.detected_files.push('yarn.lock');
+        } catch {
+          analysis.package_manager = 'npm'; // default
+        }
+      }
+
+      // Detect framework
+      const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+      if (deps.next) {
+        analysis.framework = 'nextjs';
+        analysis.build_command = packageJson.scripts?.build || 'npm run build';
+        analysis.start_command = packageJson.scripts?.start || 'npm start';
+      } else if (deps.express) {
+        analysis.framework = 'express';
+        analysis.start_command = packageJson.scripts?.start || 'node index.js';
+      } else if (deps.react) {
+        analysis.framework = 'react';
+        analysis.build_command = packageJson.scripts?.build || 'npm run build';
+      } else if (deps.vue) {
+        analysis.framework = 'vue';
+        analysis.build_command = packageJson.scripts?.build || 'npm run build';
+      }
+
+      // Use package.json scripts as fallback
+      if (!analysis.build_command && packageJson.scripts?.build) {
+        analysis.build_command = 'npm run build';
+      }
+      if (!analysis.start_command && packageJson.scripts?.start) {
+        analysis.start_command = 'npm start';
+      }
+    } catch {}
+
+    // Check for Python project
+    if (analysis.project_type === 'unknown') {
+      try {
+        await fs.access(path.join(absolutePath, 'requirements.txt'));
+        analysis.project_type = 'python';
+        analysis.detected_files.push('requirements.txt');
+
+        // Check for specific Python files
+        try {
+          await fs.access(path.join(absolutePath, 'app.py'));
+          analysis.framework = 'flask';
+          analysis.start_command = 'python app.py';
+          analysis.detected_files.push('app.py');
+        } catch {
+          try {
+            await fs.access(path.join(absolutePath, 'main.py'));
+            analysis.framework = 'fastapi';
+            analysis.start_command = 'uvicorn main:app --host 0.0.0.0';
+            analysis.detected_files.push('main.py');
+          } catch {}
+        }
+      } catch {}
+    }
+
+    // Check for static HTML project
+    if (analysis.project_type === 'unknown') {
+      try {
+        await fs.access(path.join(absolutePath, 'index.html'));
+        analysis.project_type = 'static';
+        analysis.framework = 'html';
+        analysis.detected_files.push('index.html');
+      } catch {}
+    }
+
+    // Check for Go project
+    if (analysis.project_type === 'unknown') {
+      try {
+        await fs.access(path.join(absolutePath, 'go.mod'));
+        analysis.project_type = 'go';
+        analysis.detected_files.push('go.mod');
+        analysis.build_command = 'go build -o app';
+        analysis.start_command = './app';
+      } catch {}
+    }
+
+  } catch (error) {
+    console.error('Project analysis error:', error);
+  }
+
+  return analysis;
+}
+
+// Check for existing MLGym project in current directory
+async function checkExistingProject(local_path = '.') {
+  const absolutePath = path.resolve(local_path);
+
+  // Check for git repository
+  try {
+    const { stdout: remotes } = await execAsync('git remote -v', { cwd: absolutePath });
+
+    // Check for mlgym remote
+    if (remotes.includes('mlgym') && remotes.includes('git.mlgym.io')) {
+      // Extract project info from remote URL
+      const match = remotes.match(/mlgym\s+git@git\.mlgym\.io:([^\/]+)\/([^\.]+)\.git/);
+      if (match) {
+        const [, namespace, projectName] = match;
+        return {
+          exists: true,
+          name: projectName,
+          namespace: namespace,
+          configured: true,
+          message: `Project '${projectName}' already configured for MLGym deployment`
+        };
+      }
+    }
+
+    // Git repo exists but no mlgym remote
+    return {
+      exists: false,
+      has_git: true,
+      configured: false,
+      message: 'Git repository exists but no MLGym remote configured'
+    };
+  } catch {
+    // No git repository
+    return {
+      exists: false,
+      has_git: false,
+      configured: false,
+      message: 'No git repository found in current directory'
+    };
+  }
+}
+
+// Generate appropriate Dockerfile based on project type
+function generateDockerfile(projectType, framework, packageManager = 'npm') {
+  let dockerfile = '';
+
+  if (projectType === 'nodejs') {
+    if (framework === 'nextjs') {
+      dockerfile = `# Build stage
+FROM node:18-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN ${packageManager} ${packageManager === 'npm' ? 'ci' : 'install --frozen-lockfile'}
+COPY . .
+RUN ${packageManager} run build
+
+# Production stage
+FROM node:18-alpine
+WORKDIR /app
+COPY --from=builder /app/.next ./.next
+COPY --from=builder /app/node_modules ./node_modules
+COPY --from=builder /app/package.json ./
+COPY --from=builder /app/public ./public
+EXPOSE 3000
+CMD ["${packageManager}", "start"]`;
+    } else if (framework === 'express') {
+      dockerfile = `FROM node:18-alpine
+WORKDIR /app
+COPY package*.json ./
+RUN ${packageManager} ${packageManager === 'npm' ? 'ci --only=production' : 'install --frozen-lockfile --production'}
+COPY . .
+EXPOSE 3000
+CMD ["node", "index.js"]`;
+    } else if (framework === 'react' || framework === 'vue') {
+      dockerfile = `# Build stage
+FROM node:18-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN ${packageManager} ${packageManager === 'npm' ? 'ci' : 'install --frozen-lockfile'}
+COPY . .
+RUN ${packageManager} run build
+
+# Production stage
+FROM nginx:alpine
+COPY --from=builder /app/${framework === 'react' ? 'build' : 'dist'} /usr/share/nginx/html
+EXPOSE 80
+CMD ["nginx", "-g", "daemon off;"]`;
+    } else {
+      // Generic Node.js
+      dockerfile = `FROM node:18-alpine
+WORKDIR /app
+COPY package*.json ./
+RUN ${packageManager} ${packageManager === 'npm' ? 'ci --only=production' : 'install --frozen-lockfile --production'}
+COPY . .
+EXPOSE 3000
+CMD ["${packageManager}", "start"]`;
+    }
+  } else if (projectType === 'python') {
+    if (framework === 'flask') {
+      dockerfile = `FROM python:3.11-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+EXPOSE 5000
+CMD ["python", "app.py"]`;
+    } else if (framework === 'fastapi') {
+      dockerfile = `FROM python:3.11-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+EXPOSE 8000
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]`;
+    } else {
+      // Generic Python
+      dockerfile = `FROM python:3.11-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+EXPOSE 8000
+CMD ["python", "main.py"]`;
+    }
+  } else if (projectType === 'static') {
+    dockerfile = `FROM nginx:alpine
+COPY . /usr/share/nginx/html
+EXPOSE 80
+CMD ["nginx", "-g", "daemon off;"]`;
+  } else if (projectType === 'go') {
+    dockerfile = `# Build stage
+FROM golang:1.21-alpine AS builder
+WORKDIR /app
+COPY go.mod go.sum ./
+RUN go mod download
+COPY . .
+RUN go build -o app
+
+# Production stage
+FROM alpine:latest
+RUN apk --no-cache add ca-certificates
+WORKDIR /root/
+COPY --from=builder /app/app .
+EXPOSE 8080
+CMD ["./app"]`;
+  } else {
+    // Unknown type - basic Alpine with shell
+    dockerfile = `FROM alpine:latest
+WORKDIR /app
+COPY . .
+RUN echo "Unknown project type - please configure manually"
+CMD ["/bin/sh"]`;
+  }
+
+  return dockerfile;
+}
+
+// Prepare project for deployment
+async function prepareProject(args) {
+  const { local_path = '.', project_type, framework, package_manager } = args;
+  const absolutePath = path.resolve(local_path);
+
+  const actions = [];
+
+  try {
+    // Check if Dockerfile exists
+    const dockerfilePath = path.join(absolutePath, 'Dockerfile');
+    let dockerfileExists = false;
+
+    try {
+      await fs.access(dockerfilePath);
+      dockerfileExists = true;
+      actions.push('Dockerfile already exists - skipping generation');
+    } catch {}
+
+    // Generate Dockerfile if missing
+    if (!dockerfileExists && project_type !== 'unknown') {
+      const dockerfile = generateDockerfile(project_type, framework, package_manager);
+      await fs.writeFile(dockerfilePath, dockerfile);
+      actions.push(`Generated Dockerfile for ${project_type}/${framework || 'generic'}`);
+    }
+
+    // Check/create .gitignore
+    const gitignorePath = path.join(absolutePath, '.gitignore');
+    let gitignoreExists = false;
+
+    try {
+      await fs.access(gitignorePath);
+      gitignoreExists = true;
+    } catch {}
+
+    if (!gitignoreExists) {
+      let gitignoreContent = '';
+
+      if (project_type === 'nodejs') {
+        gitignoreContent = `node_modules/
+.env
+.env.local
+dist/
+build/
+.next/
+*.log`;
+      } else if (project_type === 'python') {
+        gitignoreContent = `__pycache__/
+*.py[cod]
+*$py.class
+.env
+venv/
+env/
+.venv/`;
+      } else {
+        gitignoreContent = `.env
+*.log
+.DS_Store`;
+      }
+
+      await fs.writeFile(gitignorePath, gitignoreContent);
+      actions.push('Created .gitignore file');
+    }
+
+    return {
+      status: 'success',
+      message: 'Project prepared for deployment',
+      actions: actions,
+      dockerfile_created: !dockerfileExists && project_type !== 'unknown',
+      project_type: project_type,
+      framework: framework
+    };
+
+  } catch (error) {
+    return {
+      status: 'error',
+      message: 'Failed to prepare project',
+      error: error.message,
+      actions: actions
+    };
+  }
+}
+
 // Check authentication status
 async function checkAuthStatus() {
   const auth = await loadAuth();
@@ -548,7 +921,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
     tools: [
       {
         name: 'mlgym_auth_status',
-        description: 'Check if you are authenticated. Always call this first to see if authentication is needed.',
+        description: 'ALWAYS CALL THIS FIRST! Check authentication status before any other operation.',
         inputSchema: {
           type: 'object',
           properties: {}
@@ -556,7 +929,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       },
       {
         name: 'mlgym_authenticate',
-        description: 'Step 1: Authenticate with MLGym. Just provide email and password. For new users, optionally set create_if_not_exists=true with full_name.',
+        description: 'PHASE 1: Authentication ONLY. Get email, password, and existing account status in ONE interaction. Never ask for project details here!',
         inputSchema: {
           type: 'object',
           properties: {
@@ -589,9 +962,37 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           required: ['email', 'password']
         }
       },
+      {
+        name: 'mlgym_project_analyze',
+        description: 'PHASE 2: Analyze project to detect type, framework, and configuration. Call BEFORE creating project.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            local_path: {
+              type: 'string',
+              description: 'Local directory path (defaults to current directory)',
+              default: '.'
+            }
+          }
+        }
+      },
+      {
+        name: 'mlgym_project_status',
+        description: 'PHASE 2: Check if MLGym project exists in current directory.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            local_path: {
+              type: 'string',
+              description: 'Local directory path (defaults to current directory)',
+              default: '.'
+            }
+          }
+        }
+      },
       {
         name: 'mlgym_project_init',
-        description: 'Step 2: After authentication, create project. Provide name, description, and optionally hostname for deployment.',
+        description: 'PHASE 2: Create project ONLY after checking project status. Never ask for email/password here - only project details!',
         inputSchema: {
           type: 'object',
           properties: {
@@ -626,6 +1027,36 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           },
           required: ['name', 'description']
         }
+      },
+      {
+        name: 'mlgym_project_prepare',
+        description: 'PHASE 2: Prepare project for deployment by generating Dockerfile and config files.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            local_path: {
+              type: 'string',
+              description: 'Local directory path (defaults to current directory)',
+              default: '.'
+            },
+            project_type: {
+              type: 'string',
+              description: 'Project type from analysis',
+              enum: ['nodejs', 'python', 'static', 'go', 'unknown']
+            },
+            framework: {
+              type: 'string',
+              description: 'Framework from analysis',
+              enum: ['nextjs', 'express', 'react', 'vue', 'flask', 'fastapi', 'html', null]
+            },
+            package_manager: {
+              type: 'string',
+              description: 'Package manager for Node.js projects',
+              enum: ['npm', 'yarn'],
+              default: 'npm'
+            }
+          }
+        }
       }
     ]
   };
@@ -645,9 +1076,36 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case 'mlgym_authenticate':
         return await authenticate(args);
 
+      case 'mlgym_project_analyze':
+        const analysis = await analyzeProject(args.local_path);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(analysis, null, 2)
+          }]
+        };
+
+      case 'mlgym_project_status':
+        const projectStatus = await checkExistingProject(args.local_path);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(projectStatus, null, 2)
+          }]
+        };
+
       case 'mlgym_project_init':
         return await initProject(args);
 
+      case 'mlgym_project_prepare':
+        const prepResult = await prepareProject(args);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(prepResult, null, 2)
+          }]
+        };
+
       default:
         throw new Error(`Unknown tool: ${name}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mlgym-deploy",
-  "version": "2.4.1",
+  "version": "2.6.0",
   "description": "MCP server for GitLab Backend - User creation and project deployment",
   "main": "index.js",
   "type": "module",