@compass-ai/nova 1.0.74 → 1.0.76

package/dist/utils/ignore-patterns.js

@@ -1,710 +0,0 @@
-/**
- * Shared ignore patterns utility for file discovery and tree generation.
- *
- * This module provides a single source of truth for ignore patterns used by:
- * - Codebase indexer (file discovery)
- * - Context builder (directory tree generation)
- * - File listing commands
- *
- * It also provides utilities for loading .gitignore files and converting
- * between glob patterns and simple name matching.
- */
-import ignore from 'ignore';
-import path from 'path';
-import { glob } from 'glob';
-import fs from 'fs/promises';
-import { safeReadFile, pathExists, stat } from './file-system.js';
-import { getProjectCompassDir } from './path.js';
-import { logger } from './logger.js';
-/**
- * Default glob patterns to ignore during file discovery and indexing.
- * These patterns are compatible with the glob library.
- */
-export const DEFAULT_IGNORE_PATTERNS = [
-    // Dependencies
-    'node_modules/**',
-    'bower_components/**',
-    'jspm_packages/**',
-    // VCS
-    '.git/**',
-    // Build outputs
-    'dist/**',
-    'build/**',
-    'out/**',
-    '.output/**',
-    // Framework-specific build outputs
-    '.next/**',
-    '.nuxt/**',
-    '.svelte-kit/**',
-    '.remix/**',
-    '.astro/**',
-    '.docusaurus/**',
-    '.angular/**',
-    // Coverage and test artifacts
-    'coverage/**',
-    '.nyc_output/**',
-    '.pytest_cache/**',
-    '.vitest/**',
-    'jest-cache/**',
-    '.tox/**',
-    // Cache and temp directories
-    '.cache/**',
-    '.turbo/**',
-    '.parcel-cache/**',
-    // Environment and secrets
-    '.env*',
-    // Log files
-    '*.log',
-    // Lock files
-    '*.lock',
-    'package-lock.json',
-    'yarn.lock',
-    'pnpm-lock.yaml',
-    'Gemfile.lock',
-    'composer.lock',
-    'go.sum',
-    'Cargo.lock',
-    'pubspec.lock',
-    'Podfile.lock',
-    'Packages.resolved',
-    // Minified and source maps
-    '*.min.js',
-    '*.min.css',
-    '*.map',
-    // Python
-    '__pycache__/**',
-    '*.pyc',
-    'venv/**',
-    '.venv/**',
-    '*.egg-info/**',
-    '*.egg',
-    'dist-info/**',
-    // Ruby
-    '.bundle/**',
-    // Rust
-    'target/**',
-    // Java/JVM
-    '*.class',
-    '.gradle/**',
-    '.mvn/**',
-    // .NET
-    'bin/**',
-    'obj/**',
-    '.nuget/**',
-    'packages/**',
-    // PHP
-    'vendor/**',
-    // Elixir/Phoenix
-    '_build/**',
-    'deps/**',
-    // iOS/macOS
-    'Pods/**',
-    'DerivedData/**',
-    'Carthage/**',
-    '*.xcworkspace/**',
-    // Android
-    '*.apk',
-    '*.aab',
-    // Terraform/IaC
-    '*.tfstate',
-    '*.tfstate.backup',
-    // IDE and editor
-    '.idea/**',
-    '.vscode/**',
-    '.vs/**',
-    // CLI data directories
-    '.compass/**',
-    '.claude/**',
-    // OS files
-    '.DS_Store',
-    'Thumbs.db',
-    '*.swp',
-    '*.swo',
-];
-/**
- * Extracts directory names from glob patterns.
- * Converts patterns like 'node_modules/**' or 'dist/' to just the directory name.
- *
- * @param patterns - Array of glob patterns
- * @returns Set of directory names
- */
-export function extractDirectoryNames(patterns) {
-    const names = new Set();
-    for (const pattern of patterns) {
-        // Match patterns like 'dirname/**', 'dirname/', or just 'dirname' (without wildcards)
-        const match = pattern.match(/^\.?([^/*?]+)(?:\/\*\*|\/)?$/);
-        if (match) {
-            names.add(match[1]);
-        }
-    }
-    return names;
-}
-/**
- * Pre-computed set of directory names that should be excluded during tree traversal.
- * Derived from DEFAULT_IGNORE_PATTERNS for efficient name-based filtering.
- */
-export const EXCLUDED_DIRECTORY_NAMES = extractDirectoryNames(DEFAULT_IGNORE_PATTERNS);
-/**
- * Checks if a directory name should be excluded based on default patterns.
- * For use in tree traversal where full paths aren't available.
- *
- * @param name - Directory name to check (not full path)
- * @returns True if the directory should be excluded
- */
-export function shouldExcludeDirectory(name) {
-    // Hidden directories (starting with .)
-    if (name.startsWith('.')) {
-        return true;
-    }
-    return EXCLUDED_DIRECTORY_NAMES.has(name);
-}
-/**
- * Checks if a file should be excluded based on its extension/name.
- *
- * @param name - File name to check (not full path)
- * @returns True if the file should be excluded
- */
-export function shouldExcludeFile(name) {
-    // Hidden files
-    if (name.startsWith('.')) {
-        return true;
-    }
-    // Log files
-    if (name.endsWith('.log')) {
-        return true;
-    }
-    // Lock files
-    if (name.endsWith('.lock') || name === 'package-lock.json' || name === 'yarn.lock' || name === 'pnpm-lock.yaml') {
-        return true;
-    }
-    // Minified files
-    if (name.endsWith('.min.js') || name.endsWith('.min.css')) {
-        return true;
-    }
-    // Source maps
-    if (name.endsWith('.map')) {
-        return true;
-    }
-    // Python compiled
-    if (name.endsWith('.pyc')) {
-        return true;
-    }
-    // Java compiled
-    if (name.endsWith('.class')) {
-        return true;
-    }
-    // Android binaries
-    if (name.endsWith('.apk') || name.endsWith('.aab')) {
-        return true;
-    }
-    // Terraform state (may contain secrets)
-    if (name.endsWith('.tfstate') || name.endsWith('.tfstate.backup')) {
-        return true;
-    }
-    // Swap files
-    if (name.endsWith('.swp') || name.endsWith('.swo')) {
-        return true;
-    }
-    // OS files
-    if (name === '.DS_Store' || name === 'Thumbs.db') {
-        return true;
-    }
-    // Image files (not useful for code analysis)
-    const ext = name.lastIndexOf('.') !== -1 ? name.slice(name.lastIndexOf('.')).toLowerCase() : '';
-    if ([
-        '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.svg',
-        '.webp', '.tiff', '.tif', '.avif', '.heic', '.heif',
-        '.txt', '.pdf',
-    ].includes(ext)) {
-        return true;
-    }
-    return false;
-}
-// Cache for createIgnoreInstance — avoids re-reading all .gitignore files on every tool call
-const CACHE_TTL_MS = 30 * 60_000; // 30 minutes — .gitignore files rarely change mid-session
-let ignoreInstanceCache = null;
-const DISK_CACHE_MAX_AGE_MS = 24 * 60 * 60_000; // 24 hours
-function getDiskCachePath(projectRoot) {
-    return path.join(getProjectCompassDir(projectRoot), 'cache', 'gitignore-cache.json');
-}
-async function loadDiskCache(projectRoot) {
-    try {
-        const cachePath = getDiskCachePath(projectRoot);
-        if (!await pathExists(cachePath))
-            return null;
-        const raw = await fs.readFile(cachePath, 'utf-8');
-        const cache = JSON.parse(raw);
-        // Validate structure and freshness
-        if (cache.version !== 1 ||
-            cache.projectRoot !== projectRoot ||
-            Date.now() - cache.timestamp > DISK_CACHE_MAX_AGE_MS) {
-            return null;
-        }
-        // Validate each known .gitignore file's mtime
-        for (const [relPath, cachedMtime] of Object.entries(cache.mtimes)) {
-            const fullPath = path.join(projectRoot, relPath);
-            const fileStat = await stat(fullPath);
-            if (!fileStat || Math.abs(fileStat.mtimeMs - cachedMtime) > 1000) {
-                logger.debug(`Disk cache invalidated: ${relPath} mtime changed`);
-                return null;
-            }
-        }
-        logger.debug(`Disk cache valid: ${cache.gitignoreFiles.length} .gitignore files`);
-        return cache.gitignoreFiles;
-    }
-    catch {
-        return null;
-    }
-}
-async function saveDiskCache(projectRoot, gitignoreFiles) {
-    try {
-        const cachePath = getDiskCachePath(projectRoot);
-        const cacheDir = path.dirname(cachePath);
-        await fs.mkdir(cacheDir, { recursive: true });
-        const mtimes = {};
-        for (const relPath of gitignoreFiles) {
-            const fullPath = path.join(projectRoot, relPath);
-            const fileStat = await stat(fullPath);
-            if (fileStat) {
-                mtimes[relPath] = fileStat.mtimeMs;
-            }
-        }
-        const cache = {
-            version: 1,
-            projectRoot,
-            gitignoreFiles,
-            mtimes,
-            timestamp: Date.now(),
-        };
-        await fs.writeFile(cachePath, JSON.stringify(cache), 'utf-8');
-        logger.debug(`Saved gitignore disk cache: ${gitignoreFiles.length} files`);
-    }
-    catch (err) {
-        logger.debug('Failed to save gitignore disk cache', err);
-    }
-}
-// In-memory cache for getCachedGitignoreFiles (shared between createIgnoreInstance and loadIgnorePatterns)
-let gitignoreFilesCache = null;
-/**
- * Returns the list of .gitignore files, using disk cache first, then in-memory cache,
- * falling back to the expensive glob scan.
- */
-async function getCachedGitignoreFiles(projectRoot) {
-    // Check in-memory cache
-    if (gitignoreFilesCache &&
-        gitignoreFilesCache.root === projectRoot &&
-        Date.now() - gitignoreFilesCache.timestamp < CACHE_TTL_MS) {
-        return gitignoreFilesCache.files;
-    }
-    // Check disk cache
-    const diskCached = await loadDiskCache(projectRoot);
-    if (diskCached) {
-        gitignoreFilesCache = { root: projectRoot, files: diskCached, timestamp: Date.now() };
-        return diskCached;
-    }
-    // Full scan (expensive)
-    const files = await findAllGitignoreFiles(projectRoot);
-    gitignoreFilesCache = { root: projectRoot, files, timestamp: Date.now() };
-    // Fire-and-forget save to disk
-    saveDiskCache(projectRoot, files).catch(() => { });
-    return files;
-}
-/**
- * Creates an ignore instance from .gitignore files (including nested ones).
- * Falls back to default patterns if no .gitignore files exist.
- * Results are cached for 1 minute to avoid redundant filesystem reads on every tool call.
- *
- * @param projectRoot - Project root directory
- * @param useDefaults - Whether to use DEFAULT_IGNORE_PATTERNS as fallback (default: true)
- * @returns Configured ignore instance
- */
-export async function createIgnoreInstance(projectRoot, useDefaults = true) {
-    if (ignoreInstanceCache &&
-        ignoreInstanceCache.root === projectRoot &&
-        ignoreInstanceCache.useDefaults === useDefaults &&
-        Date.now() - ignoreInstanceCache.timestamp < CACHE_TTL_MS) {
-        logger.debug('Using cached ignore instance');
-        return ignoreInstanceCache.instance;
-    }
-    const ig = ignore();
-    let hasPatterns = false;
-    // Try to load root .gitignore
-    const rootGitignorePath = path.join(projectRoot, '.gitignore');
-    const rootContent = await safeReadFile(rootGitignorePath);
-    if (rootContent) {
-        logger.debug(`Loaded .gitignore from ${rootGitignorePath}`);
-        ig.add(rootContent);
-        hasPatterns = true;
-    }
-    // Load nested .gitignore files (uses disk cache when available)
-    const nestedGitignoreFiles = await getCachedGitignoreFiles(projectRoot);
-    for (const gitignorePath of nestedGitignoreFiles) {
-        // Skip the root .gitignore (already processed)
-        if (gitignorePath === '.gitignore') {
-            continue;
-        }
-        const fullPath = path.join(projectRoot, gitignorePath);
-        const content = await safeReadFile(fullPath);
-        if (content) {
-            // Get the directory containing this .gitignore
-            const dirPath = path.dirname(gitignorePath);
-            const patterns = parseGitignoreContent(content);
-            const scopedPatterns = scopePatternsToDirectory(patterns, dirPath);
-            logger.debug(`Loaded ${scopedPatterns.length} patterns from nested .gitignore at ${gitignorePath}`);
-            ig.add(scopedPatterns);
-            hasPatterns = true;
-        }
-    }
-    if (hasPatterns) {
-        // Always ignore .git directory
-        ig.add('.git');
-    }
-    else if (useDefaults) {
-        logger.debug('No .gitignore found, using default ignore patterns');
-        ig.add(DEFAULT_IGNORE_PATTERNS);
-    }
-    ignoreInstanceCache = { root: projectRoot, useDefaults, instance: ig, timestamp: Date.now() };
-    return ig;
-}
-/**
- * Parses gitignore content into patterns array.
- *
- * @param content - Raw gitignore file content
- * @returns Array of parsed patterns
- */
-function parseGitignoreContent(content) {
-    return content
-        .split('\n')
-        .map((line) => line.trim())
-        .filter((line) => line && !line.startsWith('#'));
-}
-/**
- * Transforms gitignore patterns to be glob-compatible.
- * - Patterns ending with '/' need '**' to match directory contents
- * - Simple directory/file names without wildcards need variants to match at any depth
- *
- * @param patterns - Array of raw gitignore patterns
- * @returns Array of glob-compatible patterns
- */
-function transformPatternsForGlob(patterns) {
-    return patterns.flatMap((pattern) => {
-        // Handle negation patterns
-        const isNegation = pattern.startsWith('!');
-        const actualPattern = isNegation ? pattern.slice(1) : pattern;
-        // Patterns ending with / are directory patterns - need /** to match contents
-        if (actualPattern.endsWith('/')) {
-            const dirName = actualPattern.slice(0, -1);
-            // Match at root level and at any depth
-            const rootPattern = `${dirName}/**`;
-            const deepPattern = `**/${dirName}/**`;
-            if (isNegation) {
-                return [`!${rootPattern}`, `!${deepPattern}`];
-            }
-            return [rootPattern, deepPattern];
-        }
-        // If pattern already has glob wildcards, return as-is
-        if (actualPattern.includes('*') || actualPattern.includes('?')) {
-            return isNegation ? [`!${actualPattern}`] : [actualPattern];
-        }
-        // Handle patterns with leading '/' (anchored to root in gitignore)
-        // Strip the leading '/' since glob treats it as an absolute filesystem path
-        if (actualPattern.startsWith('/')) {
-            const stripped = actualPattern.slice(1);
-            // Could be a file or directory, generate both variants
-            const asFile = stripped;
-            const asDir = `${stripped}/**`;
-            if (isNegation) {
-                return [`!${asFile}`, `!${asDir}`];
-            }
-            return [asFile, asDir];
-        }
-        // If pattern has path separators (but no leading /), it's a relative path
-        if (actualPattern.includes('/')) {
-            return isNegation ? [`!${actualPattern}`] : [actualPattern];
-        }
-        // Simple name without wildcards (like 'node_modules', 'dist', '.env')
-        // Should match at any depth AND as a directory
-        const asFile = actualPattern;
-        const asDir = `${actualPattern}/**`;
-        const deepFile = `**/${actualPattern}`;
-        const deepDir = `**/${actualPattern}/**`;
-        if (isNegation) {
-            return [`!${asFile}`, `!${asDir}`, `!${deepFile}`, `!${deepDir}`];
-        }
-        return [asFile, asDir, deepFile, deepDir];
-    });
-}
-/**
- * Scopes gitignore patterns to a subdirectory.
- * Patterns from subdirectory .gitignore files need to be prefixed with the
- * relative path to work correctly with glob from the project root.
- *
- * Gitignore semantics:
- * - Patterns without leading '/' match at any depth (e.g., 'node_modules' matches 'foo/bar/node_modules')
- * - Patterns with leading '/' are anchored to the gitignore directory
- * - Patterns ending with '/' only match directories
- *
- * @param patterns - Array of patterns from a .gitignore file
- * @param relativeDirPath - Relative path of the directory containing the .gitignore
- * @returns Array of scoped patterns
- */
-function scopePatternsToDirectory(patterns, relativeDirPath) {
-    if (!relativeDirPath || relativeDirPath === '.') {
-        return patterns;
-    }
-    // Normalize path separators
-    const normalizedDir = relativeDirPath.replace(/\\/g, '/');
-    return patterns.flatMap((pattern) => {
-        // Handle negation patterns (patterns starting with !)
-        const isNegation = pattern.startsWith('!');
-        const actualPattern = isNegation ? pattern.slice(1) : pattern;
-        // If the pattern starts with /, it's anchored to the .gitignore directory
-        if (actualPattern.startsWith('/')) {
-            // Remove the leading / and scope to the directory
-            const scopedPattern = `${normalizedDir}${actualPattern}`;
-            return isNegation ? [`!${scopedPattern}`] : [scopedPattern];
-        }
-        // For patterns without leading /, they can match at any depth within the directory
-        // In gitignore, 'node_modules' matches 'node_modules', 'foo/node_modules', etc.
-        // We need to generate patterns that match both at the directory root AND at any depth
-        // Check if pattern already contains path separators or glob wildcards
-        const hasPathSeparator = actualPattern.includes('/');
-        const hasDoublestar = actualPattern.includes('**');
-        if (hasDoublestar) {
-            // Pattern already has **, just prefix with directory
-            const scopedPattern = `${normalizedDir}/${actualPattern}`;
-            return isNegation ? [`!${scopedPattern}`] : [scopedPattern];
-        }
-        if (hasPathSeparator) {
-            // Pattern has path separator but no **, treat as relative path from gitignore location
-            // e.g., 'build/output' in backend/.gitignore -> 'backend/build/output'
-            const scopedPattern = `${normalizedDir}/${actualPattern}`;
-            return isNegation ? [`!${scopedPattern}`] : [scopedPattern];
-        }
-        // Simple pattern without path separators (e.g., 'node_modules', '*.log', 'dist/')
-        // Should match at the directory root AND at any depth within it
-        // Generate two patterns: one for root level, one for any depth
-        // Handle directory patterns (ending with /)
-        // 'node_modules/' should match the directory and all its contents
-        if (actualPattern.endsWith('/')) {
-            const dirName = actualPattern.slice(0, -1);
-            const rootPattern = `${normalizedDir}/${dirName}/**`;
-            const deepPattern = `${normalizedDir}/**/${dirName}/**`;
-            if (isNegation) {
-                return [`!${rootPattern}`, `!${deepPattern}`];
-            }
-            return [rootPattern, deepPattern];
-        }
-        // Check if pattern contains wildcards (like *.log)
-        const hasWildcard = actualPattern.includes('*') || actualPattern.includes('?');
-        if (hasWildcard) {
-            // For wildcard patterns, just scope them
-            const rootPattern = `${normalizedDir}/${actualPattern}`;
-            const deepPattern = `${normalizedDir}/**/${actualPattern}`;
-            if (isNegation) {
-                return [`!${rootPattern}`, `!${deepPattern}`];
-            }
-            return [rootPattern, deepPattern];
-        }
-        // For simple names without wildcards (like 'node_modules', 'dist', '.env')
-        // These could be files or directories, so generate patterns for both
-        // Also add /** versions to match directory contents
-        const rootPattern = `${normalizedDir}/${actualPattern}`;
-        const rootDirPattern = `${normalizedDir}/${actualPattern}/**`;
-        const deepPattern = `${normalizedDir}/**/${actualPattern}`;
-        const deepDirPattern = `${normalizedDir}/**/${actualPattern}/**`;
-        if (isNegation) {
-            return [`!${rootPattern}`, `!${rootDirPattern}`, `!${deepPattern}`, `!${deepDirPattern}`];
-        }
-        return [rootPattern, rootDirPattern, deepPattern, deepDirPattern];
-    });
-}
-/**
- * Finds all .gitignore files in a project, including nested ones in subdirectories.
- *
- * @param projectRoot - Project root directory
- * @returns Array of relative paths to .gitignore files
- */
-async function findAllGitignoreFiles(projectRoot) {
-    try {
-        // Find all .gitignore files, but skip common directories that are typically ignored
-        const gitignoreFiles = await glob('**/.gitignore', {
-            cwd: projectRoot,
-            dot: true,
-            ignore: [
-                'node_modules/**',
-                '.git/**',
-                'dist/**',
-                'build/**',
-                'vendor/**',
-                '.next/**',
-                '.nuxt/**',
-                'coverage/**',
-                '__pycache__/**',
-                'venv/**',
-                '.venv/**',
-                'target/**',
-            ],
-            absolute: false,
-        });
-        return gitignoreFiles;
-    }
-    catch (error) {
-        logger.debug('Failed to find nested .gitignore files', error);
-        return [];
-    }
-}
-/**
- * Loads ignore patterns from .gitignore file and all nested .gitignore files
- * in subdirectories, falling back to defaults if no .gitignore exists.
- * Returns patterns as an array suitable for use with the glob library.
- *
- * @param projectRoot - Project root directory
- * @returns Array of ignore patterns
- */
-// Cache for loadIgnorePatterns — avoids re-reading all .gitignore files on every tool call
-let ignorePatternsCache = null;
-export async function loadIgnorePatterns(projectRoot) {
-    if (ignorePatternsCache &&
-        ignorePatternsCache.root === projectRoot &&
-        Date.now() - ignorePatternsCache.timestamp < CACHE_TTL_MS) {
-        logger.debug('Using cached ignore patterns');
-        return ignorePatternsCache.patterns;
-    }
-    const allPatterns = [];
-    // First, try to load the root .gitignore
-    const rootGitignorePath = path.join(projectRoot, '.gitignore');
-    const rootContent = await safeReadFile(rootGitignorePath);
-    if (rootContent) {
-        const rawPatterns = parseGitignoreContent(rootContent);
-        const rootPatterns = transformPatternsForGlob(rawPatterns);
-        logger.debug(`Loaded ${rawPatterns.length} raw patterns from root .gitignore, transformed to ${rootPatterns.length} glob patterns`);
-        logger.debug(`Root .gitignore patterns (sample): ${rootPatterns.slice(0, 10).join(', ')}${rootPatterns.length > 10 ? '...' : ''}`);
-        allPatterns.push(...rootPatterns);
-    }
-    // Find and load all nested .gitignore files (uses disk cache when available)
-    const nestedGitignoreFiles = await getCachedGitignoreFiles(projectRoot);
-    if (nestedGitignoreFiles.length > 0) {
-        logger.info(`Found ${nestedGitignoreFiles.length} .gitignore file(s) in project`);
-    }
-    logger.debug(`Gitignore files found: ${nestedGitignoreFiles.join(', ')}`);
-    for (const gitignorePath of nestedGitignoreFiles) {
-        // Normalize path separators for comparison
-        const normalizedPath = gitignorePath.replace(/\\/g, '/');
-        // Skip the root .gitignore (already processed)
-        if (normalizedPath === '.gitignore') {
-            continue;
-        }
-        const fullPath = path.join(projectRoot, gitignorePath);
-        const content = await safeReadFile(fullPath);
-        if (content) {
-            // Get the directory containing this .gitignore (use normalized path)
-            const dirPath = path.dirname(normalizedPath);
-            const patterns = parseGitignoreContent(content);
-            const scopedPatterns = scopePatternsToDirectory(patterns, dirPath);
-            logger.debug(`Loaded ${scopedPatterns.length} patterns from nested .gitignore at ${gitignorePath}: ${scopedPatterns.slice(0, 5).join(', ')}${scopedPatterns.length > 5 ? '...' : ''}`);
-            allPatterns.push(...scopedPatterns);
-        }
-    }
-    // If we found any patterns, return them
-    if (allPatterns.length > 0) {
-        // Always include .git
-        if (!allPatterns.includes('.git') && !allPatterns.includes('.git/**')) {
-            allPatterns.push('.git/**');
-        }
-        logger.info(`Loaded ${allPatterns.length} ignore patterns from .gitignore files`);
-        ignorePatternsCache = { root: projectRoot, patterns: allPatterns, timestamp: Date.now() };
-        return allPatterns;
-    }
-    logger.debug('No .gitignore found, using default ignore patterns');
-    return [...DEFAULT_IGNORE_PATTERNS];
-}
-/**
- * Merges custom patterns with defaults, removing duplicates.
- *
- * @param customPatterns - Custom patterns to merge
- * @param defaults - Default patterns (defaults to DEFAULT_IGNORE_PATTERNS)
- * @returns Merged array of unique patterns
- */
-export function mergeIgnorePatterns(customPatterns, defaults = DEFAULT_IGNORE_PATTERNS) {
-    return [...new Set([...defaults, ...customPatterns])];
-}
-/**
- * Normalizes folder patterns to proper glob format.
- * - Simple folder names like "folder" become "**\/folder/**" to match at any depth
- * - Relative paths like "some/path" become "some/path/**"
- * - Patterns with glob syntax are returned as-is
- *
- * @param folderPatterns - Array of folder patterns (can be simple names or globs)
- * @returns Array of normalized glob patterns
- */
-export function normalizeFolderPatterns(folderPatterns) {
-    return folderPatterns.map((pattern) => {
-        // Already has glob syntax
-        if (pattern.includes('*') || pattern.includes('?')) {
-            return pattern;
-        }
-        // Remove trailing slash if present
-        const normalized = pattern.replace(/[/\\]+$/, '');
-        // If it's a simple folder name (no path separators), match at any depth
-        if (!normalized.includes('/') && !normalized.includes('\\')) {
-            return `**/${normalized}/**`;
-        }
-        // It's a relative path, add /** to match all contents
-        return `${normalized}/**`;
-    });
-}
-/**
- * Checks if a relative path should be excluded based on session folder patterns.
- * Used by directory tree traversal to exclude paths like "api/stacks" correctly.
- *
- * @param relativePath - The relative path to check (e.g., "api/stacks")
- * @param sessionExcludedFolders - Raw session excluded folder patterns
- * @returns True if the path should be excluded
- */
-export function shouldExcludeSessionPath(relativePath, sessionExcludedFolders) {
-    // Normalize path separators
-    const normalizedPath = relativePath.replace(/\\/g, '/');
-    for (const pattern of sessionExcludedFolders) {
-        // Normalize pattern separators and remove trailing slashes
-        let normalizedPattern = pattern.replace(/\\/g, '/').replace(/\/+$/, '');
-        // Handle glob patterns like "folder/**" - extract the base path
-        if (normalizedPattern.endsWith('/**')) {
-            normalizedPattern = normalizedPattern.slice(0, -3);
-        }
-        else if (normalizedPattern.includes('*') || normalizedPattern.includes('?')) {
-            // Skip complex glob patterns (can't easily match without glob library)
-            continue;
-        }
-        // Check if it's a simple folder name (no path separator)
-        if (!normalizedPattern.includes('/')) {
-            // Simple folder name should match at any depth
-            // Check if any segment of the path matches the folder name
-            const segments = normalizedPath.split('/');
-            if (segments.includes(normalizedPattern)) {
-                return true;
-            }
-        }
-        else {
-            // It's a path pattern like "api/stacks"
-            // Check if the relative path matches or starts with the pattern
-            if (normalizedPath === normalizedPattern || normalizedPath.startsWith(normalizedPattern + '/')) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-/**
- * Merges session excluded folders with base ignore patterns.
- * Normalizes folder patterns to proper glob format.
- *
- * @param sessionExcludedFolders - Folders from session state
- * @param basePatterns - Base patterns to merge with
- * @returns Merged array of unique patterns
- */
-export function mergeSessionExclusions(sessionExcludedFolders, basePatterns = DEFAULT_IGNORE_PATTERNS) {
-    const normalizedFolders = normalizeFolderPatterns(sessionExcludedFolders);
-    return [...new Set([...basePatterns, ...normalizedFolders])];
-}
-//# sourceMappingURL=ignore-patterns.js.map