@savvy-web/lint-staged 0.1.2 → 0.2.0

package/376.js

@@ -0,0 +1,1198 @@
+import { Command, Options } from "@effect/cli";
+import { NodeContext, NodeRuntime } from "@effect/platform-node";
+import { Effect } from "effect";
+import { FileSystem } from "@effect/platform";
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, normalize, relative, resolve } from "node:path";
+import { cosmiconfigSync, defaultLoaders } from "cosmiconfig";
+import parser from "@typescript-eslint/parser";
+import { ESLint } from "eslint";
+import eslint_plugin_tsdoc from "eslint-plugin-tsdoc";
+import { getWorkspaceInfos } from "workspace-tools";
+import typescript from "typescript";
+const VALID_COMMAND_PATTERN = /^[\w@/-]+$/;
+function validateCommandName(name) {
+    if (!VALID_COMMAND_PATTERN.test(name)) throw new Error(`Invalid command name: "${name}". Only alphanumeric characters, hyphens, underscores, @ and / are allowed.`);
+}
+class Command_Command {
+    static cachedPackageManager = null;
+    static detectPackageManager(cwd = process.cwd()) {
+        if (null !== Command_Command.cachedPackageManager) return Command_Command.cachedPackageManager;
+        const packageJsonPath = join(cwd, "package.json");
+        if (!existsSync(packageJsonPath)) {
+            Command_Command.cachedPackageManager = "npm";
+            return "npm";
+        }
+        try {
+            const content = readFileSync(packageJsonPath, "utf-8");
+            const pkg = JSON.parse(content);
+            if (pkg.packageManager) {
+                const match = pkg.packageManager.match(/^(npm|pnpm|yarn|bun)@/);
+                if (match) {
+                    Command_Command.cachedPackageManager = match[1];
+                    return Command_Command.cachedPackageManager;
+                }
+            }
+        } catch  {}
+        Command_Command.cachedPackageManager = "npm";
+        return "npm";
+    }
+    static getExecPrefix(packageManager) {
+        switch(packageManager){
+            case "pnpm":
+                return [
+                    "pnpm",
+                    "exec"
+                ];
+            case "yarn":
+                return [
+                    "yarn",
+                    "exec"
+                ];
+            case "bun":
+                return [
+                    "bunx"
+                ];
+            default:
+                return [
+                    "npx",
+                    "--no"
+                ];
+        }
+    }
+    static clearCache() {
+        Command_Command.cachedPackageManager = null;
+    }
+    static isAvailable(command) {
+        validateCommandName(command);
+        try {
+            execSync(`command -v ${command}`, {
+                stdio: "ignore"
+            });
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+    static findTool(tool) {
+        validateCommandName(tool);
+        if (Command_Command.isAvailable(tool)) return {
+            available: true,
+            command: tool,
+            source: "global"
+        };
+        const pm = Command_Command.detectPackageManager();
+        const prefix = Command_Command.getExecPrefix(pm);
+        const execCmd = [
+            ...prefix,
+            tool
+        ].join(" ");
+        try {
+            execSync(`${execCmd} --version`, {
+                stdio: "ignore"
+            });
+            return {
+                available: true,
+                command: execCmd,
+                source: pm
+            };
+        } catch  {}
+        return {
+            available: false,
+            command: void 0,
+            source: void 0
+        };
+    }
+    static requireTool(tool, errorMessage) {
+        const result = Command_Command.findTool(tool);
+        if (!result.available || !result.command) throw new Error(errorMessage ?? `Required tool '${tool}' is not available. Install it globally or add it as a dev dependency.`);
+        return result.command;
+    }
+    static exec(command) {
+        return execSync(command, {
+            encoding: "utf-8"
+        }).trim();
+    }
+    static execSilent(command) {
+        try {
+            execSync(command, {
+                stdio: "ignore"
+            });
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+}
+const TOOL_CONFIGS = {
+    markdownlint: {
+        moduleName: "markdownlint-cli2",
+        libConfigFiles: [
+            ".markdownlint-cli2.jsonc",
+            ".markdownlint-cli2.json",
+            ".markdownlint-cli2.yaml",
+            ".markdownlint-cli2.cjs",
+            ".markdownlint.jsonc",
+            ".markdownlint.json",
+            ".markdownlint.yaml"
+        ],
+        standardPlaces: [
+            ".markdownlint-cli2.jsonc",
+            ".markdownlint-cli2.json",
+            ".markdownlint-cli2.yaml",
+            ".markdownlint-cli2.cjs",
+            ".markdownlint.jsonc",
+            ".markdownlint.json",
+            ".markdownlint.yaml"
+        ]
+    },
+    biome: {
+        moduleName: "biome",
+        libConfigFiles: [
+            "biome.jsonc",
+            "biome.json"
+        ],
+        standardPlaces: [
+            "biome.jsonc",
+            "biome.json"
+        ]
+    },
+    eslint: {
+        moduleName: "eslint",
+        libConfigFiles: [
+            "eslint.config.ts",
+            "eslint.config.js",
+            "eslint.config.mjs"
+        ],
+        standardPlaces: [
+            "eslint.config.ts",
+            "eslint.config.js",
+            "eslint.config.mjs"
+        ]
+    },
+    prettier: {
+        moduleName: "prettier",
+        libConfigFiles: [
+            ".prettierrc",
+            ".prettierrc.json",
+            ".prettierrc.yaml",
+            ".prettierrc.js",
+            "prettier.config.js"
+        ],
+        standardPlaces: [
+            ".prettierrc",
+            ".prettierrc.json",
+            ".prettierrc.yaml",
+            ".prettierrc.js",
+            "prettier.config.js",
+            "package.json"
+        ]
+    }
+};
+class ConfigSearch {
+    static libConfigDir = "lib/configs";
+    static find(tool, options = {}) {
+        const config = TOOL_CONFIGS[tool];
+        if (!config) return {
+            filepath: void 0,
+            found: false
+        };
+        return ConfigSearch.findFile(config.moduleName, {
+            libConfigFiles: config.libConfigFiles,
+            standardPlaces: config.standardPlaces,
+            ...options
+        });
+    }
+    static findFile(moduleName, options = {}) {
+        const { searchFrom = process.cwd(), stopDir, libConfigFiles = [], standardPlaces = [] } = options;
+        const loaders = {
+            ".jsonc": defaultLoaders[".json"],
+            ".yaml": defaultLoaders[".yaml"],
+            ".yml": defaultLoaders[".yaml"]
+        };
+        const libConfigDir = join(searchFrom, ConfigSearch.libConfigDir);
+        for (const file of libConfigFiles){
+            const filepath = join(libConfigDir, file);
+            if (existsSync(filepath)) return {
+                filepath,
+                found: true
+            };
+        }
+        if (0 === standardPlaces.length) return {
+            filepath: void 0,
+            found: false
+        };
+        try {
+            const explorer = cosmiconfigSync(moduleName, {
+                searchPlaces: standardPlaces,
+                loaders,
+                ...void 0 !== stopDir && {
+                    stopDir
+                }
+            });
+            const result = explorer.search(searchFrom);
+            if (result?.filepath) return {
+                filepath: result.filepath,
+                found: true
+            };
+        } catch  {}
+        return {
+            filepath: void 0,
+            found: false
+        };
+    }
+    static exists(filepath) {
+        return existsSync(filepath);
+    }
+    static resolve(filename, fallback) {
+        const libPath = `${ConfigSearch.libConfigDir}/${filename}`;
+        if (ConfigSearch.exists(libPath)) return libPath;
+        return fallback;
+    }
+}
+class Filter {
+    static exclude(filenames, patterns) {
+        if (0 === patterns.length) return [
+            ...filenames
+        ];
+        return filenames.filter((file)=>!patterns.some((pattern)=>file.includes(pattern)));
+    }
+    static include(filenames, patterns) {
+        if (0 === patterns.length) return [];
+        return filenames.filter((file)=>patterns.some((pattern)=>file.includes(pattern)));
+    }
+    static apply(filenames, options) {
+        let result = [
+            ...filenames
+        ];
+        if (options.include && options.include.length > 0) result = Filter.include(result, options.include);
+        if (options.exclude && options.exclude.length > 0) result = Filter.exclude(result, options.exclude);
+        return result;
+    }
+}
+class Biome {
+    static glob = "*.{js,ts,cjs,mjs,d.cts,d.mts,jsx,tsx,json,jsonc}";
+    static defaultExcludes = [
+        "package-lock.json",
+        "__fixtures__"
+    ];
+    static handler = Biome.create();
+    static findBiome() {
+        const result = Command_Command.findTool("biome");
+        return result.command;
+    }
+    static isAvailable() {
+        return Command_Command.findTool("biome").available;
+    }
+    static findConfig() {
+        const result = ConfigSearch.find("biome");
+        return result.filepath;
+    }
+    static create(options = {}) {
+        const excludes = options.exclude ?? [
+            ...Biome.defaultExcludes
+        ];
+        const config = options.config ?? Biome.findConfig();
+        return (filenames)=>{
+            const filtered = Filter.exclude(filenames, excludes);
+            if (0 === filtered.length) return [];
+            const biomeCmd = Command_Command.requireTool("biome", "Biome is not available. Install it globally (recommended) or add @biomejs/biome as a dev dependency.");
+            const files = filtered.join(" ");
+            const flags = options.flags ?? [];
+            const configFlag = config ? `--config-path=${config}` : "";
+            const cmd = [
+                `${biomeCmd} check --write --no-errors-on-unmatched`,
+                configFlag,
+                ...flags,
+                files
+            ].filter(Boolean).join(" ");
+            return cmd;
+        };
+    }
+}
+class Markdown {
+    static glob = "**/*.{md,mdx}";
+    static defaultExcludes = [];
+    static handler = Markdown.create();
+    static findMarkdownlint() {
+        const result = Command_Command.findTool("markdownlint-cli2");
+        return result.command;
+    }
+    static isAvailable() {
+        return Command_Command.findTool("markdownlint-cli2").available;
+    }
+    static findConfig() {
+        const result = ConfigSearch.find("markdownlint");
+        return result.filepath;
+    }
+    static create(options = {}) {
+        const excludes = options.exclude ?? [
+            ...Markdown.defaultExcludes
+        ];
+        const noFix = options.noFix ?? false;
+        const config = options.config ?? Markdown.findConfig();
+        return (filenames)=>{
+            const filtered = Filter.exclude(filenames, excludes);
+            if (0 === filtered.length) return [];
+            const mdlintCmd = Command_Command.requireTool("markdownlint-cli2", "markdownlint-cli2 is not available. Install it globally or add it as a dev dependency.");
+            const files = filtered.join(" ");
+            const fixFlag = noFix ? "" : "--fix";
+            const configFlag = config ? `--config '${config}'` : "";
+            const cmd = [
+                mdlintCmd,
+                configFlag,
+                fixFlag,
+                files
+            ].filter(Boolean).join(" ");
+            return cmd;
+        };
+    }
+}
+class TsDocLinter {
+    eslint;
+    constructor(options = {}){
+        const ignorePatterns = options.ignorePatterns ?? [];
+        const config = [
+            {
+                ignores: [
+                    "**/node_modules/**",
+                    "**/dist/**",
+                    "**/coverage/**",
+                    ...ignorePatterns
+                ]
+            },
+            {
+                files: [
+                    "**/*.ts",
+                    "**/*.tsx",
+                    "**/*.mts",
+                    "**/*.cts"
+                ],
+                languageOptions: {
+                    parser: parser
+                },
+                plugins: {
+                    tsdoc: eslint_plugin_tsdoc
+                },
+                rules: {
+                    "tsdoc/syntax": "error"
+                }
+            }
+        ];
+        this.eslint = new ESLint({
+            overrideConfigFile: true,
+            overrideConfig: config
+        });
+    }
+    async lintFiles(filePaths) {
+        if (0 === filePaths.length) return [];
+        const results = await this.eslint.lintFiles(filePaths);
+        return results.map((result)=>({
+                filePath: result.filePath,
+                errorCount: result.errorCount,
+                warningCount: result.warningCount,
+                messages: result.messages.map((msg)=>({
+                        line: msg.line,
+                        column: msg.column,
+                        severity: msg.severity,
+                        message: msg.message,
+                        ruleId: msg.ruleId
+                    }))
+            }));
+    }
+    async lintFilesAndThrow(filePaths) {
+        const results = await this.lintFiles(filePaths);
+        const errors = [];
+        for (const result of results)if (result.errorCount > 0) {
+            for (const msg of result.messages)if (2 === msg.severity) errors.push(`${result.filePath}:${msg.line}:${msg.column} - ${msg.message}`);
+        }
+        if (errors.length > 0) throw new Error(`TSDoc validation failed:\n${errors.join("\n")}`);
+    }
+    static formatResults(results) {
+        const lines = [];
+        for (const result of results)if (0 !== result.errorCount || 0 !== result.warningCount) {
+            lines.push(`\n${result.filePath}`);
+            for (const msg of result.messages){
+                const severity = 2 === msg.severity ? "error" : "warning";
+                const rule = msg.ruleId ? ` (${msg.ruleId})` : "";
+                lines.push(`  ${msg.line}:${msg.column}  ${severity}  ${msg.message}${rule}`);
+            }
+        }
+        const totalErrors = results.reduce((sum, r)=>sum + r.errorCount, 0);
+        const totalWarnings = results.reduce((sum, r)=>sum + r.warningCount, 0);
+        if (totalErrors > 0 || totalWarnings > 0) lines.push(`\n✖ ${totalErrors} error(s), ${totalWarnings} warning(s)`);
+        return lines.join("\n");
+    }
+    static hasErrors(results) {
+        return results.some((r)=>r.errorCount > 0);
+    }
+}
+const TS_EXTENSIONS = [
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts"
+];
+class EntryExtractor {
+    extract(packageJson) {
+        const entries = {};
+        const unresolved = [];
+        const { exports } = packageJson;
+        if (!exports) {
+            const mainEntry = packageJson.module ?? packageJson.main;
+            if (mainEntry && this.isTypeScriptFile(mainEntry)) entries["."] = mainEntry;
+            else if (mainEntry) unresolved.push(".");
+            return {
+                entries,
+                unresolved
+            };
+        }
+        if ("string" == typeof exports) {
+            if (this.isTypeScriptFile(exports)) entries["."] = exports;
+            else unresolved.push(".");
+            return {
+                entries,
+                unresolved
+            };
+        }
+        this.extractFromObject(exports, entries, unresolved, ".");
+        return {
+            entries,
+            unresolved
+        };
+    }
+    extractFromObject(obj, entries, unresolved, currentPath) {
+        for (const [key, value] of Object.entries(obj)){
+            const exportPath = key.startsWith(".") ? key : currentPath;
+            if ("string" == typeof value) {
+                if (this.isTypeScriptFile(value)) entries[exportPath] = value;
+                else if (key.startsWith(".")) unresolved.push(exportPath);
+            } else if (value && "object" == typeof value && !Array.isArray(value)) {
+                const nested = value;
+                const tsPath = this.findTypeScriptCondition(nested);
+                if (tsPath) entries[exportPath] = tsPath;
+                else if (key.startsWith(".")) this.extractFromObject(nested, entries, unresolved, exportPath);
+                else {
+                    const sourcePath = this.findSourceCondition(nested);
+                    if (sourcePath && this.isTypeScriptFile(sourcePath)) entries[exportPath] = sourcePath;
+                }
+            }
+        }
+    }
+    findTypeScriptCondition(conditions) {
+        const priorityKeys = [
+            "source",
+            "typescript",
+            "development",
+            "default"
+        ];
+        for (const key of priorityKeys){
+            const value = conditions[key];
+            if ("string" == typeof value && this.isTypeScriptFile(value)) return value;
+            if (value && "object" == typeof value) {
+                const nested = this.findTypeScriptCondition(value);
+                if (nested) return nested;
+            }
+        }
+        return null;
+    }
+    findSourceCondition(conditions) {
+        const priorityKeys = [
+            "source",
+            "import",
+            "require",
+            "default"
+        ];
+        for (const key of priorityKeys){
+            const value = conditions[key];
+            if ("string" == typeof value) return value;
+            if (value && "object" == typeof value) {
+                const nested = this.findSourceCondition(value);
+                if (nested) return nested;
+            }
+        }
+        return null;
+    }
+    isTypeScriptFile(filePath) {
+        return TS_EXTENSIONS.some((ext)=>filePath.endsWith(ext));
+    }
+}
+class ImportGraph {
+    options;
+    program = null;
+    compilerOptions = null;
+    moduleResolutionCache = null;
+    constructor(options){
+        this.options = options;
+    }
+    traceFromEntries(entryPaths) {
+        const errors = [];
+        const visited = new Set();
+        const entries = [];
+        const initResult = this.initializeProgram();
+        if (!initResult.success) return {
+            files: [],
+            entries: [],
+            errors: [
+                initResult.error
+            ]
+        };
+        for (const entryPath of entryPaths){
+            const absolutePath = this.resolveEntryPath(entryPath);
+            if (!existsSync(absolutePath)) {
+                errors.push({
+                    type: "entry_not_found",
+                    message: `Entry file not found: ${entryPath}`,
+                    path: absolutePath
+                });
+                continue;
+            }
+            entries.push(absolutePath);
+            this.traceImports(absolutePath, visited, errors);
+        }
+        const files = Array.from(visited).filter((file)=>this.isSourceFile(file));
+        return {
+            files: files.sort(),
+            entries,
+            errors
+        };
+    }
+    traceFromPackageExports(packageJsonPath) {
+        const absolutePath = this.resolveEntryPath(packageJsonPath);
+        let packageJson;
+        try {
+            if (!existsSync(absolutePath)) return {
+                files: [],
+                entries: [],
+                errors: [
+                    {
+                        type: "package_json_not_found",
+                        message: `Failed to read package.json: File not found at ${absolutePath}`,
+                        path: absolutePath
+                    }
+                ]
+            };
+            const content = readFileSync(absolutePath, "utf-8");
+            packageJson = JSON.parse(content);
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                files: [],
+                entries: [],
+                errors: [
+                    {
+                        type: "package_json_parse_error",
+                        message: `Failed to parse package.json: ${message}`,
+                        path: absolutePath
+                    }
+                ]
+            };
+        }
+        const extractor = new EntryExtractor();
+        const { entries } = extractor.extract(packageJson);
+        const packageDir = dirname(absolutePath);
+        const entryPaths = Object.values(entries).map((p)=>resolve(packageDir, p));
+        return this.traceFromEntries(entryPaths);
+    }
+    initializeProgram() {
+        if (this.program) return {
+            success: true
+        };
+        const configPath = this.findTsConfig();
+        if (!configPath) {
+            this.compilerOptions = {
+                moduleResolution: typescript.ModuleResolutionKind.NodeNext,
+                module: typescript.ModuleKind.NodeNext,
+                target: typescript.ScriptTarget.ESNext,
+                strict: true
+            };
+            this.moduleResolutionCache = typescript.createModuleResolutionCache(this.options.rootDir, (fileName)=>fileName.toLowerCase(), this.compilerOptions);
+            const host = typescript.createCompilerHost(this.compilerOptions, true);
+            host.getCurrentDirectory = ()=>this.options.rootDir;
+            this.program = typescript.createProgram([], this.compilerOptions, host);
+            return {
+                success: true
+            };
+        }
+        const configFile = typescript.readConfigFile(configPath, (path)=>readFileSync(path, "utf-8"));
+        if (configFile.error) {
+            const message = typescript.flattenDiagnosticMessageText(configFile.error.messageText, "\n");
+            return {
+                success: false,
+                error: {
+                    type: "tsconfig_read_error",
+                    message: `Failed to read tsconfig.json: ${message}`,
+                    path: configPath
+                }
+            };
+        }
+        const parsed = typescript.parseJsonConfigFileContent(configFile.config, typescript.sys, dirname(configPath));
+        if (parsed.errors.length > 0) {
+            const messages = parsed.errors.map((e)=>typescript.flattenDiagnosticMessageText(e.messageText, "\n")).join("\n");
+            return {
+                success: false,
+                error: {
+                    type: "tsconfig_parse_error",
+                    message: `Failed to parse tsconfig.json: ${messages}`,
+                    path: configPath
+                }
+            };
+        }
+        this.compilerOptions = parsed.options;
+        this.moduleResolutionCache = typescript.createModuleResolutionCache(this.options.rootDir, (fileName)=>fileName.toLowerCase(), this.compilerOptions);
+        const host = typescript.createCompilerHost(this.compilerOptions, true);
+        host.getCurrentDirectory = ()=>this.options.rootDir;
+        this.program = typescript.createProgram([], this.compilerOptions, host);
+        return {
+            success: true
+        };
+    }
+    findTsConfig() {
+        if (this.options.tsconfigPath) {
+            const customPath = isAbsolute(this.options.tsconfigPath) ? this.options.tsconfigPath : resolve(this.options.rootDir, this.options.tsconfigPath);
+            if (existsSync(customPath)) return customPath;
+            return null;
+        }
+        const configPath = typescript.findConfigFile(this.options.rootDir, (path)=>existsSync(path));
+        return configPath ?? null;
+    }
+    resolveEntryPath(entryPath) {
+        if (isAbsolute(entryPath)) return normalize(entryPath);
+        return normalize(resolve(this.options.rootDir, entryPath));
+    }
+    traceImports(filePath, visited, errors) {
+        const normalizedPath = normalize(filePath);
+        if (visited.has(normalizedPath)) return;
+        if (this.isExternalModule(normalizedPath)) return;
+        visited.add(normalizedPath);
+        let content;
+        try {
+            content = readFileSync(normalizedPath, "utf-8");
+        } catch  {
+            errors.push({
+                type: "file_read_error",
+                message: `Failed to read file: ${normalizedPath}`,
+                path: normalizedPath
+            });
+            return;
+        }
+        const sourceFile = typescript.createSourceFile(normalizedPath, content, typescript.ScriptTarget.Latest, true);
+        const imports = this.extractImports(sourceFile);
+        for (const importPath of imports){
+            const resolved = this.resolveImport(importPath, normalizedPath);
+            if (resolved) this.traceImports(resolved, visited, errors);
+        }
+    }
+    extractImports(sourceFile) {
+        const imports = [];
+        const visit = (node)=>{
+            if (typescript.isImportDeclaration(node)) {
+                const specifier = node.moduleSpecifier;
+                if (typescript.isStringLiteral(specifier)) imports.push(specifier.text);
+            } else if (typescript.isExportDeclaration(node)) {
+                const specifier = node.moduleSpecifier;
+                if (specifier && typescript.isStringLiteral(specifier)) imports.push(specifier.text);
+            } else if (typescript.isCallExpression(node)) {
+                const expression = node.expression;
+                if (expression.kind === typescript.SyntaxKind.ImportKeyword && node.arguments.length > 0) {
+                    const arg = node.arguments[0];
+                    if (arg && typescript.isStringLiteral(arg)) imports.push(arg.text);
+                }
+            }
+            typescript.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+        return imports;
+    }
+    resolveImport(specifier, fromFile) {
+        if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
+            if (!this.compilerOptions?.paths || !Object.keys(this.compilerOptions.paths).length) return null;
+        }
+        if (!this.compilerOptions || !this.moduleResolutionCache) return null;
+        const resolved = typescript.resolveModuleName(specifier, fromFile, this.compilerOptions, typescript.sys, this.moduleResolutionCache);
+        if (resolved.resolvedModule) {
+            const resolvedPath = resolved.resolvedModule.resolvedFileName;
+            if (resolved.resolvedModule.isExternalLibraryImport) return null;
+            if (resolvedPath.endsWith(".d.ts")) {
+                const sourcePath = resolvedPath.replace(/\.d\.ts$/, ".ts");
+                if (existsSync(sourcePath)) return sourcePath;
+                return null;
+            }
+            return resolvedPath;
+        }
+        return null;
+    }
+    isExternalModule(filePath) {
+        return filePath.includes("/node_modules/") || filePath.includes("\\node_modules\\");
+    }
+    isSourceFile(filePath) {
+        if (!filePath.endsWith(".ts") && !filePath.endsWith(".tsx") && !filePath.endsWith(".mts") && !filePath.endsWith(".cts")) return false;
+        if (filePath.endsWith(".d.ts") || filePath.endsWith(".d.mts") || filePath.endsWith(".d.cts")) return false;
+        if (filePath.includes(".test.") || filePath.includes(".spec.")) return false;
+        if (filePath.includes("/__test__/") || filePath.includes("\\__test__\\")) return false;
+        if (filePath.includes("/__tests__/") || filePath.includes("\\__tests__\\")) return false;
+        const excludePatterns = this.options.excludePatterns ?? [];
+        for (const pattern of excludePatterns)if (filePath.includes(pattern)) return false;
+        return true;
+    }
+    static fromEntries(entryPaths, options) {
+        const graph = new ImportGraph(options);
+        return graph.traceFromEntries(entryPaths);
+    }
+    static fromPackageExports(packageJsonPath, options) {
+        const graph = new ImportGraph(options);
+        return graph.traceFromPackageExports(packageJsonPath);
+    }
+}
+class TsDocResolver {
+    options;
+    constructor(options){
+        this.options = options;
+    }
+    resolve() {
+        const { rootDir } = this.options;
+        const workspaces = [];
+        const repoTsdocPath = join(rootDir, "tsdoc.json");
+        const repoTsdocConfig = existsSync(repoTsdocPath) ? repoTsdocPath : void 0;
+        const workspaceInfos = getWorkspaceInfos(rootDir);
+        const isMonorepo = void 0 !== workspaceInfos && workspaceInfos.length > 1;
+        if (void 0 === workspaceInfos || 0 === workspaceInfos.length) {
+            const result = this.resolveWorkspace(rootDir, repoTsdocConfig);
+            if (result) workspaces.push(result);
+        } else for (const info of workspaceInfos){
+            const workspacePath = info.path;
+            const result = this.resolveWorkspace(workspacePath, repoTsdocConfig);
+            if (result) workspaces.push(result);
+        }
+        const result = {
+            workspaces,
+            isMonorepo
+        };
+        if (void 0 !== repoTsdocConfig) result.repoTsdocConfig = repoTsdocConfig;
+        return result;
+    }
+    resolveWorkspace(workspacePath, repoTsdocConfig) {
+        const packageJsonPath = join(workspacePath, "package.json");
+        if (!existsSync(packageJsonPath)) return null;
+        let packageJson;
+        try {
+            const content = readFileSync(packageJsonPath, "utf-8");
+            packageJson = JSON.parse(content);
+        } catch  {
+            return null;
+        }
+        const workspaceTsdocPath = join(workspacePath, "tsdoc.json");
+        const workspaceTsdocConfig = existsSync(workspaceTsdocPath) ? workspaceTsdocPath : void 0;
+        const tsdocConfigPath = workspaceTsdocConfig ?? repoTsdocConfig;
+        if (!tsdocConfigPath) return null;
+        if (!packageJson.exports) return null;
+        const name = packageJson.name ?? relative(this.options.rootDir, workspacePath);
+        const errors = [];
+        const graphOptions = {
+            rootDir: workspacePath
+        };
+        if (void 0 !== this.options.excludePatterns) graphOptions.excludePatterns = this.options.excludePatterns;
+        const graph = new ImportGraph(graphOptions);
+        const result = graph.traceFromPackageExports(packageJsonPath);
+        for (const error of result.errors)errors.push(error.message);
+        return {
+            name,
+            path: workspacePath,
+            tsdocConfigPath,
+            files: result.files,
+            errors
+        };
+    }
+    filterStagedFiles(stagedFiles) {
+        const result = this.resolve();
+        const output = [];
+        for (const workspace of result.workspaces){
+            const workspaceFiles = new Set(workspace.files);
+            const matchedFiles = stagedFiles.filter((f)=>workspaceFiles.has(f));
+            if (matchedFiles.length > 0) output.push({
+                files: matchedFiles,
+                tsdocConfigPath: workspace.tsdocConfigPath
+            });
+        }
+        return output;
+    }
+    needsLinting(filePath) {
+        const result = this.resolve();
+        for (const workspace of result.workspaces)if (workspace.files.includes(filePath)) return true;
+        return false;
+    }
+    getTsDocConfig(filePath) {
+        const result = this.resolve();
+        for (const workspace of result.workspaces)if (workspace.files.includes(filePath)) return workspace.tsdocConfigPath;
+    }
+    findWorkspace(filePath) {
+        const result = this.resolve();
+        for (const workspace of result.workspaces)if (filePath.startsWith(workspace.path)) return workspace;
+    }
+}
+class TypeScript {
+    static glob = "*.{ts,cts,mts,tsx}";
+    static defaultExcludes = [];
+    static defaultTsdocExcludes = [
+        ".test.",
+        ".spec.",
+        "__test__",
+        "__tests__"
+    ];
+    static detectCompiler(cwd = process.cwd()) {
+        const packageJsonPath = join(cwd, "package.json");
+        if (!existsSync(packageJsonPath)) return;
+        try {
+            const content = readFileSync(packageJsonPath, "utf-8");
+            const pkg = JSON.parse(content);
+            const allDeps = {
+                ...pkg.dependencies,
+                ...pkg.devDependencies
+            };
+            if ("@typescript/native-preview" in allDeps) return "tsgo";
+            if ("typescript" in allDeps) return "tsc";
+        } catch  {}
+    }
+    static isAvailable() {
+        return void 0 !== TypeScript.detectCompiler();
+    }
+    static getDefaultTypecheckCommand() {
+        const compiler = TypeScript.detectCompiler();
+        if (!compiler) throw new Error("No TypeScript compiler found. Install 'typescript' or '@typescript/native-preview' as a dev dependency.");
+        const pm = Command_Command.detectPackageManager();
+        const prefix = Command_Command.getExecPrefix(pm);
+        return [
+            ...prefix,
+            compiler,
+            "--noEmit"
+        ].join(" ");
+    }
+    static handler = TypeScript.create();
+    static isTsdocAvailable(cwd = process.cwd()) {
+        const tsdocPath = join(cwd, "tsdoc.json");
+        return existsSync(tsdocPath);
+    }
+    static create(options = {}) {
+        const excludes = options.exclude ?? [
+            ...TypeScript.defaultExcludes
+        ];
+        const tsdocExcludes = options.excludeTsdoc ?? [
+            ...TypeScript.defaultTsdocExcludes
+        ];
+        const skipTsdoc = options.skipTsdoc ?? false;
+        const skipTypecheck = options.skipTypecheck ?? false;
+        const rootDir = options.rootDir ?? process.cwd();
+        let typecheckCommand;
+        const getTypecheckCommand = ()=>{
+            if (void 0 === typecheckCommand) typecheckCommand = options.typecheckCommand ?? TypeScript.getDefaultTypecheckCommand();
+            return typecheckCommand;
+        };
+        return async (filenames)=>{
+            const filtered = Filter.exclude(filenames, excludes);
+            if (0 === filtered.length) return [];
+            const commands = [];
+            if (!skipTsdoc) {
+                const resolver = new TsDocResolver({
+                    rootDir,
+                    excludePatterns: [
+                        ...tsdocExcludes
+                    ]
+                });
+                const absoluteFiles = filtered.map((f)=>isAbsolute(f) ? f : join(rootDir, f));
+                const tsdocGroups = resolver.filterStagedFiles(absoluteFiles);
+                for (const group of tsdocGroups)if (group.files.length > 0) {
+                    const linter = new TsDocLinter({
+                        ignorePatterns: tsdocExcludes.map((p)=>`**/*${p}*`)
+                    });
+                    const results = await linter.lintFiles(group.files);
+                    if (TsDocLinter.hasErrors(results)) {
+                        const output = TsDocLinter.formatResults(results);
+                        throw new Error(`TSDoc validation failed:\n${output}`);
+                    }
+                }
+            }
+            if (!skipTypecheck && filtered.length > 0) commands.push(getTypecheckCommand());
+            return commands;
+        };
+    }
+}
+const CHECK_MARK = "\u2713";
+const WARNING = "\u26A0";
+const EXECUTABLE_MODE = 493;
+const HUSKY_HOOK_PATH = ".husky/pre-commit";
+const DEFAULT_CONFIG_PATH = "lib/configs/lint-staged.config.js";
+const BEGIN_MARKER = "# --- BEGIN SAVVY-LINT MANAGED SECTION ---";
+const END_MARKER = "# --- END SAVVY-LINT MANAGED SECTION ---";
+function generateManagedContent(configPath) {
+    return `# DO NOT EDIT between these markers - managed by savvy-lint
+# Skip in CI environment
+{ [ -n "$CI" ] || [ -n "$GITHUB_ACTIONS" ]; } && exit 0
+
+# Get repo root directory
+ROOT=$(git rev-parse --show-toplevel)
+
+# Detect package manager from package.json or lockfiles
+detect_pm() {
+  # Check packageManager field in package.json (e.g., "pnpm@9.0.0")
+  if [ -f "$ROOT/package.json" ]; then
+    pm=$(jq -r '.packageManager // empty' "$ROOT/package.json" 2>/dev/null | cut -d'@' -f1)
+    if [ -n "$pm" ]; then
+      echo "$pm"
+      return
+    fi
+  fi
+
+  # Fallback to lockfile detection
+  if [ -f "$ROOT/pnpm-lock.yaml" ]; then
+    echo "pnpm"
+  elif [ -f "$ROOT/yarn.lock" ]; then
+    echo "yarn"
+  elif [ -f "$ROOT/bun.lock" ]; then
+    echo "bun"
+  else
+    echo "npm"
+  fi
+}
+
+# Get the exec command for the detected package manager
+PM=$(detect_pm)
+case "$PM" in
+  pnpm) CMD="pnpm exec" ;;
+  yarn) CMD="yarn exec" ;;
+  bun)  CMD="bunx" ;;
+  *)    CMD="npx --no --" ;;
+esac
+
+$CMD lint-staged --config "$ROOT/${configPath}"`;
+}
+function generateFullHookContent(configPath) {
+    return `#!/usr/bin/env sh
+# Pre-commit hook with savvy-lint managed section
+# Custom hooks can go above or below the managed section
+
+${BEGIN_MARKER}
+${generateManagedContent(configPath)}
+${END_MARKER}
+`;
+}
+function extractManagedSection(content) {
+    const beginIndex = content.indexOf(BEGIN_MARKER);
+    const endIndex = content.indexOf(END_MARKER);
+    if (-1 === beginIndex || -1 === endIndex || endIndex <= beginIndex) return {
+        beforeSection: content,
+        managedSection: "",
+        afterSection: "",
+        found: false
+    };
+    return {
+        beforeSection: content.slice(0, beginIndex),
+        managedSection: content.slice(beginIndex, endIndex + END_MARKER.length),
+        afterSection: content.slice(endIndex + END_MARKER.length),
+        found: true
+    };
+}
+function updateManagedSection(existingContent, configPath) {
+    const { beforeSection, afterSection, found } = extractManagedSection(existingContent);
+    const newManagedSection = `${BEGIN_MARKER}\n${generateManagedContent(configPath)}\n${END_MARKER}`;
+    if (found) return `${beforeSection}${newManagedSection}${afterSection}`;
+    const trimmedContent = existingContent.trimEnd();
+    return `${trimmedContent}\n\n${newManagedSection}\n`;
+}
+function generateConfigContent(preset) {
+    return `/**
+ * @type {import('lint-staged').Configuration}
+ * Generated by savvy-lint init
+ */
+import { Preset } from "@savvy-web/lint-staged";
+
+export default Preset.${preset}();
+`;
+}
+const forceOption = Options.boolean("force").pipe(Options.withAlias("f"), Options.withDescription("Overwrite entire hook file (not just managed section)"), Options.withDefault(false));
+const configOption = Options.text("config").pipe(Options.withAlias("c"), Options.withDescription("Relative path for the lint-staged config file (from repo root)"), Options.withDefault(DEFAULT_CONFIG_PATH));
+const presetOption = Options.choice("preset", [
+    "minimal",
+    "standard",
+    "full"
+]).pipe(Options.withAlias("p"), Options.withDescription("Preset to use: minimal, standard, or full"), Options.withDefault("full"));
+function makeExecutable(path) {
+    return Effect.tryPromise(()=>import("node:fs/promises").then((fs)=>fs.chmod(path, EXECUTABLE_MODE)));
+}
+const initCommand = Command.make("init", {
+    force: forceOption,
+    config: configOption,
+    preset: presetOption
+}, ({ force, config, preset })=>Effect.gen(function*() {
+        const fs = yield* FileSystem.FileSystem;
+        if (config.startsWith("/")) yield* Effect.fail(new Error("Config path must be relative to repository root, not absolute"));
+        yield* Effect.log("Initializing lint-staged configuration...\n");
+        const huskyExists = yield* fs.exists(HUSKY_HOOK_PATH);
+        if (huskyExists && !force) {
+            const existingContent = yield* fs.readFileString(HUSKY_HOOK_PATH);
+            const { found } = extractManagedSection(existingContent);
+            const updatedContent = updateManagedSection(existingContent, config);
+            yield* fs.writeFileString(HUSKY_HOOK_PATH, updatedContent);
+            yield* makeExecutable(HUSKY_HOOK_PATH);
+            if (found) yield* Effect.log(`${CHECK_MARK} Updated managed section in ${HUSKY_HOOK_PATH}`);
+            else yield* Effect.log(`${CHECK_MARK} Added managed section to ${HUSKY_HOOK_PATH}`);
+        } else if (huskyExists && force) {
+            yield* fs.writeFileString(HUSKY_HOOK_PATH, generateFullHookContent(config));
+            yield* makeExecutable(HUSKY_HOOK_PATH);
+            yield* Effect.log(`${CHECK_MARK} Replaced ${HUSKY_HOOK_PATH} (--force)`);
+        } else {
+            yield* fs.makeDirectory(".husky", {
+                recursive: true
+            });
+            yield* fs.writeFileString(HUSKY_HOOK_PATH, generateFullHookContent(config));
+            yield* makeExecutable(HUSKY_HOOK_PATH);
+            yield* Effect.log(`${CHECK_MARK} Created ${HUSKY_HOOK_PATH}`);
+        }
+        const configExists = yield* fs.exists(config);
+        if (configExists && !force) yield* Effect.log(`${WARNING} ${config} already exists (use --force to overwrite)`);
+        else {
+            const configDir = dirname(config);
+            if (configDir && "." !== configDir) yield* fs.makeDirectory(configDir, {
+                recursive: true
+            });
+            yield* fs.writeFileString(config, generateConfigContent(preset));
+            yield* Effect.log(`${CHECK_MARK} Created ${config} (preset: ${preset})`);
+        }
+        yield* Effect.log("\nDone! Lint-staged is ready to use.");
+    })).pipe(Command.withDescription("Initialize lint-staged configuration and husky hooks"));
+const check_CHECK_MARK = "\u2713";
+const CROSS_MARK = "\u2717";
+const check_WARNING = "\u26A0";
+const BULLET = "\u2022";
+const check_HUSKY_HOOK_PATH = ".husky/pre-commit";
+const CONFIG_FILES = [
+    "lint-staged.config.js",
+    "lint-staged.config.mjs",
+    "lint-staged.config.cjs",
+    "lint-staged.config.ts",
+    ".lintstagedrc",
+    ".lintstagedrc.json",
+    ".lintstagedrc.yaml",
+    ".lintstagedrc.yml",
+    ".lintstagedrc.js",
+    ".lintstagedrc.cjs",
+    ".lintstagedrc.mjs"
+];
+const CONFIG_SEARCH_PATHS = [
+    "lib/configs/lint-staged.config.js",
+    "lib/configs/lint-staged.config.ts",
+    ...CONFIG_FILES
+];
+function findConfigFile(fs) {
+    return Effect.gen(function*() {
+        for (const file of CONFIG_SEARCH_PATHS)if (yield* fs.exists(file)) return file;
+        return null;
+    });
+}
+function extractConfigPathFromManaged(managedContent) {
+    const match = managedContent.match(/lint-staged --config "\$ROOT\/([^"]+)"/);
+    return match ? match[1] : null;
+}
+function checkManagedSectionStatus(existingManaged) {
+    const configPath = extractConfigPathFromManaged(existingManaged);
+    if (!configPath) return {
+        isUpToDate: false,
+        configPath: null,
+        needsUpdate: true
+    };
+    const expectedContent = `${BEGIN_MARKER}\n${generateManagedContent(configPath)}\n${END_MARKER}`;
+    const normalizedExisting = existingManaged.trim().replace(/\s+/g, " ");
+    const normalizedExpected = expectedContent.trim().replace(/\s+/g, " ");
+    const isUpToDate = normalizedExisting === normalizedExpected;
+    return {
+        isUpToDate,
+        configPath,
+        needsUpdate: !isUpToDate
+    };
+}
+const quietOption = Options.boolean("quiet").pipe(Options.withAlias("q"), Options.withDescription("Only output warnings (for postinstall usage)"), Options.withDefault(false));
+const checkCommand = Command.make("check", {
+    quiet: quietOption
+}, ({ quiet })=>Effect.gen(function*() {
+        const fs = yield* FileSystem.FileSystem;
+        const warnings = [];
+        const foundConfig = yield* findConfigFile(fs);
+        const hasHuskyHook = yield* fs.exists(check_HUSKY_HOOK_PATH);
+        let managedStatus = {
+            isUpToDate: false,
+            configPath: null,
+            needsUpdate: false,
+            found: false
+        };
+        if (hasHuskyHook) {
+            const hookContent = yield* fs.readFileString(check_HUSKY_HOOK_PATH);
+            const { managedSection, found } = extractManagedSection(hookContent);
+            if (found) {
+                const status = checkManagedSectionStatus(managedSection);
+                managedStatus = {
+                    ...status,
+                    found: true
+                };
+                if (status.needsUpdate) warnings.push(`${check_WARNING}  Your ${check_HUSKY_HOOK_PATH} managed section is outdated.\n   Run 'savvy-lint init' to update it (preserves your custom hooks).`);
+            } else {
+                managedStatus = {
+                    isUpToDate: false,
+                    configPath: null,
+                    needsUpdate: false,
+                    found: false
+                };
+                warnings.push(`${check_WARNING}  Your ${check_HUSKY_HOOK_PATH} does not have a savvy-lint managed section.\n   Run 'savvy-lint init' to add it.`);
+            }
+        } else warnings.push(`${check_WARNING}  No husky pre-commit hook found.\n   Run 'savvy-lint init' to create it.`);
+        if (!foundConfig) warnings.push(`${check_WARNING}  No lint-staged config file found.\n   Run 'savvy-lint init' to create one.`);
+        if (quiet) {
+            if (warnings.length > 0) for (const warning of warnings)yield* Effect.log(warning);
+            return;
+        }
+        yield* Effect.log("Checking lint-staged configuration...\n");
+        if (foundConfig) yield* Effect.log(`${check_CHECK_MARK} Config file: ${foundConfig}`);
+        else yield* Effect.log(`${CROSS_MARK} No lint-staged config file found`);
+        if (hasHuskyHook) yield* Effect.log(`${check_CHECK_MARK} Husky hook: ${check_HUSKY_HOOK_PATH}`);
+        else yield* Effect.log(`${CROSS_MARK} No husky pre-commit hook found`);
+        if (hasHuskyHook) if (managedStatus.found) if (managedStatus.isUpToDate) yield* Effect.log(`${check_CHECK_MARK} Managed section: up-to-date`);
+        else yield* Effect.log(`${check_WARNING} Managed section: outdated (run 'savvy-lint init' to update)`);
+        else yield* Effect.log(`${BULLET} Managed section: not found (run 'savvy-lint init' to add)`);
+        yield* Effect.log("\nTool availability:");
+        const biomeAvailable = Biome.isAvailable();
+        const biomeConfig = Biome.findConfig();
+        if (biomeAvailable) {
+            const configInfo = biomeConfig ? ` (config: ${biomeConfig})` : "";
+            yield* Effect.log(`  ${check_CHECK_MARK} Biome${configInfo}`);
+        } else yield* Effect.log(`  ${BULLET} Biome: not installed`);
+        const markdownAvailable = Markdown.isAvailable();
+        const markdownConfig = Markdown.findConfig();
+        if (markdownAvailable) {
+            const configInfo = markdownConfig ? ` (config: ${markdownConfig})` : "";
+            yield* Effect.log(`  ${check_CHECK_MARK} markdownlint-cli2${configInfo}`);
+        } else yield* Effect.log(`  ${BULLET} markdownlint-cli2: not installed`);
+        const typescriptAvailable = TypeScript.isAvailable();
+        if (typescriptAvailable) {
+            const compiler = TypeScript.detectCompiler();
+            yield* Effect.log(`  ${check_CHECK_MARK} TypeScript (${compiler})`);
+        } else yield* Effect.log(`  ${BULLET} TypeScript: not installed`);
+        const tsdocAvailable = TypeScript.isTsdocAvailable();
+        if (tsdocAvailable) yield* Effect.log(`  ${check_CHECK_MARK} TSDoc (tsdoc.json found)`);
+        else yield* Effect.log(`  ${BULLET} TSDoc: no tsdoc.json found`);
+        yield* Effect.log("");
+        const hasIssues = !foundConfig || !hasHuskyHook || !managedStatus.found || managedStatus.needsUpdate;
+        if (hasIssues) yield* Effect.log(`${check_WARNING} Some issues found. Run 'savvy-lint init' to fix.`);
+        else yield* Effect.log(`${check_CHECK_MARK} Lint-staged is configured correctly.`);
+    })).pipe(Command.withDescription("Check current lint-staged configuration and tool availability"));
+const rootCommand = Command.make("savvy-lint").pipe(Command.withSubcommands([
+    initCommand,
+    checkCommand
+]));
+const cli = Command.run(rootCommand, {
+    name: "savvy-lint",
+    version: "0.2.0"
+});
+function runCli() {
+    const main = Effect.suspend(()=>cli(process.argv)).pipe(Effect.provide(NodeContext.layer));
+    NodeRuntime.runMain(main);
+}
+export { Biome, Command_Command as Command, ConfigSearch, EntryExtractor, Filter, ImportGraph, Markdown, TsDocLinter, TsDocResolver, TypeScript, checkCommand, existsSync, initCommand, readFileSync, rootCommand, runCli, writeFileSync };