@savvy-web/lint-staged 0.1.3 → 0.2.0

package/index.js

@@ -1,377 +1,5 @@
-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 sort_package_json from "sort-package-json";
 import { parse, stringify } from "yaml";
-import parser from "@typescript-eslint/parser";
-import { ESLint } from "eslint";
-import eslint_plugin_tsdoc from "eslint-plugin-tsdoc";
-import { getWorkspaces } 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 {
-    static cachedPackageManager = null;
-    static detectPackageManager(cwd = process.cwd()) {
-        if (null !== Command.cachedPackageManager) return Command.cachedPackageManager;
-        const packageJsonPath = join(cwd, "package.json");
-        if (!existsSync(packageJsonPath)) {
-            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.cachedPackageManager = match[1];
-                    return Command.cachedPackageManager;
-                }
-            }
-        } catch  {}
-        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.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.isAvailable(tool)) return {
-            available: true,
-            command: tool,
-            source: "global"
-        };
-        const pm = Command.detectPackageManager();
-        const prefix = 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.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,
-                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.findTool("biome");
-        return result.command;
-    }
-    static isAvailable() {
-        return 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.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 DesignDocs {
-    static glob = ".claude/design/**/*.md";
-    static defaultExcludes = [
-        "design.config.json"
-    ];
-    static defaultValidateScript = ".claude/skills/design-validate/scripts/validate-design-doc.sh";
-    static defaultTimestampScript = ".claude/skills/design-update/scripts/update-timestamp.sh";
-    static handler = DesignDocs.create();
-    static create(options = {}) {
-        const excludes = options.exclude ?? [
-            ...DesignDocs.defaultExcludes
-        ];
-        const validateScript = options.validateScript ?? DesignDocs.defaultValidateScript;
-        const timestampScript = options.timestampScript ?? DesignDocs.defaultTimestampScript;
-        const skipTimestamp = options.skipTimestamp ?? false;
-        return (filenames)=>{
-            const filtered = Filter.exclude(filenames, excludes);
-            if (0 === filtered.length) return [];
-            const commands = [];
-            for (const file of filtered){
-                commands.push(`${validateScript} "${file}"`);
-                if (!skipTimestamp) commands.push(`${timestampScript} "${file}"`);
-            }
-            return commands;
-        };
-    }
-}
-class Markdown {
-    static glob = "**/*.{md,mdx}";
-    static defaultExcludes = [];
-    static handler = Markdown.create();
-    static findMarkdownlint() {
-        const result = Command.findTool("markdownlint-cli2");
-        return result.command;
-    }
-    static isAvailable() {
-        return 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.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;
-        };
-    }
-}
+import { Biome, Command as Command_Command, readFileSync, existsSync, TypeScript, writeFileSync, Markdown, Filter } from "./376.js";
 class PackageJson {
     static glob = "**/package.json";
     static defaultExcludes = [
@@ -387,14 +15,21 @@ class PackageJson {
         return (filenames)=>{
             const filtered = Filter.exclude(filenames, excludes);
             if (0 === filtered.length) return [];
-            if (!skipSort) for (const filepath of filtered){
-                const content = readFileSync(filepath, "utf-8");
-                const sorted = sort_package_json(content);
-                writeFileSync(filepath, sorted, "utf-8");
-            }
             const files = filtered.join(" ");
+            const commands = [];
+            if (!skipSort) {
+                const pm = Command_Command.detectPackageManager();
+                const prefix = Command_Command.getExecPrefix(pm);
+                const sortCmd = [
+                    ...prefix,
+                    "sort-package-json",
+                    files
+                ].join(" ");
+                commands.push(sortCmd);
+            }
             const biomeCmd = options.biomeConfig ? `biome check --write --max-diagnostics=none --config-path=${options.biomeConfig} ${files}` : `biome check --write --max-diagnostics=none ${files}`;
-            return biomeCmd;
+            commands.push(biomeCmd);
+            return commands.join(" && ");
         };
     }
 }
@@ -407,6 +42,11 @@ class PnpmWorkspace {
     static glob = "pnpm-workspace.yaml";
     static defaultExcludes = [];
     static handler = PnpmWorkspace.create();
+    static SORTABLE_ARRAY_KEYS = new Set([
+        "packages",
+        "onlyBuiltDependencies",
+        "publicHoistPattern"
+    ]);
     static sortContent(content) {
         const result = {};
         const keys = Object.keys(content).sort((a, b)=>{
@@ -416,13 +56,7 @@ class PnpmWorkspace {
         });
         for (const key of keys){
             const value = content[key];
-            if ("packages" === key && Array.isArray(value)) result[key] = [
-                ...value
-            ].sort();
-            else if ("onlyBuiltDependencies" === key && Array.isArray(value)) result[key] = [
-                ...value
-            ].sort();
-            else if ("publicHoistPattern" === key && Array.isArray(value)) result[key] = [
+            if (PnpmWorkspace.SORTABLE_ARRAY_KEYS.has(key) && Array.isArray(value)) result[key] = [
                 ...value
             ].sort();
             else result[key] = value;
@@ -448,6 +82,7 @@ class PnpmWorkspace {
             if (!skipSort || !skipFormat) {
                 const formatted = stringify(parsed, DEFAULT_STRINGIFY_OPTIONS);
                 writeFileSync(filepath, formatted, "utf-8");
+                return `git add ${filepath}`;
             }
             return [];
         };
@@ -472,578 +107,6 @@ class ShellScripts {
         };
     }
 }
-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;
-        let workspaceInfos;
-        let isMonorepo = false;
-        try {
-            workspaceInfos = getWorkspaces(rootDir);
-            isMonorepo = workspaceInfos.length > 1;
-        } catch  {
-            workspaceInfos = [];
-        }
-        if (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);
-        }
-        return {
-            workspaces,
-            isMonorepo,
-            repoTsdocConfig
-        };
-    }
-    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 graph = new ImportGraph({
-            rootDir: workspacePath,
-            excludePatterns: this.options.excludePatterns
-        });
-        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.detectPackageManager();
-        const prefix = 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 Yaml_DEFAULT_STRINGIFY_OPTIONS = {
     indent: 2,
     lineWidth: 0,
@@ -1084,6 +147,7 @@ class Yaml {
             } catch (error) {
                 throw new Error(`Invalid YAML in ${filepath}: ${error instanceof Error ? error.message : String(error)}`);
             }
+            if (!skipFormat && filtered.length > 0) return `git add ${filtered.join(" ")}`;
             return [];
         };
     }
@@ -1118,52 +182,48 @@ function createConfig(options = {}) {
         const handlerOptions = "object" == typeof options.typescript ? options.typescript : {};
         config[TypeScript.glob] = TypeScript.create(handlerOptions);
     }
-    if (true === options.designDocs || "object" == typeof options.designDocs) {
-        const handlerOptions = "object" == typeof options.designDocs ? options.designDocs : {};
-        config[DesignDocs.glob] = DesignDocs.create(handlerOptions);
-    }
     if (options.custom) for (const [glob, handler] of Object.entries(options.custom))config[glob] = handler;
     return config;
 }
 class Preset {
     static minimal(extend = {}) {
-        return createConfig({
+        const options = {
             packageJson: extend.packageJson ?? {},
             biome: extend.biome ?? {},
             markdown: extend.markdown ?? false,
             yaml: extend.yaml ?? false,
             pnpmWorkspace: extend.pnpmWorkspace ?? false,
             shellScripts: extend.shellScripts ?? false,
-            typescript: extend.typescript ?? false,
-            designDocs: extend.designDocs ?? false,
-            custom: extend.custom
-        });
+            typescript: extend.typescript ?? false
+        };
+        if (void 0 !== extend.custom) options.custom = extend.custom;
+        return createConfig(options);
     }
     static standard(extend = {}) {
-        return createConfig({
+        const options = {
             packageJson: extend.packageJson ?? {},
             biome: extend.biome ?? {},
             markdown: extend.markdown ?? {},
             yaml: extend.yaml ?? {},
             pnpmWorkspace: extend.pnpmWorkspace ?? {},
             shellScripts: extend.shellScripts ?? {},
-            typescript: extend.typescript ?? false,
-            designDocs: extend.designDocs ?? false,
-            custom: extend.custom
-        });
+            typescript: extend.typescript ?? false
+        };
+        if (void 0 !== extend.custom) options.custom = extend.custom;
+        return createConfig(options);
     }
     static full(extend = {}) {
-        return createConfig({
+        const options = {
             packageJson: extend.packageJson ?? {},
             biome: extend.biome ?? {},
             markdown: extend.markdown ?? {},
             yaml: extend.yaml ?? {},
             pnpmWorkspace: extend.pnpmWorkspace ?? {},
             shellScripts: extend.shellScripts ?? {},
-            typescript: extend.typescript ?? {},
-            designDocs: extend.designDocs ?? true,
-            custom: extend.custom
-        });
+            typescript: extend.typescript ?? {}
+        };
+        if (void 0 !== extend.custom) options.custom = extend.custom;
+        return createConfig(options);
     }
     static get(name, extend = {}) {
         switch(name){
@@ -1184,4 +244,5 @@ class Handler {
         throw new Error("Handler.create() must be implemented by subclass");
     }
 }
-export { Biome, Command, ConfigSearch, DesignDocs, EntryExtractor, Filter, Handler, ImportGraph, Markdown, PackageJson, PnpmWorkspace, Preset, ShellScripts, TsDocLinter, TsDocResolver, TypeScript, Yaml, createConfig };
+export { Biome, Command, ConfigSearch, EntryExtractor, Filter, ImportGraph, Markdown, TsDocLinter, TsDocResolver, TypeScript, checkCommand, initCommand, rootCommand, runCli } from "./376.js";
+export { Handler, PackageJson, PnpmWorkspace, Preset, ShellScripts, Yaml, createConfig };