openreport 0.1.0

package/src/utils/project-detector.ts

@@ -0,0 +1,296 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import type { ProjectClassification } from "../types/index.js";
+import { debugLog } from "./debug.js";
+
+async function fileExists(projectRoot: string, ...segments: string[]): Promise<boolean> {
+  try {
+    await fs.access(path.join(projectRoot, ...segments));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readJson(projectRoot: string, file: string): Promise<Record<string, unknown> | null> {
+  try {
+    const content = await fs.readFile(path.join(projectRoot, file), "utf-8");
+    return JSON.parse(content);
+  } catch (e) {
+    debugLog("project:readPackageJson", e);
+    return null;
+  }
+}
+
+function getAllDeps(pkg: Record<string, unknown> | null): Record<string, string> {
+  return {
+    ...((pkg?.dependencies as Record<string, string>) || {}),
+    ...((pkg?.devDependencies as Record<string, string>) || {}),
+  };
+}
+
+async function detectPackageManager(projectRoot: string): Promise<ProjectClassification["packageManager"]> {
+  const [hasBunLock, hasBunfig, hasPnpm, hasYarn, hasNpmLock, hasPkg] = await Promise.all([
+    fileExists(projectRoot, "bun.lockb"),
+    fileExists(projectRoot, "bunfig.toml"),
+    fileExists(projectRoot, "pnpm-lock.yaml"),
+    fileExists(projectRoot, "yarn.lock"),
+    fileExists(projectRoot, "package-lock.json"),
+    fileExists(projectRoot, "package.json"),
+  ]);
+
+  if (hasBunLock || hasBunfig) return "bun";
+  if (hasPnpm) return "pnpm";
+  if (hasYarn) return "yarn";
+  if (hasNpmLock) return "npm";
+  if (hasPkg) return "npm";
+  return null;
+}
+
+async function detectLanguage(projectRoot: string): Promise<string> {
+  const [
+    hasTsconfig, hasTsconfigBase, hasPkg,
+    hasRequirements, hasSetupPy, hasPyproject,
+    hasGoMod, hasCargo, hasPom, hasGradle,
+    hasGemfile, hasComposer, hasSwift,
+  ] = await Promise.all([
+    fileExists(projectRoot, "tsconfig.json"),
+    fileExists(projectRoot, "tsconfig.base.json"),
+    fileExists(projectRoot, "package.json"),
+    fileExists(projectRoot, "requirements.txt"),
+    fileExists(projectRoot, "setup.py"),
+    fileExists(projectRoot, "pyproject.toml"),
+    fileExists(projectRoot, "go.mod"),
+    fileExists(projectRoot, "Cargo.toml"),
+    fileExists(projectRoot, "pom.xml"),
+    fileExists(projectRoot, "build.gradle"),
+    fileExists(projectRoot, "Gemfile"),
+    fileExists(projectRoot, "composer.json"),
+    fileExists(projectRoot, "Package.swift"),
+  ]);
+
+  if (hasTsconfig || hasTsconfigBase) return "typescript";
+  if (hasPkg) return "javascript";
+  if (hasRequirements || hasSetupPy || hasPyproject) return "python";
+  if (hasGoMod) return "go";
+  if (hasCargo) return "rust";
+  if (hasPom || hasGradle) return "java";
+  if (hasGemfile) return "ruby";
+  if (hasComposer) return "php";
+  if (hasSwift) return "swift";
+  return "unknown";
+}
+
+async function detectFramework(
+  projectRoot: string,
+  pkg: Record<string, unknown> | null
+): Promise<string | null> {
+  const deps = getAllDeps(pkg);
+
+  if (deps["next"]) return "Next.js";
+  if (deps["nuxt"] || deps["nuxt3"]) return "Nuxt";
+  if (deps["@remix-run/react"] || deps["remix"]) return "Remix";
+  if (deps["@angular/core"]) return "Angular";
+  if (deps["vue"]) return "Vue";
+  if (deps["svelte"] || deps["@sveltejs/kit"]) return "Svelte";
+  if (deps["react"]) return "React";
+  if (deps["express"]) return "Express";
+  if (deps["fastify"]) return "Fastify";
+  if (deps["hono"]) return "Hono";
+  if (deps["@nestjs/core"]) return "NestJS";
+  if (deps["astro"]) return "Astro";
+  if (deps["gatsby"]) return "Gatsby";
+  if (deps["vite"]) return "Vite";
+  if (deps["electron"]) return "Electron";
+
+  // Non-JS frameworks — check in parallel
+  const [hasManagePy, hasRoutes, hasArtisan] = await Promise.all([
+    fileExists(projectRoot, "manage.py"),
+    fileExists(projectRoot, "config/routes.rb"),
+    fileExists(projectRoot, "artisan"),
+  ]);
+
+  if (hasManagePy) return "Django";
+  if (hasRoutes) return "Rails";
+  if (hasArtisan) return "Laravel";
+
+  return null;
+}
+
+async function detectProjectType(
+  projectRoot: string,
+  pkg: Record<string, unknown> | null,
+  framework: string | null
+): Promise<ProjectClassification["projectType"]> {
+  // Check for monorepo
+  const [hasLerna, hasPnpmWorkspace, hasTurbo] = await Promise.all([
+    fileExists(projectRoot, "lerna.json"),
+    fileExists(projectRoot, "pnpm-workspace.yaml"),
+    fileExists(projectRoot, "turbo.json"),
+  ]);
+
+  if (
+    hasLerna || hasPnpmWorkspace || hasTurbo ||
+    (pkg?.workspaces && Array.isArray(pkg.workspaces))
+  )
+    return "monorepo";
+
+  // Check bin field for CLI
+  if (pkg?.bin) return "cli";
+
+  // Check for API/backend
+  const webFrameworks = ["Next.js", "Nuxt", "Remix", "Angular", "Vue", "Svelte", "React", "Astro", "Gatsby"];
+  const apiFrameworks = ["Express", "Fastify", "Hono", "NestJS", "Django", "Rails", "Laravel"];
+
+  if (framework && apiFrameworks.includes(framework)) {
+    // Could be web-app if it also has frontend
+    const [hasPages, hasPublic] = await Promise.all([
+      fileExists(projectRoot, "src/pages"),
+      fileExists(projectRoot, "public"),
+    ]);
+    if (hasPages || hasPublic) return "web-app";
+    return "api";
+  }
+
+  if (framework && webFrameworks.includes(framework)) return "web-app";
+
+  // Check for library (has main/exports but no bin)
+  if (pkg?.main || pkg?.exports) return "library";
+
+  return "other";
+}
+
+async function detectBuildTool(
+  projectRoot: string,
+  pkg: Record<string, unknown> | null
+): Promise<string | null> {
+  const deps = getAllDeps(pkg);
+
+  // Check deps first (synchronous), then fall back to file checks in parallel
+  if (deps["vite"]) return "vite";
+  if (deps["webpack"]) return "webpack";
+  if (deps["esbuild"]) return "esbuild";
+  if (deps["rollup"]) return "rollup";
+  if (deps["turbopack"] || deps["@vercel/turbopack"]) return "turbopack";
+  if (deps["parcel"]) return "parcel";
+  if (deps["tsup"]) return "tsup";
+
+  const [hasViteConfig, hasWebpackConfig, hasRollupConfig, hasMakefile] = await Promise.all([
+    fileExists(projectRoot, "vite.config.ts"),
+    fileExists(projectRoot, "webpack.config.js"),
+    fileExists(projectRoot, "rollup.config.js"),
+    fileExists(projectRoot, "Makefile"),
+  ]);
+
+  if (hasViteConfig) return "vite";
+  if (hasWebpackConfig) return "webpack";
+  if (hasRollupConfig) return "rollup";
+  if (hasMakefile) return "make";
+
+  return null;
+}
+
+function detectTestFramework(
+  pkg: Record<string, unknown> | null
+): string | null {
+  const deps = getAllDeps(pkg);
+
+  if (deps["vitest"]) return "vitest";
+  if (deps["jest"]) return "jest";
+  if (deps["mocha"]) return "mocha";
+  if (deps["ava"]) return "ava";
+  if (deps["playwright"] || deps["@playwright/test"]) return "playwright";
+  if (deps["cypress"]) return "cypress";
+  if (deps["pytest"] || deps["unittest"]) return "pytest";
+
+  return null;
+}
+
+async function detectLinter(
+  pkg: Record<string, unknown> | null,
+  projectRoot: string
+): Promise<string | null> {
+  const deps = getAllDeps(pkg);
+
+  if (deps["eslint"]) return "eslint";
+  if (deps["biome"] || deps["@biomejs/biome"]) return "biome";
+  if (deps["rome"]) return "rome";
+
+  const [hasEslintJs, hasEslintJson] = await Promise.all([
+    fileExists(projectRoot, ".eslintrc.js"),
+    fileExists(projectRoot, ".eslintrc.json"),
+  ]);
+
+  if (hasEslintJs || hasEslintJson) return "eslint";
+
+  return null;
+}
+
+async function hasTestDirectory(root: string): Promise<boolean> {
+  const results = await Promise.all([
+    fileExists(root, "tests"),
+    fileExists(root, "test"),
+    fileExists(root, "__tests__"),
+    fileExists(root, "spec"),
+  ]);
+  return results.some(Boolean);
+}
+
+async function hasCIConfig(root: string): Promise<boolean> {
+  const results = await Promise.all([
+    fileExists(root, ".github", "workflows"),
+    fileExists(root, ".gitlab-ci.yml"),
+    fileExists(root, ".circleci"),
+    fileExists(root, "Jenkinsfile"),
+    fileExists(root, ".travis.yml"),
+  ]);
+  return results.some(Boolean);
+}
+
+async function hasDockerConfig(root: string): Promise<boolean> {
+  const results = await Promise.all([
+    fileExists(root, "Dockerfile"),
+    fileExists(root, "docker-compose.yml"),
+    fileExists(root, "docker-compose.yaml"),
+  ]);
+  return results.some(Boolean);
+}
+
+export async function detectProject(
+  projectRoot: string
+): Promise<ProjectClassification> {
+  const pkg = await readJson(projectRoot, "package.json");
+
+  // Run independent detection functions in parallel
+  const [language, framework, packageManager, buildTool, linter] = await Promise.all([
+    detectLanguage(projectRoot),
+    detectFramework(projectRoot, pkg),
+    detectPackageManager(projectRoot),
+    detectBuildTool(projectRoot, pkg),
+    detectLinter(pkg, projectRoot),
+  ]);
+
+  // detectProjectType depends on framework, so run after
+  const testFramework = detectTestFramework(pkg);
+  const [projectType, hasTestDir, hasCI, hasDocker] = await Promise.all([
+    detectProjectType(projectRoot, pkg, framework),
+    hasTestDirectory(projectRoot),
+    hasCIConfig(projectRoot),
+    hasDockerConfig(projectRoot),
+  ]);
+
+  const hasTests = testFramework !== null || hasTestDir;
+
+  return {
+    language,
+    framework,
+    projectType,
+    buildTool,
+    packageManager,
+    hasTests,
+    hasCI,
+    hasDocker,
+    testFramework,
+    linter,
+  };
+}