| | | 1 | | using System.Collections.Concurrent; |
| | | 2 | | |
| | | 3 | | namespace NexusLabs.Needlr.AgentFramework.Workspace; |
| | | 4 | | |
| | | 5 | | /// <summary> |
| | | 6 | | /// Thread-safe in-memory <see cref="IWorkspace"/> backed by a <see cref="ConcurrentDictionary{TKey, TValue}"/>. |
| | | 7 | | /// Suitable for testing, sandboxed agent runs, and scenarios where persistence is not needed. |
| | | 8 | | /// </summary> |
| | | 9 | | /// <remarks> |
| | | 10 | | /// <para> |
| | | 11 | | /// Marked <see cref="DoNotAutoRegisterAttribute"/> to prevent Needlr from registering it as a |
| | | 12 | | /// singleton — workspaces have per-orchestration lifecycle and must be explicitly constructed. |
| | | 13 | | /// </para> |
| | | 14 | | /// <para> |
| | | 15 | | /// Path canonicalization is delegated to <see cref="WorkspacePath.Canonicalize"/> and |
| | | 16 | | /// <see cref="WorkspacePath.CanonicalizeDirectory"/>; path equality uses |
| | | 17 | | /// <see cref="WorkspacePath.PathComparer"/>. See the <see cref="IWorkspace"/> remarks |
| | | 18 | | /// and <see cref="WorkspacePath"/> for the full contract. |
| | | 19 | | /// </para> |
| | | 20 | | /// </remarks> |
| | | 21 | | [DoNotAutoRegister] |
| | | 22 | | public sealed class InMemoryWorkspace : IWorkspace |
| | | 23 | | { |
| | 392 | 24 | | private readonly ConcurrentDictionary<string, string> _files = |
| | 392 | 25 | | new(WorkspacePath.PathComparer); |
| | | 26 | | |
| | | 27 | | /// <inheritdoc /> |
| | | 28 | | public WorkspaceResult<ReadFileResult> TryReadFile(string path) |
| | | 29 | | { |
| | 29 | 30 | | var normalized = WorkspacePath.Canonicalize(path); |
| | 25 | 31 | | return _files.TryGetValue(normalized, out var content) |
| | 25 | 32 | | ? WorkspaceResult<ReadFileResult>.Ok(new ReadFileResult(normalized, content)) |
| | 25 | 33 | | : WorkspaceResult<ReadFileResult>.Fail(new FileNotFoundException($"File not found: {normalized}", normalized |
| | | 34 | | } |
| | | 35 | | |
| | | 36 | | /// <inheritdoc /> |
| | | 37 | | public WorkspaceResult<WriteFileResult> TryWriteFile(string path, string content) |
| | | 38 | | { |
| | 146 | 39 | | var normalized = WorkspacePath.Canonicalize(path); |
| | 140 | 40 | | _files[normalized] = content; |
| | 140 | 41 | | return WorkspaceResult<WriteFileResult>.Ok(new WriteFileResult(normalized, content.Length)); |
| | | 42 | | } |
| | | 43 | | |
| | | 44 | | /// <inheritdoc /> |
| | | 45 | | public bool FileExists(string path) => |
| | 42 | 46 | | _files.ContainsKey(WorkspacePath.Canonicalize(path)); |
| | | 47 | | |
| | | 48 | | /// <inheritdoc /> |
| | | 49 | | public IEnumerable<string> GetFilePaths() => |
| | 6 | 50 | | _files.Keys; |
| | | 51 | | |
| | | 52 | | /// <inheritdoc /> |
| | | 53 | | public ReadOnlyMemory<char> ReadFileAsMemory(string path) |
| | | 54 | | { |
| | 4 | 55 | | var result = TryReadFile(path); |
| | 3 | 56 | | return result.Success |
| | 3 | 57 | | ? result.Value.Content.AsMemory() |
| | 3 | 58 | | : throw result.Exception!; |
| | | 59 | | } |
| | | 60 | | |
| | | 61 | | /// <inheritdoc /> |
| | | 62 | | public string ListDirectory(string directory, int maxDepth = 2) |
| | | 63 | | { |
| | 19 | 64 | | var root = WorkspacePath.CanonicalizeDirectory(directory); |
| | 18 | 65 | | var prefix = root.Length > 0 ? root + "/" : ""; |
| | | 66 | | |
| | 18 | 67 | | var entries = _files.Keys |
| | 42 | 68 | | .Where(k => prefix.Length == 0 || k.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)) |
| | 35 | 69 | | .Select(k => prefix.Length > 0 ? k[prefix.Length..] : k) |
| | 35 | 70 | | .OrderBy(k => k, WorkspacePath.PathComparer) |
| | 18 | 71 | | .ToList(); |
| | | 72 | | |
| | 18 | 73 | | if (entries.Count == 0) |
| | 1 | 74 | | return root.Length > 0 ? root + "/" : "./"; |
| | | 75 | | |
| | 17 | 76 | | var sb = new System.Text.StringBuilder(); |
| | 17 | 77 | | sb.AppendLine(root.Length > 0 ? root + "/" : "./"); |
| | | 78 | | |
| | 17 | 79 | | var tree = BuildTree(entries); |
| | 17 | 80 | | RenderTree(sb, tree, indent: "", maxDepth: maxDepth, currentDepth: 0); |
| | | 81 | | |
| | 17 | 82 | | return sb.ToString().TrimEnd(); |
| | | 83 | | } |
| | | 84 | | |
| | | 85 | | private static SortedDictionary<string, object?> BuildTree(List<string> paths) |
| | | 86 | | { |
| | 17 | 87 | | var root = new SortedDictionary<string, object?>(WorkspacePath.PathComparer); |
| | 104 | 88 | | foreach (var path in paths) |
| | | 89 | | { |
| | 35 | 90 | | var parts = path.Split('/'); |
| | 35 | 91 | | var current = root; |
| | 168 | 92 | | for (var i = 0; i < parts.Length; i++) |
| | | 93 | | { |
| | 49 | 94 | | var part = parts[i]; |
| | 49 | 95 | | if (i == parts.Length - 1) |
| | | 96 | | { |
| | 35 | 97 | | current.TryAdd(part, null); |
| | | 98 | | } |
| | | 99 | | else |
| | | 100 | | { |
| | 14 | 101 | | if (!current.TryGetValue(part, out var child) || child is not SortedDictionary<string, object?> dict |
| | | 102 | | { |
| | 12 | 103 | | dict = new SortedDictionary<string, object?>(WorkspacePath.PathComparer); |
| | 12 | 104 | | current[part] = dict; |
| | | 105 | | } |
| | 14 | 106 | | current = dict; |
| | | 107 | | } |
| | | 108 | | } |
| | | 109 | | } |
| | 17 | 110 | | return root; |
| | | 111 | | } |
| | | 112 | | |
| | | 113 | | private static void RenderTree( |
| | | 114 | | System.Text.StringBuilder sb, |
| | | 115 | | SortedDictionary<string, object?> node, |
| | | 116 | | string indent, |
| | | 117 | | int maxDepth, |
| | | 118 | | int currentDepth) |
| | | 119 | | { |
| | 27 | 120 | | if (currentDepth >= maxDepth) |
| | 2 | 121 | | return; |
| | | 122 | | |
| | 25 | 123 | | var entries = node.ToList(); |
| | 134 | 124 | | for (var i = 0; i < entries.Count; i++) |
| | | 125 | | { |
| | 42 | 126 | | var isLast = i == entries.Count - 1; |
| | 42 | 127 | | var connector = isLast ? "└── " : "├── "; |
| | 42 | 128 | | var childIndent = indent + (isLast ? " " : "│ "); |
| | | 129 | | |
| | 42 | 130 | | var (name, child) = entries[i]; |
| | 42 | 131 | | if (child is SortedDictionary<string, object?> dict) |
| | | 132 | | { |
| | 10 | 133 | | sb.AppendLine($"{indent}{connector}{name}/"); |
| | 10 | 134 | | RenderTree(sb, dict, childIndent, maxDepth, currentDepth + 1); |
| | | 135 | | } |
| | | 136 | | else |
| | | 137 | | { |
| | 32 | 138 | | sb.AppendLine($"{indent}{connector}{name}"); |
| | | 139 | | } |
| | | 140 | | } |
| | 25 | 141 | | } |
| | | 142 | | |
| | | 143 | | /// <inheritdoc /> |
| | | 144 | | public WorkspaceResult<CompareExchangeResult> TryCompareExchange(string path, string expectedContent, string newCont |
| | | 145 | | { |
| | 8 | 146 | | var normalized = WorkspacePath.Canonicalize(path); |
| | | 147 | | |
| | 7 | 148 | | if (!_files.TryGetValue(normalized, out var current)) |
| | 2 | 149 | | return WorkspaceResult<CompareExchangeResult>.Fail( |
| | 2 | 150 | | new FileNotFoundException($"File not found: {normalized}", normalized)); |
| | | 151 | | |
| | 5 | 152 | | if (!string.Equals(current, expectedContent, StringComparison.Ordinal)) |
| | 2 | 153 | | return WorkspaceResult<CompareExchangeResult>.Ok( |
| | 2 | 154 | | new CompareExchangeResult(false, "Content mismatch — file was modified since last read.")); |
| | | 155 | | |
| | 3 | 156 | | var exchanged = _files.TryUpdate(normalized, newContent, current); |
| | 3 | 157 | | return WorkspaceResult<CompareExchangeResult>.Ok( |
| | 3 | 158 | | new CompareExchangeResult(exchanged, exchanged ? null : "Concurrent modification during exchange.")); |
| | | 159 | | } |
| | | 160 | | |
| | | 161 | | /// <summary> |
| | | 162 | | /// Seeds the workspace with a file before agent execution begins. |
| | | 163 | | /// Convenience method for test setup and scenario harnesses. |
| | | 164 | | /// </summary> |
| | | 165 | | public void SeedFile(string path, string content) => |
| | 65 | 166 | | _files[WorkspacePath.Canonicalize(path)] = content; |
| | | 167 | | } |
| | | 168 | | |