Phase 0 completion: NT8 SDK core framework with risk management and position sizing

.kilocode/rules/CODE_STYLE_GUIDE.md

@@ -0,0 +1,273 @@
+# NT8 SDK Code Style Guide
+
+## Required Patterns for AI Agents
+
+### Class Declaration Pattern
+```csharp
+using System;
+using System.Collections.Generic;
+
+namespace NT8.Core.SomeModule
+{
+    /// <summary>
+    /// Class description
+    /// </summary>
+    public class ClassName
+    {
+        private readonly Type _field;
+        
+        /// <summary>
+        /// Property description
+        /// </summary>
+        public Type PropertyName { get; set; }
+        
+        /// <summary>
+        /// Constructor description
+        /// </summary>
+        public ClassName(Type parameter)
+        {
+            if (parameter == null) throw new ArgumentNullException("parameter");
+            _field = parameter;
+        }
+        
+        /// <summary>
+        /// Method description
+        /// </summary>
+        public ReturnType MethodName(Type parameter)
+        {
+            // Implementation
+        }
+    }
+}
+```
+
+### Interface Implementation Pattern
+```csharp
+/// <summary>
+/// Interface description
+/// </summary>
+public interface IInterfaceName
+{
+    /// <summary>
+    /// Method description
+    /// </summary>
+    ReturnType MethodName(Type parameter);
+}
+
+/// <summary>
+/// Implementation description
+/// </summary>
+public class Implementation : IInterfaceName
+{
+    public ReturnType MethodName(Type parameter)
+    {
+        // Implementation
+    }
+}
+```
+
+### Dictionary Initialization Pattern (C# 5.0)
+```csharp
+// ✅ REQUIRED Pattern
+var dictionary = new Dictionary<string, object>();
+dictionary.Add("key1", value1);
+dictionary.Add("key2", value2);
+
+// ❌ FORBIDDEN Pattern
+var dictionary = new Dictionary<string, object> 
+{
+    ["key1"] = value1,
+    ["key2"] = value2
+};
+```
+
+### String Formatting Pattern (C# 5.0)
+```csharp
+// ✅ REQUIRED Pattern
+var message = String.Format("Processing {0} with value {1:F2}", name, amount);
+_logger.LogInformation("Order {0} status: {1}", orderId, status);
+
+// ❌ FORBIDDEN Pattern
+var message = $"Processing {name} with value {amount:F2}";
+_logger.LogInformation($"Order {orderId} status: {status}");
+```
+
+### Async Method Pattern (C# 5.0)
+```csharp
+/// <summary>
+/// Async method description
+/// </summary>
+public async Task<ReturnType> MethodNameAsync(Type parameter)
+{
+    // Async implementation
+    var result = await SomeAsyncOperation();
+    return result;
+}
+```
+
+### Error Handling Pattern
+```csharp
+public ReturnType MethodName(Type parameter)
+{
+    if (parameter == null) throw new ArgumentNullException("parameter");
+    
+    try
+    {
+        // Implementation
+        return result;
+    }
+    catch (SpecificException ex)
+    {
+        _logger.LogError("Specific error occurred: {0}", ex.Message);
+        throw; // or handle appropriately
+    }
+    catch (Exception ex)
+    {
+        _logger.LogError("Unexpected error: {0}", ex.Message);
+        throw;
+    }
+}
+```
+
+### Test Class Pattern (MSTest)
+```csharp
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NT8.Core.SomeModule;
+
+namespace NT8.Core.Tests.SomeModule
+{
+    [TestClass]
+    public class ClassNameTests
+    {
+        private ClassName _target;
+        
+        [TestInitialize]
+        public void TestInitialize()
+        {
+            _target = new ClassName(/* parameters */);
+        }
+        
+        [TestMethod]
+        public void MethodName_Condition_ExpectedResult()
+        {
+            // Arrange
+            var input = /* test data */;
+            
+            // Act
+            var result = _target.MethodName(input);
+            
+            // Assert
+            Assert.IsTrue(result.Success);
+            Assert.AreEqual(expected, result.Value);
+        }
+        
+        [TestMethod]
+        public void MethodName_InvalidInput_ThrowsException()
+        {
+            // Act & Assert
+            Assert.ThrowsException<ArgumentNullException>(() => _target.MethodName(null));
+        }
+    }
+}
+```
+
+### Configuration Class Pattern
+```csharp
+/// <summary>
+/// Configuration class description
+/// </summary>
+public class ConfigurationClass
+{
+    /// <summary>
+    /// Property description
+    /// </summary>
+    public Type PropertyName { get; set; }
+    
+    /// <summary>
+    /// Constructor with all required parameters
+    /// </summary>
+    public ConfigurationClass(Type parameter1, Type parameter2)
+    {
+        PropertyName1 = parameter1;
+        PropertyName2 = parameter2;
+    }
+}
+```
+
+### Enum Pattern
+```csharp
+/// <summary>
+/// Enum description
+/// </summary>
+public enum EnumName
+{
+    /// <summary>
+    /// First value description
+    /// </summary>
+    FirstValue,
+    
+    /// <summary>
+    /// Second value description
+    /// </summary>
+    SecondValue
+}
+```
+
+## Naming Conventions
+
+### Classes and Interfaces
+- **Classes**: PascalCase (`RiskManager`, `PositionSizer`)
+- **Interfaces**: IPascalCase (`IRiskManager`, `IPositionSizer`)
+
+### Methods and Properties
+- **Methods**: PascalCase (`ValidateOrder`, `CalculateSize`)
+- **Properties**: PascalCase (`Symbol`, `Quantity`)
+
+### Fields and Variables
+- **Private fields**: _camelCase (`_logger`, `_riskConfig`)
+- **Local variables**: camelCase (`riskAmount`, `contracts`)
+- **Constants**: UPPER_CASE (`MAX_CONTRACTS`, `DEFAULT_TIMEOUT`)
+
+### Parameters
+- **Parameters**: camelCase (`intent`, `context`, `config`)
+
+## File Organization
+
+### Using Statements Order
+```csharp
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using NT8.Core.Common.Models;
+using NT8.Core.Logging;
+```
+
+### Namespace and Class Structure
+```csharp
+namespace NT8.Core.ModuleName
+{
+    /// <summary>
+    /// Class documentation
+    /// </summary>
+    public class ClassName
+    {
+        // 1. Private fields
+        private readonly Type _field;
+        
+        // 2. Public properties
+        public Type Property { get; set; }
+        
+        // 3. Constructor(s)
+        public ClassName() { }
+        
+        // 4. Public methods
+        public void PublicMethod() { }
+        
+        // 5. Private methods
+        private void PrivateMethod() { }
+    }
+}
+```
+
+These patterns MUST be followed by all AI agents to ensure consistency and compatibility.