@savvy-web/lint-staged 0.3.2 → 0.4.0

package/376.js

@@ -1,4 +1,4 @@
-import { Command, Options } from "@effect/cli";
+import { Args, Command, Options } from "@effect/cli";
 import { NodeContext, NodeRuntime } from "@effect/platform-node";
 import { Effect } from "effect";
 import { isDeepStrictEqual } from "node:util";
@@ -7,19 +7,36 @@ import { applyEdits, modify, parse } from "jsonc-parser";
 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 { getWorkspaceInfos } from "workspace-tools";
 import typescript from "typescript";
+import sort_package_json from "sort-package-json";
+import { parse as external_yaml_parse, stringify } from "yaml";
+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 detectPackageManager(cwd = process.cwd()) {
+    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)) {
@@ -54,7 +71,9 @@ class Command_Command {
                 ];
             case "bun":
                 return [
-                    "bunx"
+                    "bun",
+                    "x",
+                    "--no-install"
                 ];
             default:
                 return [
@@ -65,6 +84,7 @@ class Command_Command {
     }
     static clearCache() {
         Command_Command.cachedPackageManager = null;
+        Command_Command.cachedRoot = null;
     }
     static isAvailable(command) {
         validateCommandName(command);
@@ -111,6 +131,12 @@ class Command_Command {
         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"
@@ -190,6 +216,15 @@ const TOOL_CONFIGS = {
             "prettier.config.js",
             "package.json"
         ]
+    },
+    yamllint: {
+        moduleName: "yaml-lint",
+        libConfigFiles: [
+            ".yaml-lint.json"
+        ],
+        standardPlaces: [
+            ".yaml-lint.json"
+        ]
     }
 };
 class ConfigSearch {
@@ -846,36 +881,39 @@ class TypeScript {
         "__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
+    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
             };
-            if ("@typescript/native-preview" in allDeps) return "tsgo";
-            if ("typescript" in allDeps) return "tsc";
-        } catch  {}
+            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) throw new Error("No TypeScript compiler found. Install 'typescript' or '@typescript/native-preview' as a dev dependency.");
-        const pm = Command_Command.detectPackageManager();
-        const prefix = Command_Command.getExecPrefix(pm);
-        return [
-            ...prefix,
-            compiler,
-            "--noEmit"
-        ].join(" ");
+        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 = process.cwd()) {
+    static isTsdocAvailable(cwd = Command_Command.findRoot()) {
         const tsdocPath = join(cwd, "tsdoc.json");
         return existsSync(tsdocPath);
     }
@@ -888,7 +926,7 @@ class TypeScript {
         ];
         const skipTsdoc = options.skipTsdoc ?? false;
         const skipTypecheck = options.skipTypecheck ?? false;
-        const rootDir = options.rootDir ?? process.cwd();
+        const rootDir = options.rootDir ?? Command_Command.findRoot();
         let typecheckCommand;
         const getTypecheckCommand = ()=>{
             if (void 0 === typecheckCommand) typecheckCommand = options.typecheckCommand ?? TypeScript.getDefaultTypecheckCommand();
@@ -1515,16 +1553,186 @@ const checkCommand = Command.make("check", {
         if (hasIssues) yield* Effect.log(`${check_WARNING} Some issues found. Run 'savvy-lint init' to fix.`);
         else yield* Effect.log(`${check_CHECK_MARK} Lint-staged is configured correctly.`);
     })).pipe(Command.withDescription("Check current lint-staged configuration and tool availability"));
+const DEFAULT_STRINGIFY_OPTIONS = {
+    indent: 2,
+    lineWidth: 0,
+    singleQuote: false
+};
+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)=>{
+            if ("packages" === a) return -1;
+            if ("packages" === b) return 1;
+            return a.localeCompare(b);
+        });
+        for (const key of keys){
+            const value = content[key];
+            if (PnpmWorkspace.SORTABLE_ARRAY_KEYS.has(key) && Array.isArray(value)) result[key] = [
+                ...value
+            ].sort();
+            else result[key] = value;
+        }
+        return result;
+    }
+    static fmtCommand() {
+        return ()=>{
+            if (!existsSync("pnpm-workspace.yaml")) return [];
+            const cmd = Command_Command.findSavvyLint();
+            return `${cmd} fmt pnpm-workspace`;
+        };
+    }
+    static create(options = {}) {
+        const skipSort = options.skipSort ?? false;
+        const skipFormat = options.skipFormat ?? false;
+        const skipLint = options.skipLint ?? false;
+        return ()=>{
+            const filepath = "pnpm-workspace.yaml";
+            if (!existsSync(filepath)) return [];
+            const content = readFileSync(filepath, "utf-8");
+            let parsed;
+            try {
+                parsed = external_yaml_parse(content);
+            } catch (error) {
+                if (!skipLint) throw new Error(`Invalid YAML in ${filepath}: ${error instanceof Error ? error.message : String(error)}`);
+                return [];
+            }
+            if (!skipSort) parsed = PnpmWorkspace.sortContent(parsed);
+            if (!skipSort || !skipFormat) {
+                const formatted = stringify(parsed, DEFAULT_STRINGIFY_OPTIONS);
+                writeFileSync(filepath, formatted, "utf-8");
+            }
+            return [];
+        };
+    }
+}
+class Yaml {
+    static glob = "**/*.{yml,yaml}";
+    static defaultExcludes = [
+        "pnpm-lock.yaml",
+        "pnpm-workspace.yaml"
+    ];
+    static handler = Yaml.create();
+    static findConfig() {
+        const result = ConfigSearch.find("yamllint");
+        return result.filepath;
+    }
+    static loadConfig(filepath) {
+        try {
+            const content = readFileSync(filepath, "utf-8");
+            const config = JSON.parse(content);
+            return config.schema;
+        } catch  {
+            return;
+        }
+    }
+    static isAvailable() {
+        return true;
+    }
+    static async formatFile(filepath) {
+        const content = readFileSync(filepath, "utf-8");
+        const prettierConfig = await resolveConfig(filepath);
+        const formatted = await format(content, {
+            ...prettierConfig,
+            filepath,
+            parser: "yaml"
+        });
+        writeFileSync(filepath, formatted, "utf-8");
+    }
+    static async validateFile(filepath, schema) {
+        const content = readFileSync(filepath, "utf-8");
+        await lint(content, schema ? {
+            schema: schema
+        } : void 0);
+    }
+    static fmtCommand(options = {}) {
+        const excludes = options.exclude ?? [
+            ...Yaml.defaultExcludes
+        ];
+        return (filenames)=>{
+            const filtered = Filter.exclude(filenames, excludes);
+            if (0 === filtered.length) return [];
+            const cmd = Command_Command.findSavvyLint();
+            return `${cmd} fmt yaml ${Filter.shellEscape(filtered)}`;
+        };
+    }
+    static create(options = {}) {
+        const excludes = options.exclude ?? [
+            ...Yaml.defaultExcludes
+        ];
+        const skipFormat = options.skipFormat ?? false;
+        const skipValidate = options.skipValidate ?? false;
+        const configPath = options.config ?? Yaml.findConfig();
+        const schema = configPath ? Yaml.loadConfig(configPath) : void 0;
+        return async (filenames)=>{
+            const filtered = Filter.exclude(filenames, excludes);
+            if (0 === filtered.length) return [];
+            if (!skipFormat) for (const filepath of filtered)await Yaml.formatFile(filepath);
+            if (!skipValidate) for (const filepath of filtered)try {
+                await Yaml.validateFile(filepath, schema);
+            } catch (error) {
+                throw new Error(`Invalid YAML in ${filepath}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return [];
+        };
+    }
+}
+const YAML_STRINGIFY_OPTIONS = {
+    indent: 2,
+    lineWidth: 0,
+    singleQuote: false
+};
+const filesArg = Args.repeated(Args.file({
+    name: "files",
+    exists: "yes"
+}));
+const packageJsonCommand = Command.make("package-json", {
+    files: filesArg
+}, ({ files })=>Effect.sync(()=>{
+        for (const filepath of files){
+            const content = readFileSync(filepath, "utf-8");
+            const sorted = sort_package_json(content);
+            if (sorted !== content) writeFileSync(filepath, sorted, "utf-8");
+        }
+    }));
+const pnpmWorkspaceCommand = Command.make("pnpm-workspace", {}, ()=>Effect.sync(()=>{
+        const filepath = "pnpm-workspace.yaml";
+        if (!existsSync(filepath)) return;
+        const content = readFileSync(filepath, "utf-8");
+        const parsed = external_yaml_parse(content);
+        const sorted = PnpmWorkspace.sortContent(parsed);
+        const formatted = stringify(sorted, YAML_STRINGIFY_OPTIONS);
+        writeFileSync(filepath, formatted, "utf-8");
+    }));
+const yamlCommand = Command.make("yaml", {
+    files: filesArg
+}, ({ files })=>Effect.gen(function*() {
+        for (const filepath of files)yield* Effect.promise(()=>Yaml.formatFile(filepath));
+    }));
+const fmtCommand = Command.make("fmt").pipe(Command.withSubcommands([
+    packageJsonCommand,
+    pnpmWorkspaceCommand,
+    yamlCommand
+]));
 const rootCommand = Command.make("savvy-lint").pipe(Command.withSubcommands([
     initCommand,
-    checkCommand
+    checkCommand,
+    fmtCommand
 ]));
 const cli = Command.run(rootCommand, {
     name: "savvy-lint",
-    version: "0.3.2"
+    version: "0.4.0"
 });
 function runCli() {
     const main = Effect.suspend(()=>cli(process.argv)).pipe(Effect.provide(NodeContext.layer));
     NodeRuntime.runMain(main);
 }
-export { Biome, Command_Command as Command, ConfigSearch, EntryExtractor, Filter, ImportGraph, Markdown, TsDocLinter, TsDocResolver, TypeScript, checkCommand, existsSync, initCommand, readFileSync, rootCommand, runCli, writeFileSync };
+export { Biome, Command_Command as Command, ConfigSearch, EntryExtractor, Filter, ImportGraph, Markdown, PnpmWorkspace, TsDocLinter, TsDocResolver, TypeScript, Yaml, checkCommand, fmtCommand, initCommand, readFileSync, rootCommand, runCli, sort_package_json, writeFileSync };

package/README.md

@@ -76,27 +76,30 @@ export default {
 | `PackageJson` | `**/package.json` | Sort and format with Biome |
 | `Biome` | `*.{js,ts,jsx,tsx,json,jsonc}` | Format and lint |
 | `Markdown` | `**/*.{md,mdx}` | Lint with markdownlint-cli2 |
-| `Yaml` | `**/*.{yml,yaml}` | Format and validate |
+| `Yaml` | `**/*.{yml,yaml}` | Format (Prettier) and validate (yaml-lint) |
 | `PnpmWorkspace` | `pnpm-workspace.yaml` | Sort and format |
 | `ShellScripts` | `**/*.sh` | Manage permissions |
 | `TypeScript` | `*.{ts,cts,mts,tsx}` | TSDoc validation + typecheck |
 
 ## CLI
 
-The `savvy-lint` CLI helps bootstrap and validate your setup:
+The `savvy-lint` CLI helps bootstrap, validate, and format your setup:
 
 ```bash
 savvy-lint init              # Bootstrap hooks, config, and tooling
 savvy-lint init --preset silk --force  # Overwrite with silk preset
 savvy-lint check             # Validate current configuration
 savvy-lint check --quiet     # Warnings only (for postinstall)
+savvy-lint fmt package-json  # Sort package.json fields
+savvy-lint fmt yaml          # Format YAML files with Prettier
+savvy-lint fmt pnpm-workspace  # Sort and format pnpm-workspace.yaml
 ```
 
 ## Documentation
 
 - [Handler Configuration](./docs/handlers.md) -- Detailed options for each handler
 - [Configuration API](./docs/configuration.md) -- createConfig and Preset APIs
-- [CLI Reference](./docs/cli.md) -- `savvy-lint init` and `savvy-lint check`
+- [CLI Reference](./docs/cli.md) -- `savvy-lint init`, `check`, and `fmt`
 - [Utilities](./docs/utilities.md) -- Command, Filter, and advanced utilities
 - [Migration Guide](./docs/migration.md) -- Migrating from raw lint-staged configs
 

package/index.d.ts

@@ -24,7 +24,6 @@ import { FileSystem } from '@effect/platform';
 import { FileSystem as FileSystem_2 } from '@effect/platform/FileSystem';
 import { Option } from 'effect/Option';
 import { PlatformError } from '@effect/platform/Error';
-import { stringify } from 'yaml';
 
 /**
  * Base options shared by all handlers.
@@ -154,13 +153,37 @@ export declare const checkCommand: Command_2.Command<"check", FileSystem.FileSys
 export declare class Command {
     /** Cached package manager detection result */
     private static cachedPackageManager;
+    /** Cached project root path */
+    private static cachedRoot;
+    /**
+     * Find the project root directory using workspace-tools.
+     *
+     * Uses `findProjectRoot()` from `workspace-tools` to locate the nearest
+     * directory containing a `package.json`. Falls back to the provided `cwd`
+     * (or `process.cwd()`) on error.
+     *
+     * @remarks
+     * This is more reliable than `process.cwd()` in environments like Husky
+     * hooks where the working directory may point to `.husky/` or another
+     * subdirectory.
+     *
+     * @param cwd - Starting directory for the search (defaults to `process.cwd()`)
+     * @returns The resolved project root path
+     *
+     * @example
+     * ```typescript
+     * const root = Command.findRoot();
+     * console.log(root); // '/Users/me/my-project'
+     * ```
+     */
+    static findRoot(cwd?: string): string;
     /**
      * Detect the package manager from the root package.json's `packageManager` field.
      *
      * Parses the `packageManager` field (e.g., `pnpm\@9.0.0`) and extracts the manager name.
      * Falls back to "npm" if no packageManager field is found.
      *
-     * @param cwd - Directory to search for package.json (defaults to process.cwd())
+     * @param cwd - Directory to search for package.json (defaults to `Command.findRoot()`)
      * @returns The detected package manager
      *
      * @example
@@ -181,12 +204,12 @@ export declare class Command {
      * Command.getExecPrefix('pnpm'); // ['pnpm', 'exec']
      * Command.getExecPrefix('npm');  // ['npx', '--no']
      * Command.getExecPrefix('yarn'); // ['yarn', 'exec']
-     * Command.getExecPrefix('bun');  // ['bunx']
+     * Command.getExecPrefix('bun');  // ['bun', 'x', "--no-install"]
      * ```
      */
     static getExecPrefix(packageManager: PackageManager): string[];
     /**
-     * Clear the cached package manager detection.
+     * Clear the cached package manager and project root detection.
      * Useful for testing or when package.json changes.
      */
     static clearCache(): void;
@@ -239,6 +262,17 @@ export declare class Command {
      * ```
      */
     static requireTool(tool: string, errorMessage?: string): string;
+    /**
+     * Find the savvy-lint CLI command.
+     *
+     * @remarks
+     * Searches for the `savvy-lint` binary via the standard tool search,
+     * then falls back to the dev build at `dist/dev/bin/savvy-lint.js`
+     * for dogfooding scenarios where the package's own bin isn't linked.
+     *
+     * @returns The command string to invoke savvy-lint
+     */
+    static findSavvyLint(): string;
     /**
      * Execute a command and return its output.
      *
@@ -294,7 +328,7 @@ export declare class ConfigSearch {
     /**
      * Find a configuration file for a known tool.
      *
-     * Supported tools: 'markdownlint', 'biome', 'eslint', 'prettier'
+     * Supported tools: 'markdownlint', 'biome', 'eslint', 'prettier', 'yamllint'
      *
      * @param tool - The tool name
      * @param options - Search options
@@ -308,7 +342,7 @@ export declare class ConfigSearch {
      * }
      * ```
      */
-    static find(tool: "markdownlint" | "biome" | "eslint" | "prettier", options?: ConfigSearchOptions): ConfigSearchResult;
+    static find(tool: "markdownlint" | "biome" | "eslint" | "prettier" | "yamllint", options?: ConfigSearchOptions): ConfigSearchResult;
     /**
      * Find a configuration file with custom search locations.
      *
@@ -613,6 +647,15 @@ export declare class Filter {
     static shellEscape(filenames: readonly string[]): string;
 }
 
+/** Parent fmt command with formatting subcommands. */
+export declare const fmtCommand: Command_2.Command<"fmt", never, never, {
+    readonly subcommand: Option<    {
+    readonly files: string[];
+    } | {} | {
+    readonly files: string[];
+    }>;
+}>;
+
 /**
  * Abstract base class for lint-staged handlers.
  *
@@ -813,9 +856,18 @@ export declare const initCommand: Command_2.Command<"init", FileSystem.FileSyste
 
 /**
  * A lint-staged configuration object.
- * Maps glob patterns to handlers.
+ * Maps glob patterns to handlers, commands, or arrays of sequential steps.
+ *
+ * @remarks
+ * When a value is an array of functions/strings, lint-staged runs each element
+ * sequentially with proper staging between steps.
  */
-export declare type LintStagedConfig = Record<string, LintStagedHandler | string | string[]>;
+export declare type LintStagedConfig = Record<string, LintStagedEntry | LintStagedEntry[]>;
+
+/**
+ * A single lint-staged command entry: a handler function, a string command, or an array of strings.
+ */
+export declare type LintStagedEntry = LintStagedHandler | string | string[];
 
 /**
  * A lint-staged handler function.
@@ -961,6 +1013,25 @@ export declare class PackageJson {
      * Pre-configured handler with default options.
      */
     static readonly handler: LintStagedHandler;
+    /**
+     * Create a handler with custom options.
+     *
+     * @param options - Configuration options
+     * @returns A lint-staged compatible handler function
+     */
+    /**
+     * Create a handler that returns a CLI command to sort package.json files.
+     *
+     * @remarks
+     * Unlike {@link create}, this does not modify files in the handler function
+     * body. Instead it returns a `savvy-lint fmt package-json` command so
+     * lint-staged can detect the modification and auto-stage it.
+     * Use this in lint-staged array syntax for sequential execution.
+     *
+     * @param options - Configuration options
+     * @returns A lint-staged compatible handler function
+     */
+    static fmtCommand(options?: PackageJsonOptions): LintStagedHandler;
     /**
      * Create a handler with custom options.
      *
@@ -979,6 +1050,11 @@ export declare interface PackageJsonOptions extends BaseHandlerOptions {
      * @defaultValue false
      */
     skipSort?: boolean;
+    /**
+     * Skip Biome formatting (sort only).
+     * @defaultValue false
+     */
+    skipFormat?: boolean;
     /**
      * Path to Biome config file.
      */
@@ -1068,6 +1144,18 @@ export declare class PnpmWorkspace {
      * @returns Sorted content
      */
     static sortContent(content: PnpmWorkspaceContent): PnpmWorkspaceContent;
+    /**
+     * Create a handler that returns a CLI command to sort/format pnpm-workspace.yaml.
+     *
+     * @remarks
+     * Unlike {@link create}, this does not modify files in the handler function
+     * body. Instead it returns a `savvy-lint fmt pnpm-workspace` command so
+     * lint-staged can detect the modification and auto-stage it.
+     * Use this in lint-staged array syntax for sequential execution.
+     *
+     * @returns A lint-staged compatible handler function
+     */
+    static fmtCommand(): LintStagedHandler;
     /**
      * Create a handler with custom options.
      *
@@ -1232,6 +1320,12 @@ export declare const rootCommand: Command_2.Command<"savvy-lint", FileSystem_2,
     readonly preset: "minimal" | "silk" | "standard";
     } | {
     readonly quiet: boolean;
+    } | {
+    readonly subcommand: Option<    {
+    readonly files: string[];
+    } | {} | {
+    readonly files: string[];
+    }>;
     }>;
 }>;
 
@@ -1589,17 +1683,24 @@ export declare class TypeScript {
      * @defaultValue `['.test.', '.spec.', '__test__', '__tests__']`
      */
     static readonly defaultTsdocExcludes: readonly [".test.", ".spec.", "__test__", "__tests__"];
+    /** Cached compiler detection result */
+    private static cachedCompilerResult;
     /**
-     * Detect which TypeScript compiler to use based on package.json dependencies.
+     * Detect which TypeScript compiler to use.
      *
-     * Checks for:
-     * 1. `\@typescript/native-preview` in dependencies/devDependencies → `tsgo`
-     * 2. `typescript` in dependencies/devDependencies → `tsc`
+     * Uses `Command.findTool()` to check for available compilers:
+     * 1. `tsgo` (native TypeScript) — checked first
+     * 2. `tsc` (standard TypeScript) — fallback
      *
-     * @param cwd - Directory to search for package.json (defaults to process.cwd())
-     * @returns The compiler to use, or undefined if neither is installed
+     * @remarks
+     * Unlike the previous implementation that parsed `package.json` dependencies,
+     * this uses runtime tool detection which works correctly with pnpm catalogs,
+     * peer dependencies, and hoisted/transitive deps.
+     *
+     * @param _cwd - Ignored (kept for backward compatibility)
+     * @returns The compiler to use, or undefined if neither is available
      */
-    static detectCompiler(cwd?: string): TypeScriptCompiler | undefined;
+    static detectCompiler(_cwd?: string): TypeScriptCompiler | undefined;
     /**
      * Check if a TypeScript compiler is available.
      *
@@ -1607,12 +1708,21 @@ export declare class TypeScript {
      */
     static isAvailable(): boolean;
     /**
-     * Get the default type checking command for the detected package manager and compiler.
+     * Get the default type checking command for the detected compiler.
+     *
+     * @remarks
+     * Uses the cached `ToolSearchResult` from `detectCompiler()` to build
+     * the command string, avoiding a separate package manager detection step.
      *
-     * @returns Command string like `pnpm exec tsgo --noEmit` or `npx --no tsc --noEmit`
-     * @throws Error if no TypeScript compiler is detected in package.json
+     * @returns Command string like `pnpm exec tsgo --noEmit` or `tsgo --noEmit`
+     * @throws Error if no TypeScript compiler is available
      */
     static getDefaultTypecheckCommand(): string;
+    /**
+     * Clear the cached compiler detection result.
+     * Useful for testing or when the environment changes.
+     */
+    static clearCache(): void;
     /**
      * Pre-configured handler with default options.
      * Auto-discovers workspaces for TSDoc linting.
@@ -1679,14 +1789,14 @@ export declare interface TypeScriptOptions extends BaseHandlerOptions {
 /**
  * Handler for YAML files.
  *
- * Formats and validates YAML files using the bundled yaml library.
+ * Formats with Prettier and validates with yaml-lint, both as bundled dependencies.
  *
  * @remarks
  * Excludes pnpm-lock.yaml and pnpm-workspace.yaml by default.
  * pnpm-workspace.yaml has its own dedicated handler.
  *
- * Uses the `yaml` package for both formatting and validation
- * as a bundled dependency (no CLI spawning required).
+ * Uses Prettier for formatting and yaml-lint for validation.
+ * Both are bundled dependencies (no CLI spawning required).
  *
  * @example
  * ```typescript
@@ -1715,19 +1825,55 @@ export declare class Yaml {
      */
     static readonly handler: LintStagedHandler;
     /**
-     * Format a YAML file in-place.
+     * Find the yaml-lint config file.
+     *
+     * Searches in order:
+     * 1. `lib/configs/` directory
+     * 2. Standard locations (repo root)
+     *
+     * @returns The config file path, or undefined if not found
+     */
+    static findConfig(): string | undefined;
+    /**
+     * Load the yaml-lint schema from a config file.
+     *
+     * @param filepath - Path to the yaml-lint config file
+     * @returns The schema string, or undefined if not found
+     */
+    static loadConfig(filepath: string): string | undefined;
+    /**
+     * Check if yaml-lint is available.
+     *
+     * @returns Always `true` since yaml-lint is a bundled dependency
+     */
+    static isAvailable(): boolean;
+    /**
+     * Format a YAML file in-place using Prettier.
      *
      * @param filepath - Path to the YAML file
-     * @param options - Stringify options for the yaml package
      */
-    static formatFile(filepath: string, options?: Parameters<typeof stringify>[1]): void;
+    static formatFile(filepath: string): Promise<void>;
     /**
-     * Validate a YAML file.
+     * Validate a YAML file using yaml-lint.
      *
      * @param filepath - Path to the YAML file
+     * @param schema - The YAML schema to validate against
      * @throws Error if the YAML is invalid
      */
-    static validateFile(filepath: string): void;
+    static validateFile(filepath: string, schema?: string): Promise<void>;
+    /**
+     * Create a handler that returns a CLI command to format YAML files.
+     *
+     * @remarks
+     * Unlike {@link create}, this does not modify files in the handler function
+     * body. Instead it returns a `savvy-lint fmt yaml` command so lint-staged
+     * can detect the modification and auto-stage it.
+     * Use this in lint-staged array syntax for sequential execution.
+     *
+     * @param options - Configuration options
+     * @returns A lint-staged compatible handler function
+     */
+    static fmtCommand(options?: YamlOptions): LintStagedHandler;
     /**
      * Create a handler with custom options.
      *
@@ -1741,6 +1887,10 @@ export declare class Yaml {
  * Options for the Yaml handler.
  */
 export declare interface YamlOptions extends BaseHandlerOptions {
+    /**
+     * Path to yaml-lint config file (.yaml-lint.json).
+     */
+    config?: string;
     /**
      * Skip YAML formatting.
      * @defaultValue false

package/index.js

@@ -1,6 +1,4 @@
-import sort_package_json from "sort-package-json";
-import { parse, stringify } from "yaml";
-import { Biome, Markdown, readFileSync, TypeScript, writeFileSync, existsSync, Filter } from "./376.js";
+import { Biome, Command as Command_Command, readFileSync, Yaml, TypeScript, sort_package_json, PnpmWorkspace, writeFileSync, Markdown, Filter } from "./376.js";
 class PackageJson {
     static glob = "**/package.json";
     static defaultExcludes = [
@@ -8,11 +6,23 @@ class PackageJson {
         "__fixtures__"
     ];
     static handler = PackageJson.create();
+    static fmtCommand(options = {}) {
+        const excludes = options.exclude ?? [
+            ...PackageJson.defaultExcludes
+        ];
+        return (filenames)=>{
+            const filtered = Filter.exclude(filenames, excludes);
+            if (0 === filtered.length) return [];
+            const cmd = Command_Command.findSavvyLint();
+            return `${cmd} fmt package-json ${Filter.shellEscape(filtered)}`;
+        };
+    }
     static create(options = {}) {
         const excludes = options.exclude ?? [
             ...PackageJson.defaultExcludes
         ];
         const skipSort = options.skipSort ?? false;
+        const skipFormat = options.skipFormat ?? false;
         return (filenames)=>{
             const filtered = Filter.exclude(filenames, excludes);
             if (0 === filtered.length) return [];
@@ -21,66 +31,13 @@ class PackageJson {
                 const sorted = sort_package_json(content);
                 if (sorted !== content) writeFileSync(filepath, sorted, "utf-8");
             }
+            if (skipFormat) return [];
             const files = Filter.shellEscape(filtered);
             const biomeCmd = options.biomeConfig ? `biome check --write --max-diagnostics=none --config-path=${options.biomeConfig} ${files}` : `biome check --write --max-diagnostics=none ${files}`;
             return biomeCmd;
         };
     }
 }
-const DEFAULT_STRINGIFY_OPTIONS = {
-    indent: 2,
-    lineWidth: 0,
-    singleQuote: false
-};
-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)=>{
-            if ("packages" === a) return -1;
-            if ("packages" === b) return 1;
-            return a.localeCompare(b);
-        });
-        for (const key of keys){
-            const value = content[key];
-            if (PnpmWorkspace.SORTABLE_ARRAY_KEYS.has(key) && Array.isArray(value)) result[key] = [
-                ...value
-            ].sort();
-            else result[key] = value;
-        }
-        return result;
-    }
-    static create(options = {}) {
-        const skipSort = options.skipSort ?? false;
-        const skipFormat = options.skipFormat ?? false;
-        const skipLint = options.skipLint ?? false;
-        return ()=>{
-            const filepath = "pnpm-workspace.yaml";
-            if (!existsSync(filepath)) return [];
-            const content = readFileSync(filepath, "utf-8");
-            let parsed;
-            try {
-                parsed = parse(content);
-            } catch (error) {
-                if (!skipLint) throw new Error(`Invalid YAML in ${filepath}: ${error instanceof Error ? error.message : String(error)}`);
-                return [];
-            }
-            if (!skipSort) parsed = PnpmWorkspace.sortContent(parsed);
-            if (!skipSort || !skipFormat) {
-                const formatted = stringify(parsed, DEFAULT_STRINGIFY_OPTIONS);
-                writeFileSync(filepath, formatted, "utf-8");
-            }
-            return [];
-        };
-    }
-}
 class ShellScripts {
     static glob = "**/*.sh";
     static defaultExcludes = [
@@ -100,57 +57,27 @@ class ShellScripts {
         };
     }
 }
-const Yaml_DEFAULT_STRINGIFY_OPTIONS = {
-    indent: 2,
-    lineWidth: 0,
-    singleQuote: false
-};
-class Yaml {
-    static glob = "**/*.{yml,yaml}";
-    static defaultExcludes = [
-        "pnpm-lock.yaml",
-        "pnpm-workspace.yaml"
-    ];
-    static handler = Yaml.create();
-    static formatFile(filepath, options) {
-        const content = readFileSync(filepath, "utf-8");
-        const parsed = parse(content);
-        const formatted = stringify(parsed, {
-            ...Yaml_DEFAULT_STRINGIFY_OPTIONS,
-            ...options
-        });
-        writeFileSync(filepath, formatted, "utf-8");
-    }
-    static validateFile(filepath) {
-        const content = readFileSync(filepath, "utf-8");
-        parse(content);
-    }
-    static create(options = {}) {
-        const excludes = options.exclude ?? [
-            ...Yaml.defaultExcludes
-        ];
-        const skipFormat = options.skipFormat ?? false;
-        const skipValidate = options.skipValidate ?? false;
-        return (filenames)=>{
-            const filtered = Filter.exclude(filenames, excludes);
-            if (0 === filtered.length) return [];
-            if (!skipFormat) for (const filepath of filtered)Yaml.formatFile(filepath);
-            if (!skipValidate) for (const filepath of filtered)try {
-                Yaml.validateFile(filepath);
-            } catch (error) {
-                throw new Error(`Invalid YAML in ${filepath}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-            return [];
-        };
-    }
-}
 function createConfig(options = {}) {
     const config = {};
-    if (false !== options.packageJson) {
-        const handlerOptions = "object" == typeof options.packageJson ? options.packageJson : {};
-        config[PackageJson.glob] = PackageJson.create(handlerOptions);
+    const pkgJsonEnabled = false !== options.packageJson;
+    const biomeEnabled = false !== options.biome;
+    if (pkgJsonEnabled && biomeEnabled) {
+        const pkgOpts = "object" == typeof options.packageJson ? options.packageJson : {};
+        const biomeOpts = "object" == typeof options.biome ? options.biome : {};
+        config[PackageJson.glob] = [
+            PackageJson.fmtCommand(pkgOpts),
+            Biome.create({
+                ...biomeOpts,
+                exclude: [
+                    ...PackageJson.defaultExcludes
+                ]
+            })
+        ];
+    } else if (pkgJsonEnabled) {
+        const pkgOpts = "object" == typeof options.packageJson ? options.packageJson : {};
+        config[PackageJson.glob] = PackageJson.create(pkgOpts);
     }
-    if (false !== options.biome) {
+    if (biomeEnabled) {
         const handlerOptions = "object" == typeof options.biome ? options.biome : {};
         config[Biome.glob] = Biome.create(handlerOptions);
     }
@@ -158,13 +85,28 @@ function createConfig(options = {}) {
         const handlerOptions = "object" == typeof options.markdown ? options.markdown : {};
         config[Markdown.glob] = Markdown.create(handlerOptions);
     }
-    if (false !== options.yaml) {
-        const handlerOptions = "object" == typeof options.yaml ? options.yaml : {};
-        config[Yaml.glob] = Yaml.create(handlerOptions);
-    }
-    if (false !== options.pnpmWorkspace) {
-        const handlerOptions = "object" == typeof options.pnpmWorkspace ? options.pnpmWorkspace : {};
-        config[PnpmWorkspace.glob] = PnpmWorkspace.create(handlerOptions);
+    const pnpmEnabled = false !== options.pnpmWorkspace;
+    const yamlEnabled = false !== options.yaml;
+    if (pnpmEnabled && yamlEnabled) config[PnpmWorkspace.glob] = [
+        PnpmWorkspace.fmtCommand(),
+        Yaml.create({
+            exclude: [],
+            skipFormat: true
+        })
+    ];
+    else if (pnpmEnabled) {
+        const pnpmOpts = "object" == typeof options.pnpmWorkspace ? options.pnpmWorkspace : {};
+        config[PnpmWorkspace.glob] = PnpmWorkspace.create(pnpmOpts);
+    }
+    if (yamlEnabled) {
+        const yamlOpts = "object" == typeof options.yaml ? options.yaml : {};
+        config[Yaml.glob] = [
+            Yaml.fmtCommand(yamlOpts),
+            Yaml.create({
+                ...yamlOpts,
+                skipFormat: true
+            })
+        ];
     }
     if (false !== options.shellScripts) {
         const handlerOptions = "object" == typeof options.shellScripts ? options.shellScripts : {};
@@ -236,5 +178,5 @@ class Handler {
         throw new Error("Handler.create() must be implemented by subclass");
     }
 }
-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 };
+export { Biome, Command, ConfigSearch, EntryExtractor, Filter, ImportGraph, Markdown, PnpmWorkspace, TsDocLinter, TsDocResolver, TypeScript, Yaml, checkCommand, fmtCommand, initCommand, rootCommand, runCli } from "./376.js";
+export { Handler, PackageJson, Preset, ShellScripts, createConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/lint-staged",
-	"version": "0.3.2",
+	"version": "0.4.0",
 	"private": false,
 	"description": "Composable, configurable lint-staged handlers for pre-commit hooks. Provides reusable handlers for Biome, Markdown, YAML, TypeScript, and more.",
 	"keywords": [
@@ -49,21 +49,32 @@
 		"eslint": "^9.39.2",
 		"eslint-plugin-tsdoc": "^0.5.0",
 		"jsonc-parser": "^3.3.1",
+		"prettier": "^3.8.1",
 		"sort-package-json": "^3.6.1",
 		"workspace-tools": "^0.41.0",
-		"yaml": "^2.8.2"
+		"yaml": "^2.8.2",
+		"yaml-lint": "^1.7.0"
 	},
 	"peerDependencies": {
 		"@biomejs/biome": "2.3.14",
+		"@types/node": "^25.2.1",
+		"@typescript/native-preview": "7.0.0-dev.20260207.1",
 		"husky": "^9.1.7",
 		"lint-staged": "^16.2.7",
 		"markdownlint-cli2": "^0.20.0",
-		"markdownlint-cli2-formatter-codequality": "^0.0.7"
+		"markdownlint-cli2-formatter-codequality": "^0.0.7",
+		"typescript": "^5.9.3"
 	},
 	"peerDependenciesMeta": {
 		"@biomejs/biome": {
 			"optional": true
 		},
+		"@types/node": {
+			"optional": false
+		},
+		"@typescript/native-preview": {
+			"optional": false
+		},
 		"husky": {
 			"optional": false
 		},
@@ -75,8 +86,14 @@
 		},
 		"markdownlint-cli2-formatter-codequality": {
 			"optional": false
+		},
+		"typescript": {
+			"optional": false
 		}
 	},
+	"engines": {
+		"node": ">=24.0.0"
+	},
 	"scripts": {
 		"postinstall": "savvy-lint check --quiet || true"
 	},

package/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.56.2"
+      "packageVersion": "7.56.3"
     }
   ]
 }