@socketsecurity/lib 5.28.0 → 6.0.0

package/dist/ai/spawn.js

@@ -0,0 +1,207 @@
+"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 spawn_exports = {};
+__export(spawn_exports, {
+  backoffFor: () => backoffFor,
+  buildArgs: () => buildArgs,
+  isOverloaded: () => isOverloaded,
+  pickAgent: () => pickAgent,
+  spawnAiAgent: () => spawnAiAgent
+});
+module.exports = __toCommonJS(spawn_exports);
+var import_message = require("../errors/message");
+var import_object = require("../primordials/object");
+var import_spawn = require("../spawn/spawn");
+var import_errors = require("../spawn/errors");
+var import_discover = require("./discover");
+const MAX_ATTEMPTS = 3;
+const BACKOFF_BASE_MS = 5e3;
+function backoffFor(attempt) {
+  return BACKOFF_BASE_MS * 3 ** (attempt - 1);
+}
+function buildArgs(agent, opts) {
+  const allAllowed = [...opts.tools, ...opts.allow ?? []];
+  switch (agent) {
+    case "claude": {
+      const args = [
+        "--print",
+        "--no-session-persistence",
+        "--permission-mode",
+        opts.permissionMode,
+        "--add-dir",
+        opts.cwd
+      ];
+      for (const dir of opts.addDirs ?? []) {
+        args.push("--add-dir", dir);
+      }
+      if (opts.model) {
+        args.push("--model", opts.model);
+      }
+      if (allAllowed.length > 0) {
+        args.push("--allowedTools", ...allAllowed);
+      }
+      if (opts.disallow.length > 0) {
+        args.push("--disallowedTools", ...opts.disallow);
+      }
+      if (opts.extraArgs) {
+        args.push(...opts.extraArgs);
+      }
+      return args;
+    }
+    case "codex": {
+      const args = ["--print"];
+      if (opts.permissionMode === "plan") {
+        args.push("--read-only");
+      }
+      if (opts.model) {
+        args.push("--model", opts.model);
+      }
+      if (allAllowed.length > 0) {
+        args.push("--tools", allAllowed.join(","));
+      }
+      if (opts.disallow.length > 0) {
+        args.push("--disallow-tools", opts.disallow.join(","));
+      }
+      args.push("--cwd", opts.cwd);
+      if (opts.extraArgs) {
+        args.push(...opts.extraArgs);
+      }
+      return args;
+    }
+    case "gemini": {
+      const args = ["--no-interactive", "--workspace", opts.cwd];
+      if (opts.model) {
+        args.push("--model", opts.model);
+      }
+      if (allAllowed.length > 0) {
+        args.push("--allowed-tools", allAllowed.join(","));
+      }
+      if (opts.disallow.length > 0) {
+        args.push("--denied-tools", opts.disallow.join(","));
+      }
+      if (opts.permissionMode === "plan") {
+        args.push("--read-only");
+      }
+      if (opts.extraArgs) {
+        args.push(...opts.extraArgs);
+      }
+      return args;
+    }
+    case "opencode": {
+      const args = ["--print", "--cwd", opts.cwd];
+      if (opts.model) {
+        args.push("--model", opts.model);
+      }
+      if (allAllowed.length > 0) {
+        args.push("--tools", allAllowed.join(","));
+      }
+      if (opts.disallow.length > 0) {
+        args.push("--no-tools", opts.disallow.join(","));
+      }
+      if (opts.extraArgs) {
+        args.push(...opts.extraArgs);
+      }
+      return args;
+    }
+  }
+}
+function isOverloaded(stdout, stderr) {
+  const re = /API Error: 529|Overloaded/i;
+  return re.test(stdout) || re.test(stderr);
+}
+async function pickAgent(requested, cwd) {
+  const discovered = await (0, import_discover.discoverAiAgents)({ repoRoot: cwd });
+  if (requested) {
+    if (!(requested in discovered)) {
+      throw new Error(
+        `spawnAiAgent: requested agent "${requested}" is not on PATH. Install the CLI or pass a different agent. Discovered: ${(0, import_object.ObjectKeys)(discovered).join(", ") || "(none)"}`
+      );
+    }
+    return requested;
+  }
+  if ("claude" in discovered) {
+    return "claude";
+  }
+  for (const candidate of ["codex", "opencode", "gemini"]) {
+    if (candidate in discovered) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    "spawnAiAgent: no AI agent CLI on PATH. Install one of: claude, codex, opencode, gemini."
+  );
+}
+async function spawnAiAgent(opts) {
+  const agent = await pickAgent(opts.agent, opts.cwd);
+  const args = buildArgs(agent, opts);
+  let stdout = "";
+  let stderr = "";
+  let exitCode = 0;
+  let attempts = 0;
+  const start = Date.now();
+  while (attempts < MAX_ATTEMPTS) {
+    attempts += 1;
+    stdout = "";
+    stderr = "";
+    exitCode = 0;
+    try {
+      const child = (0, import_spawn.spawn)(agent, args, {
+        cwd: opts.cwd,
+        stdio: "pipe",
+        stdioString: true,
+        timeout: opts.timeoutMs
+      });
+      child.stdin?.end(opts.prompt);
+      const result = await child;
+      stdout = String(result.stdout ?? "");
+      stderr = String(result.stderr ?? "");
+      exitCode = result.code ?? 0;
+    } catch (e) {
+      if ((0, import_errors.isSpawnError)(e)) {
+        stdout = String(e.stdout ?? "");
+        stderr = String(e.stderr ?? "");
+        exitCode = e.code ?? 1;
+      } else {
+        stderr = (0, import_message.errorMessage)(e);
+        exitCode = 1;
+      }
+    }
+    if (!isOverloaded(stdout, stderr) || attempts >= MAX_ATTEMPTS) {
+      break;
+    }
+    await new Promise((resolve) => setTimeout(resolve, backoffFor(attempts)));
+  }
+  return {
+    attempts,
+    durationMs: Date.now() - start,
+    exitCode,
+    stderr,
+    stdout
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  backoffFor,
+  buildArgs,
+  isOverloaded,
+  pickAgent,
+  spawnAiAgent
+});

package/dist/ai/types.d.mts

@@ -0,0 +1,117 @@
+/**
+ * @file Shared types for the locked-down AI agent surface. The fleet runs
+ *   Claude / Codex / OpenCode / Gemini through CLI subprocesses, never via SDK
+ *   calls. These types model the cross- agent contract: a permission mode, a
+ *   tool allowlist, a tool denylist, a prompt, a working directory. Per-agent
+ *   flag translation lives in `spawn.ts` — callers pass the uniform
+ *   `SpawnAiAgentOptions` and the helper produces the right CLI args for the
+ *   chosen agent.
+ */
+/**
+ * The set of AI agents the helper can drive. Each must be installed as a CLI on
+ * PATH; discovery happens via `discoverAiAgents()`.
+ */
+export type AiAgentName = 'claude' | 'codex' | 'gemini' | 'opencode';
+/**
+ * Permission mode passed to the agent's CLI. The fleet rule (CLAUDE.md
+ * "Programmatic Claude calls") requires every headless call to set one of these
+ * explicitly — never the agent's default.
+ *
+ * - `acceptEdits` — Edit/Write proceed without prompting. Required for fix-mode
+ *   skills; `dontAsk` would DENY rather than auto-accept.
+ * - `dontAsk` — read-only / no-mutation use. AskUserQuestion calls are
+ *   suppressed.
+ * - `plan` — research / proposal mode. The agent can read but cannot write or run
+ *   tools that mutate state.
+ */
+export type PermissionMode = 'acceptEdits' | 'dontAsk' | 'plan';
+/**
+ * Result of an agent spawn. Consumers should inspect `exitCode` before using
+ * `stdout` — non-zero usually means the agent's CLI itself rejected, not just
+ * that the prompt failed.
+ */
+export interface AgentSpawnResult {
+    readonly attempts: number;
+    readonly durationMs: number;
+    readonly exitCode: number;
+    readonly stderr: string;
+    readonly stdout: string;
+}
+/**
+ * Inputs to a single agent spawn.
+ *
+ * Required: `prompt`, `cwd`, `tools`, `disallow`, `permissionMode`.
+ *
+ * Pre-built profiles in `profiles.ts` cover the common shapes
+ * (READ_ONLY_PROFILE, EDIT_ONLY_PROFILE) — callers spread the profile and
+ * override per-call (model, timeout, addDirs).
+ *
+ * Why the lockdown fields are required (not defaulted to a permissive shape):
+ * the CLAUDE.md rule says "all four lockdown flags MUST be set on every spawn."
+ * Making them required at the type level is the type-system version of that
+ * rule.
+ */
+export interface SpawnAiAgentOptions {
+    /**
+     * Optional explicit agent. Defaults to claude when discovered.
+     */
+    readonly agent?: AiAgentName;
+    /**
+     * Allow-list extras (Bash glob patterns, MCP tools, etc.).
+     */
+    readonly allow?: readonly string[];
+    /**
+     * Extra dirs the agent can read (e.g. parent of cwd for monorepo).
+     */
+    readonly addDirs?: readonly string[];
+    /**
+     * Tool denylist — required to enforce the lockdown.
+     */
+    readonly disallow: readonly string[];
+    /**
+     * Override the agent's flag list (rare; for one-off advanced cases).
+     */
+    readonly extraArgs?: readonly string[];
+    /**
+     * Model name override; agent default if absent.
+     */
+    readonly model?: string;
+    /**
+     * Permission mode — see PermissionMode docstring.
+     */
+    readonly permissionMode: PermissionMode;
+    /**
+     * The prompt sent on stdin.
+     */
+    readonly prompt: string;
+    /**
+     * Repository / working directory for the agent.
+     */
+    readonly cwd: string;
+    /**
+     * Per-call timeout (ms). Caller should set for predictable bounds.
+     */
+    readonly timeoutMs?: number;
+    /**
+     * Tool allowlist. Required to enforce the lockdown.
+     */
+    readonly tools: readonly string[];
+}
+/**
+ * The cwd-aware "is this binary on PATH?" snapshot. Each entry is the absolute
+ * path resolved by `which`; missing agents are absent from the map (not
+ * present-with-undefined).
+ */
+export type DiscoveredAgents = Readonly<Partial<Record<AiAgentName, string>>>;
+/**
+ * Cleanup policy for `spawnAiAgentsInWorktrees`. Default 'always'.
+ *
+ * - `always` — remove the worktree after the per-item function returns,
+ *   regardless of success/failure or whether changes were committed. Matches
+ *   the "leave no trace" expectation.
+ * - `never` — never auto-remove. Caller (or human inspector) cleans up. Useful
+ *   for debugging.
+ * - `on-empty` — remove only if the worktree had no changes (committed or
+ *   staged). Preserves evidence on failure.
+ */
+export type WorktreeCleanup = 'always' | 'never' | 'on-empty';

package/dist/ai/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/ai/worktree.d.mts

@@ -0,0 +1,104 @@
+/**
+ * @file Run AI agents in parallel, each in its own git worktree, and merge
+ *   results back to the base branch. The fleet's CLAUDE.md "Parallel Claude
+ *   sessions" rule mandates worktree isolation when multiple agents touch the
+ *   same checkout. This helper enforces that contract: each item gets a fresh
+ *   worktree branched from the base, the per-item function runs inside it, then
+ *   the helper either fast-forward-merges the worktree branch back into the
+ *   base (when changes were committed) or removes the worktree silently (when
+ *   no changes happened). Concurrency: caller-controlled with a default cap of
+ *   4. Per the "Programmatic Claude calls" CLAUDE.md rule, very high
+ *   concurrency saturates the API rate limits; 4 is safe headroom for most
+ *   accounts. The hard cap of 8 prevents accidental flag-finger disasters.
+ *   Cleanup policy: see `WorktreeCleanup` in types.mts. Default 'always' —
+ *   fail-or-pass, the worktree is removed.
+ */
+import type { WorktreeCleanup } from './types.mts';
+export interface WorktreeRunOptions {
+    /**
+     * Base repo path (the primary checkout).
+     */
+    readonly baseRepo: string;
+    /**
+     * Branch to merge results into. Default: current branch of baseRepo.
+     */
+    readonly branch?: string;
+    /**
+     * Cleanup policy. Default 'always'.
+     */
+    readonly cleanup?: WorktreeCleanup;
+    /**
+     * Parallel cap. Default 4, max 8.
+     */
+    readonly concurrency?: number;
+    /**
+     * Prefix for worktree branch + dir names. Default 'agent-task'.
+     */
+    readonly namePrefix?: string;
+    /**
+     * Where worktrees live on disk. Default: `${tmpdir}/${prefix}-<n>`.
+     */
+    readonly worktreeRoot?: string;
+}
+export interface WorktreeRunContext {
+    /**
+     * Worktree dir on disk.
+     */
+    readonly cwd: string;
+    /**
+     * Branch name created for this worktree.
+     */
+    readonly branch: string;
+    /**
+     * 0-indexed item position.
+     */
+    readonly index: number;
+}
+export interface WorktreeRunSettled<T> {
+    readonly cleanup: 'removed' | 'kept';
+    readonly error?: unknown;
+    readonly merged: boolean;
+    readonly status: 'fulfilled' | 'rejected';
+    readonly value?: T | undefined;
+    readonly worktreePath: string;
+}
+export declare function currentBranch(repo: string): string;
+export declare function git(cwd: string, ...args: string[]): string;
+export declare function hasCommittedChanges(worktree: string, baseBranch: string): boolean;
+export declare function hasStagedOrUnstaged(worktree: string): boolean;
+export declare function runOne<I, T>(item: I, index: number, worktreeBranch: string, worktreePath: string, baseRepo: string, branch: string, cleanup: WorktreeCleanup, fn: (item: I, ctx: WorktreeRunContext) => Promise<T>): Promise<WorktreeRunSettled<T>>;
+/**
+ * Run `fn` for each item in parallel, each invocation isolated in its own git
+ * worktree. Results are merged back into the base branch with `git merge
+ * --ff-only`; non-FF merges are reported as failures and the worktree is
+ * preserved (regardless of cleanup policy).
+ *
+ * @example
+ *   ;```ts
+ *   import { spawnAiAgentsInWorktrees } from '@socketsecurity/lib/ai/worktree'
+ *   import { spawnAiAgent } from '@socketsecurity/lib/ai/spawn'
+ *   import { EDIT_ONLY_PROFILE } from '@socketsecurity/lib/ai/profiles'
+ *
+ *   const repos = ['socket-addon', 'socket-btm', 'socket-lib']
+ *   const settled = await spawnAiAgentsInWorktrees(
+ *     repos,
+ *     async ({ cwd }) => {
+ *       return await spawnAiAgent({
+ *         ...EDIT_ONLY_PROFILE,
+ *         prompt: 'Run the cleanup task',
+ *         cwd,
+ *       })
+ *     },
+ *     {
+ *       baseRepo: '/Users/<user>/projects/socket-wheelhouse',
+ *       concurrency: 3,
+ *       cleanup: 'on-empty',
+ *     },
+ *   )
+ *   ```
+ */
+export declare function spawnAiAgentsInWorktrees<I, T>(items: readonly I[], fn: (item: I, ctx: WorktreeRunContext) => Promise<T>, options: WorktreeRunOptions): Promise<ReadonlyArray<WorktreeRunSettled<T>>>;
+export declare function tryGit(cwd: string, ...args: string[]): {
+    ok: boolean;
+    output: string;
+};

package/dist/ai/worktree.js

@@ -0,0 +1,200 @@
+"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 worktree_exports = {};
+__export(worktree_exports, {
+  currentBranch: () => currentBranch,
+  git: () => git,
+  hasCommittedChanges: () => hasCommittedChanges,
+  hasStagedOrUnstaged: () => hasStagedOrUnstaged,
+  runOne: () => runOne,
+  spawnAiAgentsInWorktrees: () => spawnAiAgentsInWorktrees,
+  tryGit: () => tryGit
+});
+module.exports = __toCommonJS(worktree_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"), 1);
+var import_message = require("../errors/message");
+var import_spawn = require("../spawn/spawn");
+var import_errors = require("../spawn/errors");
+const DEFAULT_CONCURRENCY = 4;
+const MAX_CONCURRENCY = 8;
+function currentBranch(repo) {
+  return git(repo, "symbolic-ref", "--short", "HEAD");
+}
+function git(cwd, ...args) {
+  const result = (0, import_spawn.spawnSync)("git", args, {
+    cwd,
+    stdio: "pipe",
+    stdioString: true
+  });
+  return String(result.stdout ?? "").trim();
+}
+function hasCommittedChanges(worktree, baseBranch) {
+  const log = tryGit(worktree, "log", "--oneline", `${baseBranch}..HEAD`);
+  if (!log.ok) {
+    return false;
+  }
+  return log.output.trim().length > 0;
+}
+function hasStagedOrUnstaged(worktree) {
+  const status = tryGit(worktree, "status", "--porcelain");
+  return status.ok && status.output.trim().length > 0;
+}
+async function runOne(item, index, worktreeBranch, worktreePath, baseRepo, branch, cleanup, fn) {
+  const add = tryGit(
+    baseRepo,
+    "worktree",
+    "add",
+    "-b",
+    worktreeBranch,
+    worktreePath,
+    branch
+  );
+  if (!add.ok) {
+    return {
+      cleanup: "kept",
+      error: new Error(`git worktree add failed: ${add.output}`),
+      merged: false,
+      status: "rejected",
+      worktreePath
+    };
+  }
+  let value;
+  let error;
+  try {
+    value = await fn(item, { branch: worktreeBranch, cwd: worktreePath, index });
+  } catch (e) {
+    error = e;
+  }
+  const hasCommitted = hasCommittedChanges(worktreePath, branch);
+  const hasUncommitted = hasStagedOrUnstaged(worktreePath);
+  let merged = false;
+  if (error === void 0 && hasCommitted) {
+    const merge = tryGit(baseRepo, "merge", "--ff-only", worktreeBranch);
+    if (merge.ok) {
+      merged = true;
+    } else {
+      error = new Error(`git merge --ff-only failed: ${merge.output}`);
+    }
+  }
+  let didCleanup = "kept";
+  const shouldCleanup = error === void 0 && (cleanup === "always" || cleanup === "on-empty" && !hasCommitted && !hasUncommitted);
+  if (shouldCleanup) {
+    const remove = tryGit(baseRepo, "worktree", "remove", worktreePath);
+    if (remove.ok) {
+      didCleanup = "removed";
+      tryGit(baseRepo, "branch", "-D", worktreeBranch);
+    }
+  }
+  if (error !== void 0) {
+    return {
+      cleanup: didCleanup,
+      error,
+      merged,
+      status: "rejected",
+      worktreePath
+    };
+  }
+  return {
+    cleanup: didCleanup,
+    merged,
+    status: "fulfilled",
+    value,
+    worktreePath
+  };
+}
+async function spawnAiAgentsInWorktrees(items, fn, options) {
+  const cleanup = options.cleanup ?? "always";
+  const namePrefix = options.namePrefix ?? "agent-task";
+  const concurrency = Math.max(
+    1,
+    Math.min(options.concurrency ?? DEFAULT_CONCURRENCY, MAX_CONCURRENCY)
+  );
+  const baseRepo = options.baseRepo;
+  if (!(0, import_node_fs.existsSync)(import_node_path.default.join(baseRepo, ".git"))) {
+    throw new Error(
+      `spawnAiAgentsInWorktrees: baseRepo is not a git checkout: ${baseRepo}`
+    );
+  }
+  const branch = options.branch ?? currentBranch(baseRepo);
+  const worktreeRoot = options.worktreeRoot ?? import_node_path.default.join(
+    process.platform === "win32" ? process.env["TEMP"] ?? "." : "/tmp",
+    `${namePrefix}-${Date.now()}`
+  );
+  const settled = [];
+  let cursor = 0;
+  async function worker() {
+    for (; ; ) {
+      const idx = cursor;
+      cursor += 1;
+      if (idx >= items.length) {
+        return;
+      }
+      const item = items[idx];
+      const worktreeBranch = `${namePrefix}-${idx}-${Date.now()}`;
+      const worktreePath = import_node_path.default.join(worktreeRoot, `${namePrefix}-${idx}`);
+      const result = await runOne(
+        item,
+        idx,
+        worktreeBranch,
+        worktreePath,
+        baseRepo,
+        branch,
+        cleanup,
+        fn
+      );
+      settled[idx] = result;
+    }
+  }
+  await Promise.all(Array.from({ length: concurrency }, () => worker()));
+  return settled;
+}
+function tryGit(cwd, ...args) {
+  try {
+    const output = git(cwd, ...args);
+    return { ok: true, output };
+  } catch (e) {
+    if ((0, import_errors.isSpawnError)(e)) {
+      return { ok: false, output: String(e.stderr ?? e.stdout ?? "") };
+    }
+    return { ok: false, output: (0, import_message.errorMessage)(e) };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  currentBranch,
+  git,
+  hasCommittedChanges,
+  hasStagedOrUnstaged,
+  runOne,
+  spawnAiAgentsInWorktrees,
+  tryGit
+});

package/dist/ansi/constants.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @file ANSI escape code constants. Commonly used terminal formatting sequences
+ *   for bold, dim, italic, reset, strikethrough, and underline.
+ */
+export declare const ANSI_BOLD = "\u001B[1m";
+export declare const ANSI_DIM = "\u001B[2m";
+export declare const ANSI_ITALIC = "\u001B[3m";
+export declare const ANSI_RESET = "\u001B[0m";
+export declare const ANSI_STRIKETHROUGH = "\u001B[9m";
+export declare const ANSI_UNDERLINE = "\u001B[4m";