Added custom instructions

Author: PawelGerr

.github/copilot-instructions.md

@@ -3,5 +3,8 @@
 **/bin/**
 **/obj/**
 **/packages/**
+.serena/cache/**
+.local-memory/**
 
-*\.sln\.DotSettings\.user
+*\.sln\.DotSettings\.user
+.claude/settings.local.json

.gitignore

@@ -0,0 +1,15 @@
+# Code Style and Conventions
+- C# 13.0, .NET 8.0/9.0
+- Nullable reference types enabled
+- Implicit usings enabled
+- Centralized package management via Directory.Packages.props
+- XML documentation files generated
+- Follows standard .NET naming conventions
+- Tests use xUnit
+- Benchmarking uses BenchmarkDotNet
+- All projects use the root namespace `Thinktecture`
+- Warnings CA1303, MSB3884 suppressed
+- Authors and copyright set in Directory.Build.props
+- Use of PropertyGroup for shared MSBuild properties
+- Use of ItemGroup for shared package references
+- All code should be documented and follow .NET best practices

.serena/memories/code_style_and_conventions.md

@@ -0,0 +1,36 @@
+# Project Purpose
+Thinktecture.EntityFrameworkCore is a set of libraries that extend Entity Framework Core with additional features for performance, convenience, and integration testing. It provides enhancements for bulk operations, temp-tables, window functions, table hints, and more, targeting SQL Server and SQLite. The project is maintained by Pawel Gerr and is available on both Azure DevOps and GitHub.
+
+# Tech Stack
+- .NET 8.0 and 9.0 (C#)
+- Entity Framework Core (EF Core)
+- SQL Server, SQLite
+- Azure Pipelines for CI/CD
+- PowerShell for CI scripting
+- NuGet for package management
+- xUnit for testing
+- BenchmarkDotNet for performance benchmarks
+
+# Codebase Structure
+- `src/`: Main library source code, organized by feature and database provider (BulkOperations, Relational, Sqlite, SqlServer, Testing)
+- `tests/`: Unit and integration tests for each main library
+- `samples/`: Sample and benchmark projects for usage demonstration
+- `ci/`: CI scripts (PowerShell)
+- Solution and build configuration files at the root
+
+# Key Components
+- Bulk operations and performance features (BulkOperations)
+- Relational and provider-specific extensions (Relational, Sqlite, SqlServer)
+- Testing utilities and helpers
+- Sample and benchmark projects for both SQL Server and SQLite
+
+# Entry Points
+- Libraries are consumed as NuGet packages
+- Sample and benchmark projects have `Program.cs` as entry points
+
+# Notable Guidelines
+- Follows .NET and C# conventions (nullable enabled, implicit usings, LangVersion 13.0)
+- Centralized package management
+- Documentation and samples provided for all major features
+
+See additional memories for commands, style, and task completion guidelines.

.serena/memories/project_overview.md

@@ -0,0 +1,27 @@
+# Code Style and Conventions
+- Namespaces start with `Thinktecture` and match folder structure
+- Nullable reference types enabled; use explicit null checks with `ArgumentNullException.ThrowIfNull(...)`
+- Async-first: provide async APIs with `CancellationToken` for I/O operations; avoid sync-over-async
+- Minimal public surface: prefer `internal` unless cross-package usage is needed
+- File-scoped namespaces, expression-bodied members where appropriate
+- Immutability: use `readonly` fields/structs where intended; prefer `record` for value-like objects
+- Query composition: keep operations server-evaluable; avoid client evaluation; prefer `IQueryable` over early `ToList()`
+- SQL safety: never concatenate raw SQL; use `FromSqlInterpolated` or helpers
+- Read-only queries: use `AsNoTracking()` unless state tracking is needed
+- Transactions: use EF Core `IDbContextTransaction`/`ExecutionStrategy` patterns
+- Provider specifics: SQL Server (table hints, temp tables, bulk ops), SQLite (conditional code for limitations)
+- XML documentation required for all public APIs
+- Tests: xUnit + AwesomeAssertions + NSubstitute + Serilog XUnit sink
+- Test naming: `MethodName_Should_DoSomething_When_Condition`
+- Test structure mirrors source structure
+- Deterministic tests: avoid time-based operations, use predictable data
+- Use `CollectExecutedCommands()` to verify SQL in tests
+- Centralized package versions in `Directory.Packages.props`
+- No inline package versions in `.csproj`
+- Build and test for both `net8.0` and `net9.0`
+- No new analyzer warnings or violations
+- Add XML docs and examples for public APIs
+- Use file-scoped namespaces and expression-bodied members where it improves clarity
+- Use guard clauses for argument validation
+- Use async/await and propagate `CancellationToken`
+- Throw appropriate exceptions for error handling

.serena/memories/style_and_conventions.md

@@ -0,0 +1,28 @@
+# Suggested Commands for Development
+
+## Build
+- `dotnet build` — Builds the solution (Thinktecture.EntityFrameworkCore.slnx)
+
+## Test
+- `dotnet test tests/**/*.csproj` — Runs all tests
+
+## Pack
+- `dotnet pack -c Release` — Creates NuGet packages
+
+## Run Samples/Benchmarks
+- `dotnet run --project samples/Thinktecture.EntityFrameworkCore.SqlServer.Samples`
+- `dotnet run --project samples/Thinktecture.EntityFrameworkCore.Sqlite.Samples`
+- `dotnet run --project samples/Thinktecture.EntityFrameworkCore.Benchmarks`
+
+## CI/CD
+- Azure Pipelines: defined in `azure-pipelines.yml`
+- PowerShell CI script: `ci/ci.ps1`
+
+## Version Suffix (for releases)
+- Run PowerShell: `. ./ci/ci.ps1; Set-VersionSuffixOnTag <dir> <branch>`
+
+## Utilities (Windows)
+- Use PowerShell for scripting
+- Standard git commands for version control
+
+See Readme.md and azure-pipelines.yml for more details.

.serena/memories/suggested_commands.md

@@ -0,0 +1,16 @@
+# What to Do When a Task is Completed
+
+1. Ensure all code builds and passes tests on both `net8.0` and `net9.0`.
+2. Check for and resolve any analyzer warnings or code style violations.
+3. Ensure new/changed code follows repository conventions (see style_and_conventions.md).
+4. Add or update XML documentation for any public APIs.
+5. If the change is performance-sensitive, add or update benchmarks in `samples/Thinktecture.EntityFrameworkCore.Benchmarks`.
+6. If the change is user-facing, update samples and documentation as needed.
+7. For new features or bug fixes:
+   - Add/extend tests in `tests/**` (unit first, integration if needed)
+   - Use `CollectExecutedCommands()` in tests to verify SQL if relevant
+   - Ensure provider-specific code is handled for both SQL Server and SQLite
+8. If dependencies were added, update `Directory.Packages.props` and reference in `.csproj` (no inline versions).
+9. If the change affects CI/CD, update `azure-pipelines.yml` or scripts in `ci/`.
+10. Commit and push changes, then create a pull request with a clear description and scope.
+11. Ensure PR passes all CI checks before merging.

.serena/memories/task_completion_checklist.md

@@ -0,0 +1,12 @@
+# Task Completion Guidelines
+- Ensure all code builds and tests pass (`dotnet build`, `dotnet test`)
+- Update documentation if new features or changes are introduced
+- If releasing, ensure version suffix is set for tags
+- Run benchmarks if performance is affected
+- Follow code style and conventions
+- Update samples if APIs change
+- Commit and push changes with clear messages
+- For CI/CD, verify Azure Pipelines status
+- For new features, add or update tests in the appropriate `tests/` project
+- For bug fixes, add regression tests if possible
+- For new features or changes, update Readme.md and relevant wiki pages

.serena/memories/task_completion_guidelines.md

@@ -0,0 +1,68 @@
+# language of the project (csharp, python, rust, java, typescript, go, cpp, or ruby)
+#  * For C, use cpp
+#  * For JavaScript, use typescript
+# Special requirements:
+#  * csharp: Requires the presence of a .sln file in the project folder.
+language: csharp
+
+# whether to use the project's gitignore file to ignore files
+# Added on 2025-04-07
+ignore_all_files_in_gitignore: true
+# list of additional paths to ignore
+# same syntax as gitignore, so you can use * and **
+# Was previously called `ignored_dirs`, please update your config if you are using that.
+# Added (renamed)on 2025-04-07
+ignored_paths: []
+
+# whether the project is in read-only mode
+# If set to true, all editing tools will be disabled and attempts to use them will result in an error
+# Added on 2025-04-18
+read_only: false
+
+
+# list of tool names to exclude. We recommend not excluding any tools, see the readme for more details.
+# Below is the complete list of tools for convenience.
+# To make sure you have the latest list of tools, and to view their descriptions, 
+# execute `uv run scripts/print_tool_overview.py`.
+#
+#  * `activate_project`: Activates a project by name.
+#  * `check_onboarding_performed`: Checks whether project onboarding was already performed.
+#  * `create_text_file`: Creates/overwrites a file in the project directory.
+#  * `delete_lines`: Deletes a range of lines within a file.
+#  * `delete_memory`: Deletes a memory from Serena's project-specific memory store.
+#  * `execute_shell_command`: Executes a shell command.
+#  * `find_referencing_code_snippets`: Finds code snippets in which the symbol at the given location is referenced.
+#  * `find_referencing_symbols`: Finds symbols that reference the symbol at the given location (optionally filtered by type).
+#  * `find_symbol`: Performs a global (or local) search for symbols with/containing a given name/substring (optionally filtered by type).
+#  * `get_current_config`: Prints the current configuration of the agent, including the active and available projects, tools, contexts, and modes.
+#  * `get_symbols_overview`: Gets an overview of the top-level symbols defined in a given file.
+#  * `initial_instructions`: Gets the initial instructions for the current project.
+#     Should only be used in settings where the system prompt cannot be set,
+#     e.g. in clients you have no control over, like Claude Desktop.
+#  * `insert_after_symbol`: Inserts content after the end of the definition of a given symbol.
+#  * `insert_at_line`: Inserts content at a given line in a file.
+#  * `insert_before_symbol`: Inserts content before the beginning of the definition of a given symbol.
+#  * `list_dir`: Lists files and directories in the given directory (optionally with recursion).
+#  * `list_memories`: Lists memories in Serena's project-specific memory store.
+#  * `onboarding`: Performs onboarding (identifying the project structure and essential tasks, e.g. for testing or building).
+#  * `prepare_for_new_conversation`: Provides instructions for preparing for a new conversation (in order to continue with the necessary context).
+#  * `read_file`: Reads a file within the project directory.
+#  * `read_memory`: Reads the memory with the given name from Serena's project-specific memory store.
+#  * `remove_project`: Removes a project from the Serena configuration.
+#  * `replace_lines`: Replaces a range of lines within a file with new content.
+#  * `replace_symbol_body`: Replaces the full definition of a symbol.
+#  * `restart_language_server`: Restarts the language server, may be necessary when edits not through Serena happen.
+#  * `search_for_pattern`: Performs a search for a pattern in the project.
+#  * `summarize_changes`: Provides instructions for summarizing the changes made to the codebase.
+#  * `switch_modes`: Activates modes by providing a list of their names
+#  * `think_about_collected_information`: Thinking tool for pondering the completeness of collected information.
+#  * `think_about_task_adherence`: Thinking tool for determining whether the agent is still on track with the current task.
+#  * `think_about_whether_you_are_done`: Thinking tool for determining whether the task is truly completed.
+#  * `write_memory`: Writes a named memory (for future reference) to Serena's project-specific memory store.
+excluded_tools: []
+
+# initial prompt for the project. It will always be given to the LLM upon activating the project
+# (contrary to the memories, which are loaded on demand).
+initial_prompt: ""
+
+project_name: "Thinktecture.EntityFrameworkCore"

.serena/project.yml

@@ -0,0 +1,148 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Essential Development Commands
+
+### Building the Solution
+```powershell
+dotnet restore
+dotnet build -c Release
+```
+
+### Running Tests
+```powershell
+dotnet test -c Release --no-build
+```
+
+### Running a Single Test Project
+```powershell
+dotnet test tests/Thinktecture.EntityFrameworkCore.SqlServer.Tests/ -c Release
+```
+
+## Architecture Overview
+
+This repository extends Entity Framework Core with performance enhancements and testing utilities across multiple database providers.
+
+### Core Package Structure
+
+**Runtime Packages (`src/`)**:
+- `Thinktecture.EntityFrameworkCore.Relational` - Base abstractions and shared functionality
+- `Thinktecture.EntityFrameworkCore.BulkOperations` - Multi-provider bulk operations
+- `Thinktecture.EntityFrameworkCore.SqlServer` - SQL Server specific features
+- `Thinktecture.EntityFrameworkCore.Sqlite` - SQLite specific features  
+- `Thinktecture.EntityFrameworkCore.Testing` - Base testing infrastructure
+- `Thinktecture.EntityFrameworkCore.SqlServer.Testing` - SQL Server test helpers
+- `Thinktecture.EntityFrameworkCore.Sqlite.Testing` - SQLite test helpers
+
+**Test Structure (`tests/`)**:
+- Tests mirror the `src/` structure with `.Tests` suffix
+- `TestHelpers` package provides shared test utilities
+
+### Key Architectural Patterns
+
+**Bulk Operations Architecture**:
+- Provider-agnostic interfaces (`IBulkInsertExecutor`, `IBulkUpdateExecutor`, etc.)
+- SQL Server implementation uses `SqlBulkCopy` for inserts and MERGE statements for updates
+- Context factories manage connection lifecycle and transaction handling
+- Strongly-typed options classes inherit from base interfaces
+
+**Temp Tables Architecture**:
+- `ITempTableCreator` creates temp tables with `ITempTableReference` for lifecycle management
+- `ITempTableQuery<T>` wraps `IQueryable<T>` with automatic cleanup via `IAsyncDisposable`
+- Integration with bulk operations via `ITempTableBulkInsertExecutor`
+
+**Multi-Provider Support**:
+- Shared interfaces in BulkOperations with provider-specific implementations
+- SQL Server: Table hints, temp tables, window functions, tenant database support
+- SQLite: Simplified bulk operations, window functions, limitation handling
+
+## Testing Infrastructure
+
+### SQL Server Integration Tests
+- Base class: `IntegrationTestsBase`
+- Mark tests with `[Collection("SqlServerTests")]` for proper isolation
+- Use `SqlServerFixture` for shared connections
+- Capture SQL with `CollectExecutedCommands()` to verify generated queries
+
+### SQLite Integration Tests  
+- Base class: `SqliteDbContextIntegrationTests<T>`
+- Use `DbContextProviderFactoryFixture` for database lifecycle management
+- Less isolation requirements compared to SQL Server tests
+
+### Test Patterns
+- xUnit + AwesomeAssertions + NSubstitute + Serilog XUnit sink
+- Naming: `MethodName_Should_DoSomething_When_Condition`
+- Use `ArrangeDbContext`, `ActDbContext`, `AssertDbContext` for different test phases
+- Results written to `test-results/<TargetFramework>/`
+
+## Development Workflows
+
+### Feature Development (Test-First Approach)
+1. **Understand scope**: Identify affected packages in `src/**` and corresponding tests in `tests/**`
+2. **Write failing tests first**: Create unit tests in `tests/<Package>.Tests/**` folder
+3. **Minimal public surface**: Keep APIs `internal` unless cross-package usage is needed
+4. **Server-evaluable queries**: Ensure EF Core operations stay on the server side
+5. **Use appropriate test base**: `IntegrationTestsBase` for SQL Server, `SqliteDbContextIntegrationTests<T>` for SQLite
+6. **Verify SQL generation**: Use `CollectExecutedCommands()` to validate generated SQL
+
+### Bug Fix Workflow
+1. **Reproduce first**: Create a failing test demonstrating the bug
+2. **Minimal fix**: Implement the smallest change to pass the test
+3. **Multi-TFM validation**: Test on both `net8.0` and `net9.0`
+
+## Key Development Guidelines
+
+### EF Core Specifics
+- Keep operations server-evaluable; avoid client evaluation; prefer `IQueryable` over early `ToList()`
+- Never concatenate raw SQL; use `FromSqlInterpolated` or existing parameterized helpers
+- Use `AsNoTracking()` for read-only queries unless state tracking is needed
+- Always provide async APIs with `CancellationToken` for I/O operations; avoid sync-over-async
+- Use EF Core `IDbContextTransaction`/`ExecutionStrategy` patterns for transactions
+
+### Code Conventions
+- Target frameworks: `net8.0` and `net9.0`
+- C# 13.0 with nullable reference types enabled, implicit usings enabled
+- File-scoped namespaces starting with `Thinktecture` and match folder structure
+- Default to `internal` visibility unless cross-package usage is needed
+- Use explicit null checks with `ArgumentNullException.ThrowIfNull()`
+- Expression-bodied members where appropriate; prefer `record` for value-like objects
+
+### Package Management
+- All package versions centralized in `Directory.Packages.props`
+- Reference packages from `.csproj` files without version numbers
+- EF Core 9.x is the current target version (Microsoft.EntityFrameworkCore.*: 9.0.8)
+
+### Provider-Specific Considerations
+- SQL Server: Leverage table hints, temp tables, bulk operations via existing abstractions
+- SQLite: Account for concurrency limitations, DDL locks, missing server features
+- Add conditional code paths only when necessary; maintain consistent API surface where possible
+
+### Essential Patterns
+```csharp
+// Proper async method signature
+public async Task<Result> ProcessAsync(CancellationToken cancellationToken = default)
+{
+    ArgumentNullException.ThrowIfNull(parameter);
+    var data = await GetDataAsync(cancellationToken);
+    return ProcessData(data);
+}
+
+// Bulk operations usage
+await ActDbContext.BulkInsertAsync(entities);
+await using var tempTable = await ActDbContext.BulkInsertIntoTempTableAsync(values);
+
+// Table hints (SQL Server)
+query.WithTableHints(SqlServerTableHint.NoLock)
+
+// Window functions
+EF.Functions.WindowFunction(function, arg, EF.Functions.PartitionBy(...), EF.Functions.OrderBy(...))
+```
+
+## Important Files to Know
+
+- `Thinktecture.EntityFrameworkCore.slnx` - Main solution file
+- `Directory.Packages.props` - Centralized package version management
+- `Directory.Build.props` - Shared MSBuild properties
+- `.github/copilot-instructions.md` - Comprehensive development guidelines
+- Test results are written to `test-results/<TargetFramework>/`