deep-slop 1.4.1

package/dist/import-intelligence-SK4F7XpL.js

@@ -0,0 +1,966 @@
+import { _ as parseFile, d as initParser, n as extractImportFromNode, o as findNodesOfTypes, y as walkAST } from "./tree-sitter-CM-cP0nl.js";
+import { t as collectFiles } from "./discover-B_S_Fy2S.js";
+import { i as toLines, n as extractImports, r as readFileContent } from "./file-utils-B_HFXhCs.js";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { stat } from "node:fs/promises";
+
+//#region src/engines/import-intelligence/index.ts
+/** Packages known to support deep / tree-shakeable imports */
+const TREE_SHAKEABLE_PACKAGES = {
+	lodash: "lodash/{symbol}",
+	"lodash-es": "lodash-es/{symbol}",
+	ramda: "ramda/src/{symbol}",
+	underscore: "underscore/cjs/{symbol}",
+	rxjs: "rxjs/{symbol}",
+	d3: "d3-{symbol}",
+	"date-fns": "date-fns/{symbol}"
+};
+/** Side-effect-only import pattern (no bindings) */
+const SIDE_EFFECT_RE = /^import\s+['"][^'"]+['"];?\s*$/;
+/** Named-import extraction: `import { A, B as C, ... } from ...` */
+const NAMED_IMPORTS_RE = /import\s+(?:type\s+)?\{([^}]+)\}/;
+/** Default-import extraction: `import X from ...` (no braces) */
+const DEFAULT_IMPORT_RE = /^import\s+(?:type\s+)?(\w+)\s+from\s+['"]/;
+/** Namespace import: `import * as X from ...` */
+const NAMESPACE_IMPORT_RE = /^import\s+\*\s+as\s+(\w+)\s+from\s+['"]/;
+/** React version threshold for automatic JSX runtime */
+const REACT_AUTOMATIC_JSX_VERSION = 17;
+/** Drizzle ORM symbols that are commonly flagged as unused (false positives) */
+const DRIZZLE_FP_SYMBOLS = new Set([
+	"sql",
+	"count",
+	"desc",
+	"and",
+	"inArray",
+	"eq",
+	"ne",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"like",
+	"ilike",
+	"not",
+	"or",
+	"between",
+	"exists",
+	"notInArray",
+	"isNull",
+	"isNotNull"
+]);
+/** Packages that are Drizzle ORM */
+const DRIZZLE_PACKAGES = new Set([
+	"drizzle-orm",
+	"drizzle-orm/sqlite-core",
+	"drizzle-orm/pg-core",
+	"drizzle-orm/mysql-core",
+	"drizzle-orm/sqlite-singlestore-core"
+]);
+/**
+* Parse imports from a file using tree-sitter AST.
+* Returns ParsedImport[] with viaAST=true, or null if tree-sitter unavailable.
+*/
+async function parseImportsAST(content, filePath) {
+	if (!await initParser()) return null;
+	const ast = await parseFile(content, filePath.endsWith(".tsx") || filePath.endsWith(".jsx"));
+	if (!ast) return null;
+	const importNodes = findNodesOfTypes(ast, ["import_statement", "import_declaration"]);
+	const results = [];
+	for (const node of importNodes) {
+		const extracted = extractImportFromNode(node);
+		if (!extracted) continue;
+		const raw = node.text.trim();
+		const isSideEffect = SIDE_EFFECT_RE.test(raw);
+		const isNamespace = NAMESPACE_IMPORT_RE.test(raw);
+		const nsMatch = raw.match(NAMESPACE_IMPORT_RE);
+		const namespaceAlias = nsMatch ? nsMatch[1] : "";
+		const isDefault = !!(raw.match(DEFAULT_IMPORT_RE) && !raw.includes("{"));
+		results.push({
+			line: extracted.line,
+			source: extracted.source,
+			raw,
+			isTypeOnly: extracted.isTypeOnly,
+			isDefault,
+			isDynamic: false,
+			symbols: extracted.symbols,
+			isSideEffect,
+			isNamespace,
+			namespaceAlias,
+			viaAST: true
+		});
+	}
+	const lazyImports = findLazyImportsAST(ast);
+	for (const lazy of lazyImports) results.push({
+		line: lazy.line,
+		source: lazy.source,
+		raw: `import('${lazy.source}')`,
+		isTypeOnly: false,
+		isDefault: false,
+		isDynamic: true,
+		symbols: [],
+		isSideEffect: false,
+		isNamespace: false,
+		namespaceAlias: "",
+		viaAST: true
+	});
+	return results;
+}
+/**
+* Walk AST to find dynamic import() calls inside function bodies.
+* These are "lazy imports" that create hidden circular dependencies.
+*/
+function findLazyImportsAST(ast) {
+	const lazyImports = [];
+	walkAST(ast, (node) => {
+		if (node.type === "call_expression") {
+			const func = node.children[0];
+			if (func && func.type === "import") {
+				const args = node.children.find((c) => c.type === "arguments");
+				if (args) {
+					const stringArg = args.children.find((c) => c.type === "string" || c.type === "template_string");
+					if (stringArg) {
+						const source = stringArg.text.replace(/^['"]|['"]$/g, "");
+						lazyImports.push({
+							source,
+							line: node.startRow + 1,
+							insideFunction: true,
+							isDynamic: true
+						});
+					}
+				}
+				return false;
+			}
+		}
+	});
+	return lazyImports;
+}
+/**
+* AST-enhanced barrel file detection.
+* Uses tree-sitter to find all export nodes including type-only exports
+* that the regex-based detector misses.
+*/
+async function detectBarrelFileAST(content, filePath) {
+	if (!await initParser()) return null;
+	const ast = await parseFile(content, filePath.endsWith(".tsx") || filePath.endsWith(".jsx"));
+	if (!ast) return null;
+	const reExports = [];
+	let hasNonExportCode = false;
+	findNodesOfTypes(ast, ["export_statement", "export_declaration"]);
+	const topLevelTypes = /* @__PURE__ */ new Set();
+	walkAST(ast, (node) => {
+		if (node.type === "program") {
+			for (const child of node.children) {
+				const t = child.type;
+				if (t !== "comment" && t !== "//" && t !== "/*") topLevelTypes.add(t);
+			}
+			return false;
+		}
+	});
+	const programNode = ast.type === "program" ? ast : null;
+	if (programNode) for (const child of programNode.children) {
+		const t = child.type;
+		if (!child.text.trim() || t === "comment" || t === "//" || t === "/*") continue;
+		if (t === "export_statement" || t === "export_declaration") {
+			const parsed = parseExportNodeAST(child);
+			if (parsed) {
+				reExports.push(parsed);
+				continue;
+			}
+		}
+		hasNonExportCode = true;
+		break;
+	}
+	if (reExports.length > 0 && !hasNonExportCode) return {
+		filePath: "",
+		reExports
+	};
+	return null;
+}
+/**
+* Parse an export AST node into a re-export descriptor.
+*/
+function parseExportNodeAST(node) {
+	const text = node.text.trim();
+	if (/\bexport\s+\*\s+from\s+/.test(text)) {
+		const sourceMatch = text.match(/from\s+['"]([^'"]+)['"]/);
+		if (sourceMatch) return {
+			source: sourceMatch[1],
+			symbols: [],
+			isWildcard: true
+		};
+	}
+	const isTypeOnly = /\bexport\s+type\s+\{/.test(text);
+	const namedExport = text.match(/\bexport\s+(?:type\s+)?\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/);
+	if (namedExport) {
+		const symbols = namedExport[1].split(",").map((s) => s.trim()).filter(Boolean);
+		return {
+			source: namedExport[2],
+			symbols,
+			isWildcard: false,
+			isTypeOnly
+		};
+	}
+	const localExport = text.match(/\bexport\s+(?:type\s+)?\{([^}]+)\}/);
+	if (localExport && !text.includes("from")) return {
+		source: ".",
+		symbols: localExport[1].split(",").map((s) => s.trim()).filter(Boolean),
+		isWildcard: false,
+		isTypeOnly
+	};
+	return null;
+}
+/**
+* AST-enhanced unused symbol detection.
+* Walks the AST to find actual identifier usage in value and type positions,
+* producing more accurate results than the regex word-boundary check.
+*/
+function findUsedSymbolsAST(ast, symbolNames) {
+	const usedSymbols = /* @__PURE__ */ new Set();
+	const symbolSet = new Set(symbolNames);
+	walkAST(ast, (node) => {
+		if (node.type === "identifier" || node.type === "type_identifier") {
+			const name = node.text;
+			if (symbolSet.has(name)) {
+				const parent = node.parent;
+				if (parent && (parent.type === "import_statement" || parent.type === "import_declaration" || parent.type === "named_imports" || parent.type === "import_clause" || parent.type === "import_specifier")) return;
+				usedSymbols.add(name);
+			}
+		}
+		if (node.type === "property_identifier" || node.type === "member_expression") {
+			const text = node.text;
+			for (const sym of symbolNames) if (text.startsWith(sym + ".") || text === sym) usedSymbols.add(sym);
+		}
+	});
+	return usedSymbols;
+}
+/** Make a Diagnostic with sensible defaults */
+function diag(filePath, rule, severity, message, line, help, opts = {}) {
+	return {
+		filePath,
+		engine: "import-intelligence",
+		rule,
+		severity,
+		message,
+		help,
+		line,
+		column: opts.column ?? 1,
+		category: "imports",
+		fixable: opts.fixable ?? false,
+		suggestion: opts.suggestion,
+		detail: opts.detail
+	};
+}
+/** Parse an import line into richer ParsedImport (regex fallback) */
+function parseImport(imp) {
+	const raw = imp.raw.trim();
+	const isSideEffect = SIDE_EFFECT_RE.test(raw);
+	let symbols = [];
+	const namedMatch = raw.match(NAMED_IMPORTS_RE);
+	if (namedMatch) symbols = namedMatch[1].split(",").map((s) => {
+		const trimmed = s.trim();
+		const asMatch = trimmed.match(/^(\w+)\s+as\s+(\w+)$/);
+		return asMatch ? asMatch[2] : trimmed;
+	}).filter(Boolean);
+	const defaultMatch = raw.match(DEFAULT_IMPORT_RE);
+	if (defaultMatch && !raw.includes("{")) symbols.push(defaultMatch[1]);
+	let isNamespace = false;
+	let namespaceAlias = "";
+	const nsMatch = raw.match(NAMESPACE_IMPORT_RE);
+	if (nsMatch) {
+		isNamespace = true;
+		namespaceAlias = nsMatch[1];
+		symbols.push(nsMatch[1]);
+	}
+	return {
+		...imp,
+		symbols,
+		isSideEffect,
+		isNamespace,
+		namespaceAlias,
+		viaAST: false
+	};
+}
+/** Check if a symbol is used in the file body (text after the import block) */
+function isSymbolUsed(symbol, bodyAfterImports) {
+	return new RegExp(`\\b${escapeRegex(symbol)}\\b`).test(bodyAfterImports);
+}
+/** Escape special regex characters */
+function escapeRegex(s) {
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** Read and parse package.json */
+async function readPackageJson(rootDir) {
+	try {
+		const content = await readFileContent(join(rootDir, "package.json"));
+		const pkg = JSON.parse(content);
+		return {
+			...pkg.dependencies,
+			...pkg.devDependencies,
+			...pkg.peerDependencies
+		};
+	} catch {
+		return null;
+	}
+}
+/** Read and parse tsconfig.json for paths and compilerOptions */
+async function readTsConfig(rootDir) {
+	try {
+		const content = await readFileContent(join(rootDir, "tsconfig.json"));
+		const co = JSON.parse(content).compilerOptions ?? {};
+		return {
+			paths: co.paths,
+			baseUrl: co.baseUrl,
+			jsx: co.jsx,
+			jsxImportSource: co.jsxImportSource
+		};
+	} catch {
+		return {};
+	}
+}
+/** Check whether a file path exists */
+async function fileExists(p) {
+	try {
+		return (await stat(p)).isFile();
+	} catch {
+		return false;
+	}
+}
+/** Resolve a tsconfig path alias to a real path */
+function resolveAliasPath(source, paths, baseUrl, rootDir) {
+	const sortedAliases = Object.keys(paths).sort((a, b) => b.length - a.length);
+	for (const alias of sortedAliases) {
+		const aliasRegexStr = "^" + escapeRegex(alias).replace(/\\\*/g, "(.*)") + "$";
+		const match = source.match(new RegExp(aliasRegexStr));
+		if (match) {
+			const resolved = paths[alias][0].replace(/\*/g, match[1]);
+			return {
+				alias,
+				resolvedPattern: resolve(rootDir, baseUrl ?? ".", resolved)
+			};
+		}
+	}
+	return null;
+}
+/**
+* Merge regex-parsed and AST-parsed imports, preferring AST-confirmed.
+* Key: (source, line) — same import from same line should be counted once.
+*/
+function mergeImportSources(regexImports, astImports) {
+	if (!astImports) return regexImports;
+	const seen = /* @__PURE__ */ new Map();
+	for (const imp of regexImports) {
+		const key = `${imp.source}:${imp.line}`;
+		seen.set(key, imp);
+	}
+	for (const imp of astImports) {
+		const key = `${imp.source}:${imp.line}`;
+		const existing = seen.get(key);
+		if (existing) seen.set(key, {
+			...existing,
+			symbols: imp.symbols.length > 0 ? imp.symbols : existing.symbols,
+			isTypeOnly: imp.isTypeOnly ?? existing.isTypeOnly,
+			viaAST: true
+		});
+		else seen.set(key, imp);
+	}
+	return [...seen.values()];
+}
+/**
+* Deduplicate diagnostics: when the same (filePath, rule, line) appears
+* from both regex and AST paths, prefer the AST-confirmed one.
+*/
+function deduplicateDiagnostics(diagnostics) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const d of diagnostics) {
+		const key = `${d.filePath}:${d.rule}:${d.line}`;
+		const existing = seen.get(key);
+		if (!existing) {
+			seen.set(key, d);
+			continue;
+		}
+		const existingAST = existing.detail?.astConfirmed === true;
+		const currentAST = d.detail?.astConfirmed === true;
+		if (currentAST && !existingAST) seen.set(key, d);
+		else if (currentAST && existingAST) {
+			if ((d.suggestion?.confidence ?? 0) > (existing.suggestion?.confidence ?? 0)) seen.set(key, d);
+		}
+	}
+	return [...seen.values()];
+}
+function checkAlternativeImports(parsed, filePath, dependencies, frameworks, isReactAutoJsx) {
+	const diagnostics = [];
+	const pkgName = parsed.source.startsWith("@") ? parsed.source.split("/").slice(0, 2).join("/") : parsed.source.split("/")[0];
+	const template = TREE_SHAKEABLE_PACKAGES[pkgName];
+	if (template && parsed.symbols.length > 0 && !parsed.isNamespace) {
+		const alternatives = parsed.symbols.map((sym) => {
+			return `import ${sym} from '${template.replace("{symbol}", sym)}'`;
+		});
+		const baseConfidence = parsed.viaAST ? .9 : .85;
+		diagnostics.push(diag(filePath, "import-intelligence/tree-shakeable", "suggestion", `Tree-shakeable alternative available for '${pkgName}' import`, parsed.line, `Replace with deep imports so bundlers can eliminate unused code.`, {
+			fixable: true,
+			suggestion: {
+				type: "replace",
+				text: alternatives.join("\n"),
+				range: {
+					startLine: parsed.line,
+					startCol: 1,
+					endLine: parsed.line,
+					endCol: parsed.raw.length + 1
+				},
+				confidence: baseConfidence,
+				reason: `Deep imports from '${pkgName}' allow bundlers to tree-shake unused modules, reducing bundle size significantly. Named imports from the barrel pull in the entire package.`
+			},
+			detail: { astConfirmed: parsed.viaAST }
+		}));
+	}
+	if (isReactAutoJsx && parsed.source === "react") {
+		if (parsed.isDefault && parsed.symbols.length === 1 && parsed.symbols[0] === "React") diagnostics.push(diag(filePath, "import-intelligence/react-auto-jsx", "suggestion", `Default React import is unnecessary with automatic JSX runtime`, parsed.line, `Remove the default React import or switch to named imports (hooks, etc.) if you use them.`, {
+			fixable: true,
+			suggestion: {
+				type: "delete",
+				text: "",
+				range: {
+					startLine: parsed.line,
+					startCol: 1,
+					endLine: parsed.line,
+					endCol: parsed.raw.length + 1
+				},
+				confidence: parsed.viaAST ? .85 : .8,
+				reason: `With React ${REACT_AUTOMATIC_JSX_VERSION}+ automatic JSX runtime (jsx: 'react-jsx' in tsconfig), 'import React' is not needed for JSX transforms. Removing it reduces unused imports.`
+			},
+			detail: { astConfirmed: parsed.viaAST }
+		}));
+		if (parsed.isDefault && parsed.symbols.length > 1 && parsed.symbols.includes("React")) {
+			const replacement = `import { ${parsed.symbols.filter((s) => s !== "React").join(", ")} } from 'react'`;
+			diagnostics.push(diag(filePath, "import-intelligence/react-auto-jsx-named", "suggestion", `Default React import is unnecessary with automatic JSX runtime; keep named imports only`, parsed.line, `Remove the default React import and keep only the named hooks/utilities.`, {
+				fixable: true,
+				suggestion: {
+					type: "replace",
+					text: replacement,
+					range: {
+						startLine: parsed.line,
+						startCol: 1,
+						endLine: parsed.line,
+						endCol: parsed.raw.length + 1
+					},
+					confidence: parsed.viaAST ? .85 : .8,
+					reason: `With automatic JSX runtime, the default 'React' import is unused. Keeping only named imports is cleaner and avoids pulling in the full React object.`
+				},
+				detail: { astConfirmed: parsed.viaAST }
+			}));
+		}
+	}
+	return diagnostics;
+}
+/** Detect barrel files (index.ts that only re-export) — regex fallback */
+function detectBarrelFile(content) {
+	const lines = toLines(content);
+	const reExports = [];
+	let hasNonExportCode = false;
+	for (const { text } of lines) {
+		const trimmed = text.trim();
+		if (trimmed === "" || trimmed.startsWith("//") || trimmed.startsWith("/*")) continue;
+		const namedExport = trimmed.match(/^export\s+\{([^}]+)\}\s+from\s+['"]([^'"]+)['"];?/);
+		if (namedExport) {
+			const symbols = namedExport[1].split(",").map((s) => s.trim()).filter(Boolean);
+			reExports.push({
+				source: namedExport[2],
+				symbols,
+				isWildcard: false
+			});
+			continue;
+		}
+		const wildcardExport = trimmed.match(/^export\s+\*\s+from\s+['"]([^'"]+)['"];?/);
+		if (wildcardExport) {
+			reExports.push({
+				source: wildcardExport[1],
+				symbols: [],
+				isWildcard: true
+			});
+			continue;
+		}
+		const typeExport = trimmed.match(/^export\s+type\s+\{([^}]+)\}\s+from\s+['"]([^'"]+)['"];?/);
+		if (typeExport) {
+			const symbols = typeExport[1].split(",").map((s) => s.trim()).filter(Boolean);
+			reExports.push({
+				source: typeExport[2],
+				symbols,
+				isWildcard: false,
+				isTypeOnly: true
+			});
+			continue;
+		}
+		const localExport = trimmed.match(/^export\s+\{([^}]+)\};?/);
+		if (localExport) {
+			const symbols = localExport[1].split(",").map((s) => s.trim()).filter(Boolean);
+			reExports.push({
+				source: ".",
+				symbols,
+				isWildcard: false
+			});
+			continue;
+		}
+		hasNonExportCode = true;
+		break;
+	}
+	if (reExports.length > 0 && !hasNonExportCode) return {
+		filePath: "",
+		reExports
+	};
+	return null;
+}
+function checkBarrelOptimization(parsed, filePath, barrelCache, rootDir) {
+	const diagnostics = [];
+	if (!parsed.source.startsWith(".")) return diagnostics;
+	const barrelKey = parsed.source;
+	const barrel = barrelCache.get(barrelKey);
+	if (!barrel) return diagnostics;
+	const symbolToSource = /* @__PURE__ */ new Map();
+	for (const reExport of barrel.reExports) {
+		if (reExport.isWildcard) continue;
+		for (const sym of reExport.symbols) {
+			const localName = sym.includes(" as ") ? sym.split(" as ")[1].trim() : sym;
+			symbolToSource.set(localName, reExport.source);
+		}
+	}
+	const sourceGroups = /* @__PURE__ */ new Map();
+	for (const sym of parsed.symbols) {
+		const source = symbolToSource.get(sym);
+		if (source && source !== ".") {
+			if (!sourceGroups.has(source)) sourceGroups.set(source, []);
+			sourceGroups.get(source).push(sym);
+		}
+	}
+	if (sourceGroups.size > 0) {
+		const replacementLines = [];
+		for (const [source, symbols] of sourceGroups) replacementLines.push(`import { ${symbols.join(", ")} } from '${source}'`);
+		const hasTypeOnlyReExports = barrel.reExports.some((r) => r.isTypeOnly);
+		const baseConfidence = parsed.viaAST || hasTypeOnlyReExports ? .78 : .7;
+		diagnostics.push(diag(filePath, "import-intelligence/barrel-bypass", "suggestion", `Import directly from source instead of barrel file '${parsed.source}'`, parsed.line, `Direct imports avoid the barrel file indirection, improving tree-shaking and build speed.`, {
+			fixable: true,
+			suggestion: {
+				type: "replace",
+				text: replacementLines.join("\n"),
+				range: {
+					startLine: parsed.line,
+					startCol: 1,
+					endLine: parsed.line,
+					endCol: parsed.raw.length + 1
+				},
+				confidence: baseConfidence,
+				reason: `Barrel files (index.ts re-exporting from sub-modules) prevent bundlers from tree-shaking effectively. Importing from the source module directly allows the bundler to only include what you actually use, and reduces module resolution overhead during builds.`
+			},
+			detail: {
+				astConfirmed: parsed.viaAST,
+				hasTypeOnlyReExports
+			}
+		}));
+	}
+	return diagnostics;
+}
+async function checkAliasResolution(parsed, filePath, paths, baseUrl, rootDir) {
+	const diagnostics = [];
+	if (!paths || Object.keys(paths).length === 0) return diagnostics;
+	const aliasResult = resolveAliasPath(parsed.source, paths, baseUrl ?? ".", rootDir);
+	if (!aliasResult) return diagnostics;
+	const resolvedPath = aliasResult.resolvedPattern;
+	let found = false;
+	for (const ext of [
+		"",
+		".ts",
+		".tsx",
+		".js",
+		".jsx",
+		"/index.ts",
+		"/index.tsx",
+		"/index.js"
+	]) if (await fileExists(resolvedPath + ext)) {
+		found = true;
+		break;
+	}
+	if (!found) diagnostics.push(diag(filePath, "import-intelligence/broken-alias", "error", `Alias '${aliasResult.alias}' resolves to '${resolvedPath}' which does not exist`, parsed.line, `Fix the tsconfig paths mapping or the import path.`, {
+		fixable: false,
+		suggestion: {
+			type: "replace",
+			text: `/* TODO: fix alias — ${parsed.source} resolves to non-existent ${resolvedPath} */`,
+			confidence: parsed.viaAST ? .95 : .9,
+			reason: `The tsconfig paths alias '${aliasResult.alias}' maps to '${resolvedPath}', but no file exists at that location. This will cause a TypeScript compilation error or runtime module-not-found.`
+		},
+		detail: {
+			alias: aliasResult.alias,
+			resolvedPath,
+			originalImport: parsed.source,
+			astConfirmed: parsed.viaAST
+		}
+	}));
+	else {
+		const relPath = relative(dirname(filePath), resolvedPath);
+		const canonicalPath = relPath.startsWith(".") ? relPath : "./" + relPath;
+		if (parsed.source !== canonicalPath && !parsed.source.startsWith(".")) diagnostics.push(diag(filePath, "import-intelligence/alias-canonical", "info", `Alias '${parsed.source}' resolves to '${canonicalPath}'`, parsed.line, `Consider using the relative path for explicitness in small projects, or keep the alias for large monorepos.`, {
+			suggestion: {
+				type: "replace",
+				text: `from '${canonicalPath}'`,
+				confidence: parsed.viaAST ? .6 : .5,
+				reason: `Using the resolved relative path makes the dependency graph explicit without relying on tsconfig alias resolution, but aliases are often preferred for readability in large codebases.`
+			},
+			detail: { astConfirmed: parsed.viaAST }
+		}));
+	}
+	return diagnostics;
+}
+function buildImportGraph(fileImports, rootDir) {
+	const adjacency = /* @__PURE__ */ new Map();
+	const reverse = /* @__PURE__ */ new Map();
+	for (const [filePath, imports] of fileImports) {
+		const deps = /* @__PURE__ */ new Set();
+		for (const imp of imports) if (imp.source.startsWith(".")) {
+			const resolved = resolve(dirname(filePath), imp.source);
+			deps.add(resolved);
+		}
+		adjacency.set(filePath, deps);
+		for (const dep of deps) {
+			if (!reverse.has(dep)) reverse.set(dep, /* @__PURE__ */ new Set());
+			reverse.get(dep).add(filePath);
+		}
+	}
+	return {
+		adjacency,
+		reverse
+	};
+}
+/** DFS-based cycle detection with path tracking */
+function detectCycles(graph, maxDepth) {
+	const cycles = [];
+	const visited = /* @__PURE__ */ new Set();
+	const inStack = /* @__PURE__ */ new Set();
+	const stack = [];
+	function dfs(node) {
+		if (inStack.has(node)) {
+			const cycleStart = stack.indexOf(node);
+			if (cycleStart !== -1) {
+				const cyclePath = stack.slice(cycleStart);
+				cyclePath.push(node);
+				cycles.push({
+					cycle: cyclePath,
+					depth: cyclePath.length - 1
+				});
+			}
+			return;
+		}
+		if (visited.has(node)) return;
+		visited.add(node);
+		inStack.add(node);
+		stack.push(node);
+		if (stack.length <= maxDepth) {
+			const neighbors = graph.adjacency.get(node) ?? /* @__PURE__ */ new Set();
+			for (const neighbor of neighbors) dfs(neighbor);
+		}
+		stack.pop();
+		inStack.delete(node);
+	}
+	for (const node of graph.adjacency.keys()) dfs(node);
+	const seen = /* @__PURE__ */ new Set();
+	const unique = [];
+	for (const c of cycles) {
+		const key = [...c.cycle.slice(0, -1)].sort().join("→");
+		if (!seen.has(key)) {
+			seen.add(key);
+			unique.push(c);
+		}
+	}
+	return unique;
+}
+function reportCycles(cycles, rootDir, hasASTImports) {
+	const diagnostics = [];
+	for (const { cycle, depth } of cycles) {
+		const chain = cycle.map((p) => relative(rootDir, p) || p).join(" → ");
+		const involvedFiles = cycle.slice(0, -1);
+		const firstFile = involvedFiles[0] ?? "";
+		const relFirst = relative(rootDir, firstFile) || firstFile;
+		diagnostics.push(diag(relFirst, "import-intelligence/circular-dependency", "warning", `Circular dependency detected: ${chain}`, 1, `Break the cycle by extracting shared logic into a separate module that both files can import without creating a loop.`, {
+			fixable: false,
+			detail: {
+				cycle: involvedFiles.map((p) => relative(rootDir, p)),
+				depth,
+				astConfirmed: hasASTImports
+			},
+			suggestion: {
+				type: "refactor",
+				text: `/* Circular: ${chain} — extract shared code to break the cycle */`,
+				confidence: hasASTImports ? .97 : .95,
+				reason: `Circular dependencies create fragile coupling, can cause initialization order bugs, and make the module graph harder to reason about. Extracting the shared dependency into a third module breaks the cycle cleanly.${hasASTImports ? " AST analysis also checked lazy imports inside function bodies." : ""}`
+			}
+		}));
+	}
+	return diagnostics;
+}
+function checkImportClassification(parsed, filePath, fileContent, astUsedSymbols) {
+	const diagnostics = [];
+	if (parsed.isSideEffect) {
+		diagnostics.push(diag(filePath, "import-intelligence/side-effect-import", "info", `Side-effect import: '${parsed.source}' (no bindings imported)`, parsed.line, `Ensure this import is needed for its side effects (polyfills, CSS, etc.). Remove if unnecessary.`, {
+			suggestion: {
+				type: "delete",
+				text: "",
+				confidence: .3,
+				reason: `Side-effect imports ('import foo') load a module for its side effects only. This is correct for polyfills, CSS, and global setup, but can be an accidental leftover if the module was expected to provide bindings.`
+			},
+			detail: { astConfirmed: parsed.viaAST }
+		}));
+		return diagnostics;
+	}
+	if (parsed.isDynamic) return diagnostics;
+	if (!parsed.isTypeOnly && parsed.symbols.length > 0) {
+		let allTypeUsage;
+		if (astUsedSymbols !== void 0 && parsed.viaAST) allTypeUsage = parsed.symbols.every((sym) => {
+			if (!astUsedSymbols.has(sym)) return true;
+			return isTypeOnlyUsage(sym, getBodyAfterImports(fileContent, parsed.line));
+		});
+		else {
+			const bodyAfterImports = getBodyAfterImports(fileContent, parsed.line);
+			allTypeUsage = parsed.symbols.every((sym) => {
+				return isTypeOnlyUsage(sym, bodyAfterImports);
+			});
+		}
+		if (allTypeUsage) {
+			const replacement = parsed.raw.replace(/^import\s+/, "import type ").replace(/^import\s+type\s+type\s+/, "import type ");
+			diagnostics.push(diag(filePath, "import-intelligence/type-only-import", "suggestion", `All imported symbols from '${parsed.source}' are used only as types — use 'import type'`, parsed.line, `Switch to 'import type' for better tree-shaking and to make intent explicit.`, {
+				fixable: true,
+				suggestion: {
+					type: "replace",
+					text: replacement,
+					range: {
+						startLine: parsed.line,
+						startCol: 1,
+						endLine: parsed.line,
+						endCol: parsed.raw.length + 1
+					},
+					confidence: parsed.viaAST ? .85 : .75,
+					reason: `Using 'import type' makes it explicit that the import is type-only, allowing TypeScript compilers and bundlers to erase it at build time. This reduces runtime bundle size and clarifies the module's role.`
+				},
+				detail: { astConfirmed: parsed.viaAST }
+			}));
+		}
+	}
+	return diagnostics;
+}
+/** Get the file content after the last import line */
+function getBodyAfterImports(content, lastImportLine) {
+	return content.split("\n").slice(lastImportLine).join("\n");
+}
+/** Heuristic: check if a symbol is used only in type positions */
+function isTypeOnlyUsage(symbol, body) {
+	let stripped = body;
+	stripped = stripped.replace(/:\s*[A-Z]\w*(?:\s*[&|]\s*[A-Z]\w*)*/g, "");
+	stripped = stripped.replace(/<[^>]*>/g, "");
+	stripped = stripped.replace(/\bas\s+[A-Z]\w*/g, "");
+	stripped = stripped.replace(/\b(?:extends|implements)\s+[A-Z]\w*/g, "");
+	stripped = stripped.replace(/\btype\s+\w+\s*=\s*[A-Z]\w*/g, "");
+	stripped = stripped.replace(/\binterface\s+\w+[^{]*/g, "");
+	return !new RegExp(`\\b${escapeRegex(symbol)}\\b`).test(stripped);
+}
+function checkUnusedImports(parsed, filePath, fileContent, astUsedSymbols) {
+	const diagnostics = [];
+	if (parsed.isSideEffect || parsed.isNamespace || parsed.isDynamic) return diagnostics;
+	const bodyAfterImports = getBodyAfterImports(fileContent, parsed.line);
+	const unusedSymbols = [];
+	for (const sym of parsed.symbols) {
+		if (DRIZZLE_FP_SYMBOLS.has(sym) && DRIZZLE_PACKAGES.has(parsed.source.split("/").slice(0, 2).join("/"))) continue;
+		if (astUsedSymbols !== void 0 && parsed.viaAST) {
+			if (!astUsedSymbols.has(sym) && !isSymbolUsed(sym, bodyAfterImports)) unusedSymbols.push(sym);
+		} else if (!isSymbolUsed(sym, bodyAfterImports)) unusedSymbols.push(sym);
+	}
+	if (unusedSymbols.length > 0 && unusedSymbols.length < parsed.symbols.length) {
+		const usedSymbols = parsed.symbols.filter((s) => !unusedSymbols.includes(s));
+		const replacement = parsed.raw.replace(/\{[^}]+\}/, `{ ${usedSymbols.join(", ")} }`);
+		diagnostics.push(diag(filePath, "import-intelligence/unused-symbol", "warning", `Unused imported symbols: ${unusedSymbols.join(", ")}`, parsed.line, `Remove unused symbols from the import to keep the codebase clean.`, {
+			fixable: true,
+			suggestion: {
+				type: "replace",
+				text: replacement,
+				range: {
+					startLine: parsed.line,
+					startCol: 1,
+					endLine: parsed.line,
+					endCol: parsed.raw.length + 1
+				},
+				confidence: parsed.viaAST ? .95 : .9,
+				reason: `Unused imported symbols add noise and may cause bundlers to include dead code. Removing them clarifies what the module actually depends on.`
+			},
+			detail: { astConfirmed: parsed.viaAST }
+		}));
+	} else if (unusedSymbols.length === parsed.symbols.length) {
+		const isDrizzle = DRIZZLE_PACKAGES.has(parsed.source.split("/").slice(0, 2).join("/"));
+		const allDrizzleFPs = parsed.symbols.every((s) => DRIZZLE_FP_SYMBOLS.has(s));
+		if (isDrizzle && allDrizzleFPs) return diagnostics;
+		diagnostics.push(diag(filePath, "import-intelligence/unused-import", "warning", `Entire import from '${parsed.source}' is unused`, parsed.line, `Remove the unused import line entirely.`, {
+			fixable: true,
+			suggestion: {
+				type: "delete",
+				text: "",
+				range: {
+					startLine: parsed.line,
+					startCol: 1,
+					endLine: parsed.line,
+					endCol: parsed.raw.length + 1
+				},
+				confidence: parsed.viaAST ? .92 : .85,
+				reason: `This import is never used in the file. Removing it reduces bundle size and avoids misleading readers about the module's dependencies.`
+			},
+			detail: { astConfirmed: parsed.viaAST }
+		}));
+	}
+	return diagnostics;
+}
+function checkDuplicateImports(allImports, filePath) {
+	const diagnostics = [];
+	const bySource = /* @__PURE__ */ new Map();
+	for (const imp of allImports) {
+		const key = imp.source;
+		if (!bySource.has(key)) bySource.set(key, []);
+		bySource.get(key).push(imp);
+	}
+	for (const [source, imports] of bySource) {
+		if (imports.length < 2) continue;
+		const allSymbols = [];
+		const hasDefault = imports.some((imp) => imp.isDefault);
+		const defaultImport = hasDefault ? imports.find((imp) => imp.isDefault) : void 0;
+		defaultImport && defaultImport.symbols.find((s) => !imports.find((imp2) => imp2 !== defaultImport && imp2.symbols.includes(s) && !imp2.isDefault));
+		for (const imp of imports) for (const sym of imp.symbols) if (!allSymbols.includes(sym)) allSymbols.push(sym);
+		let merged;
+		const namedSymbols = allSymbols.filter((s) => {
+			if (hasDefault) {
+				const defImp = imports.find((imp) => imp.isDefault);
+				if (defImp && defImp.symbols[0] === s && s !== "React") return false;
+			}
+			return true;
+		});
+		if (hasDefault && namedSymbols.length > 0) merged = `import ${imports.find((imp) => imp.isDefault).symbols[0]}, { ${namedSymbols.join(", ")} } from '${source}'`;
+		else if (hasDefault) merged = `import ${imports.find((imp) => imp.isDefault).symbols[0]} from '${source}'`;
+		else merged = `import { ${allSymbols.join(", ")} } from '${source}'`;
+		const firstLine = Math.min(...imports.map((imp) => imp.line));
+		const anyAST = imports.some((imp) => imp.viaAST);
+		diagnostics.push(diag(filePath, "import-intelligence/duplicate-import", "suggestion", `Multiple import statements from '${source}' — merge into one`, firstLine, `Combine imports from the same module into a single statement.`, {
+			fixable: true,
+			suggestion: {
+				type: "replace",
+				text: merged,
+				range: {
+					startLine: Math.min(...imports.map((imp) => imp.line)),
+					startCol: 1,
+					endLine: Math.max(...imports.map((imp) => imp.line)),
+					endCol: imports.reduce((max, imp) => imp.line === Math.max(...imports.map((i) => i.line)) ? Math.max(max, imp.raw.length + 1) : max, 0)
+				},
+				confidence: anyAST ? .93 : .9,
+				reason: `Multiple import statements from the same module are redundant and add visual noise. Merging them into a single line makes the dependency on that module clearer and is the conventional style.`
+			},
+			detail: {
+				duplicateLines: imports.map((imp) => imp.line),
+				mergedImport: merged,
+				astConfirmed: anyAST
+			}
+		}));
+	}
+	return diagnostics;
+}
+async function scanBarrelFiles(rootDir, files) {
+	const barrels = /* @__PURE__ */ new Map();
+	const indexFiles = files.filter((f) => {
+		const base = basename(f);
+		return base === "index.ts" || base === "index.tsx" || base === "index.js";
+	});
+	for (const idxFile of indexFiles) try {
+		const content = await readFileContent(idxFile);
+		let barrel = await detectBarrelFileAST(content, idxFile);
+		if (!barrel) barrel = detectBarrelFile(content);
+		if (barrel) {
+			const relDir = relative(rootDir, dirname(idxFile));
+			barrel.filePath = idxFile;
+			barrels.set(relDir, barrel);
+			barrels.set("./" + relDir, barrel);
+			barrels.set(".//" + relDir, barrel);
+			const parentRel = relative(rootDir, dirname(idxFile));
+			barrels.set(parentRel, barrel);
+		}
+	} catch {}
+	return barrels;
+}
+const importIntelligenceEngine = {
+	name: "import-intelligence",
+	description: "Deep import analysis: tree-shakeable alternatives, barrel optimization, alias validation, circular dependency detection, import classification, unused detection (with Drizzle FP suppression), and duplicate merging. AST-enhanced via tree-sitter for more accurate results.",
+	supportedLanguages: ["typescript", "javascript"],
+	async run(context) {
+		const startTime = Date.now();
+		const diagnostics = [];
+		const { rootDirectory, frameworks, config } = context;
+		const cfg = config.imports;
+		const files = await collectFiles(rootDirectory, ["typescript", "javascript"], config.exclude, context.files);
+		if (files.length === 0) return {
+			engine: "import-intelligence",
+			diagnostics: [],
+			elapsed: Date.now() - startTime,
+			skipped: true,
+			skipReason: "No TypeScript or JavaScript files found to scan."
+		};
+		const astAvailable = await initParser();
+		const dependencies = await readPackageJson(rootDirectory);
+		const tsconfig = await readTsConfig(rootDirectory);
+		const isReactAutoJsx = frameworks.includes("react") || frameworks.includes("next.js") ? (() => {
+			const reactVersion = dependencies?.["react"] ?? dependencies?.["react-dom"] ?? "0";
+			return (parseInt(reactVersion.replace(/[^0-9]/g, ""), 10) || 0) >= REACT_AUTOMATIC_JSX_VERSION || tsconfig.jsx === "react-jsx" || tsconfig.jsx === "react-jsxdev";
+		})() : false;
+		let barrelCache = /* @__PURE__ */ new Map();
+		if (cfg.optimizeBarrels) barrelCache = await scanBarrelFiles(rootDirectory, files);
+		const fileImportsMap = /* @__PURE__ */ new Map();
+		let anyASTUsed = false;
+		for (const filePath of files) {
+			const relPath = relative(rootDirectory, filePath);
+			let content;
+			try {
+				content = await readFileContent(filePath);
+			} catch {
+				continue;
+			}
+			const regexParsed = extractImports(content, "typescript").map(parseImport);
+			let astParsed = null;
+			let astUsedSymbols;
+			let astRoot = null;
+			if (astAvailable) {
+				astParsed = await parseImportsAST(content, filePath);
+				const isTsx = filePath.endsWith(".tsx") || filePath.endsWith(".jsx");
+				astRoot = await parseFile(content, isTsx);
+				if (astRoot) {
+					const allSymbolNames = [...regexParsed.flatMap((p) => p.symbols), ...astParsed?.flatMap((p) => p.symbols) ?? []];
+					const uniqueNames = [...new Set(allSymbolNames)];
+					astUsedSymbols = findUsedSymbolsAST(astRoot, uniqueNames);
+					anyASTUsed = true;
+				}
+			}
+			const parsedImports = mergeImportSources(regexParsed, astParsed);
+			fileImportsMap.set(filePath, parsedImports);
+			for (const parsed of parsedImports) {
+				if (cfg.suggestAlternatives) diagnostics.push(...checkAlternativeImports(parsed, relPath, dependencies, frameworks, isReactAutoJsx));
+				if (cfg.optimizeBarrels) diagnostics.push(...checkBarrelOptimization(parsed, relPath, barrelCache, rootDirectory));
+				if (cfg.validateAliases && tsconfig.paths) {
+					const aliasDiagnostics = await checkAliasResolution(parsed, relPath, tsconfig.paths, tsconfig.baseUrl, rootDirectory);
+					diagnostics.push(...aliasDiagnostics);
+				}
+				diagnostics.push(...checkImportClassification(parsed, relPath, content, astUsedSymbols));
+				diagnostics.push(...checkUnusedImports(parsed, relPath, content, astUsedSymbols));
+			}
+			diagnostics.push(...checkDuplicateImports(parsedImports, relPath));
+		}
+		if (cfg.buildGraph) {
+			const cycleDiagnostics = reportCycles(detectCycles(buildImportGraph(fileImportsMap, rootDirectory), cfg.maxCircularDepth), rootDirectory, anyASTUsed);
+			diagnostics.push(...cycleDiagnostics);
+		}
+		return {
+			engine: "import-intelligence",
+			diagnostics: deduplicateDiagnostics(diagnostics),
+			elapsed: Date.now() - startTime,
+			skipped: false
+		};
+	}
+};
+
+//#endregion
+export { importIntelligenceEngine };