@nhonh/qabot 0.1.0

package/src/analyzers/feature-detector.js

@@ -0,0 +1,298 @@
+import path from "node:path";
+import { listDirs, fileExists, safeReadFile } from "../utils/file-utils.js";
+
+export async function detectFeatures(projectDir, projectProfile) {
+  const result = {
+    pages: [],
+    features: [],
+    components: {
+      shared: { count: 0, path: null },
+      page: { count: 0, path: null },
+    },
+    routes: [],
+  };
+
+  const detectors = {
+    "react-spa": detectReactSpa,
+    nextjs: detectNextjs,
+    vue: detectVue,
+    angular: detectAngular,
+    dotnet: detectDotnet,
+  };
+
+  const detect = detectors[projectProfile.type] || detectGeneric;
+  const detected = await detect(projectDir, projectProfile);
+  return { ...result, ...detected };
+}
+
+async function detectReactSpa(dir) {
+  const result = {
+    pages: [],
+    features: [],
+    components: {
+      shared: { count: 0, path: null },
+      page: { count: 0, path: null },
+    },
+    routes: [],
+  };
+  const srcDir = path.join(dir, "src");
+
+  const containerCandidates = [
+    "src/view/containers",
+    "src/pages",
+    "src/views",
+    "src/containers",
+    "src/screens",
+  ];
+  for (const candidate of containerCandidates) {
+    const fullPath = path.join(dir, candidate);
+    const dirs = await listDirs(fullPath);
+    if (dirs.length > 0) {
+      result.pages = dirs.map((d) => ({
+        name: d,
+        path: path.join(candidate, d),
+        route: guessRouteFromPageName(d),
+      }));
+      result.components.page = { count: dirs.length, path: candidate };
+      break;
+    }
+  }
+
+  const featureCandidates = [
+    "src/view/shared/features",
+    "src/features",
+    "src/modules",
+  ];
+  for (const candidate of featureCandidates) {
+    const fullPath = path.join(dir, candidate);
+    const dirs = await listDirs(fullPath);
+    if (dirs.length > 0) {
+      result.features = dirs.map((d) => ({
+        name: d,
+        path: path.join(candidate, d),
+        type: "feature-module",
+      }));
+      break;
+    }
+  }
+
+  const sharedCandidates = [
+    "src/view/shared/components",
+    "src/components",
+    "src/shared/components",
+    "src/ui",
+  ];
+  for (const candidate of sharedCandidates) {
+    const dirs = await listDirs(path.join(dir, candidate));
+    if (dirs.length > 0) {
+      result.components.shared = { count: dirs.length, path: candidate };
+      break;
+    }
+  }
+
+  const routeFile = await findRouteFile(dir);
+  if (routeFile) {
+    result.routes = await parseSimpleRoutes(routeFile);
+  }
+
+  return result;
+}
+
+async function detectNextjs(dir) {
+  const result = {
+    pages: [],
+    features: [],
+    components: {
+      shared: { count: 0, path: null },
+      page: { count: 0, path: null },
+    },
+    routes: [],
+  };
+
+  const appDir = (await fileExists(path.join(dir, "app")))
+    ? "app"
+    : (await fileExists(path.join(dir, "src", "app")))
+      ? "src/app"
+      : null;
+  const pagesDir = (await fileExists(path.join(dir, "pages")))
+    ? "pages"
+    : (await fileExists(path.join(dir, "src", "pages")))
+      ? "src/pages"
+      : null;
+
+  const routeDir = appDir || pagesDir;
+  if (routeDir) {
+    const dirs = await listDirs(path.join(dir, routeDir));
+    const filtered = dirs.filter(
+      (d) => !d.startsWith("_") && !d.startsWith(".") && d !== "api",
+    );
+    result.pages = filtered.map((d) => ({
+      name: d,
+      path: path.join(routeDir, d),
+      route: `/${d}`,
+    }));
+    result.components.page = { count: filtered.length, path: routeDir };
+  }
+
+  const compDirs =
+    (await listDirs(path.join(dir, "components"))) ||
+    (await listDirs(path.join(dir, "src", "components")));
+  if (compDirs.length > 0) {
+    result.components.shared = { count: compDirs.length, path: "components" };
+  }
+
+  return result;
+}
+
+async function detectVue(dir) {
+  const result = {
+    pages: [],
+    features: [],
+    components: {
+      shared: { count: 0, path: null },
+      page: { count: 0, path: null },
+    },
+    routes: [],
+  };
+
+  for (const candidate of ["src/views", "src/pages"]) {
+    const dirs = await listDirs(path.join(dir, candidate));
+    if (dirs.length > 0) {
+      result.pages = dirs.map((d) => ({
+        name: d,
+        path: path.join(candidate, d),
+        route: `/${d.toLowerCase()}`,
+      }));
+      result.components.page = { count: dirs.length, path: candidate };
+      break;
+    }
+  }
+
+  const compDirs = await listDirs(path.join(dir, "src", "components"));
+  if (compDirs.length > 0) {
+    result.components.shared = {
+      count: compDirs.length,
+      path: "src/components",
+    };
+  }
+
+  return result;
+}
+
+async function detectAngular(dir) {
+  const result = {
+    pages: [],
+    features: [],
+    components: {
+      shared: { count: 0, path: null },
+      page: { count: 0, path: null },
+    },
+    routes: [],
+  };
+
+  const appDirs = await listDirs(path.join(dir, "src", "app"));
+  const pageDirs = appDirs.filter(
+    (d) => d.endsWith("-page") || d.startsWith("page-"),
+  );
+  const featureDirs = appDirs.filter(
+    (d) =>
+      !d.startsWith("_") &&
+      !pageDirs.includes(d) &&
+      d !== "shared" &&
+      d !== "core",
+  );
+
+  result.pages = pageDirs.map((d) => ({
+    name: d,
+    path: `src/app/${d}`,
+    route: `/${d.replace(/-page$/, "")}`,
+  }));
+  result.features = featureDirs.map((d) => ({
+    name: d,
+    path: `src/app/${d}`,
+    type: "angular-module",
+  }));
+  result.components.page = { count: pageDirs.length, path: "src/app" };
+
+  return result;
+}
+
+async function detectDotnet(dir) {
+  const result = {
+    pages: [],
+    features: [],
+    components: {
+      shared: { count: 0, path: null },
+      page: { count: 0, path: null },
+    },
+    routes: [],
+  };
+  const dirs = await listDirs(dir);
+  const projectDirs = dirs.filter(
+    (d) =>
+      !d.includes(".Tests") &&
+      !d.startsWith(".") &&
+      !d.includes("node_modules"),
+  );
+  const testDirs = dirs.filter((d) => d.includes(".Tests"));
+
+  result.features = projectDirs.map((d) => ({
+    name: d,
+    path: d,
+    type: "dotnet-project",
+  }));
+  return result;
+}
+
+async function detectGeneric(dir) {
+  return {
+    pages: [],
+    features: [],
+    components: {
+      shared: { count: 0, path: null },
+      page: { count: 0, path: null },
+    },
+    routes: [],
+  };
+}
+
+function guessRouteFromPageName(name) {
+  const cleaned = name
+    .replace(/^Page/, "")
+    .replace(/([A-Z])/g, "-$1")
+    .toLowerCase()
+    .replace(/^-/, "");
+  return `/${cleaned}`;
+}
+
+async function findRouteFile(dir) {
+  const candidates = [
+    "src/routes/routesData.js",
+    "src/routes/index.js",
+    "src/router/index.js",
+    "src/routes.js",
+    "src/App.routes.js",
+  ];
+  for (const c of candidates) {
+    const full = path.join(dir, c);
+    if (await fileExists(full)) return full;
+  }
+  return null;
+}
+
+async function parseSimpleRoutes(filePath) {
+  const content = await safeReadFile(filePath);
+  if (!content) return [];
+
+  const routes = [];
+  const pathRegex = /path:\s*["'`]([^"'`]+)["'`]/g;
+  let match;
+  while ((match = pathRegex.exec(content)) !== null) {
+    routes.push({
+      path: match[1],
+      component: null,
+      isPrivate: content.includes(`isPrivate: true`),
+    });
+  }
+  return routes;
+}

package/src/analyzers/project-analyzer.js

@@ -0,0 +1,157 @@
+import path from "node:path";
+import { fileExists, readJSON, safeReadFile } from "../utils/file-utils.js";
+import { FRAMEWORK_DETECT_MAP } from "../core/constants.js";
+
+export async function analyzeProject(projectDir) {
+  const profile = {
+    name: path.basename(projectDir),
+    type: "unknown",
+    techStack: {
+      language: "unknown",
+      framework: null,
+      bundler: null,
+      stateManagement: null,
+      styling: [],
+      apiClient: null,
+      authProvider: null,
+    },
+    paths: { root: projectDir, src: null, tests: null, config: null },
+    packageManager: "npm",
+  };
+
+  const pkg = await detectPackageJson(projectDir);
+  if (pkg) {
+    profile.name = pkg.name || profile.name;
+    profile.techStack = detectTechStack(pkg);
+    profile.type = detectProjectType(pkg, projectDir);
+    profile.packageManager = await detectPackageManager(projectDir);
+    profile.paths.src = await detectSrcDir(projectDir);
+  }
+
+  const dotnet = await detectDotnet(projectDir);
+  if (dotnet) {
+    profile.type = "dotnet";
+    profile.techStack.language = "csharp";
+    profile.techStack.framework = "dotnet";
+  }
+
+  const python = await detectPython(projectDir);
+  if (python) {
+    profile.type = "python";
+    profile.techStack.language = "python";
+  }
+
+  return profile;
+}
+
+async function detectPackageJson(dir) {
+  try {
+    return await readJSON(path.join(dir, "package.json"));
+  } catch {
+    return null;
+  }
+}
+
+function detectProjectType(pkg, dir) {
+  const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+  if (allDeps.next) return "nextjs";
+  if (allDeps["@angular/core"]) return "angular";
+  if (allDeps.vue) return "vue";
+  if (allDeps.react) return "react-spa";
+  if (allDeps.express || allDeps.fastify || allDeps.koa) return "node";
+  return "unknown";
+}
+
+function detectTechStack(pkg) {
+  const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const stack = {
+    language: allDeps.typescript ? "typescript" : "javascript",
+    framework: null,
+    bundler: null,
+    stateManagement: null,
+    styling: [],
+    apiClient: null,
+    authProvider: null,
+  };
+
+  if (allDeps.next) stack.framework = "nextjs";
+  else if (allDeps.react) stack.framework = "react";
+  else if (allDeps.vue) stack.framework = "vue";
+  else if (allDeps["@angular/core"]) stack.framework = "angular";
+  else if (allDeps.express) stack.framework = "express";
+
+  if (allDeps.webpack) stack.bundler = "webpack";
+  else if (allDeps.vite) stack.bundler = "vite";
+  else if (allDeps.esbuild) stack.bundler = "esbuild";
+  else if (allDeps.next) stack.bundler = "turbopack";
+
+  if (allDeps["redux-saga"]) stack.stateManagement = "redux-saga";
+  else if (allDeps["@reduxjs/toolkit"]) stack.stateManagement = "redux-toolkit";
+  else if (allDeps.redux) stack.stateManagement = "redux";
+  else if (allDeps.zustand) stack.stateManagement = "zustand";
+  else if (allDeps.xstate) stack.stateManagement = "xstate";
+  else if (allDeps.vuex) stack.stateManagement = "vuex";
+  else if (allDeps.pinia) stack.stateManagement = "pinia";
+  else if (allDeps.mobx) stack.stateManagement = "mobx";
+
+  if (allDeps.tailwindcss) stack.styling.push("tailwind");
+  if (allDeps["@mui/material"] || allDeps["@material-ui/core"])
+    stack.styling.push("mui");
+  if (allDeps["styled-components"]) stack.styling.push("styled-components");
+  if (allDeps["@emotion/react"]) stack.styling.push("emotion");
+  if (allDeps["@chakra-ui/react"]) stack.styling.push("chakra");
+  if (allDeps["antd"]) stack.styling.push("antd");
+
+  if (allDeps.axios) stack.apiClient = "axios";
+  else if (allDeps["graphql-request"] || allDeps["@apollo/client"])
+    stack.apiClient = "graphql";
+
+  if (
+    allDeps["auth0-js"] ||
+    allDeps["@auth0/nextjs-auth0"] ||
+    allDeps["@auth0/auth0-react"]
+  )
+    stack.authProvider = "auth0";
+  else if (allDeps["firebase"]) stack.authProvider = "firebase";
+  else if (allDeps["@okta/okta-react"]) stack.authProvider = "okta";
+  else if (allDeps["next-auth"]) stack.authProvider = "next-auth";
+
+  return stack;
+}
+
+async function detectPackageManager(dir) {
+  if (
+    (await fileExists(path.join(dir, "bun.lockb"))) ||
+    (await fileExists(path.join(dir, "bun.lock")))
+  )
+    return "bun";
+  if (await fileExists(path.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+  if (await fileExists(path.join(dir, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+
+async function detectSrcDir(dir) {
+  const candidates = ["src", "app", "lib", "source"];
+  for (const c of candidates) {
+    if (await fileExists(path.join(dir, c))) return c;
+  }
+  return null;
+}
+
+async function detectDotnet(dir) {
+  const { readdir } = await import("node:fs/promises");
+  try {
+    const entries = await readdir(dir);
+    return entries.some((e) => e.endsWith(".sln") || e.endsWith(".csproj"));
+  } catch {
+    return false;
+  }
+}
+
+async function detectPython(dir) {
+  return (
+    (await fileExists(path.join(dir, "pyproject.toml"))) ||
+    (await fileExists(path.join(dir, "requirements.txt"))) ||
+    (await fileExists(path.join(dir, "setup.py")))
+  );
+}

package/src/analyzers/test-detector.js

@@ -0,0 +1,158 @@
+import path from "node:path";
+import { fileExists, readJSON, findFiles } from "../utils/file-utils.js";
+import { RUNNER_DETECT_MAP } from "../core/constants.js";
+
+export async function detectTests(projectDir, projectProfile) {
+  const result = {
+    frameworks: [],
+    testFiles: {
+      unit: { count: 0, pattern: null, examples: [] },
+      integration: { count: 0, pattern: null },
+      e2e: { count: 0, pattern: null },
+    },
+    coverage: { configured: false, thresholds: null, lastReport: null },
+    scripts: {},
+    ci: { platform: null, testJob: false },
+  };
+
+  const pkg = await readPkg(projectDir);
+  if (pkg) {
+    result.frameworks = await detectFrameworks(projectDir, pkg);
+    result.scripts = detectTestScripts(pkg);
+  }
+
+  for (const fw of result.frameworks) {
+    const counts = await countTestFiles(projectDir, fw.name);
+    if (fw.name === "playwright" || fw.name === "cypress") {
+      result.testFiles.e2e = {
+        count: counts.count,
+        pattern: counts.pattern,
+        examples: counts.examples,
+      };
+    } else {
+      result.testFiles.unit = {
+        count: counts.count,
+        pattern: counts.pattern,
+        examples: counts.examples,
+      };
+    }
+  }
+
+  const integrationFiles = await findFiles(
+    projectDir,
+    "**/*.integration.test.{js,ts,jsx,tsx}",
+  );
+  result.testFiles.integration = {
+    count: integrationFiles.length,
+    pattern: "**/*.integration.test.*",
+  };
+
+  result.coverage = await detectCoverage(projectDir);
+  result.ci = await detectCI(projectDir);
+
+  return result;
+}
+
+async function readPkg(dir) {
+  try {
+    return await readJSON(path.join(dir, "package.json"));
+  } catch {
+    return null;
+  }
+}
+
+async function detectFrameworks(dir, pkg) {
+  const frameworks = [];
+  const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+  for (const [name, info] of Object.entries(RUNNER_DETECT_MAP)) {
+    const hasDep = info.devDeps.some((d) => allDeps[d]);
+    const hasConfig = await Promise.any(
+      info.configs.map((c) =>
+        fileExists(path.join(dir, c)).then((exists) =>
+          exists ? c : Promise.reject(),
+        ),
+      ),
+    ).catch(() => null);
+
+    if (hasDep || hasConfig) {
+      const version =
+        info.devDeps.map((d) => allDeps[d]).find(Boolean) || "unknown";
+      frameworks.push({ name, version, configFile: hasConfig || null });
+    }
+  }
+
+  return frameworks;
+}
+
+function detectTestScripts(pkg) {
+  const scripts = {};
+  const s = pkg.scripts || {};
+  if (s.test) scripts.test = `npm test`;
+  if (s["test:watch"]) scripts.testWatch = `npm run test:watch`;
+  if (s.testcov || s["test:coverage"])
+    scripts.testCoverage = `npm run ${s.testcov ? "testcov" : "test:coverage"}`;
+  if (s["test:e2e"]) scripts.testE2e = `npm run test:e2e`;
+  return scripts;
+}
+
+async function countTestFiles(dir, runner) {
+  const patterns = {
+    jest: "**/*.test.{js,ts,jsx,tsx}",
+    vitest: "**/*.{test,spec}.{js,ts,jsx,tsx}",
+    playwright: "**/*.spec.{js,ts}",
+    cypress: "**/*.cy.{js,ts,jsx,tsx}",
+  };
+  const pattern = patterns[runner] || "**/*.test.*";
+  try {
+    const files = await findFiles(dir, pattern);
+    const filtered = files.filter((f) => !f.includes("node_modules"));
+    return {
+      count: filtered.length,
+      pattern,
+      examples: filtered.slice(0, 3).map((f) => path.relative(dir, f)),
+    };
+  } catch {
+    return { count: 0, pattern, examples: [] };
+  }
+}
+
+async function detectCoverage(dir) {
+  const jestConfig = await readJestConfig(dir);
+  if (jestConfig?.coverageThreshold) {
+    return {
+      configured: true,
+      thresholds: jestConfig.coverageThreshold.global || null,
+      lastReport: null,
+    };
+  }
+  return { configured: false, thresholds: null, lastReport: null };
+}
+
+async function readJestConfig(dir) {
+  const configPath = path.join(dir, "jest.config.js");
+  if (!(await fileExists(configPath))) return null;
+  try {
+    const mod = await import(`file://${configPath}`);
+    return mod.default || mod;
+  } catch {
+    return null;
+  }
+}
+
+async function detectCI(dir) {
+  if (await fileExists(path.join(dir, ".github", "workflows"))) {
+    const files = await findFiles(
+      path.join(dir, ".github", "workflows"),
+      "*.{yml,yaml}",
+    );
+    return { platform: "github-actions", testJob: files.length > 0 };
+  }
+  if (await fileExists(path.join(dir, ".gitlab-ci.yml")))
+    return { platform: "gitlab-ci", testJob: true };
+  if (await fileExists(path.join(dir, "Jenkinsfile")))
+    return { platform: "jenkins", testJob: true };
+  if (await fileExists(path.join(dir, ".circleci")))
+    return { platform: "circleci", testJob: true };
+  return { platform: null, testJob: false };
+}