@savvy-web/lint-staged 0.7.3 → 1.0.0

package/878.js

@@ -2,17 +2,298 @@ 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 { Effect, Layer } from "effect";
-import { PackageManagerDetectorLive, WorkspaceRootLive } from "workspaces-effect";
+import { WorkspacesLive, findWorkspaceRootSync, getWorkspacePackagesSync } from "workspaces-effect";
 import { isDeepStrictEqual } from "node:util";
 import { FileSystem } from "@effect/platform";
 import { applyEdits, modify, parse } from "jsonc-effect";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { execSync } from "node:child_process";
 import sort_package_json from "sort-package-json";
 import { parse as external_yaml_parse, stringify } from "yaml";
-import { execSync } from "node:child_process";
-import { dirname, join, resolve } from "node:path";
 import { format, resolveConfig } from "prettier";
 import { lint } from "yaml-lint";
+const VALID_COMMAND_PATTERN = /^[\w@/-]+$/;
+function validateCommandName(name) {
+    if (!VALID_COMMAND_PATTERN.test(name)) throw new Error(`Invalid command name: "${name}". Only alphanumeric characters, hyphens, underscores, @ and / are allowed.`);
+}
+class Command_Command {
+    static cachedPackageManager = null;
+    static cachedRoot = null;
+    static findRoot(cwd = process.cwd()) {
+        if (null !== Command_Command.cachedRoot) return Command_Command.cachedRoot;
+        let dir = resolve(cwd);
+        while(true){
+            if (existsSync(join(dir, "package.json"))) {
+                Command_Command.cachedRoot = dir;
+                return dir;
+            }
+            const parent = dirname(dir);
+            if (parent === dir) break;
+            dir = parent;
+        }
+        Command_Command.cachedRoot = cwd;
+        return cwd;
+    }
+    static detectPackageManager(cwd = Command_Command.findRoot()) {
+        if (null !== Command_Command.cachedPackageManager) return Command_Command.cachedPackageManager;
+        const packageJsonPath = join(cwd, "package.json");
+        if (!existsSync(packageJsonPath)) {
+            Command_Command.cachedPackageManager = "npm";
+            return "npm";
+        }
+        try {
+            const content = readFileSync(packageJsonPath, "utf-8");
+            const pkg = JSON.parse(content);
+            if (pkg.packageManager) {
+                const match = pkg.packageManager.match(/^(npm|pnpm|yarn|bun)@/);
+                if (match) {
+                    Command_Command.cachedPackageManager = match[1];
+                    return Command_Command.cachedPackageManager;
+                }
+            }
+        } catch  {}
+        Command_Command.cachedPackageManager = "npm";
+        return "npm";
+    }
+    static getExecPrefix(packageManager) {
+        switch(packageManager){
+            case "pnpm":
+                return [
+                    "pnpm",
+                    "exec"
+                ];
+            case "yarn":
+                return [
+                    "yarn",
+                    "exec"
+                ];
+            case "bun":
+                return [
+                    "bun",
+                    "x",
+                    "--no-install"
+                ];
+            default:
+                return [
+                    "npx",
+                    "--no"
+                ];
+        }
+    }
+    static clearCache() {
+        Command_Command.cachedPackageManager = null;
+        Command_Command.cachedRoot = null;
+    }
+    static isAvailable(command) {
+        validateCommandName(command);
+        try {
+            execSync(`command -v ${command}`, {
+                stdio: "ignore"
+            });
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+    static findTool(tool) {
+        validateCommandName(tool);
+        if (Command_Command.isAvailable(tool)) return {
+            available: true,
+            command: tool,
+            source: "global"
+        };
+        const pm = Command_Command.detectPackageManager();
+        const prefix = Command_Command.getExecPrefix(pm);
+        const execCmd = [
+            ...prefix,
+            tool
+        ].join(" ");
+        try {
+            execSync(`${execCmd} --version`, {
+                stdio: "ignore"
+            });
+            return {
+                available: true,
+                command: execCmd,
+                source: pm
+            };
+        } catch  {}
+        return {
+            available: false,
+            command: void 0,
+            source: void 0
+        };
+    }
+    static requireTool(tool, errorMessage) {
+        const result = Command_Command.findTool(tool);
+        if (!result.available || !result.command) throw new Error(errorMessage ?? `Required tool '${tool}' is not available. Install it globally or add it as a dev dependency.`);
+        return result.command;
+    }
+    static findSavvyLint() {
+        const result = Command_Command.findTool("savvy-lint");
+        if (result.available && result.command) return result.command;
+        const root = Command_Command.findRoot();
+        return `node ${root}/dist/dev/bin/savvy-lint.js`;
+    }
+    static exec(command) {
+        return execSync(command, {
+            encoding: "utf-8"
+        }).trim();
+    }
+    static execSilent(command) {
+        try {
+            execSync(command, {
+                stdio: "ignore"
+            });
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+}
+class Filter {
+    static exclude(filenames, patterns) {
+        if (0 === patterns.length) return [
+            ...filenames
+        ];
+        return filenames.filter((file)=>!patterns.some((pattern)=>file.includes(pattern)));
+    }
+    static include(filenames, patterns) {
+        if (0 === patterns.length) return [];
+        return filenames.filter((file)=>patterns.some((pattern)=>file.includes(pattern)));
+    }
+    static apply(filenames, options) {
+        let result = [
+            ...filenames
+        ];
+        if (options.include && options.include.length > 0) result = Filter.include(result, options.include);
+        if (options.exclude && options.exclude.length > 0) result = Filter.exclude(result, options.exclude);
+        return result;
+    }
+    static shellEscape(filenames) {
+        return filenames.map((f)=>`'${f.replace(/'/g, "'\\''")}'`).join(" ");
+    }
+}
+const UNRESOLVED = Symbol("unresolved");
+let cachedRoot = UNRESOLVED;
+let cachedPackages = UNRESOLVED;
+let cachedPaths = UNRESOLVED;
+function getWorkspaceRoot() {
+    if (cachedRoot !== UNRESOLVED) return cachedRoot;
+    cachedRoot = findWorkspaceRootSync() ?? null;
+    return cachedRoot;
+}
+function getWorkspacePackages() {
+    if (cachedPackages !== UNRESOLVED) return cachedPackages;
+    const root = getWorkspaceRoot();
+    if (null === root) {
+        cachedPackages = null;
+        return null;
+    }
+    const all = getWorkspacePackagesSync(root) ?? [];
+    cachedPackages = all.filter((pkg)=>pkg.path !== root);
+    return cachedPackages;
+}
+function getWorkspacePackagePaths() {
+    if (cachedPaths !== UNRESOLVED) return cachedPaths;
+    const packages = getWorkspacePackages();
+    cachedPaths = packages?.map((pkg)=>pkg.path) ?? [];
+    return cachedPaths;
+}
+function isWorkspacePackagePath(filePath) {
+    const root = getWorkspaceRoot();
+    if (null === root) return true;
+    const dir = dirname(filePath);
+    if (dir === root) return true;
+    const packagePaths = getWorkspacePackagePaths();
+    return packagePaths.includes(dir);
+}
+function resetWorkspaceCache() {
+    cachedRoot = UNRESOLVED;
+    cachedPackages = UNRESOLVED;
+    cachedPaths = UNRESOLVED;
+}
+class Biome {
+    static glob = "*.{js,ts,cjs,mjs,d.cts,d.mts,jsx,tsx,json,jsonc}";
+    static defaultExcludes = [
+        "package.json",
+        "package-lock.json",
+        "__fixtures__",
+        "__test__/fixtures"
+    ];
+    static CONFIG_NAMES = [
+        "biome.jsonc",
+        "biome.json"
+    ];
+    static handler = Biome.create();
+    static findBiome() {
+        const result = Command_Command.findTool("biome");
+        return result.command;
+    }
+    static isAvailable() {
+        return Command_Command.findTool("biome").available;
+    }
+    static findConfig() {
+        const root = getWorkspaceRoot();
+        const searchDir = root ?? process.cwd();
+        for (const name of Biome.CONFIG_NAMES){
+            const fullPath = join(searchDir, name);
+            if (existsSync(fullPath)) return fullPath;
+        }
+    }
+    static findAllConfigs() {
+        const root = getWorkspaceRoot();
+        const configs = [];
+        if (null === root) {
+            const cwd = process.cwd();
+            for (const name of Biome.CONFIG_NAMES){
+                const fullPath = join(cwd, name);
+                if (existsSync(fullPath)) {
+                    configs.push(fullPath);
+                    break;
+                }
+            }
+            return configs;
+        }
+        for (const name of Biome.CONFIG_NAMES){
+            const fullPath = join(root, name);
+            if (existsSync(fullPath)) {
+                configs.push(fullPath);
+                break;
+            }
+        }
+        for (const pkgPath of getWorkspacePackagePaths())for (const name of Biome.CONFIG_NAMES){
+            const fullPath = join(pkgPath, name);
+            if (existsSync(fullPath)) {
+                configs.push(fullPath);
+                break;
+            }
+        }
+        return configs;
+    }
+    static create(options = {}) {
+        const excludes = options.exclude ?? [
+            ...Biome.defaultExcludes
+        ];
+        const config = options.config ?? Biome.findConfig();
+        return (filenames)=>{
+            const filtered = Filter.exclude(filenames, excludes);
+            if (0 === filtered.length) return [];
+            const biomeCmd = Command_Command.requireTool("biome", "Biome is not available. Install it globally (recommended) or add @biomejs/biome as a dev dependency.");
+            const files = Filter.shellEscape(filtered);
+            const flags = options.flags ?? [];
+            const configFlag = config ? `--config-path=${config}` : "";
+            const cmd = [
+                `${biomeCmd} check --write --no-errors-on-unmatched`,
+                configFlag,
+                ...flags,
+                files
+            ].filter(Boolean).join(" ");
+            return cmd;
+        };
+    }
+}
 const HUSKY_HOOK_PATH = ".husky/pre-commit";
 const POST_CHECKOUT_HOOK_PATH = ".husky/post-checkout";
 const POST_MERGE_HOOK_PATH = ".husky/post-merge";
@@ -373,25 +654,31 @@ function checkMarkdownlintConfig(content) {
 }
 function checkBiomeSchemas() {
     return Effect.gen(function*() {
-        const version = "2.4.9";
+        const version = "2.4.12";
         const statuses = [];
         if (!version) return {
             statuses,
             warnings: []
         };
-        const syncer = yield* BiomeSchemaSync;
-        const result = yield* syncer.check(version);
+        const fs = yield* FileSystem.FileSystem;
         const warnings = [];
-        for (const configPath of result.current)statuses.push({
-            path: configPath,
-            matches: true
-        });
-        for (const configPath of result.updated){
-            statuses.push({
+        const expectedSchema = `https://biomejs.dev/schemas/${version}/schema.json`;
+        const configPaths = Biome.findAllConfigs();
+        for (const configPath of configPaths){
+            const content = yield* fs.readFileString(configPath);
+            const parsed = yield* parse(content);
+            const currentSchema = parsed.$schema;
+            if (currentSchema === expectedSchema) statuses.push({
                 path: configPath,
-                matches: false
+                matches: true
             });
-            warnings.push(`${WARNING}  ${configPath}: biome $schema is outdated.\n   Run 'savvy-lint init' to update it.`);
+            else {
+                statuses.push({
+                    path: configPath,
+                    matches: false
+                });
+                warnings.push(`${WARNING}  ${configPath}: biome $schema is outdated.\n   Run 'savvy-lint init' to update it.`);
+            }
         }
         return {
             statuses,
@@ -438,7 +725,7 @@ const checkCommand = Command.make("check", {
                 if (status.found && status.needsUpdate) warnings.push(`${WARNING}  Your ${hookPath} managed section is outdated.\n   Run 'savvy-lint init' to update it (preserves your custom hooks).`);
             }
         }
-        const biomeSchemaStatus = yield* checkBiomeSchemas().pipe(Effect.catchTag("BiomeSyncError", ()=>Effect.succeed({
+        const biomeSchemaStatus = yield* checkBiomeSchemas().pipe(Effect.catchAll(()=>Effect.succeed({
                 statuses: [],
                 warnings: [
                     `${WARNING}  Could not check biome $schema URLs.`
@@ -509,9 +796,6 @@ const checkCommand = Command.make("check", {
         if (tsgoAvailable) yield* Effect.log(`  ${CHECK_MARK} TypeScript (tsgo)`);
         else if (tscAvailable) yield* Effect.log(`  ${CHECK_MARK} TypeScript (tsc)`);
         else yield* Effect.log(`  ${BULLET} TypeScript: not installed`);
-        const tsdocConfig = yield* discovery.find("tsdoc.json");
-        if (tsdocConfig) yield* Effect.log(`  ${CHECK_MARK} TSDoc (tsdoc.json found)`);
-        else yield* Effect.log(`  ${BULLET} TSDoc: no tsdoc.json found`);
         if (hasMarkdownlintConfig) if (markdownlintStatus.isUpToDate) yield* Effect.log(`  ${CHECK_MARK} ${MARKDOWNLINT_CONFIG_PATH}: up-to-date`);
         else {
             const issues = [];
@@ -530,145 +814,6 @@ const checkCommand = Command.make("check", {
         if (hasIssues) yield* Effect.log(`${WARNING} Some issues found. Run 'savvy-lint init' to fix.`);
         else yield* Effect.log(`${CHECK_MARK} Lint-staged is configured correctly.`);
     })).pipe(Command.withDescription("Check current lint-staged configuration and tool availability"));
-const VALID_COMMAND_PATTERN = /^[\w@/-]+$/;
-function validateCommandName(name) {
-    if (!VALID_COMMAND_PATTERN.test(name)) throw new Error(`Invalid command name: "${name}". Only alphanumeric characters, hyphens, underscores, @ and / are allowed.`);
-}
-class Command_Command {
-    static cachedPackageManager = null;
-    static cachedRoot = null;
-    static findRoot(cwd = process.cwd()) {
-        if (null !== Command_Command.cachedRoot) return Command_Command.cachedRoot;
-        let dir = resolve(cwd);
-        while(true){
-            if (existsSync(join(dir, "package.json"))) {
-                Command_Command.cachedRoot = dir;
-                return dir;
-            }
-            const parent = dirname(dir);
-            if (parent === dir) break;
-            dir = parent;
-        }
-        Command_Command.cachedRoot = cwd;
-        return cwd;
-    }
-    static detectPackageManager(cwd = Command_Command.findRoot()) {
-        if (null !== Command_Command.cachedPackageManager) return Command_Command.cachedPackageManager;
-        const packageJsonPath = join(cwd, "package.json");
-        if (!existsSync(packageJsonPath)) {
-            Command_Command.cachedPackageManager = "npm";
-            return "npm";
-        }
-        try {
-            const content = readFileSync(packageJsonPath, "utf-8");
-            const pkg = JSON.parse(content);
-            if (pkg.packageManager) {
-                const match = pkg.packageManager.match(/^(npm|pnpm|yarn|bun)@/);
-                if (match) {
-                    Command_Command.cachedPackageManager = match[1];
-                    return Command_Command.cachedPackageManager;
-                }
-            }
-        } catch  {}
-        Command_Command.cachedPackageManager = "npm";
-        return "npm";
-    }
-    static getExecPrefix(packageManager) {
-        switch(packageManager){
-            case "pnpm":
-                return [
-                    "pnpm",
-                    "exec"
-                ];
-            case "yarn":
-                return [
-                    "yarn",
-                    "exec"
-                ];
-            case "bun":
-                return [
-                    "bun",
-                    "x",
-                    "--no-install"
-                ];
-            default:
-                return [
-                    "npx",
-                    "--no"
-                ];
-        }
-    }
-    static clearCache() {
-        Command_Command.cachedPackageManager = null;
-        Command_Command.cachedRoot = null;
-    }
-    static isAvailable(command) {
-        validateCommandName(command);
-        try {
-            execSync(`command -v ${command}`, {
-                stdio: "ignore"
-            });
-            return true;
-        } catch  {
-            return false;
-        }
-    }
-    static findTool(tool) {
-        validateCommandName(tool);
-        if (Command_Command.isAvailable(tool)) return {
-            available: true,
-            command: tool,
-            source: "global"
-        };
-        const pm = Command_Command.detectPackageManager();
-        const prefix = Command_Command.getExecPrefix(pm);
-        const execCmd = [
-            ...prefix,
-            tool
-        ].join(" ");
-        try {
-            execSync(`${execCmd} --version`, {
-                stdio: "ignore"
-            });
-            return {
-                available: true,
-                command: execCmd,
-                source: pm
-            };
-        } catch  {}
-        return {
-            available: false,
-            command: void 0,
-            source: void 0
-        };
-    }
-    static requireTool(tool, errorMessage) {
-        const result = Command_Command.findTool(tool);
-        if (!result.available || !result.command) throw new Error(errorMessage ?? `Required tool '${tool}' is not available. Install it globally or add it as a dev dependency.`);
-        return result.command;
-    }
-    static findSavvyLint() {
-        const result = Command_Command.findTool("savvy-lint");
-        if (result.available && result.command) return result.command;
-        const root = Command_Command.findRoot();
-        return `node ${root}/dist/dev/bin/savvy-lint.js`;
-    }
-    static exec(command) {
-        return execSync(command, {
-            encoding: "utf-8"
-        }).trim();
-    }
-    static execSilent(command) {
-        try {
-            execSync(command, {
-                stdio: "ignore"
-            });
-            return true;
-        } catch  {
-            return false;
-        }
-    }
-}
 const DEFAULT_STRINGIFY_OPTIONS = {
     indent: 2,
     lineWidth: 0,
@@ -730,29 +875,6 @@ class PnpmWorkspace {
         };
     }
 }
-class Filter {
-    static exclude(filenames, patterns) {
-        if (0 === patterns.length) return [
-            ...filenames
-        ];
-        return filenames.filter((file)=>!patterns.some((pattern)=>file.includes(pattern)));
-    }
-    static include(filenames, patterns) {
-        if (0 === patterns.length) return [];
-        return filenames.filter((file)=>patterns.some((pattern)=>file.includes(pattern)));
-    }
-    static apply(filenames, options) {
-        let result = [
-            ...filenames
-        ];
-        if (options.include && options.include.length > 0) result = Filter.include(result, options.include);
-        if (options.exclude && options.exclude.length > 0) result = Filter.exclude(result, options.exclude);
-        return result;
-    }
-    static shellEscape(filenames) {
-        return filenames.map((f)=>`'${f.replace(/'/g, "'\\''")}'`).join(" ");
-    }
-}
 class Yaml {
     static glob = "**/*.{yml,yaml}";
     static defaultExcludes = [
@@ -762,9 +884,11 @@ class Yaml {
     ];
     static handler = Yaml.create();
     static findConfig() {
-        const libPath = "lib/configs/.yaml-lint.json";
+        const root = getWorkspaceRoot() ?? process.cwd();
+        const libPath = join(root, "lib/configs/.yaml-lint.json");
         if (existsSync(libPath)) return libPath;
-        if (existsSync(".yaml-lint.json")) return ".yaml-lint.json";
+        const rootPath = join(root, ".yaml-lint.json");
+        if (existsSync(rootPath)) return rootPath;
     }
     static loadConfig(filepath) {
         try {
@@ -935,7 +1059,7 @@ function writeMarkdownlintConfig(fs, preset, force) {
 }
 function syncBiomeSchemas() {
     return Effect.gen(function*() {
-        const version = "2.4.9";
+        const version = "2.4.12";
         if (!version) return;
         const syncer = yield* BiomeSchemaSync;
         const result = yield* syncer.sync(version);
@@ -1003,9 +1127,8 @@ const initCommand = Command.make("init", {
         }
         yield* Effect.log("\nDone! Lint-staged is ready to use.");
     })).pipe(Command.withDescription("Initialize lint-staged configuration and husky hooks"));
-const WorkspaceLive = Layer.mergeAll(PackageManagerDetectorLive, WorkspaceRootLive);
 const SilkLive = Layer.mergeAll(ManagedSectionLive, BiomeSchemaSyncLive, ConfigDiscoveryLive, ToolDiscoveryLive);
-const AppLayer = SilkLive.pipe(Layer.provideMerge(WorkspaceLive), Layer.provideMerge(NodeContext.layer));
+const AppLayer = SilkLive.pipe(Layer.provideMerge(WorkspacesLive), Layer.provideMerge(NodeContext.layer));
 const rootCommand = Command.make("savvy-lint").pipe(Command.withSubcommands([
     initCommand,
     checkCommand,
@@ -1013,10 +1136,10 @@ const rootCommand = Command.make("savvy-lint").pipe(Command.withSubcommands([
 ]));
 const cli = Command.run(rootCommand, {
     name: "savvy-lint",
-    version: "0.7.3"
+    version: "1.0.0"
 });
 function runCli() {
     const main = Effect.suspend(()=>cli(process.argv)).pipe(Effect.provide(AppLayer));
     NodeRuntime.runMain(main);
 }
-export { Command_Command as Command, Filter, PnpmWorkspace, Yaml, checkCommand, fmtCommand, initCommand, rootCommand, runCli };
+export { Biome, Command_Command as Command, Filter, PnpmWorkspace, Yaml, checkCommand, fmtCommand, getWorkspacePackagePaths, getWorkspacePackages, getWorkspaceRoot, initCommand, isWorkspacePackagePath, resetWorkspaceCache, rootCommand, runCli };

package/README.md

@@ -13,9 +13,9 @@ sensible defaults and easy customization.
 - 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
+- Workspace-aware config discovery anchored to workspace root
 - Shareable Biome configuration via `@savvy-web/lint-staged/biome/silk.jsonc`
-- Static class API with excellent TypeScript and TSDoc support
+- Static class API with excellent TypeScript support
 
 ## Installation
 
@@ -79,7 +79,7 @@ export default {
 | `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 |
+| `TypeScript` | `*.{ts,cts,mts,tsx}` | Type checking (tsgo/tsc) |
 
 ## CLI
 

package/biome/silk.jsonc

@@ -1,5 +1,5 @@
 {
-	"$schema": "https://biomejs.dev/schemas/2.4.5/schema.json",
+	"$schema": "https://biomejs.dev/schemas/2.4.12/schema.json",
 	"assist": {
 		"actions": {
 			"source": {
@@ -133,9 +133,12 @@
 			"!**/.vitest",
 			"!**/.coverage",
 			"!coverage",
+			"!**/__test__/fixtures",
+			"!**/__test__/snapshots",
 			"!**/__test__/**/fixtures",
 			"!**/__test__/**/snapshots",
-			"!**/__fixtures__"
+			"!**/__fixtures__",
+			"!**/__snapshots__"
 		]
 	}
 }