@compass-ai/nova 1.0.72 → 1.0.74

package/dist/utils/ignore-patterns.js

@@ -0,0 +1,710 @@
+/**
+ * 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