@socketsecurity/lib 5.27.0 → 6.0.0

package/dist/fs/write-json.d.ts

@@ -0,0 +1,78 @@
+/**
+ * @file JSON writers that match the wire-format conventions a tool ecosystem
+ *   expects: configurable indentation, configurable EOL, trailing newline by
+ *   default. The `stringify` helper is exported so callers that already have an
+ *   `fs` handle can render a buffer without round-tripping through this
+ *   module's writers.
+ */
+import type { PathLike } from 'node:fs';
+import type { JsonReviver } from '../json/types';
+import type { WriteJsonOptions } from './types';
+/**
+ * Stringify JSON with custom formatting options. Formats JSON with configurable
+ * line endings and indentation.
+ *
+ * @param json - Value to stringify.
+ * @param EOL - End-of-line sequence.
+ * @param finalEOL - Whether to add final newline.
+ * @param replacer - JSON replacer function.
+ * @param spaces - Indentation spaces or string.
+ *
+ * @returns Formatted JSON string
+ */
+export declare function stringify(json: unknown, EOL: string, finalEOL: boolean, replacer: JsonReviver | undefined, spaces?: number | string): string;
+/**
+ * Write JSON content to a file asynchronously with formatting. Stringifies the
+ * value with configurable indentation and line endings. Automatically adds a
+ * final newline by default for POSIX compliance.
+ *
+ * @example
+ *   ;```ts
+ *   // Write formatted JSON with default 2-space indentation
+ *   await writeJson('./data.json', { name: 'example', version: '1.0.0' })
+ *
+ *   // Write with custom indentation
+ *   await writeJson('./config.json', config, { spaces: 4 })
+ *
+ *   // Write with tabs instead of spaces
+ *   await writeJson('./data.json', data, { spaces: '\t' })
+ *
+ *   // Write without final newline
+ *   await writeJson('./inline.json', obj, { finalEOL: false })
+ *
+ *   // Write with Windows line endings
+ *   await writeJson('./win.json', data, { EOL: '\r\n' })
+ *   ```
+ *
+ * @param filepath - Path to write to.
+ * @param jsonContent - Value to stringify and write.
+ * @param options - Write options including formatting and encoding.
+ *
+ * @returns Promise that resolves when write completes
+ */
+export declare function writeJson(filepath: PathLike, jsonContent: unknown, options?: WriteJsonOptions | string): Promise<void>;
+/**
+ * Write JSON content to a file synchronously with formatting. Stringifies the
+ * value with configurable indentation and line endings. Automatically adds a
+ * final newline by default for POSIX compliance.
+ *
+ * @example
+ *   ;```ts
+ *   // Write formatted JSON with default 2-space indentation
+ *   writeJsonSync('./package.json', pkg)
+ *
+ *   // Write with custom indentation
+ *   writeJsonSync('./tsconfig.json', tsconfig, { spaces: 4 })
+ *
+ *   // Write with tabs for indentation
+ *   writeJsonSync('./data.json', data, { spaces: '\t' })
+ *
+ *   // Write compacted (no indentation)
+ *   writeJsonSync('./compact.json', data, { spaces: 0 })
+ *   ```
+ *
+ * @param filepath - Path to write to.
+ * @param jsonContent - Value to stringify and write.
+ * @param options - Write options including formatting and encoding.
+ */
+export declare function writeJsonSync(filepath: PathLike, jsonContent: unknown, options?: WriteJsonOptions | string | undefined): void;

package/dist/fs/write-json.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 write_json_exports = {};
+__export(write_json_exports, {
+  stringify: () => stringify,
+  writeJson: () => writeJson,
+  writeJsonSync: () => writeJsonSync
+});
+module.exports = __toCommonJS(write_json_exports);
+var import_fs = require("../node/fs");
+var import_json = require("../primordials/json");
+var import_string = require("../primordials/string");
+const NEWLINE_REGEX = /\n/g;
+// @__NO_SIDE_EFFECTS__
+function stringify(json, EOL, finalEOL, replacer, spaces = 2) {
+  const EOF = finalEOL ? EOL : "";
+  const str = (0, import_json.JSONStringify)(json, replacer, spaces);
+  return `${(0, import_string.StringPrototypeReplace)(str, NEWLINE_REGEX, EOL)}${EOF}`;
+}
+async function writeJson(filepath, jsonContent, options) {
+  const opts = typeof options === "string" ? { encoding: options } : options;
+  const { EOL, finalEOL, replacer, spaces, ...fsOptions } = {
+    __proto__: null,
+    ...opts
+  };
+  const fs = (0, import_fs.getNodeFs)();
+  const jsonString = /* @__PURE__ */ stringify(
+    jsonContent,
+    EOL || "\n",
+    finalEOL !== void 0 ? finalEOL : true,
+    replacer,
+    spaces
+  );
+  await fs.promises.writeFile(filepath, jsonString, {
+    encoding: "utf8",
+    ...fsOptions,
+    __proto__: null
+  });
+}
+function writeJsonSync(filepath, jsonContent, options) {
+  const opts = typeof options === "string" ? { encoding: options } : options;
+  const { EOL, finalEOL, replacer, spaces, ...fsOptions } = {
+    __proto__: null,
+    ...opts
+  };
+  const fs = (0, import_fs.getNodeFs)();
+  const jsonString = /* @__PURE__ */ stringify(
+    jsonContent,
+    EOL || "\n",
+    finalEOL !== void 0 ? finalEOL : true,
+    replacer,
+    spaces
+  );
+  fs.writeFileSync(filepath, jsonString, {
+    encoding: "utf8",
+    ...fsOptions,
+    __proto__: null
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  stringify,
+  writeJson,
+  writeJsonSync
+});

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_spawn = require("../spawn/spawn");
+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_spawn.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_spawn.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;