stdin-glob 1.3.0 → 1.8.0

package/README.md

@@ -31,6 +31,8 @@ This pipes all relevant TypeScript/TSX files directly into my clipboard, ready t
 - Support for absolute or relative paths
 - Option to show only file paths without content
 - **Intelligent handling of binary files** - shows metadata instead of attempting to display unreadable content
+- **Automatic .gitignore filtering** - respects your project's ignore rules by default
+- **Reverse apply** - recreate files from a markdown document containing code blocks (inverse operation)
 - Written in TypeScript
 
 ## Installation
@@ -47,15 +49,16 @@ stdin-glob [options] [patterns...]
 
 ### Options
 
-| Option                | Description                                                           |
-| --------------------- | --------------------------------------------------------------------- |
-| `--no-content`        | Do not show file contents, only list matching paths                   |
-| `--absolute`          | Show absolute paths for entries                                       |
-| `-c, --copy`          | Copy the output to clipboard instead of printing to console           |
-| `-m, --max-lines <n>` | Show only the first N lines of each file (shows full file if omitted) |
-| `-n, --line-numbers`  | Display line numbers next to each line, like in IDE sidebars          |
-| `-V, --version`       | Output the version number                                             |
-| `-h, --help`          | Display help information                                              |
+| Option                | Description                                                                 |
+| --------------------- | --------------------------------------------------------------------------- |
+| `--no-content`        | Do not show file contents, only list matching paths                         |
+| `--absolute`          | Show absolute paths for entries                                             |
+| `-c, --copy`          | Copy the output to clipboard instead of printing to console                 |
+| `-m, --max-lines <n>` | Show only the first N lines of each file (shows full file if omitted)       |
+| `-n, --line-numbers`  | Display line numbers next to each line, like in IDE sidebars                |
+| `--no-gitignore`      | Disable .gitignore filtering (include files that would normally be ignored) |
+| `-V, --version`       | Output the version number                                                   |
+| `-h, --help`          | Display help information                                                    |
 
 ### Arguments
 
@@ -63,6 +66,44 @@ stdin-glob [options] [patterns...]
 | ---------- | ------------------------------------------ |
 | `patterns` | Glob patterns to match files (one or more) |
 
+### Apply Command
+
+The `apply` subcommand is the inverse operation: it reads a file containing code blocks in the format produced by `stdin-glob` and creates or updates the corresponding files on disk.
+
+```bash
+stdin-glob apply <input-file> [options]
+```
+
+#### Apply Options
+
+| Option             | Description                                                |
+| ------------------ | ---------------------------------------------------------- |
+| `<input-file>`     | File containing code blocks in markdown format             |
+| `-d, --dir <path>` | Base directory to apply files (default: current directory) |
+| `--dry-run`        | Show what would be done without making any changes         |
+
+#### How It Works
+
+The `apply` command parses a document looking for code blocks that follow this structure:
+
+````
+```ext
+// path/to/file.ext
+file content here
+```
+````
+
+It then creates or updates each file based on the extracted content. This is particularly useful when an LLM generates modified code—you can simply apply the output directly to your project.
+
+Key behaviors:
+
+- **Noise tolerance**: Ignores any text outside of code blocks (explanations, comments, etc.)
+- **Matching backticks**: Only recognizes code blocks where the opening and closing have the exact same number of backticks
+- **Binary file detection**: Files marked with `[BINARY FILE]` are automatically skipped
+- **Truncation warnings**: Warns when the source content was truncated
+- **Directory creation**: Automatically creates any necessary parent directories
+- **Create vs. update**: Reports which files were created new and which were modified
+
 ## Pattern Syntax
 
 This tool uses [fast-glob](https://github.com/mrmlnc/fast-glob) for pattern matching, which supports the feature set of [picomatch](https://github.com/micromatch/picomatch). For detailed information about available globbing features and syntax options, refer to the [picomatch globbing features documentation](https://github.com/micromatch/picomatch?tab=readme-ov-file#globbing-features).
@@ -251,3 +292,119 @@ stdin-glob "src/**/*.ts" --no-content | pbcopy
 stdin-glob "src/**/*.ts" --content
 stdin-glob "src/**/*.ts" --copy
 ```
+
+### .gitignore Support
+
+By default, `stdin-glob` automatically respects your project's `.gitignore` rules. This means files and directories listed in `.gitignore` won't appear in the output. This is especially useful when you want to avoid including build artifacts, dependencies, or environment files in your context.
+
+The gitignore pattern matching implementation is based on the official [gitignore pattern format documentation](https://git-scm.com/docs/gitignore#_pattern_format), ensuring compatibility with how git itself handles ignore rules.
+
+#### Including ignored files
+
+If you need to include files that would normally be ignored, use the `--no-gitignore` flag:
+
+```bash
+stdin-glob "dist/**/*.js" --no-gitignore
+```
+
+This disables all `.gitignore` filtering and includes every file matching your patterns.
+
+### Apply files from markdown output
+
+Apply code blocks from a file directly to your project:
+
+```bash
+stdin-glob apply output.md
+```
+
+This reads `output.md`, finds all code blocks with file paths, and creates or updates the corresponding files.
+
+#### Apply to a specific directory
+
+Target a different directory than the current one:
+
+```bash
+stdin-glob apply output.md --dir ./my-project
+```
+
+#### Dry run
+
+Preview what would happen without making any changes:
+
+```bash
+stdin-glob apply output.md --dry-run
+```
+
+Output:
+
+```
+Found 3 file(s) to process:
+
+  [OK] src/index.ts
+  [OK] src/utils/helpers.ts
+  [WARN - truncated] src/types/index.ts
+
+[Dry run] No files were modified.
+```
+
+#### Handling noisy input
+
+The `apply` command is designed to work with real LLM output, which often includes explanations between code blocks:
+
+````
+Here are the updated files:
+
+The main index file has been modified to add error handling:
+
+```ts
+// src/index.ts
+console.log('Hello!');
+```
+
+I also created a new utility:
+
+```js
+// src/utils/new.js
+export const helper = () => true;
+```
+
+Let me know if you need anything else!
+````
+
+Running `stdin-glob apply response.md` on the above will correctly extract and apply only the two code blocks, ignoring all the surrounding text.
+
+#### Full workflow example
+
+A typical workflow when working with LLMs:
+
+```bash
+# 1. Gather context from your project
+stdin-glob "src/**/*.ts" --copy
+
+# 2. Paste into your LLM and ask for modifications
+
+# 3. Save the LLM response to a file
+# (paste from clipboard)
+# pbpaste > response.md
+
+# 4. Preview what will change
+stdin-glob apply response.md --dry-run
+
+# 5. Apply the changes
+stdin-glob apply response.md
+```
+
+Output after applying:
+
+```
+Found 2 file(s) to process:
+
+  [OK] src/index.ts
+  [OK] src/utils/new.js
+
+Results:
+  Created: 1
+    + src/utils/new.js
+  Updated: 1
+    ~ src/index.ts
+```

package/dist/apply.d.ts

@@ -0,0 +1,26 @@
+export interface ParsedFile {
+    filePath: string;
+    content: string;
+    isBinary: boolean;
+}
+/**
+ * Parse a document containing code blocks and extract file paths and contents
+ * Handles varying numbers of backticks and ignores "noise" between blocks
+ */
+export declare const parseCodeBlocks: (input: string) => ParsedFile[];
+export interface ApplyResult {
+    created: string[];
+    updated: string[];
+    skipped: string[];
+}
+/**
+ * Apply parsed files
+ */
+export declare const applyFiles: (files: ParsedFile[], baseDir?: string) => Promise<ApplyResult>;
+/**
+ *
+ */
+export declare const applyFromFile: (inputPath: string, baseDir?: string) => Promise<ApplyResult & {
+    parsed: ParsedFile[];
+}>;
+//# sourceMappingURL=apply.d.ts.map

package/dist/apply.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyFromFile = exports.applyFiles = exports.parseCodeBlocks = void 0;
+const promises_1 = require("fs/promises");
+const path_1 = __importDefault(require("path"));
+/**
+ * Parse a document containing code blocks and extract file paths and contents
+ * Handles varying numbers of backticks and ignores "noise" between blocks
+ */
+const parseCodeBlocks = (input) => {
+    const files = [];
+    const lines = input.split('\n');
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        // Check if this line is a code block opening (3+ backticks followed by optional extension)
+        const backtickMatch = line.match(/^(`{3,})(\S*)\s*$/);
+        if (backtickMatch) {
+            const numBackticks = backtickMatch[1].length;
+            //
+            const closingLine = '`'.repeat(numBackticks);
+            //
+            let j = i + 1;
+            while (j < lines.length && lines[j].trim() !== closingLine) {
+                j++;
+            }
+            if (j < lines.length) {
+                // found closing!! - extract content between opening and closing
+                const contentLines = lines.slice(i + 1, j);
+                // First line should be file path comment
+                // For example: `// src/some/thinghs.java`
+                if (contentLines.length > 0) {
+                    const firstLine = contentLines[0].trim();
+                    if (firstLine.startsWith('// ')) {
+                        const filePath = firstLine.slice(3).trim();
+                        // Content is everything after the first line
+                        const content = contentLines.slice(1).join('\n');
+                        // it's a binary file marker? I known't
+                        const isBinary = content.includes('[BINARY FILE]');
+                        files.push({ filePath, content, isBinary });
+                    }
+                }
+                i = j + 1;
+                continue;
+            }
+        }
+        i++;
+    }
+    return files;
+};
+exports.parseCodeBlocks = parseCodeBlocks;
+/**
+ * Apply parsed files
+ */
+const applyFiles = async (files, baseDir) => {
+    const created = [];
+    const updated = [];
+    const skipped = [];
+    for (const file of files) {
+        const fullPath = baseDir
+            ? path_1.default.join(baseDir, file.filePath)
+            : file.filePath;
+        const dir = path_1.default.dirname(fullPath);
+        if (file.isBinary) {
+            // is binary file, skip then
+            skipped.push(fullPath);
+            continue;
+        }
+        // if it doesn't exist:
+        await (0, promises_1.mkdir)(dir, { recursive: true });
+        let fileExists = false;
+        try {
+            await (0, promises_1.stat)(fullPath);
+            fileExists = true;
+        }
+        catch {
+            // File doesn't exist
+        }
+        await (0, promises_1.writeFile)(fullPath, file.content, 'utf-8');
+        if (fileExists) {
+            updated.push(fullPath);
+        }
+        else {
+            created.push(fullPath);
+        }
+    }
+    return { created, updated, skipped };
+};
+exports.applyFiles = applyFiles;
+/**
+ *
+ */
+const applyFromFile = async (inputPath, baseDir) => {
+    const content = await (0, promises_1.readFile)(inputPath, 'utf-8');
+    const parsed = (0, exports.parseCodeBlocks)(content);
+    const result = await (0, exports.applyFiles)(parsed, baseDir);
+    return { ...result, parsed };
+};
+exports.applyFromFile = applyFromFile;
+//# sourceMappingURL=apply.js.map

package/dist/apply.test.d.ts

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

package/dist/apply.test.js

@@ -0,0 +1,317 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const promises_1 = require("fs/promises");
+const apply_1 = require("./apply");
+vitest_1.vi.mock('fs/promises');
+(0, vitest_1.describe)('parseCodeBlocks', () => {
+    const bt = (n) => '`'.repeat(n);
+    (0, vitest_1.it)('parses basic code blocks', () => {
+        const input = `${bt(3)}ts\n// src/index.ts\nconsole.log('hello');\n${bt(3)}`;
+        const files = (0, apply_1.parseCodeBlocks)(input);
+        (0, vitest_1.expect)(files).toHaveLength(1);
+        (0, vitest_1.expect)(files[0].filePath).toBe('src/index.ts');
+        (0, vitest_1.expect)(files[0].content).toBe("console.log('hello');");
+        (0, vitest_1.expect)(files[0].isBinary).toBe(false);
+    });
+    (0, vitest_1.it)('handles noise between blocks', () => {
+        const input = `Some noise here bla bla bla
+${bt(3)}txt
+// file1.txt
+content1
+${bt(3)}
+More noise and random text, jojojo
+${bt(3)}js
+// file2.js
+content2
+${bt(3)}
+Even more noise and webos`;
+        const files = (0, apply_1.parseCodeBlocks)(input);
+        (0, vitest_1.expect)(files).toHaveLength(2);
+        (0, vitest_1.expect)(files[0].filePath).toBe('file1.txt');
+        (0, vitest_1.expect)(files[0].content).toBe('content1');
+        (0, vitest_1.expect)(files[1].filePath).toBe('file2.js');
+        (0, vitest_1.expect)(files[1].content).toBe('content2');
+    });
+    (0, vitest_1.it)('handles different numbers of backticks', () => {
+        const input = `${bt(3)}ts\n// file1.ts\ncontent1\n${bt(3)}
+${bt(4)}js\n// file2.js\ncontent2 with ${bt(3)}backticks${bt(3)} inside\n${bt(4)}
+${bt(5)}py\n// file3.py\ncontent3\n${bt(5)}`;
+        const files = (0, apply_1.parseCodeBlocks)(input);
+        (0, vitest_1.expect)(files).toHaveLength(3);
+        (0, vitest_1.expect)(files[0].filePath).toBe('file1.ts');
+        (0, vitest_1.expect)(files[1].filePath).toBe('file2.js');
+        (0, vitest_1.expect)(files[1].content).toBe('content2 with ```backticks``` inside');
+        (0, vitest_1.expect)(files[2].filePath).toBe('file3.py');
+    });
+    (0, vitest_1.it)('requires matching backtick counts for opening and closing', () => {
+        const input = `${bt(4)}ts\n// file.ts\ncontent\n${bt(3)}`;
+        const files = (0, apply_1.parseCodeBlocks)(input);
+        (0, vitest_1.expect)(files).toHaveLength(0);
+    });
+    (0, vitest_1.it)('does not confuse shorter backtick sequence as closing for longer opening', () => {
+        const input = `${bt(5)}md
+// readme.md
+Here is some ${bt(3)}code${bt(3)}
+And more ${bt(4)}more code${bt(4)}
+ ${bt(5)}`;
+        const files = (0, apply_1.parseCodeBlocks)(input);
+        (0, vitest_1.expect)(files).toHaveLength(1);
+        (0, vitest_1.expect)(files[0].content).toBe('Here is some ```code```\nAnd more ````more code````');
+    });
+    (0, vitest_1.it)('identifies binary files', () => {
+        const input = `${bt(3)}png\n// image.png\n// [BINARY FILE] - Size: 1.000 MB\n${bt(3)}`;
+        const files = (0, apply_1.parseCodeBlocks)(input);
+        (0, vitest_1.expect)(files).toHaveLength(1);
+        (0, vitest_1.expect)(files[0].isBinary).toBe(true);
+    });
+    (0, vitest_1.it)('identifies truncated files', () => {
+        const input = `${bt(3)}ts\n// file.ts\ncontent\n// ... (100 more lines truncated)\n${bt(3)}`;
+        const files = (0, apply_1.parseCodeBlocks)(input);
+        (0, vitest_1.expect)(files).toHaveLength(1);
+    });
+    (0, vitest_1.it)('handles empty content after file path', () => {
+        const input = `${bt(3)}ts\n// empty.ts\n${bt(3)}`;
+        const files = (0, apply_1.parseCodeBlocks)(input);
+        (0, vitest_1.expect)(files).toHaveLength(1);
+        (0, vitest_1.expect)(files[0].content).toBe('');
+    });
+    (0, vitest_1.it)('ignores blocks without file path comment', () => {
+        const input = `${bt(3)}ts\njust code without path\n${bt(3)}`;
+        const files = (0, apply_1.parseCodeBlocks)(input);
+        (0, vitest_1.expect)(files).toHaveLength(0);
+    });
+    (0, vitest_1.it)('ignores blocks where first line does not start with //', () => {
+        const input = `${bt(3)}ts\nsrc/index.ts\nconsole.log('hello');\n${bt(3)}`;
+        const files = (0, apply_1.parseCodeBlocks)(input);
+        (0, vitest_1.expect)(files).toHaveLength(0);
+    });
+    (0, vitest_1.it)('handles unclosed code blocks gracefully', () => {
+        const input = `${bt(3)}ts\n// file.ts\ncontent without closing`;
+        const files = (0, apply_1.parseCodeBlocks)(input);
+        (0, vitest_1.expect)(files).toHaveLength(0);
+    });
+    (0, vitest_1.it)('handles multiline content correctly', () => {
+        const input = `${bt(3)}ts
+// src/main.ts
+import { foo } from './bar';
+
+const x = 1;
+const y = 2;
+
+export function add(): number {
+  return x + y;
+}
+ ${bt(3)}`;
+        const files = (0, apply_1.parseCodeBlocks)(input);
+        (0, vitest_1.expect)(files).toHaveLength(1);
+        const expectedContent = `import { foo } from './bar';
+
+const x = 1;
+const y = 2;
+
+export function add(): number {
+  return x + y;
+}`;
+        (0, vitest_1.expect)(files[0].content).toBe(expectedContent);
+    });
+    (0, vitest_1.it)('handles file paths with spaces', () => {
+        const input = `${bt(3)}txt\n// path with spaces/file name.txt\ncontent\n${bt(3)}`;
+        const files = (0, apply_1.parseCodeBlocks)(input);
+        (0, vitest_1.expect)(files[0].filePath).toBe('path with spaces/file name.txt');
+    });
+    (0, vitest_1.it)('handles extension without content on same line', () => {
+        const input = `${bt(3)}js\n// app.js\nconsole.log('test');\n${bt(3)}`;
+        const files = (0, apply_1.parseCodeBlocks)(input);
+        (0, vitest_1.expect)(files).toHaveLength(1);
+    });
+    (0, vitest_1.it)('handles no extension (just backticks)', () => {
+        const input = `${bt(3)}\n// Makefile\nall:\n\techo hello\n${bt(3)}`;
+        const files = (0, apply_1.parseCodeBlocks)(input);
+        (0, vitest_1.expect)(files).toHaveLength(1);
+        (0, vitest_1.expect)(files[0].filePath).toBe('Makefile');
+        (0, vitest_1.expect)(files[0].content).toBe('all:\n\techo hello');
+    });
+    (0, vitest_1.it)('handles consecutive code blocks without noise', () => {
+        const input = `${bt(3)}a\n// file1.a\ncontent1\n${bt(3)}
+${bt(3)}b\n// file2.b\ncontent2\n${bt(3)}
+${bt(3)}c\n// file3.c\ncontent3\n${bt(3)}`;
+        const files = (0, apply_1.parseCodeBlocks)(input);
+        (0, vitest_1.expect)(files).toHaveLength(3);
+    });
+    (0, vitest_1.it)('example from the requirements', () => {
+        const input = `Aqui hay texto de ruido entre cada bloque de contenido
+${bt(3)}perl
+// src/webo.perl
+aqui hay contenido
+${bt(3)}
+Aqui hay texto de ruido entre cada bloque de contenido
+${bt(3)}txt
+// src/ejemplo.txt
+Aqui nuevamente contenido correcto
+${bt(3)}`;
+        const files = (0, apply_1.parseCodeBlocks)(input);
+        (0, vitest_1.expect)(files).toHaveLength(2);
+        (0, vitest_1.expect)(files[0].filePath).toBe('src/webo.perl');
+        (0, vitest_1.expect)(files[0].content).toBe('aqui hay contenido');
+        (0, vitest_1.expect)(files[1].filePath).toBe('src/ejemplo.txt');
+        (0, vitest_1.expect)(files[1].content).toBe('Aqui nuevamente contenido correcto');
+    });
+});
+(0, vitest_1.describe)('applyFiles', () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetAllMocks();
+    });
+    (0, vitest_1.it)('creates new files', async () => {
+        vitest_1.vi.mocked(promises_1.stat).mockRejectedValue(new Error('Not found'));
+        vitest_1.vi.mocked(promises_1.mkdir).mockResolvedValue(undefined);
+        vitest_1.vi.mocked(promises_1.writeFile).mockResolvedValue(undefined);
+        const files = [
+            {
+                filePath: 'src/index.ts',
+                content: 'console.log("hello");',
+                isBinary: false,
+                isTruncated: false,
+            },
+        ];
+        const result = await (0, apply_1.applyFiles)(files);
+        (0, vitest_1.expect)(result.created).toHaveLength(1);
+        (0, vitest_1.expect)(result.created[0]).toContain('src/index.ts');
+        (0, vitest_1.expect)(result.updated).toHaveLength(0);
+        (0, vitest_1.expect)(promises_1.writeFile).toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('updates existing files', async () => {
+        vitest_1.vi.mocked(promises_1.stat).mockResolvedValue({});
+        vitest_1.vi.mocked(promises_1.mkdir).mockResolvedValue(undefined);
+        vitest_1.vi.mocked(promises_1.writeFile).mockResolvedValue(undefined);
+        const files = [
+            {
+                filePath: 'src/index.ts',
+                content: 'console.log("updated");',
+                isBinary: false,
+                isTruncated: false,
+            },
+        ];
+        const result = await (0, apply_1.applyFiles)(files);
+        (0, vitest_1.expect)(result.updated).toHaveLength(1);
+        (0, vitest_1.expect)(result.created).toHaveLength(0);
+    });
+    (0, vitest_1.it)('skips binary files', async () => {
+        const files = [
+            {
+                filePath: 'image.png',
+                content: '// [BINARY FILE]',
+                isBinary: true,
+                isTruncated: false,
+            },
+        ];
+        const result = await (0, apply_1.applyFiles)(files);
+        (0, vitest_1.expect)(result.skipped).toHaveLength(1);
+        (0, vitest_1.expect)(result.skipped[0]).toContain('image.png');
+        (0, vitest_1.expect)(promises_1.writeFile).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('tracks truncated files', async () => {
+        vitest_1.vi.mocked(promises_1.stat).mockRejectedValue(new Error('Not found'));
+        vitest_1.vi.mocked(promises_1.mkdir).mockResolvedValue(undefined);
+        vitest_1.vi.mocked(promises_1.writeFile).mockResolvedValue(undefined);
+        const files = [
+            {
+                filePath: 'large.ts',
+                content: 'line1\n// ... (100 more lines truncated)',
+                isBinary: false,
+                isTruncated: true,
+            },
+        ];
+        const result = await (0, apply_1.applyFiles)(files);
+        (0, vitest_1.expect)(result.created).toHaveLength(1);
+    });
+    (0, vitest_1.it)('respects baseDir option', async () => {
+        vitest_1.vi.mocked(promises_1.stat).mockRejectedValue(new Error('Not found'));
+        vitest_1.vi.mocked(promises_1.mkdir).mockResolvedValue(undefined);
+        vitest_1.vi.mocked(promises_1.writeFile).mockResolvedValue(undefined);
+        const files = [
+            {
+                filePath: 'src/index.ts',
+                content: 'content',
+                isBinary: false,
+                isTruncated: false,
+            },
+        ];
+        await (0, apply_1.applyFiles)(files, '/custom/path');
+        (0, vitest_1.expect)(promises_1.mkdir).toHaveBeenCalledWith('/custom/path/src', { recursive: true });
+        (0, vitest_1.expect)(promises_1.writeFile).toHaveBeenCalledWith('/custom/path/src/index.ts', 'content', 'utf-8');
+    });
+    (0, vitest_1.it)('creates nested directories', async () => {
+        vitest_1.vi.mocked(promises_1.stat).mockRejectedValue(new Error('Not found'));
+        vitest_1.vi.mocked(promises_1.mkdir).mockResolvedValue(undefined);
+        vitest_1.vi.mocked(promises_1.writeFile).mockResolvedValue(undefined);
+        const files = [
+            {
+                filePath: 'src/deep/nested/file.ts',
+                content: 'content',
+                isBinary: false,
+                isTruncated: false,
+            },
+        ];
+        await (0, apply_1.applyFiles)(files);
+        (0, vitest_1.expect)(promises_1.mkdir).toHaveBeenCalledWith('src/deep/nested', { recursive: true });
+    });
+    (0, vitest_1.it)('handles multiple files with mixed states', async () => {
+        vitest_1.vi.mocked(promises_1.stat)
+            .mockRejectedValueOnce(new Error('Not found'))
+            .mockResolvedValueOnce({})
+            .mockRejectedValueOnce(new Error('Not found'));
+        vitest_1.vi.mocked(promises_1.mkdir).mockResolvedValue(undefined);
+        vitest_1.vi.mocked(promises_1.writeFile).mockResolvedValue(undefined);
+        const files = [
+            {
+                filePath: 'new.ts',
+                content: 'new',
+                isBinary: false,
+                isTruncated: false,
+            },
+            {
+                filePath: 'existing.ts',
+                content: 'updated',
+                isBinary: false,
+                isTruncated: false,
+            },
+            {
+                filePath: 'image.png',
+                content: '// [BINARY FILE]',
+                isBinary: true,
+                isTruncated: false,
+            },
+        ];
+        const result = await (0, apply_1.applyFiles)(files);
+        (0, vitest_1.expect)(result.created).toHaveLength(1);
+        (0, vitest_1.expect)(result.updated).toHaveLength(1);
+        (0, vitest_1.expect)(result.skipped).toHaveLength(1);
+    });
+});
+(0, vitest_1.describe)('applyFromFile', () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetAllMocks();
+    });
+    (0, vitest_1.it)('reads file and applies parsed content', async () => {
+        const inputContent = '```ts\n// test.ts\nconsole.log("test");\n```';
+        vitest_1.vi.mocked(promises_1.readFile).mockResolvedValue(inputContent);
+        vitest_1.vi.mocked(promises_1.stat).mockRejectedValue(new Error('Not found'));
+        vitest_1.vi.mocked(promises_1.mkdir).mockResolvedValue(undefined);
+        vitest_1.vi.mocked(promises_1.writeFile).mockResolvedValue(undefined);
+        const result = await (0, apply_1.applyFromFile)('input.md');
+        (0, vitest_1.expect)(result.parsed).toHaveLength(1);
+        (0, vitest_1.expect)(result.created).toHaveLength(1);
+        (0, vitest_1.expect)(promises_1.readFile).toHaveBeenCalledWith('input.md', 'utf-8');
+    });
+    (0, vitest_1.it)('passes baseDir to applyFiles', async () => {
+        const inputContent = '```ts\n// test.ts\ncontent\n```';
+        vitest_1.vi.mocked(promises_1.readFile).mockResolvedValue(inputContent);
+        vitest_1.vi.mocked(promises_1.stat).mockRejectedValue(new Error('Not found'));
+        vitest_1.vi.mocked(promises_1.mkdir).mockResolvedValue(undefined);
+        vitest_1.vi.mocked(promises_1.writeFile).mockResolvedValue(undefined);
+        await (0, apply_1.applyFromFile)('input.md', '/output');
+        (0, vitest_1.expect)(promises_1.mkdir).toHaveBeenCalledWith('/output', { recursive: true });
+    });
+});
+//# sourceMappingURL=apply.test.js.map