knip 5.63.0 → 5.63.1

package/dist/graph/build.d.ts

@@ -4,33 +4,19 @@ import type { DependencyDeputy } from '../DependencyDeputy.js';
 import type { IssueCollector } from '../IssueCollector.js';
 import type { PrincipalFactory } from '../PrincipalFactory.js';
 import type { ProjectPrincipal } from '../ProjectPrincipal.js';
-import type { Tags } from '../types/cli.js';
-import type { Report } from '../types/issues.js';
 import type { ModuleGraph } from '../types/module-graph.js';
+import type { MainOptions } from '../util/create-options.js';
 interface BuildOptions {
-    cacheLocation: string;
     chief: ConfigurationChief;
     collector: IssueCollector;
-    cwd: string;
     deputy: DependencyDeputy;
     factory: PrincipalFactory;
-    gitignore: boolean;
-    isCache: boolean;
-    isFixExports: boolean;
-    isFixTypes: boolean;
     isGitIgnored: (path: string) => boolean;
-    isIsolateWorkspaces: boolean;
-    isProduction: boolean;
-    isSkipLibs: boolean;
-    isStrict: boolean;
-    isWatch: boolean;
-    report: Report;
     streamer: ConsoleStreamer;
-    tags: Tags;
-    tsConfigFile?: string;
     workspaces: Workspace[];
+    options: MainOptions;
 }
-export declare function build({ cacheLocation, chief, collector, cwd, deputy, factory, gitignore, isCache, isFixExports, isFixTypes, isGitIgnored, isIsolateWorkspaces, isProduction, isSkipLibs, isStrict, isWatch, report, streamer, tags, tsConfigFile, workspaces, }: BuildOptions): Promise<{
+export declare function build({ chief, collector, deputy, factory, isGitIgnored, streamer, workspaces, options, }: BuildOptions): Promise<{
     graph: ModuleGraph;
     entryPaths: Set<string>;
     analyzedFiles: Set<string>;

package/dist/graph/build.js

@@ -13,19 +13,26 @@ import { getPackageNameFromModuleSpecifier, isStartsLikePackageName, sanitizeSpe
 import { getEntrySpecifiersFromManifest, getManifestImportDependencies } from '../util/package-json.js';
 import { dirname, extname, isAbsolute, join, relative, toRelative } from '../util/path.js';
 import { augmentWorkspace, getToSourcePathHandler, getToSourcePathsHandler } from '../util/to-source-path.js';
-export async function build({ cacheLocation, chief, collector, cwd, deputy, factory, gitignore, isCache, isFixExports, isFixTypes, isGitIgnored, isIsolateWorkspaces, isProduction, isSkipLibs, isStrict, isWatch, report, streamer, tags, tsConfigFile, workspaces, }) {
+export async function build({ chief, collector, deputy, factory, isGitIgnored, streamer, workspaces, options, }) {
     const configFilesMap = new Map();
     const enabledPluginsStore = new Map();
     const toSourceFilePath = getToSourcePathHandler(chief);
     const toSourceFilePaths = getToSourcePathsHandler(chief);
     const getReferencedInternalFilePath = getReferencedInputsHandler(collector, deputy, chief, isGitIgnored);
-    const isReportClassMembers = report.classMembers;
     for (const workspace of workspaces) {
         const { name, dir, manifestPath, manifestStr } = workspace;
         const manifest = chief.getManifestForWorkspace(name);
         if (!manifest)
             continue;
-        deputy.addWorkspace({ name, cwd, dir, manifestPath, manifestStr, manifest, ...chief.getIgnores(name) });
+        deputy.addWorkspace({
+            name,
+            cwd: options.cwd,
+            dir,
+            manifestPath,
+            manifestStr,
+            manifest,
+            ...chief.getIgnores(name),
+        });
     }
     for (const workspace of workspaces) {
         const { name, dir, ancestors, pkgName, manifestPath: filePath } = workspace;
@@ -38,29 +45,25 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
         const extensions = getCompilerExtensions(compilers);
         const extensionGlobStr = `.{${[...DEFAULT_EXTENSIONS, ...extensions].map(ext => ext.slice(1)).join(',')}}`;
         const config = chief.getConfigForWorkspace(name, extensions);
-        const tsConfigFilePath = join(dir, tsConfigFile ?? 'tsconfig.json');
+        const tsConfigFilePath = join(dir, options.tsConfigFile ?? 'tsconfig.json');
         const { isFile, compilerOptions, definitionPaths } = await loadTSConfig(tsConfigFilePath);
         if (isFile)
             augmentWorkspace(workspace, dir, compilerOptions);
         const worker = new WorkspaceWorker({
             name,
             dir,
-            cwd,
             config,
             manifest,
             dependencies,
             getReferencedInternalFilePath: (input) => getReferencedInternalFilePath(input, workspace),
             findWorkspaceByFilePath: chief.findWorkspaceByFilePath.bind(chief),
-            isProduction,
-            isStrict,
             rootIgnore: chief.config.ignore,
             negatedWorkspacePatterns: chief.getNegatedWorkspacePatterns(name),
             ignoredWorkspacePatterns: chief.getIgnoredWorkspacesFor(name),
             enabledPluginsInAncestors: ancestors.flatMap(ancestor => enabledPluginsStore.get(ancestor) ?? []),
             getSourceFile: (filePath) => principal.backend.fileManager.getSourceFile(filePath),
-            isCache,
-            cacheLocation,
             configFilesMap,
+            options,
         });
         await worker.init();
         const inputs = new Set();
@@ -70,8 +73,8 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
                 inputs.add(toProductionEntry(id, { containingFilePath: tsConfigFilePath }));
         }
         const ignore = worker.getIgnorePatterns();
-        const sharedGlobOptions = { cwd, dir, gitignore };
-        collector.addIgnorePatterns(ignore.map(pattern => join(cwd, pattern)));
+        const sharedGlobOptions = { cwd: options.cwd, dir, gitignore: options.gitignore };
+        collector.addIgnorePatterns(ignore.map(pattern => join(options.cwd, pattern)));
         const entrySpecifiersFromManifest = getEntrySpecifiersFromManifest(manifest);
         for (const filePath of await toSourceFilePaths(entrySpecifiersFromManifest, dir, extensionGlobStr)) {
             inputs.add(toProductionEntry(filePath));
@@ -86,19 +89,13 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
         }
         for (const dep of getManifestImportDependencies(manifest))
             deputy.addReferencedDependency(name, dep);
-        const principal = factory.createPrincipal({
-            cwd: dir,
+        const principal = factory.createPrincipal(options, {
+            dir,
             isFile,
             compilerOptions,
             compilers,
             pkgName,
-            isIsolateWorkspaces,
-            isSkipLibs,
-            isWatch,
             toSourceFilePath,
-            isCache,
-            cacheLocation,
-            isProduction,
         });
         principal.addPaths(config.paths, dir);
         const inputsFromPlugins = await worker.runPlugins();
@@ -152,7 +149,7 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
                         productionPatternsSkipExports.add(resolvedFilePath);
                     }
                     else if (isDeferResolveEntry(input)) {
-                        if (!isProduction || !input.optional)
+                        if (!options.isProduction || !input.optional)
                             entryPatternsSkipExports.add(resolvedFilePath);
                     }
                     else {
@@ -161,7 +158,7 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
                 }
             }
         }
-        if (isProduction) {
+        if (options.isProduction) {
             const negatedEntryPatterns = [...entryPatterns, ...entryPatternsSkipExports].map(negate);
             {
                 const label = 'entry paths';
@@ -238,8 +235,8 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
                     principal.addProjectPath(projectPath);
             }
         }
-        if (chief.resolvedConfigFilePath) {
-            principal.addEntryPath(chief.resolvedConfigFilePath, { skipExportsAnalysis: true });
+        if (options.configFilePath) {
+            factory.getPrincipals().at(0)?.addEntryPath(options.configFilePath, { skipExportsAnalysis: true });
         }
         worker.onDispose();
     }
@@ -255,20 +252,20 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
         if (workspace)
             return factory.getPrincipalByPackageName(workspace.pkgName);
     };
+    const analyzeOpts = {
+        isFixExports: options.isFixUnusedExports,
+        isFixTypes: options.isFixUnusedTypes,
+        isReportClassMembers: options.isReportClassMembers,
+        skipTypeOnly: options.isStrict,
+        tags: options.tags,
+    };
     const analyzeSourceFile = (filePath, principal) => {
-        if (!isWatch && analyzedFiles.has(filePath))
+        if (!options.isWatch && analyzedFiles.has(filePath))
             return;
         analyzedFiles.add(filePath);
         const workspace = chief.findWorkspaceByFilePath(filePath);
         if (workspace) {
-            const file = principal.analyzeSourceFile(filePath, {
-                skipTypeOnly: isStrict,
-                isFixExports,
-                isFixTypes,
-                ignoreExportsUsedInFile: chief.config.ignoreExportsUsedInFile,
-                isReportClassMembers,
-                tags,
-            });
+            const file = principal.analyzeSourceFile(filePath, analyzeOpts, chief.config.ignoreExportsUsedInFile);
             const _unresolved = new Set();
             for (const unresolvedImport of file.imports.unresolved) {
                 const { specifier } = unresolvedImport;
@@ -307,8 +304,14 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
                 const dependencies = deputy.getDependencies(workspace.name);
                 const manifestScriptNames = new Set(Object.keys(chief.getManifestForWorkspace(workspace.name)?.scripts ?? {}));
                 const dir = dirname(filePath);
-                const options = { cwd: dir, rootCwd: cwd, containingFilePath: filePath, dependencies, manifestScriptNames };
-                const inputs = _getInputsFromScripts(file.scripts, options);
+                const opts = {
+                    cwd: dir,
+                    rootCwd: options.cwd,
+                    containingFilePath: filePath,
+                    dependencies,
+                    manifestScriptNames,
+                };
+                const inputs = _getInputsFromScripts(file.scripts, opts);
                 for (const input of inputs) {
                     input.containingFilePath ??= filePath;
                     input.dir ??= dir;
@@ -334,7 +337,7 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
             streamer.cast('Running async compilers');
             await principal.runAsyncCompilers();
         }
-        streamer.cast('Analyzing source files', toRelative(principal.cwd));
+        streamer.cast('Analyzing source files', toRelative(principal.cwd, options.cwd));
         let size = principal.entryPaths.size;
         let round = 0;
         do {
@@ -350,16 +353,16 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
         for (const filePath of principal.entryPaths)
             entryPaths.add(filePath);
         principal.reconcileCache(graph);
-        if (isIsolateWorkspaces || (isSkipLibs && !isWatch)) {
-            factory.deletePrincipal(principal);
+        if (options.isIsolateWorkspaces || (options.isSkipLibs && !options.isWatch)) {
+            factory.deletePrincipal(principal, options.cwd);
             principals[i] = undefined;
         }
         perfObserver.addMemoryMark(factory.getPrincipalCount());
     }
-    if (!isWatch && isSkipLibs && !isIsolateWorkspaces) {
+    if (!options.isWatch && options.isSkipLibs && !options.isIsolateWorkspaces) {
         for (const principal of principals) {
             if (principal)
-                factory.deletePrincipal(principal);
+                factory.deletePrincipal(principal, options.cwd);
         }
         principals.length = 0;
     }

package/dist/index.d.ts

@@ -1,14 +1,10 @@
-import type { CommandLineOptions } from './types/cli.js';
+import type { MainOptions } from './util/create-options.js';
 export type { RawConfiguration as KnipConfig } from './types/config.js';
 export type { Preprocessor, Reporter, ReporterOptions } from './types/issues.js';
-export declare const main: (unresolvedConfiguration: CommandLineOptions) => Promise<{
-    report: import("./types/issues.js").Report;
+export declare const main: (options: MainOptions) => Promise<{
     issues: import("./types/issues.js").Issues;
     counters: import("./types/issues.js").Counters;
-    rules: import("./types/issues.js").Rules;
     tagHints: Set<import("./types/issues.js").TagHint>;
     configurationHints: Set<import("./types/issues.js").ConfigurationHint>;
-    isTreatConfigHintsAsErrors: boolean;
-    includedWorkspaces: import("./ConfigurationChief.js").Workspace[];
-    configFilePath: string | undefined;
+    includedWorkspaceDirs: string[];
 }>;

package/dist/index.js

@@ -11,57 +11,30 @@ import { build } from './graph/build.js';
 import { debugLogArray, debugLogObject } from './util/debug.js';
 import { getGitIgnoredHandler } from './util/glob-core.js';
 import { getWatchHandler } from './util/watch.js';
-export const main = async (unresolvedConfiguration) => {
-    const { cacheLocation, cwd, excludedIssueTypes, fixTypes, gitignore, includedIssueTypes, isCache, isDebug, isDependenciesShorthand, isExportsShorthand, isFilesShorthand, isFix, isFormat, isIncludeEntryExports, isIncludeLibs, isIsolateWorkspaces, isProduction, isRemoveFiles, isShowProgress, isStrict, isWatch, tags, tsConfigFile, workspace, } = unresolvedConfiguration;
-    debugLogObject('*', 'Unresolved configuration (from CLI arguments)', unresolvedConfiguration);
-    const chief = new ConfigurationChief({ cwd, isProduction, isStrict, isIncludeEntryExports, workspace });
-    const deputy = new DependencyDeputy({ isProduction, isStrict });
+export const main = async (options) => {
+    const { cwd } = options;
+    debugLogObject('*', 'Unresolved configuration', options);
+    debugLogObject('*', 'Included issue types', options.includedIssueTypes);
+    const chief = new ConfigurationChief(options);
+    const deputy = new DependencyDeputy(options);
     const factory = new PrincipalFactory();
-    const streamer = new ConsoleStreamer({ isEnabled: isShowProgress });
+    const streamer = new ConsoleStreamer(options);
+    const fixer = new IssueFixer(options);
+    const collector = new IssueCollector(options);
     streamer.cast('Reading workspace configuration');
-    await chief.init();
-    const workspaces = chief.getWorkspaces();
-    const report = chief.getIncludedIssueTypes({
-        includedIssueTypes,
-        excludedIssueTypes,
-        isDependenciesShorthand,
-        isExportsShorthand,
-        isFilesShorthand,
-    });
-    const rules = chief.getRules();
-    const filters = chief.getFilters();
-    const finalTags = tags[0].length > 0 || tags[1].length > 0 ? tags : chief.getTags();
-    const fixer = new IssueFixer({ isEnabled: isFix, cwd, fixTypes, isRemoveFiles });
-    debugLogObject('*', 'Included issue types', report);
-    const isReportClassMembers = report.classMembers;
-    const isSkipLibs = !(isIncludeLibs || isReportClassMembers);
-    const collector = new IssueCollector({ cwd, rules, filters });
-    const o = () => workspaces.map(w => ({ pkgName: w.pkgName, name: w.name, config: w.config, ancestors: w.ancestors }));
+    const workspaces = await chief.getWorkspaces();
+    const isGitIgnored = await getGitIgnoredHandler(options);
     debugLogObject('*', 'Included workspaces', () => workspaces.map(w => w.pkgName));
-    debugLogObject('*', 'Included workspace configs', o);
-    const isGitIgnored = await getGitIgnoredHandler({ cwd, gitignore });
+    debugLogObject('*', 'Included workspace configs', () => workspaces.map(w => ({ pkgName: w.pkgName, name: w.name, config: w.config, ancestors: w.ancestors })));
     const { graph, entryPaths, analyzedFiles, unreferencedFiles, analyzeSourceFile } = await build({
-        cacheLocation,
         chief,
         collector,
-        cwd,
         deputy,
         factory,
-        gitignore,
-        isCache,
-        isFixExports: fixer.isEnabled && fixer.isFixUnusedExports,
-        isFixTypes: fixer.isEnabled && fixer.isFixUnusedTypes,
         isGitIgnored,
-        isIsolateWorkspaces,
-        isProduction,
-        isSkipLibs,
-        isStrict,
-        isWatch,
-        report,
         streamer,
-        tags: finalTags,
-        tsConfigFile,
         workspaces,
+        options,
     });
     const reAnalyze = await analyze({
         analyzedFiles,
@@ -72,39 +45,30 @@ export const main = async (unresolvedConfiguration) => {
         factory,
         fixer,
         graph,
-        isFix,
-        isIncludeLibs,
-        isProduction,
-        report,
         streamer,
-        tags: finalTags,
         unreferencedFiles,
+        options,
     });
-    const { issues, counters, tagHints, configurationHints } = collector.getIssues();
-    for (const hint of chief.getConfigurationHints())
-        collector.addConfigurationHint(hint);
-    if (isWatch) {
-        const isIgnored = (filePath) => filePath.startsWith(cacheLocation) || filePath.includes('/.git/') || isGitIgnored(filePath);
-        const watchHandler = await getWatchHandler({
+    if (options.isWatch) {
+        const isIgnored = (filePath) => filePath.startsWith(options.cacheLocation) || filePath.includes('/.git/') || isGitIgnored(filePath);
+        const watchHandler = await getWatchHandler(options, {
             analyzedFiles,
             analyzeSourceFile,
             chief,
             collector,
             analyze: reAnalyze,
-            cwd,
             factory,
             graph,
-            isDebug,
             isIgnored,
-            report,
             streamer,
             unreferencedFiles,
         });
         watch('.', { recursive: true }, watchHandler);
     }
-    if (isFix) {
+    const { issues, counters, tagHints, configurationHints } = collector.getIssues();
+    if (options.isFix) {
         const touchedFiles = await fixer.fixIssues(issues);
-        if (isFormat) {
+        if (options.isFormat) {
             const report = await formatly(Array.from(touchedFiles), { cwd });
             if (report.ran && report.result && (report.result.runner === 'virtual' || report.result.code === 0)) {
                 debugLogArray('*', `Formatted files using ${report.formatter.name} (${report.formatter.runner})`, touchedFiles);
@@ -114,17 +78,13 @@ export const main = async (unresolvedConfiguration) => {
             }
         }
     }
-    if (!isWatch)
+    if (!options.isWatch)
         streamer.clear();
     return {
-        report,
         issues,
         counters,
-        rules,
         tagHints,
         configurationHints,
-        isTreatConfigHintsAsErrors: chief.config.isTreatConfigHintsAsErrors,
-        includedWorkspaces: chief.includedWorkspaces,
-        configFilePath: chief.resolvedConfigFilePath,
+        includedWorkspaceDirs: chief.includedWorkspaces.map(w => w.dir),
     };
 };

package/dist/plugins/index.d.ts

@@ -515,6 +515,11 @@ export declare const Plugins: {
         isEnabled: import("../types/config.js").IsPluginEnabled;
         config: string[];
     };
+    pnpm: {
+        title: string;
+        isEnabled: import("../types/config.js").IsPluginEnabled;
+        config: string[];
+    };
     postcss: {
         title: string;
         enablers: string[];

package/dist/plugins/index.js

@@ -61,6 +61,7 @@ import { default as playwrightCt } from './playwright-ct/index.js';
 import { default as playwrightTest } from './playwright-test/index.js';
 import { default as playwright } from './playwright/index.js';
 import { default as plop } from './plop/index.js';
+import { default as pnpm } from './pnpm/index.js';
 import { default as postcss } from './postcss/index.js';
 import { default as preconstruct } from './preconstruct/index.js';
 import { default as prettier } from './prettier/index.js';
@@ -173,6 +174,7 @@ export const Plugins = {
     'playwright-ct': playwrightCt,
     'playwright-test': playwrightTest,
     plop,
+    pnpm,
     postcss,
     preconstruct,
     prettier,

package/dist/plugins/nuxt/index.js

@@ -1,4 +1,4 @@
-import { toProductionEntry } from '../../util/input.js';
+import { toDependency, toProductionEntry } from '../../util/input.js';
 import { join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'Nuxt';
@@ -33,8 +33,9 @@ const resolveConfig = async (localConfig) => {
         'server/routes/**/*.ts',
         'server/middleware/**/*.ts',
         'server/plugins/**/*.ts',
-    ];
-    return patterns.map(pattern => toProductionEntry(join(srcDir, pattern)));
+    ].map(pattern => toProductionEntry(join(srcDir, pattern)));
+    const deps = localConfig.modules?.map(id => toDependency(id)) ?? [];
+    return [...deps, ...patterns];
 };
 const note = `Knip works best with [explicit imports](https://nuxt.com/docs/guide/concepts/auto-imports#explicit-imports).
 Nuxt allows to [disable auto-imports](https://nuxt.com/docs/guide/concepts/auto-imports#disabling-auto-imports).`;

package/dist/plugins/nuxt/types.d.ts

@@ -1,8 +1,9 @@
-export type NuxtConfig = {
+export interface NuxtConfig {
     srcDir?: string;
     dir?: {
         pages?: string;
         layouts?: string;
         middleware?: string;
     };
-};
+    modules?: Array<string>;
+}

package/dist/plugins/pnpm/index.d.ts

@@ -0,0 +1,7 @@
+import type { IsPluginEnabled } from '../../types/config.js';
+declare const _default: {
+    title: string;
+    isEnabled: IsPluginEnabled;
+    config: string[];
+};
+export default _default;

package/dist/plugins/pnpm/index.js

@@ -0,0 +1,8 @@
+const title = 'pnpm';
+const isEnabled = ({ manifest }) => Boolean(manifest.packageManager?.startsWith('pnpm@'));
+const config = ['.pnpmfile.cjs'];
+export default {
+    title,
+    isEnabled,
+    config,
+};

package/dist/plugins/rsbuild/index.js

@@ -6,12 +6,29 @@ const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['rsbuild*.config.{mjs,ts,js,cjs,mts,cts}'];
 const resolveConfig = async (config) => {
     const inputs = new Set();
-    if (config.source?.entry) {
-        if (Array.isArray(config.source.entry))
-            for (const entry of config.source.entry)
-                inputs.add(toEntry(entry));
-        if (typeof config.source.entry === 'string')
-            inputs.add(toEntry(config.source.entry));
+    const checkSource = (source) => {
+        if (source?.entry) {
+            for (const entry of Object.values(source.entry)) {
+                if (typeof entry === 'string')
+                    inputs.add(toEntry(entry));
+                else if (Array.isArray(entry))
+                    for (const e of entry)
+                        inputs.add(toEntry(e));
+                else {
+                    if (typeof entry.import === 'string')
+                        inputs.add(toEntry(entry.import));
+                    else if (Array.isArray(entry.import))
+                        for (const e of entry.import)
+                            inputs.add(toEntry(e));
+                }
+            }
+        }
+    };
+    checkSource(config.source);
+    if (config.environments) {
+        for (const environment of Object.values(config.environments)) {
+            checkSource(environment.source);
+        }
     }
     return Array.from(inputs);
 };

package/dist/plugins/rsbuild/types.d.ts

@@ -7,5 +7,8 @@ export type RsbuildConfig = {
     source?: {
         entry?: Entry;
     };
+    environments?: {
+        [k: string]: Pick<RsbuildConfig, 'plugins' | 'source'>;
+    };
 };
 export {};

package/dist/plugins.js

@@ -1,8 +1,9 @@
+import { parseArgs } from 'node:util';
 import { Plugins } from './plugins/index.js';
 import { timerify } from './util/Performance.js';
-import parsedArgValues from './util/cli-arguments.js';
 const PMap = Plugins;
-const { performance: isEnabled = false } = parsedArgValues;
+const { values } = parseArgs({ strict: false, options: { performance: { type: 'boolean' } } });
+const isEnabled = !!values.performance;
 const timerifyMethods = ['resolve', 'resolveConfig', 'resolveAST'];
 const PluginEntries = Object.entries(PMap);
 if (isEnabled) {

package/dist/reporters/codeclimate.d.ts

@@ -1,3 +1,3 @@
 import type { ReporterOptions } from '../types/issues.js';
-declare const _default: ({ report, issues }: ReporterOptions) => Promise<void>;
+declare const _default: ({ report, issues, cwd }: ReporterOptions) => Promise<void>;
 export default _default;

package/dist/reporters/codeclimate.js

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import { ISSUE_TYPE_TITLE } from '../constants.js';
 import { toRelative } from '../util/path.js';
 import { getIssueTypeTitle } from './util/util.js';
-export default async ({ report, issues }) => {
+export default async ({ report, issues, cwd }) => {
     const entries = [];
     for (const [type, isReportType] of Object.entries(report)) {
         if (!isReportType) {
@@ -17,9 +17,9 @@ export default async ({ report, issues }) => {
                     check_name: getIssueTypeTitle(fixedType),
                     description: getSymbolDescription({ type: issue.type, symbol, parentSymbol: issue.parentSymbol }),
                     categories: ['Duplication'],
-                    location: createLocation(filePath, symbol.line, symbol.col),
+                    location: createLocation(filePath, cwd, symbol.line, symbol.col),
                     severity: convertSeverity(issue.severity),
-                    fingerprint: createFingerprint(filePath, symbol.symbol),
+                    fingerprint: createFingerprint(filePath, cwd, symbol.symbol),
                 })));
             }
             else {
@@ -28,9 +28,9 @@ export default async ({ report, issues }) => {
                     check_name: getIssueTypeTitle(fixedType),
                     description: getIssueDescription(issue),
                     categories: ['Bug Risk'],
-                    location: createLocation(filePath, issue.line, issue.col),
+                    location: createLocation(filePath, cwd, issue.line, issue.col),
                     severity: convertSeverity(issue.severity),
-                    fingerprint: createFingerprint(filePath, issue.symbol),
+                    fingerprint: createFingerprint(filePath, cwd, issue.symbol),
                 });
             }
         }
@@ -62,10 +62,10 @@ function getIssueDescription({ type, symbol, symbols, parentSymbol }) {
 function getSymbolDescription({ type, symbol, parentSymbol, }) {
     return `${getPrefix(type)}: ${symbol.symbol}${parentSymbol ? ` (${parentSymbol})` : ''}`;
 }
-function createLocation(filePath, line, col) {
+function createLocation(filePath, cwd, line, col) {
     if (col !== undefined) {
         return {
-            path: toRelative(filePath),
+            path: toRelative(filePath, cwd),
             positions: {
                 begin: {
                     line: line ?? 0,
@@ -79,16 +79,16 @@ function createLocation(filePath, line, col) {
         };
     }
     return {
-        path: toRelative(filePath),
+        path: toRelative(filePath, cwd),
         lines: {
             begin: line ?? 0,
             end: line ?? 0,
         },
     };
 }
-function createFingerprint(filePath, message) {
+function createFingerprint(filePath, cwd, message) {
     const md5 = createHash('md5');
-    md5.update(toRelative(filePath));
+    md5.update(toRelative(filePath, cwd));
     md5.update(message);
     return md5.digest('hex');
 }

package/dist/reporters/codeowners.d.ts

@@ -1,3 +1,3 @@
 import type { ReporterOptions } from '../types/issues.js';
-declare const _default: ({ report, issues, isShowProgress, options }: ReporterOptions) => void;
+declare const _default: ({ report, issues, isShowProgress, options, cwd }: ReporterOptions) => void;
 export default _default;

package/dist/reporters/codeowners.js

@@ -1,13 +1,13 @@
 import { createOwnershipEngine } from '../util/codeowners.js';
 import { relative, resolve } from '../util/path.js';
 import { getColoredTitle, getIssueLine, getIssueTypeTitle } from './util/util.js';
-const logIssueRecord = (issues) => {
+const logIssueRecord = (issues, cwd) => {
     const sortedByFilePath = issues.sort((a, b) => (a.owner < b.owner ? -1 : 1));
     for (const { filePath, symbols, owner, parentSymbol } of sortedByFilePath) {
-        console.log(getIssueLine({ owner, filePath, symbols, parentSymbol }));
+        console.log(getIssueLine({ owner, filePath, symbols, parentSymbol }, cwd));
     }
 };
-export default ({ report, issues, isShowProgress, options }) => {
+export default ({ report, issues, isShowProgress, options, cwd }) => {
     let opts = {};
     try {
         opts = options ? JSON.parse(options) : opts;
@@ -20,7 +20,7 @@ export default ({ report, issues, isShowProgress, options }) => {
     const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;
     const [dependenciesOwner = '[no-owner]'] = findOwners('package.json');
     let totalIssues = 0;
-    const calcFileOwnership = (filePath) => findOwners(relative(filePath))[0] ?? dependenciesOwner;
+    const calcFileOwnership = (filePath) => findOwners(relative(cwd, filePath))[0] ?? dependenciesOwner;
     const addOwner = (issue) => ({
         ...issue,
         owner: calcFileOwnership(issue.filePath),
@@ -40,7 +40,7 @@ export default ({ report, issues, isShowProgress, options }) => {
                 if (totalIssues)
                     console.log();
                 title && console.log(getColoredTitle(title, issuesForType.length));
-                logIssueRecord(issuesForType);
+                logIssueRecord(issuesForType, cwd);
             }
             totalIssues = totalIssues + issuesForType.length;
         }

package/dist/reporters/compact.d.ts

@@ -1,3 +1,3 @@
 import type { ReporterOptions } from '../types/issues.js';
-declare const _default: ({ report, issues, isShowProgress }: ReporterOptions) => void;
+declare const _default: ({ report, issues, isShowProgress, cwd }: ReporterOptions) => void;
 export default _default;