@savvy-web/lint-staged 0.8.0 → 1.0.0

package/index.js

@@ -1,60 +1,7 @@
-import typescript from "typescript";
-import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import sort_package_json from "sort-package-json";
-import { dirname, isAbsolute, join, normalize, relative, resolve } from "node:path";
-import parser from "@typescript-eslint/parser";
-import { ESLint } from "eslint";
-import eslint_plugin_tsdoc from "eslint-plugin-tsdoc";
-import { parse } from "yaml";
-import { Command as Command_Command, Yaml, PnpmWorkspace, Filter } from "./878.js";
-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 handler = Biome.create();
-    static findBiome() {
-        const result = Command_Command.findTool("biome");
-        return result.command;
-    }
-    static isAvailable() {
-        return Command_Command.findTool("biome").available;
-    }
-    static findConfig() {
-        for (const name of [
-            "biome.jsonc",
-            "biome.json"
-        ]){
-            const libPath = `lib/configs/${name}`;
-            if (existsSync(libPath)) return libPath;
-            if (existsSync(name)) return name;
-        }
-    }
-    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;
-        };
-    }
-}
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { Filter, Command as Command_Command, isWorkspacePackagePath, Biome, PnpmWorkspace, Yaml, getWorkspaceRoot } from "./878.js";
 class Markdown {
     static glob = "**/*.{md,mdx}";
     static defaultExcludes = [];
@@ -67,6 +14,7 @@ class Markdown {
         return Command_Command.findTool("markdownlint-cli2").available;
     }
     static findConfig() {
+        const root = getWorkspaceRoot() ?? process.cwd();
         const filenames = [
             ".markdownlint-cli2.jsonc",
             ".markdownlint-cli2.json",
@@ -77,9 +25,10 @@ class Markdown {
             ".markdownlint.yaml"
         ];
         for (const name of filenames){
-            const libPath = `lib/configs/${name}`;
+            const libPath = join(root, "lib/configs", name);
             if (existsSync(libPath)) return libPath;
-            if (existsSync(name)) return name;
+            const rootPath = join(root, name);
+            if (existsSync(rootPath)) return rootPath;
         }
     }
     static create(options = {}) {
@@ -112,12 +61,18 @@ class PackageJson {
         "__fixtures__"
     ];
     static handler = PackageJson.create();
+    static filterToWorkspaceRoots(filenames, excludes) {
+        const excluded = Filter.exclude(filenames, [
+            ...excludes
+        ]);
+        return excluded.filter((f)=>isWorkspacePackagePath(f));
+    }
     static fmtCommand(options = {}) {
         const excludes = options.exclude ?? [
             ...PackageJson.defaultExcludes
         ];
         return (filenames)=>{
-            const filtered = Filter.exclude(filenames, excludes);
+            const filtered = PackageJson.filterToWorkspaceRoots(filenames, excludes);
             if (0 === filtered.length) return [];
             const cmd = Command_Command.findSavvyLint();
             return `${cmd} fmt package-json ${Filter.shellEscape(filtered)}`;
@@ -130,7 +85,7 @@ class PackageJson {
         const skipSort = options.skipSort ?? false;
         const skipFormat = options.skipFormat ?? false;
         return (filenames)=>{
-            const filtered = Filter.exclude(filenames, excludes);
+            const filtered = PackageJson.filterToWorkspaceRoots(filenames, excludes);
             if (0 === filtered.length) return [];
             if (!skipSort) for (const filepath of filtered){
                 const content = readFileSync(filepath, "utf-8");
@@ -163,524 +118,9 @@ class ShellScripts {
         };
     }
 }
-class TsDocLinter {
-    eslint;
-    constructor(options = {}){
-        const ignorePatterns = options.ignorePatterns ?? [];
-        const config = [
-            {
-                ignores: [
-                    "**/node_modules/**",
-                    "**/dist/**",
-                    "**/coverage/**",
-                    ...ignorePatterns
-                ]
-            },
-            {
-                files: [
-                    "**/*.ts",
-                    "**/*.tsx",
-                    "**/*.mts",
-                    "**/*.cts"
-                ],
-                languageOptions: {
-                    parser: parser
-                },
-                plugins: {
-                    tsdoc: eslint_plugin_tsdoc
-                },
-                rules: {
-                    "tsdoc/syntax": "error"
-                }
-            }
-        ];
-        this.eslint = new ESLint({
-            overrideConfigFile: true,
-            overrideConfig: config
-        });
-    }
-    async lintFiles(filePaths) {
-        if (0 === filePaths.length) return [];
-        const results = await this.eslint.lintFiles(filePaths);
-        return results.map((result)=>({
-                filePath: result.filePath,
-                errorCount: result.errorCount,
-                warningCount: result.warningCount,
-                messages: result.messages.map((msg)=>({
-                        line: msg.line,
-                        column: msg.column,
-                        severity: msg.severity,
-                        message: msg.message,
-                        ruleId: msg.ruleId
-                    }))
-            }));
-    }
-    async lintFilesAndThrow(filePaths) {
-        const results = await this.lintFiles(filePaths);
-        const errors = [];
-        for (const result of results)if (result.errorCount > 0) {
-            for (const msg of result.messages)if (2 === msg.severity) errors.push(`${result.filePath}:${msg.line}:${msg.column} - ${msg.message}`);
-        }
-        if (errors.length > 0) throw new Error(`TSDoc validation failed:\n${errors.join("\n")}`);
-    }
-    static formatResults(results) {
-        const lines = [];
-        for (const result of results)if (0 !== result.errorCount || 0 !== result.warningCount) {
-            lines.push(`\n${result.filePath}`);
-            for (const msg of result.messages){
-                const severity = 2 === msg.severity ? "error" : "warning";
-                const rule = msg.ruleId ? ` (${msg.ruleId})` : "";
-                lines.push(`  ${msg.line}:${msg.column}  ${severity}  ${msg.message}${rule}`);
-            }
-        }
-        const totalErrors = results.reduce((sum, r)=>sum + r.errorCount, 0);
-        const totalWarnings = results.reduce((sum, r)=>sum + r.warningCount, 0);
-        if (totalErrors > 0 || totalWarnings > 0) lines.push(`\n✖ ${totalErrors} error(s), ${totalWarnings} warning(s)`);
-        return lines.join("\n");
-    }
-    static hasErrors(results) {
-        return results.some((r)=>r.errorCount > 0);
-    }
-}
-const TS_EXTENSIONS = [
-    ".ts",
-    ".tsx",
-    ".mts",
-    ".cts"
-];
-class EntryExtractor {
-    extract(packageJson) {
-        const entries = {};
-        const unresolved = [];
-        const { exports } = packageJson;
-        if (!exports) {
-            const mainEntry = packageJson.module ?? packageJson.main;
-            if (mainEntry && this.isTypeScriptFile(mainEntry)) entries["."] = mainEntry;
-            else if (mainEntry) unresolved.push(".");
-            return {
-                entries,
-                unresolved
-            };
-        }
-        if ("string" == typeof exports) {
-            if (this.isTypeScriptFile(exports)) entries["."] = exports;
-            else unresolved.push(".");
-            return {
-                entries,
-                unresolved
-            };
-        }
-        this.extractFromObject(exports, entries, unresolved, ".");
-        return {
-            entries,
-            unresolved
-        };
-    }
-    extractFromObject(obj, entries, unresolved, currentPath) {
-        for (const [key, value] of Object.entries(obj)){
-            const exportPath = key.startsWith(".") ? key : currentPath;
-            if ("string" == typeof value) {
-                if (this.isTypeScriptFile(value)) entries[exportPath] = value;
-                else if (key.startsWith(".")) unresolved.push(exportPath);
-            } else if (value && "object" == typeof value && !Array.isArray(value)) {
-                const nested = value;
-                const tsPath = this.findTypeScriptCondition(nested);
-                if (tsPath) entries[exportPath] = tsPath;
-                else if (key.startsWith(".")) this.extractFromObject(nested, entries, unresolved, exportPath);
-                else {
-                    const sourcePath = this.findSourceCondition(nested);
-                    if (sourcePath && this.isTypeScriptFile(sourcePath)) entries[exportPath] = sourcePath;
-                }
-            }
-        }
-    }
-    findTypeScriptCondition(conditions) {
-        const priorityKeys = [
-            "source",
-            "typescript",
-            "development",
-            "default"
-        ];
-        for (const key of priorityKeys){
-            const value = conditions[key];
-            if ("string" == typeof value && this.isTypeScriptFile(value)) return value;
-            if (value && "object" == typeof value) {
-                const nested = this.findTypeScriptCondition(value);
-                if (nested) return nested;
-            }
-        }
-        return null;
-    }
-    findSourceCondition(conditions) {
-        const priorityKeys = [
-            "source",
-            "import",
-            "require",
-            "default"
-        ];
-        for (const key of priorityKeys){
-            const value = conditions[key];
-            if ("string" == typeof value) return value;
-            if (value && "object" == typeof value) {
-                const nested = this.findSourceCondition(value);
-                if (nested) return nested;
-            }
-        }
-        return null;
-    }
-    isTypeScriptFile(filePath) {
-        return TS_EXTENSIONS.some((ext)=>filePath.endsWith(ext));
-    }
-}
-class ImportGraph {
-    options;
-    program = null;
-    compilerOptions = null;
-    moduleResolutionCache = null;
-    constructor(options){
-        this.options = options;
-    }
-    traceFromEntries(entryPaths) {
-        const errors = [];
-        const visited = new Set();
-        const entries = [];
-        const initResult = this.initializeProgram();
-        if (!initResult.success) return {
-            files: [],
-            entries: [],
-            errors: [
-                initResult.error
-            ]
-        };
-        for (const entryPath of entryPaths){
-            const absolutePath = this.resolveEntryPath(entryPath);
-            if (!existsSync(absolutePath)) {
-                errors.push({
-                    type: "entry_not_found",
-                    message: `Entry file not found: ${entryPath}`,
-                    path: absolutePath
-                });
-                continue;
-            }
-            entries.push(absolutePath);
-            this.traceImports(absolutePath, visited, errors);
-        }
-        const files = Array.from(visited).filter((file)=>this.isSourceFile(file));
-        return {
-            files: files.sort(),
-            entries,
-            errors
-        };
-    }
-    traceFromPackageExports(packageJsonPath) {
-        const absolutePath = this.resolveEntryPath(packageJsonPath);
-        let packageJson;
-        try {
-            if (!existsSync(absolutePath)) return {
-                files: [],
-                entries: [],
-                errors: [
-                    {
-                        type: "package_json_not_found",
-                        message: `Failed to read package.json: File not found at ${absolutePath}`,
-                        path: absolutePath
-                    }
-                ]
-            };
-            const content = readFileSync(absolutePath, "utf-8");
-            packageJson = JSON.parse(content);
-        } catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return {
-                files: [],
-                entries: [],
-                errors: [
-                    {
-                        type: "package_json_parse_error",
-                        message: `Failed to parse package.json: ${message}`,
-                        path: absolutePath
-                    }
-                ]
-            };
-        }
-        const extractor = new EntryExtractor();
-        const { entries } = extractor.extract(packageJson);
-        const packageDir = dirname(absolutePath);
-        const entryPaths = Object.values(entries).map((p)=>resolve(packageDir, p));
-        return this.traceFromEntries(entryPaths);
-    }
-    initializeProgram() {
-        if (this.program) return {
-            success: true
-        };
-        const configPath = this.findTsConfig();
-        if (!configPath) {
-            this.compilerOptions = {
-                moduleResolution: typescript.ModuleResolutionKind.NodeNext,
-                module: typescript.ModuleKind.NodeNext,
-                target: typescript.ScriptTarget.ESNext,
-                strict: true
-            };
-            this.moduleResolutionCache = typescript.createModuleResolutionCache(this.options.rootDir, (fileName)=>fileName.toLowerCase(), this.compilerOptions);
-            const host = typescript.createCompilerHost(this.compilerOptions, true);
-            host.getCurrentDirectory = ()=>this.options.rootDir;
-            this.program = typescript.createProgram([], this.compilerOptions, host);
-            return {
-                success: true
-            };
-        }
-        const configFile = typescript.readConfigFile(configPath, (path)=>readFileSync(path, "utf-8"));
-        if (configFile.error) {
-            const message = typescript.flattenDiagnosticMessageText(configFile.error.messageText, "\n");
-            return {
-                success: false,
-                error: {
-                    type: "tsconfig_read_error",
-                    message: `Failed to read tsconfig.json: ${message}`,
-                    path: configPath
-                }
-            };
-        }
-        const parsed = typescript.parseJsonConfigFileContent(configFile.config, typescript.sys, dirname(configPath));
-        if (parsed.errors.length > 0) {
-            const messages = parsed.errors.map((e)=>typescript.flattenDiagnosticMessageText(e.messageText, "\n")).join("\n");
-            return {
-                success: false,
-                error: {
-                    type: "tsconfig_parse_error",
-                    message: `Failed to parse tsconfig.json: ${messages}`,
-                    path: configPath
-                }
-            };
-        }
-        this.compilerOptions = parsed.options;
-        this.moduleResolutionCache = typescript.createModuleResolutionCache(this.options.rootDir, (fileName)=>fileName.toLowerCase(), this.compilerOptions);
-        const host = typescript.createCompilerHost(this.compilerOptions, true);
-        host.getCurrentDirectory = ()=>this.options.rootDir;
-        this.program = typescript.createProgram([], this.compilerOptions, host);
-        return {
-            success: true
-        };
-    }
-    findTsConfig() {
-        if (this.options.tsconfigPath) {
-            const customPath = isAbsolute(this.options.tsconfigPath) ? this.options.tsconfigPath : resolve(this.options.rootDir, this.options.tsconfigPath);
-            if (existsSync(customPath)) return customPath;
-            return null;
-        }
-        const configPath = typescript.findConfigFile(this.options.rootDir, (path)=>existsSync(path));
-        return configPath ?? null;
-    }
-    resolveEntryPath(entryPath) {
-        if (isAbsolute(entryPath)) return normalize(entryPath);
-        return normalize(resolve(this.options.rootDir, entryPath));
-    }
-    traceImports(filePath, visited, errors) {
-        const normalizedPath = normalize(filePath);
-        if (visited.has(normalizedPath)) return;
-        if (this.isExternalModule(normalizedPath)) return;
-        visited.add(normalizedPath);
-        let content;
-        try {
-            content = readFileSync(normalizedPath, "utf-8");
-        } catch  {
-            errors.push({
-                type: "file_read_error",
-                message: `Failed to read file: ${normalizedPath}`,
-                path: normalizedPath
-            });
-            return;
-        }
-        const sourceFile = typescript.createSourceFile(normalizedPath, content, typescript.ScriptTarget.Latest, true);
-        const imports = this.extractImports(sourceFile);
-        for (const importPath of imports){
-            const resolved = this.resolveImport(importPath, normalizedPath);
-            if (resolved) this.traceImports(resolved, visited, errors);
-        }
-    }
-    extractImports(sourceFile) {
-        const imports = [];
-        const visit = (node)=>{
-            if (typescript.isImportDeclaration(node)) {
-                const specifier = node.moduleSpecifier;
-                if (typescript.isStringLiteral(specifier)) imports.push(specifier.text);
-            } else if (typescript.isExportDeclaration(node)) {
-                const specifier = node.moduleSpecifier;
-                if (specifier && typescript.isStringLiteral(specifier)) imports.push(specifier.text);
-            } else if (typescript.isCallExpression(node)) {
-                const expression = node.expression;
-                if (expression.kind === typescript.SyntaxKind.ImportKeyword && node.arguments.length > 0) {
-                    const arg = node.arguments[0];
-                    if (arg && typescript.isStringLiteral(arg)) imports.push(arg.text);
-                }
-            }
-            typescript.forEachChild(node, visit);
-        };
-        visit(sourceFile);
-        return imports;
-    }
-    resolveImport(specifier, fromFile) {
-        if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
-            if (!this.compilerOptions?.paths || !Object.keys(this.compilerOptions.paths).length) return null;
-        }
-        if (!this.compilerOptions || !this.moduleResolutionCache) return null;
-        const resolved = typescript.resolveModuleName(specifier, fromFile, this.compilerOptions, typescript.sys, this.moduleResolutionCache);
-        if (resolved.resolvedModule) {
-            const resolvedPath = resolved.resolvedModule.resolvedFileName;
-            if (resolved.resolvedModule.isExternalLibraryImport) return null;
-            if (resolvedPath.endsWith(".d.ts")) {
-                const sourcePath = resolvedPath.replace(/\.d\.ts$/, ".ts");
-                if (existsSync(sourcePath)) return sourcePath;
-                return null;
-            }
-            return resolvedPath;
-        }
-        return null;
-    }
-    isExternalModule(filePath) {
-        return filePath.includes("/node_modules/") || filePath.includes("\\node_modules\\");
-    }
-    isSourceFile(filePath) {
-        if (!filePath.endsWith(".ts") && !filePath.endsWith(".tsx") && !filePath.endsWith(".mts") && !filePath.endsWith(".cts")) return false;
-        if (filePath.endsWith(".d.ts") || filePath.endsWith(".d.mts") || filePath.endsWith(".d.cts")) return false;
-        if (filePath.includes(".test.") || filePath.includes(".spec.")) return false;
-        if (filePath.includes("/__test__/") || filePath.includes("\\__test__\\")) return false;
-        if (filePath.includes("/__tests__/") || filePath.includes("\\__tests__\\")) return false;
-        const excludePatterns = this.options.excludePatterns ?? [];
-        for (const pattern of excludePatterns)if (filePath.includes(pattern)) return false;
-        return true;
-    }
-    static fromEntries(entryPaths, options) {
-        const graph = new ImportGraph(options);
-        return graph.traceFromEntries(entryPaths);
-    }
-    static fromPackageExports(packageJsonPath, options) {
-        const graph = new ImportGraph(options);
-        return graph.traceFromPackageExports(packageJsonPath);
-    }
-}
-function expandWorkspaceGlob(rootDir, pattern) {
-    const base = pattern.replace(/\/\*+$/, "");
-    const baseDir = resolve(rootDir, base);
-    if (!existsSync(baseDir)) return [];
-    const results = [];
-    for (const entry of readdirSync(baseDir, {
-        withFileTypes: true
-    }))if (entry.isDirectory()) {
-        const candidate = join(baseDir, entry.name);
-        if (existsSync(join(candidate, "package.json"))) results.push(candidate);
-    }
-    return results;
-}
-function detectWorkspacePackages(rootDir) {
-    const pnpmWorkspacePath = join(rootDir, "pnpm-workspace.yaml");
-    if (existsSync(pnpmWorkspacePath)) try {
-        const content = readFileSync(pnpmWorkspacePath, "utf-8");
-        const parsed = parse(content);
-        if (Array.isArray(parsed?.packages)) return parsed.packages.flatMap((pattern)=>expandWorkspaceGlob(rootDir, pattern));
-    } catch  {}
-    const rootPkgPath = join(rootDir, "package.json");
-    if (existsSync(rootPkgPath)) try {
-        const pkg = JSON.parse(readFileSync(rootPkgPath, "utf-8"));
-        const patterns = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces?.packages;
-        if (Array.isArray(patterns)) return patterns.flatMap((pattern)=>expandWorkspaceGlob(rootDir, pattern));
-    } catch  {}
-    return [];
-}
-class TsDocResolver {
-    options;
-    constructor(options){
-        this.options = options;
-    }
-    resolve() {
-        const { rootDir } = this.options;
-        const workspaces = [];
-        const repoTsdocPath = join(rootDir, "tsdoc.json");
-        const repoTsdocConfig = existsSync(repoTsdocPath) ? repoTsdocPath : void 0;
-        const workspacePaths = detectWorkspacePackages(rootDir);
-        const isMonorepo = workspacePaths.length > 1;
-        if (0 === workspacePaths.length) {
-            const result = this.resolveWorkspace(rootDir, repoTsdocConfig);
-            if (result) workspaces.push(result);
-        } else for (const workspacePath of workspacePaths){
-            const result = this.resolveWorkspace(workspacePath, repoTsdocConfig);
-            if (result) workspaces.push(result);
-        }
-        const result = {
-            workspaces,
-            isMonorepo
-        };
-        if (void 0 !== repoTsdocConfig) result.repoTsdocConfig = repoTsdocConfig;
-        return result;
-    }
-    resolveWorkspace(workspacePath, repoTsdocConfig) {
-        const packageJsonPath = join(workspacePath, "package.json");
-        if (!existsSync(packageJsonPath)) return null;
-        let packageJson;
-        try {
-            const content = readFileSync(packageJsonPath, "utf-8");
-            packageJson = JSON.parse(content);
-        } catch  {
-            return null;
-        }
-        const workspaceTsdocPath = join(workspacePath, "tsdoc.json");
-        const workspaceTsdocConfig = existsSync(workspaceTsdocPath) ? workspaceTsdocPath : void 0;
-        const tsdocConfigPath = workspaceTsdocConfig ?? repoTsdocConfig;
-        if (!tsdocConfigPath) return null;
-        if (!packageJson.exports) return null;
-        const name = packageJson.name ?? relative(this.options.rootDir, workspacePath);
-        const errors = [];
-        const graphOptions = {
-            rootDir: workspacePath
-        };
-        if (void 0 !== this.options.excludePatterns) graphOptions.excludePatterns = this.options.excludePatterns;
-        const graph = new ImportGraph(graphOptions);
-        const result = graph.traceFromPackageExports(packageJsonPath);
-        for (const error of result.errors)errors.push(error.message);
-        return {
-            name,
-            path: workspacePath,
-            tsdocConfigPath,
-            files: result.files,
-            errors
-        };
-    }
-    filterStagedFiles(stagedFiles) {
-        const result = this.resolve();
-        const output = [];
-        for (const workspace of result.workspaces){
-            const workspaceFiles = new Set(workspace.files);
-            const matchedFiles = stagedFiles.filter((f)=>workspaceFiles.has(f));
-            if (matchedFiles.length > 0) output.push({
-                files: matchedFiles,
-                tsdocConfigPath: workspace.tsdocConfigPath
-            });
-        }
-        return output;
-    }
-    needsLinting(filePath) {
-        const result = this.resolve();
-        for (const workspace of result.workspaces)if (workspace.files.includes(filePath)) return true;
-        return false;
-    }
-    getTsDocConfig(filePath) {
-        const result = this.resolve();
-        for (const workspace of result.workspaces)if (workspace.files.includes(filePath)) return workspace.tsdocConfigPath;
-    }
-    findWorkspace(filePath) {
-        const result = this.resolve();
-        for (const workspace of result.workspaces)if (filePath.startsWith(workspace.path)) return workspace;
-    }
-}
 class TypeScript {
     static glob = "*.{ts,cts,mts,tsx}";
     static defaultExcludes = [];
-    static defaultTsdocExcludes = [
-        ".test.",
-        ".spec.",
-        "__test__",
-        "__tests__"
-    ];
     static cachedCompilerResult = null;
     static detectCompiler(_cwd) {
         if (null !== TypeScript.cachedCompilerResult) return TypeScript.cachedCompilerResult.compiler;
@@ -713,57 +153,23 @@ class TypeScript {
         TypeScript.cachedCompilerResult = null;
     }
     static handler = TypeScript.create();
-    static isTsdocAvailable(cwd = process.cwd()) {
-        let dir = resolve(cwd);
-        while(true){
-            if (existsSync(join(dir, "tsdoc.json"))) return true;
-            const parent = dirname(dir);
-            if (parent === dir) break;
-            dir = parent;
-        }
-        return false;
-    }
     static create(options = {}) {
         const excludes = options.exclude ?? [
             ...TypeScript.defaultExcludes
         ];
-        const tsdocExcludes = options.excludeTsdoc ?? [
-            ...TypeScript.defaultTsdocExcludes
-        ];
-        const skipTsdoc = options.skipTsdoc ?? false;
         const skipTypecheck = options.skipTypecheck ?? false;
-        const rootDir = options.rootDir ?? Command_Command.findRoot();
         let typecheckCommand;
         const getTypecheckCommand = ()=>{
             if (void 0 === typecheckCommand) typecheckCommand = options.typecheckCommand ?? TypeScript.getDefaultTypecheckCommand();
             return typecheckCommand;
         };
-        return async (filenames)=>{
+        return (filenames)=>{
             const filtered = Filter.exclude(filenames, excludes);
             if (0 === filtered.length) return [];
-            const commands = [];
-            if (!skipTsdoc) {
-                const resolver = new TsDocResolver({
-                    rootDir,
-                    excludePatterns: [
-                        ...tsdocExcludes
-                    ]
-                });
-                const absoluteFiles = filtered.map((f)=>isAbsolute(f) ? f : join(rootDir, f));
-                const tsdocGroups = resolver.filterStagedFiles(absoluteFiles);
-                for (const group of tsdocGroups)if (group.files.length > 0) {
-                    const linter = new TsDocLinter({
-                        ignorePatterns: tsdocExcludes.map((p)=>`**/*${p}*`)
-                    });
-                    const results = await linter.lintFiles(group.files);
-                    if (TsDocLinter.hasErrors(results)) {
-                        const output = TsDocLinter.formatResults(results);
-                        throw new Error(`TSDoc validation failed:\n${output}`);
-                    }
-                }
-            }
-            if (!skipTypecheck && filtered.length > 0) commands.push(getTypecheckCommand());
-            return commands;
+            if (!skipTypecheck) return [
+                getTypecheckCommand()
+            ];
+            return [];
         };
     }
 }
@@ -888,6 +294,6 @@ class Handler {
         throw new Error("Handler.create() must be implemented by subclass");
     }
 }
-export { Command, Filter, PnpmWorkspace, Yaml, checkCommand, fmtCommand, initCommand, rootCommand, runCli } from "./878.js";
+export { Biome, Command, Filter, PnpmWorkspace, Yaml, checkCommand, fmtCommand, getWorkspacePackagePaths, getWorkspacePackages, getWorkspaceRoot, initCommand, isWorkspacePackagePath, resetWorkspaceCache, rootCommand, runCli } from "./878.js";
 export { ConfigDiscovery, ConfigDiscoveryLive } from "@savvy-web/silk-effects";
-export { Biome, EntryExtractor, Handler, ImportGraph, Markdown, PackageJson, Preset, ShellScripts, TsDocLinter, TsDocResolver, TypeScript, createConfig };
+export { Handler, Markdown, PackageJson, Preset, ShellScripts, TypeScript, createConfig };