cistack 1.0.0

package/src/detectors/hosting.js

@@ -0,0 +1,256 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Detects hosting platforms from config files, package.json deps, and directory structure.
+ * Each result: { name, confidence (0–1), deployCommand, secrets, notes }
+ */
+class HostingDetector {
+  constructor(projectPath, codebaseInfo) {
+    this.root = projectPath;
+    this.info = codebaseInfo;
+    this.pkg = codebaseInfo.packageJson || {};
+    this.deps = {
+      ...((this.pkg.dependencies) || {}),
+      ...((this.pkg.devDependencies) || {}),
+    };
+    this.scripts = this.pkg.scripts || {};
+    this.configs = new Set(codebaseInfo.configFiles);
+    this.files = new Set(codebaseInfo.files);
+  }
+
+  async detect() {
+    const results = [];
+
+    const checks = [
+      this._checkFirebase(),
+      this._checkVercel(),
+      this._checkNetlify(),
+      this._checkRender(),
+      this._checkRailway(),
+      this._checkHeroku(),
+      this._checkGCPAppEngine(),
+      this._checkAWS(),
+      this._checkAzure(),
+      this._checkGitHubPages(),
+      this._checkDocker(),
+    ];
+
+    for (const result of checks) {
+      if (result && result.confidence > 0) {
+        results.push(result);
+      }
+    }
+
+    // Sort by confidence descending
+    results.sort((a, b) => b.confidence - a.confidence);
+
+    // De-duplicate by name
+    const seen = new Set();
+    return results.filter((r) => {
+      if (seen.has(r.name)) return false;
+      seen.add(r.name);
+      return true;
+    });
+  }
+
+  // ── individual checks ─────────────────────────────────────────────────────
+
+  _checkFirebase() {
+    let confidence = 0;
+    const notes = [];
+
+    if (this.configs.has('firebase.json')) { confidence += 0.6; notes.push('firebase.json found'); }
+    if (this.configs.has('.firebaserc')) { confidence += 0.3; notes.push('.firebaserc found'); }
+    if (this.deps['firebase-tools'] || this.deps['firebase']) { confidence += 0.2; notes.push('firebase dep'); }
+    if (Object.values(this.scripts).some((s) => s.includes('firebase deploy'))) { confidence += 0.3; notes.push('deploy script'); }
+    if (this.info.srcStructure.hasFunctions) { confidence += 0.1; }
+
+    // Detect what Firebase services are used
+    let deployTarget = 'hosting';
+    try {
+      const fbJson = JSON.parse(fs.readFileSync(path.join(this.root, 'firebase.json'), 'utf8'));
+      const services = [];
+      if (fbJson.hosting) services.push('hosting');
+      if (fbJson.functions) services.push('functions');
+      if (fbJson.firestore) services.push('firestore');
+      if (fbJson.storage) services.push('storage');
+      deployTarget = services.join(',') || 'hosting';
+    } catch (_) {}
+
+    return {
+      name: 'Firebase',
+      confidence: Math.min(confidence, 1),
+      deployCommand: `firebase deploy --only ${deployTarget}`,
+      secrets: ['FIREBASE_TOKEN'],
+      notes,
+      buildStep: this._detectBuildScript(),
+    };
+  }
+
+  _checkVercel() {
+    let confidence = 0;
+    const notes = [];
+
+    if (this.configs.has('vercel.json')) { confidence += 0.7; notes.push('vercel.json found'); }
+    if (this.configs.has('.vercel')) { confidence += 0.4; notes.push('.vercel dir found'); }
+    if (this.deps['vercel']) { confidence += 0.3; notes.push('vercel dep'); }
+    if (Object.values(this.scripts).some((s) => s.includes('vercel'))) { confidence += 0.3; notes.push('vercel script'); }
+
+    return {
+      name: 'Vercel',
+      confidence: Math.min(confidence, 1),
+      deployCommand: 'vercel --prod --token $VERCEL_TOKEN',
+      secrets: ['VERCEL_TOKEN', 'VERCEL_ORG_ID', 'VERCEL_PROJECT_ID'],
+      notes,
+      buildStep: this._detectBuildScript(),
+    };
+  }
+
+  _checkNetlify() {
+    let confidence = 0;
+    const notes = [];
+
+    if (this.configs.has('netlify.toml')) { confidence += 0.7; notes.push('netlify.toml found'); }
+    if (this.configs.has('_redirects')) { confidence += 0.2; notes.push('_redirects found'); }
+    if (this.deps['netlify-cli'] || this.deps['netlify']) { confidence += 0.3; notes.push('netlify dep'); }
+    if (Object.values(this.scripts).some((s) => s.includes('netlify'))) { confidence += 0.3; notes.push('netlify script'); }
+
+    let publishDir = 'dist';
+    try {
+      const toml = fs.readFileSync(path.join(this.root, 'netlify.toml'), 'utf8');
+      const match = toml.match(/publish\s*=\s*["']?([^"'\n]+)/);
+      if (match) publishDir = match[1].trim();
+    } catch (_) {}
+
+    return {
+      name: 'Netlify',
+      confidence: Math.min(confidence, 1),
+      deployCommand: `netlify deploy --prod --dir=${publishDir}`,
+      secrets: ['NETLIFY_AUTH_TOKEN', 'NETLIFY_SITE_ID'],
+      notes,
+      publishDir,
+      buildStep: this._detectBuildScript(),
+    };
+  }
+
+  _checkRender() {
+    let confidence = 0;
+    if (this.configs.has('render.yaml')) { confidence += 0.8; }
+    return {
+      name: 'Render',
+      confidence,
+      deployCommand: 'curl -X POST $RENDER_DEPLOY_HOOK_URL',
+      secrets: ['RENDER_DEPLOY_HOOK_URL'],
+      notes: ['render.yaml detected'],
+    };
+  }
+
+  _checkRailway() {
+    let confidence = 0;
+    if (this.configs.has('railway.json') || this.configs.has('railway.toml')) confidence += 0.8;
+    if (this.deps['@railway/cli']) confidence += 0.2;
+    return {
+      name: 'Railway',
+      confidence,
+      deployCommand: 'railway up',
+      secrets: ['RAILWAY_TOKEN'],
+      notes: [],
+    };
+  }
+
+  _checkHeroku() {
+    let confidence = 0;
+    if (this.configs.has('Procfile')) { confidence += 0.5; }
+    if (this.configs.has('heroku.yml')) { confidence += 0.5; }
+    if (this.deps['heroku']) { confidence += 0.2; }
+    return {
+      name: 'Heroku',
+      confidence,
+      deployCommand: 'git push heroku main',
+      secrets: ['HEROKU_API_KEY', 'HEROKU_APP_NAME'],
+      notes: [],
+    };
+  }
+
+  _checkGCPAppEngine() {
+    let confidence = 0;
+    if (this.configs.has('app.yaml')) { confidence += 0.7; }
+    if (this.deps['@google-cloud/functions-framework']) confidence += 0.2;
+    return {
+      name: 'GCP App Engine',
+      confidence,
+      deployCommand: 'gcloud app deploy',
+      secrets: ['GCP_PROJECT_ID', 'GCP_SA_KEY'],
+      notes: [],
+    };
+  }
+
+  _checkAWS() {
+    let confidence = 0;
+    if (this.configs.has('appspec.yml')) confidence += 0.5;
+    if (this.configs.has('serverless.yml') || this.configs.has('serverless.yaml')) confidence += 0.6;
+    if (this.configs.has('cdk.json')) confidence += 0.4;
+    if (this.deps['aws-sdk'] || this.deps['@aws-sdk/client-s3']) confidence += 0.15;
+    return {
+      name: 'AWS',
+      confidence: Math.min(confidence, 1),
+      deployCommand: 'aws s3 sync ./dist s3://$AWS_S3_BUCKET --delete',
+      secrets: ['AWS_ACCESS_KEY_ID', 'AWS_SECRET_ACCESS_KEY', 'AWS_REGION'],
+      notes: [],
+    };
+  }
+
+  _checkAzure() {
+    let confidence = 0;
+    if (this.files.has('.azure/pipelines.yml')) confidence += 0.5;
+    if (this.deps['@azure/core-http']) confidence += 0.2;
+    return {
+      name: 'Azure',
+      confidence,
+      deployCommand: 'az webapp up',
+      secrets: ['AZURE_CREDENTIALS'],
+      notes: [],
+    };
+  }
+
+  _checkGitHubPages() {
+    let confidence = 0;
+    const pkgHomepage = this.pkg.homepage || '';
+    if (pkgHomepage.includes('github.io')) { confidence += 0.6; }
+    if (this.deps['gh-pages']) { confidence += 0.4; }
+    if (Object.values(this.scripts).some((s) => s.includes('gh-pages'))) confidence += 0.3;
+    return {
+      name: 'GitHub Pages',
+      confidence: Math.min(confidence, 1),
+      deployCommand: null, // handled by actions/deploy-pages
+      secrets: [],
+      notes: [],
+      buildStep: this._detectBuildScript(),
+    };
+  }
+
+  _checkDocker() {
+    let confidence = 0;
+    if (this.configs.has('Dockerfile')) confidence += 0.5;
+    if (this.configs.has('docker-compose.yml') || this.configs.has('docker-compose.yaml')) confidence += 0.3;
+    return {
+      name: 'Docker',
+      confidence,
+      deployCommand: 'docker push $DOCKER_IMAGE',
+      secrets: ['DOCKER_USERNAME', 'DOCKER_PASSWORD'],
+      notes: [],
+    };
+  }
+
+  _detectBuildScript() {
+    const scripts = this.pkg.scripts || {};
+    if (scripts.build) return `npm run build`;
+    if (scripts['build:prod']) return `npm run build:prod`;
+    return null;
+  }
+}
+
+module.exports = HostingDetector;

package/src/detectors/language.js

@@ -0,0 +1,116 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+
+const EXT_MAP = {
+  '.ts': 'TypeScript',
+  '.tsx': 'TypeScript',
+  '.js': 'JavaScript',
+  '.jsx': 'JavaScript',
+  '.mjs': 'JavaScript',
+  '.py': 'Python',
+  '.rb': 'Ruby',
+  '.go': 'Go',
+  '.rs': 'Rust',
+  '.java': 'Java',
+  '.kt': 'Kotlin',
+  '.scala': 'Scala',
+  '.php': 'PHP',
+  '.cs': 'C#',
+  '.cpp': 'C++',
+  '.c': 'C',
+  '.swift': 'Swift',
+  '.dart': 'Dart',
+  '.ex': 'Elixir',
+  '.exs': 'Elixir',
+  '.hs': 'Haskell',
+  '.clj': 'Clojure',
+  '.r': 'R',
+  '.R': 'R',
+  '.lua': 'Lua',
+  '.jl': 'Julia',
+};
+
+class LanguageDetector {
+  constructor(projectPath, codebaseInfo) {
+    this.root = projectPath;
+    this.info = codebaseInfo;
+  }
+
+  async detect() {
+    const counts = {};
+
+    for (const file of this.info.files) {
+      const ext = path.extname(file).toLowerCase();
+      const lang = EXT_MAP[ext] || EXT_MAP[path.extname(file)];
+      if (lang) {
+        counts[lang] = (counts[lang] || 0) + 1;
+      }
+    }
+
+    // Package manager hints
+    const pkg = this.info.packageJson;
+    if (pkg) counts['JavaScript'] = (counts['JavaScript'] || 0) + 5;
+
+    const results = Object.entries(counts)
+      .map(([name, fileCount]) => ({
+        name,
+        fileCount,
+        confidence: Math.min(fileCount / 10, 1),
+        packageManager: this._packageManager(name),
+        nodeVersion: this._nodeVersion(name),
+      }))
+      .sort((a, b) => b.fileCount - a.fileCount);
+
+    // Normalise: if TS is present, suppress JS unless JS files are dominant
+    const hasTS = results.find((r) => r.name === 'TypeScript');
+    const hasJS = results.find((r) => r.name === 'JavaScript');
+    if (hasTS && hasJS && hasTS.fileCount >= hasJS.fileCount * 0.3) {
+      return results.filter((r) => r.name !== 'JavaScript');
+    }
+
+    return results;
+  }
+
+  _packageManager(lang) {
+    const lockFiles = this.info.lockFiles;
+    if (lang === 'JavaScript' || lang === 'TypeScript') {
+      if (lockFiles.includes('pnpm-lock.yaml')) return 'pnpm';
+      if (lockFiles.includes('yarn.lock')) return 'yarn';
+      if (lockFiles.includes('bun.lockb')) return 'bun';
+      return 'npm';
+    }
+    if (lang === 'Python') {
+      if (lockFiles.includes('poetry.lock')) return 'poetry';
+      if (lockFiles.includes('Pipfile.lock')) return 'pipenv';
+      return 'pip';
+    }
+    if (lang === 'Ruby') return 'bundler';
+    if (lang === 'Go') return 'go mod';
+    if (lang === 'Rust') return 'cargo';
+    if (lang === 'Java') {
+      if (fs.existsSync(path.join(this.root, 'pom.xml'))) return 'maven';
+      return 'gradle';
+    }
+    if (lang === 'PHP') return 'composer';
+    return null;
+  }
+
+  _nodeVersion(lang) {
+    if (lang !== 'JavaScript' && lang !== 'TypeScript') return null;
+    const pkg = this.info.packageJson;
+    if (pkg && pkg.engines && pkg.engines.node) {
+      const match = pkg.engines.node.match(/(\d+)/);
+      if (match) return match[1];
+    }
+    try {
+      const nvmrc = fs.readFileSync(path.join(this.root, '.nvmrc'), 'utf8').trim();
+      const match = nvmrc.match(/(\d+)/);
+      if (match) return match[1];
+    } catch (_) {}
+    return '20';
+  }
+}
+
+module.exports = LanguageDetector;

package/src/detectors/testing.js

@@ -0,0 +1,137 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+class TestingDetector {
+  constructor(projectPath, codebaseInfo) {
+    this.root = projectPath;
+    this.info = codebaseInfo;
+    this.pkg = codebaseInfo.packageJson || {};
+    this.deps = {
+      ...(this.pkg.dependencies || {}),
+      ...(this.pkg.devDependencies || {}),
+    };
+    this.scripts = this.pkg.scripts || {};
+    this.configs = new Set(codebaseInfo.configFiles);
+    this.files = new Set(codebaseInfo.files);
+  }
+
+  async detect() {
+    const results = [];
+
+    const checks = [
+      this._checkJest(),
+      this._checkVitest(),
+      this._checkMocha(),
+      this._checkCypress(),
+      this._checkPlaywright(),
+      this._checkStorybook(),
+      this._checkPytest(),
+      this._checkRspec(),
+      this._checkGo(),
+      this._checkCargo(),
+      this._checkPHPUnit(),
+      this._checkJUnit(),
+    ];
+
+    for (const c of checks) {
+      if (c && c.confidence > 0) results.push(c);
+    }
+
+    return results.sort((a, b) => b.confidence - a.confidence);
+  }
+
+  _checkJest() {
+    let conf = 0;
+    if (this.deps['jest'] || this.deps['@jest/core']) conf += 0.5;
+    if (this.configs.has('jest.config.js') || this.configs.has('jest.config.ts')) conf += 0.4;
+    if (this.scripts.test && this.scripts.test.includes('jest')) conf += 0.2;
+    return { name: 'Jest', confidence: Math.min(conf, 1), command: this._testScript('jest') || 'npx jest --coverage', type: 'unit' };
+  }
+
+  _checkVitest() {
+    let conf = 0;
+    if (this.deps['vitest']) conf += 0.6;
+    if (this.configs.has('vitest.config.js') || this.configs.has('vitest.config.ts')) conf += 0.4;
+    return { name: 'Vitest', confidence: Math.min(conf, 1), command: this._testScript('vitest') || 'npx vitest run --coverage', type: 'unit' };
+  }
+
+  _checkMocha() {
+    let conf = 0;
+    if (this.deps['mocha']) conf += 0.5;
+    if (this.configs.has('.mocharc.js') || this.configs.has('.mocharc.yml')) conf += 0.4;
+    return { name: 'Mocha', confidence: Math.min(conf, 1), command: 'npx mocha', type: 'unit' };
+  }
+
+  _checkCypress() {
+    let conf = 0;
+    if (this.deps['cypress']) conf += 0.6;
+    if (this.configs.has('cypress.config.js') || this.configs.has('cypress.config.ts')) conf += 0.4;
+    if (this.files.has('cypress/e2e') || [...this.files].some((f) => f.startsWith('cypress/'))) conf += 0.2;
+    return { name: 'Cypress', confidence: Math.min(conf, 1), command: 'npx cypress run', type: 'e2e' };
+  }
+
+  _checkPlaywright() {
+    let conf = 0;
+    if (this.deps['@playwright/test']) conf += 0.6;
+    if (this.configs.has('playwright.config.js') || this.configs.has('playwright.config.ts')) conf += 0.4;
+    return { name: 'Playwright', confidence: Math.min(conf, 1), command: 'npx playwright test', type: 'e2e' };
+  }
+
+  _checkStorybook() {
+    let conf = 0;
+    if (this.deps['@storybook/react'] || this.deps['@storybook/vue3'] || this.deps['storybook']) conf += 0.6;
+    const hasStories = [...this.files].some((f) => f.endsWith('.stories.tsx') || f.endsWith('.stories.jsx') || f.endsWith('.stories.ts') || f.endsWith('.stories.js'));
+    if (hasStories) conf += 0.3;
+    return { name: 'Storybook', confidence: Math.min(conf, 1), command: 'npx storybook build', type: 'visual' };
+  }
+
+  _checkPytest() {
+    let conf = 0;
+    const reqPath = path.join(this.root, 'requirements.txt');
+    if (fs.existsSync(reqPath) && fs.readFileSync(reqPath, 'utf8').toLowerCase().includes('pytest')) conf += 0.6;
+    if (this.files.has('pytest.ini') || this.files.has('conftest.py') || this.configs.has('conftest.py')) conf += 0.3;
+    const pyprojectPath = path.join(this.root, 'pyproject.toml');
+    if (fs.existsSync(pyprojectPath) && fs.readFileSync(pyprojectPath, 'utf8').includes('pytest')) conf += 0.3;
+    return { name: 'Pytest', confidence: Math.min(conf, 1), command: 'pytest --cov', type: 'unit', isPython: true };
+  }
+
+  _checkRspec() {
+    const gemfilePath = path.join(this.root, 'Gemfile');
+    if (!fs.existsSync(gemfilePath)) return { name: 'RSpec', confidence: 0 };
+    const content = fs.readFileSync(gemfilePath, 'utf8').toLowerCase();
+    const conf = content.includes('rspec') ? 0.9 : 0;
+    return { name: 'RSpec', confidence: conf, command: 'bundle exec rspec', type: 'unit', isRuby: true };
+  }
+
+  _checkGo() {
+    const conf = this.info.lockFiles.includes('go.sum') ? 0.9 : 0;
+    return { name: 'Go Test', confidence: conf, command: 'go test ./... -coverprofile=coverage.out', type: 'unit', isGo: true };
+  }
+
+  _checkCargo() {
+    const cargoPath = path.join(this.root, 'Cargo.toml');
+    const conf = fs.existsSync(cargoPath) ? 0.9 : 0;
+    return { name: 'Cargo Test', confidence: conf, command: 'cargo test', type: 'unit', isRust: true };
+  }
+
+  _checkPHPUnit() {
+    const conf = this.configs.has('phpunit.xml') ? 0.9 : 0;
+    return { name: 'PHPUnit', confidence: conf, command: 'vendor/bin/phpunit', type: 'unit', isPHP: true };
+  }
+
+  _checkJUnit() {
+    const conf = fs.existsSync(path.join(this.root, 'pom.xml')) ? 0.6 : 0;
+    return { name: 'JUnit', confidence: conf, command: 'mvn test', type: 'unit', isJVM: true };
+  }
+
+  _testScript(tool) {
+    const scripts = this.pkg.scripts || {};
+    if (scripts.test && scripts.test.includes(tool)) return 'npm test';
+    if (scripts['test:ci']) return 'npm run test:ci';
+    return null;
+  }
+}
+
+module.exports = TestingDetector;