@savvy-web/lint-staged 1.1.0 → 1.2.1

package/841.js

@@ -1,6 +1,6 @@
 import { Args, Command, Options } from "@effect/cli";
 import { NodeContext, NodeRuntime } from "@effect/platform-node";
-import { BiomeSchemaSync, BiomeSchemaSyncLive, CheckResult, ConfigDiscovery, ConfigDiscoveryLive, ManagedSection, ManagedSectionLive, SectionDefinition, ShellSectionDefinition, SyncResult, ToolDefinition, ToolDiscovery, ToolDiscoveryLive } from "@savvy-web/silk-effects";
+import { BiomeSchemaSync, BiomeSchemaSyncLive, CheckResult, ConfigDiscovery, ConfigDiscoveryLive, ManagedSection, ManagedSectionLive, SavvyBaseSection, SavvyHooksSection, SectionDefinition, ToolDefinition, ToolDiscovery, ToolDiscoveryLive, savvyBasePreamble, savvyHooksHygiene, savvyToolSection } from "@savvy-web/silk-effects";
 import { Effect, Layer } from "effect";
 import { WorkspacesLive, findWorkspaceRootSync, getWorkspacePackagesSync } from "workspaces-effect";
 import { isDeepStrictEqual } from "node:util";
@@ -299,69 +299,18 @@ const POST_CHECKOUT_HOOK_PATH = ".husky/post-checkout";
 const POST_MERGE_HOOK_PATH = ".husky/post-merge";
 const DEFAULT_CONFIG_PATH = "lib/configs/lint-staged.config.ts";
 const MARKDOWNLINT_CONFIG_PATH = "lib/configs/.markdownlint-cli2.jsonc";
-const SavvyLintSection = ShellSectionDefinition.make({
-    toolName: "SAVVY-LINT"
-});
 const SavvyLintSectionDef = SectionDefinition.make({
-    toolName: "SAVVY-LINT"
+    toolName: "savvy-lint"
 });
-function generateManagedContent(configPath) {
-    return `# DO NOT EDIT between these markers - managed by savvy-lint
-# Skip in CI environment
-if ! { [ -n "$CI" ] || [ -n "$GITHUB_ACTIONS" ]; }; then
-
-# Get repo root directory
-ROOT=$(git rev-parse --show-toplevel)
-
-# Detect package manager from package.json or lockfiles
-detect_pm() {
-  # Check packageManager field in package.json (e.g., "pnpm@9.0.0")
-  if [ -f "$ROOT/package.json" ]; then
-    pm=$(jq -r '.packageManager // empty' "$ROOT/package.json" 2>/dev/null | cut -d'@' -f1)
-    if [ -n "$pm" ]; then
-      echo "$pm"
-      return
-    fi
-  fi
-
-  # Fallback to lockfile detection
-  if [ -f "$ROOT/pnpm-lock.yaml" ]; then
-    echo "pnpm"
-  elif [ -f "$ROOT/yarn.lock" ]; then
-    echo "yarn"
-  elif [ -f "$ROOT/bun.lock" ]; then
-    echo "bun"
-  else
-    echo "npm"
-  fi
-}
-
-# Run lint-staged with the detected package manager
-PM=$(detect_pm)
-case "$PM" in
-  pnpm) pnpm exec lint-staged --config "$ROOT/${configPath}" ;;
-  yarn) yarn exec lint-staged --config "$ROOT/${configPath}" ;;
-  bun)  bunx lint-staged --config "$ROOT/${configPath}" ;;
-  *)    npx --no -- lint-staged --config "$ROOT/${configPath}" ;;
-esac
-
-fi`;
+const LegacySavvyLintHygieneDef = SectionDefinition.make({
+    toolName: "savvy-lint"
+});
+function lintStagedCommand(configPath) {
+    return `lint-staged --config "$ROOT/${configPath}"`;
 }
-function generateShellScriptsManagedContent() {
-    return `# DO NOT EDIT between these markers - managed by savvy-lint
-if ! { [ -n "$CI" ] || [ -n "$GITHUB_ACTIONS" ]; }; then
-
-# Configure git to ignore executable bit changes
-# This ensures hook scripts can be made executable locally without git tracking the change
-git config core.fileMode false
-
-# Ensure all shell scripts tracked by git are executable
-git ls-files -z '*.sh' | xargs -0 -r chmod +x 2>/dev/null || true
-
-fi`;
+function savvyLintBlock(configPath) {
+    return savvyToolSection("savvy-lint", lintStagedCommand(configPath));
 }
-const preCommitBlock = SavvyLintSection.generate(generateManagedContent);
-const shellScriptsBlock = ()=>SavvyLintSection.block(generateShellScriptsManagedContent());
 const MARKDOWNLINT_TEMPLATE = {
     $schema: "https://raw.githubusercontent.com/DavidAnson/markdownlint-cli2/v0.22.0/schema/markdownlint-cli2-config-schema.json",
     globs: [
@@ -547,10 +496,10 @@ const MARKDOWNLINT_CONFIG = {
     "changeset-uncategorized-content": false,
     "changeset-dependency-table-format": false
 };
-const CHECK_MARK = "\u2713";
-const CROSS_MARK = "\u2717";
-const WARNING = "\u26A0";
-const BULLET = "\u2022";
+const CHECK_MARK = "✓";
+const CROSS_MARK = "✗";
+const WARNING = "⚠";
+const BULLET = "•";
 const CONFIG_FILES = [
     "lint-staged.config.ts",
     "lint-staged.config.js",
@@ -588,56 +537,6 @@ function extractConfigPathFromManaged(managedContent) {
     const match = managedContent.match(/lint-staged --config "\$ROOT\/([^"]+)"/);
     return match ? match[1] : null;
 }
-function checkHookManagedSection(section, hookPath, block) {
-    return Effect.gen(function*() {
-        const result = yield* section.check(hookPath, block);
-        return CheckResult.$match(result, {
-            Found: ({ isUpToDate })=>({
-                    found: true,
-                    isUpToDate,
-                    needsUpdate: !isUpToDate
-                }),
-            NotFound: ()=>({
-                    found: false,
-                    isUpToDate: false,
-                    needsUpdate: false
-                })
-        });
-    });
-}
-function checkManagedSectionStatus(section, hookPath) {
-    return Effect.gen(function*() {
-        const existing = yield* section.read(hookPath, SavvyLintSectionDef);
-        if (null === existing) return {
-            isUpToDate: false,
-            configPath: null,
-            needsUpdate: false,
-            found: false
-        };
-        const configPath = extractConfigPathFromManaged(existing.text);
-        if (!configPath) return {
-            isUpToDate: false,
-            configPath: null,
-            needsUpdate: true,
-            found: true
-        };
-        const result = yield* section.check(hookPath, preCommitBlock(configPath));
-        return CheckResult.$match(result, {
-            Found: ({ isUpToDate })=>({
-                    isUpToDate,
-                    configPath: configPath,
-                    needsUpdate: !isUpToDate,
-                    found: true
-                }),
-            NotFound: ()=>({
-                    isUpToDate: false,
-                    configPath: null,
-                    needsUpdate: false,
-                    found: false
-                })
-        });
-    });
-}
 function checkMarkdownlintConfig(content) {
     return Effect.gen(function*() {
         const parsed = yield* parse(content);
@@ -654,7 +553,7 @@ function checkMarkdownlintConfig(content) {
 }
 function checkBiomeSchemas() {
     return Effect.gen(function*() {
-        const version = "2.4.15";
+        const version = "2.4.16";
         const statuses = [];
         if (!version) return {
             statuses,
@@ -691,23 +590,45 @@ const checkCommand = Command.make("check", {
     quiet: quietOption
 }, ({ quiet })=>Effect.gen(function*() {
         const fs = yield* FileSystem.FileSystem;
-        const section = yield* ManagedSection;
+        const ms = yield* ManagedSection;
         const td = yield* ToolDiscovery;
         const discovery = yield* ConfigDiscovery;
         const warnings = [];
         const foundConfig = yield* findConfigFile(fs);
         const hasHuskyHook = yield* fs.exists(HUSKY_HOOK_PATH);
-        let managedStatus = {
-            isUpToDate: false,
-            configPath: null,
-            needsUpdate: false,
-            found: false
-        };
+        let sectionsHealthy = true;
+        let baseStatusLabel = "missing";
+        let lintStatusLabel = "missing";
+        let detectedConfigPath = null;
         if (hasHuskyHook) {
-            managedStatus = yield* checkManagedSectionStatus(section, HUSKY_HOOK_PATH);
-            if (managedStatus.found && managedStatus.needsUpdate) warnings.push(`${WARNING}  Your ${HUSKY_HOOK_PATH} managed section is outdated.\n   Run 'savvy-lint init' to update it (preserves your custom hooks).`);
-            else if (!managedStatus.found) warnings.push(`${WARNING}  Your ${HUSKY_HOOK_PATH} does not have a savvy-lint managed section.\n   Run 'savvy-lint init' to add it.`);
-        } else warnings.push(`${WARNING}  No husky pre-commit hook found.\n   Run 'savvy-lint init' to create it.`);
+            const baseResult = yield* ms.check(HUSKY_HOOK_PATH, SavvyBaseSection.block(savvyBasePreamble()));
+            if (CheckResult.$is("Found")(baseResult)) {
+                baseStatusLabel = baseResult.isUpToDate ? "up-to-date" : "outdated";
+                if (!baseResult.isUpToDate) sectionsHealthy = false;
+            } else sectionsHealthy = false;
+            const existing = yield* ms.read(HUSKY_HOOK_PATH, SavvyLintSectionDef);
+            if (existing) {
+                const configPath = extractConfigPathFromManaged(existing.content);
+                detectedConfigPath = configPath;
+                if (configPath) {
+                    const lintResult = yield* ms.check(HUSKY_HOOK_PATH, savvyLintBlock(configPath));
+                    if (CheckResult.$is("Found")(lintResult)) {
+                        lintStatusLabel = lintResult.isUpToDate ? "up-to-date" : "outdated";
+                        if (!lintResult.isUpToDate) sectionsHealthy = false;
+                    } else {
+                        lintStatusLabel = "outdated";
+                        sectionsHealthy = false;
+                    }
+                } else {
+                    lintStatusLabel = "outdated";
+                    sectionsHealthy = false;
+                }
+            } else sectionsHealthy = false;
+            if ("up-to-date" !== baseStatusLabel || "up-to-date" !== lintStatusLabel) warnings.push(`${WARNING}  Your ${HUSKY_HOOK_PATH} managed sections are out of date.\n   Run 'savvy-lint init' to update (preserves your custom hooks).`);
+        } else {
+            sectionsHealthy = false;
+            warnings.push(`${WARNING}  No husky pre-commit hook found.\n   Run 'savvy-lint init' to create it.`);
+        }
         if (!foundConfig) warnings.push(`${WARNING}  No lint-staged config file found.\n   Run 'savvy-lint init' to create one.`);
         const shellHookPaths = [
             POST_CHECKOUT_HOOK_PATH,
@@ -716,13 +637,30 @@ const checkCommand = Command.make("check", {
         const shellHookStatuses = [];
         for (const hookPath of shellHookPaths){
             const hookExists = yield* fs.exists(hookPath);
-            if (hookExists) {
-                const status = yield* checkHookManagedSection(section, hookPath, shellScriptsBlock());
+            if (!hookExists) {
                 shellHookStatuses.push({
                     path: hookPath,
-                    ...status
+                    found: false,
+                    isUpToDate: false
                 });
-                if (status.found && status.needsUpdate) warnings.push(`${WARNING}  Your ${hookPath} managed section is outdated.\n   Run 'savvy-lint init' to update it (preserves your custom hooks).`);
+                continue;
+            }
+            const hygieneResult = yield* ms.check(hookPath, SavvyHooksSection.block(savvyHooksHygiene()));
+            const found = CheckResult.$is("Found")(hygieneResult);
+            const isUpToDate = CheckResult.$is("Found")(hygieneResult) && hygieneResult.isUpToDate;
+            shellHookStatuses.push({
+                path: hookPath,
+                found,
+                isUpToDate
+            });
+            if (found) {
+                if (!isUpToDate) {
+                    sectionsHealthy = false;
+                    warnings.push(`${WARNING}  ${hookPath} savvy-hooks section is outdated.\n   Run 'savvy-lint init' to update.`);
+                }
+            } else {
+                sectionsHealthy = false;
+                warnings.push(`${WARNING}  ${hookPath} has no savvy-hooks section.\n   Run 'savvy-lint init' to add it.`);
             }
         }
         const biomeSchemaStatus = yield* checkBiomeSchemas().pipe(Effect.catchAll(()=>Effect.succeed({
@@ -754,11 +692,18 @@ const checkCommand = Command.make("check", {
         else yield* Effect.log(`${CROSS_MARK} No lint-staged config file found`);
         if (hasHuskyHook) yield* Effect.log(`${CHECK_MARK} Husky hook: ${HUSKY_HOOK_PATH}`);
         else yield* Effect.log(`${CROSS_MARK} No husky pre-commit hook found`);
-        if (hasHuskyHook) if (managedStatus.found) if (managedStatus.isUpToDate) yield* Effect.log(`${CHECK_MARK} Managed section: up-to-date`);
-        else yield* Effect.log(`${WARNING} Managed section: outdated (run 'savvy-lint init' to update)`);
-        else yield* Effect.log(`${BULLET} Managed section: not found (run 'savvy-lint init' to add)`);
+        if (hasHuskyHook) {
+            if ("up-to-date" === baseStatusLabel) yield* Effect.log(`${CHECK_MARK} Base section: up-to-date`);
+            else if ("outdated" === baseStatusLabel) yield* Effect.log(`${WARNING} Base section: outdated (run 'savvy-lint init' to update)`);
+            else yield* Effect.log(`${BULLET} Base section: not found (run 'savvy-lint init' to add)`);
+            const lintLabel = detectedConfigPath ? ` (config: ${detectedConfigPath})` : "";
+            if ("up-to-date" === lintStatusLabel) yield* Effect.log(`${CHECK_MARK} Lint section: up-to-date${lintLabel}`);
+            else if ("outdated" === lintStatusLabel) yield* Effect.log(`${WARNING} Lint section: outdated (run 'savvy-lint init' to update)`);
+            else yield* Effect.log(`${BULLET} Lint section: not found (run 'savvy-lint init' to add)`);
+        }
         for (const status of shellHookStatuses)if (status.found) if (status.isUpToDate) yield* Effect.log(`${CHECK_MARK} ${status.path}: up-to-date`);
         else yield* Effect.log(`${WARNING} ${status.path}: outdated (run 'savvy-lint init' to update)`);
+        else yield* Effect.log(`${BULLET} ${status.path}: savvy-hooks section not found`);
         yield* Effect.log("\nTool availability:");
         const biomeAvailable = yield* td.isAvailable(ToolDefinition.make({
             name: "biome"
@@ -807,10 +752,9 @@ const checkCommand = Command.make("check", {
         for (const status of biomeSchemaStatus.statuses)if (status.matches) yield* Effect.log(`  ${CHECK_MARK} ${status.path}: biome $schema up-to-date`);
         else yield* Effect.log(`  ${WARNING} ${status.path}: biome $schema outdated (run 'savvy-lint init' to update)`);
         yield* Effect.log("");
-        const hasShellHookIssues = shellHookStatuses.some((s)=>s.found && s.needsUpdate);
         const hasMarkdownlintIssues = hasMarkdownlintConfig && !markdownlintStatus.isUpToDate;
         const hasBiomeSchemaIssues = biomeSchemaStatus.statuses.some((s)=>!s.matches);
-        const hasIssues = !foundConfig || !hasHuskyHook || !managedStatus.found || managedStatus.needsUpdate || hasShellHookIssues || hasMarkdownlintIssues || hasBiomeSchemaIssues;
+        const hasIssues = !foundConfig || !hasHuskyHook || !sectionsHealthy || hasMarkdownlintIssues || hasBiomeSchemaIssues;
         if (hasIssues) yield* Effect.log(`${WARNING} Some issues found. Run 'savvy-lint init' to fix.`);
         else yield* Effect.log(`${CHECK_MARK} Lint-staged is configured correctly.`);
     })).pipe(Command.withDescription("Check current lint-staged configuration and tool availability"));
@@ -987,13 +931,15 @@ const fmtCommand = Command.make("fmt").pipe(Command.withSubcommands([
     pnpmWorkspaceCommand,
     yamlCommand
 ]));
-const init_CHECK_MARK = "\u2713";
-const init_WARNING = "\u26A0";
+const init_CHECK_MARK = "✓";
+const init_WARNING = "⚠";
 const EXECUTABLE_MODE = 493;
 const JSONC_FORMAT = {
     tabSize: 1,
     insertSpaces: false
 };
+const PRE_COMMIT_HEADER = "#!/usr/bin/env sh\n# Pre-commit hook with savvy managed sections\n# Custom hooks can go above, below, or between the managed sections\n\n";
+const HYGIENE_HEADER = "#!/usr/bin/env sh\n# Managed by savvy-hooks\n# Custom hooks can go above or below the managed section\n\n";
 function presetIncludesShellScripts(preset) {
     return "minimal" !== preset;
 }
@@ -1059,7 +1005,7 @@ function writeMarkdownlintConfig(fs, preset, force) {
 }
 function syncBiomeSchemas() {
     return Effect.gen(function*() {
-        const version = "2.4.15";
+        const version = "2.4.16";
         if (!version) return;
         const syncer = yield* BiomeSchemaSync;
         const result = yield* syncer.sync(version);
@@ -1067,7 +1013,7 @@ function syncBiomeSchemas() {
         for (const configPath of result.updated)yield* Effect.log(`${init_CHECK_MARK} Updated $schema in ${configPath}`);
     });
 }
-const forceOption = Options.boolean("force").pipe(Options.withAlias("f"), Options.withDescription("Overwrite entire hook file (not just managed section)"), Options.withDefault(false));
+const forceOption = Options.boolean("force").pipe(Options.withAlias("f"), Options.withDescription("Overwrite the pre-commit hook and config file entirely (managed sections in post-checkout/post-merge are never force-reset)"), Options.withDefault(false));
 const configOption = Options.text("config").pipe(Options.withAlias("c"), Options.withDescription("Relative path for the lint-staged config file (from repo root)"), Options.withDefault(DEFAULT_CONFIG_PATH));
 const presetOption = Options.choice("preset", [
     "minimal",
@@ -1077,25 +1023,11 @@ 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, section, hookPath, block, comment, force) {
+function ensureHookFile(path, header) {
     return Effect.gen(function*() {
-        const hookExists = yield* fs.exists(hookPath);
-        const header = `#!/usr/bin/env sh\n# ${comment}\n# Custom hooks can go above or below the managed section\n`;
-        if (!hookExists || force) {
-            if (!hookExists) yield* fs.makeDirectory(".husky", {
-                recursive: true
-            });
-            yield* fs.writeFileString(hookPath, header);
-        }
-        const result = yield* section.sync(hookPath, block);
-        yield* makeExecutable(hookPath);
-        if (hookExists) if (force) yield* Effect.log(`${init_CHECK_MARK} Replaced ${hookPath} (--force)`);
-        else yield* SyncResult.$match(result, {
-            Created: ()=>Effect.log(`${init_CHECK_MARK} Added managed section to ${hookPath}`),
-            Updated: ()=>Effect.log(`${init_CHECK_MARK} Updated managed section in ${hookPath}`),
-            Unchanged: ()=>Effect.log(`${init_CHECK_MARK} ${hookPath}: up-to-date`)
-        });
-        else yield* Effect.log(`${init_CHECK_MARK} Created ${hookPath}`);
+        const fs = yield* FileSystem.FileSystem;
+        const exists = yield* fs.exists(path);
+        if (!exists) yield* fs.writeFileString(path, header);
     });
 }
 const initCommand = Command.make("init", {
@@ -1104,14 +1036,29 @@ const initCommand = Command.make("init", {
     preset: presetOption
 }, ({ force, config, preset })=>Effect.gen(function*() {
         const fs = yield* FileSystem.FileSystem;
-        const section = yield* ManagedSection;
+        const ms = yield* ManagedSection;
         if (config.startsWith("/")) yield* Effect.fail(new Error("Config path must be relative to repository root, not absolute"));
         yield* Effect.log("Initializing lint-staged configuration...\n");
-        yield* writeHook(fs, section, HUSKY_HOOK_PATH, preCommitBlock(config), "Pre-commit hook with savvy-lint managed section", force);
-        if (presetIncludesShellScripts(preset)) {
-            const shellBlock = shellScriptsBlock();
-            yield* writeHook(fs, section, POST_CHECKOUT_HOOK_PATH, shellBlock, "Post-checkout hook with savvy-lint managed section", force);
-            yield* writeHook(fs, section, POST_MERGE_HOOK_PATH, shellBlock, "Post-merge hook with savvy-lint managed section", force);
+        yield* fs.makeDirectory(".husky", {
+            recursive: true
+        });
+        if (force) yield* fs.writeFileString(HUSKY_HOOK_PATH, PRE_COMMIT_HEADER);
+        else yield* ensureHookFile(HUSKY_HOOK_PATH, PRE_COMMIT_HEADER);
+        const preCommitResults = yield* ms.syncMany(HUSKY_HOOK_PATH, [
+            SavvyBaseSection.block(savvyBasePreamble()),
+            savvyLintBlock(config)
+        ]);
+        yield* makeExecutable(HUSKY_HOOK_PATH);
+        yield* Effect.log(`${init_CHECK_MARK} ${force ? "Replaced" : "Synced"} ${HUSKY_HOOK_PATH} (${preCommitResults.map((r)=>r._tag).join(", ")})`);
+        if (presetIncludesShellScripts(preset)) for (const hookPath of [
+            POST_CHECKOUT_HOOK_PATH,
+            POST_MERGE_HOOK_PATH
+        ]){
+            yield* ensureHookFile(hookPath, HYGIENE_HEADER);
+            yield* ms.remove(hookPath, LegacySavvyLintHygieneDef);
+            yield* ms.sync(hookPath, SavvyHooksSection.block(savvyHooksHygiene()));
+            yield* makeExecutable(hookPath);
+            yield* Effect.log(`${init_CHECK_MARK} Synced ${hookPath}`);
         }
         if (presetIncludesMarkdown(preset)) yield* writeMarkdownlintConfig(fs, preset, force);
         yield* syncBiomeSchemas().pipe(Effect.catchTag("BiomeSyncError", (e)=>Effect.log(`${init_WARNING} Could not sync biome $schema: ${e.message}`)));
@@ -1136,7 +1083,7 @@ const rootCommand = Command.make("savvy-lint").pipe(Command.withSubcommands([
 ]));
 const cli = Command.run(rootCommand, {
     name: "savvy-lint",
-    version: "1.1.0"
+    version: "1.2.1"
 });
 function runCli() {
     const main = Effect.suspend(()=>cli(process.argv)).pipe(Effect.provide(AppLayer));

package/README.md

@@ -1,12 +1,11 @@
 # @savvy-web/lint-staged
 
-[![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/)
+[![npm](https://img.shields.io/npm/v/@savvy-web%2Flint-staged?label=npm&color=cb3837)](https://www.npmjs.com/package/@savvy-web/lint-staged)
+[![License: MIT](https://img.shields.io/badge/License-MIT-4caf50.svg)](https://opensource.org/licenses/MIT)
+[![Node.js %3E%3D24](https://img.shields.io/badge/Node.js-%3E%3D24-5fa04e.svg)](https://nodejs.org/)
+[![TypeScript 6.0](https://img.shields.io/badge/TypeScript-6.0-3178c6.svg)](https://www.typescriptlang.org/)
 
-Composable, configurable lint-staged handlers for pre-commit hooks. Stop
-duplicating lint-staged configs across projects -- use reusable handlers with
-sensible defaults and easy customization.
+Composable, configurable lint-staged handlers for pre-commit hooks. Stop duplicating lint-staged configs across projects — reuse handlers with sensible defaults and easy customization.
 
 ## Features
 
@@ -17,7 +16,7 @@ sensible defaults and easy customization.
 - Shareable Biome configuration via `@savvy-web/lint-staged/biome/silk.jsonc`
 - Static class API with excellent TypeScript support
 
-## Installation
+## Install
 
 ```bash
 # Install the package and required peer dependencies
@@ -30,7 +29,7 @@ npm install -D @biomejs/biome
 npm install -D markdownlint-cli2
 ```
 
-## Quick Start
+## Quick start
 
 Use the CLI to bootstrap your configuration:
 
@@ -69,7 +68,7 @@ export default {
 | `standard()` | + Markdown, Yaml, PnpmWorkspace, ShellScripts |
 | `silk()` | + TypeScript |
 
-## Available Handlers
+## Available handlers
 
 | Handler | Files | Description |
 | --- | --- | --- |
@@ -86,20 +85,22 @@ export default {
 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
+savvy-lint init                        # Bootstrap hooks, config, and tooling
+savvy-lint init --preset silk --force  # Reset pre-commit and config file
+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
 ```
 
-## Claude Code Plugin
+`init` writes two managed sections into `.husky/pre-commit` — a shared `SAVVY-BASE` preamble that defines `pm_exec` and a `SAVVY-LINT` one-liner that runs lint-staged. It also reconciles a co-owned `SAVVY-HOOKS` hygiene section in `.husky/post-checkout` and `.husky/post-merge` that is shared with `@savvy-web/commitlint`. `--force` resets only the pre-commit hook and the lint-staged config file; the hygiene hooks are always reconciled in place because they are co-owned across the Silk Suite tools.
 
-A companion Claude Code plugin is available that automatically injects code
-quality context (Biome, markdownlint, and TypeScript conventions) at session
-start.
+`check` validates each managed section independently and reports a per-section status; a stale or missing section degrades the overall verdict even when the hook file is present.
+
+## Claude Code plugin
+
+A companion Claude Code plugin is available that automatically injects code quality context (Biome, markdownlint, and TypeScript conventions) at session start.
 
 ```bash
 # Add the Savvy Web plugin marketplace (one-time setup)
@@ -111,17 +112,16 @@ start.
 
 ## 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`, `check`, and `fmt`
-- [Utilities](../docs/utilities.md) -- Command, Filter, and advanced utilities
-- [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`, `check`, and `fmt`.
+- [Utilities](../docs/utilities.md) — `Command`, `Filter`, and advanced utilities.
+- [Migration guide](../docs/migration.md) — Migrating from raw lint-staged configs.
 
 ## Contributing
 
-Contributions welcome! See [CONTRIBUTING.md](../CONTRIBUTING.md) for setup
-and guidelines.
+Contributions welcome. See [CONTRIBUTING.md](../CONTRIBUTING.md) for setup and guidelines.
 
 ## License
 
-[MIT](./LICENSE)
+[MIT](LICENSE)

package/index.d.ts

@@ -169,6 +169,9 @@ export declare interface BiomeOptions extends BaseHandlerOptions {
  *
  * @remarks
  * Validates the current lint-staged setup and displays detected settings.
+ * Validates the `savvy-base` and `savvy-lint` sections in the pre-commit hook and the
+ * co-owned `savvy-hooks` hygiene section in `post-checkout` / `post-merge`. Section
+ * health degrades the overall verdict even if files exist.
  * With --quiet flag, only outputs warnings (for postinstall usage).
  */
 export declare const checkCommand: Command_2.Command<"check", ConfigDiscovery | FileSystem.FileSystem | ManagedSection | ToolDiscovery, JsoncParseError | SectionParseError | PlatformError, {
@@ -546,14 +549,18 @@ export declare abstract class Handler {
  * Init command implementation.
  *
  * @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
- * the savvy-lint section without them being overwritten on updates.
+ * Writes:
+ * - `.husky/pre-commit` — `savvy-base` preamble + `savvy-lint` tool section, in order
+ *   (via `ManagedSection.syncMany`).
+ * - `.husky/post-checkout` and `.husky/post-merge` — co-owned `savvy-hooks` hygiene
+ *   (idempotent, shared with `@savvy-web/commitlint`). Migrates legacy `SAVVY-LINT`
+ *   hygiene blocks by removing them before writing the new section.
+ * - `.markdownlint-cli2.jsonc` config (when preset includes Markdown).
+ * - lint-staged config at the specified path.
+ *
+ * Users may add custom commands above, below, or between the managed sections.
+ * `--force` resets only the pre-commit hook and the config file; the hygiene sections
+ * are always reconciled with `sync`.
  */
 export declare const initCommand: Command_2.Command<"init", BiomeSchemaSync | FileSystem.FileSystem | ManagedSection, Error | JsoncModificationError | JsoncParseError | SectionWriteError | PlatformError, {
     readonly force: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@savvy-web/lint-staged",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "private": false,
   "description": "Composable, configurable lint-staged handlers for pre-commit hooks. Provides reusable handlers for Biome, Markdown, YAML, TypeScript, and more.",
   "keywords": [
@@ -44,24 +44,24 @@
     "@effect/cli": "^0.75.1",
     "@effect/platform": "^0.96.1",
     "@effect/platform-node": "^0.106.0",
-    "@savvy-web/silk-effects": "^0.3.0",
+    "@savvy-web/silk-effects": "^0.5.0",
     "effect": "^3.21.2",
     "jsonc-effect": "^0.2.1",
     "prettier": "^3.8.3",
     "sort-package-json": "^3.6.1",
-    "workspaces-effect": "^1.0.0",
+    "workspaces-effect": "^1.1.0",
     "yaml": "^2.9.0",
     "yaml-lint": "^1.7.0"
   },
   "peerDependencies": {
-    "@biomejs/biome": "2.4.15",
+    "@biomejs/biome": "2.4.16",
     "@types/node": "^25.6.0",
     "@typescript/native-preview": "^7.0.0-dev.20260513.1",
     "husky": "^9.1.7",
     "lint-staged": "^17.0.5",
     "markdownlint-cli2": "^0.22.1",
     "markdownlint-cli2-formatter-codequality": "^0.0.7",
-    "turbo": "^2.9.14",
+    "turbo": "^2.9.16",
     "typescript": "^6.0.0"
   },
   "peerDependenciesMeta": {