@iaforged/context-code 1.0.62 → 1.0.65

package/dist/src/utils/gitDiff.js

@@ -1,395 +0,0 @@
-import { access, readFile } from 'fs/promises';
-import { dirname, join, relative, sep } from 'path';
-import { getCwd } from './cwd.js';
-import { getCachedRepository } from './detectRepository.js';
-import { execFileNoThrow, execFileNoThrowWithCwd } from './execFileNoThrow.js';
-import { isFileWithinReadSizeLimit } from './file.js';
-import { findGitRoot, getDefaultBranch, getGitDir, getIsGit, gitExe, } from './git.js';
-const GIT_TIMEOUT_MS = 5000;
-const MAX_FILES = 50;
-const MAX_DIFF_SIZE_BYTES = 1_000_000; // 1 MB - skip files larger than this
-const MAX_LINES_PER_FILE = 400; // GitHub's auto-load limit
-const MAX_FILES_FOR_DETAILS = 500; // Skip per-file details if more files than this
-/**
- * Fetch git diff stats and hunks comparing working tree to HEAD.
- * Returns null if not in a git repo or if git commands fail.
- *
- * Returns null during merge/rebase/cherry-pick/revert operations since the
- * working tree contains incoming changes that weren't intentionally
- * made by the user.
- */
-export async function fetchGitDiff() {
-    const isGit = await getIsGit();
-    if (!isGit)
-        return null;
-    // Skip diff calculation during transient git states since the
-    // working tree contains incoming changes, not user-intentional edits
-    if (await isInTransientGitState()) {
-        return null;
-    }
-    // Quick probe: use --shortstat to get totals without loading all content.
-    // This is O(1) memory and lets us detect massive diffs (e.g., jj workspaces)
-    // before committing to expensive operations.
-    const { stdout: shortstatOut, code: shortstatCode } = await execFileNoThrow(gitExe(), ['--no-optional-locks', 'diff', 'HEAD', '--shortstat'], { timeout: GIT_TIMEOUT_MS, preserveOutputOnError: false });
-    if (shortstatCode === 0) {
-        const quickStats = parseShortstat(shortstatOut);
-        if (quickStats && quickStats.filesCount > MAX_FILES_FOR_DETAILS) {
-            // Too many files - return accurate totals but skip per-file details
-            // to avoid loading hundreds of MB into memory
-            return {
-                stats: quickStats,
-                perFileStats: new Map(),
-                hunks: new Map(),
-            };
-        }
-    }
-    // Get stats via --numstat (all uncommitted changes vs HEAD)
-    const { stdout: numstatOut, code: numstatCode } = await execFileNoThrow(gitExe(), ['--no-optional-locks', 'diff', 'HEAD', '--numstat'], { timeout: GIT_TIMEOUT_MS, preserveOutputOnError: false });
-    if (numstatCode !== 0)
-        return null;
-    const { stats, perFileStats } = parseGitNumstat(numstatOut);
-    // Include untracked files (new files not yet staged)
-    // Just filenames - no content reading for performance
-    const remainingSlots = MAX_FILES - perFileStats.size;
-    if (remainingSlots > 0) {
-        const untrackedStats = await fetchUntrackedFiles(remainingSlots);
-        if (untrackedStats) {
-            stats.filesCount += untrackedStats.size;
-            for (const [path, fileStats] of untrackedStats) {
-                perFileStats.set(path, fileStats);
-            }
-        }
-    }
-    // Return stats only - hunks are fetched on-demand via fetchGitDiffHunks()
-    // to avoid expensive git diff HEAD call on every poll
-    return { stats, perFileStats, hunks: new Map() };
-}
-/**
- * Fetch git diff hunks on-demand (for DiffDialog).
- * Separated from fetchGitDiff() to avoid expensive calls during polling.
- */
-export async function fetchGitDiffHunks() {
-    const isGit = await getIsGit();
-    if (!isGit)
-        return new Map();
-    if (await isInTransientGitState()) {
-        return new Map();
-    }
-    const { stdout: diffOut, code: diffCode } = await execFileNoThrow(gitExe(), ['--no-optional-locks', 'diff', 'HEAD'], { timeout: GIT_TIMEOUT_MS, preserveOutputOnError: false });
-    if (diffCode !== 0) {
-        return new Map();
-    }
-    return parseGitDiff(diffOut);
-}
-/**
- * Parse git diff --numstat output into stats.
- * Format: <added>\t<removed>\t<filename>
- * Binary files show '-' for counts.
- * Only stores first MAX_FILES entries in perFileStats.
- */
-export function parseGitNumstat(stdout) {
-    const lines = stdout.trim().split('\n').filter(Boolean);
-    let added = 0;
-    let removed = 0;
-    let validFileCount = 0;
-    const perFileStats = new Map();
-    for (const line of lines) {
-        const parts = line.split('\t');
-        // Valid numstat lines have exactly 3 tab-separated parts: added, removed, filename
-        if (parts.length < 3)
-            continue;
-        validFileCount++;
-        const addStr = parts[0];
-        const remStr = parts[1];
-        const filePath = parts.slice(2).join('\t'); // filename may contain tabs
-        const isBinary = addStr === '-' || remStr === '-';
-        const fileAdded = isBinary ? 0 : parseInt(addStr ?? '0', 10) || 0;
-        const fileRemoved = isBinary ? 0 : parseInt(remStr ?? '0', 10) || 0;
-        added += fileAdded;
-        removed += fileRemoved;
-        // Only store first MAX_FILES entries
-        if (perFileStats.size < MAX_FILES) {
-            perFileStats.set(filePath, {
-                added: fileAdded,
-                removed: fileRemoved,
-                isBinary,
-            });
-        }
-    }
-    return {
-        stats: {
-            filesCount: validFileCount,
-            linesAdded: added,
-            linesRemoved: removed,
-        },
-        perFileStats,
-    };
-}
-/**
- * Parse unified diff output into per-file hunks.
- * Splits by "diff --git" and parses each file's hunks.
- *
- * Applies limits:
- * - MAX_FILES: stop after this many files
- * - Files >1MB: skipped entirely (not in result map)
- * - Files ≤1MB: parsed but limited to MAX_LINES_PER_FILE lines
- */
-export function parseGitDiff(stdout) {
-    const result = new Map();
-    if (!stdout.trim())
-        return result;
-    // Split by file diffs
-    const fileDiffs = stdout.split(/^diff --git /m).filter(Boolean);
-    for (const fileDiff of fileDiffs) {
-        // Stop after MAX_FILES
-        if (result.size >= MAX_FILES)
-            break;
-        // Skip files larger than 1MB
-        if (fileDiff.length > MAX_DIFF_SIZE_BYTES) {
-            continue;
-        }
-        const lines = fileDiff.split('\n');
-        // Extract filename from first line: "a/path/to/file b/path/to/file"
-        const headerMatch = lines[0]?.match(/^a\/(.+?) b\/(.+)$/);
-        if (!headerMatch)
-            continue;
-        const filePath = headerMatch[2] ?? headerMatch[1] ?? '';
-        // Find and parse hunks
-        const fileHunks = [];
-        let currentHunk = null;
-        let lineCount = 0;
-        for (let i = 1; i < lines.length; i++) {
-            const line = lines[i] ?? '';
-            // StructuredPatchHunk header: @@ -oldStart,oldLines +newStart,newLines @@
-            const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
-            if (hunkMatch) {
-                if (currentHunk) {
-                    fileHunks.push(currentHunk);
-                }
-                currentHunk = {
-                    oldStart: parseInt(hunkMatch[1] ?? '0', 10),
-                    oldLines: parseInt(hunkMatch[2] ?? '1', 10),
-                    newStart: parseInt(hunkMatch[3] ?? '0', 10),
-                    newLines: parseInt(hunkMatch[4] ?? '1', 10),
-                    lines: [],
-                };
-                continue;
-            }
-            // Skip binary file markers and other metadata
-            if (line.startsWith('index ') ||
-                line.startsWith('---') ||
-                line.startsWith('+++') ||
-                line.startsWith('new file') ||
-                line.startsWith('deleted file') ||
-                line.startsWith('old mode') ||
-                line.startsWith('new mode') ||
-                line.startsWith('Binary files')) {
-                continue;
-            }
-            // Add diff lines to current hunk (with line limit)
-            if (currentHunk &&
-                (line.startsWith('+') ||
-                    line.startsWith('-') ||
-                    line.startsWith(' ') ||
-                    line === '')) {
-                // Stop adding lines once we hit the limit
-                if (lineCount >= MAX_LINES_PER_FILE) {
-                    continue;
-                }
-                // Force a flat string copy to break V8 sliced string references.
-                // When split() creates lines, V8 creates "sliced strings" that reference
-                // the parent. This keeps the entire parent string (~MBs) alive as long as
-                // any line is retained. Using '' + line forces a new flat string allocation,
-                // unlike slice(0) which V8 may optimize to return the same reference.
-                currentHunk.lines.push('' + line);
-                lineCount++;
-            }
-        }
-        // Don't forget the last hunk
-        if (currentHunk) {
-            fileHunks.push(currentHunk);
-        }
-        if (fileHunks.length > 0) {
-            result.set(filePath, fileHunks);
-        }
-    }
-    return result;
-}
-/**
- * Check if we're in a transient git state (merge, rebase, cherry-pick, or revert).
- * During these operations, we skip diff calculation since the working
- * tree contains incoming changes that weren't intentionally made.
- *
- * Uses fs.access to check for transient ref files, avoiding process spawns.
- */
-async function isInTransientGitState() {
-    const gitDir = await getGitDir(getCwd());
-    if (!gitDir)
-        return false;
-    const transientFiles = [
-        'MERGE_HEAD',
-        'REBASE_HEAD',
-        'CHERRY_PICK_HEAD',
-        'REVERT_HEAD',
-    ];
-    const results = await Promise.all(transientFiles.map(file => access(join(gitDir, file))
-        .then(() => true)
-        .catch(() => false)));
-    return results.some(Boolean);
-}
-/**
- * Fetch untracked file names (no content reading).
- * Returns file paths only - they'll be displayed with a note to stage them.
- *
- * @param maxFiles Maximum number of untracked files to include
- */
-async function fetchUntrackedFiles(maxFiles) {
-    // Get list of untracked files (excludes gitignored)
-    const { stdout, code } = await execFileNoThrow(gitExe(), ['--no-optional-locks', 'ls-files', '--others', '--exclude-standard'], { timeout: GIT_TIMEOUT_MS, preserveOutputOnError: false });
-    if (code !== 0 || !stdout.trim())
-        return null;
-    const untrackedPaths = stdout.trim().split('\n').filter(Boolean);
-    if (untrackedPaths.length === 0)
-        return null;
-    const perFileStats = new Map();
-    // Just record filenames, no content reading
-    for (const filePath of untrackedPaths.slice(0, maxFiles)) {
-        perFileStats.set(filePath, {
-            added: 0,
-            removed: 0,
-            isBinary: false,
-            isUntracked: true,
-        });
-    }
-    return perFileStats;
-}
-/**
- * Parse git diff --shortstat output into stats.
- * Format: " 1648 files changed, 52341 insertions(+), 8123 deletions(-)"
- *
- * This is O(1) memory regardless of diff size - git computes totals without
- * loading all content. Used as a quick probe before expensive operations.
- */
-export function parseShortstat(stdout) {
-    // Match: "N files changed" with optional ", N insertions(+)" and ", N deletions(-)"
-    const match = stdout.match(/(\d+)\s+files?\s+changed(?:,\s+(\d+)\s+insertions?\(\+\))?(?:,\s+(\d+)\s+deletions?\(-\))?/);
-    if (!match)
-        return null;
-    return {
-        filesCount: parseInt(match[1] ?? '0', 10),
-        linesAdded: parseInt(match[2] ?? '0', 10),
-        linesRemoved: parseInt(match[3] ?? '0', 10),
-    };
-}
-const SINGLE_FILE_DIFF_TIMEOUT_MS = 3000;
-/**
- * Fetch a structured diff for a single file against the merge base with the
- * default branch. This produces a PR-like diff showing all changes since
- * the branch diverged. Falls back to diffing against HEAD if the merge base
- * cannot be determined (e.g., on the default branch itself).
- * For untracked files, generates a synthetic diff showing all additions.
- * Returns null if not in a git repo or if git commands fail.
- */
-export async function fetchSingleFileGitDiff(absoluteFilePath) {
-    const gitRoot = findGitRoot(dirname(absoluteFilePath));
-    if (!gitRoot)
-        return null;
-    const gitPath = relative(gitRoot, absoluteFilePath).split(sep).join('/');
-    const repository = getCachedRepository();
-    // Check if the file is tracked by git
-    const { code: lsFilesCode } = await execFileNoThrowWithCwd(gitExe(), ['--no-optional-locks', 'ls-files', '--error-unmatch', gitPath], { cwd: gitRoot, timeout: SINGLE_FILE_DIFF_TIMEOUT_MS });
-    if (lsFilesCode === 0) {
-        // File is tracked - diff against merge base for PR-like view
-        const diffRef = await getDiffRef(gitRoot);
-        const { stdout, code } = await execFileNoThrowWithCwd(gitExe(), ['--no-optional-locks', 'diff', diffRef, '--', gitPath], { cwd: gitRoot, timeout: SINGLE_FILE_DIFF_TIMEOUT_MS });
-        if (code !== 0)
-            return null;
-        if (!stdout)
-            return null;
-        return {
-            ...parseRawDiffToToolUseDiff(gitPath, stdout, 'modified'),
-            repository,
-        };
-    }
-    // File is untracked - generate synthetic diff
-    const syntheticDiff = await generateSyntheticDiff(gitPath, absoluteFilePath);
-    if (!syntheticDiff)
-        return null;
-    return { ...syntheticDiff, repository };
-}
-/**
- * Parse raw unified diff output into the structured ToolUseDiff format.
- * Extracts only the hunk content (starting from @@) as the patch,
- * and counts additions/deletions.
- */
-function parseRawDiffToToolUseDiff(filename, rawDiff, status) {
-    const lines = rawDiff.split('\n');
-    const patchLines = [];
-    let inHunks = false;
-    let additions = 0;
-    let deletions = 0;
-    for (const line of lines) {
-        if (line.startsWith('@@')) {
-            inHunks = true;
-        }
-        if (inHunks) {
-            patchLines.push(line);
-            if (line.startsWith('+') && !line.startsWith('+++')) {
-                additions++;
-            }
-            else if (line.startsWith('-') && !line.startsWith('---')) {
-                deletions++;
-            }
-        }
-    }
-    return {
-        filename,
-        status,
-        additions,
-        deletions,
-        changes: additions + deletions,
-        patch: patchLines.join('\n'),
-    };
-}
-/**
- * Determine the best ref to diff against for a PR-like diff.
- * Priority:
- * 1. CLAUDE_CODE_BASE_REF env var (set externally, e.g. by CCR managed containers)
- * 2. Merge base with the default branch (best guess)
- * 3. HEAD (fallback if merge-base fails)
- */
-async function getDiffRef(gitRoot) {
-    const baseBranch = process.env.CLAUDE_CODE_BASE_REF || (await getDefaultBranch());
-    const { stdout, code } = await execFileNoThrowWithCwd(gitExe(), ['--no-optional-locks', 'merge-base', 'HEAD', baseBranch], { cwd: gitRoot, timeout: SINGLE_FILE_DIFF_TIMEOUT_MS });
-    if (code === 0 && stdout.trim()) {
-        return stdout.trim();
-    }
-    return 'HEAD';
-}
-async function generateSyntheticDiff(gitPath, absoluteFilePath) {
-    try {
-        if (!isFileWithinReadSizeLimit(absoluteFilePath, MAX_DIFF_SIZE_BYTES)) {
-            return null;
-        }
-        const content = await readFile(absoluteFilePath, 'utf-8');
-        const lines = content.split('\n');
-        // Remove trailing empty line from split if file ends with newline
-        if (lines.length > 0 && lines.at(-1) === '') {
-            lines.pop();
-        }
-        const lineCount = lines.length;
-        const addedLines = lines.map(line => `+${line}`).join('\n');
-        const patch = `@@ -0,0 +1,${lineCount} @@\n${addedLines}`;
-        return {
-            filename: gitPath,
-            status: 'added',
-            additions: lineCount,
-            deletions: 0,
-            changes: lineCount,
-            patch,
-        };
-    }
-    catch {
-        return null;
-    }
-}

package/dist/src/utils/gitSettings.js

@@ -1,18 +0,0 @@
-// Git-related behaviors that depend on user settings.
-//
-// This lives outside git.ts because git.ts is in the vscode extension's
-// dep graph and must stay free of settings.ts, which transitively pulls
-// @opentelemetry/api + undici (forbidden in vscode). It's also a cycle:
-// settings.ts → git/gitignore.ts → git.ts, so git.ts → settings.ts loops.
-//
-// If you're tempted to add `import settings` to git.ts — don't. Put it here.
-import { isEnvDefinedFalsy, isEnvTruthy } from './envUtils.js';
-import { getInitialSettings } from './settings/settings.js';
-export function shouldIncludeGitInstructions() {
-    const envVal = process.env.CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS;
-    if (isEnvTruthy(envVal))
-        return false;
-    if (isEnvDefinedFalsy(envVal))
-        return true;
-    return getInitialSettings().includeGitInstructions ?? true;
-}

package/dist/src/utils/github/ghAuthStatus.js

@@ -1,23 +0,0 @@
-import { execa } from 'execa';
-import { which } from '../which.js';
-/**
- * Returns gh CLI install + auth status for telemetry.
- * Uses which() first (Bun.which — no subprocess) to detect install, then
- * exit code of `gh auth token` to detect auth. Uses `auth token` instead of
- * `auth status` because the latter makes a network request to GitHub's API,
- * while `auth token` only reads local config/keyring. Spawns with
- * stdout: 'ignore' so the token never enters this process.
- */
-export async function getGhAuthStatus() {
-    const ghPath = await which('gh');
-    if (!ghPath) {
-        return 'not_installed';
-    }
-    const { exitCode } = await execa('gh', ['auth', 'token'], {
-        stdout: 'ignore',
-        stderr: 'ignore',
-        timeout: 5000,
-        reject: false,
-    });
-    return exitCode === 0 ? 'authenticated' : 'not_authenticated';
-}

package/dist/src/utils/githubRepoPathMapping.js

@@ -1,135 +0,0 @@
-import { realpath } from 'fs/promises';
-import { getOriginalCwd } from '../bootstrap/state.js';
-import { getGlobalConfig, saveGlobalConfig } from './config.js';
-import { logForDebugging } from './debug.js';
-import { detectCurrentRepository, parseGitHubRepository, } from './detectRepository.js';
-import { pathExists } from './file.js';
-import { getRemoteUrlForDir } from './git/gitFilesystem.js';
-import { findGitRoot } from './git.js';
-/**
- * Updates the GitHub repository path mapping in global config.
- * Called at startup (fire-and-forget) to track known local paths for repos.
- * This is non-blocking and errors are logged silently.
- *
- * Stores the git root (not cwd) so the mapping always points to the
- * repository root regardless of which subdirectory the user launched from.
- * If the path is already tracked, it is promoted to the front of the list
- * so the most recently used clone appears first.
- */
-export async function updateGithubRepoPathMapping() {
-    try {
-        const repo = await detectCurrentRepository();
-        if (!repo) {
-            logForDebugging('Not in a GitHub repository, skipping path mapping update');
-            return;
-        }
-        // Use the git root as the canonical path for this repo clone.
-        // This ensures we always store the repo root, not an arbitrary subdirectory.
-        const cwd = getOriginalCwd();
-        const gitRoot = findGitRoot(cwd);
-        const basePath = gitRoot ?? cwd;
-        // Resolve symlinks for canonical storage
-        let currentPath;
-        try {
-            currentPath = (await realpath(basePath)).normalize('NFC');
-        }
-        catch {
-            currentPath = basePath;
-        }
-        // Normalize repo key to lowercase for case-insensitive matching
-        const repoKey = repo.toLowerCase();
-        const config = getGlobalConfig();
-        const existingPaths = config.githubRepoPaths?.[repoKey] ?? [];
-        if (existingPaths[0] === currentPath) {
-            // Already at the front — nothing to do
-            logForDebugging(`Path ${currentPath} already tracked for repo ${repoKey}`);
-            return;
-        }
-        // Remove if present elsewhere (to promote to front), then prepend
-        const withoutCurrent = existingPaths.filter(p => p !== currentPath);
-        const updatedPaths = [currentPath, ...withoutCurrent];
-        saveGlobalConfig(current => ({
-            ...current,
-            githubRepoPaths: {
-                ...current.githubRepoPaths,
-                [repoKey]: updatedPaths,
-            },
-        }));
-        logForDebugging(`Added ${currentPath} to tracked paths for repo ${repoKey}`);
-    }
-    catch (error) {
-        logForDebugging(`Error updating repo path mapping: ${error}`);
-        // Silently fail - this is non-blocking startup work
-    }
-}
-/**
- * Gets known local paths for a given GitHub repository.
- * @param repo The repository in "owner/repo" format
- * @returns Array of known absolute paths, or empty array if none
- */
-export function getKnownPathsForRepo(repo) {
-    const config = getGlobalConfig();
-    const repoKey = repo.toLowerCase();
-    return config.githubRepoPaths?.[repoKey] ?? [];
-}
-/**
- * Filters paths to only those that exist on the filesystem.
- * @param paths Array of absolute paths to check
- * @returns Array of paths that exist
- */
-export async function filterExistingPaths(paths) {
-    const results = await Promise.all(paths.map(pathExists));
-    return paths.filter((_, i) => results[i]);
-}
-/**
- * Validates that a path contains the expected GitHub repository.
- * @param path Absolute path to check
- * @param expectedRepo Expected repository in "owner/repo" format
- * @returns true if the path contains the expected repo, false otherwise
- */
-export async function validateRepoAtPath(path, expectedRepo) {
-    try {
-        const remoteUrl = await getRemoteUrlForDir(path);
-        if (!remoteUrl) {
-            return false;
-        }
-        const actualRepo = parseGitHubRepository(remoteUrl);
-        if (!actualRepo) {
-            return false;
-        }
-        // Case-insensitive comparison
-        return actualRepo.toLowerCase() === expectedRepo.toLowerCase();
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Removes a path from the tracked paths for a given repository.
- * Used when a path is found to be invalid during selection.
- * @param repo The repository in "owner/repo" format
- * @param pathToRemove The path to remove from tracking
- */
-export function removePathFromRepo(repo, pathToRemove) {
-    const config = getGlobalConfig();
-    const repoKey = repo.toLowerCase();
-    const existingPaths = config.githubRepoPaths?.[repoKey] ?? [];
-    const updatedPaths = existingPaths.filter(path => path !== pathToRemove);
-    if (updatedPaths.length === existingPaths.length) {
-        // Path wasn't in the list, nothing to do
-        return;
-    }
-    const updatedMapping = { ...config.githubRepoPaths };
-    if (updatedPaths.length === 0) {
-        // Remove the repo key entirely if no paths remain
-        delete updatedMapping[repoKey];
-    }
-    else {
-        updatedMapping[repoKey] = updatedPaths;
-    }
-    saveGlobalConfig(current => ({
-        ...current,
-        githubRepoPaths: updatedMapping,
-    }));
-    logForDebugging(`Removed ${pathToRemove} from tracked paths for repo ${repoKey}`);
-}

package/dist/src/utils/glob.js

@@ -1,90 +0,0 @@
-import { basename, dirname, isAbsolute, join, sep } from 'path';
-import { isEnvTruthy } from './envUtils.js';
-import { getFileReadIgnorePatterns, normalizePatternsToPath, } from './permissions/filesystem.js';
-import { getPlatform } from './platform.js';
-import { getGlobExclusionsForPluginCache } from './plugins/orphanedPluginFilter.js';
-import { ripGrep } from './ripgrep.js';
-/**
- * Extracts the static base directory from a glob pattern.
- * The base directory is everything before the first glob special character (* ? [ {).
- * Returns the directory portion and the remaining relative pattern.
- */
-export function extractGlobBaseDirectory(pattern) {
-    // Find the first glob special character: *, ?, [, {
-    const globChars = /[*?[{]/;
-    const match = pattern.match(globChars);
-    if (!match || match.index === undefined) {
-        // No glob characters - this is a literal path
-        // Return the directory portion and filename as pattern
-        const dir = dirname(pattern);
-        const file = basename(pattern);
-        return { baseDir: dir, relativePattern: file };
-    }
-    // Get everything before the first glob character
-    const staticPrefix = pattern.slice(0, match.index);
-    // Find the last path separator in the static prefix
-    const lastSepIndex = Math.max(staticPrefix.lastIndexOf('/'), staticPrefix.lastIndexOf(sep));
-    if (lastSepIndex === -1) {
-        // No path separator before the glob - pattern is relative to cwd
-        return { baseDir: '', relativePattern: pattern };
-    }
-    let baseDir = staticPrefix.slice(0, lastSepIndex);
-    const relativePattern = pattern.slice(lastSepIndex + 1);
-    // Handle root directory patterns (e.g., /*.txt on Unix or C:/*.txt on Windows)
-    // When lastSepIndex is 0, baseDir is empty but we need to use '/' as the root
-    if (baseDir === '' && lastSepIndex === 0) {
-        baseDir = '/';
-    }
-    // Handle Windows drive root paths (e.g., C:/*.txt)
-    // 'C:' means "current directory on drive C" (relative), not root
-    // We need 'C:/' or 'C:\' for the actual drive root
-    if (getPlatform() === 'windows' && /^[A-Za-z]:$/.test(baseDir)) {
-        baseDir = baseDir + sep;
-    }
-    return { baseDir, relativePattern };
-}
-export async function glob(filePattern, cwd, { limit, offset }, abortSignal, toolPermissionContext) {
-    let searchDir = cwd;
-    let searchPattern = filePattern;
-    // Handle absolute paths by extracting the base directory and converting to relative pattern
-    // ripgrep's --glob flag only works with relative patterns
-    if (isAbsolute(filePattern)) {
-        const { baseDir, relativePattern } = extractGlobBaseDirectory(filePattern);
-        if (baseDir) {
-            searchDir = baseDir;
-            searchPattern = relativePattern;
-        }
-    }
-    const ignorePatterns = normalizePatternsToPath(getFileReadIgnorePatterns(toolPermissionContext), searchDir);
-    // Use ripgrep for better memory performance
-    // --files: list files instead of searching content
-    // --glob: filter by pattern
-    // --sort=modified: sort by modification time (oldest first)
-    // --no-ignore: don't respect .gitignore (default true, set CLAUDE_CODE_GLOB_NO_IGNORE=false to respect .gitignore)
-    // --hidden: include hidden files (default true, set CLAUDE_CODE_GLOB_HIDDEN=false to exclude)
-    // Note: use || instead of ?? to treat empty string as unset (defaulting to true)
-    const noIgnore = isEnvTruthy(process.env.CLAUDE_CODE_GLOB_NO_IGNORE || 'true');
-    const hidden = isEnvTruthy(process.env.CLAUDE_CODE_GLOB_HIDDEN || 'true');
-    const args = [
-        '--files',
-        '--glob',
-        searchPattern,
-        '--sort=modified',
-        ...(noIgnore ? ['--no-ignore'] : []),
-        ...(hidden ? ['--hidden'] : []),
-    ];
-    // Add ignore patterns
-    for (const pattern of ignorePatterns) {
-        args.push('--glob', `!${pattern}`);
-    }
-    // Exclude orphaned plugin version directories
-    for (const exclusion of await getGlobExclusionsForPluginCache(searchDir)) {
-        args.push('--glob', exclusion);
-    }
-    const allPaths = await ripGrep(args, searchDir, abortSignal);
-    // ripgrep returns relative paths, convert to absolute
-    const absolutePaths = allPaths.map(p => isAbsolute(p) ? p : join(searchDir, p));
-    const truncated = absolutePaths.length > offset + limit;
-    const files = absolutePaths.slice(offset, offset + limit);
-    return { files, truncated };
-}