@socketsecurity/lib 5.28.0 → 6.0.0

package/dist/git/changed.js

@@ -0,0 +1,83 @@
+"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 changed_exports = {};
+__export(changed_exports, {
+  getChangedFiles: () => getChangedFiles,
+  getChangedFilesSync: () => getChangedFilesSync,
+  isChanged: () => isChanged,
+  isChangedSync: () => isChangedSync
+});
+module.exports = __toCommonJS(changed_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 getChangedFiles(options) {
+  const args = (0, import_internal.getGitDiffSpawnArgs)(options?.cwd).all;
+  return await (0, import_internal.innerDiff)(args, {
+    __proto__: null,
+    ...options,
+    porcelain: true
+  });
+}
+function getChangedFilesSync(options) {
+  const args = (0, import_internal.getGitDiffSpawnArgs)(options?.cwd).all;
+  return (0, import_internal.innerDiffSync)(args, {
+    __proto__: null,
+    ...options,
+    porcelain: true
+  });
+}
+async function isChanged(pathname, options) {
+  const files = await getChangedFiles({
+    __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 isChangedSync(pathname, options) {
+  const files = getChangedFilesSync({
+    __proto__: null,
+    ...options,
+    absolute: false
+  });
+  const path = (0, import_repo.getPath)();
+  try {
+    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);
+  } catch {
+    return false;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getChangedFiles,
+  getChangedFilesSync,
+  isChanged,
+  isChangedSync
+});

package/dist/git/repo.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @file Git repository discovery + foundational lazy fs/path/cwd helpers shared
+ *   across `git/*` leaves. Owns `findGitRoot`, the realpath cache, the cwd
+ *   resolver, and the lazy `node:fs` / `node:path` loaders — pulling these
+ *   together keeps the dependency direction one-way: `_internal.ts` and the
+ *   public-surface leaves all import from here.
+ */
+export declare const realpathCache: Map<string, string>;
+export declare const gitRootCache: Map<string, string>;
+/**
+ * Find git repository root by walking up from the given directory.
+ *
+ * Searches for a `.git` directory or file by traversing parent directories
+ * upward until found or filesystem root is reached. Returns the original path
+ * if no git repository is found.
+ *
+ * This function is exported primarily for testing purposes.
+ *
+ * @example
+ *   ;```typescript
+ *   const root = findGitRoot('/path/to/repo/src/subdir')
+ *   // => '/path/to/repo'
+ *
+ *   const notFound = findGitRoot('/not/a/repo')
+ *   // => '/not/a/repo'
+ *   ```
+ *
+ * @param startPath - Directory path to start searching from.
+ *
+ * @returns Git repository root path, or `startPath` if not found.
+ */
+export declare function findGitRoot(startPath: string): string;
+/**
+ * Get the real path with caching to avoid repeated filesystem calls. Validates
+ * cache with existsSync() which is cheaper than realpathSync().
+ *
+ * ENOENT/ENOTDIR are re-thrown because the caller explicitly passed a path they
+ * expect to exist — swallowing these would turn "file not found" into a silent
+ * no-op. Other errors (EACCES, EPERM, EIO) fall back to the input path since
+ * they can happen on container/overlay filesystems where the path exists but
+ * realpath resolution is restricted.
+ */
+export declare function getCachedRealpath(pathname: string): string;
+/**
+ * Get the current working directory for git operations.
+ *
+ * Returns the real path to handle symlinks correctly. This is important because
+ * symlinked directories like `/tmp -> /private/tmp` can cause path mismatches
+ * when comparing git output.
+ *
+ * @example
+ *   ;```typescript
+ *   const cwd = getCwd()
+ *   // In /tmp (symlink to /private/tmp):
+ *   // => '/private/tmp'
+ *   ```
+ *
+ * @returns The resolved real path of `process.cwd()`.
+ */
+export declare function getCwd(): string;
+export { getNodeFs as getFs } from '../node/fs';
+export { getNodePath as getPath } from '../node/path';

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);