@viberails/scanner 0.1.0

package/dist/index.js

@@ -0,0 +1,744 @@
+// src/compute-statistics.ts
+import { readdir as readdir2, readFile } from "fs/promises";
+import { extname, join as join2 } from "path";
+
+// src/utils/walk-directory.ts
+import { readdir } from "fs/promises";
+import { join, relative } from "path";
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  ".viberails",
+  "coverage",
+  ".turbo",
+  ".cache",
+  ".output"
+]);
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".vue",
+  ".svelte",
+  ".astro"
+]);
+async function walkDirectory(projectPath, maxDepth = 4) {
+  const results = [];
+  const queue = [];
+  try {
+    const rootEntries = await readdir(projectPath, { withFileTypes: true });
+    for (const entry of rootEntries) {
+      if (entry.isDirectory() && !entry.isSymbolicLink() && !IGNORED_DIRS.has(entry.name)) {
+        queue.push({ absolutePath: join(projectPath, entry.name), depth: 1 });
+      }
+    }
+  } catch {
+    return results;
+  }
+  while (queue.length > 0) {
+    const { absolutePath, depth } = queue.shift();
+    const sourceFileNames = [];
+    try {
+      const entries = await readdir(absolutePath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isSymbolicLink()) continue;
+        if (entry.isDirectory() && depth < maxDepth && !IGNORED_DIRS.has(entry.name)) {
+          queue.push({ absolutePath: join(absolutePath, entry.name), depth: depth + 1 });
+        } else if (entry.isFile()) {
+          const dotIndex = entry.name.lastIndexOf(".");
+          if (dotIndex > 0) {
+            const ext = entry.name.substring(dotIndex);
+            if (SOURCE_EXTENSIONS.has(ext)) {
+              sourceFileNames.push(entry.name);
+            }
+          }
+        }
+      }
+    } catch {
+      continue;
+    }
+    const rel = relative(projectPath, absolutePath).split("\\").join("/");
+    results.push({
+      relativePath: rel,
+      absolutePath,
+      sourceFileCount: sourceFileNames.length,
+      sourceFileNames,
+      depth
+    });
+  }
+  return results;
+}
+
+// src/compute-statistics.ts
+async function countLines(filePath) {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    if (content.length === 0) return 0;
+    let count = 0;
+    for (let i = 0; i < content.length; i++) {
+      if (content.charCodeAt(i) === 10) count++;
+    }
+    if (content.charCodeAt(content.length - 1) !== 10) count++;
+    return count;
+  } catch {
+    return 0;
+  }
+}
+async function getRootSourceFiles(projectPath) {
+  try {
+    const entries = await readdir2(projectPath, { withFileTypes: true });
+    const sourceFiles = [];
+    for (const entry of entries) {
+      if (entry.isFile()) {
+        const ext = extname(entry.name);
+        if (SOURCE_EXTENSIONS.has(ext)) {
+          sourceFiles.push(entry.name);
+        }
+      }
+    }
+    return sourceFiles;
+  } catch {
+    return [];
+  }
+}
+async function computeStatistics(projectPath, dirs) {
+  const directories = dirs ?? await walkDirectory(projectPath);
+  const rootFiles = await getRootSourceFiles(projectPath);
+  const filesToProcess = [];
+  for (const name of rootFiles) {
+    filesToProcess.push({
+      relativePath: name,
+      absolutePath: join2(projectPath, name),
+      ext: extname(name)
+    });
+  }
+  for (const dir of directories) {
+    for (const name of dir.sourceFileNames) {
+      filesToProcess.push({
+        relativePath: `${dir.relativePath}/${name}`,
+        absolutePath: join2(dir.absolutePath, name),
+        ext: extname(name)
+      });
+    }
+  }
+  const totalFiles = filesToProcess.length;
+  if (totalFiles === 0) {
+    return {
+      totalFiles: 0,
+      totalLines: 0,
+      averageFileLines: 0,
+      largestFiles: [],
+      filesByExtension: {}
+    };
+  }
+  const lineResults = await Promise.all(
+    filesToProcess.map(async (file) => ({
+      path: file.relativePath,
+      lines: await countLines(file.absolutePath),
+      ext: file.ext
+    }))
+  );
+  let totalLines = 0;
+  const filesByExtension = {};
+  const allFiles = [];
+  for (const result of lineResults) {
+    totalLines += result.lines;
+    filesByExtension[result.ext] = (filesByExtension[result.ext] ?? 0) + 1;
+    allFiles.push({ path: result.path, lines: result.lines });
+  }
+  allFiles.sort((a, b) => b.lines - a.lines);
+  const largestFiles = allFiles.slice(0, 5);
+  return {
+    totalFiles,
+    totalLines,
+    averageFileLines: Math.round(totalLines / totalFiles),
+    largestFiles,
+    filesByExtension
+  };
+}
+
+// src/detect-conventions.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join3 } from "path";
+import { confidenceFromConsistency } from "@viberails/types";
+
+// src/utils/classify-filename.ts
+var PATTERNS = [
+  { convention: "PascalCase", regex: /^[A-Z][a-zA-Z0-9]*$/ },
+  { convention: "camelCase", regex: /^[a-z][a-zA-Z0-9]*[A-Z][a-zA-Z0-9]*$/ },
+  { convention: "kebab-case", regex: /^[a-z][a-z0-9]*(-[a-z0-9]+)+$/ },
+  { convention: "snake_case", regex: /^[a-z][a-z0-9]*(_[a-z0-9]+)+$/ }
+];
+function classifyFilename(filename) {
+  for (const { convention, regex } of PATTERNS) {
+    if (regex.test(filename)) return convention;
+  }
+  return "unknown";
+}
+
+// src/detect-conventions.ts
+async function detectConventions(projectPath, structure, dirs) {
+  if (!dirs) {
+    dirs = await walkDirectory(projectPath, 4);
+  }
+  const result = {};
+  const fileNaming = detectFileNaming(dirs);
+  if (fileNaming) result.fileNaming = fileNaming;
+  const componentNaming = detectComponentNaming(dirs, structure);
+  if (componentNaming) result.componentNaming = componentNaming;
+  const hookNaming = detectHookNaming(dirs, structure);
+  if (hookNaming) result.hookNaming = hookNaming;
+  const importAlias = await detectImportAlias(projectPath);
+  if (importAlias) result.importAlias = importAlias;
+  return result;
+}
+function stripExtension(filename) {
+  const firstDot = filename.indexOf(".");
+  return firstDot > 0 ? filename.substring(0, firstDot) : filename;
+}
+function detectFileNaming(dirs) {
+  const conventionCounts = /* @__PURE__ */ new Map();
+  let total = 0;
+  for (const dir of dirs) {
+    if (dir.sourceFileCount < 3) continue;
+    for (const filename of dir.sourceFileNames) {
+      if (filename.includes(".test.") || filename.includes(".spec.")) continue;
+      const bare = stripExtension(filename);
+      if (bare === "index") continue;
+      const convention = classifyFilename(bare);
+      total++;
+      if (convention !== "unknown") {
+        conventionCounts.set(convention, (conventionCounts.get(convention) ?? 0) + 1);
+      }
+    }
+  }
+  if (total < 3) return void 0;
+  const sorted = [...conventionCounts.entries()].sort((a, b) => b[1] - a[1]);
+  if (sorted.length === 0) return void 0;
+  const [dominantConvention, dominantCount] = sorted[0];
+  const consistency = Math.round(dominantCount / total * 100);
+  const confidence = confidenceFromConsistency(consistency);
+  if (confidence === "low") return void 0;
+  return {
+    value: dominantConvention,
+    confidence,
+    sampleSize: total,
+    consistency
+  };
+}
+function detectComponentNaming(dirs, structure) {
+  const componentPaths = new Set(
+    structure.directories.filter((d) => d.role === "components").map((d) => d.path)
+  );
+  const tsxFiles = [];
+  for (const dir of dirs) {
+    if (!componentPaths.has(dir.relativePath)) continue;
+    for (const f of dir.sourceFileNames) {
+      if (f.endsWith(".tsx")) tsxFiles.push(f);
+    }
+  }
+  if (tsxFiles.length < 3) return void 0;
+  const pascalCount = tsxFiles.filter((f) => /^[A-Z]/.test(stripExtension(f))).length;
+  const consistency = Math.round(pascalCount / tsxFiles.length * 100);
+  const dominantValue = pascalCount >= tsxFiles.length / 2 ? "PascalCase" : "camelCase";
+  return {
+    value: dominantValue,
+    confidence: confidenceFromConsistency(consistency),
+    sampleSize: tsxFiles.length,
+    consistency
+  };
+}
+function detectHookNaming(dirs, structure) {
+  const hookPaths = new Set(
+    structure.directories.filter((d) => d.role === "hooks").map((d) => d.path)
+  );
+  const hookFiles = [];
+  for (const dir of dirs) {
+    if (!hookPaths.has(dir.relativePath)) continue;
+    for (const f of dir.sourceFileNames) {
+      const bare = stripExtension(f);
+      if (bare.startsWith("use-") || /^use[A-Z]/.test(bare)) {
+        hookFiles.push(f);
+      }
+    }
+  }
+  if (hookFiles.length < 3) return void 0;
+  let kebabCount = 0;
+  let camelCount = 0;
+  for (const filename of hookFiles) {
+    const bare = stripExtension(filename);
+    if (bare.startsWith("use-")) {
+      kebabCount++;
+    } else if (/^use[A-Z]/.test(bare)) {
+      camelCount++;
+    }
+  }
+  const total = hookFiles.length;
+  const isDominantKebab = kebabCount >= camelCount;
+  const dominantCount = isDominantKebab ? kebabCount : camelCount;
+  const consistency = Math.round(dominantCount / total * 100);
+  return {
+    value: isDominantKebab ? "use-*" : "useXxx",
+    confidence: confidenceFromConsistency(consistency),
+    sampleSize: total,
+    consistency
+  };
+}
+async function detectImportAlias(projectPath) {
+  try {
+    const raw = await readFile2(join3(projectPath, "tsconfig.json"), "utf-8");
+    const tsconfig = JSON.parse(raw);
+    const paths = tsconfig.compilerOptions?.paths;
+    if (!paths) return void 0;
+    const aliases = Object.keys(paths);
+    if (aliases.length === 0) return void 0;
+    return {
+      value: aliases[0],
+      confidence: "high",
+      sampleSize: aliases.length,
+      consistency: 100
+    };
+  } catch {
+    return void 0;
+  }
+}
+
+// src/detect-stack.ts
+import { access } from "fs/promises";
+import { join as join5 } from "path";
+
+// src/utils/read-package-json.ts
+import { readFile as readFile3 } from "fs/promises";
+import { join as join4 } from "path";
+async function readPackageJson(projectPath) {
+  try {
+    const raw = await readFile3(join4(projectPath, "package.json"), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+// src/detect-stack.ts
+function extractMajorVersion(range) {
+  const match = range.match(/(\d+)/);
+  return match?.[1];
+}
+async function fileExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var FRAMEWORK_MAPPINGS = [
+  { dep: "next", name: "nextjs" },
+  { dep: "@sveltejs/kit", name: "sveltekit" },
+  { dep: "svelte", name: "svelte" },
+  { dep: "astro", name: "astro" },
+  { dep: "vue", name: "vue" },
+  { dep: "react", name: "react", excludeDep: "next" }
+];
+var BACKEND_MAPPINGS = [
+  { dep: "express", name: "express" },
+  { dep: "fastify", name: "fastify" },
+  { dep: "hono", name: "hono" },
+  { dep: "@supabase/supabase-js", name: "supabase" },
+  { dep: "firebase", name: "firebase" },
+  { dep: "@prisma/client", name: "prisma" },
+  { dep: "prisma", name: "prisma" },
+  { dep: "drizzle-orm", name: "drizzle" }
+];
+var STYLING_MAPPINGS = [
+  { dep: "tailwindcss", name: "tailwindcss" },
+  { dep: "styled-components", name: "styled-components" },
+  { dep: "@emotion/react", name: "emotion" },
+  { dep: "sass", name: "sass" }
+];
+var LIBRARY_MAPPINGS = [
+  { deps: ["zod"], name: "zod" },
+  { deps: ["@trpc/server", "@trpc/client"], name: "trpc" },
+  { deps: ["@tanstack/react-query"], name: "react-query" }
+];
+var LOCK_FILE_MAP = [
+  { file: "pnpm-lock.yaml", name: "pnpm" },
+  { file: "yarn.lock", name: "yarn" },
+  { file: "bun.lockb", name: "bun" },
+  { file: "package-lock.json", name: "npm" }
+];
+async function detectStack(projectPath) {
+  const pkg = await readPackageJson(projectPath);
+  const allDeps = {
+    ...pkg?.dependencies,
+    ...pkg?.devDependencies
+  };
+  const framework = detectFramework(allDeps);
+  const language = await detectLanguage(projectPath, allDeps);
+  const styling = detectFirst(allDeps, STYLING_MAPPINGS);
+  const backend = detectFirst(allDeps, BACKEND_MAPPINGS);
+  const packageManager = await detectPackageManager(projectPath);
+  const linter = detectLinter(allDeps);
+  const testRunner = detectTestRunner(allDeps);
+  const libraries = detectLibraries(allDeps);
+  return {
+    ...framework && { framework },
+    language,
+    ...styling && { styling },
+    ...backend && { backend },
+    packageManager,
+    ...linter && { linter },
+    ...testRunner && { testRunner },
+    libraries
+  };
+}
+function detectFramework(allDeps) {
+  for (const mapping of FRAMEWORK_MAPPINGS) {
+    if (!(mapping.dep in allDeps)) continue;
+    if (mapping.excludeDep && mapping.excludeDep in allDeps) continue;
+    return {
+      name: mapping.name,
+      version: extractMajorVersion(allDeps[mapping.dep])
+    };
+  }
+  return void 0;
+}
+async function detectLanguage(projectPath, allDeps) {
+  if ("typescript" in allDeps) {
+    return {
+      name: "typescript",
+      version: extractMajorVersion(allDeps.typescript)
+    };
+  }
+  if (await fileExists(join5(projectPath, "tsconfig.json"))) {
+    return { name: "typescript" };
+  }
+  return { name: "javascript" };
+}
+function detectFirst(allDeps, mappings) {
+  for (const mapping of mappings) {
+    if (mapping.dep in allDeps) {
+      return {
+        name: mapping.name,
+        version: extractMajorVersion(allDeps[mapping.dep])
+      };
+    }
+  }
+  return void 0;
+}
+async function detectPackageManager(projectPath) {
+  for (const entry of LOCK_FILE_MAP) {
+    if (await fileExists(join5(projectPath, entry.file))) {
+      return { name: entry.name };
+    }
+  }
+  return { name: "npm" };
+}
+function detectLinter(allDeps) {
+  if ("eslint" in allDeps) {
+    return { name: "eslint", version: extractMajorVersion(allDeps.eslint) };
+  }
+  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) };
+  }
+  if ("jest" in allDeps) {
+    return { name: "jest", version: extractMajorVersion(allDeps.jest) };
+  }
+  return void 0;
+}
+function detectLibraries(allDeps) {
+  const libs = [];
+  for (const mapping of LIBRARY_MAPPINGS) {
+    const found = mapping.deps.find((dep) => dep in allDeps);
+    if (found) {
+      libs.push({
+        name: mapping.name,
+        version: extractMajorVersion(allDeps[found])
+      });
+    }
+  }
+  return libs;
+}
+
+// src/detect-structure.ts
+import { confidenceFromConsistency as confidenceFromConsistency2 } from "@viberails/types";
+
+// src/utils/classify-directory.ts
+var ROLE_PATTERNS = [
+  { role: "pages", pathPatterns: ["src/app", "src/pages", "app", "pages"] },
+  { role: "components", pathPatterns: ["src/components", "components"] },
+  { role: "hooks", pathPatterns: ["src/hooks", "hooks"] },
+  {
+    role: "utils",
+    pathPatterns: ["src/lib", "src/utils", "src/helpers", "lib", "utils", "helpers"]
+  },
+  { role: "types", pathPatterns: ["src/types", "types", "src/@types", "@types"] },
+  { role: "tests", pathPatterns: ["__tests__", "tests", "test", "src/__tests__", "src/tests"] },
+  { role: "styles", pathPatterns: ["src/styles", "styles", "src/css", "css"] },
+  { role: "api", pathPatterns: ["src/api", "api", "src/app/api", "app/api"] },
+  { role: "config", pathPatterns: ["config", "src/config"] }
+];
+function classifyDirectory(dir) {
+  const nameMatch = matchByName(dir.relativePath);
+  if (nameMatch) {
+    const confidence = dir.sourceFileCount > 0 ? "high" : "low";
+    return {
+      path: dir.relativePath,
+      role: nameMatch,
+      fileCount: dir.sourceFileCount,
+      confidence
+    };
+  }
+  if (dir.sourceFileCount === 0) return null;
+  const contentRole = inferFromContent(dir);
+  if (contentRole) return contentRole;
+  return {
+    path: dir.relativePath,
+    role: "unknown",
+    fileCount: dir.sourceFileCount,
+    confidence: "low"
+  };
+}
+function matchByName(relativePath) {
+  for (const { role, pathPatterns } of ROLE_PATTERNS) {
+    for (const pattern of pathPatterns) {
+      if (relativePath === pattern) return role;
+    }
+  }
+  return null;
+}
+function inferFromContent(dir) {
+  const { sourceFileNames, sourceFileCount } = dir;
+  const hookFiles = sourceFileNames.filter((f) => {
+    const name = f.split(".")[0];
+    return name.startsWith("use-") || /^use[A-Z]/.test(name);
+  });
+  if (hookFiles.length > 0 && hookFiles.length / sourceFileCount >= 0.5) {
+    return {
+      path: dir.relativePath,
+      role: "hooks",
+      fileCount: sourceFileCount,
+      confidence: hookFiles.length / sourceFileCount >= 0.9 ? "high" : "medium"
+    };
+  }
+  const testFiles = sourceFileNames.filter((f) => f.includes(".test.") || f.includes(".spec."));
+  if (testFiles.length > 0 && testFiles.length / sourceFileCount >= 0.5) {
+    return {
+      path: dir.relativePath,
+      role: "tests",
+      fileCount: sourceFileCount,
+      confidence: testFiles.length / sourceFileCount >= 0.9 ? "high" : "medium"
+    };
+  }
+  return null;
+}
+
+// src/detect-structure.ts
+async function detectStructure(projectPath, dirs) {
+  if (!dirs) {
+    dirs = await walkDirectory(projectPath, 4);
+  }
+  const hasSrcDir = dirs.some((d) => d.relativePath === "src" || d.relativePath.startsWith("src/"));
+  const srcDir = hasSrcDir ? "src" : void 0;
+  const directories = dirs.map((d) => classifyDirectory(d)).filter((d) => d !== null);
+  const testPattern = detectTestPattern(dirs);
+  return {
+    ...srcDir !== void 0 && { srcDir },
+    directories,
+    ...testPattern !== void 0 && { testPattern }
+  };
+}
+function detectTestPattern(dirs) {
+  const allFiles = dirs.flatMap((d) => d.sourceFileNames);
+  const testFiles = allFiles.filter((f) => f.includes(".test.") || f.includes(".spec."));
+  if (testFiles.length < 3) return void 0;
+  const dotTestCount = testFiles.filter((f) => f.includes(".test.")).length;
+  const dotSpecCount = testFiles.filter((f) => f.includes(".spec.")).length;
+  const isDotTest = dotTestCount >= dotSpecCount;
+  const dominantSep = isDotTest ? ".test." : ".spec.";
+  const dominantCount = isDotTest ? dotTestCount : dotSpecCount;
+  const consistency = Math.round(dominantCount / testFiles.length * 100);
+  const extCounts = /* @__PURE__ */ new Map();
+  for (const f of testFiles.filter((f2) => f2.includes(dominantSep))) {
+    const ext = f.substring(f.lastIndexOf("."));
+    extCounts.set(ext, (extCounts.get(ext) ?? 0) + 1);
+  }
+  const topExt = [...extCounts.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? ".ts";
+  const sep = isDotTest ? "test" : "spec";
+  return {
+    value: `*.${sep}${topExt}`,
+    confidence: confidenceFromConsistency2(consistency),
+    sampleSize: testFiles.length,
+    consistency
+  };
+}
+
+// src/detect-workspace.ts
+import { readdir as readdir3, readFile as readFile4 } from "fs/promises";
+import { join as join6, relative as relative2 } from "path";
+async function detectWorkspace(projectRoot) {
+  const patterns = await readWorkspacePatterns(projectRoot);
+  if (!patterns || patterns.length === 0) return void 0;
+  const packageDirs = await resolvePatterns(projectRoot, patterns);
+  const packages = await resolvePackages(projectRoot, packageDirs);
+  if (packages.length === 0) return void 0;
+  const packageNames = new Set(packages.map((p) => p.name));
+  for (const pkg of packages) {
+    pkg.internalDeps = pkg.internalDeps.filter((dep) => packageNames.has(dep));
+  }
+  return { patterns, packages };
+}
+async function readWorkspacePatterns(projectRoot) {
+  try {
+    const yaml = await readFile4(join6(projectRoot, "pnpm-workspace.yaml"), "utf-8");
+    return parsePnpmWorkspaceYaml(yaml);
+  } catch {
+  }
+  const pkg = await readPackageJson(projectRoot);
+  if (!pkg) return void 0;
+  const raw = pkg;
+  const workspaces = raw.workspaces;
+  if (Array.isArray(workspaces)) {
+    return workspaces.filter((w) => typeof w === "string");
+  }
+  if (workspaces && typeof workspaces === "object" && "packages" in workspaces) {
+    const nested = workspaces.packages;
+    if (Array.isArray(nested)) {
+      return nested.filter((w) => typeof w === "string");
+    }
+  }
+  return void 0;
+}
+function parsePnpmWorkspaceYaml(content) {
+  const patterns = [];
+  let inPackages = false;
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "packages:") {
+      inPackages = true;
+      continue;
+    }
+    if (inPackages && trimmed.length > 0 && !trimmed.startsWith("-")) {
+      break;
+    }
+    if (inPackages && trimmed.startsWith("-")) {
+      const value = trimmed.slice(1).trim().replace(/^['"]|['"]$/g, "");
+      if (value) patterns.push(value);
+    }
+  }
+  return patterns;
+}
+async function resolvePatterns(projectRoot, patterns) {
+  const dirs = [];
+  for (const pattern of patterns) {
+    if (pattern.endsWith("/*")) {
+      const parent = join6(projectRoot, pattern.slice(0, -2));
+      try {
+        const entries = await readdir3(parent, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            dirs.push(join6(parent, entry.name));
+          }
+        }
+      } catch {
+      }
+    } else {
+      dirs.push(join6(projectRoot, pattern));
+    }
+  }
+  return dirs;
+}
+async function resolvePackages(projectRoot, dirs) {
+  const packages = [];
+  for (const dir of dirs) {
+    const pkg = await readPackageJson(dir);
+    if (!pkg?.name) continue;
+    const allDeps = [
+      ...Object.keys(pkg.dependencies ?? {}),
+      ...Object.keys(pkg.devDependencies ?? {})
+    ];
+    packages.push({
+      name: pkg.name,
+      path: dir,
+      relativePath: relative2(projectRoot, dir),
+      internalDeps: allDeps
+    });
+  }
+  return packages;
+}
+
+// src/scan.ts
+import { stat } from "fs/promises";
+import { resolve } from "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 scan(projectPath, _options) {
+  const root = resolve(projectPath);
+  try {
+    const st = await stat(root);
+    if (!st.isDirectory()) {
+      throw new Error(`Project path is not a directory: ${root}`);
+    }
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith("Project path is not")) {
+      throw err;
+    }
+    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);
+  return {
+    root,
+    stack,
+    structure,
+    conventions,
+    statistics,
+    workspace
+  };
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+export {
+  VERSION,
+  computeStatistics,
+  detectConventions,
+  detectStack,
+  detectStructure,
+  detectWorkspace,
+  extractMajorVersion,
+  readPackageJson,
+  scan,
+  walkDirectory
+};
+//# sourceMappingURL=index.js.map