@chappibunny/repolens 1.16.2 → 1.16.3

package/src/analyzers/graphql-analyzer.js

@@ -3,6 +3,8 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { info } from "../utils/logger.js";
+import { extractJsImports, externalPackageName } from "./import-parsers.js";
+import { stripJsComments } from "../utils/js-lexer.js";
 
 const GRAPHQL_EXTENSIONS = [".graphql", ".gql"];
 
@@ -19,28 +21,57 @@ const TYPE_PATTERNS = {
   directive: /directive\s+@(\w+)/g,
 };
 
+// Word boundaries matter: `useQuery: {` (a React Query hook map) is not `Query: {`.
 const RESOLVER_PATTERNS = [
-  /(?:Query|Mutation|Subscription)\s*:\s*\{/,
-  /resolvers?\s*=\s*\{/,
-  /createResolversMap/,
+  /(?:^|[^\w$])(?:Query|Mutation|Subscription)\s*:\s*\{/m,
+  /\bresolvers?\s*=\s*\{/,
+  /\bcreateResolversMap\b/,
   /\bresolveType\b/,
-  /fieldResolver/,
+  /\bfieldResolver\b/,
 ];
 
-const SCHEMA_LIBRARY_PATTERNS = [
-  { name: "Apollo Server", pattern: /ApolloServer|@apollo\/server|apollo-server/ },
-  { name: "GraphQL Yoga", pattern: /graphql-yoga|createYoga/ },
-  { name: "Mercurius", pattern: /mercurius/ },
-  { name: "graphql-js", pattern: /graphql\b.*\bbuildSchema\b|\bGraphQLSchema\b|\bGraphQLObjectType\b/ },
-  { name: "type-graphql", pattern: /type-graphql|@Resolver|@Query|@Mutation/ },
-  { name: "Nexus", pattern: /nexus|makeSchema|objectType\(/ },
-  { name: "Pothos", pattern: /pothos|SchemaBuilder/ },
-  { name: "Hasura", pattern: /hasura/ },
-  { name: "Relay", pattern: /relay-runtime|RelayEnvironment/ },
-  { name: "urql", pattern: /urql|@urql/ },
-  { name: "Apollo Client", pattern: /ApolloClient|@apollo\/client|apollo-client|useQuery|useMutation/ },
+// Libraries count only when a file imports them. A comment that mentions Apollo or urql,
+// or a React Query `useQuery` hook, is not GraphQL.
+const SCHEMA_LIBRARY_PACKAGES = [
+  { name: "Apollo Server", match: (pkg) => pkg === "@apollo/server" || pkg === "@apollo/subgraph" || pkg === "apollo-server" || pkg.startsWith("apollo-server-") },
+  { name: "GraphQL Yoga", match: (pkg) => pkg === "graphql-yoga" || pkg.startsWith("@graphql-yoga/") },
+  { name: "Mercurius", match: (pkg) => pkg === "mercurius" },
+  { name: "graphql-js", match: (pkg) => pkg === "graphql" },
+  { name: "type-graphql", match: (pkg) => pkg === "type-graphql" },
+  { name: "Nexus", match: (pkg) => pkg === "nexus" || pkg === "@nexus/schema" },
+  { name: "Pothos", match: (pkg) => pkg.startsWith("@pothos/") },
+  { name: "Relay", match: (pkg) => pkg === "relay-runtime" || pkg === "react-relay" },
+  { name: "urql", match: (pkg) => pkg === "urql" || pkg.startsWith("@urql/") },
+  { name: "Apollo Client", match: (pkg) => pkg === "@apollo/client" || pkg === "apollo-client" || pkg === "react-apollo" || pkg === "apollo-boost" },
+  { name: "graphql-request", match: (pkg) => pkg === "graphql-request" },
+  { name: "graphql-tag", match: (pkg) => pkg === "graphql-tag" },
+  // Hasura has no server SDK; its client and tooling packages are the grounded signal.
+  // A bare "hasura" mention in text is no longer enough (see CHANGELOG).
+  { name: "Hasura", match: (pkg) => pkg.startsWith("@hasura/") || pkg.startsWith("hasura-") },
 ];
 
+export function graphqlLibrariesImported(source) {
+  const names = [];
+  let imports = [];
+  try { imports = extractJsImports(source); } catch { imports = []; }
+  for (const imported of imports) {
+    const pkg = externalPackageName(imported.specifier);
+    if (!pkg) continue;
+    for (const { name, match } of SCHEMA_LIBRARY_PACKAGES) {
+      if (match(pkg) && !names.includes(name)) names.push(name);
+    }
+  }
+  return names;
+}
+
+async function hasHasuraProject(repoRoot) {
+  for (const rel of ["hasura/config.yaml", "config.yaml"]) {
+    const text = await readFileSafe(path.join(repoRoot, rel));
+    if (/^\s*metadata_directory\s*:/m.test(text)) return true;
+  }
+  return false;
+}
+
 function parseFieldsFromBlock(block) {
   const fields = [];
   const lines = block.split("\n").map(l => l.trim()).filter(l => l && !l.startsWith("#"));
@@ -102,40 +133,57 @@ export async function analyzeGraphQL(files, repoRoot) {
   }
 
   // Scan code files for inline schemas, resolvers, and libraries
+  const resolverCandidates = [];
   for (const file of codeFiles) {
     const content = await readFileSafe(path.join(repoRoot, file));
     if (!content) continue;
 
-    // Detect GraphQL libraries
-    for (const { name, pattern } of SCHEMA_LIBRARY_PATTERNS) {
-      if (pattern.test(content) && !result.libraries.includes(name)) {
-        result.libraries.push(name);
-      }
+    // Detect GraphQL libraries from real imports
+    const fileLibraries = graphqlLibrariesImported(content);
+    for (const name of fileLibraries) {
+      if (!result.libraries.includes(name)) result.libraries.push(name);
     }
 
+    const code = stripJsComments(content);
+    const typesBefore = result.types.length + result.queries.length + result.mutations.length + result.subscriptions.length;
+
     // Detect inline SDL (template literals with gql tag or type definitions)
-    const inlineSdlPattern = /(?:gql|graphql)\s*`([^`]+)`/gs;
+    const inlineSdlPattern = /\b(?:gql|graphql)\s*`([^`]+)`/gs;
     let match;
-    while ((match = inlineSdlPattern.exec(content)) !== null) {
+    while ((match = inlineSdlPattern.exec(code)) !== null) {
       extractSchemaTypes(match[1], file, result);
     }
 
     // Also detect raw type definitions in string literals
-    if (/type\s+(?:Query|Mutation|Subscription)\s*\{/.test(content)) {
-      extractSchemaTypes(content, file, result);
+    if (/\btype\s+(?:Query|Mutation|Subscription)\s*\{/.test(code)) {
+      extractSchemaTypes(code, file, result);
     }
+    const hasSdl = result.types.length + result.queries.length + result.mutations.length + result.subscriptions.length > typesBefore;
 
-    // Detect resolver files
-    const isResolver = RESOLVER_PATTERNS.some(p => p.test(content));
-    if (isResolver && !result.resolverFiles.includes(file)) {
-      result.resolverFiles.push(file);
+    // Resolver candidates are confirmed after the whole scan: a resolver map needs
+    // GraphQL evidence in the file or somewhere in the repository.
+    if (RESOLVER_PATTERNS.some(p => p.test(code))) {
+      // `resolvers = { Query: { ... } }` together is a resolver map on its own.
+      const resolverMap = RESOLVER_PATTERNS[0].test(code) && RESOLVER_PATTERNS[1].test(code);
+      resolverCandidates.push({ file, local: fileLibraries.length > 0 || hasSdl || resolverMap });
     }
   }
 
-  result.detected = result.schemaFiles.length > 0 ||
-    result.types.length > 0 ||
-    result.resolverFiles.length > 0 ||
+  // Hasura projects are recognized by their CLI project file, not by the word "hasura".
+  if (!result.libraries.includes("Hasura") && await hasHasuraProject(repoRoot)) {
+    result.libraries.push("Hasura");
+  }
+
+  const repoHasGraphQL = result.schemaFiles.length > 0 ||
+    result.types.length > 0 || result.queries.length > 0 || result.mutations.length > 0 ||
     result.libraries.length > 0;
+  for (const candidate of resolverCandidates) {
+    if ((candidate.local || repoHasGraphQL) && !result.resolverFiles.includes(candidate.file)) {
+      result.resolverFiles.push(candidate.file);
+    }
+  }
+
+  result.detected = repoHasGraphQL || result.resolverFiles.length > 0;
 
   if (result.detected) {
     result.summary = buildSummary(result);

package/src/analyzers/language-coverage.js

@@ -0,0 +1,222 @@
+// Which scanned source files the import graph and code health can read.
+// RepoLens detects and scans many languages, but it builds import graphs and scores code
+// health only for JavaScript/TypeScript, Python, and Go. A C# or Java repository must not
+// get "no circular dependencies" or "health 100/100" from one incidental docs script.
+
+import path from "node:path";
+import { LANGUAGE_PROFILES } from "../core/languages.js";
+import { isNonProductPath } from "../utils/path-roles.js";
+
+export const ANALYZED_LANGUAGES_TEXT = "JavaScript/TypeScript, Python, and Go";
+
+const ANALYZED_EXTENSIONS = new Set([".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".py", ".pyw", ".go"]);
+
+// A code-health badge is one number for the whole repository. Below this share of
+// product source files in analyzed languages, `repolens badge` refuses to print it.
+// The docs still show the partial graph and scores with a coverage note.
+export const BADGE_MIN_SHARE = 0.1;
+
+// Vendored or third-party trees are not the repository's own code, in any language.
+export const VENDORED_DIRECTORIES = new Set([
+  "vendor", "vendored", "third_party", "third-party", "thirdparty", "3rdparty",
+  "deps", "external", "extern", "node_modules", "bower_components",
+]);
+
+const LABEL_BY_EXTENSION = new Map();
+LABEL_BY_EXTENSION.set(".vue", "Vue");
+LABEL_BY_EXTENSION.set(".svelte", "Svelte");
+const COMPANION_LABELS_LIST = ["Vue", "Svelte"];
+for (const profile of LANGUAGE_PROFILES) {
+  const label = profile.id === "java" ? "Java/Kotlin" : profile.id === "cpp" ? "C/C++" : profile.label;
+  for (const ext of profile.extensions) {
+    if (!LABEL_BY_EXTENSION.has(ext)) LABEL_BY_EXTENSION.set(ext, label);
+  }
+}
+
+function isDeclarationFile(file) {
+  return /\.d\.[cm]?ts$/.test(file);
+}
+
+export function isVendoredPath(file) {
+  const parts = String(file || "").replace(/\\/g, "/").toLowerCase().split("/");
+  parts.pop();
+  return parts.some((segment) => VENDORED_DIRECTORIES.has(segment));
+}
+
+/**
+ * Product source = not a test, docs, tooling, example, or vendored path.
+ *
+ * - "none": no source files in any known language
+ * - "full": every product source file is in an analyzed language
+ * - "partial": analyzed-language product code exists next to other languages; analysis
+ *   runs and every page says what it did not cover
+ * - "unsupported": no analyzed-language product code at all (only a docs script, a test
+ *   helper, or vendored files); graph and health are not built
+ *
+ * @param {string[]} files - scanned file paths
+ */
+export function computeLanguageCoverage(files) {
+  let analyzedFiles = 0;
+  let analyzedProductFiles = 0;
+  let unanalyzedFiles = 0;
+  let unanalyzedProductFiles = 0;
+  let vendoredFiles = 0;
+  let vendoredAnalyzedFiles = 0;
+  const byLabelProduct = new Map();
+  const byLabelAll = new Map();
+
+  for (const raw of files || []) {
+    const file = String(raw).replace(/\\/g, "/");
+    if (isDeclarationFile(file)) continue;
+    const ext = path.posix.extname(file).toLowerCase();
+    const analyzed = ANALYZED_EXTENSIONS.has(ext);
+    const label = analyzed ? null : LABEL_BY_EXTENSION.get(ext);
+    if (!analyzed && !label) continue;
+    if (isVendoredPath(file)) {
+      vendoredFiles += 1;
+      if (analyzed) vendoredAnalyzedFiles += 1;
+      continue;
+    }
+    const product = !isNonProductPath(file);
+    if (analyzed) {
+      analyzedFiles += 1;
+      if (product) analyzedProductFiles += 1;
+      continue;
+    }
+    unanalyzedFiles += 1;
+    byLabelAll.set(label, (byLabelAll.get(label) || 0) + 1);
+    if (product) {
+      unanalyzedProductFiles += 1;
+      byLabelProduct.set(label, (byLabelProduct.get(label) || 0) + 1);
+    }
+  }
+
+  // Product files decide everything; a tree with no product files at all (only tests,
+  // docs, or tooling) falls back to every non-vendored file.
+  const useProduct = analyzedProductFiles + unanalyzedProductFiles > 0;
+  const analyzedBase = useProduct ? analyzedProductFiles : analyzedFiles;
+  const unanalyzedBase = useProduct ? unanalyzedProductFiles : unanalyzedFiles;
+  const byLabel = useProduct ? byLabelProduct : byLabelAll;
+  const totalBase = analyzedBase + unanalyzedBase;
+  const share = totalBase > 0 ? analyzedBase / totalBase : null;
+  // Vue and Svelte components sit next to analyzed JavaScript/TypeScript. They are not
+  // analyzed, but they do not count against the badge share: a component library with
+  // two .ts files and forty .vue files keeps its (partial) score.
+  const companionBase = COMPANION_LABELS_LIST.reduce((sum, label) => sum + (byLabel.get(label) || 0), 0);
+  const badgeShare = totalBase - companionBase > 0 ? analyzedBase / (totalBase - companionBase) : null;
+
+  const unanalyzedLanguages = [...byLabel.entries()]
+    .map(([label, count]) => ({ label, files: count }))
+    .sort((a, b) => b.files - a.files || a.label.localeCompare(b.label));
+
+  let status;
+  if (totalBase === 0) status = "none";
+  else if (unanalyzedBase === 0) status = "full";
+  else if (analyzedBase === 0) status = "unsupported";
+  else status = "partial";
+
+  return {
+    status,
+    analyzedFiles,
+    analyzedProductFiles,
+    unanalyzedFiles,
+    unanalyzedProductFiles,
+    vendoredFiles,
+    vendoredAnalyzedFiles,
+    productBased: useProduct,
+    analyzedBase,
+    totalBase,
+    unanalyzedLanguages,
+    share,
+    companionBase,
+    badgeShare,
+  };
+}
+
+/** Whether one code-health number may stand for the repository. */
+export function badgeCoverageOk(coverage) {
+  if (!coverage) return true;
+  if (coverage.status === "full" || coverage.status === "none") return true;
+  if (coverage.status === "unsupported") return false;
+  const share = coverage.badgeShare ?? coverage.share ?? 0;
+  return share >= BADGE_MIN_SHARE;
+}
+
+/**
+ * Short qualifier for claims made from the graph ("no circular dependencies"), or "".
+ * Partial: " (analyzed files only: 50 of 650 product source files; C/C++ not analyzed)".
+ */
+export function coverageScope(coverage) {
+  if (!coverage || coverage.status !== "partial") return "";
+  return ` (analyzed files only: ${coverage.analyzedBase} of ${coverage.totalBase} ${coverage.productBased ? "product " : ""}source files; ${unanalyzedLanguageNames(coverage)} not analyzed)`;
+}
+
+/** "C# (780 files)" / "Java/Kotlin (247 files) and C (3 files)". */
+export function describeUnanalyzedLanguages(coverage, limit = 3) {
+  const list = (coverage?.unanalyzedLanguages || []).slice(0, limit)
+    .map(({ label, files }) => `${label} (${files} ${coverage?.productBased ? "product " : ""}file${files === 1 ? "" : "s"})`);
+  if (list.length === 0) return "";
+  if (list.length === 1) return list[0];
+  return `${list.slice(0, -1).join(", ")} and ${list[list.length - 1]}`;
+}
+
+/** Short language names only: "C#", "Java/Kotlin and Scala". */
+export function unanalyzedLanguageNames(coverage, limit = 3) {
+  const list = (coverage?.unanalyzedLanguages || []).slice(0, limit).map(({ label }) => label);
+  if (list.length <= 1) return list[0] || "";
+  return `${list.slice(0, -1).join(", ")} and ${list[list.length - 1]}`;
+}
+
+/**
+ * Files an analyzer should read. When the analyzed languages are only incidental
+ * (status "unsupported"), none: the graph or score would describe a docs script,
+ * not the repository.
+ */
+export function filesForAnalysis(files, coverage = computeLanguageCoverage(files)) {
+  if (coverage.status === "unsupported") return [];
+  return files;
+}
+
+function verbFor(coverage) {
+  return (coverage?.unanalyzedLanguages || []).length > 1 ? "are" : "is";
+}
+
+/**
+ * Markdown lines that say what a page did not analyze.
+ * `what` is "import analysis" or "code health".
+ * Returns [] for full coverage or when there is nothing to say.
+ */
+export function coverageNotice(coverage, what) {
+  if (!coverage) return [];
+  const langs = describeUnanalyzedLanguages(coverage);
+  if (coverage.status === "unsupported") {
+    const n = (coverage.analyzedFiles || 0) + (coverage.vendoredAnalyzedFiles || 0);
+    const incidental = n > 0
+      ? ` ${n === 1 ? "One file" : `${n} files`} in a supported language ${n === 1 ? "was" : "were"} found only in docs, tests, tooling, examples, or vendored directories, so ${n === 1 ? "it was" : "they were"} not ${what === "code health" ? "scored" : "graphed"} as if ${n === 1 ? "it were" : "they were"} the codebase.`
+      : "";
+    return [
+      `> ${langs} ${verbFor(coverage)} not supported for ${what} yet. RepoLens ${what === "code health" ? "scores" : "builds import graphs for"} ${ANALYZED_LANGUAGES_TEXT} only.`,
+      "",
+      `Modules and file structure for this repository are still documented in the other pages. This is a language limitation, not a problem with your \`scan.include\` patterns.${incidental}`,
+      "",
+    ];
+  }
+  if (coverage.status === "partial") {
+    const pct = coverage.share != null ? Math.round(coverage.share * 100) : null;
+    return [
+      `> **Partial coverage:** ${what} covers ${coverage.analyzedBase} of ${coverage.totalBase} ${coverage.productBased ? "product " : ""}source files${pct != null ? ` (${pct}%)` : ""}, the ${ANALYZED_LANGUAGES_TEXT} ones. ${langs} ${verbFor(coverage)} not analyzed, so results below say nothing about ${coverage.unanalyzedLanguages.length > 1 ? "those languages" : "that language"}.`,
+      "",
+    ];
+  }
+  return [];
+}
+
+/** One plain-text line for logs and the badge CLI. */
+export function coverageLine(coverage, what) {
+  if (!coverage || (coverage.status !== "unsupported" && coverage.status !== "partial")) return "";
+  const langs = describeUnanalyzedLanguages(coverage);
+  if (coverage.status === "unsupported") {
+    return `${langs} ${verbFor(coverage)} not supported for ${what} yet (${ANALYZED_LANGUAGES_TEXT} only).`;
+  }
+  return `${what} covers ${ANALYZED_LANGUAGES_TEXT} only; ${langs} ${verbFor(coverage)} not analyzed.`;
+}

package/src/analyzers/workspace-packages.js

@@ -0,0 +1,105 @@
+// Workspace members declared by the repository: root package.json `workspaces`
+// (npm / yarn / bun), pnpm-workspace.yaml `packages`, and lerna.json `packages`.
+// Only declared members are internal packages for the dependency graph. A stray
+// package.json (a test stub named `express`, a fixture, a vendored copy) is not.
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import fg from "fast-glob";
+import { loadYaml } from "../utils/yaml.js";
+
+async function readJson(file) {
+  try {
+    return JSON.parse(await fs.readFile(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function cleanPattern(raw) {
+  if (typeof raw !== "string") return null;
+  let p = raw.trim();
+  if (!p || p.includes("\0")) return null;
+  const negated = p.startsWith("!");
+  if (negated) p = p.slice(1).trim();
+  p = p.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
+  if (!p || p.startsWith("/") || /^[A-Za-z]:/.test(p)) return null;
+  if (p.split("/").includes("..")) return null;
+  return { pattern: p, negated };
+}
+
+async function declaredPatterns(repoRoot) {
+  const sources = [];
+  const patterns = [];
+
+  const rootPkg = await readJson(path.join(repoRoot, "package.json"));
+  if (rootPkg?.workspaces) {
+    const list = Array.isArray(rootPkg.workspaces) ? rootPkg.workspaces : rootPkg.workspaces.packages;
+    if (Array.isArray(list) && list.length > 0) {
+      sources.push("package.json workspaces");
+      patterns.push(...list);
+    }
+  }
+
+  try {
+    const doc = loadYaml(await fs.readFile(path.join(repoRoot, "pnpm-workspace.yaml"), "utf8"));
+    if (Array.isArray(doc?.packages) && doc.packages.length > 0) {
+      sources.push("pnpm-workspace.yaml");
+      patterns.push(...doc.packages);
+    }
+  } catch {
+    // no pnpm workspace
+  }
+
+  const lerna = await readJson(path.join(repoRoot, "lerna.json"));
+  if (lerna) {
+    const list = Array.isArray(lerna.packages) && lerna.packages.length > 0 ? lerna.packages : ["packages/*"];
+    sources.push("lerna.json");
+    patterns.push(...list);
+  }
+
+  return { sources, patterns };
+}
+
+/**
+ * @returns {Promise<{ sources: string[], packages: { name: string, dir: string, manifest: object }[] }>}
+ * `dir` is repository-relative with forward slashes ("" never occurs: the root is not a member).
+ */
+export async function listWorkspacePackages(repoRoot) {
+  const { sources, patterns } = await declaredPatterns(repoRoot);
+  const positive = [];
+  const negative = [];
+  for (const raw of patterns) {
+    const cleaned = cleanPattern(raw);
+    if (!cleaned) continue;
+    (cleaned.negated ? negative : positive).push(cleaned.pattern);
+  }
+  if (positive.length === 0) return { sources, packages: [] };
+
+  let manifests = [];
+  try {
+    manifests = await fg(positive.map((p) => `${p}/package.json`), {
+      cwd: repoRoot,
+      dot: true,
+      onlyFiles: true,
+      followSymbolicLinks: false,
+      unique: true,
+      ignore: ["**/node_modules/**", ...negative.map((p) => `${p}/package.json`), ...negative.map((p) => `${p}/**`)],
+    });
+  } catch {
+    manifests = [];
+  }
+
+  const byName = new Map();
+  for (const rel of manifests.sort()) {
+    const dir = path.posix.dirname(rel.replace(/\\/g, "/"));
+    if (!dir || dir === ".") continue;
+    const manifest = await readJson(path.join(repoRoot, rel));
+    if (!manifest || typeof manifest.name !== "string" || !manifest.name) continue;
+    const existing = byName.get(manifest.name);
+    if (!existing || dir.split("/").length < existing.dir.split("/").length) {
+      byName.set(manifest.name, { name: manifest.name, dir, manifest });
+    }
+  }
+  return { sources, packages: [...byName.values()] };
+}

package/src/badge.js

@@ -2,11 +2,17 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { analyzeComplexity, computeCodeHealth } from "./analyzers/complexity-analyzer.js";
 import { analyzeDependencyGraph } from "./analyzers/dependency-graph.js";
+import { badgeCoverageOk, coverageLine } from "./analyzers/language-coverage.js";
 import { analyzeJSDoc } from "./analyzers/jsdoc-analyzer.js";
 import { analyzeSecurityPatterns } from "./analyzers/security-patterns.js";
 import { GALLERY_URL, REPO_URL } from "./delivery/comment-constants.js";
 
 const SOURCE_EXT = new Set([".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx", ".py", ".pyw", ".go"]);
+const OTHER_SOURCE_EXT = new Set([
+  ".rs", ".java", ".kt", ".kts", ".scala", ".rb", ".php", ".cs", ".swift",
+  ".c", ".cc", ".cpp", ".h", ".hpp", ".vue", ".svelte",
+]);
+const MAX_SOURCE_FILES = 20000;
 const SKIP_DIR = new Set([
   "node_modules", ".git", "dist", "build", "vendor", "target", "coverage",
   ".repolens", "__pycache__", ".cache",
@@ -119,15 +125,19 @@ export function compactHealth(health) {
   };
 }
 
-export async function listScoreFiles(root, { maxFiles = 2500 } = {}) {
-  const out = [];
+/**
+ * Walk the tree once. Up to `maxFiles` scored files are analyzed, but every source file
+ * (scored languages and others alike) is counted up to `maxSourceFiles`, with the same
+ * skip rules, so the language-coverage decision never compares a capped sample of one
+ * language against an uncapped count of another. `coverageTruncated` is true when that
+ * shared limit was hit, and the ratio is then an estimate.
+ */
+export async function listScoreFiles(root, { maxFiles = 2500, maxSourceFiles = MAX_SOURCE_FILES } = {}) {
+  const scored = [];
+  const others = [];
   const stack = [root];
-  let capped = false;
-  while (stack.length) {
-    if (out.length >= maxFiles) {
-      capped = true;
-      break;
-    }
+  let coverageTruncated = false;
+  walk: while (stack.length) {
     const dir = stack.pop();
     let entries;
     try {
@@ -146,33 +156,47 @@ export async function listScoreFiles(root, { maxFiles = 2500 } = {}) {
       }
       if (!entry.isFile()) continue;
       if (entry.name.endsWith(".snap")) continue;
-      if (!SOURCE_EXT.has(path.extname(entry.name))) continue;
-      if (out.length >= maxFiles) {
-        capped = true;
-        break;
+      const ext = path.extname(entry.name);
+      const isScored = SOURCE_EXT.has(ext);
+      if (!isScored && !OTHER_SOURCE_EXT.has(ext.toLowerCase())) continue;
+      if (scored.length + others.length >= maxSourceFiles) {
+        coverageTruncated = true;
+        break walk;
       }
       const rel = path.relative(root, full).replace(/\\/g, "/");
-      out.push(rel);
+      (isScored ? scored : others).push(rel);
     }
   }
-  out.sort();
-  return { files: out, capped };
+  const capped = scored.length > maxFiles || coverageTruncated;
+  const files = scored.slice(0, maxFiles).sort();
+  return {
+    files,
+    capped,
+    others: others.sort(),
+    coverageFiles: [...scored, ...others],
+    coverageTruncated,
+  };
 }
 
 export async function scoreRepository(root, { files, maxFiles = 2500 } = {}) {
   let list = files;
   let capped = false;
+  let coverageFiles = files;
+  let coverageTruncated = false;
   if (!list) {
     const walked = await listScoreFiles(root, { maxFiles });
     list = walked.files;
     capped = walked.capped;
+    coverageFiles = walked.coverageFiles;
+    coverageTruncated = walked.coverageTruncated;
   }
-  const complexity = await analyzeComplexity(list, root);
-  const depGraph = await analyzeDependencyGraph(list, root);
+  // Coverage is judged on every counted source file; only `list` is analyzed.
+  const complexity = await analyzeComplexity(list, root, { coverageFiles });
+  const depGraph = await analyzeDependencyGraph(list, root, { coverageFiles });
   const jsdoc = await analyzeJSDoc(list, root);
   const security = await analyzeSecurityPatterns(list, root);
   const health = computeCodeHealth(complexity, depGraph, jsdoc, security);
-  return { health, depGraph, files: list, capped };
+  return { health, depGraph, files: list, capped, coverageTruncated };
 }
 
 function resolveOutPaths(outPath) {
@@ -228,6 +252,23 @@ export async function runBadgeCli({
     return 1;
   }
   const total = scored.health?.stats?.totalFiles || 0;
+  const coverage = scored.health?.coverage;
+  if (scored.coverageTruncated) {
+    console.error(`Note: language coverage was estimated from the first ${MAX_SOURCE_FILES} source files.`);
+  }
+  if (coverage && !badgeCoverageOk(coverage)) {
+    if (coverage.status === "unsupported") {
+      console.error(`Not scored: ${coverageLine(coverage, "code health")}`);
+    } else {
+      const pct = Math.round((coverage.share || 0) * 100);
+      console.error(`Not scored: only ${coverage.analyzedBase} of ${coverage.totalBase} product source files (${pct}%) are ${"JavaScript/TypeScript, Python, or Go"}; ${coverageLine(coverage, "code health")}`);
+    }
+    console.error("No badge was printed: one score would not stand for this repository.");
+    return 2;
+  }
+  if (coverage?.status === "partial") {
+    console.error(`Partial coverage: ${coverageLine(coverage, "code health")}`);
+  }
   if (!total) {
     console.error("No source files analyzed.");
     console.error("Code health covers JavaScript, TypeScript, Python, and Go. Empty documentation was not scored.");

package/src/core/scan.js

@@ -186,6 +186,7 @@ function packageEntryFiles(pkg) {
  */
 function detectLanguagesFromFiles(files) {
   const languages = new Set();
+  const counts = new Map();
   
   // Extension to language mapping
   const extensionMap = {
@@ -241,9 +242,12 @@ function detectLanguagesFromFiles(files) {
     // types. They do not make the library a TypeScript project.
     if (ext === ".ts" && /\.d\.ts$/i.test(file)) continue;
     if (extensionMap[ext] === "TypeScript" && isTestPath(file)) continue;
-    languages.add(extensionMap[ext]);
+    const label = extensionMap[ext];
+    counts.set(label, (counts.get(label) || 0) + 1);
   }
 
+  // Most files first, so a C# repository with one docs script reads "C#, JavaScript".
+  for (const [label] of [...counts.entries()].sort((a, b) => b[1] - a[1])) languages.add(label);
   return languages;
 }
 
@@ -406,9 +410,8 @@ async function extractRepoMetadata(repoRoot, files = []) {
 
   // Merge languages detected from file extensions
   const fileLanguages = detectLanguagesFromFiles(files);
-  for (const lang of fileLanguages) {
-    metadata.languages.add(lang);
-  }
+  const manifestLanguages = [...metadata.languages];
+  metadata.languages = new Set([...fileLanguages, ...manifestLanguages]);
 
   // De-duplicate frameworks (in case detected from multiple sources)
   metadata.frameworks = [...new Set(metadata.frameworks)];
@@ -589,6 +592,7 @@ export async function scanRepo(cfg) {
   }
 
   const moduleCounts = new Map();
+  const moduleTestCounts = new Map();
   const flatKeys = new Set();
   const rootLabel = rootModuleLabel(repoRoot);
 
@@ -600,12 +604,14 @@ export async function scanRepo(cfg) {
     const key = moduleKeyForFile(file, cfg.module_roots || [], rootLabel);
     if (!norm(file).includes("/")) flatKeys.add(key);
     moduleCounts.set(key, (moduleCounts.get(key) || 0) + 1);
+    if (isTestPath(file)) moduleTestCounts.set(key, (moduleTestCounts.get(key) || 0) + 1);
   }
 
   const modules = [...moduleCounts.entries()]
     .map(([key, fileCount]) => ({
       key,
       fileCount,
+      ...(moduleTestCounts.get(key) ? { testFileCount: moduleTestCounts.get(key) } : {}),
       ...(flatKeys.has(key) ? { flat: true } : {}),
     }))
     .sort((a, b) => b.fileCount - a.fileCount);