@parseme/cli 0.0.4 → 0.0.6

package/dist/utils/file-filter.js

@@ -0,0 +1,99 @@
+import { exec } from 'child_process';
+import { readdir, stat } from 'fs/promises';
+import { join, relative } from 'path';
+import { promisify } from 'util';
+import ignore from 'ignore';
+const execAsync = promisify(exec);
+export class FileFilterService {
+    excludePatterns;
+    useGitForFiles;
+    ig;
+    constructor(excludePatterns = [], useGitForFiles = true) {
+        this.excludePatterns = excludePatterns;
+        this.useGitForFiles = useGitForFiles;
+        this.ig = ignore();
+        this.ig.add(excludePatterns);
+    }
+    /**
+     * Get all files that should be analyzed, respecting:
+     * 1. Git-tracked files (respects all .gitignore files automatically)
+     * 2. All files (if non-git repo) - respects only custom excludePatterns
+     * 3. Custom excludePatterns from config (always applied)
+     */
+    async getFilteredFiles(rootDir, fileExtensions) {
+        try {
+            let files;
+            // Try to get git-tracked files first (only if useGitForFiles is enabled)
+            const isGitRepo = this.useGitForFiles && (await this.isGitRepository(rootDir));
+            if (isGitRepo) {
+                files = await this.getGitTrackedFiles(rootDir);
+            }
+            else {
+                // Fallback: get all files recursively
+                files = await this.getAllFilesRecursive(rootDir, rootDir);
+            }
+            // Apply custom exclude patterns
+            const filteredFiles = files.filter((file) => !this.ig.ignores(file));
+            // Optionally filter by file extensions
+            if (fileExtensions && fileExtensions.length > 0) {
+                const extensionSet = new Set(fileExtensions.map((ext) => (ext.startsWith('.') ? ext : `.${ext}`)));
+                return filteredFiles.filter((file) => {
+                    const ext = file.substring(file.lastIndexOf('.'));
+                    return extensionSet.has(ext);
+                });
+            }
+            return filteredFiles;
+        }
+        catch (error) {
+            throw new Error(`Failed to get filtered files: ${error.message}`);
+        }
+    }
+    /**
+     * Check if the directory is a git repository
+     */
+    async isGitRepository(rootDir) {
+        try {
+            await execAsync('git rev-parse --git-dir', { cwd: rootDir });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get all tracked files from git
+     * This respects all .gitignore files in the repository (parent, current, and child dirs)
+     */
+    async getGitTrackedFiles(rootDir) {
+        const { stdout } = await execAsync('git ls-files', { cwd: rootDir });
+        return stdout
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line);
+    }
+    /**
+     * Get all files recursively (fallback for non-git repos)
+     */
+    async getAllFilesRecursive(dir, rootDir) {
+        const entries = await readdir(dir);
+        const files = [];
+        for (const entry of entries) {
+            const fullPath = join(dir, entry);
+            const relativePath = relative(rootDir, fullPath);
+            const stats = await stat(fullPath);
+            if (stats.isFile()) {
+                files.push(relativePath);
+            }
+            else if (stats.isDirectory() && !entry.startsWith('.')) {
+                files.push(...(await this.getAllFilesRecursive(fullPath, rootDir)));
+            }
+        }
+        return files;
+    }
+    /**
+     * Check if a specific file should be filtered out
+     */
+    shouldIgnore(filePath) {
+        return this.ig.ignores(filePath);
+    }
+}

package/dist/{core/analyzers/git-analyzer.d.ts → utils/git.d.ts}

@@ -1,4 +1,4 @@
-import type { GitInfo } from '../types.js';
+import type { GitInfo } from '../core/types.js';
 export declare class GitAnalyzer {
     analyze(rootDir: string): Promise<GitInfo | null>;
     private getCurrentBranch;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parseme/cli",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Adds a PARSEME.md file—a README.md for AI agents—to your project, providing context and structure for automated tools.",
   "type": "module",
   "main": "./dist/index.js",
@@ -24,11 +24,14 @@
     "format:check": "prettier . --ignore-unknown --check",
     "lint": "eslint --config ./eslint.config.js --fix",
     "lint:check": "eslint --config ./eslint.config.js --no-fix --max-warnings 0",
-    "test": "node --test --experimental-test-coverage 'tests/**/*.test.ts'",
-    "test:unit": "node --test tests/unit/**/*.test.ts",
-    "test:integration": "node --test tests/integration/**/*.test.ts",
-    "test:watch": "node --test --watch tests/**/*.test.ts",
-    "test:coverage": "node --test --experimental-test-coverage tests/**/*.test.ts",
+    "test": "node --test 'tests/**/*.test.ts'",
+    "pretest": "npm run build",
+    "test:unit": "node --test 'tests/unit/**/*.test.ts'",
+    "test:integration": "node --test 'tests/integration/**/*.test.ts'",
+    "test:watch": "node --test --watch 'tests/**/*.test.ts'",
+    "test:coverage": "node --test --experimental-test-coverage 'tests/unit/**/*.test.ts' 'tests/integration/**/*.test.ts'",
+    "test:setup:e2e": "npm run -C ../e2e setup",
+    "test:e2e": "npm run -C ../e2e test",
     "clean": "rm -rf dist"
   },
   "keywords": [