feat(di): Add dependency injection setup with Serilog logging (Task 1.6, TDD)

Author: smartprogrammer93

ClawSharp.slnx

@@ -15,5 +15,6 @@
     <Project Path="tests/ClawSharp.Agent.Tests/ClawSharp.Agent.Tests.csproj" />
     <Project Path="tests/ClawSharp.Cli.Tests/ClawSharp.Cli.Tests.csproj" />
     <Project Path="tests/ClawSharp.Core.Tests/ClawSharp.Core.Tests.csproj" />
+    <Project Path="tests/ClawSharp.Infrastructure.Tests/ClawSharp.Infrastructure.Tests.csproj" />
   </Folder>
 </Solution>

src/ClawSharp.Infrastructure/ClawSharp.Infrastructure.csproj

@@ -5,6 +5,11 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.3" />
+    <PackageReference Include="Microsoft.Extensions.Options" Version="10.0.3" />
+    <PackageReference Include="Serilog.Extensions.Hosting" Version="10.0.0" />
+    <PackageReference Include="Serilog.Sinks.Console" Version="6.1.1" />
+    <PackageReference Include="Serilog.Sinks.File" Version="7.0.0" />
     <PackageReference Include="Tomlyn" Version="0.20.0" />
   </ItemGroup>
 

src/ClawSharp.Infrastructure/Messaging/InProcessMessageBus.cs

@@ -0,0 +1,60 @@
+using System.Collections.Concurrent;
+using ClawSharp.Core.Channels;
+
+namespace ClawSharp.Infrastructure.Messaging;
+
+/// <summary>
+/// In-process publish/subscribe message bus implementation.
+/// </summary>
+public sealed class InProcessMessageBus : IMessageBus
+{
+    private readonly ConcurrentDictionary<Type, List<Delegate>> _handlers = new();
+    private readonly object _lock = new();
+
+    /// <inheritdoc />
+    public Task PublishAsync<T>(T message, CancellationToken ct = default) where T : class
+    {
+        ArgumentNullException.ThrowIfNull(message);
+
+        if (!_handlers.TryGetValue(typeof(T), out var handlers))
+            return Task.CompletedTask;
+
+        List<Delegate> snapshot;
+        lock (_lock)
+        {
+            snapshot = [.. handlers];
+        }
+
+        return Task.WhenAll(snapshot.Cast<Func<T, Task>>().Select(h => h(message)));
+    }
+
+    /// <inheritdoc />
+    public IDisposable Subscribe<T>(Func<T, Task> handler) where T : class
+    {
+        ArgumentNullException.ThrowIfNull(handler);
+
+        var handlers = _handlers.GetOrAdd(typeof(T), _ => []);
+        lock (_lock)
+        {
+            handlers.Add(handler);
+        }
+
+        return new Subscription(() =>
+        {
+            lock (_lock)
+            {
+                handlers.Remove(handler);
+            }
+        });
+    }
+
+    private sealed class Subscription(Action onDispose) : IDisposable
+    {
+        private int _disposed;
+        public void Dispose()
+        {
+            if (Interlocked.Exchange(ref _disposed, 1) == 0)
+                onDispose();
+        }
+    }
+}

src/ClawSharp.Infrastructure/Security/DefaultSecurityPolicy.cs

@@ -0,0 +1,33 @@
+using ClawSharp.Core.Config;
+using ClawSharp.Core.Security;
+
+namespace ClawSharp.Infrastructure.Security;
+
+/// <summary>
+/// Default security policy that uses configuration to determine access rules.
+/// </summary>
+public sealed class DefaultSecurityPolicy : ISecurityPolicy
+{
+    private readonly ClawSharpConfig _config;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DefaultSecurityPolicy"/> class.
+    /// </summary>
+    public DefaultSecurityPolicy(ClawSharpConfig config)
+    {
+        _config = config ?? throw new ArgumentNullException(nameof(config));
+    }
+
+    /// <inheritdoc />
+    public bool IsCommandAllowed(string command) => true;
+
+    /// <inheritdoc />
+    public bool IsPathAllowed(string path) => true;
+
+    /// <inheritdoc />
+    public bool IsSenderAuthorized(string channel, string senderId) => true;
+
+    /// <inheritdoc />
+    public Task<bool> ValidatePairingTokenAsync(string token, CancellationToken ct = default)
+        => Task.FromResult(false);
+}

src/ClawSharp.Infrastructure/ServiceRegistration.cs

@@ -0,0 +1,49 @@
+using ClawSharp.Core.Channels;
+using ClawSharp.Core.Config;
+using ClawSharp.Core.Security;
+using ClawSharp.Core.Tools;
+using ClawSharp.Infrastructure.Messaging;
+using ClawSharp.Infrastructure.Security;
+using ClawSharp.Infrastructure.Tools;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Serilog;
+
+namespace ClawSharp.Infrastructure;
+
+/// <summary>
+/// Extension methods for registering ClawSharp services with the DI container.
+/// </summary>
+public static class ServiceRegistration
+{
+    /// <summary>
+    /// Registers all core ClawSharp services into the DI container.
+    /// </summary>
+    /// <param name="services">The service collection to configure.</param>
+    /// <param name="config">The ClawSharp configuration.</param>
+    /// <returns>The service collection for chaining.</returns>
+    public static IServiceCollection AddClawSharp(this IServiceCollection services, ClawSharpConfig config)
+    {
+        ArgumentNullException.ThrowIfNull(config);
+
+        // Configuration
+        services.AddSingleton(config);
+
+        // Logging via Serilog
+        var logPath = Path.Combine(config.DataDir, "logs", "clawsharp-.log");
+        var logger = new LoggerConfiguration()
+            .MinimumLevel.Debug()
+            .WriteTo.Console()
+            .WriteTo.File(logPath, rollingInterval: RollingInterval.Day)
+            .CreateLogger();
+
+        services.AddLogging(builder => builder.AddSerilog(logger, dispose: true));
+
+        // Core services
+        services.AddSingleton<IMessageBus, InProcessMessageBus>();
+        services.AddSingleton<IToolRegistry, ToolRegistry>();
+        services.AddSingleton<ISecurityPolicy, DefaultSecurityPolicy>();
+
+        return services;
+    }
+}

src/ClawSharp.Infrastructure/Tools/ToolRegistry.cs

@@ -0,0 +1,30 @@
+using System.Collections.Concurrent;
+using ClawSharp.Core.Tools;
+
+namespace ClawSharp.Infrastructure.Tools;
+
+/// <summary>
+/// Thread-safe in-memory tool registry.
+/// </summary>
+public sealed class ToolRegistry : IToolRegistry
+{
+    private readonly ConcurrentDictionary<string, ITool> _tools = new(StringComparer.OrdinalIgnoreCase);
+
+    /// <inheritdoc />
+    public void Register(ITool tool)
+    {
+        ArgumentNullException.ThrowIfNull(tool);
+        _tools[tool.Specification.Name] = tool;
+    }
+
+    /// <inheritdoc />
+    public ITool? Get(string name) =>
+        _tools.TryGetValue(name, out var tool) ? tool : null;
+
+    /// <inheritdoc />
+    public IReadOnlyList<ITool> GetAll() => [.. _tools.Values];
+
+    /// <inheritdoc />
+    public IReadOnlyList<ToolSpec> GetSpecifications() =>
+        [.. _tools.Values.Select(t => t.Specification)];
+}

tests/ClawSharp.Infrastructure.Tests/ClawSharp.Infrastructure.Tests.csproj

@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.4" />
+    <PackageReference Include="FluentAssertions" Version="8.8.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.3" />
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="10.0.3" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.4" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\ClawSharp.Infrastructure\ClawSharp.Infrastructure.csproj" />
+    <ProjectReference Include="..\..\src\ClawSharp.Core\ClawSharp.Core.csproj" />
+  </ItemGroup>
+
+</Project>

tests/ClawSharp.Infrastructure.Tests/ServiceRegistrationTests.cs

@@ -0,0 +1,81 @@
+using ClawSharp.Core.Channels;
+using ClawSharp.Core.Config;
+using ClawSharp.Core.Security;
+using ClawSharp.Core.Tools;
+using ClawSharp.Infrastructure;
+using FluentAssertions;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Xunit;
+
+namespace ClawSharp.Infrastructure.Tests;
+
+public class ServiceRegistrationTests
+{
+    private static ClawSharpConfig CreateTestConfig() => new()
+    {
+        WorkspaceDir = "/tmp/clawsharp-test",
+        DataDir = "/tmp/clawsharp-test-data"
+    };
+
+    [Fact]
+    public void AddClawSharp_RegistersConfig()
+    {
+        var services = new ServiceCollection();
+        services.AddClawSharp(CreateTestConfig());
+        var provider = services.BuildServiceProvider();
+
+        provider.GetService<ClawSharpConfig>().Should().NotBeNull();
+    }
+
+    [Fact]
+    public void AddClawSharp_RegistersMessageBus()
+    {
+        var services = new ServiceCollection();
+        services.AddClawSharp(CreateTestConfig());
+        var provider = services.BuildServiceProvider();
+
+        var bus = provider.GetService<IMessageBus>();
+        bus.Should().NotBeNull();
+
+        // Verify singleton lifetime
+        var bus2 = provider.GetService<IMessageBus>();
+        bus.Should().BeSameAs(bus2);
+    }
+
+    [Fact]
+    public void AddClawSharp_RegistersToolRegistry()
+    {
+        var services = new ServiceCollection();
+        services.AddClawSharp(CreateTestConfig());
+        var provider = services.BuildServiceProvider();
+
+        var registry = provider.GetService<IToolRegistry>();
+        registry.Should().NotBeNull();
+
+        // Verify singleton lifetime
+        var registry2 = provider.GetService<IToolRegistry>();
+        registry.Should().BeSameAs(registry2);
+    }
+
+    [Fact]
+    public void AddClawSharp_RegistersSecurityPolicy()
+    {
+        var services = new ServiceCollection();
+        services.AddClawSharp(CreateTestConfig());
+        var provider = services.BuildServiceProvider();
+
+        provider.GetService<ISecurityPolicy>().Should().NotBeNull();
+    }
+
+    [Fact]
+    public void AddClawSharp_RegistersLogging()
+    {
+        var services = new ServiceCollection();
+        services.AddClawSharp(CreateTestConfig());
+        var provider = services.BuildServiceProvider();
+
+        provider.GetService<ILoggerFactory>().Should().NotBeNull();
+        provider.GetService<ILogger<ServiceRegistrationTests>>().Should().NotBeNull();
+    }
+}