vg-coder-cli 1.0.17 → 2.0.0

package/vg/packages/core/src/lib/ignore/ignore-manager.ts

@@ -0,0 +1,315 @@
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import ignore from 'ignore';
+
+/**
+ * Manage ignore patterns following Git standards
+ */
+export class IgnoreManager {
+    private ignoreInstances = new Map<string, any>(); // Cache ignore instances by directory
+    private defaultIgnores: string[];
+
+    constructor(private projectPath: string) {
+        this.defaultIgnores = this.getDefaultIgnores();
+    }
+
+    /**
+     * Get list of default ignore patterns
+     */
+    getDefaultIgnores(): string[] {
+        return [
+            // Node.js
+            'node_modules/',
+            'package-lock.json',
+            'yarn.lock',
+            'npm-debug.log*',
+            'yarn-debug.log*',
+            'yarn-error.log*',
+            '.npm',
+            '.yarn/',
+
+            // Build outputs
+            'dist/',
+            'build/',
+            'out/',
+            'target/',
+            'bin/',
+            'obj/',
+
+            // IDE and Editor
+            '.vscode/',
+            '.idea/',
+            '*.swp',
+            '*.swo',
+            '*~',
+            '.DS_Store',
+            'Thumbs.db',
+
+            // Logs
+            'logs/',
+            '*.log',
+
+            // Environment files
+            '.env',
+            '.env.local',
+            '.env.development.local',
+            '.env.test.local',
+            '.env.production.local',
+
+            // Cache directories
+            '.cache/',
+            '.parcel-cache/',
+            '.next/',
+            '.nuxt/',
+
+            // Coverage reports
+            'coverage/',
+            '*.lcov',
+
+            // Dependency directories
+            'bower_components/',
+            'jspm_packages/',
+
+            // Java
+            '*.class',
+            '*.jar',
+            '*.war',
+            '*.ear',
+            '.gradle/',
+
+            // Python
+            '__pycache__/',
+            '*.py[cod]',
+            '*$py.class',
+            '*.so',
+            '.Python',
+            'env/',
+            'venv/',
+            '.venv/',
+            'pip-log.txt',
+            'pip-delete-this-directory.txt',
+
+            // .NET
+            '[Bb]in/',
+            '[Oo]bj/',
+            '*.user',
+            '*.suo',
+            '*.userosscache',
+            '*.sln.docstates',
+
+            // Temporary files
+            '*.tmp',
+            '*.temp',
+            '*.bak',
+            '*.backup',
+
+            // OS generated files
+            '.DS_Store?',
+            'ehthumbs.db',
+            'Icon?',
+
+            // VG Coder output
+            'vg-output/'
+        ];
+    }
+
+    /**
+     * Get ignore instance for a specific directory
+     */
+    async getIgnoreInstance(dirPath: string): Promise<any> {
+        const relativePath = path.relative(this.projectPath, dirPath);
+        const cacheKey = relativePath || '.';
+
+        if (this.ignoreInstances.has(cacheKey)) {
+            return this.ignoreInstances.get(cacheKey);
+        }
+
+        const ig = ignore();
+
+        // Add default ignores
+        ig.add(this.defaultIgnores);
+
+        // Read .gitignore and .vgignore from root to current directory
+        const pathParts = relativePath ? relativePath.split(path.sep) : [];
+        let currentPath = this.projectPath;
+
+        // Read .gitignore and .vgignore from root
+        await this.addIgnoreFromPath(ig, currentPath);
+
+        // Read .gitignore and .vgignore from subdirectories in order
+        for (const part of pathParts) {
+            currentPath = path.join(currentPath, part);
+            await this.addIgnoreFromPath(ig, currentPath);
+        }
+
+        this.ignoreInstances.set(cacheKey, ig);
+        return ig;
+    }
+
+    /**
+     * Add patterns from .gitignore and .vgignore files
+     */
+    async addIgnoreFromPath(ig: any, dirPath: string): Promise<void> {
+        // Read .gitignore
+        const gitignorePath = path.join(dirPath, '.gitignore');
+        try {
+            if (await fs.pathExists(gitignorePath)) {
+                const content = await fs.readFile(gitignorePath, 'utf8');
+                const patterns = this.parseIgnoreContent(content, dirPath);
+                ig.add(patterns);
+            }
+        } catch (error) {
+            // Ignore errors reading .gitignore files
+        }
+
+        // Read .vgignore (has higher priority than .gitignore)
+        const vgignorePath = path.join(dirPath, '.vgignore');
+        try {
+            if (await fs.pathExists(vgignorePath)) {
+                const content = await fs.readFile(vgignorePath, 'utf8');
+                const patterns = this.parseIgnoreContent(content, dirPath);
+                ig.add(patterns);
+            }
+        } catch (error) {
+            // Ignore errors reading .vgignore files
+        }
+    }
+
+    /**
+     * Parse content of .gitignore and .vgignore
+     */
+    parseIgnoreContent(content: string, basePath: string): string[] {
+        const lines = content.split('\n');
+        const patterns: string[] = [];
+
+        for (let line of lines) {
+            line = line.trim();
+
+            // Skip empty lines and comments
+            if (!line || line.startsWith('#')) {
+                continue;
+            }
+
+            // Handle relative path from basePath
+            const relativePath = path.relative(this.projectPath, basePath);
+            if (relativePath && !line.startsWith('/')) {
+                // If pattern doesn't start with /, add relative path
+                line = path.posix.join(relativePath, line);
+            } else if (line.startsWith('/')) {
+                // Remove leading slash for absolute patterns
+                line = line.substring(1);
+            }
+
+            patterns.push(line);
+        }
+
+        return patterns;
+    }
+
+    /**
+     * Check if a file/directory should be ignored
+     */
+    async shouldIgnore(filePath: string): Promise<boolean> {
+        try {
+            const absolutePath = path.resolve(this.projectPath, filePath);
+            const relativePath = path.relative(this.projectPath, absolutePath);
+
+            // Do not ignore if file is outside project
+            if (relativePath.startsWith('..')) {
+                return false;
+            }
+
+            const dirPath = path.dirname(absolutePath);
+            const ig = await this.getIgnoreInstance(dirPath);
+
+            return ig.ignores(relativePath);
+        } catch (error) {
+            return false;
+        }
+    }
+
+    /**
+     * Filter list of files/directories
+     */
+    async filterIgnored(items: string[]): Promise<string[]> {
+        const results: string[] = [];
+
+        for (const item of items) {
+            const shouldIgnore = await this.shouldIgnore(item);
+            if (!shouldIgnore) {
+                results.push(item);
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * Get all patterns currently applied to a directory
+     */
+    async getAppliedPatterns(dirPath: string = this.projectPath): Promise<{ default: string[], gitignore: string[] }> {
+        const ig = await this.getIgnoreInstance(dirPath);
+        // Access internal _rules if available, otherwise this might need adjustment depending on ignore package version
+        // For now assuming _rules exists or we might need another way to get rules
+        const rules = (ig as any)._rules || [];
+
+        return {
+            default: this.defaultIgnores,
+            gitignore: rules.filter((rule: any) => !this.defaultIgnores.includes(rule.origin))
+        };
+    }
+
+    /**
+     * Check if there are any .gitignore files
+     */
+    async hasGitignoreFiles(): Promise<string[]> {
+        const gitignoreFiles: string[] = [];
+
+        const checkGitignore = async (dirPath: string) => {
+            const gitignorePath = path.join(dirPath, '.gitignore');
+            if (await fs.pathExists(gitignorePath)) {
+                gitignoreFiles.push(path.relative(this.projectPath, gitignorePath));
+            }
+        };
+
+        // Check root
+        await checkGitignore(this.projectPath);
+
+        // Check subdirectories (only 2 levels to avoid being too slow)
+        try {
+            const items = await fs.readdir(this.projectPath);
+            for (const item of items) {
+                const itemPath = path.join(this.projectPath, item);
+                const stat = await fs.stat(itemPath);
+                if (stat.isDirectory()) {
+                    await checkGitignore(itemPath);
+
+                    // Level 2
+                    try {
+                        const subItems = await fs.readdir(itemPath);
+                        for (const subItem of subItems) {
+                            const subItemPath = path.join(itemPath, subItem);
+                            const subStat = await fs.stat(subItemPath);
+                            if (subStat.isDirectory()) {
+                                await checkGitignore(subItemPath);
+                            }
+                        }
+                    } catch (error) {
+                        // Ignore errors
+                    }
+                }
+            }
+        } catch (error) {
+            // Ignore errors
+        }
+
+        return gitignoreFiles;
+    }
+
+    /**
+     * Clear cache
+     */
+    clearCache(): void {
+        this.ignoreInstances.clear();
+    }
+}