@savvy-web/lint-staged 0.6.6 → 0.7.1

package/878.js

@@ -1,1005 +1,88 @@
 import { Args, Command, Options } from "@effect/cli";
 import { NodeContext, NodeRuntime } from "@effect/platform-node";
-import { Effect } from "effect";
+import { BiomeSchemaSync, BiomeSchemaSyncLive, CheckResult, ConfigDiscovery, ConfigDiscoveryLive, ManagedSection, ManagedSectionLive, SectionDefinition, ShellSectionDefinition, SyncResult, ToolDefinition, ToolDiscovery, ToolDiscoveryLive } from "@savvy-web/silk-effects";
+import { Effect, Layer } from "effect";
+import { PackageManagerDetectorLive, WorkspaceRootLive } from "workspaces-effect";
 import { isDeepStrictEqual } from "node:util";
 import { FileSystem } from "@effect/platform";
 import { applyEdits, modify, parse } from "jsonc-effect";
-import { execSync } from "node:child_process";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, isAbsolute, join, normalize, relative, resolve } from "node:path";
-import { findProjectRoot, getWorkspaceInfos } from "workspace-tools";
-import { cosmiconfigSync, defaultLoaders } from "cosmiconfig";
-import parser from "@typescript-eslint/parser";
-import { ESLint } from "eslint";
-import eslint_plugin_tsdoc from "eslint-plugin-tsdoc";
-import typescript from "typescript";
 import sort_package_json from "sort-package-json";
 import { parse as external_yaml_parse, stringify } from "yaml";
+import { execSync } from "node:child_process";
+import { dirname, join, resolve } from "node:path";
 import { format, resolveConfig } from "prettier";
 import { lint } from "yaml-lint";
-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 cachedRoot = null;
-    static findRoot(cwd = process.cwd()) {
-        if (null !== Command_Command.cachedRoot) return Command_Command.cachedRoot;
-        try {
-            const root = findProjectRoot(cwd);
-            if (root) {
-                Command_Command.cachedRoot = root;
-                return root;
-            }
-        } catch  {}
-        Command_Command.cachedRoot = cwd;
-        return cwd;
-    }
-    static detectPackageManager(cwd = Command_Command.findRoot()) {
-        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 [
-                    "bun",
-                    "x",
-                    "--no-install"
-                ];
-            default:
-                return [
-                    "npx",
-                    "--no"
-                ];
-        }
-    }
-    static clearCache() {
-        Command_Command.cachedPackageManager = null;
-        Command_Command.cachedRoot = 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 findSavvyLint() {
-        const result = Command_Command.findTool("savvy-lint");
-        if (result.available && result.command) return result.command;
-        const root = Command_Command.findRoot();
-        return `node ${root}/dist/dev/bin/savvy-lint.js`;
-    }
-    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"
-        ]
-    },
-    yamllint: {
-        moduleName: "yaml-lint",
-        libConfigFiles: [
-            ".yaml-lint.json"
-        ],
-        standardPlaces: [
-            ".yaml-lint.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;
-    }
-    static shellEscape(filenames) {
-        return filenames.map((f)=>`'${f.replace(/'/g, "'\\''")}'`).join(" ");
-    }
-}
-class Biome {
-    static glob = "*.{js,ts,cjs,mjs,d.cts,d.mts,jsx,tsx,json,jsonc}";
-    static defaultExcludes = [
-        "package.json",
-        "package-lock.json",
-        "__fixtures__",
-        "__test__/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 = Filter.shellEscape(filtered);
-            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 = Filter.shellEscape(filtered);
-            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 cachedCompilerResult = null;
-    static detectCompiler(_cwd) {
-        if (null !== TypeScript.cachedCompilerResult) return TypeScript.cachedCompilerResult.compiler;
-        const tsgo = Command_Command.findTool("tsgo");
-        if (tsgo.available) {
-            TypeScript.cachedCompilerResult = {
-                compiler: "tsgo",
-                tool: tsgo
-            };
-            return "tsgo";
-        }
-        const tsc = Command_Command.findTool("tsc");
-        if (tsc.available) {
-            TypeScript.cachedCompilerResult = {
-                compiler: "tsc",
-                tool: tsc
-            };
-            return "tsc";
-        }
-    }
-    static isAvailable() {
-        return void 0 !== TypeScript.detectCompiler();
-    }
-    static getDefaultTypecheckCommand() {
-        const compiler = TypeScript.detectCompiler();
-        if (!compiler || !TypeScript.cachedCompilerResult) throw new Error("No TypeScript compiler found. Install 'typescript' or '@typescript/native-preview' as a dev dependency.");
-        return `${TypeScript.cachedCompilerResult.tool.command} --noEmit`;
-    }
-    static clearCache() {
-        TypeScript.cachedCompilerResult = null;
-    }
-    static handler = TypeScript.create();
-    static isTsdocAvailable(cwd = Command_Command.findRoot()) {
-        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 ?? Command_Command.findRoot();
-        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 SCHEMA_URL_PREFIX = "https://biomejs.dev/schemas/";
-const SCHEMA_URL_SUFFIX = "/schema.json";
-const BIOME_GLOB_PATTERN = "**/biome.{json,jsonc}";
-const BIOME_EXCLUDE_DIRS = [
-    "node_modules",
-    "dist",
-    ".turbo",
-    ".git",
-    ".rslib"
-];
-function extractSemver(versionRange) {
-    return versionRange.replace(/^[^\d]*/, "");
-}
-function buildSchemaUrl(version) {
-    return `${SCHEMA_URL_PREFIX}${version}${SCHEMA_URL_SUFFIX}`;
-}
-function getBiomePeerVersion() {
-    const raw = "catalog:silk";
-    if (!raw) return;
-    return extractSemver(raw);
+const HUSKY_HOOK_PATH = ".husky/pre-commit";
+const POST_CHECKOUT_HOOK_PATH = ".husky/post-checkout";
+const POST_MERGE_HOOK_PATH = ".husky/post-merge";
+const DEFAULT_CONFIG_PATH = "lib/configs/lint-staged.config.ts";
+const MARKDOWNLINT_CONFIG_PATH = "lib/configs/.markdownlint-cli2.jsonc";
+const SavvyLintSection = ShellSectionDefinition.make({
+    toolName: "SAVVY-LINT"
+});
+const SavvyLintSectionDef = SectionDefinition.make({
+    toolName: "SAVVY-LINT"
+});
+function generateManagedContent(configPath) {
+    return `# DO NOT EDIT between these markers - managed by savvy-lint
+# Skip in CI environment
+if ! { [ -n "$CI" ] || [ -n "$GITHUB_ACTIONS" ]; }; then
+
+# 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
 }
-function getExpectedSchemaUrl() {
-    const version = getBiomePeerVersion();
-    if (!version) return;
-    return buildSchemaUrl(version);
+
+# Run lint-staged with the detected package manager
+PM=$(detect_pm)
+case "$PM" in
+  pnpm) pnpm exec lint-staged --config "$ROOT/${configPath}" ;;
+  yarn) yarn exec lint-staged --config "$ROOT/${configPath}" ;;
+  bun)  bunx lint-staged --config "$ROOT/${configPath}" ;;
+  *)    npx --no -- lint-staged --config "$ROOT/${configPath}" ;;
+esac
+
+fi`;
 }
-function findBiomeConfigs() {
-    return Effect.tryPromise(async ()=>{
-        const { glob } = await import("node:fs/promises");
-        const paths = [];
-        for await (const entry of glob(BIOME_GLOB_PATTERN, {
-            exclude: (name)=>BIOME_EXCLUDE_DIRS.includes(name)
-        }))paths.push(entry);
-        return paths;
-    });
+function generateShellScriptsManagedContent() {
+    return `# DO NOT EDIT between these markers - managed by savvy-lint
+if ! { [ -n "$CI" ] || [ -n "$GITHUB_ACTIONS" ]; }; then
+
+# Configure git to ignore executable bit changes
+# This ensures hook scripts can be made executable locally without git tracking the change
+git config core.fileMode false
+
+# Ensure all shell scripts tracked by git are executable
+git ls-files -z '*.sh' | xargs -0 -r chmod +x 2>/dev/null || true
+
+fi`;
 }
+const preCommitBlock = SavvyLintSection.generate(generateManagedContent);
+const shellScriptsBlock = ()=>SavvyLintSection.block(generateShellScriptsManagedContent());
 const MARKDOWNLINT_TEMPLATE = {
-    $schema: "https://raw.githubusercontent.com/DavidAnson/markdownlint-cli2/v0.21.0/schema/markdownlint-cli2-config-schema.json",
+    $schema: "https://raw.githubusercontent.com/DavidAnson/markdownlint-cli2/v0.22.0/schema/markdownlint-cli2-config-schema.json",
     globs: [
         "**/*.{md,mdx}"
     ],
@@ -1101,7 +184,7 @@ const MARKDOWNLINT_TEMPLATE = {
         "changeset-dependency-table-format": false
     }
 };
-const MARKDOWNLINT_SCHEMA = "https://raw.githubusercontent.com/DavidAnson/markdownlint-cli2/v0.21.0/schema/markdownlint-cli2-config-schema.json";
+const MARKDOWNLINT_SCHEMA = "https://raw.githubusercontent.com/DavidAnson/markdownlint-cli2/v0.22.0/schema/markdownlint-cli2-config-schema.json";
 const MARKDOWNLINT_CONFIG = {
     default: true,
     MD001: true,
@@ -1184,263 +267,9 @@ const MARKDOWNLINT_CONFIG = {
     "changeset-dependency-table-format": false
 };
 const CHECK_MARK = "\u2713";
-const WARNING = "\u26A0";
-const EXECUTABLE_MODE = 493;
-const HUSKY_HOOK_PATH = ".husky/pre-commit";
-const POST_CHECKOUT_HOOK_PATH = ".husky/post-checkout";
-const POST_MERGE_HOOK_PATH = ".husky/post-merge";
-const DEFAULT_CONFIG_PATH = "lib/configs/lint-staged.config.ts";
-const MARKDOWNLINT_CONFIG_PATH = "lib/configs/.markdownlint-cli2.jsonc";
-const JSONC_FORMAT = {
-    tabSize: 1,
-    insertSpaces: false
-};
-const BEGIN_MARKER = "# --- BEGIN SAVVY-LINT MANAGED SECTION ---";
-const END_MARKER = "# --- END SAVVY-LINT MANAGED SECTION ---";
-function presetIncludesShellScripts(preset) {
-    return "minimal" !== preset;
-}
-function presetIncludesMarkdown(preset) {
-    return "minimal" !== preset;
-}
-function generateManagedContent(configPath) {
-    return `# DO NOT EDIT between these markers - managed by savvy-lint
-# Skip in CI environment
-if ! { [ -n "$CI" ] || [ -n "$GITHUB_ACTIONS" ]; }; then
-
-# 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
-}
-
-# Run lint-staged with the detected package manager
-PM=$(detect_pm)
-case "$PM" in
-  pnpm) pnpm exec lint-staged --config "$ROOT/${configPath}" ;;
-  yarn) yarn exec lint-staged --config "$ROOT/${configPath}" ;;
-  bun)  bunx lint-staged --config "$ROOT/${configPath}" ;;
-  *)    npx --no -- lint-staged --config "$ROOT/${configPath}" ;;
-esac
-
-fi`;
-}
-function generateShellScriptsManagedContent() {
-    return `# DO NOT EDIT between these markers - managed by savvy-lint
-if ! { [ -n "$CI" ] || [ -n "$GITHUB_ACTIONS" ]; }; then
-
-# Configure git to ignore executable bit changes
-# This ensures hook scripts can be made executable locally without git tracking the change
-git config core.fileMode false
-
-# Ensure all shell scripts tracked by git are executable
-git ls-files -z '*.sh' | xargs -0 -r chmod +x 2>/dev/null || true
-
-fi`;
-}
-function updateManagedSectionWithContent(existingContent, managedContent) {
-    const { beforeSection, afterSection, found } = extractManagedSection(existingContent);
-    const newManagedSection = `${BEGIN_MARKER}\n${managedContent}\n${END_MARKER}`;
-    if (found) return `${beforeSection}${newManagedSection}${afterSection}`;
-    const trimmedContent = existingContent.trimEnd();
-    return `${trimmedContent}\n\n${newManagedSection}\n`;
-}
-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 generateFullHookContentFromManaged(comment, managedContent) {
-    return `#!/usr/bin/env sh
-# ${comment}
-# Custom hooks can go above or below the managed section
-
-${BEGIN_MARKER}
-${managedContent}
-${END_MARKER}
-`;
-}
-function generateConfigContent(preset) {
-    return `/**
- * lint-staged configuration
- * Generated by savvy-lint init
- */
-import { Preset } from "@savvy-web/lint-staged";
-
-export default Preset.${preset}();
-`;
-}
-function writeMarkdownlintConfig(fs, preset, force) {
-    return Effect.gen(function*() {
-        const configExists = yield* fs.exists(MARKDOWNLINT_CONFIG_PATH);
-        const fullTemplate = JSON.stringify(MARKDOWNLINT_TEMPLATE, null, "\t");
-        if (!configExists) {
-            yield* fs.makeDirectory("lib/configs", {
-                recursive: true
-            });
-            yield* fs.writeFileString(MARKDOWNLINT_CONFIG_PATH, `${fullTemplate}\n`);
-            yield* Effect.log(`${CHECK_MARK} Created ${MARKDOWNLINT_CONFIG_PATH}`);
-            return;
-        }
-        if ("silk" !== preset) return void (yield* Effect.log(`${CHECK_MARK} ${MARKDOWNLINT_CONFIG_PATH}: exists (not managed by ${preset} preset)`));
-        if (force) {
-            yield* fs.writeFileString(MARKDOWNLINT_CONFIG_PATH, `${fullTemplate}\n`);
-            yield* Effect.log(`${CHECK_MARK} Replaced ${MARKDOWNLINT_CONFIG_PATH} (--force)`);
-            return;
-        }
-        const existingText = yield* fs.readFileString(MARKDOWNLINT_CONFIG_PATH);
-        const existingParsed = yield* parse(existingText);
-        let updatedText = existingText;
-        let schemaUpdated = false;
-        if (existingParsed.$schema !== MARKDOWNLINT_SCHEMA) {
-            const edits = yield* modify(updatedText, [
-                "$schema"
-            ], MARKDOWNLINT_SCHEMA, {
-                formattingOptions: JSONC_FORMAT
-            });
-            updatedText = yield* applyEdits(updatedText, edits);
-            schemaUpdated = true;
-        }
-        const existingConfig = existingParsed.config;
-        const configMatches = void 0 !== existingConfig && isDeepStrictEqual(existingConfig, MARKDOWNLINT_CONFIG);
-        if (!configMatches) {
-            yield* Effect.log(`${WARNING} ${MARKDOWNLINT_CONFIG_PATH}: config rules differ from template (use --force to overwrite)`);
-            if (schemaUpdated) {
-                yield* fs.writeFileString(MARKDOWNLINT_CONFIG_PATH, updatedText);
-                yield* Effect.log(`${CHECK_MARK} Updated $schema in ${MARKDOWNLINT_CONFIG_PATH}`);
-            }
-            return;
-        }
-        if (schemaUpdated) {
-            yield* fs.writeFileString(MARKDOWNLINT_CONFIG_PATH, updatedText);
-            yield* Effect.log(`${CHECK_MARK} Updated $schema in ${MARKDOWNLINT_CONFIG_PATH}`);
-        } else yield* Effect.log(`${CHECK_MARK} ${MARKDOWNLINT_CONFIG_PATH}: up-to-date`);
-    });
-}
-function syncBiomeSchemas(fs) {
-    return Effect.gen(function*() {
-        const expectedUrl = getExpectedSchemaUrl();
-        if (!expectedUrl) return;
-        const configs = yield* findBiomeConfigs();
-        for (const configPath of configs){
-            const content = yield* fs.readFileString(configPath);
-            const parsed = yield* parse(content);
-            if ("string" != typeof parsed.$schema) continue;
-            if (!parsed.$schema.startsWith(SCHEMA_URL_PREFIX)) continue;
-            if (parsed.$schema === expectedUrl) {
-                yield* Effect.log(`${CHECK_MARK} ${configPath}: biome $schema up-to-date`);
-                continue;
-            }
-            const edits = yield* modify(content, [
-                "$schema"
-            ], expectedUrl, {
-                formattingOptions: JSONC_FORMAT
-            });
-            const updated = yield* applyEdits(content, edits);
-            yield* fs.writeFileString(configPath, updated);
-            yield* Effect.log(`${CHECK_MARK} Updated $schema in ${configPath}`);
-        }
-    });
-}
-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",
-    "silk"
-]).pipe(Options.withAlias("p"), Options.withDescription("Preset to use: minimal, standard, or silk"), Options.withDefault("silk"));
-function makeExecutable(path) {
-    return Effect.tryPromise(()=>import("node:fs/promises").then((fs)=>fs.chmod(path, EXECUTABLE_MODE)));
-}
-function writeHook(fs, hookPath, managedContent, comment, force) {
-    return Effect.gen(function*() {
-        const hookExists = yield* fs.exists(hookPath);
-        if (hookExists && !force) {
-            const existingContent = yield* fs.readFileString(hookPath);
-            const { found } = extractManagedSection(existingContent);
-            const updatedContent = updateManagedSectionWithContent(existingContent, managedContent);
-            yield* fs.writeFileString(hookPath, updatedContent);
-            yield* makeExecutable(hookPath);
-            if (found) yield* Effect.log(`${CHECK_MARK} Updated managed section in ${hookPath}`);
-            else yield* Effect.log(`${CHECK_MARK} Added managed section to ${hookPath}`);
-        } else if (hookExists && force) {
-            yield* fs.writeFileString(hookPath, generateFullHookContentFromManaged(comment, managedContent));
-            yield* makeExecutable(hookPath);
-            yield* Effect.log(`${CHECK_MARK} Replaced ${hookPath} (--force)`);
-        } else {
-            yield* fs.makeDirectory(".husky", {
-                recursive: true
-            });
-            yield* fs.writeFileString(hookPath, generateFullHookContentFromManaged(comment, managedContent));
-            yield* makeExecutable(hookPath);
-            yield* Effect.log(`${CHECK_MARK} Created ${hookPath}`);
-        }
-    });
-}
-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");
-        yield* writeHook(fs, HUSKY_HOOK_PATH, generateManagedContent(config), "Pre-commit hook with savvy-lint managed section", force);
-        if (presetIncludesShellScripts(preset)) {
-            const shellContent = generateShellScriptsManagedContent();
-            yield* writeHook(fs, POST_CHECKOUT_HOOK_PATH, shellContent, "Post-checkout hook with savvy-lint managed section", force);
-            yield* writeHook(fs, POST_MERGE_HOOK_PATH, shellContent, "Post-merge hook with savvy-lint managed section", force);
-        }
-        if (presetIncludesMarkdown(preset)) yield* writeMarkdownlintConfig(fs, preset, force);
-        yield* syncBiomeSchemas(fs);
-        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 WARNING = "\u26A0";
 const BULLET = "\u2022";
-const check_HUSKY_HOOK_PATH = ".husky/pre-commit";
 const CONFIG_FILES = [
     "lint-staged.config.ts",
     "lint-staged.config.js",
@@ -1465,43 +294,68 @@ function findConfigFile(fs) {
         return null;
     });
 }
+function findConfig(discovery, names) {
+    return Effect.gen(function*() {
+        for (const name of names){
+            const result = yield* discovery.find(name);
+            if (result) return result.path;
+        }
+        return null;
+    });
+}
 function extractConfigPathFromManaged(managedContent) {
     const match = managedContent.match(/lint-staged --config "\$ROOT\/([^"]+)"/);
     return match ? match[1] : null;
 }
-function checkHookManagedSection(hookContent, expectedManagedContent) {
-    const { managedSection, found } = extractManagedSection(hookContent);
-    if (!found) return {
-        found: false,
-        isUpToDate: false,
-        needsUpdate: false
-    };
-    const expectedSection = `${BEGIN_MARKER}\n${expectedManagedContent}\n${END_MARKER}`;
-    const normalizedExisting = managedSection.trim().replace(/\s+/g, " ");
-    const normalizedExpected = expectedSection.trim().replace(/\s+/g, " ");
-    const isUpToDate = normalizedExisting === normalizedExpected;
-    return {
-        found: true,
-        isUpToDate,
-        needsUpdate: !isUpToDate
-    };
+function checkHookManagedSection(section, hookPath, block) {
+    return Effect.gen(function*() {
+        const result = yield* section.check(hookPath, block);
+        return CheckResult.$match(result, {
+            Found: ({ isUpToDate })=>({
+                    found: true,
+                    isUpToDate,
+                    needsUpdate: !isUpToDate
+                }),
+            NotFound: ()=>({
+                    found: false,
+                    isUpToDate: false,
+                    needsUpdate: false
+                })
+        });
+    });
 }
-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
-    };
+function checkManagedSectionStatus(section, hookPath) {
+    return Effect.gen(function*() {
+        const existing = yield* section.read(hookPath, SavvyLintSectionDef);
+        if (null === existing) return {
+            isUpToDate: false,
+            configPath: null,
+            needsUpdate: false,
+            found: false
+        };
+        const configPath = extractConfigPathFromManaged(existing.text);
+        if (!configPath) return {
+            isUpToDate: false,
+            configPath: null,
+            needsUpdate: true,
+            found: true
+        };
+        const result = yield* section.check(hookPath, preCommitBlock(configPath));
+        return CheckResult.$match(result, {
+            Found: ({ isUpToDate })=>({
+                    isUpToDate,
+                    configPath: configPath,
+                    needsUpdate: !isUpToDate,
+                    found: true
+                }),
+            NotFound: ()=>({
+                    isUpToDate: false,
+                    configPath: null,
+                    needsUpdate: false,
+                    found: false
+                })
+        });
+    });
 }
 function checkMarkdownlintConfig(content) {
     return Effect.gen(function*() {
@@ -1517,26 +371,27 @@ function checkMarkdownlintConfig(content) {
         };
     });
 }
-function checkBiomeSchemas(fs) {
+function checkBiomeSchemas() {
     return Effect.gen(function*() {
-        const expectedUrl = getExpectedSchemaUrl();
+        const version = "catalog:silk";
         const statuses = [];
-        if (!expectedUrl) return {
+        if (!version) return {
             statuses,
             warnings: []
         };
-        const configs = yield* findBiomeConfigs();
+        const syncer = yield* BiomeSchemaSync;
+        const result = yield* syncer.check(version);
         const warnings = [];
-        for (const configPath of configs){
-            const content = yield* fs.readFileString(configPath);
-            const parsed = yield* parse(content);
-            if ("string" != typeof parsed.$schema || !parsed.$schema.startsWith(SCHEMA_URL_PREFIX)) continue;
-            const matches = parsed.$schema === expectedUrl;
+        for (const configPath of result.current)statuses.push({
+            path: configPath,
+            matches: true
+        });
+        for (const configPath of result.updated){
             statuses.push({
                 path: configPath,
-                matches
+                matches: false
             });
-            if (!matches) warnings.push(`${check_WARNING}  ${configPath}: biome $schema is outdated.\n   Run 'savvy-lint init' to update it.`);
+            warnings.push(`${WARNING}  ${configPath}: biome $schema is outdated.\n   Run 'savvy-lint init' to update it.`);
         }
         return {
             statuses,
@@ -1549,9 +404,12 @@ const checkCommand = Command.make("check", {
     quiet: quietOption
 }, ({ quiet })=>Effect.gen(function*() {
         const fs = yield* FileSystem.FileSystem;
+        const section = yield* ManagedSection;
+        const td = yield* ToolDiscovery;
+        const discovery = yield* ConfigDiscovery;
         const warnings = [];
         const foundConfig = yield* findConfigFile(fs);
-        const hasHuskyHook = yield* fs.exists(check_HUSKY_HOOK_PATH);
+        const hasHuskyHook = yield* fs.exists(HUSKY_HOOK_PATH);
         let managedStatus = {
             isUpToDate: false,
             configPath: null,
@@ -1559,26 +417,11 @@ const checkCommand = Command.make("check", {
             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.`);
+            managedStatus = yield* checkManagedSectionStatus(section, HUSKY_HOOK_PATH);
+            if (managedStatus.found && managedStatus.needsUpdate) warnings.push(`${WARNING}  Your ${HUSKY_HOOK_PATH} managed section is outdated.\n   Run 'savvy-lint init' to update it (preserves your custom hooks).`);
+            else if (!managedStatus.found) warnings.push(`${WARNING}  Your ${HUSKY_HOOK_PATH} does not have a savvy-lint managed section.\n   Run 'savvy-lint init' to add it.`);
+        } else warnings.push(`${WARNING}  No husky pre-commit hook found.\n   Run 'savvy-lint init' to create it.`);
+        if (!foundConfig) warnings.push(`${WARNING}  No lint-staged config file found.\n   Run 'savvy-lint init' to create one.`);
         const shellHookPaths = [
             POST_CHECKOUT_HOOK_PATH,
             POST_MERGE_HOOK_PATH
@@ -1587,16 +430,20 @@ const checkCommand = Command.make("check", {
         for (const hookPath of shellHookPaths){
             const hookExists = yield* fs.exists(hookPath);
             if (hookExists) {
-                const hookContent = yield* fs.readFileString(hookPath);
-                const status = checkHookManagedSection(hookContent, generateShellScriptsManagedContent());
+                const status = yield* checkHookManagedSection(section, hookPath, shellScriptsBlock());
                 shellHookStatuses.push({
                     path: hookPath,
                     ...status
                 });
-                if (status.found && status.needsUpdate) warnings.push(`${check_WARNING}  Your ${hookPath} managed section is outdated.\n   Run 'savvy-lint init' to update it (preserves your custom hooks).`);
+                if (status.found && status.needsUpdate) warnings.push(`${WARNING}  Your ${hookPath} managed section is outdated.\n   Run 'savvy-lint init' to update it (preserves your custom hooks).`);
             }
         }
-        const biomeSchemaStatus = yield* checkBiomeSchemas(fs);
+        const biomeSchemaStatus = yield* checkBiomeSchemas().pipe(Effect.catchTag("BiomeSyncError", ()=>Effect.succeed({
+                statuses: [],
+                warnings: [
+                    `${WARNING}  Could not check biome $schema URLs.`
+                ]
+            })));
         warnings.push(...biomeSchemaStatus.warnings);
         const hasMarkdownlintConfig = yield* fs.exists(MARKDOWNLINT_CONFIG_PATH);
         let markdownlintStatus = {
@@ -1608,62 +455,220 @@ const checkCommand = Command.make("check", {
         if (hasMarkdownlintConfig) {
             const mdContent = yield* fs.readFileString(MARKDOWNLINT_CONFIG_PATH);
             markdownlintStatus = yield* checkMarkdownlintConfig(mdContent);
-            if (!markdownlintStatus.schemaMatches) warnings.push(`${check_WARNING}  ${MARKDOWNLINT_CONFIG_PATH}: $schema differs from template.\n   Run 'savvy-lint init' to update it.`);
-            if (!markdownlintStatus.configMatches) warnings.push(`${check_WARNING}  ${MARKDOWNLINT_CONFIG_PATH}: config rules differ from template.\n   Run 'savvy-lint init --force' to overwrite.`);
+            if (!markdownlintStatus.schemaMatches) warnings.push(`${WARNING}  ${MARKDOWNLINT_CONFIG_PATH}: $schema differs from template.\n   Run 'savvy-lint init' to update it.`);
+            if (!markdownlintStatus.configMatches) warnings.push(`${WARNING}  ${MARKDOWNLINT_CONFIG_PATH}: config rules differ from template.\n   Run 'savvy-lint init --force' to overwrite.`);
         }
         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}`);
+        if (foundConfig) yield* Effect.log(`${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}`);
+        if (hasHuskyHook) yield* Effect.log(`${CHECK_MARK} Husky hook: ${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)`);
+        if (hasHuskyHook) if (managedStatus.found) if (managedStatus.isUpToDate) yield* Effect.log(`${CHECK_MARK} Managed section: up-to-date`);
+        else yield* Effect.log(`${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)`);
-        for (const status of shellHookStatuses)if (status.found) if (status.isUpToDate) yield* Effect.log(`${check_CHECK_MARK} ${status.path}: up-to-date`);
-        else yield* Effect.log(`${check_WARNING} ${status.path}: outdated (run 'savvy-lint init' to update)`);
+        for (const status of shellHookStatuses)if (status.found) if (status.isUpToDate) yield* Effect.log(`${CHECK_MARK} ${status.path}: up-to-date`);
+        else yield* Effect.log(`${WARNING} ${status.path}: outdated (run 'savvy-lint init' to update)`);
         yield* Effect.log("\nTool availability:");
-        const biomeAvailable = Biome.isAvailable();
-        const biomeConfig = Biome.findConfig();
+        const biomeAvailable = yield* td.isAvailable(ToolDefinition.make({
+            name: "biome"
+        }));
+        const biomeConfig = yield* findConfig(discovery, [
+            "biome.jsonc",
+            "biome.json"
+        ]);
         if (biomeAvailable) {
             const configInfo = biomeConfig ? ` (config: ${biomeConfig})` : "";
-            yield* Effect.log(`  ${check_CHECK_MARK} Biome${configInfo}`);
+            yield* Effect.log(`  ${CHECK_MARK} Biome${configInfo}`);
         } else yield* Effect.log(`  ${BULLET} Biome: not installed`);
-        const markdownAvailable = Markdown.isAvailable();
-        const markdownConfig = Markdown.findConfig();
+        const markdownAvailable = yield* td.isAvailable(ToolDefinition.make({
+            name: "markdownlint-cli2"
+        }));
+        const markdownConfig = yield* findConfig(discovery, [
+            ".markdownlint-cli2.jsonc",
+            ".markdownlint-cli2.json",
+            ".markdownlint-cli2.yaml",
+            ".markdownlint-cli2.cjs",
+            ".markdownlint.jsonc",
+            ".markdownlint.json",
+            ".markdownlint.yaml"
+        ]);
         if (markdownAvailable) {
             const configInfo = markdownConfig ? ` (config: ${markdownConfig})` : "";
-            yield* Effect.log(`  ${check_CHECK_MARK} markdownlint-cli2${configInfo}`);
+            yield* Effect.log(`  ${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)`);
+        const tsgoAvailable = yield* td.isAvailable(ToolDefinition.make({
+            name: "tsgo"
+        }));
+        const tscAvailable = yield* td.isAvailable(ToolDefinition.make({
+            name: "tsc"
+        }));
+        if (tsgoAvailable) yield* Effect.log(`  ${CHECK_MARK} TypeScript (tsgo)`);
+        else if (tscAvailable) yield* Effect.log(`  ${CHECK_MARK} TypeScript (tsc)`);
+        else yield* Effect.log(`  ${BULLET} TypeScript: not installed`);
+        const tsdocConfig = yield* discovery.find("tsdoc.json");
+        if (tsdocConfig) yield* Effect.log(`  ${CHECK_MARK} TSDoc (tsdoc.json found)`);
         else yield* Effect.log(`  ${BULLET} TSDoc: no tsdoc.json found`);
-        if (hasMarkdownlintConfig) if (markdownlintStatus.isUpToDate) yield* Effect.log(`  ${check_CHECK_MARK} ${MARKDOWNLINT_CONFIG_PATH}: up-to-date`);
+        if (hasMarkdownlintConfig) if (markdownlintStatus.isUpToDate) yield* Effect.log(`  ${CHECK_MARK} ${MARKDOWNLINT_CONFIG_PATH}: up-to-date`);
         else {
             const issues = [];
             if (!markdownlintStatus.schemaMatches) issues.push("$schema");
             if (!markdownlintStatus.configMatches) issues.push("config");
-            yield* Effect.log(`  ${check_WARNING} ${MARKDOWNLINT_CONFIG_PATH}: ${issues.join(", ")} differ from template`);
+            yield* Effect.log(`  ${WARNING} ${MARKDOWNLINT_CONFIG_PATH}: ${issues.join(", ")} differ from template`);
         }
         else yield* Effect.log(`  ${BULLET} ${MARKDOWNLINT_CONFIG_PATH}: not found`);
-        for (const status of biomeSchemaStatus.statuses)if (status.matches) yield* Effect.log(`  ${check_CHECK_MARK} ${status.path}: biome $schema up-to-date`);
-        else yield* Effect.log(`  ${check_WARNING} ${status.path}: biome $schema outdated (run 'savvy-lint init' to update)`);
+        for (const status of biomeSchemaStatus.statuses)if (status.matches) yield* Effect.log(`  ${CHECK_MARK} ${status.path}: biome $schema up-to-date`);
+        else yield* Effect.log(`  ${WARNING} ${status.path}: biome $schema outdated (run 'savvy-lint init' to update)`);
         yield* Effect.log("");
         const hasShellHookIssues = shellHookStatuses.some((s)=>s.found && s.needsUpdate);
         const hasMarkdownlintIssues = hasMarkdownlintConfig && !markdownlintStatus.isUpToDate;
         const hasBiomeSchemaIssues = biomeSchemaStatus.statuses.some((s)=>!s.matches);
         const hasIssues = !foundConfig || !hasHuskyHook || !managedStatus.found || managedStatus.needsUpdate || hasShellHookIssues || hasMarkdownlintIssues || hasBiomeSchemaIssues;
-        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.`);
+        if (hasIssues) yield* Effect.log(`${WARNING} Some issues found. Run 'savvy-lint init' to fix.`);
+        else yield* Effect.log(`${CHECK_MARK} Lint-staged is configured correctly.`);
     })).pipe(Command.withDescription("Check current lint-staged configuration and tool availability"));
+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 cachedRoot = null;
+    static findRoot(cwd = process.cwd()) {
+        if (null !== Command_Command.cachedRoot) return Command_Command.cachedRoot;
+        let dir = resolve(cwd);
+        while(true){
+            if (existsSync(join(dir, "package.json"))) {
+                Command_Command.cachedRoot = dir;
+                return dir;
+            }
+            const parent = dirname(dir);
+            if (parent === dir) break;
+            dir = parent;
+        }
+        Command_Command.cachedRoot = cwd;
+        return cwd;
+    }
+    static detectPackageManager(cwd = Command_Command.findRoot()) {
+        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 [
+                    "bun",
+                    "x",
+                    "--no-install"
+                ];
+            default:
+                return [
+                    "npx",
+                    "--no"
+                ];
+        }
+    }
+    static clearCache() {
+        Command_Command.cachedPackageManager = null;
+        Command_Command.cachedRoot = 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 findSavvyLint() {
+        const result = Command_Command.findTool("savvy-lint");
+        if (result.available && result.command) return result.command;
+        const root = Command_Command.findRoot();
+        return `node ${root}/dist/dev/bin/savvy-lint.js`;
+    }
+    static exec(command) {
+        return execSync(command, {
+            encoding: "utf-8"
+        }).trim();
+    }
+    static execSilent(command) {
+        try {
+            execSync(command, {
+                stdio: "ignore"
+            });
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+}
 const DEFAULT_STRINGIFY_OPTIONS = {
     indent: 2,
     lineWidth: 0,
@@ -1725,6 +730,29 @@ class PnpmWorkspace {
         };
     }
 }
+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;
+    }
+    static shellEscape(filenames) {
+        return filenames.map((f)=>`'${f.replace(/'/g, "'\\''")}'`).join(" ");
+    }
+}
 class Yaml {
     static glob = "**/*.{yml,yaml}";
     static defaultExcludes = [
@@ -1734,8 +762,9 @@ class Yaml {
     ];
     static handler = Yaml.create();
     static findConfig() {
-        const result = ConfigSearch.find("yamllint");
-        return result.filepath;
+        const libPath = "lib/configs/.yaml-lint.json";
+        if (existsSync(libPath)) return libPath;
+        if (existsSync(".yaml-lint.json")) return ".yaml-lint.json";
     }
     static loadConfig(filepath) {
         try {
@@ -1834,6 +863,149 @@ const fmtCommand = Command.make("fmt").pipe(Command.withSubcommands([
     pnpmWorkspaceCommand,
     yamlCommand
 ]));
+const init_CHECK_MARK = "\u2713";
+const init_WARNING = "\u26A0";
+const EXECUTABLE_MODE = 493;
+const JSONC_FORMAT = {
+    tabSize: 1,
+    insertSpaces: false
+};
+function presetIncludesShellScripts(preset) {
+    return "minimal" !== preset;
+}
+function presetIncludesMarkdown(preset) {
+    return "minimal" !== preset;
+}
+function generateConfigContent(preset) {
+    return `/**
+ * lint-staged configuration
+ * Generated by savvy-lint init
+ */
+import { Preset } from "@savvy-web/lint-staged";
+
+export default Preset.${preset}();
+`;
+}
+function writeMarkdownlintConfig(fs, preset, force) {
+    return Effect.gen(function*() {
+        const configExists = yield* fs.exists(MARKDOWNLINT_CONFIG_PATH);
+        const fullTemplate = JSON.stringify(MARKDOWNLINT_TEMPLATE, null, "\t");
+        if (!configExists) {
+            yield* fs.makeDirectory("lib/configs", {
+                recursive: true
+            });
+            yield* fs.writeFileString(MARKDOWNLINT_CONFIG_PATH, `${fullTemplate}\n`);
+            yield* Effect.log(`${init_CHECK_MARK} Created ${MARKDOWNLINT_CONFIG_PATH}`);
+            return;
+        }
+        if ("silk" !== preset) return void (yield* Effect.log(`${init_CHECK_MARK} ${MARKDOWNLINT_CONFIG_PATH}: exists (not managed by ${preset} preset)`));
+        if (force) {
+            yield* fs.writeFileString(MARKDOWNLINT_CONFIG_PATH, `${fullTemplate}\n`);
+            yield* Effect.log(`${init_CHECK_MARK} Replaced ${MARKDOWNLINT_CONFIG_PATH} (--force)`);
+            return;
+        }
+        const existingText = yield* fs.readFileString(MARKDOWNLINT_CONFIG_PATH);
+        const existingParsed = yield* parse(existingText);
+        let updatedText = existingText;
+        let schemaUpdated = false;
+        if (existingParsed.$schema !== MARKDOWNLINT_SCHEMA) {
+            const edits = yield* modify(updatedText, [
+                "$schema"
+            ], MARKDOWNLINT_SCHEMA, {
+                formattingOptions: JSONC_FORMAT
+            });
+            updatedText = yield* applyEdits(updatedText, edits);
+            schemaUpdated = true;
+        }
+        const existingConfig = existingParsed.config;
+        const configMatches = void 0 !== existingConfig && isDeepStrictEqual(existingConfig, MARKDOWNLINT_CONFIG);
+        if (!configMatches) {
+            yield* Effect.log(`${init_WARNING} ${MARKDOWNLINT_CONFIG_PATH}: config rules differ from template (use --force to overwrite)`);
+            if (schemaUpdated) {
+                yield* fs.writeFileString(MARKDOWNLINT_CONFIG_PATH, updatedText);
+                yield* Effect.log(`${init_CHECK_MARK} Updated $schema in ${MARKDOWNLINT_CONFIG_PATH}`);
+            }
+            return;
+        }
+        if (schemaUpdated) {
+            yield* fs.writeFileString(MARKDOWNLINT_CONFIG_PATH, updatedText);
+            yield* Effect.log(`${init_CHECK_MARK} Updated $schema in ${MARKDOWNLINT_CONFIG_PATH}`);
+        } else yield* Effect.log(`${init_CHECK_MARK} ${MARKDOWNLINT_CONFIG_PATH}: up-to-date`);
+    });
+}
+function syncBiomeSchemas() {
+    return Effect.gen(function*() {
+        const version = "catalog:silk";
+        if (!version) return;
+        const syncer = yield* BiomeSchemaSync;
+        const result = yield* syncer.sync(version);
+        for (const configPath of result.current)yield* Effect.log(`${init_CHECK_MARK} ${configPath}: biome $schema up-to-date`);
+        for (const configPath of result.updated)yield* Effect.log(`${init_CHECK_MARK} Updated $schema in ${configPath}`);
+    });
+}
+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",
+    "silk"
+]).pipe(Options.withAlias("p"), Options.withDescription("Preset to use: minimal, standard, or silk"), Options.withDefault("silk"));
+function makeExecutable(path) {
+    return Effect.tryPromise(()=>import("node:fs/promises").then((fs)=>fs.chmod(path, EXECUTABLE_MODE)));
+}
+function writeHook(fs, section, hookPath, block, comment, force) {
+    return Effect.gen(function*() {
+        const hookExists = yield* fs.exists(hookPath);
+        const header = `#!/usr/bin/env sh\n# ${comment}\n# Custom hooks can go above or below the managed section\n`;
+        if (!hookExists || force) {
+            if (!hookExists) yield* fs.makeDirectory(".husky", {
+                recursive: true
+            });
+            yield* fs.writeFileString(hookPath, header);
+        }
+        const result = yield* section.sync(hookPath, block);
+        yield* makeExecutable(hookPath);
+        if (hookExists) if (force) yield* Effect.log(`${init_CHECK_MARK} Replaced ${hookPath} (--force)`);
+        else yield* SyncResult.$match(result, {
+            Created: ()=>Effect.log(`${init_CHECK_MARK} Added managed section to ${hookPath}`),
+            Updated: ()=>Effect.log(`${init_CHECK_MARK} Updated managed section in ${hookPath}`),
+            Unchanged: ()=>Effect.log(`${init_CHECK_MARK} ${hookPath}: up-to-date`)
+        });
+        else yield* Effect.log(`${init_CHECK_MARK} Created ${hookPath}`);
+    });
+}
+const initCommand = Command.make("init", {
+    force: forceOption,
+    config: configOption,
+    preset: presetOption
+}, ({ force, config, preset })=>Effect.gen(function*() {
+        const fs = yield* FileSystem.FileSystem;
+        const section = yield* ManagedSection;
+        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");
+        yield* writeHook(fs, section, HUSKY_HOOK_PATH, preCommitBlock(config), "Pre-commit hook with savvy-lint managed section", force);
+        if (presetIncludesShellScripts(preset)) {
+            const shellBlock = shellScriptsBlock();
+            yield* writeHook(fs, section, POST_CHECKOUT_HOOK_PATH, shellBlock, "Post-checkout hook with savvy-lint managed section", force);
+            yield* writeHook(fs, section, POST_MERGE_HOOK_PATH, shellBlock, "Post-merge hook with savvy-lint managed section", force);
+        }
+        if (presetIncludesMarkdown(preset)) yield* writeMarkdownlintConfig(fs, preset, force);
+        yield* syncBiomeSchemas().pipe(Effect.catchTag("BiomeSyncError", (e)=>Effect.log(`${init_WARNING} Could not sync biome $schema: ${e.message}`)));
+        const configExists = yield* fs.exists(config);
+        if (configExists && !force) yield* Effect.log(`${init_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(`${init_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 WorkspaceLive = Layer.mergeAll(PackageManagerDetectorLive, WorkspaceRootLive);
+const SilkLive = Layer.mergeAll(ManagedSectionLive, BiomeSchemaSyncLive, ConfigDiscoveryLive, ToolDiscoveryLive);
+const AppLayer = SilkLive.pipe(Layer.provideMerge(WorkspaceLive), Layer.provideMerge(NodeContext.layer));
 const rootCommand = Command.make("savvy-lint").pipe(Command.withSubcommands([
     initCommand,
     checkCommand,
@@ -1841,10 +1013,10 @@ const rootCommand = Command.make("savvy-lint").pipe(Command.withSubcommands([
 ]));
 const cli = Command.run(rootCommand, {
     name: "savvy-lint",
-    version: "0.6.6"
+    version: "0.7.1"
 });
 function runCli() {
-    const main = Effect.suspend(()=>cli(process.argv)).pipe(Effect.provide(NodeContext.layer));
+    const main = Effect.suspend(()=>cli(process.argv)).pipe(Effect.provide(AppLayer));
     NodeRuntime.runMain(main);
 }
-export { Biome, Command_Command as Command, ConfigSearch, EntryExtractor, Filter, ImportGraph, Markdown, PnpmWorkspace, TsDocLinter, TsDocResolver, TypeScript, Yaml, checkCommand, fmtCommand, initCommand, rootCommand, runCli };
+export { Command_Command as Command, Filter, PnpmWorkspace, Yaml, checkCommand, fmtCommand, initCommand, rootCommand, runCli };