Add comprehensive tests for PathConfidenceScorer, PathEnumerator, ShellSymbolicExecutor, and SymbolicState

- Implemented unit tests for PathConfidenceScorer to evaluate path scoring under various conditions, including empty constraints, known and unknown constraints, environmental dependencies, and custom weights.
- Developed tests for PathEnumerator to ensure correct path enumeration from simple scripts, handling known environments, and respecting maximum paths and depth limits.
- Created tests for ShellSymbolicExecutor to validate execution of shell scripts, including handling of commands, branching, and environment tracking.
- Added tests for SymbolicState to verify state management, variable handling, constraint addition, and environment dependency collection.

src/AdvisoryAI/__Tests/StellaOps.AdvisoryAI.Tests/AdvisoryVectorRetrieverTests.cs

@@ -3,6 +3,7 @@ using StellaOps.AdvisoryAI.Abstractions;
 using StellaOps.AdvisoryAI.Chunking;
 using StellaOps.AdvisoryAI.Documents;
 using StellaOps.AdvisoryAI.Retrievers;
+using StellaOps.AdvisoryAI.Tests.TestUtilities;
 using StellaOps.AdvisoryAI.Vectorization;
 using Xunit;
 
@@ -40,7 +41,7 @@ public sealed class AdvisoryVectorRetrieverTests
                 new MarkdownDocumentChunker(),
             });
 
-        using var encoder = new DeterministicHashVectorEncoder();
+        var encoder = new DeterministicHashVectorEncoder(new TestCryptoHash());
         var vectorRetriever = new AdvisoryVectorRetriever(structuredRetriever, encoder);
 
         var matches = await vectorRetriever.SearchAsync(

src/AdvisoryAI/__Tests/StellaOps.AdvisoryAI.Tests/TestUtilities/TestCryptoHash.cs

@@ -0,0 +1,54 @@
+using System.Security.Cryptography;
+using StellaOps.Cryptography;
+
+namespace StellaOps.AdvisoryAI.Tests.TestUtilities;
+
+/// <summary>
+/// Simple test implementation of ICryptoHash using SHA-256.
+/// </summary>
+internal sealed class TestCryptoHash : ICryptoHash
+{
+    public byte[] ComputeHash(ReadOnlySpan<byte> data, string? algorithmId = null)
+        => SHA256.HashData(data);
+
+    public string ComputeHashHex(ReadOnlySpan<byte> data, string? algorithmId = null)
+        => Convert.ToHexString(ComputeHash(data, algorithmId)).ToLowerInvariant();
+
+    public string ComputeHashBase64(ReadOnlySpan<byte> data, string? algorithmId = null)
+        => Convert.ToBase64String(ComputeHash(data, algorithmId));
+
+    public async ValueTask<byte[]> ComputeHashAsync(Stream stream, string? algorithmId = null, CancellationToken cancellationToken = default)
+    {
+        using var sha = SHA256.Create();
+        return await sha.ComputeHashAsync(stream, cancellationToken).ConfigureAwait(false);
+    }
+
+    public async ValueTask<string> ComputeHashHexAsync(Stream stream, string? algorithmId = null, CancellationToken cancellationToken = default)
+    {
+        var hash = await ComputeHashAsync(stream, algorithmId, cancellationToken).ConfigureAwait(false);
+        return Convert.ToHexString(hash).ToLowerInvariant();
+    }
+
+    // Purpose-based methods (delegate to algorithm-based methods for test purposes)
+    public byte[] ComputeHashForPurpose(ReadOnlySpan<byte> data, string purpose)
+        => ComputeHash(data);
+
+    public string ComputeHashHexForPurpose(ReadOnlySpan<byte> data, string purpose)
+        => ComputeHashHex(data);
+
+    public string ComputeHashBase64ForPurpose(ReadOnlySpan<byte> data, string purpose)
+        => ComputeHashBase64(data);
+
+    public ValueTask<byte[]> ComputeHashForPurposeAsync(Stream stream, string purpose, CancellationToken cancellationToken = default)
+        => ComputeHashAsync(stream, null, cancellationToken);
+
+    public ValueTask<string> ComputeHashHexForPurposeAsync(Stream stream, string purpose, CancellationToken cancellationToken = default)
+        => ComputeHashHexAsync(stream, null, cancellationToken);
+
+    public string GetAlgorithmForPurpose(string purpose) => "SHA-256";
+
+    public string GetHashPrefix(string purpose) => "sha256:";
+
+    public string ComputePrefixedHashForPurpose(ReadOnlySpan<byte> data, string purpose)
+        => $"{GetHashPrefix(purpose)}{ComputeHashHex(data)}";
+}