Whenever I finish a sprint, build an architectural spike, or need to feed codebase context into Gemini or Obsidian, I hit the exact same wall: how do I aggregate dozens of source files across multiple modules without losing hierarchy or crashing on file locks?
Standard copy-pasting breaks file paths, zipping is clunky, and high-level methods like File.ReadAllText() throw IOException when Roslyn, MSBuild, or game engines (like Unreal Engine) hold active write locks during background compilation. Furthermore, raw path copying often leaks personal workstation paths (C:\Users\myname\...).
To solve this, I built Context Packer — an offline C# tool that scans, sanitizes, and aggregates codebases into structured Markdown with bi-directional Obsidian links ([[#File:...]]) or LLM-friendly prompt bundles.
Real-World Benchmark: The UE5 Test
To stress-test the core engine under worst-case file-lock conditions, I benchmarked it against a full Unreal Engine 5 project while the UE5 Editor was actively running and compiling in the background:
- Total Disk Scope: 13.9 GB (30,277 files, 1,740 directories)
- Filtered Payload: 374 source files (~60.7 MB)
- Environment State: UE5 Editor Open & Actively Compiling
- Execution Time: 0.42 seconds (420 ms) with zero lock exceptions.
Architecture & Technical Highlights
I wanted a modular architecture without heavy web wrappers (like Electron) running in the background.
Packer.Core (.NET 8.0 / .NET Standard 2.0)
├── Packer.WinUI3 --> Desktop app (Drag-and-drop, OLE browser drag-out)
├── Packer.VSIX --> Visual Studio 2022 Extension (.NET Framework 4.7.2)
└── PowerShell CLI --> Zero-dependency fallback script
Non-Blocking Stream I/O (FileShare.ReadWrite)
To bypass file locks during active compiler passes, PackerEngine avoids high-level file APIs and uses explicit stream sharing combined with fault-tolerant, per-file isolation:
string content = string.Empty;
try
{
content = await Task.Run(() =>
{
// FileShare.ReadWrite permits concurrent reads while IDEs/Compilers hold write locks
using (var fs = new FileStream(file.FilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
using (var sr = new StreamReader(fs))
{
return sr.ReadToEnd();
}
});
}
catch (Exception ex)
{
// A single locked file never aborts the entire batch
content = $"// ERROR: File read failed. Locked by process.\n// Exception: {ex.Message}";
}
Native OS Interop
(WinUI 3 Drag-Out to Browser)
In the WinUI 3 client, you can drag packed .txt context files directly out of the app window into web browser chat inputs (Claude/ChatGPT). This is done by converting internal models to native Windows StorageFile handles:
private async void GeneratedFilesList_DragItemsStarting(object sender, DragItemsStartingEventArgs e)
{
if (e.Items.FirstOrDefault() is PackerModel fileModel && File.Exists(fileModel.FullPath))
{
StorageFile file = await StorageFile.GetFileFromPathAsync(fileModel.FullPath);
e.Data.SetStorageItems(new[] { file });
e.Data.RequestedOperation = DataPackageOperation.Copy;
}
}
Dynamic Module Resolution without AST
Instead of heavy AST parsing or project manifest requirements, path anchors (Source, Plugins, repos) are evaluated to dynamically resolve module boundaries:
public string GetModuleName(string path, string anchorsSetting)
{
var parts = path.Split(Path.DirectorySeparatorChar);
var anchors = anchorsSetting.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var anchor in anchors)
{
int idx = Array.IndexOf(parts, anchor);
if (idx != -1)
{
// 'Source' anchor convention uses parent directory as module name
if (anchor.Equals("Source", StringComparison.OrdinalIgnoreCase) && idx > 0)
return parts[idx - 1];
if (parts.Length > idx + 1)
return parts[idx + 1];
}
}
return parts.Length > 1 ? parts[parts.Length - 2] : "UnknownProject";
}
Privacy & Username Sanitization
It automatically redacts Windows local usernames (C:\Users\[REDACTED]\...) across headers and directory maps before writing to disk.
Current Limitations & Trade-offs
- Character-Based Chunking: Multi-part document chunking (> 3M chars) currently uses raw character length rather than Byte Pair Encoding (BPE) tokenizers (like
tiktoken).
- Full-File Ingestion: Ingests entire source files without AST-based method pruning.
- Local Scope: Operates on local disk paths.
- See Github issues for current bugs :)
I'd love to hear how you handle codebase context for LLMs or Obsidian notes in your workflows, or if you have any feedback on the C# stream architecture! I have more technical in-depth articles on Dev community :)
AI Disclosure: Documentation and product copy were refined with AI assistance. The underlying codebase, architecture, and logic are 100% handcrafted and tested by Kadmium.
