mlgym-deploy 2.5.0 → 2.7.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 COMPLIANCE
-const CURRENT_VERSION = '2.5.0';
+// Current version of this MCP server - INCREMENT FOR WORKFLOW FIXES
+const CURRENT_VERSION = '2.7.0';
 const PACKAGE_NAME = 'mlgym-deploy';
 
 // Version check state
@@ -353,6 +353,140 @@ 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);
@@ -395,6 +529,203 @@ async function checkExistingProject(local_path = '.') {
   }
 }
 
+// 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();
@@ -446,6 +777,122 @@ async function checkAuthStatus() {
   };
 }
 
+// Smart deployment initialization that follows the correct workflow
+async function smartDeploy(args) {
+  const { local_path = '.' } = args;
+  const absolutePath = path.resolve(local_path);
+
+  const steps = [];
+
+  try {
+    // Step 1: Check authentication
+    steps.push({ step: 'auth_check', status: 'running' });
+    const auth = await loadAuth();
+    if (!auth.token) {
+      steps[steps.length - 1].status = 'failed';
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({
+            status: 'error',
+            message: 'Not authenticated. Please use mlgym_authenticate first',
+            workflow_steps: steps
+          }, null, 2)
+        }]
+      };
+    }
+    steps[steps.length - 1].status = 'completed';
+
+    // Step 2: Analyze project
+    steps.push({ step: 'project_analysis', status: 'running' });
+    const analysis = await analyzeProject(local_path);
+    steps[steps.length - 1].status = 'completed';
+    steps[steps.length - 1].result = {
+      type: analysis.project_type,
+      framework: analysis.framework,
+      suggested_name: analysis.suggested_name
+    };
+
+    // Step 3: Check existing project
+    steps.push({ step: 'check_existing', status: 'running' });
+    const projectStatus = await checkExistingProject(local_path);
+    steps[steps.length - 1].status = 'completed';
+
+    if (projectStatus.configured) {
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({
+            status: 'info',
+            message: projectStatus.message,
+            project_name: projectStatus.name,
+            git_remote: `git@git.mlgym.io:${projectStatus.namespace}/${projectStatus.name}.git`,
+            next_steps: [
+              'Project already configured',
+              'Run: git push mlgym main'
+            ],
+            workflow_steps: steps
+          }, null, 2)
+        }]
+      };
+    }
+
+    // Step 4: Prepare project (generate Dockerfile if needed)
+    steps.push({ step: 'prepare_project', status: 'running' });
+    if (!analysis.has_dockerfile && analysis.project_type !== 'unknown') {
+      const prepResult = await prepareProject({
+        local_path,
+        project_type: analysis.project_type,
+        framework: analysis.framework,
+        package_manager: analysis.package_manager
+      });
+      steps[steps.length - 1].status = 'completed';
+      steps[steps.length - 1].result = prepResult.actions;
+    } else {
+      steps[steps.length - 1].status = 'skipped';
+      steps[steps.length - 1].result = 'Dockerfile already exists or project type unknown';
+    }
+
+    // Return analysis and next steps
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'ready',
+          message: 'Project analyzed and prepared. Ready for MLGym initialization.',
+          analysis: {
+            project_type: analysis.project_type,
+            framework: analysis.framework,
+            suggested_name: analysis.suggested_name,
+            has_dockerfile: analysis.has_dockerfile || true
+          },
+          next_step: 'Use mlgym_project_init with project details to create MLGym project',
+          suggested_params: {
+            name: analysis.suggested_name,
+            description: `${analysis.framework || analysis.project_type} application`,
+            enable_deployment: true,
+            hostname: analysis.suggested_name
+          },
+          workflow_steps: steps
+        }, null, 2)
+      }]
+    };
+
+  } catch (error) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          status: 'error',
+          message: 'Smart deploy failed',
+          error: error.message,
+          workflow_steps: steps
+        }, null, 2)
+      }]
+    };
+  }
+}
+
 // Initialize Project (requires authentication)
 async function initProject(args) {
   let { name, description, enable_deployment = true, hostname, local_path = '.' } = args;
@@ -631,9 +1078,23 @@ 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 START: Check if MLGym project exists in current directory. Call this AFTER authentication succeeds.',
+        description: 'PHASE 2: Check if MLGym project exists in current directory.',
         inputSchema: {
           type: 'object',
           properties: {
@@ -682,6 +1143,50 @@ 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'
+            }
+          }
+        }
+      },
+      {
+        name: 'mlgym_smart_deploy',
+        description: 'RECOMMENDED: Smart deployment workflow that automatically analyzes, prepares, and guides you through the entire deployment process. Use this for new projects!',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            local_path: {
+              type: 'string',
+              description: 'Local directory path (defaults to current directory)',
+              default: '.'
+            }
+          }
+        }
       }
     ]
   };
@@ -701,6 +1206,15 @@ 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 {
@@ -713,6 +1227,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       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)
+          }]
+        };
+
+      case 'mlgym_smart_deploy':
+        return await smartDeploy(args);
+
       default:
         throw new Error(`Unknown tool: ${name}`);
     }

package/package.json

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