From c92b2910ef68c83111d977c64e51ee677054bd1f Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 29 Jan 2026 01:27:49 +0000
Subject: [PATCH 1/3] Initial plan


From bcdfebcbf37ffc1c9a19f002cb36e1f2e69da231 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 29 Jan 2026 01:31:08 +0000
Subject: [PATCH 2/3] Create comprehensive documentation files
 (getting-started.md, introduction.md, readme.md, setup.md)

Co-authored-by: Chris-Wolfgang <210299580+Chris-Wolfgang@users.noreply.github.com>
---
 docs/getting-started.md | 191 +++++++++++++++++++++
 docs/introduction.md    |  82 +++++++++
 docs/readme.md          | 250 ++++++++++++++++++++++++++++
 docs/setup.md           | 357 ++++++++++++++++++++++++++++++++++++++++
 4 files changed, 880 insertions(+)
 create mode 100644 docs/getting-started.md
 create mode 100644 docs/introduction.md
 create mode 100644 docs/readme.md
 create mode 100644 docs/setup.md

diff --git a/docs/getting-started.md b/docs/getting-started.md
new file mode 100644
index 0000000..44c563a
--- /dev/null
+++ b/docs/getting-started.md
@@ -0,0 +1,191 @@
+# Getting Started
+
+This guide will help you quickly start using Wolfgang.Extensions.IComparable in your .NET projects.
+
+## Prerequisites
+
+- .NET 8.0 or later
+- A C# project (any project type: console, web, library, etc.)
+
+## Installation
+
+### Using NuGet Package Manager
+
+```bash
+dotnet add package Wolfgang.Extensions.IComparable
+```
+
+### Using Package Manager Console (Visual Studio)
+
+```powershell
+Install-Package Wolfgang.Extensions.IComparable
+```
+
+### Using .csproj File
+
+Add the following package reference to your `.csproj` file:
+
+```xml
+<ItemGroup>
+  <PackageReference Include="Wolfgang.Extensions.IComparable" Version="*" />
+</ItemGroup>
+```
+
+## Basic Usage
+
+### 1. Add the Using Directive
+
+Add the namespace to your C# file:
+
+```csharp
+using Wolfgang.Extensions.IComparable;
+```
+
+### 2. Use IsBetween Method
+
+Check if a value is strictly between two bounds (exclusive):
+
+```csharp
+int temperature = 25;
+
+if (temperature.IsBetween(0, 30))
+{
+    Console.WriteLine("Temperature is between 0 and 30 (exclusive)");
+}
+```
+
+**Example Results:**
+- `5.IsBetween(1, 10)` → `true` (5 is greater than 1 and less than 10)
+- `1.IsBetween(1, 10)` → `false` (1 is not greater than 1)
+- `10.IsBetween(1, 10)` → `false` (10 is not less than 10)
+
+### 3. Use IsInRange Method
+
+Check if a value is within a range (inclusive):
+
+```csharp
+int score = 85;
+
+if (score.IsInRange(0, 100))
+{
+    Console.WriteLine("Score is within the valid range of 0-100");
+}
+```
+
+**Example Results:**
+- `5.IsInRange(1, 10)` → `true` (5 is between 1 and 10)
+- `1.IsInRange(1, 10)` → `true` (1 equals the lower bound)
+- `10.IsInRange(1, 10)` → `true` (10 equals the upper bound)
+
+## Common Examples
+
+### Validating User Input
+
+```csharp
+int age = GetUserAge();
+
+if (age.IsInRange(0, 120))
+{
+    Console.WriteLine("Valid age entered");
+}
+else
+{
+    Console.WriteLine("Age must be between 0 and 120");
+}
+```
+
+### Working with Decimals
+
+```csharp
+decimal price = 49.99m;
+
+if (price.IsBetween(0m, 100m))
+{
+    Console.WriteLine("Price is in the medium range");
+}
+```
+
+### Working with Dates
+
+```csharp
+DateTime checkDate = DateTime.Now;
+DateTime startDate = new DateTime(2024, 1, 1);
+DateTime endDate = new DateTime(2024, 12, 31);
+
+if (checkDate.IsInRange(startDate, endDate))
+{
+    Console.WriteLine("Date falls within 2024");
+}
+```
+
+### Working with Strings
+
+```csharp
+string value = "M";
+
+// String comparison is alphabetical
+if (value.IsBetween("A", "Z"))
+{
+    Console.WriteLine("Value is between A and Z (exclusive)");
+}
+```
+
+### Working with Custom Types
+
+```csharp
+public class Employee : IComparable<Employee>
+{
+    public string Name { get; set; }
+    public decimal Salary { get; set; }
+    
+    public int CompareTo(Employee other)
+    {
+        return Salary.CompareTo(other.Salary);
+    }
+}
+
+var employee = new Employee { Name = "John", Salary = 50000 };
+var minSalary = new Employee { Salary = 30000 };
+var maxSalary = new Employee { Salary = 100000 };
+
+if (employee.IsInRange(minSalary, maxSalary))
+{
+    Console.WriteLine("Employee salary is within the expected range");
+}
+```
+
+## Quick Reference
+
+| Method | Comparison Type | Lower Bound | Upper Bound | Example |
+|--------|----------------|-------------|-------------|---------|
+| `IsBetween` | Exclusive | `>` | `<` | `5.IsBetween(1, 10)` → `true` |
+| `IsInRange` | Inclusive | `>=` | `<=` | `1.IsInRange(1, 10)` → `true` |
+
+## Next Steps
+
+- Explore more [advanced usage examples](./readme.md)
+- Learn about [setting up your development environment](./setup.md)
+- Read the full [introduction](./introduction.md) to understand the library's design
+
+## Troubleshooting
+
+### Namespace Not Found
+
+If you get a compile error that the namespace cannot be found:
+1. Ensure the package is properly installed (`dotnet restore`)
+2. Verify you're using .NET 8.0 or later
+3. Check that your IDE has indexed the new package (restart if necessary)
+
+### Method Not Available
+
+If the extension methods don't appear:
+1. Ensure you've added the `using Wolfgang.Extensions.IComparable;` directive
+2. Verify your type implements `IComparable<T>`
+3. Check that IntelliSense has refreshed (rebuild the solution)
+
+## Getting Help
+
+If you encounter any issues:
+- Check the [GitHub Issues](https://github.com/Chris-Wolfgang/IComparable-Extensions/issues)
+- Review the [examples](../examples/) in the repository
+- Read the [API documentation](../README.md)
diff --git a/docs/introduction.md b/docs/introduction.md
new file mode 100644
index 0000000..9e522d3
--- /dev/null
+++ b/docs/introduction.md
@@ -0,0 +1,82 @@
+# Introduction
+
+## Overview
+
+**Wolfgang.Extensions.IComparable** is a lightweight .NET library that provides powerful extension methods for types implementing the `IComparable<T>` interface. This library simplifies common comparison operations, making your code more readable and expressive.
+
+## What is IComparable?
+
+The `IComparable<T>` interface is a fundamental part of .NET that allows objects to be compared for ordering purposes. Types that implement this interface can be sorted and compared using standardized methods.
+
+## Why Use This Library?
+
+When working with comparable types in C#, you often need to check if a value falls within a specific range. Without this library, such checks can be verbose and error-prone:
+
+```csharp
+// Without Wolfgang.Extensions.IComparable
+if (value.CompareTo(min) >= 0 && value.CompareTo(max) <= 0)
+{
+    // Value is in range
+}
+
+// With Wolfgang.Extensions.IComparable
+if (value.IsInRange(min, max))
+{
+    // Value is in range - much clearer!
+}
+```
+
+## Key Features
+
+- **Intuitive API**: Extension methods that read like natural language
+- **Type-Safe**: Works with any type that implements `IComparable<T>`
+- **Zero Dependencies**: Lightweight library with no external dependencies
+- **Well-Tested**: Comprehensive test coverage to ensure reliability
+- **Performance-Optimized**: Minimal overhead compared to manual comparison operations
+
+## Available Extension Methods
+
+### IsBetween
+
+Determines if a value is **strictly between** two bounds (exclusive comparison):
+
+```csharp
+int value = 5;
+bool result = value.IsBetween(1, 10); // true (5 > 1 AND 5 < 10)
+```
+
+### IsInRange
+
+Determines if a value is **within the range** of two bounds (inclusive comparison):
+
+```csharp
+int value = 5;
+bool result = value.IsInRange(5, 10); // true (5 >= 5 AND 5 <= 10)
+```
+
+## Use Cases
+
+This library is particularly useful in scenarios such as:
+
+- **Validation**: Checking if user input falls within acceptable ranges
+- **Business Logic**: Implementing rules that depend on value ranges
+- **Data Processing**: Filtering or categorizing data based on value ranges
+- **Game Development**: Checking bounds for positions, scores, or other metrics
+- **Financial Applications**: Validating amounts, dates, or other comparable values
+
+## Supported Types
+
+Any type that implements `IComparable<T>` can use these extension methods, including:
+
+- Numeric types: `int`, `double`, `decimal`, `float`, etc.
+- Date and time types: `DateTime`, `DateTimeOffset`, `TimeSpan`
+- String comparisons
+- Custom types that implement `IComparable<T>`
+
+## License
+
+This project is licensed under the Mozilla Public License 2.0. See the [LICENSE](../LICENSE) file for details.
+
+## Contributing
+
+We welcome contributions! Please see our [CONTRIBUTING.md](../CONTRIBUTING.md) guide for more information.
diff --git a/docs/readme.md b/docs/readme.md
new file mode 100644
index 0000000..ef0ce7b
--- /dev/null
+++ b/docs/readme.md
@@ -0,0 +1,250 @@
+# Wolfgang.Extensions.IComparable
+
+A powerful and intuitive .NET library that extends the `IComparable<T>` interface with convenient range-checking methods.
+
+## What Does It Do?
+
+This library provides two essential extension methods that make range comparisons simple and readable:
+
+### IsBetween (Exclusive Range)
+
+Returns `true` when a value is **strictly greater than** the lower bound AND **strictly less than** the upper bound.
+
+```csharp
+5.IsBetween(1, 10)  // true  (5 > 1 AND 5 < 10)
+1.IsBetween(1, 10)  // false (1 is not > 1)
+10.IsBetween(1, 10) // false (10 is not < 10)
+```
+
+### IsInRange (Inclusive Range)
+
+Returns `true` when a value is **greater than or equal to** the lower bound AND **less than or equal to** the upper bound.
+
+```csharp
+5.IsInRange(1, 10)  // true (5 >= 1 AND 5 <= 10)
+1.IsInRange(1, 10)  // true (1 >= 1 AND 1 <= 10)
+10.IsInRange(1, 10) // true (10 >= 1 AND 10 <= 10)
+```
+
+## Installation
+
+Install via NuGet:
+
+```bash
+dotnet add package Wolfgang.Extensions.IComparable
+```
+
+## Quick Start
+
+```csharp
+using Wolfgang.Extensions.IComparable;
+
+// Check if a number is in a valid range
+int temperature = 22;
+if (temperature.IsInRange(18, 26))
+{
+    Console.WriteLine("Temperature is comfortable");
+}
+
+// Check if a date is between two dates (exclusive)
+DateTime today = DateTime.Now;
+DateTime start = new DateTime(2024, 1, 1);
+DateTime end = new DateTime(2024, 12, 31);
+
+if (today.IsBetween(start, end))
+{
+    Console.WriteLine("Date is within 2024 (exclusive of boundaries)");
+}
+```
+
+## Detailed Examples
+
+### Numeric Validation
+
+```csharp
+// Age validation
+int age = 25;
+bool isAdult = age.IsInRange(18, 120);
+
+// Percentage validation
+decimal percentage = 85.5m;
+bool isValidPercentage = percentage.IsInRange(0m, 100m);
+
+// Temperature monitoring
+double temp = 98.6;
+bool hasFeaver = temp.IsBetween(98.6, 103.0); // false (not > 98.6)
+```
+
+### String Comparisons
+
+```csharp
+string grade = "B";
+
+// Check if grade is between A and C (alphabetically)
+bool isPassing = grade.IsInRange("A", "D"); // true
+
+// Check for specific range (exclusive)
+bool isBetweenAandC = grade.IsBetween("A", "C"); // true (B is after A and before C)
+```
+
+### DateTime Operations
+
+```csharp
+DateTime appointmentTime = new DateTime(2024, 6, 15, 14, 30, 0);
+DateTime officeOpen = new DateTime(2024, 6, 15, 9, 0, 0);
+DateTime officeClosed = new DateTime(2024, 6, 15, 17, 0, 0);
+
+// Check if appointment is during business hours
+bool isDuringBusinessHours = appointmentTime.IsInRange(officeOpen, officeClosed);
+
+// Check if time is strictly between opening and closing
+bool isNotAtBoundary = appointmentTime.IsBetween(officeOpen, officeClosed);
+```
+
+### Custom Types
+
+Any type implementing `IComparable<T>` works automatically:
+
+```csharp
+public class Version : IComparable<Version>
+{
+    public int Major { get; set; }
+    public int Minor { get; set; }
+    
+    public int CompareTo(Version other)
+    {
+        int result = Major.CompareTo(other.Major);
+        return result != 0 ? result : Minor.CompareTo(other.Minor);
+    }
+}
+
+var currentVersion = new Version { Major = 2, Minor = 5 };
+var minVersion = new Version { Major = 2, Minor = 0 };
+var maxVersion = new Version { Major = 3, Minor = 0 };
+
+bool isSupported = currentVersion.IsInRange(minVersion, maxVersion);
+```
+
+## Real-World Use Cases
+
+### Input Validation
+
+```csharp
+public bool ValidateInput(int value)
+{
+    const int MIN_VALUE = 1;
+    const int MAX_VALUE = 100;
+    
+    return value.IsInRange(MIN_VALUE, MAX_VALUE);
+}
+```
+
+### Business Hours Checker
+
+```csharp
+public bool IsWithinBusinessHours(DateTime timestamp)
+{
+    var openTime = new TimeSpan(9, 0, 0);   // 9:00 AM
+    var closeTime = new TimeSpan(17, 0, 0); // 5:00 PM
+    
+    return timestamp.TimeOfDay.IsInRange(openTime, closeTime);
+}
+```
+
+### Price Range Filtering
+
+```csharp
+public List<Product> FilterByPriceRange(List<Product> products, decimal min, decimal max)
+{
+    return products.Where(p => p.Price.IsInRange(min, max)).ToList();
+}
+```
+
+### Game Development - Boundary Checking
+
+```csharp
+public class GameCharacter
+{
+    public bool IsInPlayArea(float x, float y)
+    {
+        const float MIN_X = 0f;
+        const float MAX_X = 100f;
+        const float MIN_Y = 0f;
+        const float MAX_Y = 100f;
+        
+        return x.IsInRange(MIN_X, MAX_X) && y.IsInRange(MIN_Y, MAX_Y);
+    }
+}
+```
+
+## API Reference
+
+### IsBetween&lt;T&gt;
+
+```csharp
+public static bool IsBetween<T>(this T value, T lowerBound, T upperBound) 
+    where T : IComparable<T>
+```
+
+**Parameters:**
+- `value`: The value to compare
+- `lowerBound`: The lower end of the range (exclusive)
+- `upperBound`: The upper end of the range (exclusive)
+
+**Returns:** `true` if `value > lowerBound AND value < upperBound`, otherwise `false`
+
+### IsInRange&lt;T&gt;
+
+```csharp
+public static bool IsInRange<T>(this T value, T lowerBound, T upperBound) 
+    where T : IComparable<T>
+```
+
+**Parameters:**
+- `value`: The value to compare
+- `lowerBound`: The lower end of the range (inclusive)
+- `upperBound`: The upper end of the range (inclusive)
+
+**Returns:** `true` if `value >= lowerBound AND value <= upperBound`, otherwise `false`
+
+## Performance
+
+Both methods are lightweight wrappers around the `CompareTo` method with minimal overhead:
+
+- **IsBetween**: 2 comparison operations
+- **IsInRange**: 2 comparison operations
+
+Performance is equivalent to writing the comparisons manually but with significantly improved readability.
+
+## Requirements
+
+- .NET 8.0 or later
+- Any C# project type (console, web, library, etc.)
+
+## Documentation
+
+- [Introduction](./introduction.md) - Learn about the library and its benefits
+- [Getting Started](./getting-started.md) - Installation and basic usage
+- [Setup Guide](./setup.md) - Development environment setup
+
+## Contributing
+
+Contributions are welcome! Please read our [Contributing Guidelines](../CONTRIBUTING.md) before submitting pull requests.
+
+## Code of Conduct
+
+This project follows the [Contributor Covenant Code of Conduct](../CODE_OF_CONDUCT.md). Please be respectful and constructive in all interactions.
+
+## License
+
+This project is licensed under the [Mozilla Public License 2.0](../LICENSE).
+
+## Support
+
+- Report bugs or request features via [GitHub Issues](https://github.com/Chris-Wolfgang/IComparable-Extensions/issues)
+- View examples in the [examples folder](../examples/)
+- Check out the full source code on [GitHub](https://github.com/Chris-Wolfgang/IComparable-Extensions)
+
+## Acknowledgments
+
+Built with ❤️ by the Wolfgang Extensions team.
diff --git a/docs/setup.md b/docs/setup.md
new file mode 100644
index 0000000..52332c3
--- /dev/null
+++ b/docs/setup.md
@@ -0,0 +1,357 @@
+# Development Setup Guide
+
+This guide will help you set up your development environment to contribute to Wolfgang.Extensions.IComparable.
+
+## Prerequisites
+
+Before you begin, ensure you have the following installed:
+
+### Required Software
+
+1. **.NET 8.0 SDK** or later
+   - Download from [dotnet.microsoft.com](https://dotnet.microsoft.com/download)
+   - Verify installation: `dotnet --version`
+
+2. **Git**
+   - Download from [git-scm.com](https://git-scm.com/)
+   - Verify installation: `git --version`
+
+3. **A Code Editor** (choose one):
+   - [Visual Studio 2022](https://visualstudio.microsoft.com/) (Community, Professional, or Enterprise)
+   - [Visual Studio Code](https://code.visualstudio.com/) with C# extension
+   - [JetBrains Rider](https://www.jetbrains.com/rider/)
+
+### Recommended Tools
+
+1. **ReportGenerator** (for code coverage reports)
+   ```bash
+   dotnet tool install -g dotnet-reportgenerator-globaltool
+   ```
+
+2. **DevSkim CLI** (for security scanning)
+   ```bash
+   dotnet tool install --global Microsoft.CST.DevSkim.CLI
+   ```
+
+## Getting the Source Code
+
+### 1. Fork the Repository
+
+1. Navigate to [https://github.com/Chris-Wolfgang/IComparable-Extensions](https://github.com/Chris-Wolfgang/IComparable-Extensions)
+2. Click the **Fork** button in the upper right
+3. Select your GitHub account as the destination
+
+### 2. Clone Your Fork
+
+```bash
+# Clone your fork
+git clone https://github.com/YOUR-USERNAME/IComparable-Extensions.git
+
+# Navigate to the repository
+cd IComparable-Extensions
+
+# Add upstream remote
+git remote add upstream https://github.com/Chris-Wolfgang/IComparable-Extensions.git
+```
+
+### 3. Verify Your Setup
+
+```bash
+# Check remotes
+git remote -v
+
+# Should show:
+# origin    https://github.com/YOUR-USERNAME/IComparable-Extensions.git (fetch)
+# origin    https://github.com/YOUR-USERNAME/IComparable-Extensions.git (push)
+# upstream  https://github.com/Chris-Wolfgang/IComparable-Extensions.git (fetch)
+# upstream  https://github.com/Chris-Wolfgang/IComparable-Extensions.git (push)
+```
+
+## Building the Project
+
+### 1. Restore Dependencies
+
+```bash
+dotnet restore
+```
+
+### 2. Build the Solution
+
+```bash
+# Build in Debug mode
+dotnet build
+
+# Build in Release mode (recommended for testing)
+dotnet build --configuration Release
+```
+
+Expected output:
+```
+Build succeeded.
+    0 Warning(s)
+    0 Error(s)
+```
+
+## Running Tests
+
+### Run All Tests
+
+```bash
+dotnet test --configuration Release
+```
+
+### Run Tests with Code Coverage
+
+```bash
+# Run tests and collect coverage
+dotnet test --configuration Release --collect:"XPlat Code Coverage" --results-directory "./TestResults"
+
+# Generate coverage report (if ReportGenerator is installed)
+reportgenerator -reports:"TestResults/**/coverage.cobertura.xml" \
+                -targetdir:"CoverageReport" \
+                -reporttypes:"Html;TextSummary"
+
+# View the report
+# Open CoverageReport/index.html in your browser
+```
+
+### Run Specific Test Projects
+
+```bash
+# Run only unit tests
+dotnet test tests/Wolfgang.Extensions.IComparable.Tests/Wolfgang.Extensions.IComparable.Tests.csproj
+```
+
+## Code Quality Checks
+
+### Run Security Scanning
+
+```bash
+# Run DevSkim security analysis
+devskim analyze --source-code . -f text --output-file devskim-results.txt
+
+# View results
+cat devskim-results.txt
+```
+
+### Check Code Style
+
+The project uses `.editorconfig` for consistent code style. Most IDEs will automatically apply these rules.
+
+To manually check:
+```bash
+# Format code
+dotnet format
+
+# Verify formatting
+dotnet format --verify-no-changes
+```
+
+## Running Benchmarks
+
+If you're working on performance improvements:
+
+```bash
+# Navigate to benchmarks
+cd benchmarks
+
+# Run benchmarks
+dotnet run --configuration Release
+```
+
+## Project Structure
+
+```
+IComparable-Extensions/
+├── src/
+│   └── Wolfgang.Extensions.IComparable/
+│       ├── Wolfgang.Extensions.IComparable.csproj
+│       └── IComparableExtensions.cs
+├── tests/
+│   └── Wolfgang.Extensions.IComparable.Tests/
+│       ├── Wolfgang.Extensions.IComparable.Tests.csproj
+│       └── IComparableExtensionsTests.cs
+├── benchmarks/
+│   └── (Benchmark projects)
+├── examples/
+│   └── (Example projects)
+├── docs/
+│   ├── introduction.md
+│   ├── getting-started.md
+│   ├── readme.md
+│   └── setup.md
+├── .github/
+│   └── workflows/
+│       └── pr.yaml (CI/CD pipeline)
+├── .editorconfig (Code style rules)
+├── .gitignore
+├── IComparable Extensions.slnx (Solution file)
+├── README.md
+└── LICENSE
+```
+
+## Development Workflow
+
+### 1. Create a Feature Branch
+
+```bash
+# Update your main branch
+git checkout main
+git pull upstream main
+
+# Create a new feature branch
+git checkout -b feature/your-feature-name
+```
+
+### 2. Make Your Changes
+
+- Write code following the existing style
+- Add or update tests for your changes
+- Ensure tests pass: `dotnet test`
+- Ensure coverage meets requirements (≥80%)
+
+### 3. Commit Your Changes
+
+```bash
+# Stage your changes
+git add .
+
+# Commit with a descriptive message
+git commit -m "Add feature: description of your changes"
+```
+
+### 4. Push and Create Pull Request
+
+```bash
+# Push to your fork
+git push origin feature/your-feature-name
+```
+
+Then:
+1. Go to your fork on GitHub
+2. Click "Compare & pull request"
+3. Fill out the PR template
+4. Submit the pull request
+
+## CI/CD Pipeline
+
+The project uses GitHub Actions for continuous integration. On every pull request:
+
+1. **Build Check**: Code is built in Release mode
+2. **Test Execution**: All tests are run
+3. **Code Coverage**: Coverage is collected and must be ≥80%
+4. **Security Scan**: DevSkim analyzes for security vulnerabilities
+5. **Artifacts**: Coverage reports and scan results are uploaded
+
+### Local CI Simulation
+
+To simulate the CI pipeline locally:
+
+```bash
+# Clean previous builds
+dotnet clean
+
+# Restore dependencies
+dotnet restore
+
+# Build in Release mode
+dotnet build --no-restore --configuration Release
+
+# Run tests with coverage
+find ./tests -type f -name '*Test*.csproj' | while read proj; do
+  dotnet test "$proj" --no-build --configuration Release \
+    --collect:"XPlat Code Coverage" \
+    --results-directory "./TestResults"
+done
+
+# Generate coverage report
+reportgenerator -reports:"TestResults/**/coverage.cobertura.xml" \
+                -targetdir:"CoverageReport" \
+                -reporttypes:"Html;TextSummary;MarkdownSummaryGithub;CsvSummary"
+
+# Run security scan
+devskim analyze --source-code . -f text --output-file devskim-results.txt -E
+```
+
+## Troubleshooting
+
+### Build Errors
+
+**Problem**: `The SDK 'Microsoft.NET.Sdk' specified could not be found`
+- **Solution**: Install .NET 8.0 SDK from [dotnet.microsoft.com](https://dotnet.microsoft.com/download)
+
+**Problem**: `Package restore failed`
+- **Solution**: 
+  ```bash
+  dotnet nuget locals all --clear
+  dotnet restore
+  ```
+
+### Test Failures
+
+**Problem**: Tests pass locally but fail in CI
+- **Solution**: Ensure you're building in Release mode: `dotnet test --configuration Release`
+
+**Problem**: Code coverage below 80%
+- **Solution**: Add tests for uncovered code paths
+
+### Git Issues
+
+**Problem**: Merge conflicts
+- **Solution**:
+  ```bash
+  git fetch upstream
+  git merge upstream/main
+  # Resolve conflicts in your editor
+  git add .
+  git commit -m "Merge upstream changes"
+  ```
+
+## Editor Configuration
+
+### Visual Studio Code
+
+Recommended extensions:
+- C# (Microsoft)
+- C# Dev Kit (Microsoft)
+- EditorConfig for VS Code
+
+Settings (`.vscode/settings.json`):
+```json
+{
+  "dotnet.defaultSolution": "IComparable Extensions.slnx",
+  "editor.formatOnSave": true,
+  "editor.codeActionsOnSave": {
+    "source.fixAll": true
+  }
+}
+```
+
+### Visual Studio
+
+The solution should work out of the box. Ensure:
+- Code cleanup is configured to use `.editorconfig` rules
+- Code analysis is enabled
+
+### JetBrains Rider
+
+Rider automatically respects `.editorconfig`. Additional settings:
+- Enable "Reformat code on save"
+- Enable "Optimize imports on save"
+
+## Getting Help
+
+If you encounter issues:
+
+1. Check [existing GitHub issues](https://github.com/Chris-Wolfgang/IComparable-Extensions/issues)
+2. Review the [CONTRIBUTING.md](../CONTRIBUTING.md) guide
+3. Ask questions in a new GitHub issue
+
+## Next Steps
+
+- Read the [Contributing Guidelines](../CONTRIBUTING.md)
+- Review the [Code of Conduct](../CODE_OF_CONDUCT.md)
+- Explore the [examples](../examples/) folder
+- Join the community discussions
+
+Happy coding! 🚀

From fdbc9f8d7ec18df35f874b98a8d3a9b06a95360a Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 29 Jan 2026 01:32:41 +0000
Subject: [PATCH 3/3] Fix spelling error, improve date examples, and update
 version specification

Co-authored-by: Chris-Wolfgang <210299580+Chris-Wolfgang@users.noreply.github.com>
---
 docs/getting-started.md | 4 ++--
 docs/readme.md          | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/docs/getting-started.md b/docs/getting-started.md
index 44c563a..cd397bc 100644
--- a/docs/getting-started.md
+++ b/docs/getting-started.md
@@ -27,7 +27,7 @@ Add the following package reference to your `.csproj` file:
 
 ```xml
 <ItemGroup>
-  <PackageReference Include="Wolfgang.Extensions.IComparable" Version="*" />
+  <PackageReference Include="Wolfgang.Extensions.IComparable" Version="1.*" />
 </ItemGroup>
 ```
 
@@ -108,7 +108,7 @@ if (price.IsBetween(0m, 100m))
 ### Working with Dates
 
 ```csharp
-DateTime checkDate = DateTime.Now;
+DateTime checkDate = new DateTime(2024, 6, 15);
 DateTime startDate = new DateTime(2024, 1, 1);
 DateTime endDate = new DateTime(2024, 12, 31);
 
diff --git a/docs/readme.md b/docs/readme.md
index ef0ce7b..63c5aa8 100644
--- a/docs/readme.md
+++ b/docs/readme.md
@@ -47,11 +47,11 @@ if (temperature.IsInRange(18, 26))
 }
 
 // Check if a date is between two dates (exclusive)
-DateTime today = DateTime.Now;
+DateTime checkDate = new DateTime(2024, 6, 15);
 DateTime start = new DateTime(2024, 1, 1);
 DateTime end = new DateTime(2024, 12, 31);
 
-if (today.IsBetween(start, end))
+if (checkDate.IsBetween(start, end))
 {
     Console.WriteLine("Date is within 2024 (exclusive of boundaries)");
 }
@@ -72,7 +72,7 @@ bool isValidPercentage = percentage.IsInRange(0m, 100m);
 
 // Temperature monitoring
 double temp = 98.6;
-bool hasFeaver = temp.IsBetween(98.6, 103.0); // false (not > 98.6)
+bool hasFever = temp.IsBetween(98.6, 103.0); // false (98.6 is not > 98.6, boundary is excluded)
 ```
 
 ### String Comparisons