Replace .cusor/rules/sqlitecpp-skills-routing.mdc by AGENTS.md

It's much more generic and should be loaded by most AI agents out there,
but not by Github Copilot extensions in VS and Rider

Mention AGENTS.md and skills in the README.md

Author: SRombauts

.cursor/rules/sqlitecpp-skills-routing.mdc

@@ -0,0 +1,84 @@
+# SQLiteCpp AI Agents Custom Instructions
+
+## Project Overview
+- SQLiteCpp is a C++11 RAII wrapper around SQLite3 C APIs
+- Minimal dependencies: C++11 STL + SQLite3
+- Cross-platform: Windows, Linux, macOS
+- Thread-safe at SQLite multi-thread level
+
+## Maintaining This Documentation
+
+**IMPORTANT:** When the user explains how to do something, corrects your behavior, or points out errors:
+1. **Update AGENTS.md** if the information is a universal constraint or best practice for SQLiteCpp, a correction to existing guidance in this file
+2. **Update skills** if the information is Task-specific guidance (build, testing, documentation, etc.) a correction to existing skill content or a new process
+**Goal:** Keep this documentation accurate and comprehensive so future sessions benefit from corrections and clarifications.
+
+## Core Non-Negotiables (MUST Follow)
+
+1. **RAII only**: Acquire resources in constructors, release in destructors
+2. **Never throw in destructors**: Use `SQLITECPP_ASSERT()` instead
+3. **C++11 core library**: C++14 only in VariadicBind.h and ExecuteMany.h
+4. **Public API isolation**: Headers must NOT include sqlite3.h
+5. **Export macros**: Public API must use `SQLITECPP_API` from SQLiteCppExport.h
+6. **Threading constraint**: One Database/Statement/Column per thread
+7. **Tests required**: New functionality must have tests in tests/
+8. **Portability**: Code must work on Windows, Linux, and macOS
+9. **Const correctness**: Use `const` for methods that don't modify object state, `const&` for read-only parameters
+
+## Error Handling
+- Throw `SQLite::Exception` for errors in throwing APIs
+- Use `tryExec()`, `tryExecuteStep()`, `tryReset()` for error codes
+- In destructors: use `SQLITECPP_ASSERT()` never throw
+
+## Code Style
+- 4 spaces (no tabs)
+- Allman braces style
+- LF line endings (Unix style)
+- Final newline at end of file
+- `#pragma once` in headers
+
+## Naming Conventions
+
+| Element | Convention | Example |
+|---------|------------|---------|
+| Types | PascalCase | `Database`, `Statement`, `TransactionBehavior` |
+| Functions/vars | camelCase | `executeStep()`, `getColumn()`, `getErrorCode()` |
+| Member variables | `m` prefix | `mDatabase`, `mQuery`, `mStmt` |
+| Function arguments | `a` prefix | `aDatabase`, `aQuery`, `aFilename` |
+| Boolean variables | `b`/`mb` prefix | `bExists`, `mbDone`, `mbReadOnly` |
+| Pointer variables | `p`/`mp` prefix | `pValue`, `mpSQLite`, `mpStmt` |
+| Constants | ALL_CAPS | `OPEN_READONLY`, `SQLITE_OK` |
+
+## Documentation Requirements
+- Doxygen required for all public API
+- ASCII only in code and comments
+- Max 120 characters per line
+
+## Repository Structure
+```
+include/SQLiteCpp/    # Public headers
+src/                  # Implementation files
+tests/                # Unit tests (*_test.cpp)
+sqlite3/              # Bundled SQLite3 source
+examples/             # Example applications
+```
+
+## Key Classes
+- `Database`: Connection management and database operations
+- `Statement`: Prepared statement execution
+- `Column`: Result column access
+- `Exception`: Error handling
+
+## Use skills for task guidance
+Skills live under `.claude/skills/`. Load the relevant skill(s) based on the task:
+- `sqlitecpp-coding-standards`: core library edits, public API rules, style and naming.
+- `sqlitecpp-workflow`: add methods/classes, tests, build file updates, changelog.
+- `sqlitecpp-git-branching`: branch creation and naming rules.
+- `sqlitecpp-build-cmake`: CMake builds, options, tests.
+- `sqlitecpp-build-meson`: Meson builds, options, tests.
+- `sqlitecpp-ci-workflows`: CI config updates and build matrices.
+- `sqlitecpp-doxygen-guide`: Doxygen standards and public API documentation.
+- `sqlitecpp-testing-practices`: GoogleTest patterns and test structure.
+- `sqlitecpp-troubleshooting`: compiler/linker/build issues.
+- `sqlitecpp-sqlite-flags`: SQLite/SQLiteCpp feature flags.
+

AGENTS.md

@@ -99,7 +99,7 @@ The "CMakeLists.txt" file defining the static library is provided in the root di
 so you simply have to add_subdirectory(SQLiteCpp) to you main CMakeLists.txt
 and link to the "SQLiteCpp" wrapper library.
 
-Example for Linux: 
+Example for Linux:
 ```cmake
 add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/thirdparty/SQLiteCpp)
 
@@ -110,7 +110,7 @@ target_link_libraries(main
   pthread
   dl
   )
-``` 
+```
 Thus this SQLiteCpp repository can be directly used as a Git submodule.
 See the [SQLiteCpp_Example](https://github.com/SRombauts/SQLiteCpp_Example) side repository for a standalone "from scratch" example.
 
@@ -144,7 +144,7 @@ The SQLiteCpp port in vcpkg is kept up to date by Microsoft team members and com
 
 #### Using SQLiteCpp on a system-wide installation
 
-If you installed this package to your system, a `SQLiteCppConfig.cmake` file will be generated & installed to your system.  
+If you installed this package to your system, a `SQLiteCppConfig.cmake` file will be generated & installed to your system.
 This file lets you link against the SQLiteCpp library for use in your Cmake project.
 
 Here's an example of using this in your CMakeLists.txt
@@ -205,7 +205,7 @@ Arch Linux:
 sudo pacman -Syu clang ninja
 # install python and pip (required for meson)
 sudo pacman -Syu python python-pip
-# install meson 
+# install meson
 pip install meson
 ```
 
@@ -224,7 +224,7 @@ for example you can build the library using the default options with:
 
 ```sh
 # setup the build directory
-meson setup builddir 
+meson setup builddir
 # build sqlitecpp
 meson compile -C builddir
 ```
@@ -276,6 +276,14 @@ You can:
  - or turn off the `option(SQLITE_ENABLE_COLUMN_METADATA "Enable Column::getColumnOriginName(). Require support from sqlite3 library." ON)` in [CMakeFiles.txt](CMakeFiles.txt) (or other build system scripts)
  - or turn on the `option(SQLITECPP_INTERNAL_SQLITE "Add the internal SQLite3 source to the project." ON)` in [CMakeFiles.txt](CMakeFiles.txt)
 
+### AI Coding Assistance
+
+SQLiteCpp includes instructions for AI coding assistants:
+- `/AGENTS.md`: base custom instructions for all tasks
+- `/.claude/skills`: specialized skills covering specific subjects, workflow and processes
+
+These files help AI assistants understand SQLiteCpp's coding standards, architecture, and best practices.
+
 ### Continuous Integration
 
 This project is continuously tested under Ubuntu Linux with the gcc and clang compilers
@@ -315,28 +323,28 @@ valgrind --leak-check=full --show-leak-kinds=all --track-origins=yes --verbose b
 or uncoment the line at the end of [build.sh](build.sh)
 
 ## Examples
-### The first sample demonstrates how to query a database and get results: 
+### The first sample demonstrates how to query a database and get results:
 
 ```C++
 try
 {
     // Open a database file
     SQLite::Database    db("example.db3");
-    
+
     // Compile a SQL query, containing one parameter (index 1)
     SQLite::Statement   query(db, "SELECT * FROM test WHERE size > ?");
-    
+
     // Bind the integer value 6 to the first parameter of the SQL query
     query.bind(1, 6);
-    
+
     // Loop to execute the query step by step, to get rows of result
     while (query.executeStep())
     {
         // Demonstrate how to get some typed column value
         int         id      = query.getColumn(0);
         const char* value   = query.getColumn(1);
         int         size    = query.getColumn(2);
-        
+
         std::cout << "row: " << id << ", " << value << ", " << size << std::endl;
     }
 }
@@ -375,8 +383,8 @@ catch (std::exception& e)
 ### The third sample shows how to manage a prepared statement with a transaction:
 
 ```C++
-try 
-{ 
+try
+{
     SQLite::Database    db("test.db3", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE);
 
     db.exec("DROP TABLE IF EXISTS test");
@@ -454,8 +462,8 @@ See bellow a short comparison of other wrappers done at the time of writing:
  - [sqdbcpp](http://code.google.com/p/sqdbcpp/): RAII design, simple, no dependencies, UTF-8/UTF-16, new BSD license
  - [sqlite3cc](http://ed.am/dev/sqlite3cc): uses boost, modern design, LPGPL
  - [sqlite3pp](https://github.com/iwongu/sqlite3pp): modern design inspired by boost, MIT License
- - [SQLite++](http://sqlitepp.berlios.de/): uses boost build system, Boost License 1.0 
- - [CppSQLite](http://www.codeproject.com/Articles/6343/CppSQLite-C-Wrapper-for-SQLite/): famous Code Project but old design, BSD License 
- - [easySQLite](http://code.google.com/p/easysqlite/): manages table as structured objects, complex 
+ - [SQLite++](http://sqlitepp.berlios.de/): uses boost build system, Boost License 1.0
+ - [CppSQLite](http://www.codeproject.com/Articles/6343/CppSQLite-C-Wrapper-for-SQLite/): famous Code Project but old design, BSD License
+ - [easySQLite](http://code.google.com/p/easysqlite/): manages table as structured objects, complex
  - [sqlite_modern_cpp](https://github.com/keramer/sqlite_modern_cpp): modern C++11, all in one file, MIT license
  - [sqlite_orm](https://github.com/fnc12/sqlite_orm): modern C++14, header only all in one file, no raw string queries, BSD-3 license