@dbx-tools/path 0.9.119 → 0.9.121

package/lib/src/watch.js

@@ -8,26 +8,30 @@
  *
  * @module
  */
+import { readFile } from "node:fs/promises";
 import { isAbsolute, relative, resolve } from "path";
+import { errorUtils, log } from "@dbx-tools/shared-core";
 import { watch } from "chokidar";
 import { hasMagic } from "glob";
 import { findFiles } from "./find.js";
+import { GitIgnore } from "./git-ignore.js";
 import { ignorePathMatcher } from "./ignore.js";
 import { pathMatchTests } from "./match.js";
 import { FOLLOW_SYMLINKS_DEFAULT } from "./scan.js";
+const logger = log.logger("path/watch");
 /**
  * Watches files and directories for real-time changes, applying the shared
  * ignore groups so it prunes the same paths {@link findFiles} skips for the
  * same patterns.
  */
-export function watchFiles(paths, options) {
-    const normalized = toNormalizedFileWatchOptions(options);
-    const { ignored, cwd, followSymlinks, ...chokidarOptions } = normalized;
+export async function watchFiles(paths, options) {
+    const normalized = await toNormalizedFileWatchOptions(options);
+    const { gitIgnore, ignored, cwd, followSymlinks, ...chokidarOptions } = normalized;
     const { paths: literals, globs } = partitionPaths(paths);
     let watchPaths;
     if (globs.length > 0) {
         const distinctWatchPaths = new Set(literals);
-        for (const path of findFiles(globs, toFindFilesOptions(normalized))) {
+        for await (const path of findFiles(globs, toFindFilesOptions(normalized))) {
             distinctWatchPaths.add(path);
         }
         watchPaths = [...distinctWatchPaths];
@@ -35,12 +39,21 @@ export function watchFiles(paths, options) {
     else {
         watchPaths = literals;
     }
-    return watch(watchPaths, {
+    const watcher = watch(watchPaths, {
         ...chokidarOptions,
         cwd,
         followSymlinks,
         ignored,
     });
+    if (gitIgnore) {
+        attachGitIgnoreWatcher(watcher, gitIgnore, watchPaths, {
+            cwd,
+            followSymlinks,
+            ignoreOptions: options?.ignoreOptions,
+            persistent: chokidarOptions.persistent,
+        });
+    }
+    return watcher;
 }
 function partitionPaths(paths) {
     const globs = [];
@@ -55,13 +68,18 @@ function partitionPaths(paths) {
  * built-in groups are consolidated into one chokidar {@link MatchFunction}. When
  * `stats` marks a directory, the matcher also tests `path + "/"` for pruning.
  */
-function toNormalizedFileWatchOptions(options) {
+async function toNormalizedFileWatchOptions(options) {
     const { cwd, ignore, followSymlinks, ignoreOptions, ...chokidarOptions } = options ?? {};
+    const root = cwd ?? process.cwd();
+    const gitIgnore = ignoreOptions?.git
+        ? await GitIgnore.load(root, { ignoreOptions, followSymlinks })
+        : undefined;
     return {
         ...chokidarOptions,
-        cwd: cwd ?? process.cwd(),
+        cwd: root,
         followSymlinks: followSymlinks ?? FOLLOW_SYMLINKS_DEFAULT,
-        ignored: toWatchMatchFunction(ignore, ignoreOptions, cwd ?? process.cwd()),
+        ...(gitIgnore ? { gitIgnore } : {}),
+        ignored: toWatchMatchFunction(ignore, ignoreOptions, root, gitIgnore),
     };
 }
 /** Glob expansion reuses the normalized ignore matcher as a cwd-relative path predicate. */
@@ -78,7 +96,7 @@ function toFindFilesOptions(normalized) {
  * {@link MatchFunction}s into one ignore test. Directory pruning uses `stats`
  * when chokidar supplies it; glob expansion passes `undefined`.
  */
-function toWatchMatchFunction(ignore, ignoreOptions, cwd) {
+function toWatchMatchFunction(ignore, ignoreOptions, cwd, gitIgnore) {
     const patterns = [];
     const functions = [];
     if (ignore !== undefined) {
@@ -94,6 +112,8 @@ function toWatchMatchFunction(ignore, ignoreOptions, cwd) {
         matcher = matcher.or(...pathMatchTests(...patterns));
     const matchPath = (path, stats) => {
         const rel = toCwdRelativePath(path, cwd);
+        if (gitIgnore?.ignores(rel, stats?.isDirectory() ?? false))
+            return true;
         if (matcher(rel))
             return true;
         for (const fn of functions) {
@@ -113,6 +133,50 @@ function toWatchMatchFunction(ignore, ignoreOptions, cwd) {
     };
     return matchPath;
 }
+function attachGitIgnoreWatcher(watcher, gitIgnore, watchPaths, options) {
+    const builtInIgnore = ignorePathMatcher(options.ignoreOptions);
+    const controls = watch(".", {
+        atomic: false,
+        cwd: options.cwd,
+        followSymlinks: options.followSymlinks,
+        ignoreInitial: true,
+        persistent: options.persistent,
+        ignored(path, stats) {
+            const relativePath = toCwdRelativePath(path, options.cwd);
+            if (GitIgnore.isFile(relativePath))
+                return false;
+            if (builtInIgnore(relativePath) || builtInIgnore(`${relativePath}/`))
+                return true;
+            return stats ? !stats.isDirectory() : false;
+        },
+    });
+    const reload = (path) => {
+        void readFile(resolve(options.cwd, path), "utf8")
+            .then((content) => {
+            gitIgnore.set(path, content);
+            watcher.add([...watchPaths]);
+            logger.debug(".gitignore updated", { path });
+        })
+            .catch((error) => {
+            logger.warn("failed to reload .gitignore", {
+                path,
+                error: errorUtils.toError(error),
+            });
+        });
+    };
+    controls.on("add", reload);
+    controls.on("change", reload);
+    controls.on("unlink", (path) => {
+        gitIgnore.delete(path);
+        watcher.add([...watchPaths]);
+        logger.debug(".gitignore removed", { path });
+    });
+    controls.on("error", (error) => watcher.emit("error", error));
+    const close = watcher.close.bind(watcher);
+    watcher.close = async () => {
+        await Promise.all([close(), controls.close()]);
+    };
+}
 /** Aligns chokidar paths with the cwd-relative form {@link findFiles} uses. */
 function toCwdRelativePath(path, cwd) {
     if (!isAbsolute(path))
@@ -126,7 +190,7 @@ if (import.meta.main) {
     const cwd = resolve(process.argv[2] ?? resolve(import.meta.dirname, ".."));
     console.log("--- Starting File Watcher ---");
     console.log(`Working Directory: ${cwd}`);
-    const watcher = watchFiles("**/src/**", {
+    const watcher = await watchFiles("**/src/**", {
         cwd,
         ignoreInitial: false,
         ignore: ["**/index.ts", "**/core/**"],
@@ -142,4 +206,4 @@ if (import.meta.main) {
     });
     console.log("Watcher started");
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"watch.js","sourceRoot":"","sources":["../../src/watch.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Repository-consistent file watching over Chokidar.\n *\n * Reuse `watchFiles()` when live workflows must match `findFiles()`\n * discovery and the central ignore catalogue. The wrapper expands globs once,\n * prunes ignored directories consistently, and preserves Chokidar's native\n * watcher result for callers.\n *\n * @module\n */\n\nimport { Stats } from \"fs\";\nimport { isAbsolute, relative, resolve } from \"path\";\nimport { ChokidarOptions, MatchFunction, watch } from \"chokidar\";\nimport { hasMagic } from \"glob\";\nimport { findFiles, type FileFindOptions } from \"./find.ts\";\nimport { ignorePathMatcher } from \"./ignore.ts\";\nimport { pathMatchTests } from \"./match.ts\";\nimport { FileScanIgnoreOptions, FileScanOptions, FOLLOW_SYMLINKS_DEFAULT } from \"./scan.ts\";\n\n/** Chokidar options extended with the shared dbx-tools ignore configuration. */\nexport interface FileWatchOptions\n  extends Omit<ChokidarOptions, \"ignored\">, Omit<FileScanOptions, \"ignore\"> {\n  ignore?: string | string[] | MatchFunction | MatchFunction[];\n}\n\ninterface NormalizedFileWatchOptions extends Omit<FileWatchOptions, \"ignore\" | \"ignoreOptions\"> {\n  ignored: MatchFunction;\n}\n\n/**\n * Watches files and directories for real-time changes, applying the shared\n * ignore groups so it prunes the same paths {@link findFiles} skips for the\n * same patterns.\n */\nexport function watchFiles(paths: string | string[], options?: FileWatchOptions) {\n  const normalized = toNormalizedFileWatchOptions(options);\n  const { ignored, cwd, followSymlinks, ...chokidarOptions } = normalized;\n  const { paths: literals, globs } = partitionPaths(paths);\n\n  let watchPaths: string[];\n  if (globs.length > 0) {\n    const distinctWatchPaths = new Set(literals);\n    for (const path of findFiles(globs, toFindFilesOptions(normalized))) {\n      distinctWatchPaths.add(path);\n    }\n    watchPaths = [...distinctWatchPaths];\n  } else {\n    watchPaths = literals;\n  }\n\n  return watch(watchPaths, {\n    ...chokidarOptions,\n    cwd,\n    followSymlinks,\n    ignored,\n  });\n}\n\nfunction partitionPaths(paths: string | string[]): { paths: string[]; globs: string[] } {\n  const globs: string[] = [];\n  const literals: string[] = [];\n  for (const path of Array.isArray(paths) ? paths : [paths]) {\n    (hasMagic(path) ? globs : literals).push(path);\n  }\n  return { paths: literals, globs };\n}\n\n/**\n * Builds {@link NormalizedFileWatchOptions} first: all caller ignore inputs and\n * built-in groups are consolidated into one chokidar {@link MatchFunction}. When\n * `stats` marks a directory, the matcher also tests `path + \"/\"` for pruning.\n */\nfunction toNormalizedFileWatchOptions(options?: FileWatchOptions): NormalizedFileWatchOptions & {\n  cwd: string;\n  followSymlinks: boolean;\n} {\n  const { cwd, ignore, followSymlinks, ignoreOptions, ...chokidarOptions } = options ?? {};\n  return {\n    ...chokidarOptions,\n    cwd: cwd ?? process.cwd(),\n    followSymlinks: followSymlinks ?? FOLLOW_SYMLINKS_DEFAULT,\n    ignored: toWatchMatchFunction(ignore, ignoreOptions, cwd ?? process.cwd()),\n  };\n}\n\n/** Glob expansion reuses the normalized ignore matcher as a cwd-relative path predicate. */\nfunction toFindFilesOptions(\n  normalized: NormalizedFileWatchOptions & { cwd: string; followSymlinks: boolean },\n): FileFindOptions {\n  const { ignored, cwd, followSymlinks } = normalized;\n  return {\n    cwd,\n    followSymlinks,\n    ignore: (path) => ignored(path, undefined),\n  };\n}\n\n/**\n * Consolidates built-in ignore groups, caller glob patterns, and caller\n * {@link MatchFunction}s into one ignore test. Directory pruning uses `stats`\n * when chokidar supplies it; glob expansion passes `undefined`.\n */\nfunction toWatchMatchFunction(\n  ignore: FileWatchOptions[\"ignore\"] | undefined,\n  ignoreOptions: FileScanIgnoreOptions | undefined,\n  cwd: string,\n): MatchFunction {\n  const patterns: string[] = [];\n  const functions: MatchFunction[] = [];\n\n  if (ignore !== undefined) {\n    for (const item of Array.isArray(ignore) ? ignore : [ignore]) {\n      if (typeof item === \"string\") patterns.push(item);\n      else functions.push(item);\n    }\n  }\n\n  let matcher = ignorePathMatcher(ignoreOptions);\n  if (patterns.length > 0) matcher = matcher.or(...pathMatchTests(...patterns));\n\n  const matchPath = (path: string, stats?: Stats): boolean => {\n    const rel = toCwdRelativePath(path, cwd);\n    if (matcher(rel)) return true;\n    for (const fn of functions) {\n      if (fn(rel, stats)) return true;\n    }\n    if (stats?.isDirectory()) {\n      const directoryPath = rel + \"/\";\n      if (matcher(directoryPath)) return true;\n      for (const fn of functions) {\n        if (fn(directoryPath, stats)) return true;\n      }\n    }\n    return false;\n  };\n\n  return matchPath;\n}\n\n/** Aligns chokidar paths with the cwd-relative form {@link findFiles} uses. */\nfunction toCwdRelativePath(path: string, cwd: string): string {\n  if (!isAbsolute(path)) return path;\n  const rel = relative(cwd, path);\n  return rel === \"\" ? \".\" : rel;\n}\n\n// Manual demo: run this file directly (`bun src/watch.ts [dir]`) to watch a tree\n// and log every file event as it happens. Defaults to this package.\nif (import.meta.main) {\n  const cwd = resolve(process.argv[2] ?? resolve(import.meta.dirname, \"..\"));\n  console.log(\"--- Starting File Watcher ---\");\n  console.log(`Working Directory: ${cwd}`);\n\n  const watcher = watchFiles(\"**/src/**\", {\n    cwd,\n    ignoreInitial: false,\n    ignore: [\"**/index.ts\", \"**/core/**\"],\n    ignoreOptions: {\n      temp: false,\n    },\n  });\n  watcher.on(\"all\", (event: string, path: string) => {\n    console.log(`[${event.toUpperCase()}] ${path}`);\n  });\n  watcher.on(\"error\", (error) => {\n    console.error(\"Watcher error:\", error);\n  });\n  console.log(\"Watcher started\");\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"watch.js","sourceRoot":"","sources":["../../src/watch.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Repository-consistent file watching over Chokidar.\n *\n * Reuse `watchFiles()` when live workflows must match `findFiles()`\n * discovery and the central ignore catalogue. The wrapper expands globs once,\n * prunes ignored directories consistently, and preserves Chokidar's native\n * watcher result for callers.\n *\n * @module\n */\n\nimport { Stats } from \"fs\";\nimport { readFile } from \"node:fs/promises\";\nimport { isAbsolute, relative, resolve } from \"path\";\nimport { errorUtils, log } from \"@dbx-tools/shared-core\";\nimport { ChokidarOptions, MatchFunction, watch, type FSWatcher } from \"chokidar\";\nimport { hasMagic } from \"glob\";\nimport { findFiles, type FileFindOptions } from \"./find.ts\";\nimport { GitIgnore } from \"./git-ignore.ts\";\nimport { ignorePathMatcher } from \"./ignore.ts\";\nimport { pathMatchTests } from \"./match.ts\";\nimport { FileScanIgnoreOptions, FileScanOptions, FOLLOW_SYMLINKS_DEFAULT } from \"./scan.ts\";\n\nconst logger = log.logger(\"path/watch\");\n\n/** Chokidar options extended with the shared dbx-tools ignore configuration. */\nexport interface FileWatchOptions\n  extends Omit<ChokidarOptions, \"ignored\">, Omit<FileScanOptions, \"ignore\"> {\n  ignore?: string | string[] | MatchFunction | MatchFunction[];\n}\n\ninterface NormalizedFileWatchOptions extends Omit<FileWatchOptions, \"ignore\" | \"ignoreOptions\"> {\n  gitIgnore?: GitIgnore;\n  ignored: MatchFunction;\n}\n\n/**\n * Watches files and directories for real-time changes, applying the shared\n * ignore groups so it prunes the same paths {@link findFiles} skips for the\n * same patterns.\n */\nexport async function watchFiles(\n  paths: string | string[],\n  options?: FileWatchOptions,\n): Promise<FSWatcher> {\n  const normalized = await toNormalizedFileWatchOptions(options);\n  const { gitIgnore, ignored, cwd, followSymlinks, ...chokidarOptions } = normalized;\n  const { paths: literals, globs } = partitionPaths(paths);\n\n  let watchPaths: string[];\n  if (globs.length > 0) {\n    const distinctWatchPaths = new Set(literals);\n    for await (const path of findFiles(globs, toFindFilesOptions(normalized))) {\n      distinctWatchPaths.add(path);\n    }\n    watchPaths = [...distinctWatchPaths];\n  } else {\n    watchPaths = literals;\n  }\n\n  const watcher = watch(watchPaths, {\n    ...chokidarOptions,\n    cwd,\n    followSymlinks,\n    ignored,\n  });\n  if (gitIgnore) {\n    attachGitIgnoreWatcher(watcher, gitIgnore, watchPaths, {\n      cwd,\n      followSymlinks,\n      ignoreOptions: options?.ignoreOptions,\n      persistent: chokidarOptions.persistent,\n    });\n  }\n  return watcher;\n}\n\nfunction partitionPaths(paths: string | string[]): { paths: string[]; globs: string[] } {\n  const globs: string[] = [];\n  const literals: string[] = [];\n  for (const path of Array.isArray(paths) ? paths : [paths]) {\n    (hasMagic(path) ? globs : literals).push(path);\n  }\n  return { paths: literals, globs };\n}\n\n/**\n * Builds {@link NormalizedFileWatchOptions} first: all caller ignore inputs and\n * built-in groups are consolidated into one chokidar {@link MatchFunction}. When\n * `stats` marks a directory, the matcher also tests `path + \"/\"` for pruning.\n */\nasync function toNormalizedFileWatchOptions(options?: FileWatchOptions): Promise<\n  NormalizedFileWatchOptions & {\n    cwd: string;\n    followSymlinks: boolean;\n  }\n> {\n  const { cwd, ignore, followSymlinks, ignoreOptions, ...chokidarOptions } = options ?? {};\n  const root = cwd ?? process.cwd();\n  const gitIgnore = ignoreOptions?.git\n    ? await GitIgnore.load(root, { ignoreOptions, followSymlinks })\n    : undefined;\n  return {\n    ...chokidarOptions,\n    cwd: root,\n    followSymlinks: followSymlinks ?? FOLLOW_SYMLINKS_DEFAULT,\n    ...(gitIgnore ? { gitIgnore } : {}),\n    ignored: toWatchMatchFunction(ignore, ignoreOptions, root, gitIgnore),\n  };\n}\n\n/** Glob expansion reuses the normalized ignore matcher as a cwd-relative path predicate. */\nfunction toFindFilesOptions(\n  normalized: NormalizedFileWatchOptions & { cwd: string; followSymlinks: boolean },\n): FileFindOptions {\n  const { ignored, cwd, followSymlinks } = normalized;\n  return {\n    cwd,\n    followSymlinks,\n    ignore: (path) => ignored(path, undefined),\n  };\n}\n\n/**\n * Consolidates built-in ignore groups, caller glob patterns, and caller\n * {@link MatchFunction}s into one ignore test. Directory pruning uses `stats`\n * when chokidar supplies it; glob expansion passes `undefined`.\n */\nfunction toWatchMatchFunction(\n  ignore: FileWatchOptions[\"ignore\"] | undefined,\n  ignoreOptions: FileScanIgnoreOptions | undefined,\n  cwd: string,\n  gitIgnore?: GitIgnore,\n): MatchFunction {\n  const patterns: string[] = [];\n  const functions: MatchFunction[] = [];\n\n  if (ignore !== undefined) {\n    for (const item of Array.isArray(ignore) ? ignore : [ignore]) {\n      if (typeof item === \"string\") patterns.push(item);\n      else functions.push(item);\n    }\n  }\n\n  let matcher = ignorePathMatcher(ignoreOptions);\n  if (patterns.length > 0) matcher = matcher.or(...pathMatchTests(...patterns));\n\n  const matchPath = (path: string, stats?: Stats): boolean => {\n    const rel = toCwdRelativePath(path, cwd);\n    if (gitIgnore?.ignores(rel, stats?.isDirectory() ?? false)) return true;\n    if (matcher(rel)) return true;\n    for (const fn of functions) {\n      if (fn(rel, stats)) return true;\n    }\n    if (stats?.isDirectory()) {\n      const directoryPath = rel + \"/\";\n      if (matcher(directoryPath)) return true;\n      for (const fn of functions) {\n        if (fn(directoryPath, stats)) return true;\n      }\n    }\n    return false;\n  };\n\n  return matchPath;\n}\n\nfunction attachGitIgnoreWatcher(\n  watcher: FSWatcher,\n  gitIgnore: GitIgnore,\n  watchPaths: readonly string[],\n  options: {\n    cwd: string;\n    followSymlinks: boolean;\n    ignoreOptions?: FileScanIgnoreOptions;\n    persistent?: boolean;\n  },\n): void {\n  const builtInIgnore = ignorePathMatcher(options.ignoreOptions);\n  const controls = watch(\".\", {\n    atomic: false,\n    cwd: options.cwd,\n    followSymlinks: options.followSymlinks,\n    ignoreInitial: true,\n    persistent: options.persistent,\n    ignored(path, stats) {\n      const relativePath = toCwdRelativePath(path, options.cwd);\n      if (GitIgnore.isFile(relativePath)) return false;\n      if (builtInIgnore(relativePath) || builtInIgnore(`${relativePath}/`)) return true;\n      return stats ? !stats.isDirectory() : false;\n    },\n  });\n  const reload = (path: string): void => {\n    void readFile(resolve(options.cwd, path), \"utf8\")\n      .then((content) => {\n        gitIgnore.set(path, content);\n        watcher.add([...watchPaths]);\n        logger.debug(\".gitignore updated\", { path });\n      })\n      .catch((error) => {\n        logger.warn(\"failed to reload .gitignore\", {\n          path,\n          error: errorUtils.toError(error),\n        });\n      });\n  };\n  controls.on(\"add\", reload);\n  controls.on(\"change\", reload);\n  controls.on(\"unlink\", (path) => {\n    gitIgnore.delete(path);\n    watcher.add([...watchPaths]);\n    logger.debug(\".gitignore removed\", { path });\n  });\n  controls.on(\"error\", (error) => watcher.emit(\"error\", error));\n  const close = watcher.close.bind(watcher);\n  watcher.close = async () => {\n    await Promise.all([close(), controls.close()]);\n  };\n}\n\n/** Aligns chokidar paths with the cwd-relative form {@link findFiles} uses. */\nfunction toCwdRelativePath(path: string, cwd: string): string {\n  if (!isAbsolute(path)) return path;\n  const rel = relative(cwd, path);\n  return rel === \"\" ? \".\" : rel;\n}\n\n// Manual demo: run this file directly (`bun src/watch.ts [dir]`) to watch a tree\n// and log every file event as it happens. Defaults to this package.\nif (import.meta.main) {\n  const cwd = resolve(process.argv[2] ?? resolve(import.meta.dirname, \"..\"));\n  console.log(\"--- Starting File Watcher ---\");\n  console.log(`Working Directory: ${cwd}`);\n\n  const watcher = await watchFiles(\"**/src/**\", {\n    cwd,\n    ignoreInitial: false,\n    ignore: [\"**/index.ts\", \"**/core/**\"],\n    ignoreOptions: {\n      temp: false,\n    },\n  });\n  watcher.on(\"all\", (event: string, path: string) => {\n    console.log(`[${event.toUpperCase()}] ${path}`);\n  });\n  watcher.on(\"error\", (error) => {\n    console.error(\"Watcher error:\", error);\n  });\n  console.log(\"Watcher started\");\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/find.ts","../src/ignore.ts","../src/match.ts","../src/pattern.ts","../src/scan.ts","../src/watch.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/find.ts","../src/git-ignore.ts","../src/ignore.ts","../src/match.ts","../src/pattern.ts","../src/scan.ts","../src/watch.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -23,10 +23,11 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@dbx-tools/core": "^0.9.119",
-    "@dbx-tools/shared-core": "^0.9.119",
+    "@dbx-tools/core": "^0.9.121",
+    "@dbx-tools/shared-core": "^0.9.121",
     "chokidar": "^4.0.3",
     "glob": "^13.0.6",
+    "ignore": "^7.0.12",
     "minimatch": "^10.2.5"
   },
   "main": "./lib/index.js",
@@ -44,6 +45,10 @@
         "types": "./lib/src/find.d.ts",
         "default": "./lib/src/find.js"
       },
+      "./git-ignore": {
+        "types": "./lib/src/git-ignore.d.ts",
+        "default": "./lib/src/git-ignore.js"
+      },
       "./ignore": {
         "types": "./lib/src/ignore.d.ts",
         "default": "./lib/src/ignore.js"
@@ -71,7 +76,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.9.119",
+  "version": "0.9.121",
   "types": "./lib/index.d.ts",
   "dbxToolsConfig": {
     "tags": [
@@ -88,6 +93,10 @@
       "types": "./lib/src/find.d.ts",
       "default": "./lib/src/find.js"
     },
+    "./git-ignore": {
+      "types": "./lib/src/git-ignore.d.ts",
+      "default": "./lib/src/git-ignore.js"
+    },
     "./ignore": {
       "types": "./lib/src/ignore.d.ts",
       "default": "./lib/src/ignore.js"

package/src/find.ts

@@ -1,22 +1,29 @@
 /**
  * Repository-consistent file discovery over `glob`.
  *
- * Reuse {@link findFiles} when package discovery, generation, cleanup, or docs
- * tooling must honor the same ignore catalogue and symlink defaults as watchers.
- * Direct `glob` calls should be reserved for behavior that intentionally differs.
+ * Reuse {@link findFiles} or {@link findFilesSync} when package discovery,
+ * generation, cleanup, or docs tooling must honor the same ignore catalogue and
+ * symlink defaults as watchers. Direct `glob` calls should be reserved for
+ * behavior that intentionally differs.
  *
  * @module
  */
 
 import { object, type Sequence } from "@dbx-tools/shared-core";
-import { globIterateSync, IgnoreLike, type GlobOptionsWithFileTypesUnset } from "glob";
+import {
+  globIterate,
+  globIterateSync,
+  IgnoreLike,
+  type GlobOptionsWithFileTypesUnset,
+} from "glob";
+import { GitIgnore } from "./git-ignore.ts";
 import { ignorePathMatcher } from "./ignore.ts";
 import { PathMatcher, PathMatchInput, pathMatchTests, toPathMatcher } from "./match.ts";
 import { FileScanIgnoreOptions, FileScanOptions, FOLLOW_SYMLINKS_DEFAULT } from "./scan.ts";
 
 type FileFindIgnore = PathMatchInput | readonly PathMatchInput[] | IgnoreLike;
 
-/** Glob, root, ignore, and symlink options for {@link findFiles}. */
+/** Glob, root, ignore, and symlink options for {@link findFiles} and {@link findFilesSync}. */
 export interface FileFindOptions
   extends
     Omit<
@@ -33,17 +40,51 @@ export interface FileFindOptions
  * in which case only that predicate applies). The ignore list mirrors what
  * {@link watchFiles} feeds through its matchers.
  */
-export function findFiles(pattern: string | string[], options?: FileFindOptions): Sequence<string> {
-  return object.sequence(globIterateSync(pattern, toGlobOptions(options)));
+export async function* findFiles(
+  pattern: string | string[],
+  options?: FileFindOptions,
+): AsyncGenerator<string> {
+  yield* globIterate(pattern, await toGlobOptions(options));
 }
 
-function toGlobOptions(options: FileFindOptions | undefined): GlobOptionsWithFileTypesUnset {
+/** Synchronous counterpart to {@link findFiles}. */
+export function findFilesSync(
+  pattern: string | string[],
+  options?: FileFindOptions,
+): Sequence<string> {
+  return object.sequence(globIterateSync(pattern, toGlobOptionsSync(options)));
+}
+
+async function toGlobOptions(
+  options: FileFindOptions | undefined,
+): Promise<GlobOptionsWithFileTypesUnset> {
+  const { cwd, ignoreOptions, followSymlinks } = options ?? {};
+  const root = cwd ?? process.cwd();
+  const gitIgnore = ignoreOptions?.git
+    ? await GitIgnore.load(root, { ignoreOptions, followSymlinks })
+    : undefined;
+  return buildGlobOptions(options, gitIgnore);
+}
+
+function toGlobOptionsSync(options: FileFindOptions | undefined): GlobOptionsWithFileTypesUnset {
+  const { cwd, ignoreOptions, followSymlinks } = options ?? {};
+  const root = cwd ?? process.cwd();
+  const gitIgnore = ignoreOptions?.git
+    ? GitIgnore.loadSync(root, { ignoreOptions, followSymlinks })
+    : undefined;
+  return buildGlobOptions(options, gitIgnore);
+}
+
+function buildGlobOptions(
+  options: FileFindOptions | undefined,
+  gitIgnore: GitIgnore | undefined,
+): GlobOptionsWithFileTypesUnset {
   const { cwd, ignore, ignoreOptions, followSymlinks, ...restOptions } = options ?? {};
   return {
     ...restOptions,
     cwd: cwd ?? process.cwd(),
     follow: followSymlinks ?? FOLLOW_SYMLINKS_DEFAULT,
-    ignore: normalizeIgnore(ignore, ignoreOptions),
+    ignore: normalizeIgnore(ignore, ignoreOptions, gitIgnore),
   };
 }
 
@@ -66,7 +107,7 @@ function isIgnoreLike(value: unknown): value is IgnoreLike {
   return false;
 }
 /**
- * Builds the {@link IgnoreLike} object {@link findFiles} hands to `glob`.
+ * Builds the {@link IgnoreLike} object file discovery hands to `glob`.
  *
  * A caller-supplied `IgnoreLike` (an object, not string/array) is consulted
  * first - its `ignored`/`childrenIgnored` win - after which the shared
@@ -78,6 +119,7 @@ function isIgnoreLike(value: unknown): value is IgnoreLike {
 function normalizeIgnore(
   ignore: FileFindIgnore | undefined,
   ignoreOptions: FileScanIgnoreOptions | undefined,
+  gitIgnore: GitIgnore | undefined,
 ): IgnoreLike {
   const ignoreLike: IgnoreLike | undefined = isIgnoreLike(ignore) ? ignore : undefined;
   const ignorePathMatcherInputs: PathMatchInput[] | undefined =
@@ -96,6 +138,7 @@ function normalizeIgnore(
     ignored(path) {
       if (ignoreLike?.ignored?.(path)) return true;
       const patheRelative = path.relative();
+      if (gitIgnore?.ignores(patheRelative, path.isDirectory())) return true;
       const ignore = ignoreMatcher(patheRelative);
       return ignore;
     },
@@ -103,6 +146,7 @@ function normalizeIgnore(
       if (ignoreLike?.childrenIgnored?.(path)) return true;
       const patheRelative = path.relative();
       if (patheRelative) {
+        if (gitIgnore?.ignores(patheRelative, true)) return true;
         if (ignoreMatcher(patheRelative)) {
           return true;
         } else if (ignoreMatcher(patheRelative + "/")) {
@@ -131,7 +175,7 @@ if (import.meta.main) {
       test: true,
     },
   });
-  for (const file of files) {
+  for await (const file of files) {
     console.log(file);
   }
   const elapsed = performance.now() - startTime;

package/src/git-ignore.ts

@@ -0,0 +1,200 @@
+/**
+ * Mutable, Git-compatible `.gitignore` path matching.
+ *
+ * Rule syntax is owned by the `ignore` package, whose compatibility suite
+ * compares behavior with `git check-ignore`. This module adds repository and
+ * nested-file scoping plus in-memory add, update, and removal.
+ *
+ * @module
+ */
+
+import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { glob, globSync, type IgnoreLike } from "glob";
+import ignore from "ignore";
+import type { IgnorePatternOptions } from "./ignore.ts";
+import { ignorePathMatcher } from "./ignore.ts";
+import { toPathMatcher, type PathMatcher } from "./match.ts";
+
+interface GitIgnoreRuleSet {
+  content: string;
+  directory: string;
+  matcher: ReturnType<typeof ignore>;
+  path: string;
+}
+
+/** Options used while discovering `.gitignore` files beneath a root. */
+export interface GitIgnoreLoadOptions {
+  /** Built-in directory groups pruned while looking for ignore files. */
+  ignoreOptions?: IgnorePatternOptions;
+  /** Follow symlinked directories during discovery. Defaults to false. */
+  followSymlinks?: boolean;
+}
+
+/** Mutable path predicate composed from root and nested `.gitignore` files. */
+export class GitIgnore {
+  readonly root: string;
+  /** Stable composable matcher that observes later {@link set}, {@link delete}, and {@link clear} calls. */
+  readonly matcher: PathMatcher = toPathMatcher((path) => this.ignores(path));
+
+  private readonly files = new Map<string, GitIgnoreRuleSet>();
+  private rules: GitIgnoreRuleSet[] = [];
+
+  constructor(root: string | URL) {
+    this.root = resolve(root instanceof URL ? fileURLToPath(root) : root);
+  }
+
+  /** Load every applicable `.gitignore` beneath {@link root}. */
+  static async load(
+    root: string | URL,
+    options: GitIgnoreLoadOptions = {},
+  ): Promise<GitIgnore> {
+    const result = new GitIgnore(root);
+    for (const path of await glob("**/.gitignore", discoveryOptions(result.root, options))) {
+      result.set(path, await readFile(resolve(result.root, path), "utf8"));
+    }
+    return result;
+  }
+
+  /** Synchronous counterpart to {@link GitIgnore.load}. */
+  static loadSync(root: string | URL, options: GitIgnoreLoadOptions = {}): GitIgnore {
+    const result = new GitIgnore(root);
+    for (const path of globSync("**/.gitignore", discoveryOptions(result.root, options))) {
+      result.set(path, readFileSync(resolve(result.root, path), "utf8"));
+    }
+    return result;
+  }
+
+  /** Whether `path` names a `.gitignore` control file. */
+  static isFile(path: string): boolean {
+    return basename(path) === ".gitignore";
+  }
+
+  /** Add or replace one `.gitignore` file and its in-memory content. */
+  set(path: string, content: string): void {
+    const relativePath = this.relativePath(path);
+    if (!relativePath || !GitIgnore.isFile(relativePath)) {
+      throw new TypeError(`Git ignore path must name a .gitignore under ${this.root}: ${path}`);
+    }
+    this.files.set(relativePath, {
+      content,
+      directory: toPosix(dirname(relativePath)) === "." ? "" : toPosix(dirname(relativePath)),
+      matcher: ignore().add(content),
+      path: relativePath,
+    });
+    this.refreshRules();
+  }
+
+  /** Remove one `.gitignore` file. Returns whether it was registered. */
+  delete(path: string): boolean {
+    const relativePath = this.relativePath(path);
+    if (!relativePath) return false;
+    const deleted = this.files.delete(relativePath);
+    if (deleted) this.refreshRules();
+    return deleted;
+  }
+
+  /** Remove every registered `.gitignore`. */
+  clear(): void {
+    this.files.clear();
+    this.rules = [];
+  }
+
+  /** Return the retained content for a registered `.gitignore`. */
+  get(path: string): string | undefined {
+    const relativePath = this.relativePath(path);
+    return relativePath ? this.files.get(relativePath)?.content : undefined;
+  }
+
+  /** Whether a path is ignored after applying parent then nested rule files. */
+  ignores(path: string, directory: boolean = false): boolean {
+    const relativePath = this.relativePath(path);
+    if (!relativePath || relativePath === ".") return false;
+    let ignored = false;
+    for (const rules of this.rules) {
+      const scopedPath = pathWithin(rules.directory, relativePath);
+      if (scopedPath === undefined || scopedPath === "") continue;
+      if (ignoredParent(rules.matcher, scopedPath)) return true;
+      const result = rules.matcher.test(directory ? `${trimSlash(scopedPath)}/` : scopedPath);
+      if (result.ignored) ignored = true;
+      if (result.unignored) ignored = false;
+    }
+    return ignored;
+  }
+
+  private relativePath(path: string): string | undefined {
+    const absolute = isAbsolute(path) ? resolve(path) : resolve(this.root, path);
+    const relativePath = relative(this.root, absolute);
+    if (relativePath === "" || relativePath === ".") return ".";
+    if (relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
+      return undefined;
+    }
+    return toPosix(relativePath);
+  }
+
+  private refreshRules(): void {
+    this.rules = [...this.files.values()].sort(
+      (left, right) =>
+        pathDepth(left.directory) - pathDepth(right.directory) ||
+        left.path.localeCompare(right.path),
+    );
+  }
+}
+
+function discoveryOptions(
+  root: string,
+  options: GitIgnoreLoadOptions,
+): {
+  cwd: string;
+  dot: true;
+  follow: boolean;
+  ignore: IgnoreLike;
+  nodir: true;
+} {
+  const matcher = ignorePathMatcher(options.ignoreOptions);
+  return {
+    cwd: root,
+    dot: true,
+    follow: options.followSymlinks ?? false,
+    ignore: {
+      ignored(path) {
+        const relativePath = path.relative();
+        return !GitIgnore.isFile(relativePath) && matcher(relativePath);
+      },
+      childrenIgnored(path) {
+        const relativePath = path.relative();
+        return matcher(relativePath) || matcher(`${relativePath}/`);
+      },
+    },
+    nodir: true,
+  };
+}
+
+function ignoredParent(matcher: ReturnType<typeof ignore>, path: string): boolean {
+  const segments = trimSlash(path).split("/");
+  const parentCount = segments.length - 1;
+  for (let index = 1; index <= parentCount; index++) {
+    if (matcher.test(`${segments.slice(0, index).join("/")}/`).ignored) return true;
+  }
+  return false;
+}
+
+function pathWithin(directory: string, path: string): string | undefined {
+  if (!directory) return path;
+  if (path === directory) return "";
+  return path.startsWith(`${directory}/`) ? path.slice(directory.length + 1) : undefined;
+}
+
+function pathDepth(path: string): number {
+  return path ? path.split("/").length : 0;
+}
+
+function trimSlash(path: string): string {
+  return path.replace(/^\/+|\/+$/g, "");
+}
+
+function toPosix(path: string): string {
+  return path.split(sep).join("/");
+}

package/src/scan.ts

@@ -8,7 +8,7 @@
  * @module
  */
 
-import { IgnorePatternOptions } from "./ignore.ts";
+import type { IgnorePatternOptions } from "./ignore.ts";
 import { PathMatchInput } from "./match.ts";
 
 /** Shared default used by file discovery and watching to avoid traversing symlinks. */
@@ -43,5 +43,11 @@ export interface FileScanOptions {
   signal?: AbortSignal;
 }
 
-/** Options controlling the generated ignore pattern list. */
-export type FileScanIgnoreOptions = IgnorePatternOptions;
+/** Options controlling built-in and repository `.gitignore` matching. */
+export interface FileScanIgnoreOptions extends IgnorePatternOptions {
+  /**
+   * Load root and nested `.gitignore` files using Git-compatible semantics.
+   * Defaults to false.
+   */
+  git?: boolean;
+}