@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/git/repo.js

@@ -0,0 +1,111 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var repo_exports = {};
+__export(repo_exports, {
+  findGitRoot: () => findGitRoot,
+  getCachedRealpath: () => getCachedRealpath,
+  getCwd: () => getCwd,
+  getFs: () => import_fs2.getNodeFs,
+  getPath: () => import_path2.getNodePath,
+  gitRootCache: () => gitRootCache,
+  realpathCache: () => realpathCache
+});
+module.exports = __toCommonJS(repo_exports);
+var import_node_process = __toESM(require("node:process"));
+var import_map_set = require("../primordials/map-set");
+var import_fs = require("../node/fs");
+var import_path = require("../node/path");
+var import_fs2 = require("../node/fs");
+var import_path2 = require("../node/path");
+const realpathCache = new import_map_set.MapCtor();
+const gitRootCache = new import_map_set.MapCtor();
+function findGitRoot(startPath) {
+  const fs = (0, import_fs.getNodeFs)();
+  const path = (0, import_path.getNodePath)();
+  const cached = gitRootCache.get(startPath);
+  if (cached) {
+    if (fs.existsSync(path.join(cached, ".git"))) {
+      return cached;
+    }
+    gitRootCache.delete(startPath);
+  }
+  let currentPath = startPath;
+  while (true) {
+    try {
+      const gitPath = path.join(currentPath, ".git");
+      if (fs.existsSync(gitPath)) {
+        gitRootCache.set(startPath, currentPath);
+        return currentPath;
+      }
+    } catch {
+    }
+    const parentPath = path.dirname(currentPath);
+    if (parentPath === currentPath) {
+      return startPath;
+    }
+    currentPath = parentPath;
+  }
+}
+function getCachedRealpath(pathname) {
+  const fs = (0, import_fs.getNodeFs)();
+  const cached = realpathCache.get(pathname);
+  if (cached) {
+    if (fs.existsSync(cached)) {
+      return cached;
+    }
+    realpathCache.delete(pathname);
+  }
+  let resolved;
+  try {
+    resolved = fs.realpathSync(pathname);
+  } catch (e) {
+    const code = e.code;
+    if (code === "ENOENT" || code === "ENOTDIR") {
+      throw e;
+    }
+    resolved = pathname;
+  }
+  realpathCache.set(pathname, resolved);
+  return resolved;
+}
+function getCwd() {
+  return getCachedRealpath(import_node_process.default.cwd());
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findGitRoot,
+  getCachedRealpath,
+  getCwd,
+  getFs,
+  getPath,
+  gitRootCache,
+  realpathCache
+});

package/dist/git/staged.d.ts

@@ -0,0 +1,138 @@
+/**
+ * @file "Ready for the next commit" helpers — `git diff --cached` over only the
+ *   index. Excludes unstaged tracked-file edits and untracked paths; use
+ *   `changed.ts` if you need the broader view.
+ */
+import type { GitDiffOptions } from './types';
+/**
+ * Get staged files ready for commit (changes added with `git add`).
+ *
+ * Uses `git diff --cached --name-only` which returns only staged changes. Does
+ * NOT include: - Unstaged modifications (changes not added with `git add`) -
+ * Untracked files (new files not added to git)
+ *
+ * This is a focused check for what will be included in the next commit. Useful
+ * for validating changes before committing or running pre-commit hooks.
+ *
+ * @example
+ *   ;```typescript
+ *   // Get currently staged files
+ *   const files = await getStagedFiles()
+ *   // => ['src/foo.ts']
+ *
+ *   // Stage more files
+ *   await spawn('git', ['add', 'src/bar.ts'])
+ *   const files = await getStagedFiles()
+ *   // => ['src/foo.ts', 'src/bar.ts']
+ *
+ *   // Get absolute paths
+ *   const files = await getStagedFiles({ absolute: true })
+ *   // => ['/path/to/repo/src/foo.ts', ...]
+ *   ```
+ *
+ * @param options - Options controlling path format and filtering.
+ *
+ * @returns Promise resolving to array of staged file paths.
+ */
+export declare function getStagedFiles(options?: GitDiffOptions | undefined): Promise<string[]>;
+/**
+ * Get staged files ready for commit (changes added with `git add`).
+ *
+ * Synchronous version of `getStagedFiles()`. Uses `git diff --cached
+ * --name-only` which returns only staged changes. Does NOT include: - Unstaged
+ * modifications (changes not added with `git add`) - Untracked files (new files
+ * not added to git)
+ *
+ * This is a focused check for what will be included in the next commit. Useful
+ * for validating changes before committing or running pre-commit hooks.
+ *
+ * @example
+ *   ;```typescript
+ *   // Get currently staged files
+ *   const files = getStagedFilesSync()
+ *   // => ['src/foo.ts']
+ *
+ *   // Stage more files
+ *   spawnSync('git', ['add', 'src/bar.ts'])
+ *   const files = getStagedFilesSync()
+ *   // => ['src/foo.ts', 'src/bar.ts']
+ *
+ *   // Get absolute paths
+ *   const files = getStagedFilesSync({ absolute: true })
+ *   // => ['/path/to/repo/src/foo.ts', ...]
+ *   ```
+ *
+ * @param options - Options controlling path format and filtering.
+ *
+ * @returns Array of staged file paths.
+ */
+export declare function getStagedFilesSync(options?: GitDiffOptions | undefined): string[];
+/**
+ * Check if a file or directory is staged for commit.
+ *
+ * Checks if the given pathname has changes staged with `git add` that will be
+ * included in the next commit. Does NOT include: - Unstaged modifications
+ * (changes not added with `git add`) - Untracked files (new files not in git)
+ *
+ * For directories, returns `true` if ANY file within the directory is staged.
+ *
+ * Symlinks in the pathname and cwd are automatically resolved using
+ * `fs.realpathSync()` before comparison.
+ *
+ * @example
+ *   ;```typescript
+ *   // Check if file is staged
+ *   const staged = await isStaged('src/foo.ts')
+ *   // => false
+ *
+ *   // Stage the file
+ *   await spawn('git', ['add', 'src/foo.ts'])
+ *   const staged = await isStaged('src/foo.ts')
+ *   // => true
+ *
+ *   // Check directory
+ *   const staged = await isStaged('src/')
+ *   // => true (if any file in src/ is staged)
+ *   ```
+ *
+ * @param pathname - File or directory path to check.
+ * @param options - Options for the git diff check.
+ *
+ * @returns Promise resolving to `true` if path is staged, `false` otherwise.
+ */
+export declare function isStaged(pathname: string, options?: GitDiffOptions | undefined): Promise<boolean>;
+/**
+ * Check if a file or directory is staged for commit.
+ *
+ * Synchronous version of `isStaged()`. Checks if the given pathname has changes
+ * staged with `git add` that will be included in the next commit. Does NOT
+ * include: - Unstaged modifications (changes not added with `git add`) -
+ * Untracked files (new files not in git)
+ *
+ * For directories, returns `true` if ANY file within the directory is staged.
+ *
+ * Symlinks in the pathname and cwd are automatically resolved using
+ * `fs.realpathSync()` before comparison.
+ *
+ * @example
+ *   ;```typescript
+ *   // Check if file is staged
+ *   const staged = isStagedSync('src/foo.ts')
+ *   // => false
+ *
+ *   // Stage the file
+ *   spawnSync('git', ['add', 'src/foo.ts'])
+ *   const staged = isStagedSync('src/foo.ts')
+ *   // => true
+ *
+ *   // Check directory
+ *   const staged = isStagedSync('src/')
+ *   // => true (if any file in src/ is staged)
+ *   ```
+ *
+ * @param pathname - File or directory path to check.
+ * @param options - Options for the git diff check.
+ *
+ * @returns `true` if path is staged, `false` otherwise.
+ */
+export declare function isStagedSync(pathname: string, options?: GitDiffOptions | undefined): boolean;

package/dist/git/staged.js

@@ -0,0 +1,71 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var staged_exports = {};
+__export(staged_exports, {
+  getStagedFiles: () => getStagedFiles,
+  getStagedFilesSync: () => getStagedFilesSync,
+  isStaged: () => isStaged,
+  isStagedSync: () => isStagedSync
+});
+module.exports = __toCommonJS(staged_exports);
+var import_normalize = require("../paths/normalize");
+var import_array = require("../primordials/array");
+var import_internal = require("./_internal");
+var import_repo = require("./repo");
+async function getStagedFiles(options) {
+  const args = (0, import_internal.getGitDiffSpawnArgs)(options?.cwd).staged;
+  return await (0, import_internal.innerDiff)(args, options);
+}
+function getStagedFilesSync(options) {
+  const args = (0, import_internal.getGitDiffSpawnArgs)(options?.cwd).staged;
+  return (0, import_internal.innerDiffSync)(args, options);
+}
+async function isStaged(pathname, options) {
+  const files = await getStagedFiles({
+    __proto__: null,
+    ...options,
+    absolute: false
+  });
+  const path = (0, import_repo.getPath)();
+  const resolvedPathname = (0, import_repo.getCachedRealpath)(pathname);
+  const baseCwd = options?.cwd ? (0, import_repo.getCachedRealpath)(options["cwd"]) : (0, import_repo.getCwd)();
+  const relativePath = (0, import_normalize.normalizePath)(path.relative(baseCwd, resolvedPathname));
+  return (0, import_array.ArrayPrototypeIncludes)(files, relativePath);
+}
+function isStagedSync(pathname, options) {
+  const files = getStagedFilesSync({
+    __proto__: null,
+    ...options,
+    absolute: false
+  });
+  const path = (0, import_repo.getPath)();
+  const resolvedPathname = (0, import_repo.getCachedRealpath)(pathname);
+  const baseCwd = options?.cwd ? (0, import_repo.getCachedRealpath)(options["cwd"]) : (0, import_repo.getCwd)();
+  const relativePath = (0, import_normalize.normalizePath)(path.relative(baseCwd, resolvedPathname));
+  return (0, import_array.ArrayPrototypeIncludes)(files, relativePath);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getStagedFiles,
+  getStagedFilesSync,
+  isStaged,
+  isStagedSync
+});

package/dist/git/types.d.ts

@@ -0,0 +1,109 @@
+/**
+ * @file Public type surface for `git/*` modules — the
+ *   `FilterPackagesByChangesOptions` and `GitDiffOptions` configuration
+ *   records. Pure types, no runtime side effects.
+ */
+/**
+ * Options for filtering packages by git changes.
+ *
+ * Used to determine which packages in a monorepo have changed files.
+ *
+ * @example
+ *   ;```typescript
+ *   // Filter packages with changes
+ *   const changed = filterPackagesByChanges(packages)
+ *
+ *   // Force include all packages
+ *   const all = filterPackagesByChanges(packages, { force: true })
+ *
+ *   // Use custom package key
+ *   const changed = filterPackagesByChanges(packages, {
+ *     packageKey: 'directory',
+ *   })
+ *   ```
+ */
+export interface FilterPackagesByChangesOptions {
+    /**
+     * Force include all packages regardless of changes.
+     *
+     * @default false
+     */
+    force?: boolean | undefined;
+    /**
+     * Key to access package path in package objects.
+     *
+     * @default 'path'
+     */
+    packageKey?: string | undefined;
+    /**
+     * Additional options for filtering.
+     */
+    [key: string]: unknown;
+}
+/**
+ * Options for git diff operations.
+ *
+ * Controls how git diff results are processed and returned.
+ *
+ * @example
+ *   ;```typescript
+ *   // Get absolute file paths
+ *   const files = await getChangedFiles({ absolute: true })
+ *   // => ['/path/to/repo/src/file.ts']
+ *
+ *   // Get relative paths with caching disabled
+ *   const files = await getChangedFiles({ cache: false })
+ *   // => ['src/file.ts']
+ *
+ *   // Get files from specific directory
+ *   const files = await getChangedFiles({ cwd: '/path/to/repo/src' })
+ *   ```
+ */
+export interface GitDiffOptions {
+    /**
+     * Return absolute file paths instead of relative paths.
+     *
+     * @default false
+     */
+    absolute?: boolean | undefined;
+    /**
+     * Return results as a `Set` instead of an array.
+     *
+     * @default false
+     */
+    asSet?: boolean | undefined;
+    /**
+     * Cache git diff results to avoid repeated git subprocess calls.
+     *
+     * Caching is keyed by the git command and options used, so different option
+     * combinations maintain separate cache entries.
+     *
+     * @default true
+     */
+    cache?: boolean | undefined;
+    /**
+     * Working directory for git operations.
+     *
+     * Git operations will be run from this directory, and returned paths will be
+     * relative to the git repository root. Symlinks are resolved using
+     * `fs.realpathSync()`.
+     *
+     * @default process.cwd()
+     */
+    cwd?: string | undefined;
+    /**
+     * Parse git porcelain format output (status codes like `M`, `A`, `??`).
+     *
+     * When `true`, strips the two-character status code and space from the
+     * beginning of each line. Automatically enabled for `getChangedFiles()`.
+     *
+     * @default false
+     */
+    porcelain?: boolean | undefined;
+    /**
+     * Additional options passed to glob matcher.
+     *
+     * Supports options like `dot`, `ignore`, `nocase` for filtering results.
+     */
+    [key: string]: unknown;
+}

package/dist/git/types.js

@@ -0,0 +1,18 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/git/unstaged.d.ts

@@ -0,0 +1,141 @@
+/**
+ * @file "Edited but not yet staged" helpers — `git diff` over the working tree
+ *   only. Excludes index-staged changes and untracked paths; use `changed.ts`
+ *   for the broader view or `staged.ts` for the index.
+ */
+import type { GitDiffOptions } from './types';
+/**
+ * Get unstaged modified files (changes not yet staged for commit).
+ *
+ * Uses `git diff --name-only` which returns only unstaged modifications to
+ * tracked files. Does NOT include: - Untracked files (new files not added to
+ * git) - Staged changes (files added with `git add`)
+ *
+ * This is a focused check for uncommitted changes to existing tracked files.
+ * Useful for detecting work-in-progress modifications before staging.
+ *
+ * @example
+ *   ;```typescript
+ *   // Get unstaged files
+ *   const files = await getUnstagedFiles()
+ *   // => ['src/foo.ts', 'src/bar.ts']
+ *
+ *   // After staging some files
+ *   await spawn('git', ['add', 'src/foo.ts'])
+ *   const files = await getUnstagedFiles()
+ *   // => ['src/bar.ts'] (foo.ts no longer included)
+ *
+ *   // Get absolute paths
+ *   const files = await getUnstagedFiles({ absolute: true })
+ *   // => ['/path/to/repo/src/bar.ts']
+ *   ```
+ *
+ * @param options - Options controlling path format and filtering.
+ *
+ * @returns Promise resolving to array of unstaged file paths.
+ */
+export declare function getUnstagedFiles(options?: GitDiffOptions | undefined): Promise<string[]>;
+/**
+ * Get unstaged modified files (changes not yet staged for commit).
+ *
+ * Synchronous version of `getUnstagedFiles()`. Uses `git diff --name-only`
+ * which returns only unstaged modifications to tracked files. Does NOT include:
+ * - Untracked files (new files not added to git) - Staged changes (files added
+ * with `git add`)
+ *
+ * This is a focused check for uncommitted changes to existing tracked files.
+ * Useful for detecting work-in-progress modifications before staging.
+ *
+ * @example
+ *   ;```typescript
+ *   // Get unstaged files
+ *   const files = getUnstagedFilesSync()
+ *   // => ['src/foo.ts', 'src/bar.ts']
+ *
+ *   // After staging some files
+ *   spawnSync('git', ['add', 'src/foo.ts'])
+ *   const files = getUnstagedFilesSync()
+ *   // => ['src/bar.ts'] (foo.ts no longer included)
+ *
+ *   // Get absolute paths
+ *   const files = getUnstagedFilesSync({ absolute: true })
+ *   // => ['/path/to/repo/src/bar.ts']
+ *   ```
+ *
+ * @param options - Options controlling path format and filtering.
+ *
+ * @returns Array of unstaged file paths.
+ */
+export declare function getUnstagedFilesSync(options?: GitDiffOptions | undefined): string[];
+/**
+ * Check if a file or directory has unstaged changes.
+ *
+ * Checks if the given pathname has modifications that are not yet staged for
+ * commit (changes not added with `git add`). Does NOT include: - Staged changes
+ * (already added with `git add`) - Untracked files (new files not in git)
+ *
+ * For directories, returns `true` if ANY file within the directory has unstaged
+ * changes.
+ *
+ * Symlinks in the pathname and cwd are automatically resolved using
+ * `fs.realpathSync()` before comparison.
+ *
+ * @example
+ *   ;```typescript
+ *   // Check if file has unstaged changes
+ *   const unstaged = await isUnstaged('src/foo.ts')
+ *   // => true
+ *
+ *   // After staging the file
+ *   await spawn('git', ['add', 'src/foo.ts'])
+ *   const unstaged = await isUnstaged('src/foo.ts')
+ *   // => false
+ *
+ *   // Check directory
+ *   const unstaged = await isUnstaged('src/')
+ *   // => true (if any file in src/ has unstaged changes)
+ *   ```
+ *
+ * @param pathname - File or directory path to check.
+ * @param options - Options for the git diff check.
+ *
+ * @returns Promise resolving to `true` if path has unstaged changes, `false`
+ *   otherwise.
+ */
+export declare function isUnstaged(pathname: string, options?: GitDiffOptions | undefined): Promise<boolean>;
+/**
+ * Check if a file or directory has unstaged changes.
+ *
+ * Synchronous version of `isUnstaged()`. Checks if the given pathname has
+ * modifications that are not yet staged for commit (changes not added with `git
+ * add`). Does NOT include: - Staged changes (already added with `git add`) -
+ * Untracked files (new files not in git)
+ *
+ * For directories, returns `true` if ANY file within the directory has unstaged
+ * changes.
+ *
+ * Symlinks in the pathname and cwd are automatically resolved using
+ * `fs.realpathSync()` before comparison.
+ *
+ * @example
+ *   ;```typescript
+ *   // Check if file has unstaged changes
+ *   const unstaged = isUnstagedSync('src/foo.ts')
+ *   // => true
+ *
+ *   // After staging the file
+ *   spawnSync('git', ['add', 'src/foo.ts'])
+ *   const unstaged = isUnstagedSync('src/foo.ts')
+ *   // => false
+ *
+ *   // Check directory
+ *   const unstaged = isUnstagedSync('src/')
+ *   // => true (if any file in src/ has unstaged changes)
+ *   ```
+ *
+ * @param pathname - File or directory path to check.
+ * @param options - Options for the git diff check.
+ *
+ * @returns `true` if path has unstaged changes, `false` otherwise.
+ */
+export declare function isUnstagedSync(pathname: string, options?: GitDiffOptions | undefined): boolean;

package/dist/git/unstaged.js

@@ -0,0 +1,71 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var unstaged_exports = {};
+__export(unstaged_exports, {
+  getUnstagedFiles: () => getUnstagedFiles,
+  getUnstagedFilesSync: () => getUnstagedFilesSync,
+  isUnstaged: () => isUnstaged,
+  isUnstagedSync: () => isUnstagedSync
+});
+module.exports = __toCommonJS(unstaged_exports);
+var import_normalize = require("../paths/normalize");
+var import_array = require("../primordials/array");
+var import_internal = require("./_internal");
+var import_repo = require("./repo");
+async function getUnstagedFiles(options) {
+  const args = (0, import_internal.getGitDiffSpawnArgs)(options?.cwd).unstaged;
+  return await (0, import_internal.innerDiff)(args, options);
+}
+function getUnstagedFilesSync(options) {
+  const args = (0, import_internal.getGitDiffSpawnArgs)(options?.cwd).unstaged;
+  return (0, import_internal.innerDiffSync)(args, options);
+}
+async function isUnstaged(pathname, options) {
+  const files = await getUnstagedFiles({
+    __proto__: null,
+    ...options,
+    absolute: false
+  });
+  const path = (0, import_repo.getPath)();
+  const resolvedPathname = (0, import_repo.getCachedRealpath)(pathname);
+  const baseCwd = options?.cwd ? (0, import_repo.getCachedRealpath)(options["cwd"]) : (0, import_repo.getCwd)();
+  const relativePath = (0, import_normalize.normalizePath)(path.relative(baseCwd, resolvedPathname));
+  return (0, import_array.ArrayPrototypeIncludes)(files, relativePath);
+}
+function isUnstagedSync(pathname, options) {
+  const files = getUnstagedFilesSync({
+    __proto__: null,
+    ...options,
+    absolute: false
+  });
+  const path = (0, import_repo.getPath)();
+  const resolvedPathname = (0, import_repo.getCachedRealpath)(pathname);
+  const baseCwd = options?.cwd ? (0, import_repo.getCachedRealpath)(options["cwd"]) : (0, import_repo.getCwd)();
+  const relativePath = (0, import_normalize.normalizePath)(path.relative(baseCwd, resolvedPathname));
+  return (0, import_array.ArrayPrototypeIncludes)(files, relativePath);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getUnstagedFiles,
+  getUnstagedFilesSync,
+  isUnstaged,
+  isUnstagedSync
+});

package/dist/github/constants.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @file GitHub API URL + cache-TTL constants. Inlined so values are captured at
+ *   coverage-mode bundle time rather than referenced through a module graph
+ *   indirection.
+ */
+/**
+ * GitHub REST API base URL.
+ */
+export declare const GITHUB_API_BASE_URL = "https://api.github.com";
+/**
+ * GitHub GraphQL API endpoint.
+ */
+export declare const GITHUB_GRAPHQL_URL = "https://api.github.com/graphql";
+/**
+ * Default TTL for the GitHub cache (5 minutes). Used by ref resolution and the
+ * GHSA cache layer.
+ */
+export declare const DEFAULT_CACHE_TTL_MS: number;