@savvy-web/lint-staged 0.2.2 → 0.3.1

package/376.js

@@ -1,7 +1,9 @@
 import { Command, Options } from "@effect/cli";
 import { NodeContext, NodeRuntime } from "@effect/platform-node";
 import { Effect } from "effect";
+import { isDeepStrictEqual } from "node:util";
 import { FileSystem } from "@effect/platform";
+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";
@@ -921,17 +923,201 @@ class TypeScript {
         };
     }
 }
+const MARKDOWNLINT_TEMPLATE = {
+    $schema: "https://raw.githubusercontent.com/DavidAnson/markdownlint-cli2/v0.20.0/schema/markdownlint-cli2-config-schema.json",
+    globs: [
+        "**/*.{md,mdx}"
+    ],
+    fix: true,
+    gitignore: true,
+    noBanner: true,
+    ignores: [
+        "**/node_modules",
+        "**/.cache",
+        "**/coverage",
+        "**/.coverage",
+        "**/dist",
+        "**/CHANGELOG.md",
+        "**/.claude/plans"
+    ],
+    config: {
+        default: true,
+        MD001: true,
+        MD002: true,
+        MD003: true,
+        MD004: true,
+        MD005: true,
+        MD006: true,
+        MD007: true,
+        MD008: true,
+        MD009: true,
+        MD010: true,
+        MD011: true,
+        MD012: true,
+        MD013: false,
+        MD014: true,
+        MD015: true,
+        MD016: true,
+        MD017: true,
+        MD018: true,
+        MD019: true,
+        MD020: true,
+        MD021: true,
+        MD022: true,
+        MD023: true,
+        MD024: {
+            siblings_only: true
+        },
+        MD025: true,
+        MD026: true,
+        MD027: true,
+        MD028: true,
+        MD029: true,
+        MD030: true,
+        MD031: true,
+        MD032: true,
+        MD033: {
+            allowed_elements: [
+                "br",
+                "details",
+                "summary",
+                "img",
+                "sup",
+                "sub"
+            ]
+        },
+        MD034: true,
+        MD035: true,
+        MD036: true,
+        MD037: true,
+        MD038: true,
+        MD039: true,
+        MD040: true,
+        MD041: true,
+        MD042: true,
+        MD043: false,
+        MD044: false,
+        MD045: true,
+        MD046: true,
+        MD047: true,
+        MD048: true,
+        MD049: true,
+        MD050: true,
+        MD051: true,
+        MD052: true,
+        MD053: true,
+        MD054: true,
+        MD055: true,
+        MD056: true,
+        MD057: true,
+        MD058: true,
+        MD059: true,
+        MD060: {
+            style: "compact"
+        }
+    }
+};
+const MARKDOWNLINT_SCHEMA = "https://raw.githubusercontent.com/DavidAnson/markdownlint-cli2/v0.20.0/schema/markdownlint-cli2-config-schema.json";
+const MARKDOWNLINT_CONFIG = {
+    default: true,
+    MD001: true,
+    MD002: true,
+    MD003: true,
+    MD004: true,
+    MD005: true,
+    MD006: true,
+    MD007: true,
+    MD008: true,
+    MD009: true,
+    MD010: true,
+    MD011: true,
+    MD012: true,
+    MD013: false,
+    MD014: true,
+    MD015: true,
+    MD016: true,
+    MD017: true,
+    MD018: true,
+    MD019: true,
+    MD020: true,
+    MD021: true,
+    MD022: true,
+    MD023: true,
+    MD024: {
+        siblings_only: true
+    },
+    MD025: true,
+    MD026: true,
+    MD027: true,
+    MD028: true,
+    MD029: true,
+    MD030: true,
+    MD031: true,
+    MD032: true,
+    MD033: {
+        allowed_elements: [
+            "br",
+            "details",
+            "summary",
+            "img",
+            "sup",
+            "sub"
+        ]
+    },
+    MD034: true,
+    MD035: true,
+    MD036: true,
+    MD037: true,
+    MD038: true,
+    MD039: true,
+    MD040: true,
+    MD041: true,
+    MD042: true,
+    MD043: false,
+    MD044: false,
+    MD045: true,
+    MD046: true,
+    MD047: true,
+    MD048: true,
+    MD049: true,
+    MD050: true,
+    MD051: true,
+    MD052: true,
+    MD053: true,
+    MD054: true,
+    MD055: true,
+    MD056: true,
+    MD057: true,
+    MD058: true,
+    MD059: true,
+    MD060: {
+        style: "compact"
+    }
+};
 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
-{ [ -n "$CI" ] || [ -n "$GITHUB_ACTIONS" ]; } && exit 0
+if ! { [ -n "$CI" ] || [ -n "$GITHUB_ACTIONS" ]; }; then
 
 # Get repo root directory
 ROOT=$(git rev-parse --show-toplevel)
@@ -959,26 +1145,36 @@ detect_pm() {
   fi
 }
 
-# Get the exec command for the detected package manager
+# Run lint-staged with the detected package manager
 PM=$(detect_pm)
 case "$PM" in
-  pnpm) CMD="pnpm exec" ;;
-  yarn) CMD="yarn exec" ;;
-  bun)  CMD="bunx" ;;
-  *)    CMD="npx --no --" ;;
+  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
 
-$CMD lint-staged --config "$ROOT/${configPath}"`;
+fi`;
 }
-function generateFullHookContent(configPath) {
-    return `#!/usr/bin/env sh
-# Pre-commit hook with savvy-lint managed section
-# Custom hooks can go above or below the managed section
+function generateShellScriptsManagedContent() {
+    return `# DO NOT EDIT between these markers - managed by savvy-lint
+if ! { [ -n "$CI" ] || [ -n "$GITHUB_ACTIONS" ]; }; then
 
-${BEGIN_MARKER}
-${generateManagedContent(configPath)}
-${END_MARKER}
-`;
+# 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);
@@ -996,24 +1192,73 @@ function extractManagedSection(content) {
         found: true
     };
 }
-function updateManagedSection(existingContent, configPath) {
-    const { beforeSection, afterSection, found } = extractManagedSection(existingContent);
-    const newManagedSection = `${BEGIN_MARKER}\n${generateManagedContent(configPath)}\n${END_MARKER}`;
-    if (found) return `${beforeSection}${newManagedSection}${afterSection}`;
-    const trimmedContent = existingContent.trimEnd();
-    return `${trimmedContent}\n\n${newManagedSection}\n`;
+function 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 type { Configuration } from "lint-staged";
 import { Preset } from "@savvy-web/lint-staged";
 
-export default Preset.${preset}() satisfies Configuration;
+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 = parse(existingText);
+        let updatedText = existingText;
+        let schemaUpdated = false;
+        if (existingParsed.$schema !== MARKDOWNLINT_SCHEMA) {
+            const edits = modify(updatedText, [
+                "$schema"
+            ], MARKDOWNLINT_SCHEMA, {
+                formattingOptions: JSONC_FORMAT
+            });
+            updatedText = 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`);
+    });
+}
 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", [
@@ -1024,6 +1269,31 @@ const presetOption = Options.choice("preset", [
 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,
@@ -1032,27 +1302,13 @@ const initCommand = Command.make("init", {
         const fs = yield* FileSystem.FileSystem;
         if (config.startsWith("/")) yield* Effect.fail(new Error("Config path must be relative to repository root, not absolute"));
         yield* Effect.log("Initializing lint-staged configuration...\n");
-        const huskyExists = yield* fs.exists(HUSKY_HOOK_PATH);
-        if (huskyExists && !force) {
-            const existingContent = yield* fs.readFileString(HUSKY_HOOK_PATH);
-            const { found } = extractManagedSection(existingContent);
-            const updatedContent = updateManagedSection(existingContent, config);
-            yield* fs.writeFileString(HUSKY_HOOK_PATH, updatedContent);
-            yield* makeExecutable(HUSKY_HOOK_PATH);
-            if (found) yield* Effect.log(`${CHECK_MARK} Updated managed section in ${HUSKY_HOOK_PATH}`);
-            else yield* Effect.log(`${CHECK_MARK} Added managed section to ${HUSKY_HOOK_PATH}`);
-        } else if (huskyExists && force) {
-            yield* fs.writeFileString(HUSKY_HOOK_PATH, generateFullHookContent(config));
-            yield* makeExecutable(HUSKY_HOOK_PATH);
-            yield* Effect.log(`${CHECK_MARK} Replaced ${HUSKY_HOOK_PATH} (--force)`);
-        } else {
-            yield* fs.makeDirectory(".husky", {
-                recursive: true
-            });
-            yield* fs.writeFileString(HUSKY_HOOK_PATH, generateFullHookContent(config));
-            yield* makeExecutable(HUSKY_HOOK_PATH);
-            yield* Effect.log(`${CHECK_MARK} Created ${HUSKY_HOOK_PATH}`);
+        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);
         const configExists = yield* fs.exists(config);
         if (configExists && !force) yield* Effect.log(`${WARNING} ${config} already exists (use --force to overwrite)`);
         else {
@@ -1098,6 +1354,23 @@ 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 checkManagedSectionStatus(existingManaged) {
     const configPath = extractConfigPathFromManaged(existingManaged);
     if (!configPath) return {
@@ -1115,6 +1388,18 @@ function checkManagedSectionStatus(existingManaged) {
         needsUpdate: !isUpToDate
     };
 }
+function checkMarkdownlintConfig(content) {
+    const parsed = parse(content);
+    const schemaMatches = parsed.$schema === MARKDOWNLINT_SCHEMA;
+    const existingConfig = parsed.config;
+    const configMatches = void 0 !== existingConfig && isDeepStrictEqual(existingConfig, MARKDOWNLINT_CONFIG);
+    return {
+        exists: true,
+        schemaMatches,
+        configMatches,
+        isUpToDate: schemaMatches && configMatches
+    };
+}
 const quietOption = Options.boolean("quiet").pipe(Options.withAlias("q"), Options.withDescription("Only output warnings (for postinstall usage)"), Options.withDefault(false));
 const checkCommand = Command.make("check", {
     quiet: quietOption
@@ -1150,6 +1435,36 @@ const checkCommand = Command.make("check", {
             }
         } 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.`);
+        const shellHookPaths = [
+            POST_CHECKOUT_HOOK_PATH,
+            POST_MERGE_HOOK_PATH
+        ];
+        const shellHookStatuses = [];
+        for (const hookPath of shellHookPaths){
+            const hookExists = yield* fs.exists(hookPath);
+            if (hookExists) {
+                const hookContent = yield* fs.readFileString(hookPath);
+                const status = checkHookManagedSection(hookContent, generateShellScriptsManagedContent());
+                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).`);
+            }
+        }
+        const hasMarkdownlintConfig = yield* fs.exists(MARKDOWNLINT_CONFIG_PATH);
+        let markdownlintStatus = {
+            exists: false,
+            schemaMatches: false,
+            configMatches: false,
+            isUpToDate: false
+        };
+        if (hasMarkdownlintConfig) {
+            const mdContent = yield* fs.readFileString(MARKDOWNLINT_CONFIG_PATH);
+            markdownlintStatus = 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 (quiet) {
             if (warnings.length > 0) for (const warning of warnings)yield* Effect.log(warning);
             return;
@@ -1162,6 +1477,8 @@ const checkCommand = Command.make("check", {
         if (hasHuskyHook) if (managedStatus.found) if (managedStatus.isUpToDate) yield* Effect.log(`${check_CHECK_MARK} Managed section: up-to-date`);
         else yield* Effect.log(`${check_WARNING} Managed section: outdated (run 'savvy-lint init' to update)`);
         else yield* Effect.log(`${BULLET} Managed section: not found (run 'savvy-lint init' to add)`);
+        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)`);
         yield* Effect.log("\nTool availability:");
         const biomeAvailable = Biome.isAvailable();
         const biomeConfig = Biome.findConfig();
@@ -1183,8 +1500,18 @@ const checkCommand = Command.make("check", {
         const tsdocAvailable = TypeScript.isTsdocAvailable();
         if (tsdocAvailable) yield* Effect.log(`  ${check_CHECK_MARK} TSDoc (tsdoc.json found)`);
         else yield* Effect.log(`  ${BULLET} TSDoc: no tsdoc.json found`);
+        if (hasMarkdownlintConfig) if (markdownlintStatus.isUpToDate) yield* Effect.log(`  ${check_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`);
+        }
+        else yield* Effect.log(`  ${BULLET} ${MARKDOWNLINT_CONFIG_PATH}: not found`);
         yield* Effect.log("");
-        const hasIssues = !foundConfig || !hasHuskyHook || !managedStatus.found || managedStatus.needsUpdate;
+        const hasShellHookIssues = shellHookStatuses.some((s)=>s.found && s.needsUpdate);
+        const hasMarkdownlintIssues = hasMarkdownlintConfig && !markdownlintStatus.isUpToDate;
+        const hasIssues = !foundConfig || !hasHuskyHook || !managedStatus.found || managedStatus.needsUpdate || hasShellHookIssues || hasMarkdownlintIssues;
         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"));
@@ -1194,7 +1521,7 @@ const rootCommand = Command.make("savvy-lint").pipe(Command.withSubcommands([
 ]));
 const cli = Command.run(rootCommand, {
     name: "savvy-lint",
-    version: "0.2.2"
+    version: "0.3.1"
 });
 function runCli() {
     const main = Effect.suspend(()=>cli(process.argv)).pipe(Effect.provide(NodeContext.layer));

package/README.md

@@ -2,17 +2,19 @@
 
 [![npm version](https://img.shields.io/npm/v/@savvy-web/lint-staged)](https://www.npmjs.com/package/@savvy-web/lint-staged)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node.js](https://img.shields.io/badge/Node.js-24%2B-green)](https://nodejs.org/)
 
 Composable, configurable lint-staged handlers for pre-commit hooks. Stop
-duplicating lint-staged configs across projects - use reusable handlers with
+duplicating lint-staged configs across projects -- use reusable handlers with
 sensible defaults and easy customization.
 
 ## Features
 
 - Composable handlers for Biome, Markdown, YAML, TypeScript, and more
 - Zero-config presets for instant setup
+- CLI tool (`savvy-lint`) to bootstrap and validate your configuration
 - Workspace-aware TSDoc validation for public APIs
-- Bundled dependencies for fast, offline-capable execution
+- Shareable Biome configuration via `@savvy-web/lint-staged/biome/silk.jsonc`
 - Static class API with excellent TypeScript and TSDoc support
 
 ## Installation
@@ -30,7 +32,13 @@ npm install -D markdownlint-cli2
 
 ## Quick Start
 
-Use a preset for instant setup:
+Use the CLI to bootstrap your configuration:
+
+```bash
+npx savvy-lint init --preset standard
+```
+
+Or configure manually with a preset:
 
 ```typescript
 // lint-staged.config.ts
@@ -61,17 +69,6 @@ export default {
 | `standard()` | + Markdown, Yaml, PnpmWorkspace, ShellScripts |
 | `silk()` | + TypeScript |
 
-Extend any preset with options:
-
-```typescript
-import { Preset } from '@savvy-web/lint-staged';
-
-export default Preset.standard({
-  biome: { exclude: ['vendor/'] },
-  typescript: {}, // Enable TypeScript in standard
-});
-```
-
 ## Available Handlers
 
 | Handler | Files | Description |
@@ -82,14 +79,26 @@ export default Preset.standard({
 | `Yaml` | `**/*.{yml,yaml}` | Format and validate |
 | `PnpmWorkspace` | `pnpm-workspace.yaml` | Sort and format |
 | `ShellScripts` | `**/*.sh` | Manage permissions |
-| `TypeScript` | `*.{ts,tsx}` | TSDoc validation + typecheck |
+| `TypeScript` | `*.{ts,cts,mts,tsx}` | TSDoc validation + typecheck |
+
+## CLI
+
+The `savvy-lint` CLI helps bootstrap and validate 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)
+```
 
 ## Documentation
 
-- [Handler Configuration](./docs/handlers.md) - Detailed options for each handler
-- [Utilities](./docs/utilities.md) - Command, Filter, and advanced utilities
-- [Configuration API](./docs/configuration.md) - createConfig and Preset APIs
-- [Migration Guide](./docs/migration.md) - Migrating from raw lint-staged configs
+- [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`
+- [Utilities](./docs/utilities.md) -- Command, Filter, and advanced utilities
+- [Migration Guide](./docs/migration.md) -- Migrating from raw lint-staged configs
 
 ## Contributing
 

package/biome/silk.jsonc

@@ -0,0 +1,126 @@
+{
+	"$schema": "https://biomejs.dev/schemas/2.3.14/schema.json",
+	"assist": {
+		"actions": {
+			"source": {
+				"organizeImports": {
+					"level": "on",
+					"options": {
+						"identifierOrder": "lexicographic"
+					}
+				}
+			}
+		},
+		"enabled": true
+	},
+	"formatter": {
+		"enabled": true,
+		"formatWithErrors": true,
+		"indentStyle": "tab",
+		"indentWidth": 2,
+		"lineWidth": 120
+	},
+	"json": {
+		"assist": {
+			"enabled": true
+		},
+		"formatter": {
+			"enabled": true,
+			"expand": "auto"
+		},
+		"linter": {
+			"enabled": true
+		}
+	},
+	"css": {
+		"parser": {
+			"cssModules": true
+		},
+		"linter": {
+			"enabled": true
+		}
+	},
+	"linter": {
+		"domains": {
+			"project": "all"
+		},
+		"enabled": true,
+		"rules": {
+			"correctness": {
+				"noUnusedVariables": {
+					"level": "error",
+					"options": {
+						"ignoreRestSiblings": true
+					}
+				},
+				"useImportExtensions": {
+					"level": "error",
+					"options": {
+						"forceJsExtensions": true
+					}
+				}
+			},
+			"nursery": {
+				"noImportCycles": "error",
+				"useExplicitType": "off"
+			},
+			"recommended": true,
+			"style": {
+				"useConsistentTypeDefinitions": "error",
+				"useImportType": {
+					"level": "error",
+					"options": {
+						"style": "separatedType"
+					}
+				},
+				"useNodejsImportProtocol": "error"
+			},
+			"suspicious": {
+				"noBiomeFirstException": "error",
+				"noDuplicateObjectKeys": "error",
+				"noQuickfixBiome": "error",
+				"useBiomeIgnoreFolder": "error"
+			}
+		}
+	},
+	"overrides": [
+		{
+			"includes": ["package.json"],
+			"json": {
+				"formatter": {
+					"expand": "auto"
+				}
+			}
+		},
+		{
+			"assist": {
+				"actions": {
+					"source": {
+						"useSortedKeys": "on"
+					}
+				}
+			},
+			"includes": ["**/turbo.json", "**/tsconfig.json", "**/tsconfig.*.json"]
+		}
+	],
+	"root": true,
+	"vcs": {
+		"clientKind": "git",
+		"defaultBranch": "main",
+		"enabled": true,
+		"useIgnoreFile": true
+	},
+	"files": {
+		"includes": [
+			"**",
+			"!**/node_modules",
+			"!**/dist",
+			"!**/.turbo",
+			"!**/.git",
+			"!**/.rslib",
+			"!**/.vitest",
+			"!**/.coverage",
+			"!coverage"
+		]
+	}
+}

package/index.d.ts

@@ -798,6 +798,8 @@ export declare interface ImportGraphResult {
  * @remarks
  * Creates the necessary configuration files for lint-staged:
  * - `.husky/pre-commit` hook with managed section
+ * - `.husky/post-checkout` and `.husky/post-merge` hooks (when preset includes ShellScripts)
+ * - `.markdownlint-cli2.jsonc` config (when preset includes Markdown)
  * - lint-staged config at the specified path
  *
  * The managed section feature allows users to add custom hooks above/below

package/index.js

@@ -23,7 +23,7 @@ class PackageJson {
             }
             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} && git add ${files}`;
+            return biomeCmd;
         };
     }
 }
@@ -76,7 +76,6 @@ class PnpmWorkspace {
             if (!skipSort || !skipFormat) {
                 const formatted = stringify(parsed, DEFAULT_STRINGIFY_OPTIONS);
                 writeFileSync(filepath, formatted, "utf-8");
-                return `git add ${filepath}`;
             }
             return [];
         };
@@ -141,7 +140,6 @@ 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 ${Filter.shellEscape(filtered)}`;
             return [];
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/lint-staged",
-	"version": "0.2.2",
+	"version": "0.3.1",
 	"private": false,
 	"description": "Composable, configurable lint-staged handlers for pre-commit hooks. Provides reusable handlers for Biome, Markdown, YAML, TypeScript, and more.",
 	"keywords": [
@@ -33,7 +33,8 @@
 		".": {
 			"types": "./index.d.ts",
 			"import": "./index.js"
-		}
+		},
+		"./biome/silk.jsonc": "./biome/silk.jsonc"
 	},
 	"bin": {
 		"savvy-lint": "./bin/savvy-lint.js"
@@ -47,12 +48,13 @@
 		"effect": "^3.19.16",
 		"eslint": "^9.39.2",
 		"eslint-plugin-tsdoc": "^0.5.0",
+		"jsonc-parser": "^3.3.1",
 		"sort-package-json": "^3.6.1",
 		"workspace-tools": "^0.41.0",
 		"yaml": "^2.8.2"
 	},
 	"peerDependencies": {
-		"@biomejs/biome": "^2.3.12",
+		"@biomejs/biome": "2.3.14",
 		"husky": "^9.1.7",
 		"lint-staged": "^16.2.7",
 		"markdownlint-cli2": "^0.20.0",
@@ -75,20 +77,6 @@
 			"optional": false
 		}
 	},
-	"devEngines": {
-		"packageManager": {
-			"name": "pnpm",
-			"version": "10.28.2",
-			"onFail": "ignore"
-		},
-		"runtime": [
-			{
-				"name": "node",
-				"version": "24.11.0",
-				"onFail": "ignore"
-			}
-		]
-	},
 	"scripts": {
 		"postinstall": "savvy-lint check --quiet || true"
 	},
@@ -100,6 +88,7 @@
 		"LICENSE",
 		"README.md",
 		"bin/savvy-lint.js",
+		"biome/silk.jsonc",
 		"index.d.ts",
 		"index.js",
 		"package.json",

package/tsdoc-metadata.json

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