@viberails/scanner 0.1.0 → 0.2.1

package/dist/index.cjs

@@ -21,6 +21,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   VERSION: () => VERSION,
+  aggregateConventions: () => aggregateConventions,
+  aggregateStacks: () => aggregateStacks,
+  aggregateStatistics: () => aggregateStatistics,
+  aggregateStructures: () => aggregateStructures,
   computeStatistics: () => computeStatistics,
   detectConventions: () => detectConventions,
   detectStack: () => detectStack,
@@ -29,10 +33,161 @@ __export(index_exports, {
   extractMajorVersion: () => extractMajorVersion,
   readPackageJson: () => readPackageJson,
   scan: () => scan,
+  scanPackage: () => scanPackage,
   walkDirectory: () => walkDirectory
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/aggregate.ts
+var import_types = require("@viberails/types");
+var FRAMEWORK_PRIORITY = [
+  "nextjs",
+  "sveltekit",
+  "astro",
+  "expo",
+  "react-native",
+  "svelte",
+  "vue",
+  "react"
+];
+function aggregateStacks(packages) {
+  if (packages.length === 1) return packages[0].stack;
+  const language = packages.some((p) => p.stack.language.name === "typescript") ? packages.find((p) => p.stack.language.name === "typescript").stack.language : packages[0].stack.language;
+  const packageManager = packages[0].stack.packageManager;
+  const frameworkPackages = packages.filter((p) => p.stack.framework);
+  let framework;
+  if (frameworkPackages.length > 0) {
+    frameworkPackages.sort((a, b) => {
+      const aIdx = FRAMEWORK_PRIORITY.indexOf(a.stack.framework.name);
+      const bIdx = FRAMEWORK_PRIORITY.indexOf(b.stack.framework.name);
+      return (aIdx === -1 ? Infinity : aIdx) - (bIdx === -1 ? Infinity : bIdx);
+    });
+    framework = frameworkPackages[0].stack.framework;
+  }
+  const libraryMap = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    if (pkg.stack.framework && pkg.stack.framework.name !== framework?.name) {
+      libraryMap.set(pkg.stack.framework.name, pkg.stack.framework);
+    }
+    for (const lib of pkg.stack.libraries) {
+      if (!libraryMap.has(lib.name)) {
+        libraryMap.set(lib.name, lib);
+      }
+    }
+  }
+  const styling = packages.find((p) => p.stack.styling)?.stack.styling;
+  const backend = packages.find((p) => p.stack.backend)?.stack.backend;
+  const linter = packages.find((p) => p.stack.linter)?.stack.linter;
+  const formatter = packages.find((p) => p.stack.formatter)?.stack.formatter;
+  const testRunner = packages.find((p) => p.stack.testRunner)?.stack.testRunner;
+  return {
+    language,
+    packageManager,
+    framework,
+    libraries: [...libraryMap.values()],
+    styling,
+    backend,
+    linter,
+    formatter,
+    testRunner
+  };
+}
+function aggregateStructures(packages) {
+  if (packages.length === 1) return packages[0].structure;
+  const srcDir = packages.some((p) => p.structure.srcDir) ? "src" : void 0;
+  const directories = packages.flatMap(
+    (pkg) => pkg.structure.directories.map((dir) => ({
+      ...dir,
+      path: pkg.relativePath ? `${pkg.relativePath}/${dir.path}` : dir.path
+    }))
+  );
+  const testPatterns = packages.map((p) => p.structure.testPattern).filter((t) => t !== void 0);
+  let testPattern;
+  if (testPatterns.length > 0) {
+    const counts = /* @__PURE__ */ new Map();
+    for (const tp of testPatterns) {
+      const existing = counts.get(tp.value);
+      if (existing) {
+        existing.count++;
+      } else {
+        counts.set(tp.value, { count: 1, pattern: tp });
+      }
+    }
+    let best = { count: 0, pattern: testPatterns[0] };
+    for (const entry of counts.values()) {
+      if (entry.count > best.count) best = entry;
+    }
+    testPattern = best.pattern;
+  }
+  return { srcDir, directories, testPattern };
+}
+function aggregateConventions(packages) {
+  if (packages.length === 1) return packages[0].conventions;
+  const allKeys = /* @__PURE__ */ new Set();
+  for (const pkg of packages) {
+    for (const key of Object.keys(pkg.conventions)) {
+      allKeys.add(key);
+    }
+  }
+  const result = {};
+  for (const key of allKeys) {
+    const entries = packages.map((p) => p.conventions[key]).filter((c) => c !== void 0);
+    if (entries.length < packages.length / 2) continue;
+    const valueCounts = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const existing = valueCounts.get(entry.value);
+      if (existing) {
+        existing.count++;
+        existing.totalConsistency += entry.consistency;
+        existing.totalSamples += entry.sampleSize;
+      } else {
+        valueCounts.set(entry.value, {
+          count: 1,
+          totalConsistency: entry.consistency,
+          totalSamples: entry.sampleSize
+        });
+      }
+    }
+    let majorityValue = "";
+    let majorityData = { count: 0, totalConsistency: 0, totalSamples: 0 };
+    for (const [value, data] of valueCounts) {
+      if (data.count > majorityData.count) {
+        majorityValue = value;
+        majorityData = data;
+      }
+    }
+    const agreement = majorityData.count / entries.length;
+    const avgConsistency = majorityData.totalConsistency / majorityData.count;
+    const consistency = Math.round(avgConsistency * agreement);
+    result[key] = {
+      value: majorityValue,
+      confidence: (0, import_types.confidenceFromConsistency)(consistency),
+      sampleSize: majorityData.totalSamples,
+      consistency
+    };
+  }
+  return result;
+}
+function aggregateStatistics(packages) {
+  if (packages.length === 1) return packages[0].statistics;
+  const totalFiles = packages.reduce((sum, p) => sum + p.statistics.totalFiles, 0);
+  const totalLines = packages.reduce((sum, p) => sum + p.statistics.totalLines, 0);
+  const averageFileLines = totalFiles > 0 ? Math.round(totalLines / totalFiles) : 0;
+  const largestFiles = packages.flatMap(
+    (pkg) => pkg.statistics.largestFiles.map((f) => ({
+      path: pkg.relativePath ? `${pkg.relativePath}/${f.path}` : f.path,
+      lines: f.lines
+    }))
+  ).sort((a, b) => b.lines - a.lines).slice(0, 5);
+  const filesByExtension = {};
+  for (const pkg of packages) {
+    for (const [ext, count] of Object.entries(pkg.statistics.filesByExtension)) {
+      filesByExtension[ext] = (filesByExtension[ext] ?? 0) + count;
+    }
+  }
+  return { totalFiles, totalLines, averageFileLines, largestFiles, filesByExtension };
+}
+
 // src/compute-statistics.ts
 var import_promises2 = require("fs/promises");
 var import_node_path2 = require("path");
@@ -51,7 +206,12 @@ var IGNORED_DIRS = /* @__PURE__ */ new Set([
   "coverage",
   ".turbo",
   ".cache",
-  ".output"
+  ".output",
+  ".expo",
+  "android",
+  "ios",
+  "Pods",
+  ".gradle"
 ]);
 var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".ts",
@@ -78,7 +238,9 @@ async function walkDirectory(projectPath, maxDepth = 4) {
     return results;
   }
   while (queue.length > 0) {
-    const { absolutePath, depth } = queue.shift();
+    const item = queue.shift();
+    if (!item) break;
+    const { absolutePath, depth } = item;
     const sourceFileNames = [];
     try {
       const entries = await (0, import_promises.readdir)(absolutePath, { withFileTypes: true });
@@ -202,7 +364,7 @@ async function computeStatistics(projectPath, dirs) {
 // src/detect-conventions.ts
 var import_promises3 = require("fs/promises");
 var import_node_path3 = require("path");
-var import_types = require("@viberails/types");
+var import_types2 = require("@viberails/types");
 
 // src/utils/classify-filename.ts
 var PATTERNS = [
@@ -259,7 +421,7 @@ function detectFileNaming(dirs) {
   if (sorted.length === 0) return void 0;
   const [dominantConvention, dominantCount] = sorted[0];
   const consistency = Math.round(dominantCount / total * 100);
-  const confidence = (0, import_types.confidenceFromConsistency)(consistency);
+  const confidence = (0, import_types2.confidenceFromConsistency)(consistency);
   if (confidence === "low") return void 0;
   return {
     value: dominantConvention,
@@ -285,7 +447,7 @@ function detectComponentNaming(dirs, structure) {
   const dominantValue = pascalCount >= tsxFiles.length / 2 ? "PascalCase" : "camelCase";
   return {
     value: dominantValue,
-    confidence: (0, import_types.confidenceFromConsistency)(consistency),
+    confidence: (0, import_types2.confidenceFromConsistency)(consistency),
     sampleSize: tsxFiles.length,
     consistency
   };
@@ -321,7 +483,7 @@ function detectHookNaming(dirs, structure) {
   const consistency = Math.round(dominantCount / total * 100);
   return {
     value: isDominantKebab ? "use-*" : "useXxx",
-    confidence: (0, import_types.confidenceFromConsistency)(consistency),
+    confidence: (0, import_types2.confidenceFromConsistency)(consistency),
     sampleSize: total,
     consistency
   };
@@ -335,7 +497,7 @@ async function detectImportAlias(projectPath) {
     const aliases = Object.keys(paths);
     if (aliases.length === 0) return void 0;
     return {
-      value: aliases[0],
+      value: aliases.join(","),
       confidence: "high",
       sampleSize: aliases.length,
       consistency: 100
@@ -376,6 +538,8 @@ async function fileExists(filePath) {
 }
 var FRAMEWORK_MAPPINGS = [
   { dep: "next", name: "nextjs" },
+  { dep: "expo", name: "expo" },
+  { dep: "react-native", name: "react-native", excludeDep: "expo" },
   { dep: "@sveltejs/kit", name: "sveltekit" },
   { dep: "svelte", name: "svelte" },
   { dep: "astro", name: "astro" },
@@ -409,9 +573,10 @@ var LOCK_FILE_MAP = [
   { file: "bun.lockb", name: "bun" },
   { file: "package-lock.json", name: "npm" }
 ];
-async function detectStack(projectPath) {
+async function detectStack(projectPath, additionalDeps) {
   const pkg = await readPackageJson(projectPath);
   const allDeps = {
+    ...additionalDeps,
     ...pkg?.dependencies,
     ...pkg?.devDependencies
   };
@@ -421,6 +586,7 @@ async function detectStack(projectPath) {
   const backend = detectFirst(allDeps, BACKEND_MAPPINGS);
   const packageManager = await detectPackageManager(projectPath);
   const linter = detectLinter(allDeps);
+  const formatter = detectFormatter(allDeps);
   const testRunner = detectTestRunner(allDeps);
   const libraries = detectLibraries(allDeps);
   return {
@@ -430,6 +596,7 @@ async function detectStack(projectPath) {
     ...backend && { backend },
     packageManager,
     ...linter && { linter },
+    ...formatter && { formatter },
     ...testRunner && { testRunner },
     libraries
   };
@@ -488,6 +655,18 @@ function detectLinter(allDeps) {
   }
   return void 0;
 }
+function detectFormatter(allDeps) {
+  if ("prettier" in allDeps) {
+    return { name: "prettier", version: extractMajorVersion(allDeps.prettier) };
+  }
+  if ("@biomejs/biome" in allDeps) {
+    return {
+      name: "biome",
+      version: extractMajorVersion(allDeps["@biomejs/biome"])
+    };
+  }
+  return void 0;
+}
 function detectTestRunner(allDeps) {
   if ("vitest" in allDeps) {
     return { name: "vitest", version: extractMajorVersion(allDeps.vitest) };
@@ -512,7 +691,7 @@ function detectLibraries(allDeps) {
 }
 
 // src/detect-structure.ts
-var import_types2 = require("@viberails/types");
+var import_types3 = require("@viberails/types");
 
 // src/utils/classify-directory.ts
 var ROLE_PATTERNS = [
@@ -553,7 +732,9 @@ function classifyDirectory(dir) {
 function matchByName(relativePath) {
   for (const { role, pathPatterns } of ROLE_PATTERNS) {
     for (const pattern of pathPatterns) {
-      if (relativePath === pattern) return role;
+      if (relativePath === pattern || relativePath.endsWith(`/${pattern}`)) {
+        return role;
+      }
     }
   }
   return null;
@@ -564,7 +745,7 @@ function inferFromContent(dir) {
     const name = f.split(".")[0];
     return name.startsWith("use-") || /^use[A-Z]/.test(name);
   });
-  if (hookFiles.length > 0 && hookFiles.length / sourceFileCount >= 0.5) {
+  if (hookFiles.length >= 2 && hookFiles.length / sourceFileCount >= 0.5) {
     return {
       path: dir.relativePath,
       role: "hooks",
@@ -573,7 +754,7 @@ function inferFromContent(dir) {
     };
   }
   const testFiles = sourceFileNames.filter((f) => f.includes(".test.") || f.includes(".spec."));
-  if (testFiles.length > 0 && testFiles.length / sourceFileCount >= 0.5) {
+  if (testFiles.length >= 2 && testFiles.length / sourceFileCount >= 0.5) {
     return {
       path: dir.relativePath,
       role: "tests",
@@ -618,7 +799,7 @@ function detectTestPattern(dirs) {
   const sep = isDotTest ? "test" : "spec";
   return {
     value: `*.${sep}${topExt}`,
-    confidence: (0, import_types2.confidenceFromConsistency)(consistency),
+    confidence: (0, import_types3.confidenceFromConsistency)(consistency),
     sampleSize: testFiles.length,
     consistency
   };
@@ -720,18 +901,33 @@ async function resolvePackages(projectRoot, dirs) {
 
 // src/scan.ts
 var import_promises7 = require("fs/promises");
+var import_node_path8 = require("path");
+
+// src/scan-package.ts
 var import_node_path7 = require("path");
-var FIXTURE_PATTERNS = [
-  /^tests\/fixtures(\/|$)/,
-  /^test\/fixtures(\/|$)/,
-  /^__tests__\/fixtures(\/|$)/,
-  /^fixtures(\/|$)/
-];
-function filterFixtureDirs(dirs) {
-  return dirs.filter((d) => !FIXTURE_PATTERNS.some((pattern) => pattern.test(d.relativePath)));
+async function scanPackage(packagePath, name, relativePath, rootDeps) {
+  const root = (0, import_node_path7.resolve)(packagePath);
+  const dirs = await walkDirectory(root, 4);
+  const [stack, structure, statistics] = await Promise.all([
+    detectStack(root, rootDeps),
+    detectStructure(root, dirs),
+    computeStatistics(root, dirs)
+  ]);
+  const conventions = await detectConventions(root, structure, dirs);
+  return {
+    name,
+    root,
+    relativePath,
+    stack,
+    structure,
+    conventions,
+    statistics
+  };
 }
+
+// src/scan.ts
 async function scan(projectPath, _options) {
-  const root = (0, import_node_path7.resolve)(projectPath);
+  const root = (0, import_node_path8.resolve)(projectPath);
   try {
     const st = await (0, import_promises7.stat)(root);
     if (!st.isDirectory()) {
@@ -743,22 +939,36 @@ async function scan(projectPath, _options) {
     }
     throw new Error(`Project path does not exist: ${root}`);
   }
-  const allDirs = await walkDirectory(root, 4);
-  const dirs = filterFixtureDirs(allDirs);
-  const [stack, structure, statistics] = await Promise.all([
-    detectStack(root),
-    detectStructure(root, dirs),
-    computeStatistics(root, dirs)
-  ]);
-  const conventions = await detectConventions(root, structure, dirs);
   const workspace = await detectWorkspace(root);
+  if (workspace && workspace.packages.length > 0) {
+    const rootPkg2 = await readPackageJson(root);
+    const rootDeps = {
+      ...rootPkg2?.dependencies,
+      ...rootPkg2?.devDependencies
+    };
+    const packages = await Promise.all(
+      workspace.packages.map((wp) => scanPackage(wp.path, wp.name, wp.relativePath, rootDeps))
+    );
+    return {
+      root,
+      stack: aggregateStacks(packages),
+      structure: aggregateStructures(packages),
+      conventions: aggregateConventions(packages),
+      statistics: aggregateStatistics(packages),
+      workspace,
+      packages
+    };
+  }
+  const rootPkg = await readPackageJson(root);
+  const name = rootPkg?.name ?? (0, import_node_path8.basename)(root);
+  const pkg = await scanPackage(root, name, "");
   return {
     root,
-    stack,
-    structure,
-    conventions,
-    statistics,
-    workspace
+    stack: pkg.stack,
+    structure: pkg.structure,
+    conventions: pkg.conventions,
+    statistics: pkg.statistics,
+    packages: [pkg]
   };
 }
 
@@ -767,6 +977,10 @@ var VERSION = "0.1.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   VERSION,
+  aggregateConventions,
+  aggregateStacks,
+  aggregateStatistics,
+  aggregateStructures,
   computeStatistics,
   detectConventions,
   detectStack,
@@ -775,6 +989,7 @@ var VERSION = "0.1.0";
   extractMajorVersion,
   readPackageJson,
   scan,
+  scanPackage,
   walkDirectory
 });
 //# sourceMappingURL=index.cjs.map