@schoolai/shipyard 3.7.0 → 3.8.0-rc.20260529.0

package/dist/chunk-YZ3Z3ZYI.js

@@ -0,0 +1,787 @@
+#!/usr/bin/env node
+import {
+  gitExecSafe
+} from "./chunk-4T2OQAVL.js";
+import {
+  logger
+} from "./chunk-ZAOPND5G.js";
+import {
+  getShipyardHome
+} from "./chunk-KITSAHTX.js";
+import {
+  external_exports
+} from "./chunk-CNR7O5YH.js";
+
+// src/shared/capabilities/git-repo.ts
+import { readdir, readFile as readFile3 } from "fs/promises";
+import { basename, join as join5 } from "path";
+
+// src/shared/capabilities/environments-cache.ts
+import { mkdir, readFile, rename as rename2, stat, unlink, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, isAbsolute, join as join2, resolve } from "path";
+
+// src/shared/fs-utils.ts
+import { randomUUID } from "crypto";
+import { existsSync } from "fs";
+import { rename, writeFile } from "fs/promises";
+import { dirname, join, parse } from "path";
+function isEnoent(err) {
+  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
+}
+function isEexist(err) {
+  return typeof err === "object" && err !== null && "code" in err && err.code === "EEXIST";
+}
+function isCorruptionError(err) {
+  if (err instanceof SyntaxError) return true;
+  if (typeof err === "object" && err !== null && "name" in err && err.name === "ZodError")
+    return true;
+  return false;
+}
+async function atomicWriteFile(filePath, contents, options) {
+  const tmpPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+  await writeFile(tmpPath, contents, { encoding: "utf-8", mode: options?.mode });
+  await rename(tmpPath, filePath);
+}
+function findProjectRoot(startDir) {
+  let dir = startDir;
+  while (true) {
+    if (existsSync(join(dir, "pnpm-workspace.yaml")) || existsSync(join(dir, ".git"))) {
+      return { root: dir, foundMarker: true };
+    }
+    const parent = dirname(dir);
+    if (parent === dir || parent === parse(dir).root) {
+      return { root: startDir, foundMarker: false };
+    }
+    dir = parent;
+  }
+}
+
+// src/shared/capabilities/environments-cache.ts
+var CacheEntrySchema = external_exports.object({
+  path: external_exports.string(),
+  branch: external_exports.string(),
+  remote: external_exports.string().nullable(),
+  headMtimeMs: external_exports.number(),
+  /**
+   * Added after the original cache shape. Optional so old disk caches parse,
+   * but `isCacheValid` treats missing as invalid and refreshes once.
+   */
+  configMtimeMs: external_exports.number().nullable().optional(),
+  cachedAt: external_exports.number()
+});
+var CacheFileSchema = external_exports.object({
+  entries: external_exports.record(external_exports.string(), CacheEntrySchema)
+});
+function cacheFilePath() {
+  return join2(getShipyardHome(), "data", "environments-cache.json");
+}
+var cacheMigrationDone = false;
+async function loadCache() {
+  const filePath = cacheFilePath();
+  try {
+    const raw = await readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    const result = CacheFileSchema.safeParse(parsed);
+    if (!result.success) {
+      logger.debug({ path: filePath }, "environments-cache: malformed, treating as empty");
+      cacheMigrationDone = true;
+      return /* @__PURE__ */ new Map();
+    }
+    const cache2 = new Map(Object.entries(result.data.entries));
+    if (!cacheMigrationDone) {
+      cacheMigrationDone = true;
+      await migrateConfigMtimes(cache2);
+    }
+    return cache2;
+  } catch (err) {
+    if (isEnoent(err)) {
+      cacheMigrationDone = true;
+      return /* @__PURE__ */ new Map();
+    }
+    logger.debug({ err }, "environments-cache: read failed, treating as empty");
+    return /* @__PURE__ */ new Map();
+  }
+}
+async function migrateConfigMtimes(cache2) {
+  const stale = [...cache2.values()].filter((e) => e.configMtimeMs === void 0);
+  if (stale.length === 0) return;
+  await Promise.all(
+    stale.map(async (entry) => {
+      const fp = await getGitCacheFingerprint(entry.path);
+      cache2.set(entry.path, { ...entry, configMtimeMs: fp.configMtimeMs });
+    })
+  );
+  logger.info({ count: stale.length }, "environments-cache: cache_migration_seeded");
+  await saveCache(cache2);
+}
+async function readGitdirFile(dotGitPath) {
+  const contents = await readFile(dotGitPath, "utf8");
+  const match = contents.match(/^gitdir:\s*(.+)\s*$/m);
+  if (!match?.[1]) return null;
+  const gitdirRaw = match[1].trim();
+  return isAbsolute(gitdirRaw) ? gitdirRaw : resolve(dirname2(dotGitPath), gitdirRaw);
+}
+async function resolveCommonGitDir(gitdir) {
+  try {
+    const raw = await readFile(join2(gitdir, "commondir"), "utf8");
+    const commonDirRaw = raw.trim();
+    if (commonDirRaw === "") return gitdir;
+    return isAbsolute(commonDirRaw) ? commonDirRaw : resolve(gitdir, commonDirRaw);
+  } catch {
+    return gitdir;
+  }
+}
+async function resolveHeadPath(worktreePath) {
+  const paths = await resolveGitMetadataPaths(worktreePath);
+  return paths?.headPath ?? null;
+}
+async function resolveGitMetadataPaths(worktreePath) {
+  const dotGitPath = join2(worktreePath, ".git");
+  try {
+    const dotGitStat = await stat(dotGitPath);
+    if (dotGitStat.isDirectory()) {
+      return { headPath: join2(dotGitPath, "HEAD"), configPath: join2(dotGitPath, "config") };
+    }
+    if (dotGitStat.isFile()) {
+      const gitdir = await readGitdirFile(dotGitPath);
+      if (!gitdir) return null;
+      const commonGitDir = await resolveCommonGitDir(gitdir);
+      return { headPath: join2(gitdir, "HEAD"), configPath: join2(commonGitDir, "config") };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function getPathMtime(path) {
+  if (!path) return null;
+  try {
+    const pathStat = await stat(path);
+    return pathStat.mtimeMs;
+  } catch {
+    return null;
+  }
+}
+async function getGitCacheFingerprint(worktreePath) {
+  const paths = await resolveGitMetadataPaths(worktreePath);
+  if (!paths) return { headMtimeMs: null, configMtimeMs: null };
+  const [headMtimeMs, configMtimeMs] = await Promise.all([
+    getPathMtime(paths.headPath),
+    getPathMtime(paths.configPath)
+  ]);
+  return { headMtimeMs, configMtimeMs };
+}
+function isCacheValid(entry, current) {
+  return entry.headMtimeMs === current.headMtimeMs && (entry.configMtimeMs ?? null) === current.configMtimeMs;
+}
+async function saveCache(entries) {
+  const filePath = cacheFilePath();
+  const tmpPath = `${filePath}.tmp`;
+  try {
+    await mkdir(dirname2(filePath), { recursive: true });
+    const current = await loadCache();
+    for (const [path, entry] of entries) {
+      current.set(path, entry);
+    }
+    const payload = { entries: Object.fromEntries(current) };
+    await writeFile2(tmpPath, JSON.stringify(payload), "utf8");
+    await rename2(tmpPath, filePath);
+  } catch (err) {
+    logger.debug({ err, filePath }, "environments-cache: save failed");
+    void unlink(tmpPath).catch(() => {
+    });
+  }
+}
+
+// src/shared/capabilities/repo-paths-cache.ts
+import { mkdir as mkdir2, readFile as readFile2, rename as rename3, unlink as unlink2, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3, join as join3 } from "path";
+var RepoPathsDiskSchema = external_exports.object({
+  repos: external_exports.array(external_exports.string()),
+  worktrees: external_exports.array(external_exports.string()),
+  populatedAt: external_exports.number()
+});
+var STALE_AFTER_MS_DEFAULT = 5 * 60 * 1e3;
+var cache = null;
+var cacheGeneration = 0;
+var backgroundRefreshInFlight = false;
+function cacheFilePath2() {
+  return join3(getShipyardHome(), "data", "repo-paths-cache.json");
+}
+function getCachedRepoPaths() {
+  if (!cache) return null;
+  return { repos: cache.repos, worktrees: cache.worktrees };
+}
+function setCachedRepoPaths(repos, worktrees, now = Date.now()) {
+  cache = { repos, worktrees, populatedAt: now };
+  cacheGeneration += 1;
+  void persistDisk(cache, cacheGeneration);
+}
+async function hydrateRepoPathsCacheFromDisk(opts) {
+  if (cache !== null) return { hit: false, stale: false };
+  const filePath = cacheFilePath2();
+  let raw;
+  try {
+    raw = await readFile2(filePath, "utf8");
+  } catch (err) {
+    if (isEnoent(err)) return { hit: false, stale: false };
+    logger.debug({ err, filePath }, "repo-paths-cache: read failed");
+    return { hit: false, stale: false };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { hit: false, stale: false };
+  }
+  const result = RepoPathsDiskSchema.safeParse(parsed);
+  if (!result.success) return { hit: false, stale: false };
+  if (cache !== null) return { hit: false, stale: false };
+  const staleAfterMs = opts?.staleAfterMs ?? STALE_AFTER_MS_DEFAULT;
+  const ageMs = Math.max(0, Date.now() - result.data.populatedAt);
+  const stale = ageMs > staleAfterMs;
+  cache = result.data;
+  logger.info(
+    { repos: result.data.repos.length, worktrees: result.data.worktrees.length, ageMs, stale },
+    "repo-paths-cache: hydrated from disk"
+  );
+  return { hit: true, stale };
+}
+async function persistDisk(entry, generation) {
+  const filePath = cacheFilePath2();
+  const tmpPath = `${filePath}.tmp`;
+  try {
+    await mkdir2(dirname3(filePath), { recursive: true });
+    await writeFile3(tmpPath, JSON.stringify(entry), "utf8");
+    if (generation !== cacheGeneration) {
+      await unlink2(tmpPath).catch(() => {
+      });
+      return;
+    }
+    await rename3(tmpPath, filePath);
+  } catch (err) {
+    logger.debug({ err, filePath }, "repo-paths-cache: save failed");
+    void unlink2(tmpPath).catch(() => {
+    });
+  }
+}
+function addWorktreeToCache(worktreePath, sourceRepoPath) {
+  if (!cache) return;
+  const repos = cache.repos.includes(sourceRepoPath) ? cache.repos : [...cache.repos, sourceRepoPath];
+  const worktrees = cache.worktrees.includes(worktreePath) ? cache.worktrees : [...cache.worktrees, worktreePath];
+  cache = { repos, worktrees, populatedAt: cache.populatedAt };
+  cacheGeneration += 1;
+  void persistDisk(cache, cacheGeneration);
+}
+function removeWorktreeFromCache(worktreePath) {
+  if (!cache) return;
+  const next = cache.worktrees.filter((p) => p !== worktreePath);
+  if (next.length === cache.worktrees.length) return;
+  cache = { repos: cache.repos, worktrees: next, populatedAt: cache.populatedAt };
+  cacheGeneration += 1;
+  void persistDisk(cache, cacheGeneration);
+}
+async function refreshRepoPathsInBackground(log) {
+  if (backgroundRefreshInFlight) return;
+  backgroundRefreshInFlight = true;
+  const startGen = cacheGeneration;
+  const start = Date.now();
+  try {
+    const { findGitRepos: findGitRepos2, discoverWorktrees: discoverWorktrees2 } = await import("./git-repo-TN3VZXQV.js");
+    const { homedir: homedir2 } = await import("os");
+    const repos = await findGitRepos2(homedir2());
+    const worktrees = await discoverWorktrees2(repos);
+    if (cacheGeneration !== startGen) {
+      log.debug(
+        { event: "repo_paths_cache_refresh_dropped" },
+        "repo-paths-cache: background refresh dropped (cache mutated mid-walk)"
+      );
+      return;
+    }
+    if (repos.length === 0 && cache && cache.repos.length > 0) {
+      log.warn(
+        {
+          event: "repo_paths_cache_refresh_empty_preserved",
+          prevRepos: cache.repos.length
+        },
+        "repo-paths-cache: background refresh returned empty; preserving prior cache"
+      );
+      return;
+    }
+    setCachedRepoPaths(repos, worktrees);
+    log.info(
+      {
+        event: "repo_paths_cache_refresh_complete",
+        repos: repos.length,
+        worktrees: worktrees.length,
+        durationMs: Date.now() - start
+      },
+      "repo-paths-cache: background refresh complete"
+    );
+  } catch (err) {
+    log.warn(
+      { err, event: "repo_paths_cache_refresh_failed", durationMs: Date.now() - start },
+      "repo-paths-cache: background refresh failed"
+    );
+  } finally {
+    backgroundRefreshInFlight = false;
+  }
+}
+async function hydrateAndLogRepoPathsCache(log) {
+  const result = await hydrateRepoPathsCacheFromDisk();
+  log.info(
+    {
+      event: "repo_paths_cache_hydrate_result",
+      hit: result.hit,
+      stale: result.stale
+    },
+    result.hit ? result.stale ? "repo-paths cache hydrated from disk (stale; background refresh scheduled)" : "repo-paths cache hydrated from disk (fresh)" : "repo-paths cache cold (walk will fire inside detect_environments)"
+  );
+  if (result.hit && result.stale) {
+    void refreshRepoPathsInBackground(log);
+  }
+  return result.hit;
+}
+
+// src/shared/capabilities/shell.ts
+import { execFile } from "child_process";
+import { homedir } from "os";
+import { join as join4 } from "path";
+var TIMEOUT_MS = 5e3;
+var AUTH_STATUS_TIMEOUT_MS = 5e3;
+function buildDarwinVersionManagerPaths(home) {
+  return [
+    join4(home, ".nvm", "current", "bin"),
+    join4(home, ".volta", "bin"),
+    join4(home, ".local", "bin"),
+    join4(home, ".cargo", "bin"),
+    "/opt/homebrew/opt/node/bin"
+  ];
+}
+var STANDARD_PATHS_BY_PLATFORM = {
+  darwin: [
+    "/usr/bin",
+    "/usr/local/bin",
+    "/opt/homebrew/bin",
+    ...buildDarwinVersionManagerPaths(homedir())
+  ],
+  linux: ["/usr/bin", "/usr/local/bin"]
+};
+function augmentPath(currentPath, platform) {
+  const standardPaths = STANDARD_PATHS_BY_PLATFORM[platform];
+  if (!standardPaths) return currentPath;
+  const existing = currentPath.length > 0 ? currentPath.split(":") : [];
+  const existingSet = new Set(existing);
+  const toPrepend = standardPaths.filter((p) => !existingSet.has(p));
+  if (toPrepend.length === 0) return currentPath;
+  return existing.length > 0 ? `${toPrepend.join(":")}:${currentPath}` : toPrepend.join(":");
+}
+var augmentedPath = augmentPath(process.env.PATH ?? "", process.platform);
+if (augmentedPath.length > 0) {
+  process.env.PATH = augmentedPath;
+}
+function run(command, args, cwd, timeoutMs = TIMEOUT_MS) {
+  return new Promise((resolve2, reject) => {
+    execFile(command, args, { timeout: timeoutMs, cwd }, (error, stdout) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve2(stdout.trim());
+    });
+  });
+}
+function runWithTimeout(command, args, cwd, timeoutMs) {
+  return new Promise((resolve2, reject) => {
+    execFile(
+      command,
+      args,
+      { timeout: timeoutMs, cwd, maxBuffer: 10 * 1024 * 1024 },
+      (error, stdout) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve2(stdout.trim());
+      }
+    );
+  });
+}
+var DIFF_TIMEOUT_MS = 15e3;
+var MAX_DIFF_SIZE = 5e5;
+function isMaxBufferError(err) {
+  return err instanceof Error && err.message.includes("maxBuffer");
+}
+var BUFFER_OVERFLOW_MSG = "... diff too large (exceeded buffer limit) ...\n";
+function truncateDiff(result) {
+  if (result.length <= MAX_DIFF_SIZE) return result;
+  const boundary = result.lastIndexOf("\ndiff --git ", MAX_DIFF_SIZE);
+  const cutoff = boundary > 0 ? boundary : MAX_DIFF_SIZE;
+  return `${result.slice(0, cutoff)}
+
+... diff truncated (exceeds 500KB) ...
+`;
+}
+
+// src/shared/capabilities/git-repo.ts
+var GIT_PROBE_TIMEOUT_MS = 3e3;
+var SLOW_PATH_LOG_THRESHOLD_MS = 2e3;
+async function withProbeTimeout(op, timeoutMs) {
+  return new Promise((resolve2) => {
+    const timer = setTimeout(() => resolve2(null), timeoutMs);
+    timer.unref?.();
+    op.then(
+      (v) => {
+        clearTimeout(timer);
+        resolve2(v);
+      },
+      () => {
+        clearTimeout(timer);
+        resolve2(null);
+      }
+    );
+  });
+}
+var gitRepoCache = /* @__PURE__ */ new Map();
+async function isGitRepo(cwd) {
+  const cached = gitRepoCache.get(cwd);
+  if (cached !== void 0) return cached;
+  try {
+    await runWithTimeout("git", ["rev-parse", "--git-dir"], cwd, TIMEOUT_MS);
+    gitRepoCache.set(cwd, true);
+    return true;
+  } catch {
+    gitRepoCache.set(cwd, false);
+    return false;
+  }
+}
+var ghAvailableCache = false;
+async function isGhAvailable() {
+  if (ghAvailableCache) return true;
+  try {
+    await run("which", ["gh"]);
+    ghAvailableCache = true;
+    return true;
+  } catch {
+    return false;
+  }
+}
+var topLevelCache = /* @__PURE__ */ new Map();
+async function getGitTopLevel(cwd) {
+  const cached = topLevelCache.get(cwd);
+  if (cached !== void 0) return cached;
+  const topLevel = (await runWithTimeout("git", ["rev-parse", "--show-toplevel"], cwd, TIMEOUT_MS)).trim();
+  topLevelCache.set(cwd, topLevel);
+  return topLevel;
+}
+function parseOwnerRepo(remoteUrl) {
+  const match = remoteUrl.match(/github\.com[:/]([^/]+)\/([^/.]+)/);
+  if (!match?.[1] || !match[2]) return null;
+  return { owner: match[1], repo: match[2] };
+}
+async function getRepoDefaultBranch(cwd) {
+  const head = await gitExecSafe(cwd, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]);
+  if (!head) return null;
+  return head.replace(/^origin\//, "") || null;
+}
+async function isAncestor(ancestor, descendant, cwd) {
+  try {
+    await runWithTimeout("git", ["merge-base", "--is-ancestor", ancestor, descendant], cwd, 5e3);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var EXCLUDE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "Library",
+  "Applications",
+  "Pictures",
+  "Music",
+  "Movies",
+  "go",
+  ".Trash"
+]);
+var MAX_DEPTH = 4;
+var WORKTREE_DISCOVERY_CONCURRENCY = 8;
+var REPO_METADATA_CONCURRENCY = 16;
+async function mapLimit(items, limit, mapper) {
+  const results = new Array(items.length);
+  const indexedItems = items.map((item, index) => ({ item, index }));
+  let nextIndex = 0;
+  const workerCount = Math.min(Math.max(1, limit), items.length);
+  await Promise.all(
+    Array.from({ length: workerCount }, async () => {
+      for (; ; ) {
+        const next = indexedItems[nextIndex];
+        nextIndex += 1;
+        if (!next) return;
+        results[next.index] = await mapper(next.item, next.index);
+      }
+    })
+  );
+  return results;
+}
+async function findGitRepos(dir, depth = 0) {
+  if (depth > MAX_DEPTH) return [];
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name === ".git") {
+        return [dir];
+      }
+    }
+    if (depth >= MAX_DEPTH) return [];
+    const promises = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith(".")) continue;
+      if (EXCLUDE_DIRS.has(entry.name)) continue;
+      promises.push(findGitRepos(join5(dir, entry.name), depth + 1));
+    }
+    const results = await Promise.all(promises);
+    return results.flat();
+  } catch {
+    return [];
+  }
+}
+async function readBranchFromHead(repoPath) {
+  const directHeadPath = join5(repoPath, ".git", "HEAD");
+  try {
+    const direct = await readFile3(directHeadPath, "utf8");
+    const trimmed = direct.trim();
+    if (trimmed.startsWith("ref: refs/heads/")) {
+      return trimmed.slice("ref: refs/heads/".length);
+    }
+    if (!trimmed.startsWith("gitdir:")) {
+      return "HEAD";
+    }
+  } catch {
+  }
+  try {
+    const headPath = await resolveHeadPath(repoPath);
+    if (!headPath) return "HEAD";
+    const contents = await readFile3(headPath, "utf8");
+    const trimmed2 = contents.trim();
+    if (trimmed2.startsWith("ref: refs/heads/")) {
+      return trimmed2.slice("ref: refs/heads/".length);
+    }
+    return "HEAD";
+  } catch {
+    return "HEAD";
+  }
+}
+async function getRepoMetadata(repoPath, cached) {
+  try {
+    if (cached) {
+      return {
+        path: repoPath,
+        name: basename(repoPath),
+        branch: cached.branch,
+        ...cached.remote !== null && { remote: cached.remote }
+      };
+    }
+    const [branchResult, remoteResult] = await Promise.all([
+      withProbeTimeout(readBranchFromHead(repoPath), GIT_PROBE_TIMEOUT_MS),
+      withProbeTimeout(
+        gitExecSafe(repoPath, ["remote", "get-url", "origin"]),
+        GIT_PROBE_TIMEOUT_MS
+      )
+    ]);
+    const branch = branchResult ?? "HEAD";
+    const remote = remoteResult ? remoteResult || void 0 : void 0;
+    return {
+      path: repoPath,
+      name: basename(repoPath),
+      branch,
+      ...remote && { remote }
+    };
+  } catch {
+    return null;
+  }
+}
+async function processRepoPaths(path, idx, fingerprints, prevCache, nextCache) {
+  const currentFingerprint = fingerprints[idx] ?? { headMtimeMs: null, configMtimeMs: null };
+  const prev = prevCache.get(path);
+  const cacheHit = prev !== void 0 && currentFingerprint.headMtimeMs !== null && isCacheValid(prev, currentFingerprint);
+  const start = Date.now();
+  const info = await withProbeTimeout(
+    getRepoMetadata(path, cacheHit ? prev : void 0),
+    GIT_PROBE_TIMEOUT_MS
+  );
+  const durationMs = Date.now() - start;
+  if (info === null && durationMs >= GIT_PROBE_TIMEOUT_MS * 0.9) {
+    logger.warn(
+      { event: "environments_walk_path_timed_out", path, durationMs },
+      "environments walk skipped path past per-path timeout"
+    );
+  } else if (durationMs >= SLOW_PATH_LOG_THRESHOLD_MS) {
+    logger.warn(
+      { event: "environments_walk_path_slow", path, durationMs },
+      "environments walk path resolved slowly"
+    );
+  }
+  if (info !== null && currentFingerprint.headMtimeMs !== null) {
+    nextCache.set(path, {
+      path,
+      branch: info.branch,
+      remote: info.remote ?? null,
+      headMtimeMs: currentFingerprint.headMtimeMs,
+      configMtimeMs: currentFingerprint.configMtimeMs,
+      cachedAt: cacheHit && prev ? prev.cachedAt : Date.now()
+    });
+  }
+  return info;
+}
+async function detectEnvironments(lastKnown) {
+  const { homedir: homedir2 } = await import("os");
+  const cachedPaths = getCachedRepoPaths();
+  let repoPaths;
+  let worktreePaths;
+  if (cachedPaths) {
+    repoPaths = cachedPaths.repos;
+    worktreePaths = cachedPaths.worktrees;
+  } else {
+    try {
+      repoPaths = await findGitRepos(homedir2());
+    } catch (err) {
+      if (lastKnown && lastKnown.length > 0) {
+        const { logger: logger2 } = await import("./logger-QHPTO22N.js");
+        logger2.warn(
+          { err, lastKnownCount: lastKnown.length },
+          "detectEnvironments findGitRepos threw \u2014 preserving lastKnown"
+        );
+        return lastKnown;
+      }
+      return [];
+    }
+    if (repoPaths.length === 0 && lastKnown && lastKnown.length > 0) {
+      const { logger: logger2 } = await import("./logger-QHPTO22N.js");
+      logger2.warn(
+        { lastKnownCount: lastKnown.length },
+        "detectEnvironments walk empty but lastKnown non-empty \u2014 preserving lastKnown"
+      );
+      return lastKnown;
+    }
+    worktreePaths = await discoverWorktrees(repoPaths);
+    setCachedRepoPaths(repoPaths, worktreePaths);
+  }
+  const allPaths = [.../* @__PURE__ */ new Set([...repoPaths, ...worktreePaths])];
+  const prevCache = await loadCache();
+  const fingerprints = await mapLimit(allPaths, REPO_METADATA_CONCURRENCY, getGitCacheFingerprint);
+  const nextCache = /* @__PURE__ */ new Map();
+  const resolved = await mapLimit(
+    allPaths,
+    REPO_METADATA_CONCURRENCY,
+    (path, idx) => processRepoPaths(path, idx, fingerprints, prevCache, nextCache)
+  );
+  await saveCache(nextCache);
+  return resolved.filter((info) => info !== null);
+}
+async function discoverWorktrees(repoPaths) {
+  const results = await mapLimit(
+    repoPaths,
+    WORKTREE_DISCOVERY_CONCURRENCY,
+    async (repoPath) => {
+      try {
+        return { status: "fulfilled", value: await listLinkedWorktrees(repoPath) };
+      } catch (reason) {
+        return { status: "rejected", reason };
+      }
+    }
+  );
+  return dedupePerRepoWorktreeOutputs(results);
+}
+function dedupePerRepoWorktreeOutputs(results) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const r of results) {
+    if (r.status !== "fulfilled") continue;
+    for (const wt of r.value) {
+      if (seen.has(wt)) continue;
+      seen.add(wt);
+      out.push(wt);
+    }
+  }
+  return out;
+}
+async function listLinkedWorktrees(repoPath) {
+  const gitWorktreesDir = join5(repoPath, ".git", "worktrees");
+  let entries;
+  try {
+    entries = await readdir(gitWorktreesDir);
+  } catch {
+    return [];
+  }
+  const paths = await Promise.all(
+    entries.map(async (name) => {
+      try {
+        const gitdirFile = join5(gitWorktreesDir, name, "gitdir");
+        const content = await readFile3(gitdirFile, "utf8");
+        const wtGitPath = content.trim();
+        if (wtGitPath.endsWith("/.git")) {
+          return wtGitPath.slice(0, -"/.git".length);
+        }
+        return null;
+      } catch {
+        return null;
+      }
+    })
+  );
+  return paths.filter((p) => p !== null && p !== repoPath);
+}
+function parseWorktreeListOutput(output, repoPath) {
+  const paths = [];
+  for (const line of output.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      const wt = line.slice("worktree ".length).trim();
+      if (wt && wt !== repoPath) paths.push(wt);
+    }
+  }
+  return paths;
+}
+var _testing = {
+  parseWorktreeListOutput,
+  dedupePerRepoWorktreeOutputs,
+  listLinkedWorktrees,
+  readBranchFromHead,
+  mapLimit,
+  withProbeTimeout,
+  GIT_PROBE_TIMEOUT_MS,
+  SLOW_PATH_LOG_THRESHOLD_MS,
+  resetGhAvailableCache: () => {
+    ghAvailableCache = false;
+  }
+};
+
+export {
+  TIMEOUT_MS,
+  AUTH_STATUS_TIMEOUT_MS,
+  run,
+  runWithTimeout,
+  DIFF_TIMEOUT_MS,
+  isMaxBufferError,
+  BUFFER_OVERFLOW_MSG,
+  truncateDiff,
+  isEnoent,
+  isEexist,
+  isCorruptionError,
+  atomicWriteFile,
+  findProjectRoot,
+  addWorktreeToCache,
+  removeWorktreeFromCache,
+  hydrateAndLogRepoPathsCache,
+  gitRepoCache,
+  isGitRepo,
+  isGhAvailable,
+  getGitTopLevel,
+  parseOwnerRepo,
+  getRepoDefaultBranch,
+  isAncestor,
+  findGitRepos,
+  getRepoMetadata,
+  detectEnvironments,
+  discoverWorktrees,
+  _testing
+};
+//# sourceMappingURL=chunk-YZ3Z3ZYI.js.map