deep-slop 1.4.1

package/dist/discover-B_S_Fy2S.js

@@ -0,0 +1,164 @@
+import { existsSync, readFileSync } from "node:fs";
+import { extname, join, relative } from "node:path";
+import { readFile, readdir } from "node:fs/promises";
+import { minimatch } from "minimatch";
+import micromatch from "micromatch";
+
+//#region src/utils/discover.ts
+/** File extension → language mapping */
+const EXT_MAP = {
+	".ts": "typescript",
+	".tsx": "typescript",
+	".js": "javascript",
+	".jsx": "javascript",
+	".mjs": "javascript",
+	".cjs": "javascript",
+	".py": "python",
+	".go": "go",
+	".rs": "rust",
+	".rb": "ruby",
+	".php": "php",
+	".java": "java"
+};
+/** Detect languages from file extensions in the project */
+async function detectLanguages(rootDir) {
+	const langCounts = /* @__PURE__ */ new Map();
+	await walkDir(rootDir, async (filePath) => {
+		const lang = EXT_MAP[extname(filePath)];
+		if (lang) langCounts.set(lang, (langCounts.get(lang) ?? 0) + 1);
+	}, void 0);
+	return [...langCounts.entries()].sort((a, b) => b[1] - a[1]).map(([lang]) => lang);
+}
+/** Detect frameworks from config files and dependencies */
+async function detectFrameworks(rootDir) {
+	const frameworks = [];
+	try {
+		const pkgPath = join(rootDir, "package.json");
+		const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+		const allDeps = {
+			...pkg.dependencies,
+			...pkg.devDependencies
+		};
+		if (allDeps["next"]) frameworks.push("next.js");
+		if (allDeps["react"]) frameworks.push("react");
+		if (allDeps["vue"] || allDeps["@vue/compiler-sfc"]) frameworks.push("vue");
+		if (allDeps["svelte"] || allDeps["@sveltejs/kit"]) frameworks.push("svelte");
+		if (allDeps["@angular/core"]) frameworks.push("angular");
+		if (allDeps["express"]) frameworks.push("express");
+		if (allDeps["fastify"]) frameworks.push("fastify");
+		if (allDeps["@nestjs/core"]) frameworks.push("nestjs");
+	} catch {}
+	try {
+		const req = await readFile(join(rootDir, "requirements.txt"), "utf-8");
+		if (req.includes("django")) frameworks.push("django");
+		if (req.includes("flask")) frameworks.push("flask");
+		if (req.includes("fastapi")) frameworks.push("fastapi");
+	} catch {}
+	try {
+		if ((await readFile(join(rootDir, "Gemfile"), "utf-8")).includes("rails")) frameworks.push("rails");
+	} catch {}
+	try {
+		const compPath = join(rootDir, "composer.json");
+		if (JSON.parse(await readFile(compPath, "utf-8")).require?.["laravel/framework"]) frameworks.push("laravel");
+	} catch {}
+	if (frameworks.length === 0) frameworks.push("none");
+	return frameworks;
+}
+/**
+* Load .deep-slopignore patterns from the project root.
+* Returns an array of glob patterns (lines that are not empty or comments).
+*/
+function loadDeepSlopIgnore(rootDir) {
+	const ignorePath = join(rootDir, ".deep-slopignore");
+	if (!existsSync(ignorePath)) return [];
+	try {
+		return readFileSync(ignorePath, "utf-8").split("\n").map((line) => line.trim()).filter((line) => line !== "" && !line.startsWith("#"));
+	} catch {
+		return [];
+	}
+}
+/**
+* Check if a relative file path matches any ignore pattern using minimatch.
+* Supports gitignore-style glob patterns.
+*/
+function matchesIgnorePattern(relPath, patterns) {
+	for (const pattern of patterns) {
+		if (pattern.startsWith("!")) continue;
+		if (minimatch(relPath, pattern, { dot: true })) return true;
+		if (!pattern.includes("/")) {
+			if (minimatch(relPath.split("/").pop() ?? "", pattern, { dot: true })) return true;
+		}
+	}
+	return false;
+}
+/** Collect all source files to scan */
+async function collectFiles(rootDir, languages, excludePatterns = [], includeFiles, ignorePatterns, includePatterns) {
+	if (includeFiles) {
+		let files = includeFiles.map((f) => f.startsWith("/") ? f : join(rootDir, f));
+		if (ignorePatterns && ignorePatterns.length > 0) files = files.filter((f) => {
+			return !matchesIgnorePattern(relative(rootDir, f), ignorePatterns);
+		});
+		return files;
+	}
+	const targetExts = new Set(Object.entries(EXT_MAP).filter(([, lang]) => languages.includes(lang)).map(([ext]) => ext));
+	const allIgnorePatterns = [...loadDeepSlopIgnore(rootDir), ...ignorePatterns ?? []];
+	const excludeSet = new Set(excludePatterns);
+	const files = [];
+	await walkDir(rootDir, async (filePath) => {
+		const relPath = relative(rootDir, filePath);
+		if (isExcluded(relPath, excludeSet)) return;
+		if (allIgnorePatterns.length > 0 && matchesIgnorePattern(relPath, allIgnorePatterns)) return;
+		const ext = extname(filePath);
+		if (targetExts.has(ext)) {
+			if (includePatterns && includePatterns.length > 0) {
+				if (!includePatterns.some((pat) => minimatch(relPath, pat, { dot: true }) || !pat.includes("/") && minimatch(filePath.split("/").pop() ?? "", pat, { dot: true }))) return;
+			}
+			files.push(filePath);
+		}
+	}, excludeSet);
+	return files;
+}
+/** Check if path matches any exclude pattern */
+function isExcluded(relPath, excludes) {
+	const segments = relPath.split("/");
+	const patterns = [...excludes];
+	for (const pattern of patterns) if (segments.some((s) => s === pattern)) return true;
+	if (micromatch.isMatch(relPath, patterns)) return true;
+	return false;
+}
+/** Directories to always skip during walk (never recurse into) */
+const SKIP_DIR_NAMES = new Set([
+	"node_modules",
+	".git",
+	"dist",
+	"build",
+	"coverage",
+	".next",
+	".nuxt",
+	".pnpm-store",
+	".turbo",
+	".vercel",
+	".cache",
+	"tmp-",
+	"__pycache__",
+	".venv",
+	"venv",
+	".tox",
+	"target",
+	"vendor",
+	"bower_components"
+]);
+/** Walk directory recursively, skipping excluded directories early */
+async function walkDir(dir, visitor, excludeSet) {
+	try {
+		const entries = await readdir(dir, { withFileTypes: true });
+		for (const entry of entries) if (entry.isDirectory()) {
+			if (SKIP_DIR_NAMES.has(entry.name)) continue;
+			if (excludeSet && excludeSet.has(entry.name)) continue;
+			await walkDir(join(dir, entry.name), visitor, excludeSet);
+		} else if (entry.isFile()) await visitor(join(dir, entry.name));
+	} catch {}
+}
+
+//#endregion
+export { detectFrameworks as n, detectLanguages as r, collectFiles as t };