fix(finder): resolve relative ignore patterns against scan dirs (#611)

Relative patterns like 'patches/**' or './ada/**' failed to match when
fast-glob returned absolute result paths (absolute scan path) or when the
ignore pattern was relative to a subdirectory being scanned (e.g. scanning
'./fixtures' with ignore './ada/**').

For each relative ignore pattern (not starting with '**/') generate
additional variants resolved via path.join and path.resolve against every
scan directory and cwd, covering both relative and absolute result paths.
Patterns already starting with '**/' are left unchanged as they already work.

Author: kucherenko

packages/finder/__tests__/files.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, afterEach } from 'vitest';
+import { describe, it, expect, vi, afterEach, beforeEach } from 'vitest';
 import * as path from 'path';
 import * as os from 'os';
 import * as fs from 'fs';
@@ -134,3 +134,76 @@ describe('getFilesToDetect — shebang detection', () => {
   });
 });
 
+describe('getFilesToDetect — ignore patterns with relative paths (issue #611)', () => {
+  let tmpDir: string;
+  let originalCwd: string;
+
+  beforeEach(() => {
+    originalCwd = process.cwd();
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'jscpd-ignore-test-'));
+    fs.mkdirSync(path.join(tmpDir, 'patches'), { recursive: true });
+    fs.mkdirSync(path.join(tmpDir, 'src'), { recursive: true });
+    // Each file needs enough lines to pass minLines filter
+    const content = Array.from({ length: 10 }, (_, i) => `const v${i} = ${i};`).join('\n');
+    fs.writeFileSync(path.join(tmpDir, 'patches', 'patch.js'), content);
+    fs.writeFileSync(path.join(tmpDir, 'src', 'main.js'), content);
+    process.chdir(tmpDir);
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  const makeOptions = (dir: string, ignore: string[]): any => ({
+    path: [dir],
+    format: ['javascript'],
+    pattern: '**/*',
+    minLines: 1,
+    maxLines: 10000,
+    maxSize: '100mb',
+    ignore,
+    noSymlinks: false,
+    absolute: false,
+  });
+
+  it('relative ignore pattern "patches/**" works when scan path is absolute (issue #611)', () => {
+    // Simulate the exact issue #611 scenario: default path=[process.cwd()] is absolute,
+    // and relative ignore patterns must still work.
+    const files = getFilesToDetect(makeOptions(process.cwd(), ['patches/**']));
+    const filePaths = files.map(f => f.path);
+    expect(filePaths.some(p => p.includes('patches'))).toBe(false);
+    expect(filePaths.some(p => p.includes('src'))).toBe(true);
+  });
+
+  it('relative ignore pattern "./patches/**" works when scan path is absolute', () => {
+    const files = getFilesToDetect(makeOptions(process.cwd(), ['./patches/**']));
+    const filePaths = files.map(f => f.path);
+    expect(filePaths.some(p => p.includes('patches'))).toBe(false);
+    expect(filePaths.some(p => p.includes('src'))).toBe(true);
+  });
+
+  it('relative ignore pattern "patches/**" works when scan path is "." (relative)', () => {
+    const files = getFilesToDetect(makeOptions('.', ['patches/**']));
+    const filePaths = files.map(f => f.path);
+    expect(filePaths.some(p => p.includes('patches'))).toBe(false);
+    expect(filePaths.some(p => p.includes('src'))).toBe(true);
+  });
+
+  it('relative ignore pattern "./ada/**" works when scanning a subdirectory (issue #611)', () => {
+    // Create a sub-fixture: tmpDir/subdir/{ada,src}
+    fs.mkdirSync(path.join(tmpDir, 'subdir', 'ada'), { recursive: true });
+    fs.mkdirSync(path.join(tmpDir, 'subdir', 'src'), { recursive: true });
+    const content = Array.from({ length: 10 }, (_, i) => `const v${i} = ${i};`).join('\n');
+    fs.writeFileSync(path.join(tmpDir, 'subdir', 'ada', 'ada.js'), content);
+    fs.writeFileSync(path.join(tmpDir, 'subdir', 'src', 'main.js'), content);
+
+    // Scan path is a relative subdirectory; user writes "./ada/**" meaning
+    // "ada within what I am scanning", not "ada at cwd level".
+    const files = getFilesToDetect(makeOptions('./subdir', ['./ada/**']));
+    const filePaths = files.map(f => f.path);
+    expect(filePaths.some(p => p.includes('ada'))).toBe(false);
+    expect(filePaths.some(p => p.includes('src'))).toBe(true);
+  });
+});
+

packages/finder/src/files.ts

@@ -149,25 +149,61 @@ function addContentToEntry(entry: IEntry): EntryWithContent {
 export function getFilesToDetect(options: IOptions): EntryWithContent[] {
   const pattern = options.pattern || '**/*';
   let patterns = options.path;
+  const cwd = process.cwd();
 
   if (options.noSymlinks) {
     patterns = patterns!==undefined ? patterns.filter((path: string) => !isSymlink(path)) : [];
   }
 
-  patterns = patterns!==undefined ? patterns.map((path: string) => {
-    const currentPath = realpathSync(path);
+  // Capture scan directories before appending the glob pattern, so we can resolve
+  // ignore patterns relative to each scan directory below.
+  const scanDirs: string[] = (patterns || []).map((inputPath: string) => {
+    try {
+      return isFile(realpathSync(inputPath)) ? path.dirname(inputPath) : inputPath;
+    } catch {
+      return inputPath;
+    }
+  });
+
+  patterns = patterns!==undefined ? patterns.map((inputPath: string) => {
+    const currentPath = realpathSync(inputPath);
 
     if (isFile(currentPath)) {
-      return path;
+      return inputPath;
     }
 
-    return path.endsWith('/') ? `${path}${pattern}` : `${path}/${pattern}`;
+    return inputPath.endsWith('/') ? `${inputPath}${pattern}` : `${inputPath}/${pattern}`;
   }): [];
 
+  // Normalize ignore patterns so they work regardless of whether the scan path
+  // is relative or absolute and regardless of whether it equals cwd (issue #611).
+  //
+  // fast-glob returns relative result paths for relative scan patterns and
+  // absolute result paths for absolute patterns. A pattern like "./ada/**" won't
+  // match either "fixtures/ada/file.js" (relative, when scanning "./fixtures")
+  // or "/cwd/fixtures/ada/file.js" (absolute, when scanning an absolute path).
+  //
+  // For each relative ignore pattern we generate additional variants:
+  //   • original                        – keeps backward-compat for trivial cases
+  //   • path.join(scanDir, pattern)     – matches relative result paths
+  //   • path.resolve(cwd, scanDir, pattern) – matches absolute result paths
+  // Patterns already starting with "**/" already work and are left unchanged.
+  const normalizedIgnore = (options.ignore || []).flatMap((ignorePattern: string) => {
+    if (path.isAbsolute(ignorePattern) || ignorePattern.startsWith('**/')) {
+      return [ignorePattern];
+    }
+    const variants = new Set<string>([ignorePattern]);
+    for (const scanDir of [...scanDirs, '.']) {
+      variants.add(path.join(scanDir, ignorePattern));
+      variants.add(path.resolve(cwd, scanDir, ignorePattern));
+    }
+    return [...variants];
+  });
+
   return (sync(
     patterns,
     {
-      ignore: options.ignore,
+      ignore: normalizedIgnore,
       onlyFiles: true,
       dot: true,
       stats: true,