@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/git/_internal.d.ts

@@ -0,0 +1,105 @@
+/**
+ * @file Cross-leaf diff machinery for `git/*`. Owns the LRU+TTL git-diff cache,
+ *   the spawn-args builder, the porcelain-output parser, and the async/sync
+ *   `innerDiff` runners. Public-surface leaves (`changed.ts`, `staged.ts`,
+ *   `unstaged.ts`) call into these helpers; nothing else should.
+ */
+import type { GitDiffOptions } from './types';
+export type SpawnArgs = [string, string[], Record<string, unknown>];
+export interface GitDiffSpawnArgs {
+    all: SpawnArgs;
+    unstaged: SpawnArgs;
+    staged: SpawnArgs;
+}
+export type GitDiffCacheEntry = {
+    readonly expiresAt: number;
+    readonly result: string[];
+};
+export declare const gitDiffCache: Map<string, GitDiffCacheEntry>;
+export declare const GIT_CACHE_MAX_SIZE = 100;
+export declare const GIT_CACHE_TTL_MS = 2000;
+export declare function getCachedGitDiff(key: string): string[] | undefined;
+/**
+ * Get spawn arguments for different git diff operations.
+ *
+ * Prepares argument arrays for `spawn()`/`spawnSync()` calls that retrieve: -
+ * `all`: All changed files (staged, unstaged, untracked) via `git status
+ * --porcelain` - `unstaged`: Unstaged modifications via `git diff --name-only`
+ * - `staged`: Staged changes via `git diff --cached --name-only`
+ *
+ * Automatically resolves symlinks in the provided `cwd` and enables shell mode
+ * on Windows for proper command execution.
+ *
+ * @param cwd - Working directory for git operations, defaults to
+ *   `process.cwd()`.
+ *
+ * @returns Object containing spawn arguments for all, unstaged, and staged
+ *   operations.
+ */
+export declare function getGitDiffSpawnArgs(cwd?: string | undefined): GitDiffSpawnArgs;
+/**
+ * Get the git executable path.
+ *
+ * Resolves the git binary path via PATH on first call and caches it. Falls back
+ * to 'git' if not found in PATH.
+ *
+ * @example
+ *   ;```typescript
+ *   const git = getGitPath()
+ *   // => '/usr/bin/git' or 'git' if not found
+ *   ```
+ *
+ * @returns The git executable path (resolved from PATH on first call).
+ */
+export declare function getGitPath(): string;
+/**
+ * Execute git diff command asynchronously and parse results.
+ *
+ * Internal helper for async git operations. Handles caching, command execution,
+ * and result parsing. Returns empty array on git command failure.
+ *
+ * @param args - Spawn arguments tuple `[command, args, options]`.
+ * @param options - Git diff options for caching and parsing.
+ *
+ * @returns Promise resolving to array of file paths.
+ */
+export declare function innerDiff(args: SpawnArgs, options?: GitDiffOptions | undefined): Promise<string[]>;
+/**
+ * Execute git diff command synchronously and parse results.
+ *
+ * Internal helper for sync git operations. Handles caching, command execution,
+ * and result parsing. Returns empty array on git command failure.
+ *
+ * @param args - Spawn arguments tuple `[command, args, options]`.
+ * @param options - Git diff options for caching and parsing.
+ *
+ * @returns Array of file paths.
+ */
+export declare function innerDiffSync(args: SpawnArgs, options?: GitDiffOptions | undefined): string[];
+/**
+ * Parse git diff stdout output into file path array.
+ *
+ * Internal helper that processes raw git command output by: 1. Finding git
+ * repository root from spawn cwd 2. Stripping ANSI codes and splitting into
+ * lines 3. Parsing porcelain format status codes if requested 4. Normalizing
+ * and optionally making paths absolute 5. Filtering paths based on cwd and glob
+ * options.
+ *
+ * Git always returns paths relative to the repository root, regardless of where
+ * the command was executed. This function handles the path resolution correctly
+ * by finding the repo root and adjusting paths accordingly.
+ *
+ * @param stdout - Raw stdout from git command.
+ * @param options - Git diff options for path processing.
+ * @param spawnCwd - Working directory where git command was executed.
+ *
+ * @returns Array of processed file paths.
+ */
+export declare function parseGitDiffStdout(stdout: string, options?: GitDiffOptions | undefined, spawnCwd?: string | undefined): string[];
+export declare function setCachedGitDiff(key: string, result: string[]): void;
+/**
+ * Build a stable cache key that is insensitive to object-property insertion
+ * order, so callers passing the same options with different shapes hit the same
+ * cache slot.
+ */
+export declare function stableKey(value: unknown): string;

package/dist/git/_internal.js

@@ -0,0 +1,236 @@
+"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 internal_exports = {};
+__export(internal_exports, {
+  GIT_CACHE_MAX_SIZE: () => GIT_CACHE_MAX_SIZE,
+  GIT_CACHE_TTL_MS: () => GIT_CACHE_TTL_MS,
+  getCachedGitDiff: () => getCachedGitDiff,
+  getGitDiffSpawnArgs: () => getGitDiffSpawnArgs,
+  getGitPath: () => getGitPath,
+  gitDiffCache: () => gitDiffCache,
+  innerDiff: () => innerDiff,
+  innerDiffSync: () => innerDiffSync,
+  parseGitDiffStdout: () => parseGitDiffStdout,
+  setCachedGitDiff: () => setCachedGitDiff,
+  stableKey: () => stableKey
+});
+module.exports = __toCommonJS(internal_exports);
+var import_which = require("../bin/which");
+var import_output = require("../debug/output");
+var import_matcher = require("../globs/matcher");
+var import_normalize = require("../paths/normalize");
+var import_array = require("../primordials/array");
+var import_buffer = require("../primordials/buffer");
+var import_json = require("../primordials/json");
+var import_map_set = require("../primordials/map-set");
+var import_object = require("../primordials/object");
+var import_string = require("../primordials/string");
+var import_child = require("../process/spawn/child");
+var import_strip = require("../ansi/strip");
+var import_repo = require("./repo");
+const gitDiffCache = new import_map_set.MapCtor();
+const GIT_CACHE_MAX_SIZE = 100;
+const GIT_CACHE_TTL_MS = 2e3;
+let _gitPath;
+function getCachedGitDiff(key) {
+  const entry = gitDiffCache.get(key);
+  if (!entry) {
+    return void 0;
+  }
+  if (Date.now() >= entry.expiresAt) {
+    gitDiffCache.delete(key);
+    return void 0;
+  }
+  gitDiffCache.delete(key);
+  gitDiffCache.set(key, entry);
+  return entry.result;
+}
+function getGitDiffSpawnArgs(cwd) {
+  const resolvedCwd = cwd ? (0, import_repo.getCachedRealpath)(cwd) : (0, import_repo.getCwd)();
+  return {
+    all: [
+      getGitPath(),
+      ["status", "--porcelain"],
+      {
+        cwd: resolvedCwd
+      }
+    ],
+    unstaged: [
+      getGitPath(),
+      ["diff", "--name-only"],
+      {
+        cwd: resolvedCwd
+      }
+    ],
+    staged: [
+      getGitPath(),
+      ["diff", "--cached", "--name-only"],
+      {
+        cwd: resolvedCwd
+      }
+    ]
+  };
+}
+function getGitPath() {
+  if (_gitPath === void 0) {
+    const resolved = (0, import_which.whichSync)("git", { nothrow: true });
+    _gitPath = typeof resolved === "string" ? resolved : "git";
+  }
+  return _gitPath;
+}
+async function innerDiff(args, options) {
+  const { cache = true, ...parseOptions } = { __proto__: null, ...options };
+  const cacheKey = cache ? stableKey({ args, parseOptions }) : void 0;
+  if (cache && cacheKey) {
+    const result2 = getCachedGitDiff(cacheKey);
+    if (result2) {
+      return result2;
+    }
+  }
+  let result;
+  try {
+    const spawnResult = await (0, import_child.spawn)(args[0], args[1], {
+      ...args[2],
+      stdioString: false
+    });
+    const stdout = (0, import_buffer.BufferIsBuffer)(spawnResult.stdout) ? spawnResult.stdout.toString("utf8") : (
+      // String fallback only fires if spawn returns non-Buffer stdout.
+      /* c8 ignore next */
+      String(spawnResult.stdout)
+    );
+    const spawnCwd = typeof args[2]["cwd"] === "string" ? args[2]["cwd"] : void 0;
+    result = parseGitDiffStdout(stdout, parseOptions, spawnCwd);
+  } catch (e) {
+    (0, import_output.debugNs)(
+      "git",
+      `Git command failed (${args[0]} ${args[1].join(" ")}): ${e.message}`
+    );
+    return [];
+  }
+  if (cache && cacheKey) {
+    setCachedGitDiff(cacheKey, result);
+  }
+  return result;
+}
+function innerDiffSync(args, options) {
+  const { cache = true, ...parseOptions } = { __proto__: null, ...options };
+  const cacheKey = cache ? stableKey({ args, parseOptions }) : void 0;
+  if (cache && cacheKey) {
+    const result2 = getCachedGitDiff(cacheKey);
+    if (result2) {
+      return result2;
+    }
+  }
+  let result;
+  try {
+    const spawnResult = (0, import_child.spawnSync)(args[0], args[1], {
+      ...args[2],
+      stdioString: false
+    });
+    const stdout = (0, import_buffer.BufferIsBuffer)(spawnResult.stdout) ? spawnResult.stdout.toString("utf8") : (
+      // String fallback only fires if spawn returns non-Buffer stdout.
+      /* c8 ignore next */
+      String(spawnResult.stdout)
+    );
+    const spawnCwd = typeof args[2]["cwd"] === "string" ? args[2]["cwd"] : void 0;
+    result = parseGitDiffStdout(stdout, parseOptions, spawnCwd);
+  } catch (e) {
+    (0, import_output.debugNs)(
+      "git",
+      `Git command failed (${args[0]} ${args[1].join(" ")}): ${e.message}`
+    );
+    return [];
+  }
+  if (cache && cacheKey) {
+    setCachedGitDiff(cacheKey, result);
+  }
+  return result;
+}
+function parseGitDiffStdout(stdout, options, spawnCwd) {
+  const defaultRoot = spawnCwd ? (0, import_repo.findGitRoot)(spawnCwd) : (0, import_repo.getCwd)();
+  const {
+    absolute = false,
+    cwd: cwdOption = defaultRoot,
+    porcelain = false,
+    ...matcherOptions
+  } = { __proto__: null, ...options };
+  const path = (0, import_repo.getPath)();
+  const cwd = cwdOption === defaultRoot ? defaultRoot : (0, import_repo.getCachedRealpath)(cwdOption);
+  const rootPath = defaultRoot;
+  let rawFiles = stdout ? (0, import_strip.stripAnsi)(stdout).split(/\r?\n/).map((line) => line.trimEnd()).filter((line) => line) : [];
+  if (porcelain) {
+    rawFiles = rawFiles.map((line) => {
+      return line.length > 3 ? (0, import_string.StringPrototypeSubstring)(line, 3) : line;
+    });
+  }
+  const files = absolute ? rawFiles.map((relPath2) => (0, import_normalize.normalizePath)(path.join(rootPath, relPath2))) : rawFiles.map((relPath2) => (0, import_normalize.normalizePath)(relPath2));
+  if (cwd === rootPath) {
+    return files;
+  }
+  const relPath = (0, import_normalize.normalizePath)(path.relative(rootPath, cwd));
+  const matcher = (0, import_matcher.getGlobMatcher)([`${relPath}/**`], {
+    ...matcherOptions,
+    absolute,
+    cwd: rootPath
+  });
+  const filtered = [];
+  for (const filepath of files) {
+    if (matcher(filepath)) {
+      filtered.push(filepath);
+    }
+  }
+  return filtered;
+}
+function setCachedGitDiff(key, result) {
+  if (gitDiffCache.size >= GIT_CACHE_MAX_SIZE) {
+    const oldest = gitDiffCache.keys().next().value;
+    if (oldest !== void 0) {
+      gitDiffCache.delete(oldest);
+    }
+  }
+  gitDiffCache.set(key, { expiresAt: Date.now() + GIT_CACHE_TTL_MS, result });
+}
+function stableKey(value) {
+  return (0, import_json.JSONStringify)(value, (_key, val) => {
+    if (val && typeof val === "object" && !(0, import_array.ArrayIsArray)(val)) {
+      const sorted = {};
+      for (const k of (0, import_object.ObjectKeys)(val).sort()) {
+        sorted[k] = val[k];
+      }
+      return sorted;
+    }
+    return val;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GIT_CACHE_MAX_SIZE,
+  GIT_CACHE_TTL_MS,
+  getCachedGitDiff,
+  getGitDiffSpawnArgs,
+  getGitPath,
+  gitDiffCache,
+  innerDiff,
+  innerDiffSync,
+  parseGitDiffStdout,
+  setCachedGitDiff,
+  stableKey
+});

package/dist/git/changed.d.ts

@@ -0,0 +1,145 @@
+/**
+ * @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.
+ */
+import type { GitDiffOptions } from './types';
+/**
+ * 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.
+ */
+export declare function getChangedFiles(options?: GitDiffOptions | undefined): Promise<string[]>;
+/**
+ * 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.
+ */
+export declare function getChangedFilesSync(options?: GitDiffOptions | undefined): string[];
+/**
+ * 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.
+ */
+export declare function isChanged(pathname: string, options?: GitDiffOptions | undefined): Promise<boolean>;
+/**
+ * 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.
+ */
+export declare function isChangedSync(pathname: string, options?: GitDiffOptions | undefined): boolean;

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