@iaforged/context-code 1.0.63 → 1.0.65

package/dist/src/utils/plugins/cacheUtils.js

@@ -1,174 +0,0 @@
-import { readdir, rm, stat, unlink, writeFile } from 'fs/promises';
-import { join } from 'path';
-import { clearCommandsCache } from '../../commands.js';
-import { clearAllOutputStylesCache } from '../../constants/outputStyles.js';
-import { clearAgentDefinitionsCache } from '../../tools/AgentTool/loadAgentsDir.js';
-import { clearPromptCache } from '../../tools/SkillTool/prompt.js';
-import { resetSentSkillNames } from '../attachments.js';
-import { logForDebugging } from '../debug.js';
-import { getErrnoCode } from '../errors.js';
-import { logError } from '../log.js';
-import { loadInstalledPluginsFromDisk } from './installedPluginsManager.js';
-import { clearPluginAgentCache } from './loadPluginAgents.js';
-import { clearPluginCommandCache } from './loadPluginCommands.js';
-import { clearPluginHookCache, pruneRemovedPluginHooks, } from './loadPluginHooks.js';
-import { clearPluginOutputStyleCache } from './loadPluginOutputStyles.js';
-import { clearPluginCache, getPluginCachePath } from './pluginLoader.js';
-import { clearPluginOptionsCache } from './pluginOptionsStorage.js';
-import { isPluginZipCacheEnabled } from './zipCache.js';
-const ORPHANED_AT_FILENAME = '.orphaned_at';
-const CLEANUP_AGE_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
-export function clearAllPluginCaches() {
-    clearPluginCache();
-    clearPluginCommandCache();
-    clearPluginAgentCache();
-    clearPluginHookCache();
-    // Prune hooks from plugins no longer in the enabled set so uninstalled/
-    // disabled plugins stop firing immediately (gh-36995). Prune-only: hooks
-    // from newly-enabled plugins are NOT added here — they wait for
-    // /reload-plugins like commands/agents/MCP do. Fire-and-forget: old hooks
-    // stay valid until the prune completes (preserves gh-29767). No-op when
-    // STATE.registeredHooks is empty (test/preload.ts beforeEach clears it via
-    // resetStateForTests before reaching here).
-    pruneRemovedPluginHooks().catch(e => logError(e));
-    clearPluginOptionsCache();
-    clearPluginOutputStyleCache();
-    clearAllOutputStylesCache();
-}
-export function clearAllCaches() {
-    clearAllPluginCaches();
-    clearCommandsCache();
-    clearAgentDefinitionsCache();
-    clearPromptCache();
-    resetSentSkillNames();
-}
-/**
- * Mark a plugin version as orphaned.
- * Called when a plugin is uninstalled or updated to a new version.
- */
-export async function markPluginVersionOrphaned(versionPath) {
-    try {
-        await writeFile(getOrphanedAtPath(versionPath), `${Date.now()}`, 'utf-8');
-    }
-    catch (error) {
-        logForDebugging(`Failed to write .orphaned_at: ${versionPath}: ${error}`);
-    }
-}
-/**
- * Clean up orphaned plugin versions that have been orphaned for more than 7 days.
- *
- * Pass 1: Remove .orphaned_at from installed versions (clears stale markers)
- * Pass 2: For each cached version not in installed_plugins.json:
- *   - If no .orphaned_at exists: create it (handles old CC versions, manual edits)
- *   - If .orphaned_at exists and > 7 days old: delete the version
- */
-export async function cleanupOrphanedPluginVersionsInBackground() {
-    // Zip cache mode stores plugins as .zip files, not directories. readSubdirs
-    // filters to directories only, so removeIfEmpty would see plugin dirs as empty
-    // and delete them (including the ZIPs). Skip cleanup entirely in zip mode.
-    if (isPluginZipCacheEnabled()) {
-        return;
-    }
-    try {
-        const installedVersions = getInstalledVersionPaths();
-        if (!installedVersions)
-            return;
-        const cachePath = getPluginCachePath();
-        const now = Date.now();
-        // Pass 1: Remove .orphaned_at from installed versions
-        // This handles cases where a plugin was reinstalled after being orphaned
-        await Promise.all([...installedVersions].map(p => removeOrphanedAtMarker(p)));
-        // Pass 2: Process orphaned versions
-        for (const marketplace of await readSubdirs(cachePath)) {
-            const marketplacePath = join(cachePath, marketplace);
-            for (const plugin of await readSubdirs(marketplacePath)) {
-                const pluginPath = join(marketplacePath, plugin);
-                for (const version of await readSubdirs(pluginPath)) {
-                    const versionPath = join(pluginPath, version);
-                    if (installedVersions.has(versionPath))
-                        continue;
-                    await processOrphanedPluginVersion(versionPath, now);
-                }
-                await removeIfEmpty(pluginPath);
-            }
-            await removeIfEmpty(marketplacePath);
-        }
-    }
-    catch (error) {
-        logForDebugging(`Plugin cache cleanup failed: ${error}`);
-    }
-}
-function getOrphanedAtPath(versionPath) {
-    return join(versionPath, ORPHANED_AT_FILENAME);
-}
-async function removeOrphanedAtMarker(versionPath) {
-    const orphanedAtPath = getOrphanedAtPath(versionPath);
-    try {
-        await unlink(orphanedAtPath);
-    }
-    catch (error) {
-        const code = getErrnoCode(error);
-        if (code === 'ENOENT')
-            return;
-        logForDebugging(`Failed to remove .orphaned_at: ${versionPath}: ${error}`);
-    }
-}
-function getInstalledVersionPaths() {
-    try {
-        const paths = new Set();
-        const diskData = loadInstalledPluginsFromDisk();
-        for (const installations of Object.values(diskData.plugins)) {
-            for (const entry of installations) {
-                paths.add(entry.installPath);
-            }
-        }
-        return paths;
-    }
-    catch (error) {
-        logForDebugging(`Failed to load installed plugins: ${error}`);
-        return null;
-    }
-}
-async function processOrphanedPluginVersion(versionPath, now) {
-    const orphanedAtPath = getOrphanedAtPath(versionPath);
-    let orphanedAt;
-    try {
-        orphanedAt = (await stat(orphanedAtPath)).mtimeMs;
-    }
-    catch (error) {
-        const code = getErrnoCode(error);
-        if (code === 'ENOENT') {
-            await markPluginVersionOrphaned(versionPath);
-            return;
-        }
-        logForDebugging(`Failed to stat orphaned marker: ${versionPath}: ${error}`);
-        return;
-    }
-    if (now - orphanedAt > CLEANUP_AGE_MS) {
-        try {
-            await rm(versionPath, { recursive: true, force: true });
-        }
-        catch (error) {
-            logForDebugging(`Failed to delete orphaned version: ${versionPath}: ${error}`);
-        }
-    }
-}
-async function removeIfEmpty(dirPath) {
-    if ((await readSubdirs(dirPath)).length === 0) {
-        try {
-            await rm(dirPath, { recursive: true, force: true });
-        }
-        catch (error) {
-            logForDebugging(`Failed to remove empty dir: ${dirPath}: ${error}`);
-        }
-    }
-}
-async function readSubdirs(dirPath) {
-    try {
-        const entries = await readdir(dirPath, { withFileTypes: true });
-        return entries.filter(d => d.isDirectory()).map(d => d.name);
-    }
-    catch {
-        return [];
-    }
-}

package/dist/src/utils/plugins/dependencyResolver.js

@@ -1,244 +0,0 @@
-/**
- * Plugin dependency resolution — pure functions, no I/O.
- *
- * Semantics are `apt`-style: a dependency is a *presence guarantee*, not a
- * module graph. Plugin A depending on Plugin B means "B's namespaced
- * components (MCP servers, commands, agents) must be available when A runs."
- *
- * Two entry points:
- *  - `resolveDependencyClosure` — install-time DFS walk, cycle detection
- *  - `verifyAndDemote` — load-time fixed-point check, demotes plugins with
- *    unsatisfied deps (session-local, does NOT write settings)
- */
-import { getSettingsForSource } from '../settings/settings.js';
-import { parsePluginIdentifier } from './pluginIdentifier.js';
-/**
- * Synthetic marketplace sentinel for `--plugin-dir` plugins (pluginLoader.ts
- * sets `source = "{name}@inline"`). Not a real marketplace — bare deps from
- * these plugins cannot meaningfully inherit it.
- */
-const INLINE_MARKETPLACE = 'inline';
-/**
- * Normalize a dependency reference to fully-qualified "name@marketplace" form.
- * Bare names (no @) inherit the marketplace of the plugin declaring them —
- * cross-marketplace deps are blocked anyway, so the @-suffix is boilerplate
- * in the common case.
- *
- * EXCEPTION: if the declaring plugin is @inline (loaded via --plugin-dir),
- * bare deps are returned unchanged. `inline` is a synthetic sentinel, not a
- * real marketplace — fabricating "dep@inline" would never match anything.
- * verifyAndDemote handles bare deps via name-only matching.
- */
-export function qualifyDependency(dep, declaringPluginId) {
-    if (parsePluginIdentifier(dep).marketplace)
-        return dep;
-    const mkt = parsePluginIdentifier(declaringPluginId).marketplace;
-    if (!mkt || mkt === INLINE_MARKETPLACE)
-        return dep;
-    return `${dep}@${mkt}`;
-}
-/**
- * Walk the transitive dependency closure of `rootId` via DFS.
- *
- * The returned `closure` ALWAYS contains `rootId`, plus every transitive
- * dependency that is NOT in `alreadyEnabled`. Already-enabled deps are
- * skipped (not recursed into) — this avoids surprise settings writes when a
- * dep is already installed at a different scope. The root is never skipped,
- * even if already enabled, so re-installing a plugin always re-caches it.
- *
- * Cross-marketplace dependencies are BLOCKED by default: a plugin in
- * marketplace A cannot auto-install a plugin from marketplace B. This is
- * a security boundary — installing from a trusted marketplace shouldn't
- * silently pull from an untrusted one. Two escapes: (1) install the
- * cross-mkt dep yourself first (already-enabled deps are skipped, so the
- * closure won't touch it), or (2) the ROOT marketplace's
- * `allowCrossMarketplaceDependenciesOn` allowlist — only the root's list
- * applies for the whole walk (no transitive trust: if A allows B, B's
- * plugin depending on C is still blocked unless A also allows C).
- *
- * @param rootId Root plugin to resolve from (format: "name@marketplace")
- * @param lookup Async lookup returning `{dependencies}` or `null` if not found
- * @param alreadyEnabled Plugin IDs to skip (deps only, root is never skipped)
- * @param allowedCrossMarketplaces Marketplace names the root trusts for
- *   auto-install (from the root marketplace's manifest)
- * @returns Closure to install, or a cycle/not-found/cross-marketplace error
- */
-export async function resolveDependencyClosure(rootId, lookup, alreadyEnabled, allowedCrossMarketplaces = new Set()) {
-    const rootMarketplace = parsePluginIdentifier(rootId).marketplace;
-    const closure = [];
-    const visited = new Set();
-    const stack = [];
-    async function walk(id, requiredBy) {
-        // Skip already-enabled DEPENDENCIES (avoids surprise settings writes),
-        // but NEVER skip the root: installing an already-enabled plugin must
-        // still cache/register it. Without this guard, re-installing a plugin
-        // that's in settings but missing from disk (e.g., cache cleared,
-        // installed_plugins.json stale) would return an empty closure and
-        // `cacheAndRegisterPlugin` would never fire — user sees
-        // "✔ Successfully installed" but nothing materializes.
-        if (id !== rootId && alreadyEnabled.has(id))
-            return null;
-        // Security: block auto-install across marketplace boundaries. Runs AFTER
-        // the alreadyEnabled check — if the user manually installed a cross-mkt
-        // dep, it's in alreadyEnabled and we never reach this.
-        const idMarketplace = parsePluginIdentifier(id).marketplace;
-        if (idMarketplace !== rootMarketplace &&
-            !(idMarketplace && allowedCrossMarketplaces.has(idMarketplace))) {
-            return {
-                ok: false,
-                reason: 'cross-marketplace',
-                dependency: id,
-                requiredBy,
-            };
-        }
-        if (stack.includes(id)) {
-            return { ok: false, reason: 'cycle', chain: [...stack, id] };
-        }
-        if (visited.has(id))
-            return null;
-        visited.add(id);
-        const entry = await lookup(id);
-        if (!entry) {
-            return { ok: false, reason: 'not-found', missing: id, requiredBy };
-        }
-        stack.push(id);
-        for (const rawDep of entry.dependencies ?? []) {
-            const dep = qualifyDependency(rawDep, id);
-            const err = await walk(dep, id);
-            if (err)
-                return err;
-        }
-        stack.pop();
-        closure.push(id);
-        return null;
-    }
-    const err = await walk(rootId, rootId);
-    if (err)
-        return err;
-    return { ok: true, closure };
-}
-/**
- * Load-time safety net: for each enabled plugin, verify all manifest
- * dependencies are also in the enabled set. Demote any that fail.
- *
- * Fixed-point loop: demoting plugin A may break plugin B that depends on A,
- * so we iterate until nothing changes.
- *
- * The `reason` field distinguishes:
- *  - `'not-enabled'` — dep exists in the loaded set but is disabled
- *  - `'not-found'` — dep is entirely absent (not in any marketplace)
- *
- * Does NOT mutate input. Returns the set of plugin IDs (sources) to demote.
- *
- * @param plugins All loaded plugins (enabled + disabled)
- * @returns Set of pluginIds to demote, plus errors for `/doctor`
- */
-export function verifyAndDemote(plugins) {
-    const known = new Set(plugins.map(p => p.source));
-    const enabled = new Set(plugins.filter(p => p.enabled).map(p => p.source));
-    // Name-only indexes for bare deps from --plugin-dir (@inline) plugins:
-    // the real marketplace is unknown, so match "B" against any enabled "B@*".
-    // enabledByName is a multiset: if B@epic AND B@other are both enabled,
-    // demoting one mustn't make "B" disappear from the index.
-    const knownByName = new Set(plugins.map(p => parsePluginIdentifier(p.source).name));
-    const enabledByName = new Map();
-    for (const id of enabled) {
-        const n = parsePluginIdentifier(id).name;
-        enabledByName.set(n, (enabledByName.get(n) ?? 0) + 1);
-    }
-    const errors = [];
-    let changed = true;
-    while (changed) {
-        changed = false;
-        for (const p of plugins) {
-            if (!enabled.has(p.source))
-                continue;
-            for (const rawDep of p.manifest.dependencies ?? []) {
-                const dep = qualifyDependency(rawDep, p.source);
-                // Bare dep ← @inline plugin: match by name only (see enabledByName)
-                const isBare = !parsePluginIdentifier(dep).marketplace;
-                const satisfied = isBare
-                    ? (enabledByName.get(dep) ?? 0) > 0
-                    : enabled.has(dep);
-                if (!satisfied) {
-                    enabled.delete(p.source);
-                    const count = enabledByName.get(p.name) ?? 0;
-                    if (count <= 1)
-                        enabledByName.delete(p.name);
-                    else
-                        enabledByName.set(p.name, count - 1);
-                    errors.push({
-                        type: 'dependency-unsatisfied',
-                        source: p.source,
-                        plugin: p.name,
-                        dependency: dep,
-                        reason: (isBare ? knownByName.has(dep) : known.has(dep))
-                            ? 'not-enabled'
-                            : 'not-found',
-                    });
-                    changed = true;
-                    break;
-                }
-            }
-        }
-    }
-    const demoted = new Set(plugins.filter(p => p.enabled && !enabled.has(p.source)).map(p => p.source));
-    return { demoted, errors };
-}
-/**
- * Find all enabled plugins that declare `pluginId` as a dependency.
- * Used to warn on uninstall/disable ("required by: X, Y").
- *
- * @param pluginId The plugin being removed/disabled
- * @param plugins All loaded plugins (only enabled ones are checked)
- * @returns Names of plugins that will break if `pluginId` goes away
- */
-export function findReverseDependents(pluginId, plugins) {
-    const { name: targetName } = parsePluginIdentifier(pluginId);
-    return plugins
-        .filter(p => p.enabled &&
-        p.source !== pluginId &&
-        (p.manifest.dependencies ?? []).some(d => {
-            const qualified = qualifyDependency(d, p.source);
-            // Bare dep (from @inline plugin): match by name only
-            return parsePluginIdentifier(qualified).marketplace
-                ? qualified === pluginId
-                : qualified === targetName;
-        }))
-        .map(p => p.name);
-}
-/**
- * Build the set of plugin IDs currently enabled at a given settings scope.
- * Used by install-time resolution to skip already-enabled deps and avoid
- * surprise settings writes.
- *
- * Matches `true` (plain enable) AND array values (version constraints per
- * settings/types.ts:455-463 — a plugin at `"foo@bar": ["^1.0.0"]` IS enabled).
- * Without the array check, a version-pinned dep would be re-added to the
- * closure and the settings write would clobber the constraint with `true`.
- */
-export function getEnabledPluginIdsForScope(settingSource) {
-    return new Set(Object.entries(getSettingsForSource(settingSource)?.enabledPlugins ?? {})
-        .filter(([, v]) => v === true || Array.isArray(v))
-        .map(([k]) => k));
-}
-/**
- * Format the "(+ N dependencies)" suffix for install success messages.
- * Returns empty string when `installedDeps` is empty.
- */
-export function formatDependencyCountSuffix(installedDeps) {
-    if (installedDeps.length === 0)
-        return '';
-    const n = installedDeps.length;
-    return ` (+ ${n} ${n === 1 ? 'dependency' : 'dependencies'})`;
-}
-/**
- * Format the "warning: required by X, Y" suffix for uninstall/disable
- * results. Em-dash style for CLI result messages (not the middot style
- * used in the notification UI). Returns empty string when no dependents.
- */
-export function formatReverseDependentsSuffix(rdeps) {
-    if (!rdeps || rdeps.length === 0)
-        return '';
-    return ` — warning: required by ${rdeps.join(', ')}`;
-}

package/dist/src/utils/plugins/fetchTelemetry.js

@@ -1,108 +0,0 @@
-/**
- * Telemetry for plugin/marketplace fetches that hit the network.
- *
- * Added for inc-5046 (GitHub complained about claude-plugins-official load).
- * Before this, fetch operations only had logForDebugging — no way to measure
- * actual network volume. This surfaces what's hitting GitHub vs GCS vs
- * user-hosted so we can see the GCS migration take effect and catch future
- * hot-path regressions before GitHub emails us again.
- *
- * Volume: these fire at startup (install-counts 24h-TTL)
- * and on explicit user action (install/update). NOT per-interaction. Similar
- * envelope to tengu_binary_download_*.
- */
-import { logEvent, } from '../../services/analytics/index.js';
-import { OFFICIAL_MARKETPLACE_NAME } from './officialMarketplace.js';
-// Allowlist of public hosts we report by name. Anything else (enterprise
-// git, self-hosted, internal) is bucketed as 'other' — we don't want
-// internal hostnames (git.mycorp.internal) landing in telemetry. Bounded
-// cardinality also keeps the dashboard host-breakdown tractable.
-const KNOWN_PUBLIC_HOSTS = new Set([
-    'github.com',
-    'raw.githubusercontent.com',
-    'objects.githubusercontent.com',
-    'gist.githubusercontent.com',
-    'gitlab.com',
-    'bitbucket.org',
-    'codeberg.org',
-    'dev.azure.com',
-    'ssh.dev.azure.com',
-    'storage.googleapis.com', // GCS — where Dickson's migration points
-]);
-/**
- * Extract hostname from a URL or git spec and bucket to the allowlist.
- * Handles `https://host/...`, `git@host:path`, `ssh://host/...`.
- * Returns a known public host, 'other' (parseable but not allowlisted —
- * don't leak private hostnames), or 'unknown' (unparseable / local path).
- */
-function extractHost(urlOrSpec) {
-    let host;
-    const scpMatch = /^[^@/]+@([^:/]+):/.exec(urlOrSpec);
-    if (scpMatch) {
-        host = scpMatch[1];
-    }
-    else {
-        try {
-            host = new URL(urlOrSpec).hostname;
-        }
-        catch {
-            return 'unknown';
-        }
-    }
-    const normalized = host.toLowerCase();
-    return KNOWN_PUBLIC_HOSTS.has(normalized) ? normalized : 'other';
-}
-/**
- * True if the URL/spec points at anthropics/claude-plugins-official — the
- * repo GitHub complained about. Lets the dashboard separate "our problem"
- * traffic from user-configured marketplaces.
- */
-function isOfficialRepo(urlOrSpec) {
-    return urlOrSpec.includes(`anthropics/${OFFICIAL_MARKETPLACE_NAME}`);
-}
-export function logPluginFetch(source, urlOrSpec, outcome, durationMs, errorKind) {
-    // String values are bounded enums / hostname-only — no code, no paths,
-    // no raw error messages. Same privacy envelope as tengu_web_fetch_host.
-    logEvent('tengu_plugin_remote_fetch', {
-        source: source,
-        host: (urlOrSpec ? extractHost(urlOrSpec) : 'unknown'),
-        is_official: urlOrSpec ? isOfficialRepo(urlOrSpec) : false,
-        outcome: outcome,
-        duration_ms: Math.round(durationMs),
-        ...(errorKind && { error_kind: errorKind }),
-    });
-}
-/**
- * Classify an error into a stable bucket for the error_kind field. Keeps
- * cardinality bounded — raw error messages would explode dashboard grouping.
- *
- * Handles both axios Error objects (Node.js error codes like ENOTFOUND) and
- * git stderr strings (human phrases like "Could not resolve host"). DNS
- * checked BEFORE timeout because gitClone's error enhancement at
- * marketplaceManager.ts:~950 rewrites DNS failures to include the word
- * "timeout" — ordering the other way would misclassify git DNS as timeout.
- */
-export function classifyFetchError(error) {
-    const msg = String(error?.message ?? error);
-    if (/ENOTFOUND|ECONNREFUSED|EAI_AGAIN|Could not resolve host|Connection refused/i.test(msg)) {
-        return 'dns_or_refused';
-    }
-    if (/ETIMEDOUT|timed out|timeout/i.test(msg))
-        return 'timeout';
-    if (/ECONNRESET|socket hang up|Connection reset by peer|remote end hung up/i.test(msg)) {
-        return 'conn_reset';
-    }
-    if (/403|401|authentication|permission denied/i.test(msg))
-        return 'auth';
-    if (/404|not found|repository not found/i.test(msg))
-        return 'not_found';
-    if (/certificate|SSL|TLS|unable to get local issuer/i.test(msg))
-        return 'tls';
-    // Schema validation throws "Invalid response format" (install_counts) —
-    // distinguish from true unknowns so the dashboard can
-    // see "server sent garbage" separately.
-    if (/Invalid response format|Invalid marketplace schema/i.test(msg)) {
-        return 'invalid_schema';
-    }
-    return 'other';
-}

package/dist/src/utils/plugins/gitAvailability.js

@@ -1,65 +0,0 @@
-/**
- * Utility for checking git availability.
- *
- * Git is required for installing GitHub-based marketplaces. This module
- * provides a memoized check to determine if git is available on the system.
- */
-import memoize from 'lodash-es/memoize.js';
-import { which } from '../which.js';
-/**
- * Check if a command is available in PATH.
- *
- * Uses which to find the actual executable without executing it.
- * This is a security best practice to avoid executing arbitrary code
- * in untrusted directories.
- *
- * @param command - The command to check for
- * @returns True if the command exists and is executable
- */
-async function isCommandAvailable(command) {
-    try {
-        return !!(await which(command));
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Check if git is available on the system.
- *
- * This is memoized so repeated calls within a session return the cached result.
- * Git availability is unlikely to change during a single CLI session.
- *
- * Only checks PATH — does not exec git. On macOS this means the /usr/bin/git
- * xcrun shim passes even without Xcode CLT installed; callers that hit
- * `xcrun: error:` at exec time should call markGitUnavailable() so the rest
- * of the session behaves as though git is absent.
- *
- * @returns True if git is installed and executable
- */
-export const checkGitAvailable = memoize(async () => {
-    return isCommandAvailable('git');
-});
-/**
- * Force the memoized git-availability check to return false for the rest of
- * the session.
- *
- * Call this when a git invocation fails in a way that indicates the binary
- * exists on PATH but cannot actually run — the macOS xcrun shim being the
- * main case (`xcrun: error: invalid active developer path`). Subsequent
- * checkGitAvailable() calls then short-circuit to false, so downstream code
- * that guards on git availability skips cleanly instead of failing repeatedly
- * with the same exec error.
- *
- * lodash memoize uses a no-arg cache key of undefined.
- */
-export function markGitUnavailable() {
-    checkGitAvailable.cache?.set?.(undefined, Promise.resolve(false));
-}
-/**
- * Clear the git availability cache.
- * Used for testing purposes.
- */
-export function clearGitAvailabilityCache() {
-    checkGitAvailable.cache?.clear?.();
-}