@akash-chowdhury-24/deployhub 1.0.0

package/src/detectors/backend.detector.js

@@ -0,0 +1,304 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * @typedef {Object} BackendDetectorResult
+ * @property {'backend'} projectType
+ * @property {string} framework
+ * @property {string} language
+ * @property {string|null} buildCommand
+ * @property {string|null} startCommand
+ * @property {string} buildOutput
+ * @property {string|null} testCommand
+ * @property {boolean} hasDocker
+ * @property {number} port
+ */
+
+/** @type {Record<string, { detect: (cwd: string) => boolean, defaults: Omit<BackendDetectorResult, 'projectType'|'framework'|'hasDocker'> }>} */
+const FRAMEWORKS = {
+  nestjs: {
+    detect: (cwd) => hasPackageDep(cwd, '@nestjs/core'),
+    defaults: {
+      language: 'node',
+      buildCommand: 'nest build',
+      startCommand: 'node dist/main',
+      buildOutput: 'dist',
+      testCommand: 'npm test',
+      port: 3000,
+    },
+  },
+  express: {
+    detect: (cwd) => hasPackageDep(cwd, 'express'),
+    defaults: {
+      language: 'node',
+      buildCommand: null,
+      startCommand: 'npm start',
+      buildOutput: '.',
+      testCommand: 'npm test',
+      port: 3000,
+    },
+  },
+  fastify: {
+    detect: (cwd) => hasPackageDep(cwd, 'fastify'),
+    defaults: {
+      language: 'node',
+      buildCommand: null,
+      startCommand: 'npm start',
+      buildOutput: '.',
+      testCommand: 'npm test',
+      port: 3000,
+    },
+  },
+  koa: {
+    detect: (cwd) => hasPackageDep(cwd, 'koa'),
+    defaults: {
+      language: 'node',
+      buildCommand: null,
+      startCommand: 'npm start',
+      buildOutput: '.',
+      testCommand: 'npm test',
+      port: 3000,
+    },
+  },
+  fastapi: {
+    detect: (cwd) => fileContains(cwd, 'requirements.txt', 'fastapi'),
+    defaults: {
+      language: 'python',
+      buildCommand: null,
+      startCommand: 'uvicorn main:app --host 0.0.0.0 --port 8000',
+      buildOutput: '.',
+      testCommand: 'pytest',
+      port: 8000,
+    },
+  },
+  django: {
+    detect: (cwd) => fileContains(cwd, 'requirements.txt', 'django'),
+    defaults: {
+      language: 'python',
+      buildCommand: null,
+      startCommand: 'gunicorn config.wsgi:application --bind 0.0.0.0:8000',
+      buildOutput: '.',
+      testCommand: 'python manage.py test',
+      port: 8000,
+    },
+  },
+  flask: {
+    detect: (cwd) => fileContains(cwd, 'requirements.txt', 'flask'),
+    defaults: {
+      language: 'python',
+      buildCommand: null,
+      startCommand: 'gunicorn app:app --bind 0.0.0.0:5000',
+      buildOutput: '.',
+      testCommand: 'pytest',
+      port: 5000,
+    },
+  },
+  laravel: {
+    detect: (cwd) => hasComposerPackage(cwd, 'laravel/framework'),
+    defaults: {
+      language: 'php',
+      buildCommand: null,
+      startCommand: 'php artisan serve',
+      buildOutput: '.',
+      testCommand: 'php artisan test',
+      port: 80,
+    },
+  },
+  symfony: {
+    detect: (cwd) => hasComposerPackage(cwd, 'symfony/framework-bundle'),
+    defaults: {
+      language: 'php',
+      buildCommand: null,
+      startCommand: 'php-fpm',
+      buildOutput: '.',
+      testCommand: 'php bin/phpunit',
+      port: 80,
+    },
+  },
+  spring: {
+    detect: (cwd) => fileContains(cwd, 'pom.xml', 'spring-boot'),
+    defaults: {
+      language: 'java',
+      buildCommand: 'mvn package',
+      startCommand: 'java -jar target/*.jar',
+      buildOutput: 'target',
+      testCommand: 'mvn test',
+      port: 8080,
+    },
+  },
+  go: {
+    detect: (cwd) => fs.existsSync(path.join(cwd, 'go.mod')),
+    defaults: {
+      language: 'go',
+      buildCommand: 'go build -o bin/app .',
+      startCommand: './bin/app',
+      buildOutput: 'bin',
+      testCommand: 'go test ./...',
+      port: 8080,
+    },
+  },
+  dotnet: {
+    detect: (cwd) => {
+      try {
+        return fs.readdirSync(cwd).some((f) => f.endsWith('.csproj'));
+      } catch {
+        return false;
+      }
+    },
+    defaults: {
+      language: 'dotnet',
+      buildCommand: 'dotnet publish -c Release -o publish',
+      startCommand: 'dotnet App.dll',
+      buildOutput: 'publish',
+      testCommand: 'dotnet test',
+      port: 5000,
+    },
+  },
+  rails: {
+    detect: (cwd) => fileContains(cwd, 'Gemfile', 'rails'),
+    defaults: {
+      language: 'ruby',
+      buildCommand: 'bundle exec rake assets:precompile',
+      startCommand: 'bundle exec puma',
+      buildOutput: '.',
+      testCommand: 'bundle exec rspec',
+      port: 3000,
+    },
+  },
+};
+
+const DETECTION_ORDER = [
+  'nestjs',
+  'express',
+  'fastify',
+  'koa',
+  'fastapi',
+  'django',
+  'flask',
+  'laravel',
+  'symfony',
+  'spring',
+  'go',
+  'dotnet',
+  'rails',
+];
+
+/**
+ * @param {string} cwd
+ * @param {string} dep
+ */
+function hasPackageDep(cwd, dep) {
+  const pkgPath = path.join(cwd, 'package.json');
+  if (!fs.existsSync(pkgPath)) return false;
+  const pkg = fs.readJsonSync(pkgPath);
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  return !!deps[dep];
+}
+
+/**
+ * @param {string} cwd
+ * @param {string} filename
+ * @param {string} needle
+ */
+function fileContains(cwd, filename, needle) {
+  const filePath = path.join(cwd, filename);
+  if (!fs.existsSync(filePath)) return false;
+  const content = fs.readFileSync(filePath, 'utf-8').toLowerCase();
+  return content.includes(needle.toLowerCase());
+}
+
+/**
+ * @param {string} cwd
+ * @param {string} packageName
+ */
+function hasComposerPackage(cwd, packageName) {
+  const composerPath = path.join(cwd, 'composer.json');
+  if (!fs.existsSync(composerPath)) return false;
+  const composer = fs.readJsonSync(composerPath);
+  const deps = { ...composer.require, ...composer['require-dev'] };
+  return !!deps[packageName];
+}
+
+/**
+ * @param {string} [cwd]
+ * @returns {string|null}
+ */
+export function detectBackendFramework(cwd = process.cwd()) {
+  for (const key of DETECTION_ORDER) {
+    if (FRAMEWORKS[key].detect(cwd)) return key;
+  }
+  return null;
+}
+
+/**
+ * @param {string} framework
+ * @param {string} [cwd]
+ * @returns {BackendDetectorResult}
+ */
+export function getBackendInfo(framework, cwd = process.cwd()) {
+  const hasDocker = fs.existsSync(path.join(cwd, 'Dockerfile'));
+  const def = FRAMEWORKS[framework];
+
+  if (!def) {
+    return {
+      projectType: 'backend',
+      framework,
+      language: 'node',
+      buildCommand: null,
+      startCommand: 'npm start',
+      buildOutput: '.',
+      testCommand: 'npm test',
+      hasDocker,
+      port: 3000,
+    };
+  }
+
+  const pkgPath = path.join(cwd, 'package.json');
+  const scripts = fs.existsSync(pkgPath)
+    ? fs.readJsonSync(pkgPath).scripts || {}
+    : {};
+
+  let buildCommand = def.defaults.buildCommand;
+  let startCommand = def.defaults.startCommand;
+  let testCommand = def.defaults.testCommand;
+
+  if (def.defaults.language === 'node') {
+    if (scripts.build) buildCommand = 'npm run build';
+    if (scripts.start) startCommand = 'npm start';
+    if (scripts.test) testCommand = 'npm test';
+  }
+
+  return {
+    projectType: 'backend',
+    framework,
+    language: def.defaults.language,
+    buildCommand,
+    startCommand,
+    buildOutput: def.defaults.buildOutput,
+    testCommand,
+    hasDocker,
+    port: def.defaults.port,
+  };
+}
+
+/**
+ * @param {string} [cwd]
+ * @returns {BackendDetectorResult|null}
+ */
+export function detectBackend(cwd = process.cwd()) {
+  const framework = detectBackendFramework(cwd);
+  if (!framework) return null;
+  return getBackendInfo(framework, cwd);
+}
+
+/** @type {Record<string, BackendDetectorResult>} */
+export const BACKEND_FRAMEWORK_DEFAULTS = Object.fromEntries(
+  DETECTION_ORDER.map((key) => [key, getBackendInfo(key)])
+);
+
+export default {
+  detectBackend,
+  detectBackendFramework,
+  getBackendInfo,
+  BACKEND_FRAMEWORK_DEFAULTS,
+};

package/src/detectors/dotnet.js

@@ -0,0 +1,18 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+function detect(cwd = process.cwd()) {
+  const files = fs.readdirSync(cwd);
+  return files.some((f) => f.endsWith('.csproj') || f.endsWith('.sln'));
+}
+
+function getInfo(cwd = process.cwd()) {
+  return {
+    framework: 'dotnet',
+    buildCommand: 'dotnet build -c Release',
+    buildOutput: 'bin/Release',
+    hasDocker: fs.existsSync(path.join(cwd, 'Dockerfile')),
+  };
+}
+
+export default { detect, getInfo };

package/src/detectors/frontend.detector.js

@@ -0,0 +1,219 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * @typedef {Object} DetectorResult
+ * @property {'frontend'} projectType
+ * @property {string} framework
+ * @property {string} language
+ * @property {string|null} buildCommand
+ * @property {string|null} startCommand
+ * @property {string} buildOutput
+ * @property {string|null} testCommand
+ * @property {boolean} hasDocker
+ * @property {number} port
+ */
+
+/** @type {Record<string, { deps?: string[], files?: string[], defaults: Omit<DetectorResult, 'projectType'|'framework'|'hasDocker'> & { buildCommand: string|null, startCommand: string|null, testCommand: string|null } }>} */
+const FRAMEWORKS = {
+  nextjs: {
+    deps: ['next'],
+    defaults: {
+      language: 'node',
+      buildCommand: 'npm run build',
+      startCommand: 'npm start',
+      buildOutput: '.next',
+      testCommand: 'npm test',
+      port: 3000,
+    },
+  },
+  react: {
+    deps: ['react'],
+    excludeDeps: ['next'],
+    defaults: {
+      language: 'node',
+      buildCommand: 'npm run build',
+      startCommand: null,
+      buildOutput: 'dist',
+      testCommand: 'npm test',
+      port: 80,
+    },
+  },
+  vue: {
+    deps: ['vue'],
+    defaults: {
+      language: 'node',
+      buildCommand: 'npm run build',
+      startCommand: null,
+      buildOutput: 'dist',
+      testCommand: 'npm test',
+      port: 80,
+    },
+  },
+  angular: {
+    deps: ['@angular/core'],
+    defaults: {
+      language: 'node',
+      buildCommand: 'ng build',
+      startCommand: null,
+      buildOutput: 'dist',
+      testCommand: 'npm test',
+      port: 80,
+    },
+  },
+  svelte: {
+    deps: ['svelte'],
+    defaults: {
+      language: 'node',
+      buildCommand: 'npm run build',
+      startCommand: null,
+      buildOutput: 'public',
+      testCommand: 'npm test',
+      port: 80,
+    },
+  },
+  astro: {
+    deps: ['astro'],
+    defaults: {
+      language: 'node',
+      buildCommand: 'astro build',
+      startCommand: null,
+      buildOutput: 'dist',
+      testCommand: 'npm test',
+      port: 80,
+    },
+  },
+};
+
+const DETECTION_ORDER = ['nextjs', 'react', 'vue', 'angular', 'svelte', 'astro'];
+
+/**
+ * @param {string} cwd
+ * @returns {Record<string, string>|null}
+ */
+function readPackageDeps(cwd) {
+  const pkgPath = path.join(cwd, 'package.json');
+  if (!fs.existsSync(pkgPath)) return null;
+  const pkg = fs.readJsonSync(pkgPath);
+  return { ...pkg.dependencies, ...pkg.devDependencies };
+}
+
+/**
+ * @param {string} cwd
+ * @param {string} frameworkKey
+ * @returns {boolean}
+ */
+function matchesFramework(cwd, frameworkKey) {
+  const def = FRAMEWORKS[frameworkKey];
+  if (!def) return false;
+
+  if (def.deps) {
+    const deps = readPackageDeps(cwd);
+    if (!deps) return false;
+    if (def.excludeDeps?.some((d) => deps[d])) return false;
+    return def.deps.some((d) => deps[d]);
+  }
+
+  return false;
+}
+
+/**
+ * @param {string} cwd
+ * @returns {boolean}
+ */
+function isVanilla(cwd) {
+  if (!fs.existsSync(path.join(cwd, 'index.html'))) return false;
+  const deps = readPackageDeps(cwd);
+  if (!deps) return true;
+  const majorFrameworks = ['react', 'vue', '@angular/core', 'next', 'svelte', 'astro'];
+  return !majorFrameworks.some((d) => deps[d]);
+}
+
+/**
+ * @param {string} [cwd]
+ * @returns {string|null}
+ */
+export function detectFrontendFramework(cwd = process.cwd()) {
+  for (const key of DETECTION_ORDER) {
+    if (matchesFramework(cwd, key)) return key;
+  }
+  if (isVanilla(cwd)) return 'vanilla';
+  return null;
+}
+
+/**
+ * @param {string} framework
+ * @param {string} [cwd]
+ * @returns {DetectorResult}
+ */
+export function getFrontendInfo(framework, cwd = process.cwd()) {
+  const hasDocker = fs.existsSync(path.join(cwd, 'Dockerfile'));
+  const pkgPath = path.join(cwd, 'package.json');
+  const scripts = fs.existsSync(pkgPath)
+    ? fs.readJsonSync(pkgPath).scripts || {}
+    : {};
+
+  if (framework === 'vanilla') {
+    return {
+      projectType: 'frontend',
+      framework: 'vanilla',
+      language: 'node',
+      buildCommand: null,
+      startCommand: null,
+      buildOutput: '.',
+      testCommand: scripts.test ? 'npm test' : null,
+      hasDocker,
+      port: 80,
+    };
+  }
+
+  const def = FRAMEWORKS[framework];
+  if (!def) {
+    return {
+      projectType: 'frontend',
+      framework,
+      language: 'node',
+      buildCommand: scripts.build ? 'npm run build' : null,
+      startCommand: scripts.start ? 'npm start' : null,
+      buildOutput: 'dist',
+      testCommand: scripts.test ? 'npm test' : null,
+      hasDocker,
+      port: 80,
+    };
+  }
+
+  let buildOutput = def.defaults.buildOutput;
+  if (framework === 'react' || framework === 'vue') {
+    if (fs.existsSync(path.join(cwd, 'dist'))) buildOutput = 'dist';
+    else if (fs.existsSync(path.join(cwd, 'build'))) buildOutput = 'build';
+  }
+
+  return {
+    projectType: 'frontend',
+    framework,
+    language: def.defaults.language,
+    buildCommand: scripts.build ? `npm run build` : def.defaults.buildCommand,
+    startCommand: scripts.start ? 'npm start' : def.defaults.startCommand,
+    buildOutput,
+    testCommand: scripts.test ? 'npm test' : def.defaults.testCommand,
+    hasDocker,
+    port: def.defaults.port,
+  };
+}
+
+/**
+ * @param {string} [cwd]
+ * @returns {DetectorResult|null}
+ */
+export function detectFrontend(cwd = process.cwd()) {
+  const framework = detectFrontendFramework(cwd);
+  if (!framework) return null;
+  return getFrontendInfo(framework, cwd);
+}
+
+/** @type {Record<string, DetectorResult>} */
+export const FRONTEND_FRAMEWORK_DEFAULTS = Object.fromEntries(
+  [...DETECTION_ORDER, 'vanilla'].map((key) => [key, getFrontendInfo(key)])
+);
+
+export default { detectFrontend, detectFrontendFramework, getFrontendInfo, FRONTEND_FRAMEWORK_DEFAULTS };

package/src/detectors/go.js

@@ -0,0 +1,20 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+function detect(cwd = process.cwd()) {
+  return (
+    fs.existsSync(path.join(cwd, 'go.mod')) ||
+    fs.existsSync(path.join(cwd, 'main.go'))
+  );
+}
+
+function getInfo(cwd = process.cwd()) {
+  return {
+    framework: 'go',
+    buildCommand: 'go build -o bin/app .',
+    buildOutput: 'bin',
+    hasDocker: fs.existsSync(path.join(cwd, 'Dockerfile')),
+  };
+}
+
+export default { detect, getInfo };

package/src/detectors/index.js

@@ -0,0 +1,78 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { detectFrontend } from './frontend.detector.js';
+import { detectBackend } from './backend.detector.js';
+
+/**
+ * @typedef {Object} DetectionResult
+ * @property {'frontend'|'backend'} [projectType]
+ * @property {string} framework
+ * @property {string} [language]
+ * @property {string|null} [buildCommand]
+ * @property {string|null} [startCommand]
+ * @property {string} buildOutput
+ * @property {string|null} [testCommand]
+ * @property {boolean} hasDocker
+ * @property {number} [port]
+ */
+
+/**
+ * @param {string} [cwd]
+ * @returns {Promise<DetectionResult|null>}
+ */
+export async function detectFramework(cwd = process.cwd()) {
+  const frontend = detectFrontend(cwd);
+  if (frontend) return frontend;
+
+  const backend = detectBackend(cwd);
+  if (backend) return backend;
+
+  const legacyDetectors = [
+    (await import('./react.js')).default,
+    (await import('./vue.js')).default,
+    (await import('./angular.js')).default,
+    (await import('./nextjs.js')).default,
+    (await import('./node.js')).default,
+    (await import('./python.js')).default,
+    (await import('./php.js')).default,
+    (await import('./java.js')).default,
+    (await import('./go.js')).default,
+    (await import('./dotnet.js')).default,
+  ];
+
+  for (const detector of legacyDetectors) {
+    if (detector.detect(cwd)) {
+      const info = detector.getInfo(cwd);
+      return {
+        ...info,
+        projectType: info.framework === 'node' ? 'backend' : 'frontend',
+        language: info.framework,
+        startCommand: null,
+        testCommand: 'npm test',
+        port: 3000,
+      };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * @param {string} [cwd]
+ * @returns {Promise<DetectionResult|null>}
+ */
+export async function detectProjectType(cwd = process.cwd()) {
+  return detectFramework(cwd);
+}
+
+/**
+ * @param {string} [cwd]
+ * @returns {Promise<boolean>}
+ */
+export async function hasDockerfile(cwd = process.cwd()) {
+  return fs.pathExists(path.join(cwd, 'Dockerfile'));
+}
+
+export { detectFrontend, detectBackend };
+
+export default { detectFramework, detectProjectType, hasDockerfile, detectFrontend, detectBackend };

package/src/detectors/java.js

@@ -0,0 +1,24 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+function detect(cwd = process.cwd()) {
+  return (
+    fs.existsSync(path.join(cwd, 'pom.xml')) ||
+    fs.existsSync(path.join(cwd, 'build.gradle')) ||
+    fs.existsSync(path.join(cwd, 'build.gradle.kts'))
+  );
+}
+
+function getInfo(cwd = process.cwd()) {
+  const isGradle =
+    fs.existsSync(path.join(cwd, 'build.gradle')) ||
+    fs.existsSync(path.join(cwd, 'build.gradle.kts'));
+  return {
+    framework: 'java',
+    buildCommand: isGradle ? './gradlew build' : 'mvn package',
+    buildOutput: 'target',
+    hasDocker: fs.existsSync(path.join(cwd, 'Dockerfile')),
+  };
+}
+
+export default { detect, getInfo };

package/src/detectors/nextjs.js

@@ -0,0 +1,23 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+function detect(cwd = process.cwd()) {
+  const pkgPath = path.join(cwd, 'package.json');
+  if (!fs.existsSync(pkgPath)) return false;
+  const pkg = fs.readJsonSync(pkgPath);
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  return !!deps.next;
+}
+
+function getInfo(cwd = process.cwd()) {
+  const pkg = fs.readJsonSync(path.join(cwd, 'package.json'));
+  const scripts = pkg.scripts || {};
+  return {
+    framework: 'nextjs',
+    buildCommand: scripts.build ? 'npm run build' : 'npm run build',
+    buildOutput: '.next',
+    hasDocker: fs.existsSync(path.join(cwd, 'Dockerfile')),
+  };
+}
+
+export default { detect, getInfo };