deep-slop 1.4.1

package/dist/type-safety-Dboj2C1t.js

@@ -0,0 +1,519 @@
+import { join, relative } from "node:path";
+import { readFile } from "node:fs/promises";
+
+//#region src/engines/type-safety/index.ts
+/** Check whether a file path is a TypeScript/JavaScript file we should scan */
+function isTargetFile(filePath) {
+	return /\.(ts|tsx|js|jsx|mjs|cjs)$/i.test(filePath);
+}
+/** Check whether a file path is TypeScript (not plain JS) */
+function isTypeScriptFile(filePath) {
+	return /\.(ts|tsx)$/i.test(filePath);
+}
+/** Check whether a file is a JSX/TSX file */
+function isJsxFile(filePath) {
+	return /\.(tsx|jsx)$/i.test(filePath);
+}
+/** Walk a directory recursively collecting target files (excludes configured patterns) */
+async function collectFiles(root, exclude, filter) {
+	const { readdir } = await import("node:fs/promises");
+	const results = [];
+	async function walk(dir) {
+		const entries = await readdir(dir, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = join(dir, entry.name);
+			const rel = relative(root, fullPath);
+			if (exclude.some((pattern) => rel.includes(pattern) || entry.name === pattern || new RegExp(pattern.replace(/\*/g, ".*")).test(rel))) continue;
+			if (entry.isDirectory()) await walk(fullPath);
+			else if (isTargetFile(entry.name)) if (filter && filter.length > 0) {
+				const normalizedRel = rel.replace(/\\/g, "/");
+				if (filter.some((f) => normalizedRel === f.replace(/\\/g, "/"))) results.push(fullPath);
+			} else results.push(fullPath);
+		}
+	}
+	await walk(root);
+	return results;
+}
+/** Count leading spaces/tabs for column calculation */
+function columnForIndex(line, index) {
+	return index + 1;
+}
+/**
+* Analyze the surrounding context of an `as any` cast and produce
+* a CONTEXT-AWARE suggestion. This is the crown jewel of this engine.
+*/
+function analyzeAsAnyContext(lineText, matchIndex, _line, _filePath, surroundingLines) {
+	const before = surroundingLines.before.join("\n").toLowerCase();
+	const after = surroundingLines.after.join("\n").toLowerCase();
+	const full = `${before}\n${lineText.toLowerCase()}\n${after}`;
+	if ([
+		/\.\s*findFirst\s*\(/,
+		/\.\s*findMany\s*\(/,
+		/\.\s*findUnique\s*\(/,
+		/\.\s*create\s*\(/,
+		/\.\s*update\s*\(/,
+		/\.\s*delete\s*\(/,
+		/\.\s*upsert\s*\(/,
+		/\.\s*query\s*\(/,
+		/\.\s*execute\s*\(/,
+		/prisma\./,
+		/drizzle\./,
+		/\.\s*select\s*\(/,
+		/\.\s*from\s*\(/,
+		/\.\s*where\s*\(/,
+		/db\.\s*\(/
+	].some((p) => p.test(full))) return {
+		severity: "suggestion",
+		rule: "types/as-any-orm",
+		message: "`as any` cast after ORM query — common Drizzle/Prisma workaround",
+		help: "ORMs like Drizzle sometimes produce incomplete types. Consider defining the return type explicitly instead of casting to any.",
+		suggestion: {
+			type: "refactor",
+			text: "as Awaited<ReturnType<typeof db.query.table>>",
+			confidence: .6,
+			reason: "ORM query return types can be inferred. Use ReturnType or define a specific row interface instead of `as any`. This is a known Drizzle workaround but should be typed explicitly."
+		}
+	};
+	if ([
+		/\bwindow\b/,
+		/\bdocument\b/,
+		/\bnavigator\b/,
+		/\bglobalThis\b/
+	].some((p) => p.test(lineText))) {
+		const varName = lineText.match(/(\w+)\s*(?:\.\s*\w+\s*)*=\s*.*window.*as\s+any/)?.[1] ?? "CustomWindow";
+		return {
+			severity: "warning",
+			rule: "types/as-any-window",
+			message: `\`as any\` cast on window/document — use interface extension instead`,
+			help: `Declare an extended Window interface to add custom properties instead of casting to any.`,
+			suggestion: {
+				type: "insert",
+				text: `interface ${varName.replace(/window/i, "XWindow")} extends Window {\n  // Add your custom properties here\n}\n\n// Then use: window as ${varName.replace(/window/i, "XWindow")}`,
+				confidence: .85,
+				reason: "Extending the Window interface is the TypeScript-idiomatic way to add custom globals. It preserves type safety for all standard properties while allowing your extensions."
+			}
+		};
+	}
+	const jsonParsePattern = /json\s*\.\s*parse\s*\(/i;
+	if (jsonParsePattern.test(full) || jsonParsePattern.test(lineText)) return {
+		severity: "warning",
+		rule: "types/as-any-json-parse",
+		message: "`as any` cast on JSON.parse result — use runtime validation instead",
+		help: "JSON.parse returns `any` by default. Instead of casting, use a validation library to ensure the data matches your expected shape at runtime.",
+		suggestion: {
+			type: "refactor",
+			text: `import { z } from "zod";\nconst MySchema = z.object({ /* ... */ });\nconst data = MySchema.parse(JSON.parse(raw));`,
+			confidence: .8,
+			reason: "zod (or io-ts/valibot) validates at runtime AND gives you a typed result. This eliminates both the `any` and the risk of malformed data slipping through."
+		}
+	};
+	if (/(?:function\s*\w*\s*\(|(?:const|let|var)\s+\w+\s*=\s*(?:\([^)]*\)|[^=]+)=>)\s*[^)]*as\s+any/.test(lineText) || /(?:param|arg|option|config|ctx|event)\w*\s*:\s*any/i.test(lineText)) {
+		const paramName = lineText.match(/(\w+)\s*(?::\s*any|:\s*unknown|\.\.\.)[^=]*as\s+any/)?.[1] ?? "params";
+		return {
+			severity: "warning",
+			rule: "types/as-any-param",
+			message: `\`as any\` cast on function parameter — define an interface for \`${paramName}\``,
+			help: `Instead of casting parameters to any, define an interface that describes the expected shape.`,
+			suggestion: {
+				type: "refactor",
+				text: `interface ${capitalize(paramName)}Params {\n  // Define expected properties\n}\n\n// Use: (${paramName}: ${capitalize(paramName)}Params) => ...`,
+				confidence: .7,
+				reason: "Explicit interfaces on function parameters provide documentation, IDE autocompletion, and compile-time safety. `as any` removes all of these benefits."
+			}
+		};
+	}
+	return {
+		severity: "warning",
+		rule: "types/as-any",
+		message: "Unsafe `as any` cast — disables type checking",
+		help: "Replace `as any` with a concrete type. If the type is truly unknown, use `unknown` and narrow with type guards.",
+		suggestion: {
+			type: "replace",
+			text: "as unknown",
+			confidence: .5,
+			reason: "`unknown` is the type-safe alternative to `any` — it requires narrowing before use, preventing accidental property access on the wrong type. If you know the shape, declare an interface instead."
+		}
+	};
+}
+function capitalize(s) {
+	return s.charAt(0).toUpperCase() + s.slice(1);
+}
+/**
+* Detect `as any` casts with context-aware suggestions.
+* Rule: types/as-any, types/as-any-orm, types/as-any-window,
+*       types/as-any-json-parse, types/as-any-param
+*/
+function detectAsAny(lines, filePath) {
+	const diagnostics = [];
+	const regex = /\bas\s+any\b/g;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		let match;
+		while ((match = regex.exec(line)) !== null) {
+			const col = columnForIndex(line, match.index);
+			const before = lines.slice(Math.max(0, i - 5), i);
+			const after = lines.slice(i + 1, Math.min(lines.length, i + 6));
+			const ctx = analyzeAsAnyContext(line, match.index, i + 1, filePath, {
+				before,
+				after
+			});
+			diagnostics.push({
+				filePath,
+				engine: "type-safety",
+				rule: ctx.rule,
+				severity: ctx.severity,
+				message: ctx.message,
+				help: ctx.help,
+				line: i + 1,
+				column: col,
+				category: "types",
+				fixable: false,
+				suggestion: ctx.suggestion
+			});
+		}
+	}
+	return diagnostics;
+}
+/**
+* Detect double type assertions: `as unknown as X`
+* Rule: types/double-assertion
+*/
+function detectDoubleAssertions(lines, filePath) {
+	const diagnostics = [];
+	const regex = /\bas\s+unknown\s+as\s+(\w+)/g;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		let match;
+		while ((match = regex.exec(line)) !== null) {
+			const targetTypeName = match[1];
+			const col = columnForIndex(line, match.index);
+			diagnostics.push({
+				filePath,
+				engine: "type-safety",
+				rule: "types/double-assertion",
+				severity: "warning",
+				message: `Double type assertion \`as unknown as ${targetTypeName}\` — use a named interface instead`,
+				help: `Double assertions bypass TypeScript's safety checks. Define an interface (like the YaWindow pattern) and cast once to it.`,
+				line: i + 1,
+				column: col,
+				category: "types",
+				fixable: true,
+				suggestion: {
+					type: "refactor",
+					text: `interface ${targetTypeName.startsWith("I") ? targetTypeName : `I${targetTypeName}`} {\n  // Define the expected shape\n}\n\n// Then use: ... as I${targetTypeName}`,
+					confidence: .75,
+					reason: `A named interface with a single cast is safer than \`as unknown as ${targetTypeName}\`. Double assertions hide real type mismatches — a named interface forces you to think about the actual shape.`
+				}
+			});
+		}
+	}
+	return diagnostics;
+}
+/**
+* Detect missing return type annotations on functions in TS files.
+* Skip simple arrow functions in JSX/TSX files.
+* Rule: types/missing-return-type
+*/
+function detectMissingReturnTypes(lines, filePath) {
+	if (!isTypeScriptFile(filePath)) return [];
+	const diagnostics = [];
+	const isJsx = isJsxFile(filePath);
+	const funcPatterns = [
+		/function\s+(\w+)\s*\([^)]*\)\s*\{/,
+		/(?:const|let|var)\s+(\w+)\s*=\s*\([^)]*\)\s*=>\s*\{/,
+		/(?:const|let|var)\s+(\w+)\s*=\s*\w+\s*=>\s*\{/
+	];
+	if (!isJsx) funcPatterns.push(/export\s+(?:async\s+)?function\s+(\w+)\s*\([^)]*\)\s*\{/, /export\s+default\s+(?:async\s+)?function\s+(\w+)\s*\([^)]*\)\s*\{/);
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const trimmed = line.trim();
+		if (isJsx && /^\s*(?:const|let)\s+\w+\s*=\s*\([^)]*\)\s*=>\s*[^{]/.test(line)) continue;
+		for (const pattern of funcPatterns) {
+			const match = pattern.exec(trimmed);
+			if (!match) continue;
+			const funcName = match[1] || "anonymous";
+			if (/:\s*\w+(\[\])?\s*(=>|\{)/.test(trimmed) || /:\s*\w+<[^>]+>\s*(=>|\{)/.test(trimmed)) continue;
+			if (/^(constructor|render|componentDidMount|useEffect|useState)/.test(funcName)) continue;
+			diagnostics.push({
+				filePath,
+				engine: "type-safety",
+				rule: "types/missing-return-type",
+				severity: "info",
+				message: `Function \`${funcName}\` has no explicit return type annotation`,
+				help: "Add an explicit return type to document the function's contract and catch mismatches at compile time.",
+				line: i + 1,
+				column: trimmed.indexOf(funcName) + 1,
+				category: "types",
+				fixable: true,
+				suggestion: {
+					type: "refactor",
+					text: `: /* infer return type */ = `,
+					confidence: .4,
+					reason: "Explicit return types serve as documentation and catch accidental return-type changes. Hover over the function in your IDE to see the inferred type, then add it explicitly."
+				}
+			});
+			break;
+		}
+	}
+	return diagnostics;
+}
+/**
+* Detect @ts-ignore and @ts-expect-error comments.
+* Rule: types/ts-suppress
+*/
+function detectTsSuppress(lines, filePath) {
+	if (!isTypeScriptFile(filePath)) return [];
+	const diagnostics = [];
+	const patterns = [{
+		regex: /\/\/\s*@ts-ignore/,
+		label: "@ts-ignore"
+	}, {
+		regex: /\/\/\s*@ts-expect-error/,
+		label: "@ts-expect-error"
+	}];
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		for (const { regex, label } of patterns) {
+			const match = regex.exec(line);
+			if (!match) continue;
+			const col = columnForIndex(line, match.index);
+			const nextLine = i + 1 < lines.length ? lines[i + 1].trim() : "";
+			const suppressedHint = nextLine ? ` The suppressed line is: \`${nextLine}\`` : "";
+			diagnostics.push({
+				filePath,
+				engine: "type-safety",
+				rule: "types/ts-suppress",
+				severity: "warning",
+				message: `\`${label}\` suppresses a TypeScript error — fix the underlying type issue instead`,
+				help: `Type-suppression comments hide real problems.${suppressedHint} Fix the type error on the next line and remove this comment.`,
+				line: i + 1,
+				column: col,
+				category: "types",
+				fixable: true,
+				suggestion: {
+					type: "delete",
+					text: `// Remove ${label} and fix the type error on the next line`,
+					confidence: .7,
+					reason: `${label} hides type errors that could cause runtime failures. Fix the underlying type mismatch instead of suppressing it. If the error is in a dependency's type definitions, use \`declare module\` or a local override.`
+				}
+			});
+		}
+	}
+	return diagnostics;
+}
+/**
+* Detect non-null assertions: `x!` operator.
+* Rule: types/non-null-assertion
+*/
+function detectNonNullAssertions(lines, filePath) {
+	if (!isTypeScriptFile(filePath)) return [];
+	const diagnostics = [];
+	const regex = /(\w+)!(?![=:(])/g;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (/^\s*\/\//.test(line) || /^\s*\*/.test(line)) continue;
+		let match;
+		while ((match = regex.exec(line)) !== null) {
+			const identifier = match[1];
+			const col = columnForIndex(line, match.index + identifier.length);
+			const beforeMatch = line.substring(0, match.index);
+			const singleQuotes = (beforeMatch.match(/'/g) || []).length;
+			const doubleQuotes = (beforeMatch.match(/"/g) || []).length;
+			if (singleQuotes % 2 === 1 || doubleQuotes % 2 === 1) continue;
+			if (beforeMatch.includes("`") && !beforeMatch.includes("}")) continue;
+			diagnostics.push({
+				filePath,
+				engine: "type-safety",
+				rule: "types/non-null-assertion",
+				severity: "warning",
+				message: `Non-null assertion \`${identifier}!\` — this assertion is unchecked at runtime`,
+				help: `Non-null assertions (\`!\`) tell TypeScript to assume a value is non-null, but this isn't checked at runtime. Add an explicit null check instead.`,
+				line: i + 1,
+				column: col,
+				category: "types",
+				fixable: true,
+				suggestion: {
+					type: "replace",
+					text: `if (${identifier} != null) { /* use ${identifier} safely */ }`,
+					confidence: .65,
+					reason: "An explicit null check provides runtime safety AND narrows the type in TypeScript. The `!` operator only satisfies the compiler — it can cause runtime errors if the value is actually null/undefined."
+				}
+			});
+		}
+	}
+	return diagnostics;
+}
+/**
+* Detect `any` used as a generic type parameter.
+* Rule: types/generic-any
+*/
+function detectGenericAny(lines, filePath) {
+	if (!isTypeScriptFile(filePath)) return [];
+	const diagnostics = [];
+	const genericPatterns = [
+		{
+			regex: /Array\s*<\s*any\s*>/g,
+			construct: "Array<any>",
+			suggestion: "unknown[]"
+		},
+		{
+			regex: /ReadonlyArray\s*<\s*any\s*>/g,
+			construct: "ReadonlyArray<any>",
+			suggestion: "readonly unknown[]"
+		},
+		{
+			regex: /Promise\s*<\s*any\s*>/g,
+			construct: "Promise<any>",
+			suggestion: "Promise<unknown>"
+		},
+		{
+			regex: /Record\s*<\s*([^,]+)\s*,\s*any\s*>/g,
+			construct: "Record<K, any>",
+			suggestion: "Record<K, unknown>"
+		},
+		{
+			regex: /Map\s*<\s*([^,]+)\s*,\s*any\s*>/g,
+			construct: "Map<K, any>",
+			suggestion: "Map<K, unknown>"
+		},
+		{
+			regex: /Set\s*<\s*any\s*>/g,
+			construct: "Set<any>",
+			suggestion: "Set<unknown>"
+		},
+		{
+			regex: /Partial\s*<\s*any\s*>/g,
+			construct: "Partial<any>",
+			suggestion: "Partial<Record<string, unknown>>"
+		},
+		{
+			regex: /Omit\s*<\s*any\s*,/g,
+			construct: "Omit<any, K>",
+			suggestion: "Omit<Record<string, unknown>, K>"
+		},
+		{
+			regex: /Pick\s*<\s*any\s*,/g,
+			construct: "Pick<any, K>",
+			suggestion: "Pick<Record<string, unknown>, K>"
+		},
+		{
+			regex: /ReturnType\s*<\s*any\s*>/g,
+			construct: "ReturnType<any>",
+			suggestion: "ReturnType<typeof fn>"
+		},
+		{
+			regex: /(\w+)\s*<\s*any\s*>/g,
+			construct: "T<any>",
+			suggestion: "T<unknown>"
+		}
+	];
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (/^\s*\/\//.test(line) || /^\s*\*/.test(line)) continue;
+		for (const pattern of genericPatterns) {
+			let match;
+			while ((match = pattern.regex.exec(line)) !== null) {
+				const col = columnForIndex(line, match.index);
+				let suggestionText;
+				let reason;
+				if (pattern.construct === "Record<K, any>") {
+					suggestionText = `Record<${match[1]?.trim() ?? "string"}, unknown>`;
+					reason = `Using \`any\` as the value type in Record allows unrestricted access. Use \`unknown\` to require narrowing before use, or define a specific value interface.`;
+				} else if (pattern.construct === "Map<K, any>") {
+					suggestionText = `Map<${match[1]?.trim() ?? "string"}, unknown>`;
+					reason = `Using \`any\` as the value type in Map allows unrestricted access. Use \`unknown\` to require narrowing, or define a specific value interface.`;
+				} else if (pattern.construct === "Omit<any, K>" || pattern.construct === "Pick<any, K>") {
+					const constructName = pattern.construct.startsWith("Omit") ? "Omit" : "Pick";
+					suggestionText = `${constructName}<Record<string, unknown>, K>`;
+					reason = `Using \`any\` as the base type in ${constructName} makes the result essentially untyped. Define a proper interface as the base.`;
+				} else if (pattern.construct === "T<any>") {
+					suggestionText = `${match[1] ?? "T"}<unknown>`;
+					reason = `Using \`any\` as a generic parameter defeats the purpose of generics. Use \`unknown\` or a specific type.`;
+				} else {
+					suggestionText = pattern.suggestion;
+					reason = `Using \`any\` as a generic type parameter disables all type checking for that parameter. Use \`unknown\` to require narrowing, or define a specific type.`;
+				}
+				if (diagnostics.some((d) => d.line === i + 1 && d.column === col)) continue;
+				diagnostics.push({
+					filePath,
+					engine: "type-safety",
+					rule: "types/generic-any",
+					severity: "warning",
+					message: `\`${match[0]}\` uses \`any\` as a generic type parameter`,
+					help: `Replace \`any\` with a concrete type or \`unknown\` to preserve type safety.`,
+					line: i + 1,
+					column: col,
+					category: "types",
+					fixable: true,
+					suggestion: {
+						type: "replace",
+						text: suggestionText,
+						confidence: .7,
+						reason
+					}
+				});
+			}
+		}
+	}
+	return diagnostics;
+}
+const typeSafetyEngine = {
+	name: "type-safety",
+	description: "Detects type safety issues with context-aware suggestions — as any casts, double assertions, missing return types, ts-suppress comments, non-null assertions, and generic any parameters.",
+	supportedLanguages: ["typescript", "javascript"],
+	async run(context) {
+		const startTime = performance.now();
+		const { flagAsAny, suggestTypes, flagDoubleAssertion } = context.config.types;
+		if (!flagAsAny && !suggestTypes && !flagDoubleAssertion) return {
+			engine: "type-safety",
+			diagnostics: [],
+			elapsed: performance.now() - startTime,
+			skipped: true,
+			skipReason: "All type-safety checks disabled in config"
+		};
+		const root = context.rootDirectory;
+		const exclude = context.config.exclude;
+		const files = context.files ? context.files.filter((f) => isTargetFile(f)).map((f) => join(root, f)) : await collectFiles(root, exclude);
+		if (files.length === 0) return {
+			engine: "type-safety",
+			diagnostics: [],
+			elapsed: performance.now() - startTime,
+			skipped: true,
+			skipReason: "No TypeScript/JavaScript files found to scan"
+		};
+		const allDiagnostics = [];
+		for (const filePath of files) {
+			let content;
+			try {
+				content = await readFile(filePath, "utf-8");
+			} catch {
+				continue;
+			}
+			const lines = content.split("\n");
+			const relPath = relative(root, filePath).replace(/\\/g, "/");
+			if (flagAsAny) allDiagnostics.push(...detectAsAny(lines, relPath));
+			if (flagDoubleAssertion) allDiagnostics.push(...detectDoubleAssertions(lines, relPath));
+			if (suggestTypes) allDiagnostics.push(...detectMissingReturnTypes(lines, relPath));
+			allDiagnostics.push(...detectTsSuppress(lines, relPath));
+			allDiagnostics.push(...detectNonNullAssertions(lines, relPath));
+			allDiagnostics.push(...detectGenericAny(lines, relPath));
+		}
+		return {
+			engine: "type-safety",
+			diagnostics: allDiagnostics,
+			elapsed: performance.now() - startTime,
+			skipped: false
+		};
+	},
+	async fix(diagnostics, _context) {
+		diagnostics.filter((d) => d.fixable && d.suggestion && d.suggestion.type === "replace" && d.suggestion.confidence >= .8);
+		return {
+			fixed: 0,
+			remaining: diagnostics,
+			modifiedFiles: []
+		};
+	}
+};
+
+//#endregion
+export { typeSafetyEngine };

package/package.json

@@ -0,0 +1,92 @@
+{
+  "name": "deep-slop",
+  "version": "1.4.1",
+  "description": "Deep AI slop detection with AST analysis, alternative import paths, dead code flow, type safety, and 12 engines. Far beyond aislop.",
+  "type": "module",
+  "bin": {
+    "deep-slop": "./dist/deep-slop-bundled.js",
+    "deep-slop-mcp": "./dist/mcp.js"
+  },
+  "files": [
+    "dist/deep-slop-bundled.js",
+    "dist/mcp.js",
+    "dist/index.js",
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "scripts",
+    ".deep-slop/.deep-slop-ignore",
+    "!dist/**/*.test.*",
+    "!dist/**/*.test.js.map"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "dev": "tsdown --watch",
+    "build": "rm -rf dist && NODE_ENV=production tsdown && npx esbuild src/cli.ts --bundle --platform=node --format=esm --outfile=dist/deep-slop-bundled.js --external:web-tree-sitter --external:tree-sitter-typescript --external:tree-sitter-python --external:tree-sitter-go --external:tree-sitter-rust --external:tree-sitter-php --external:tree-sitter-c-sharp --external:tree-sitter-swift --external:zod --external:glob --external:fast-glob --banner:js='import{createRequire}from\"node:module\";const require=createRequire(import.meta.url);' && npx esbuild src/mcp.ts --bundle --platform=node --format=esm --outfile=dist/mcp.js --external:web-tree-sitter --external:tree-sitter-typescript --external:tree-sitter-python --external:tree-sitter-go --external:tree-sitter-rust --external:tree-sitter-php --external:tree-sitter-c-sharp --external:tree-sitter-swift --external:zod --external:glob --external:fast-glob --banner:js='import{createRequire}from\"node:module\";const require=createRequire(import.meta.url);'",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "scan": "pnpm build && node dist/deep-slop-bundled.js scan .",
+    "scan:json": "pnpm build && node dist/deep-slop-bundled.js scan . --json"
+  },
+  "keywords": [
+    "deep-slop",
+    "ai-slop",
+    "code-quality",
+    "ast",
+    "tree-sitter",
+    "import-intelligence",
+    "dead-code",
+    "type-safety",
+    "linter",
+    "static-analysis"
+  ],
+  "author": "Romanchello",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DemumuMind/deep-slopDM.git"
+  },
+  "homepage": "https://github.com/DemumuMind/deep-slopDM#readme",
+  "bugs": {
+    "url": "https://github.com/DemumuMind/deep-slopDM/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "packageManager": "pnpm@10.28.0",
+  "dependencies": {
+    "@clack/prompts": "^1.2.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "commander": "^14.0.3",
+    "fast-glob": "^3.3.3",
+    "graphology": "^0.25.4",
+    "js-yaml": "^4.2.0",
+    "micromatch": "^4.0.8",
+    "minimatch": "^10.2.5",
+    "picocolors": "^1.1.1",
+    "tree-sitter-javascript": "^0.25.0",
+    "tree-sitter-python": "^0.25.0",
+    "tree-sitter-typescript": "^0.23.2",
+    "web-tree-sitter": "^0.25.5",
+    "yaml": "^2.8.2",
+    "zod": "^4.3.6",
+    "zod-to-json-schema": "^3.25.2"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/micromatch": "^4.0.10",
+    "@types/minimatch": "^6.0.0",
+    "@types/node": "^25.6.0",
+    "tsdown": "^0.20.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.8"
+  }
+}