@socketsecurity/lib 6.0.2 → 6.0.4

package/dist/git/changed.js

@@ -1,83 +1,200 @@
 "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");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_paths_normalize = require('../paths/normalize.js');
+const require_primordials_array = require('../primordials/array.js');
+const require_node_path = require('../node/path.js');
+const require_git_repo = require('./repo.js');
+const require_git__internal = require('./_internal.js');
+
+//#region src/git/changed.ts
+/**
+* @file "Anything different from HEAD" helpers — the broad-strokes `git status
+*   --porcelain` view that lumps staged, unstaged, and untracked paths
+*   together. Use these when you want a single answer to "did anything
+*   change?"; reach for `staged.ts` / `unstaged.ts` when the distinction
+*   matters.
+*/
+/**
+* Get all changed files including staged, unstaged, and untracked files.
+*
+* Uses `git status --porcelain` which returns the full working tree status with
+* status codes: - `M` - Modified - `A` - Added - `D` - Deleted - `??` -
+* Untracked - `R` - Renamed - `C` - Copied.
+*
+* This is the most comprehensive check - captures everything that differs from
+* the last commit, including: - Files modified and staged with `git add` -
+* Files modified but not staged - New files not yet tracked by git.
+*
+* Status codes are automatically stripped from the output.
+*
+* @example
+*   ;```typescript
+*   // Get all changed files as relative paths
+*   const files = await getChangedFiles()
+*   // => ['src/foo.ts', 'src/bar.ts', 'newfile.ts']
+*
+*   // Get absolute paths
+*   const files = await getChangedFiles({ absolute: true })
+*   // => ['/path/to/repo/src/foo.ts', ...]
+*
+*   // Get changed files in specific directory
+*   const files = await getChangedFiles({ cwd: '/path/to/repo/src' })
+*   // => ['foo.ts', 'bar.ts']
+*   ```
+*
+* @param options - Options controlling path format and filtering.
+*
+* @returns Promise resolving to array of changed file paths.
+*/
 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
-  });
+	const args = require_git__internal.getGitDiffSpawnArgs(options?.cwd).all;
+	return await require_git__internal.innerDiff(args, {
+		__proto__: null,
+		...options,
+		porcelain: true
+	});
 }
+/**
+* Get all changed files including staged, unstaged, and untracked files.
+*
+* Synchronous version of `getChangedFiles()`. Uses `git status --porcelain`
+* which returns the full working tree status with status codes: - `M` -
+* Modified - `A` - Added - `D` - Deleted - `??` - Untracked - `R` - Renamed -
+* `C` - Copied.
+*
+* This is the most comprehensive check - captures everything that differs from
+* the last commit, including: - Files modified and staged with `git add` -
+* Files modified but not staged - New files not yet tracked by git.
+*
+* Status codes are automatically stripped from the output.
+*
+* @example
+*   ;```typescript
+*   // Get all changed files as relative paths
+*   const files = getChangedFilesSync()
+*   // => ['src/foo.ts', 'src/bar.ts', 'newfile.ts']
+*
+*   // Get absolute paths
+*   const files = getChangedFilesSync({ absolute: true })
+*   // => ['/path/to/repo/src/foo.ts', ...]
+*
+*   // Get changed files in specific directory
+*   const files = getChangedFilesSync({ cwd: '/path/to/repo/src' })
+*   // => ['foo.ts', 'bar.ts']
+*   ```
+*
+* @param options - Options controlling path format and filtering.
+*
+* @returns Array of changed file paths.
+*/
 function getChangedFilesSync(options) {
-  const args = (0, import_internal.getGitDiffSpawnArgs)(options?.cwd).all;
-  return (0, import_internal.innerDiffSync)(args, {
-    __proto__: null,
-    ...options,
-    porcelain: true
-  });
+	const args = require_git__internal.getGitDiffSpawnArgs(options?.cwd).all;
+	return require_git__internal.innerDiffSync(args, {
+		__proto__: null,
+		...options,
+		porcelain: true
+	});
 }
+/**
+* Check if a file or directory has any git changes.
+*
+* Checks if the given pathname has any changes including: - Staged
+* modifications (added with `git add`) - Unstaged modifications (not yet
+* staged) - Untracked status (new file/directory not in git)
+*
+* For directories, returns `true` if ANY file within the directory has changes.
+*
+* Symlinks in the pathname and cwd are automatically resolved using
+* `fs.realpathSync()` before comparison.
+*
+* @example
+*   ;```typescript
+*   // Check if file is changed
+*   const changed = await isChanged('src/foo.ts')
+*   // => true
+*
+*   // Check if directory has any changes
+*   const changed = await isChanged('src/')
+*   // => true (if any file in src/ is changed)
+*
+*   // Check from different cwd
+*   const changed = await isChanged('/path/to/repo/src/foo.ts', {
+*     cwd: '/path/to/repo',
+*   })
+*   ```
+*
+* @param pathname - File or directory path to check.
+* @param options - Options for the git status check.
+*
+* @returns Promise resolving to `true` if path has any changes, `false`
+*   otherwise.
+*/
 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);
+	const files = await getChangedFiles({
+		__proto__: null,
+		...options,
+		absolute: false
+	});
+	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const resolvedPathname = require_git_repo.getCachedRealpath(pathname);
+	/* c8 ignore start */
+	const baseCwd = options?.cwd ? require_git_repo.getCachedRealpath(options["cwd"]) : require_git_repo.getCwd();
+	return require_primordials_array.ArrayPrototypeIncludes(files, /* @__PURE__ */ require_paths_normalize.normalizePath(path.relative(baseCwd, resolvedPathname)));
 }
+/**
+* Check if a file or directory has any git changes.
+*
+* Synchronous version of `isChanged()`. Checks if the given pathname has any
+* changes including: - Staged modifications (added with `git add`) - Unstaged
+* modifications (not yet staged) - Untracked status (new file/directory not in
+* git)
+*
+* For directories, returns `true` if ANY file within the directory has changes.
+*
+* Symlinks in the pathname and cwd are automatically resolved using
+* `fs.realpathSync()` before comparison.
+*
+* @example
+*   ;```typescript
+*   // Check if file is changed
+*   const changed = isChangedSync('src/foo.ts')
+*   // => true
+*
+*   // Check if directory has any changes
+*   const changed = isChangedSync('src/')
+*   // => true (if any file in src/ is changed)
+*
+*   // Check from different cwd
+*   const changed = isChangedSync('/path/to/repo/src/foo.ts', {
+*     cwd: '/path/to/repo',
+*   })
+*   ```
+*
+* @param pathname - File or directory path to check.
+* @param options - Options for the git status check.
+*
+* @returns `true` if path has any changes, `false` otherwise.
+*/
 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;
-  }
+	const files = getChangedFilesSync({
+		__proto__: null,
+		...options,
+		absolute: false
+	});
+	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	try {
+		const resolvedPathname = require_git_repo.getCachedRealpath(pathname);
+		/* c8 ignore start */
+		const baseCwd = options?.cwd ? require_git_repo.getCachedRealpath(options["cwd"]) : require_git_repo.getCwd();
+		return require_primordials_array.ArrayPrototypeIncludes(files, /* @__PURE__ */ require_paths_normalize.normalizePath(path.relative(baseCwd, resolvedPathname)));
+	} catch {
+		return false;
+	}
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getChangedFiles,
-  getChangedFilesSync,
-  isChanged,
-  isChangedSync
-});
+
+//#endregion
+exports.getChangedFiles = getChangedFiles;
+exports.getChangedFilesSync = getChangedFilesSync;
+exports.isChanged = isChanged;
+exports.isChangedSync = isChangedSync;

package/dist/git/repo.js

@@ -1,111 +1,125 @@
 "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();
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_primordials_map_set = require('../primordials/map-set.js');
+const require_node_fs = require('../node/fs.js');
+const require_node_path = require('../node/path.js');
+let node_process = require("node:process");
+node_process = require_runtime.__toESM(node_process);
+
+//#region src/git/repo.ts
+/**
+* @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.
+*/
+const realpathCache = new require_primordials_map_set.MapCtor();
+const gitRootCache = new require_primordials_map_set.MapCtor();
+/**
+* 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.
+*/
 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;
-  }
+	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	/* c8 ignore start */
+	const cached = gitRootCache.get(startPath);
+	if (cached) {
+		if (fs.existsSync(path.join(cached, ".git"))) return cached;
+		gitRootCache.delete(startPath);
+	}
+	/* c8 ignore stop */
+	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;
+	}
 }
+/**
+* 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.
+*/
 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;
+	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const cached = realpathCache.get(pathname);
+	/* c8 ignore start */
+	if (cached) {
+		if (fs.existsSync(cached)) return cached;
+		realpathCache.delete(pathname);
+	}
+	/* c8 ignore stop */
+	let resolved;
+	try {
+		resolved = fs.realpathSync(pathname);
+	} catch (e) {
+		const code = e.code;
+		if (code === "ENOENT" || code === "ENOTDIR") throw e;
+		resolved = pathname;
+	}
+	/* c8 ignore stop */
+	realpathCache.set(pathname, resolved);
+	return resolved;
 }
+/**
+* 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()`.
+*/
 function getCwd() {
-  return getCachedRealpath(import_node_process.default.cwd());
+	return getCachedRealpath(node_process.default.cwd());
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  findGitRoot,
-  getCachedRealpath,
-  getCwd,
-  getFs,
-  getPath,
-  gitRootCache,
-  realpathCache
-});
+
+//#endregion
+exports.findGitRoot = findGitRoot;
+exports.getCachedRealpath = getCachedRealpath;
+exports.getCwd = getCwd;
+exports.getFs = require_node_fs.getNodeFs;
+exports.getPath = require_node_path.getNodePath;
+exports.gitRootCache = gitRootCache;
+exports.realpathCache = realpathCache;