stdin-glob 1.3.0 → 1.8.0

package/dist/index.js

@@ -1,129 +1,5 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const commander_1 = require("commander");
-const package_json_1 = require("../package.json");
-const promises_1 = require("fs/promises");
-const fast_glob_1 = __importDefault(require("fast-glob"));
-const path_1 = __importDefault(require("path"));
-const clipboardy_1 = __importDefault(require("clipboardy"));
-const binary_1 = require("./utils/binary");
-const pipes_1 = require("./utils/pipes");
-const program = new commander_1.Command();
-program
-    .name('stdin-glob')
-    .description('Expand glob patterns and output file contents and paths')
-    .version(package_json_1.version)
-    .option('--no-content', 'Do not show file contents, only list matching paths')
-    .option('--absolute', 'Show the absolute path for entries', false)
-    .option('-c, --copy', 'Copy the output to clipboard instead of printing to console', false)
-    .option('-m, --max-lines <int>', 'Show a limited number of lines in the file. If you not provide a number of lines it will show the full file content.', (value) => {
-    if (isNaN(parseInt(value)))
-        throw new Error('Lines must be a number');
-    return parseInt(value);
-})
-    .option('-n, --line-numbers', 'Show line numbers next to each line, like in IDE sidebars', false)
-    .argument('[patterns...]', 'Glob patterns to match files')
-    .action(async (patterns, options) => {
-    if (patterns.length === 0) {
-        console.error('Error: No patterns provided.');
-        process.exit(1);
-    }
-    //expand glob
-    const files = await (0, fast_glob_1.default)(patterns, {
-        onlyFiles: true,
-        absolute: options.absolute ?? false,
-    });
-    if (files.length === 0) {
-        console.error('No files matched the given patterns.');
-        process.exit(1);
-    }
-    let output = '';
-    for (const file of files) {
-        if (options.content) {
-            const fileOutput = await getFileContent(file, options.maxLines ?? undefined, options.lineNumbers ?? false);
-            output += fileOutput;
-        }
-        else {
-            output += file + '\n';
-        }
-    }
-    if (options.copy) {
-        try {
-            await clipboardy_1.default.write(output.trim());
-            console.log('-> Output copied to clipboard successfully!');
-        }
-        catch (error) {
-            console.error('-X Error copying to clipboard:', error);
-            process.exit(1);
-        }
-    }
-    else {
-        console.log(output.trim());
-    }
-});
-program.parse(process.argv);
-/**
- * Find the maximum number of consecutive backticks in a string
- */
-const findMaxConsecutiveBackticks = (str) => {
-    const matches = str.match(/`+/g);
-    if (!matches)
-        return 0;
-    return Math.max(...matches.map((m) => m.length));
-};
-/**
- * Get file content with markdown format
- * @param filePath - The path to the file
- * @param maxLines - The number of lines to show. If you not provide a number of lines it will show the full file content.
- * @param showLineNumbers - Whether to show line numbers
- * @returns The file content with markdown format
- */
-const getFileContent = async (filePath, maxLines, showLineNumbers) => {
-    try {
-        const fileBuffer = await (0, promises_1.readFile)(filePath);
-        if ((0, binary_1.isBinaryFile)(fileBuffer)) {
-            // is binary!! not show content
-            const stats = await (0, promises_1.stat)(filePath);
-            const fileSize = stats.size;
-            const extension = path_1.default.extname(filePath).replace('.', '');
-            const sizeFormatted = (0, pipes_1.formatSizeInMB)(fileSize);
-            return ('```' +
-                extension +
-                '\n' +
-                `// ${filePath}\n` +
-                `// [BINARY FILE] - Size: ${sizeFormatted}\n` +
-                '```\n\n');
-        }
-        // is text file!! proceed with normal processing
-        const content = fileBuffer.toString('utf-8');
-        const lines = content.split('\n');
-        // maxLines if exists
-        const linesToShow = maxLines ? lines.slice(0, maxLines) : lines;
-        let contentToShow = linesToShow.join('\n');
-        if (showLineNumbers)
-            contentToShow = (0, pipes_1.addLineNumbers)(linesToShow.join('\n'), 1);
-        const extension = path_1.default.extname(filePath).replace('.', '');
-        const maxBackticks = findMaxConsecutiveBackticks(content);
-        const wrapper = '`'.repeat(Math.max(3, maxBackticks + 1));
-        const truncation = maxLines && lines.length > maxLines
-            ? `\n// ... (${lines.length - maxLines} more lines truncated)`
-            : '';
-        return (wrapper +
-            extension +
-            '\n' +
-            `// ${filePath}\n\n` +
-            contentToShow +
-            truncation +
-            '\n' +
-            wrapper +
-            '\n\n');
-    }
-    catch (e) {
-        console.error(`Error reading file ${filePath}:`, e);
-        return '';
-    }
-};
+const main_1 = require("./main");
+(0, main_1.main)();
 //# sourceMappingURL=index.js.map

package/dist/main.d.ts

@@ -0,0 +1,18 @@
+export declare const main: () => Promise<void>;
+/**
+ * Filter files by .gitignore rules recursively
+ */
+export declare const filterByGitignore: (files: string[]) => Promise<string[]>;
+/**
+ * Find the maximum number of consecutive backticks in a string
+ */
+export declare const findMaxConsecutiveBackticks: (str: string) => number;
+/**
+ * Get file content with markdown format
+ * @param filePath - The path to the file
+ * @param maxLines - The number of lines to show. If you not provide a number of lines it will show the full file content.
+ * @param showLineNumbers - Whether to show line numbers
+ * @returns The file content with markdown format
+ */
+export declare const getFileContent: (filePath: string, maxLines?: number, showLineNumbers?: boolean) => Promise<string>;
+//# sourceMappingURL=main.d.ts.map

package/dist/main.js

@@ -0,0 +1,249 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFileContent = exports.findMaxConsecutiveBackticks = exports.filterByGitignore = exports.main = void 0;
+const commander_1 = require("commander");
+const package_json_1 = require("../package.json");
+const promises_1 = require("fs/promises");
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const path_1 = __importDefault(require("path"));
+const clipboardy_1 = __importDefault(require("clipboardy"));
+const ignore_1 = __importDefault(require("ignore"));
+const binary_1 = require("./utils/binary");
+const pipes_1 = require("./utils/pipes");
+const gitignore_1 = require("./utils/gitignore");
+const apply_1 = require("./apply");
+const main = async () => {
+    const program = new commander_1.Command();
+    program
+        .name('stdin-glob')
+        .description('Expand glob patterns and output file contents and paths')
+        .version(package_json_1.version)
+        .option('--no-content', 'Do not show file contents, only list matching paths')
+        .option('--absolute', 'Show the absolute path for entries', false)
+        .option('-c, --copy', 'Copy the output to clipboard instead of printing to console', false)
+        .option('-m, --max-lines <int>', 'Show a limited number of lines in the file. If you not provide a number of lines it will show the full file content.', (value) => {
+        if (isNaN(parseInt(value)))
+            throw new Error('Lines must be a number');
+        return parseInt(value);
+    })
+        .option('-n, --line-numbers', 'Show line numbers next to each line, like in IDE sidebars', false)
+        .option('--no-gitignore', 'Disable .gitignore filtering (include files that would normally be ignored)')
+        .argument('[patterns...]', 'Glob patterns to match files')
+        .action(async (patterns, options) => {
+        if (patterns.length === 0) {
+            console.error('Error: No patterns provided.');
+            process.exit(1);
+        }
+        // Expand glob
+        let files = await (0, fast_glob_1.default)(patterns, {
+            onlyFiles: true,
+            dot: true,
+            absolute: false,
+        });
+        if (files.length === 0) {
+            console.error('No files matched the given patterns.');
+            process.exit(1);
+        }
+        // Apply gitignore filtering if not disabled
+        if (options.gitignore) {
+            files = await (0, exports.filterByGitignore)(files);
+            if (files.length === 0) {
+                console.error('No files remained after applying .gitignore rules.');
+                process.exit(1);
+            }
+        }
+        let output = '';
+        for (const file of files) {
+            if (options.content) {
+                const fileOutput = await (0, exports.getFileContent)(options.absolute ? path_1.default.join(process.cwd(), file) : file, options.maxLines ?? undefined, options.lineNumbers ?? false);
+                output += fileOutput;
+            }
+            else {
+                output += file + '\n';
+            }
+        }
+        if (options.copy) {
+            try {
+                await clipboardy_1.default.write(output.trim());
+                console.log('-> Output copied to clipboard successfully!');
+            }
+            catch (error) {
+                console.error('-X Error copying to clipboard:', error);
+                process.exit(1);
+            }
+        }
+        else {
+            console.log(output.trim());
+        }
+    });
+    // Apply subcommand
+    program
+        .command('apply')
+        .description('Apply code blocks from a file to create/update files (inverse operation)')
+        .argument('<input-file>', 'File containing code blocks in markdown format')
+        .option('-d, --dir <path>', 'Base directory to apply files (default: current directory)')
+        .action(async (inputFile, options) => {
+        try {
+            const { parseCodeBlocks } = await Promise.resolve().then(() => __importStar(require('./apply')));
+            const content = await (0, promises_1.readFile)(inputFile, 'utf-8');
+            const parsed = parseCodeBlocks(content);
+            if (parsed.length === 0) {
+                console.error('No valid code blocks found in the input file.');
+                process.exit(1);
+            }
+            console.log(`Found ${parsed.length} file(s) to process:\n`);
+            for (const file of parsed) {
+                const status = file.isBinary ? '[SKIP - binary]' : '[OK]';
+                console.log(`  ${status} ${file.filePath}`);
+            }
+            if (options.dryRun) {
+                console.log('\n[Dry run] No files were modified.');
+                return;
+            }
+            const result = await (0, apply_1.applyFromFile)(inputFile, options.dir);
+            console.log('\nResults:');
+            if (result.created.length > 0) {
+                console.log(`  Created: ${result.created.length}`);
+                result.created.forEach((f) => console.log(`    + ${f}`));
+            }
+            if (result.updated.length > 0) {
+                console.log(`  Updated: ${result.updated.length}`);
+                result.updated.forEach((f) => console.log(`    ~ ${f}`));
+            }
+            if (result.skipped.length > 0) {
+                console.log(`  Skipped (binary): ${result.skipped.length}`);
+                result.skipped.forEach((f) => console.log(`    - ${f}`));
+            }
+        }
+        catch (error) {
+            console.error('Error:', error);
+            process.exit(1);
+        }
+    });
+    await program.parseAsync(process.argv);
+};
+exports.main = main;
+/**
+ * Filter files by .gitignore rules recursively
+ */
+const filterByGitignore = async (files) => {
+    try {
+        // Find all .gitignore files in the project
+        const gitignoreFiles = await (0, gitignore_1.findGitignoreFiles)();
+        if (gitignoreFiles.length === 0) {
+            return files;
+        }
+        // Create ignore instance with all rules
+        const ig = (0, ignore_1.default)().add(await (0, gitignore_1.loadGitignoreRules)(gitignoreFiles));
+        return files.filter((file) => {
+            // Get relative path from the root where gitignore rules apply
+            const relativePath = path_1.default.relative(process.cwd(), file);
+            return !ig.ignores(relativePath);
+        });
+    }
+    catch (error) {
+        console.warn('Warning: Error processing .gitignore files, proceeding without filtering:', error);
+        return files;
+    }
+};
+exports.filterByGitignore = filterByGitignore;
+/**
+ * Find the maximum number of consecutive backticks in a string
+ */
+const findMaxConsecutiveBackticks = (str) => {
+    const matches = str.match(/`+/g);
+    if (!matches)
+        return 0;
+    return Math.max(...matches.map((m) => m.length));
+};
+exports.findMaxConsecutiveBackticks = findMaxConsecutiveBackticks;
+/**
+ * Get file content with markdown format
+ * @param filePath - The path to the file
+ * @param maxLines - The number of lines to show. If you not provide a number of lines it will show the full file content.
+ * @param showLineNumbers - Whether to show line numbers
+ * @returns The file content with markdown format
+ */
+const getFileContent = async (filePath, maxLines, showLineNumbers) => {
+    try {
+        const fileBuffer = await (0, promises_1.readFile)(filePath);
+        if ((0, binary_1.isBinaryFile)(fileBuffer)) {
+            // is binary!! not show content
+            const stats = await (0, promises_1.stat)(filePath);
+            const fileSize = stats.size;
+            const extension = path_1.default.extname(filePath).replace('.', '');
+            const sizeFormatted = (0, pipes_1.formatSizeInMB)(fileSize);
+            return ('```' +
+                extension +
+                '\n' +
+                `// ${filePath}\n` +
+                `// [BINARY FILE] - Size: ${sizeFormatted}\n` +
+                '```\n\n');
+        }
+        // is text file!! proceed with normal processing
+        const content = fileBuffer.toString('utf-8');
+        const lines = content.split('\n');
+        // maxLines if exists
+        const linesToShow = maxLines ? lines.slice(0, maxLines) : lines;
+        let contentToShow = linesToShow.join('\n');
+        if (showLineNumbers)
+            contentToShow = (0, pipes_1.addLineNumbers)(linesToShow.join('\n'), 1);
+        const extension = path_1.default.extname(filePath).replace('.', '');
+        const maxBackticks = (0, exports.findMaxConsecutiveBackticks)(content);
+        const wrapper = '`'.repeat(Math.max(3, maxBackticks + 1));
+        const truncation = maxLines && lines.length > maxLines
+            ? `\n// ... (${lines.length - maxLines} more lines truncated)`
+            : '';
+        return (wrapper +
+            extension +
+            '\n' +
+            `// ${filePath}\n\n` +
+            contentToShow +
+            truncation +
+            '\n' +
+            wrapper +
+            '\n\n');
+    }
+    catch (e) {
+        console.error(`Error reading file ${filePath}:`, e);
+        return '';
+    }
+};
+exports.getFileContent = getFileContent;
+//# sourceMappingURL=main.js.map

package/dist/main.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=main.test.d.ts.map

package/dist/main.test.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const promises_1 = require("fs/promises");
+const binary_1 = require("./utils/binary");
+const pipes_1 = require("./utils/pipes");
+const gitignore_1 = require("./utils/gitignore");
+const main_1 = require("./main");
+vitest_1.vi.mock('fs/promises');
+vitest_1.vi.mock('fast-glob', () => ({ default: async () => [] }));
+vitest_1.vi.mock('clipboardy');
+vitest_1.vi.mock('./utils/binary');
+vitest_1.vi.mock('./utils/pipes');
+vitest_1.vi.mock('./utils/gitignore');
+(0, vitest_1.describe)('filterByGitignore', () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetAllMocks();
+    });
+    //
+    (0, vitest_1.it)('returns all files when no gitignore files found', async () => {
+        vitest_1.vi.mocked(gitignore_1.findGitignoreFiles).mockResolvedValue([]);
+        const files = ['file1.ts', 'file2.ts'];
+        const result = await (0, main_1.filterByGitignore)(files);
+        (0, vitest_1.expect)(result).toEqual(files);
+    });
+    //
+    (0, vitest_1.it)('filters files based on gitignore rules', async () => {
+        vitest_1.vi.mocked(gitignore_1.findGitignoreFiles).mockResolvedValue(['.gitignore']);
+        vitest_1.vi.mocked(gitignore_1.loadGitignoreRules).mockResolvedValue(['node_modules']);
+        const mockIg = { ignores: vitest_1.vi.fn().mockReturnValue(true) };
+        vitest_1.vi.doMock('ignore', () => () => mockIg);
+        const files = ['src/index.ts', 'node_modules/test.js'];
+        const result = await (0, main_1.filterByGitignore)(files);
+        (0, vitest_1.expect)(result).toHaveLength(1);
+    });
+    //
+    (0, vitest_1.it)('returns all files when gitignore processing fails', async () => {
+        vitest_1.vi.mocked(gitignore_1.findGitignoreFiles).mockRejectedValue(new Error('Failed'));
+        const files = ['file1.ts'];
+        const result = await (0, main_1.filterByGitignore)(files);
+        (0, vitest_1.expect)(result).toEqual(files);
+    });
+});
+(0, vitest_1.describe)('findMaxConsecutiveBackticks', () => {
+    (0, vitest_1.it)('returns 0 for string without backticks', () => {
+        (0, vitest_1.expect)((0, main_1.findMaxConsecutiveBackticks)('hello world')).toBe(0);
+    });
+    (0, vitest_1.it)('finds max consecutive backticks', () => {
+        (0, vitest_1.expect)((0, main_1.findMaxConsecutiveBackticks)('` ``` ````')).toBe(4);
+    });
+    (0, vitest_1.it)('handles multiple occurrences', () => {
+        (0, vitest_1.expect)((0, main_1.findMaxConsecutiveBackticks)('` ``` ` ``')).toBe(3);
+    });
+});
+(0, vitest_1.describe)('getFileContent', () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetAllMocks();
+    });
+    (0, vitest_1.it)('returns empty string on file read error', async () => {
+        vitest_1.vi.mocked(promises_1.readFile).mockRejectedValue(new Error('Read error'));
+        const result = await (0, main_1.getFileContent)('test.txt');
+        (0, vitest_1.expect)(result).toBe('');
+    });
+    (0, vitest_1.it)('handles binary files', async () => {
+        vitest_1.vi.mocked(promises_1.readFile).mockResolvedValue(Buffer.from([0x00, 0x01]));
+        vitest_1.vi.mocked(binary_1.isBinaryFile).mockReturnValue(true);
+        vitest_1.vi.mocked(promises_1.stat).mockResolvedValue({ size: 1024 });
+        vitest_1.vi.mocked(pipes_1.formatSizeInMB).mockReturnValue('0.001 MB');
+        const result = await (0, main_1.getFileContent)('test.png');
+        (0, vitest_1.expect)(result).toContain('[BINARY FILE]');
+        (0, vitest_1.expect)(result).toContain('test.png');
+    });
+    (0, vitest_1.it)('processes text files correctly', async () => {
+        const content = 'line1\nline2\nline3';
+        vitest_1.vi.mocked(promises_1.readFile).mockResolvedValue(Buffer.from(content));
+        vitest_1.vi.mocked(binary_1.isBinaryFile).mockReturnValue(false);
+        const result = await (0, main_1.getFileContent)('test.txt');
+        (0, vitest_1.expect)(result).toContain('test.txt');
+        (0, vitest_1.expect)(result).toContain('line1');
+        (0, vitest_1.expect)(result).toContain('line2');
+    });
+    (0, vitest_1.it)('respects maxLines parameter', async () => {
+        const content = 'line1\nline2\nline3';
+        vitest_1.vi.mocked(promises_1.readFile).mockResolvedValue(Buffer.from(content));
+        vitest_1.vi.mocked(binary_1.isBinaryFile).mockReturnValue(false);
+        const result = await (0, main_1.getFileContent)('test.txt', 2);
+        (0, vitest_1.expect)(result).toContain('line1');
+        (0, vitest_1.expect)(result).toContain('line2');
+        (0, vitest_1.expect)(result).not.toContain('line3');
+        (0, vitest_1.expect)(result).toContain('1 more lines truncated');
+    });
+    (0, vitest_1.it)('adds line numbers when requested', async () => {
+        const content = 'line1\nline2';
+        vitest_1.vi.mocked(promises_1.readFile).mockResolvedValue(Buffer.from(content));
+        vitest_1.vi.mocked(binary_1.isBinaryFile).mockReturnValue(false);
+        vitest_1.vi.mocked(pipes_1.addLineNumbers).mockReturnValue('1 | line1\n2 | line2');
+        const result = await (0, main_1.getFileContent)('test.txt', undefined, true);
+        (0, vitest_1.expect)(result).toContain('1 | line1');
+        (0, vitest_1.expect)(result).toContain('2 | line2');
+    });
+    (0, vitest_1.it)('handles code blocks with backticks', async () => {
+        const content = '```\ncode\n```';
+        vitest_1.vi.mocked(promises_1.readFile).mockResolvedValue(Buffer.from(content));
+        vitest_1.vi.mocked(binary_1.isBinaryFile).mockReturnValue(false);
+        const result = await (0, main_1.getFileContent)('test.js');
+        (0, vitest_1.expect)(result).toContain('````js');
+    });
+});
+(0, vitest_1.describe)('CLI Integration', () => {
+    (0, vitest_1.it)('exits with error when no patterns provided', async () => {
+        vitest_1.vi.mocked(gitignore_1.findGitignoreFiles).mockResolvedValue([]);
+        const mockExit = vitest_1.vi
+            .spyOn(process, 'exit')
+            .mockImplementation(() => undefined);
+        const mockError = vitest_1.vi.spyOn(console, 'error').mockImplementation(() => { });
+        await (0, main_1.main)();
+        (0, vitest_1.expect)(mockExit).toHaveBeenCalledWith(1);
+        mockExit.mockRestore();
+        mockError.mockRestore();
+    });
+    (0, vitest_1.it)('exits with error when no files matched', async () => {
+        vitest_1.vi.mocked(gitignore_1.findGitignoreFiles).mockResolvedValue([]);
+        const mockExit = vitest_1.vi
+            .spyOn(process, 'exit')
+            .mockImplementation(() => undefined);
+        const mockError = vitest_1.vi.spyOn(console, 'error').mockImplementation(() => { });
+        await (0, main_1.main)();
+        (0, vitest_1.expect)(mockExit).toHaveBeenCalledWith(1);
+        mockExit.mockRestore();
+        mockError.mockRestore();
+    });
+});
+//# sourceMappingURL=main.test.js.map

package/dist/utils/binary.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=binary.test.d.ts.map

package/dist/utils/binary.test.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const binary_1 = require("./binary");
+(0, vitest_1.describe)('isBinaryFile', () => {
+    (0, vitest_1.it)('returns false for text content', () => {
+        const buffer = Buffer.from('Hello world\nThis is text');
+        (0, vitest_1.expect)((0, binary_1.isBinaryFile)(buffer)).toBe(false);
+    });
+    (0, vitest_1.it)('returns true for null bytes', () => {
+        const buffer = Buffer.from([0x48, 0x00, 0x65, 0x6c, 0x6c, 0x6f]);
+        (0, vitest_1.expect)((0, binary_1.isBinaryFile)(buffer)).toBe(true);
+    });
+    (0, vitest_1.it)('returns true for control characters', () => {
+        const buffer = Buffer.from([0x01, 0x02, 0x03, 0x04]);
+        (0, vitest_1.expect)((0, binary_1.isBinaryFile)(buffer)).toBe(true);
+    });
+    (0, vitest_1.it)('allows whitespace characters', () => {
+        const buffer = Buffer.from('Hello\tworld\nnew line\rreturn');
+        (0, vitest_1.expect)((0, binary_1.isBinaryFile)(buffer)).toBe(false);
+    });
+    (0, vitest_1.it)('only checks first 512 bytes', () => {
+        const buffer = Buffer.alloc(1000);
+        buffer.fill(0x41); // 'A'
+        buffer[500] = 0x00; // null byte within first 512
+        (0, vitest_1.expect)((0, binary_1.isBinaryFile)(buffer)).toBe(true);
+        const buffer2 = Buffer.alloc(1000);
+        buffer2.fill(0x41);
+        buffer2[600] = 0x00; // null byte after first 512
+        (0, vitest_1.expect)((0, binary_1.isBinaryFile)(buffer2)).toBe(false);
+    });
+});
+//# sourceMappingURL=binary.test.js.map

package/dist/utils/gitignore.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Find all .gitignore files in the project
+ */
+export declare const findGitignoreFiles: () => Promise<string[]>;
+/**
+ * Load and combine rules from recursive/multiple .gitignore files
+ * @see https://git-scm.com/docs/gitignore#_pattern_format
+ */
+export declare const loadGitignoreRules: (gitignoreFiles: string[]) => Promise<string[]>;
+//# sourceMappingURL=gitignore.d.ts.map

package/dist/utils/gitignore.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadGitignoreRules = exports.findGitignoreFiles = void 0;
+const promises_1 = require("fs/promises");
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Find all .gitignore files in the project
+ */
+const findGitignoreFiles = async () => {
+    try {
+        const files = await (0, fast_glob_1.default)('**/.gitignore', {
+            cwd: process.cwd(),
+            ignore: ['**/node_modules/**'],
+        });
+        return files;
+    }
+    catch (error) {
+        console.warn('Warning: Error finding .gitignore files:', error);
+        return [];
+    }
+};
+exports.findGitignoreFiles = findGitignoreFiles;
+/**
+ * Parse a .gitignore file and return its rules
+ */
+const parseGitignore = (content) => {
+    return content
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line && // Not empty
+        !line.startsWith('#'));
+};
+/**
+ * Load and combine rules from recursive/multiple .gitignore files
+ * @see https://git-scm.com/docs/gitignore#_pattern_format
+ */
+const loadGitignoreRules = async (gitignoreFiles) => {
+    const allRules = [];
+    for (const file of gitignoreFiles) {
+        try {
+            const content = await (0, promises_1.readFile)(file, 'utf-8');
+            const rules = parseGitignore(content);
+            // directory of this .gitignore
+            const gitignoreDir = path_1.default.dirname(file);
+            // to be relative to the gitignore location
+            const dirRelativeRules = rules.map((rule) => {
+                //handle negations
+                if (rule.startsWith('!')) {
+                    return `!${path_1.default.join(gitignoreDir, rule.slice(1))}`;
+                }
+                return path_1.default.join(gitignoreDir, rule);
+            });
+            allRules.push(...dirRelativeRules);
+        }
+        catch (error) {
+            console.warn(`Warning: Error reading .gitignore file ${file}:`, error);
+        }
+    }
+    return allRules;
+};
+exports.loadGitignoreRules = loadGitignoreRules;
+//# sourceMappingURL=gitignore.js.map

package/dist/utils/gitignore.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gitignore.test.d.ts.map