@socketsecurity/lib 6.0.3 → 6.0.5

package/dist/ai/worktree.js

@@ -1,200 +1,177 @@
 "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_child = require("../process/spawn/child");
-var import_errors = require("../process/spawn/errors");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_errors_message = require('../errors/message.js');
+const require_process_spawn_errors = require('../process/spawn/errors.js');
+const require_process_spawn_child = require('../process/spawn/child.js');
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path, 1);
+
+//#region src/ai/worktree.mts
+/**
+* @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.
+*/
 const DEFAULT_CONCURRENCY = 4;
 const MAX_CONCURRENCY = 8;
 function currentBranch(repo) {
-  return git(repo, "symbolic-ref", "--short", "HEAD");
+	return git(repo, "symbolic-ref", "--short", "HEAD");
 }
 function git(cwd, ...args) {
-  const result = (0, import_child.spawnSync)("git", args, {
-    cwd,
-    stdio: "pipe",
-    stdioString: true
-  });
-  return String(result.stdout ?? "").trim();
+	const result = require_process_spawn_child.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;
+	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;
+	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
-  };
+	const add = tryGit(baseRepo, "worktree", "add", "-b", worktreeBranch, worktreePath, branch);
+	if (!add.ok) return {
+		cleanup: "kept",
+		error: /* @__PURE__ */ 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 = /* @__PURE__ */ new Error(`git merge --ff-only failed: ${merge.output}`);
+	}
+	let didCleanup = "kept";
+	if (error === void 0 && (cleanup === "always" || cleanup === "on-empty" && !hasCommitted && !hasUncommitted)) {
+		if (tryGit(baseRepo, "worktree", "remove", worktreePath).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
+	};
 }
+/**
+* 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 { AI_PROFILE } from '@socketsecurity/lib/ai/profiles'
+*
+*   const repos = ['socket-addon', 'socket-btm', 'socket-lib']
+*   const settled = await spawnAiAgentsInWorktrees(
+*     repos,
+*     async ({ cwd }) => {
+*       return await spawnAiAgent({
+*         ...AI_PROFILE.create,
+*         prompt: 'Run the cleanup task',
+*         cwd,
+*       })
+*     },
+*     {
+*       baseRepo: '/Users/<user>/projects/socket-wheelhouse',
+*       concurrency: 3,
+*       cleanup: 'on-empty',
+*     },
+*   )
+*   ```
+*/
 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;
+	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, node_fs.existsSync)(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 ?? 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];
+			settled[idx] = await runOne(item, idx, `${namePrefix}-${idx}-${Date.now()}`, node_path.default.join(worktreeRoot, `${namePrefix}-${idx}`), baseRepo, branch, cleanup, fn);
+		}
+	}
+	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) };
-  }
+	try {
+		return {
+			ok: true,
+			output: git(cwd, ...args)
+		};
+	} catch (e) {
+		if (/* @__PURE__ */ require_process_spawn_errors.isSpawnError(e)) return {
+			ok: false,
+			output: String(e.stderr ?? e.stdout ?? "")
+		};
+		return {
+			ok: false,
+			output: require_errors_message.errorMessage(e)
+		};
+	}
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  currentBranch,
-  git,
-  hasCommittedChanges,
-  hasStagedOrUnstaged,
-  runOne,
-  spawnAiAgentsInWorktrees,
-  tryGit
-});
+
+//#endregion
+exports.currentBranch = currentBranch;
+exports.git = git;
+exports.hasCommittedChanges = hasCommittedChanges;
+exports.hasStagedOrUnstaged = hasStagedOrUnstaged;
+exports.runOne = runOne;
+exports.spawnAiAgentsInWorktrees = spawnAiAgentsInWorktrees;
+exports.tryGit = tryGit;

package/dist/ansi/constants.js

@@ -1,45 +1,23 @@
 "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 constants_exports = {};
-__export(constants_exports, {
-  ANSI_BOLD: () => ANSI_BOLD,
-  ANSI_DIM: () => ANSI_DIM,
-  ANSI_ITALIC: () => ANSI_ITALIC,
-  ANSI_RESET: () => ANSI_RESET,
-  ANSI_STRIKETHROUGH: () => ANSI_STRIKETHROUGH,
-  ANSI_UNDERLINE: () => ANSI_UNDERLINE
-});
-module.exports = __toCommonJS(constants_exports);
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/ansi/constants.ts
+/**
+* @file ANSI escape code constants. Commonly used terminal formatting sequences
+*   for bold, dim, italic, reset, strikethrough, and underline.
+*/
 const ANSI_BOLD = "\x1B[1m";
 const ANSI_DIM = "\x1B[2m";
 const ANSI_ITALIC = "\x1B[3m";
 const ANSI_RESET = "\x1B[0m";
 const ANSI_STRIKETHROUGH = "\x1B[9m";
 const ANSI_UNDERLINE = "\x1B[4m";
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ANSI_BOLD,
-  ANSI_DIM,
-  ANSI_ITALIC,
-  ANSI_RESET,
-  ANSI_STRIKETHROUGH,
-  ANSI_UNDERLINE
-});
+
+//#endregion
+exports.ANSI_BOLD = ANSI_BOLD;
+exports.ANSI_DIM = ANSI_DIM;
+exports.ANSI_ITALIC = ANSI_ITALIC;
+exports.ANSI_RESET = ANSI_RESET;
+exports.ANSI_STRIKETHROUGH = ANSI_STRIKETHROUGH;
+exports.ANSI_UNDERLINE = ANSI_UNDERLINE;

package/dist/ansi/strip.js

@@ -1,47 +1,50 @@
 "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 strip_exports = {};
-__export(strip_exports, {
-  ansiRegex: () => ansiRegex,
-  stripAnsi: () => stripAnsi
-});
-module.exports = __toCommonJS(strip_exports);
-var import_regexp = require("../primordials/regexp");
-var import_string = require("../primordials/string");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_string = require('../primordials/string.js');
+const require_primordials_regexp = require('../primordials/regexp.js');
+
+//#region src/ansi/strip.ts
+/**
+* @file ANSI escape-code regex factory and stripping helper. Provides
+*   `ansiRegex()` for matching CSI/OSC sequences and `stripAnsi()` for removing
+*   ANSI formatting from terminal output.
+*/
 const ANSI_REGEX = /\x1b\[[0-9;]*m/g;
-// @__NO_SIDE_EFFECTS__
+/**
+* Create a regular expression for matching ANSI escape codes.
+*
+* Inlined ansi-regex: https://socket.dev/npm/package/ansi-regexp/overview/6.2.2
+* MIT License Copyright (c) Sindre Sorhus
+* [sindresorhus@gmail.com](mailto:sindresorhus@gmail.com)
+* (https://sindresorhus.com)
+*
+* @example
+*   ;```typescript
+*   const regex = ansiRegex()
+*   '\u001b[31mHello\u001b[0m'.match(regex) // ['\u001b[31m', '\u001b[0m']
+*   ansiRegex({ onlyFirst: true }) // matches only the first code
+*   ```
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function ansiRegex(options) {
-  const { onlyFirst } = options ?? {};
-  const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
-  const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`;
-  const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
-  const pattern = `${osc}|${csi}`;
-  return new import_regexp.RegExpCtor(pattern, onlyFirst ? void 0 : "g");
+	const { onlyFirst } = options ?? {};
+	return new require_primordials_regexp.RegExpCtor(`(?:\\u001B\\][\\s\\S]*?(?:\\u0007|\\u001B\\u005C|\\u009C))|[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]`, onlyFirst ? void 0 : "g");
 }
-// @__NO_SIDE_EFFECTS__
+/**
+* Strip ANSI escape codes from text. Uses the inlined ansi-regex for matching.
+*
+* @example
+*   ;```typescript
+*   stripAnsi('\u001b[31mError\u001b[0m') // 'Error'
+*   stripAnsi('\u001b[1mBold\u001b[0m') // 'Bold'
+*   ```
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function stripAnsi(text) {
-  return (0, import_string.StringPrototypeReplace)(text, ANSI_REGEX, "");
+	return require_primordials_string.StringPrototypeReplace(text, ANSI_REGEX, "");
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ansiRegex,
-  stripAnsi
-});
+
+//#endregion
+exports.ansiRegex = ansiRegex;
+exports.stripAnsi = stripAnsi;