detect-tech-stack.cjs

#!/usr/bin/env node
'use strict';

const fs = require('node:fs');
const path = require('node:path');

const ENTERPRISE_STAGES = [
  'enterprise',
  'enterprise-discover',
  'enterprise-brainstorm',
  'enterprise-stack-review',
  'enterprise-plan',
  'enterprise-contract',
  'enterprise-build',
  'enterprise-review',
  'enterprise-pr-review',
  'enterprise-forge',
  'enterprise-verify',
  'enterprise-harness',
  'enterprise-compound',
  'enterprise-debug',
];

function readJsonIfExists(filePath) {
  if (!fs.existsSync(filePath)) return null;
  try {
    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
  } catch {
    return null;
  }
}

function exists(rootDir, relativePath) {
  return fs.existsSync(path.join(rootDir, relativePath));
}

function listFiles(rootDir, relativeDir) {
  const dir = path.join(rootDir, relativeDir);
  if (!fs.existsSync(dir)) return [];
  return fs.readdirSync(dir).map((name) => path.join(relativeDir, name));
}

function addUnique(target, value) {
  if (value && !target.includes(value)) target.push(value);
}

function slugify(value) {
  return String(value || 'repo')
    .toLowerCase()
    .replace(/[^a-z0-9]+/g, '-')
    .replace(/^-+|-+$/g, '')
    .slice(0, 48) || 'repo';
}

function titleCaseSlug(slug) {
  return slug
    .split('-')
    .filter(Boolean)
    .map((part) => part[0].toUpperCase() + part.slice(1))
    .join(' ');
}

function detectPackageManager(rootDir) {
  if (exists(rootDir, 'pnpm-lock.yaml')) return 'pnpm';
  if (exists(rootDir, 'yarn.lock')) return 'yarn';
  if (exists(rootDir, 'bun.lockb') || exists(rootDir, 'bun.lock')) return 'bun';
  if (exists(rootDir, 'package-lock.json')) return 'npm';
  if (exists(rootDir, 'package.json')) return 'npm';
  return null;
}

function detectFromPackageJson(rootDir, stack) {
  const packageJson = readJsonIfExists(path.join(rootDir, 'package.json'));
  if (!packageJson) return null;
  const deps = {
    ...packageJson.dependencies,
    ...packageJson.devDependencies,
    ...packageJson.peerDependencies,
  };
  const has = (name) => Object.prototype.hasOwnProperty.call(deps, name);

  addUnique(stack.runtimes, 'node');
  stack.packageManager = detectPackageManager(rootDir);

  if (has('react')) addUnique(stack.frontend, 'react');
  if (has('vue')) addUnique(stack.frontend, 'vue');
  if (has('svelte')) addUnique(stack.frontend, 'svelte');
  if (has('next')) addUnique(stack.frameworks, 'next');
  if (has('express')) addUnique(stack.frameworks, 'express');
  if (has('fastify')) addUnique(stack.frameworks, 'fastify');
  if (has('hono')) addUnique(stack.frameworks, 'hono');
  if (has('@nestjs/core')) addUnique(stack.frameworks, 'nestjs');
  if (has('vite')) addUnique(stack.tooling, 'vite');
  if (has('typescript')) addUnique(stack.languages, 'typescript');
  if (has('pg') || has('postgres') || has('postgresql')) addUnique(stack.databases, 'postgresql');
  if (has('mysql2') || has('mysql')) addUnique(stack.databases, 'mysql');
  if (has('sqlite3') || has('better-sqlite3')) addUnique(stack.databases, 'sqlite');
  if (has('mongodb') || has('mongoose')) addUnique(stack.databases, 'mongodb');
  if (has('prisma')) addUnique(stack.dataAccess, 'prisma');
  if (has('drizzle-orm')) addUnique(stack.dataAccess, 'drizzle');
  if (has('knex')) addUnique(stack.dataAccess, 'knex');
  if (has('jest')) addUnique(stack.testing, 'jest');
  if (has('vitest')) addUnique(stack.testing, 'vitest');
  if (has('@playwright/test') || has('playwright')) addUnique(stack.testing, 'playwright');
  if (has('cypress')) addUnique(stack.testing, 'cypress');

  return packageJson;
}

function detectTechStack(rootDir = process.cwd()) {
  const resolvedRoot = path.resolve(rootDir);
  const stack = {
    repoRoot: resolvedRoot,
    repoSlug: null,
    repoDisplayName: null,
    packageName: null,
    packageManager: null,
    languages: [],
    runtimes: [],
    frameworks: [],
    frontend: [],
    databases: [],
    dataAccess: [],
    testing: [],
    tooling: [],
    ci: [],
    deployment: [],
    evidence: [],
  };

  const packageJson = detectFromPackageJson(resolvedRoot, stack);
  if (packageJson?.name) {
    stack.packageName = packageJson.name;
  }

  if (exists(resolvedRoot, 'pyproject.toml') || exists(resolvedRoot, 'requirements.txt')) {
    addUnique(stack.runtimes, 'python');
    addUnique(stack.languages, 'python');
    if (exists(resolvedRoot, 'pytest.ini') || exists(resolvedRoot, 'pyproject.toml')) addUnique(stack.testing, 'pytest');
  }
  if (exists(resolvedRoot, 'go.mod')) {
    addUnique(stack.runtimes, 'go');
    addUnique(stack.languages, 'go');
  }
  if (exists(resolvedRoot, 'Cargo.toml')) {
    addUnique(stack.runtimes, 'rust');
    addUnique(stack.languages, 'rust');
  }
  if (exists(resolvedRoot, 'composer.json')) {
    addUnique(stack.runtimes, 'php');
    addUnique(stack.languages, 'php');
  }
  if (exists(resolvedRoot, 'Gemfile')) {
    addUnique(stack.runtimes, 'ruby');
    addUnique(stack.languages, 'ruby');
  }
  if (exists(resolvedRoot, '.github/workflows')) {
    addUnique(stack.ci, 'github-actions');
    for (const workflow of listFiles(resolvedRoot, '.github/workflows')) {
      stack.evidence.push(workflow);
    }
  }
  if (exists(resolvedRoot, 'render.yaml')) addUnique(stack.deployment, 'render');
  if (exists(resolvedRoot, 'vercel.json')) addUnique(stack.deployment, 'vercel');
  if (exists(resolvedRoot, 'Dockerfile') || exists(resolvedRoot, 'docker-compose.yml')) {
    addUnique(stack.deployment, 'docker');
  }

  const rootName = path.basename(resolvedRoot);
  stack.repoSlug = slugify(stack.packageName || rootName);
  stack.repoDisplayName = titleCaseSlug(stack.repoSlug);
  stack.overlayFamily = `${stack.repoSlug}-enterprise`;
  stack.recommendedStages = ENTERPRISE_STAGES;
  stack.overlayHints = {
    codeLocationFirst: true,
    sourceTruthRequired: true,
    headlessVerificationRequired: true,
    liveDataProofWhenDataSensitive: stack.databases.length > 0,
    browserProofWhenUi: stack.frontend.length > 0,
  };

  return stack;
}

function parseArgs(argv) {
  const args = { root: process.cwd(), json: true };
  for (let index = 0; index < argv.length; index += 1) {
    const arg = argv[index];
    if (arg === '--root') {
      args.root = argv[++index];
    } else if (arg === '--pretty') {
      args.json = false;
    }
  }
  return args;
}

if (require.main === module) {
  const args = parseArgs(process.argv.slice(2));
  const result = detectTechStack(args.root);
  console.log(JSON.stringify(result, null, 2));
}

module.exports = {
  ENTERPRISE_STAGES,
  detectTechStack,
  slugify,
  titleCaseSlug,
};