diff --git a/.github/FUNDING.md b/.github/FUNDING.md
new file mode 100644
index 0000000..163530b
--- /dev/null
+++ b/.github/FUNDING.md
@@ -0,0 +1 @@
+github: byjg 
\ No newline at end of file
diff --git a/.github/workflows/phpunit.yml b/.github/workflows/phpunit.yml
index 2cc2446..36c59bd 100644
--- a/.github/workflows/phpunit.yml
+++ b/.github/workflows/phpunit.yml
@@ -8,19 +8,19 @@ on:
   pull_request:
     branches:
       - master
-  schedule:
-    - cron: "0 9 * * 1"
 
 jobs:
   Build:
     runs-on: 'ubuntu-latest'
-    container: 'byjg/php:${{ matrix.php-version }}-cli'
+    container:
+      image: 'byjg/php:${{ matrix.php-version }}-cli'
+      options: --user root --privileged
     strategy:
       matrix:
         php-version:
+          - "8.5"
+          - "8.4"
           - "8.3"
-          - "8.2"
-          - "8.1"
 
     services:
       mysql:
@@ -64,22 +64,42 @@ jobs:
       MSSQL_TEST_HOST: sqlserver
 
     steps:
-      - uses: actions/checkout@v4
-#      - name: Spin up databases
-#        run: |
-#          apk add --no-cache python3 python3-dev py3-pip build-base libffi-dev
-#          pip3 install --upgrade pip
-#          pip3 install docker-compose
-#          apk add --no-cache --repository http://dl-cdn.alpinelinux.org/alpine/edge/community docker
-#          docker-compose up -d postgres mysql
+      - uses: actions/checkout@v5
       - run: composer install
-      - run: ./vendor/bin/psalm
-      - run: ./vendor/bin/phpunit
+      - run: composer test
       - run: ./vendor/bin/phpunit tests/SqliteDatabase*
       - run: ./vendor/bin/phpunit tests/MysqlDatabase*
       - run: ./vendor/bin/phpunit tests/PostgresDatabase*
-#      - run: ./vendor/bin/phpunit tests/SqlServerSqlsrv*
-#      - run: ./vendor/bin/phpunit tests/SqlServerDblib*
+
+  Psalm:
+    name: Psalm Static Analyzer
+    runs-on: ubuntu-latest
+    permissions:
+      # for github/codeql-action/upload-sarif to upload SARIF results
+      security-events: write
+    container:
+      image: byjg/php:8.4-cli
+      options: --user root --privileged
+
+    steps:
+      - name: Git checkout
+        uses: actions/checkout@v4
+
+      - name: Composer
+        run: composer install
+
+      - name: Psalm
+        # Note: Ignoring error code 2, which just signals that some
+        # flaws were found, not that Psalm itself failed to run.
+        run: ./vendor/bin/psalm
+          --show-info=true
+          --report=psalm-results.sarif || [ $? = 2 ]
+
+      - name: Upload Analysis results to GitHub
+        uses: github/codeql-action/upload-sarif@v4
+        if: github.ref == 'refs/heads/master'
+        with:
+          sarif_file: psalm-results.sarif
 
   Documentation:
     if: github.ref == 'refs/heads/master'
@@ -88,5 +108,6 @@ jobs:
     with:
       folder: php
       project: ${{ github.event.repository.name }}
-    secrets: inherit
+    secrets:
+      DOC_TOKEN: ${{ secrets.DOC_TOKEN }}
 
diff --git a/.gitignore b/.gitignore
index c51a039..25e8827 100644
--- a/.gitignore
+++ b/.gitignore
@@ -51,4 +51,7 @@ fabric.properties
 node_modules
 package-lock.json
 .usdocker
+phpunit.coverage.xml
+phpunit.report.xml
 .phpunit.result.cache
+*.bak
diff --git a/.gitpod.yml b/.gitpod.yml
new file mode 100644
index 0000000..335de09
--- /dev/null
+++ b/.gitpod.yml
@@ -0,0 +1,28 @@
+tasks:  
+  - name: Run Composer  
+    command: |  
+      composer install  
+  
+image: byjg/gitpod-image:latest  
+  
+jetbrains:  
+  phpstorm:  
+    vmoptions: '-Xmx4g'  
+  plugins:  
+    - com.github.copilot  
+    - com.intellij.kubernetes  
+    - com.intellij.mermaid  
+    - ru.adelf.idea.dotenv  
+    - org.toml.lang  
+  
+vscode:  
+  extensions:  
+    - ikappas.composer  
+    - hbenl.test-adapter-converter  
+    - hbenl.vscode-test-explorer  
+    - felixfbecker.php-debug  
+    - neilbrayfield.php-docblocker  
+    - bmewburn.vscode-intelephense-client  
+    - getpsalm.psalm-vscode-plugin  
+    - SonarSource.sonarlint-vscode  
+    - recca0120.vscode-phpunit 
\ No newline at end of file
diff --git a/.idea/runConfigurations/PHPUnit.xml b/.idea/runConfigurations/PHPUnit.xml
index 5b1e3d2..f81c245 100644
--- a/.idea/runConfigurations/PHPUnit.xml
+++ b/.idea/runConfigurations/PHPUnit.xml
@@ -1,6 +1,6 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="PHPUnit" type="PHPUnitRunConfigurationType" factoryName="PHPUnit">
     <TestRunner configuration_file="$PROJECT_DIR$/phpunit.xml.dist" scope="XML" use_alternative_configuration_file="true" />
-    <method />
+    <method v="2" />
   </configuration>
 </component>
\ No newline at end of file
diff --git a/.idea/runConfigurations/Psalm.xml b/.idea/runConfigurations/Psalm.xml
deleted file mode 100644
index 6f80a21..0000000
--- a/.idea/runConfigurations/Psalm.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Psalm" type="PhpLocalRunConfigurationType" factoryName="PHP Console" path="$PROJECT_DIR$/vendor/bin/psalm">
-    <method v="2" />
-  </configuration>
-</component>
\ No newline at end of file
diff --git a/.idea/runConfigurations/Run_Databases.xml b/.idea/runConfigurations/Run_Databases.xml
index 56bd727..c561741 100644
--- a/.idea/runConfigurations/Run_Databases.xml
+++ b/.idea/runConfigurations/Run_Databases.xml
@@ -2,6 +2,7 @@
   <configuration default="false" name="Run Databases" type="docker-deploy" factoryName="docker-compose.yml" server-name="Docker">
     <deployment type="docker-compose.yml">
       <settings>
+        <option name="envFilePath" value="" />
         <option name="services">
           <list>
             <option value="mysql" />
diff --git a/.idea/runConfigurations/psalm.xml b/.idea/runConfigurations/psalm.xml
new file mode 100644
index 0000000..d9c1b61
--- /dev/null
+++ b/.idea/runConfigurations/psalm.xml
@@ -0,0 +1,8 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="psalm" type="ComposerRunConfigurationType" factoryName="Composer Script">
+    <option name="commandLineParameters" value="" />
+    <option name="pathToComposerJson" value="$PROJECT_DIR$/composer.json" />
+    <option name="script" value="psalm" />
+    <method v="2" />
+  </configuration>
+</component>
\ No newline at end of file
diff --git a/.vscode/launch.json b/.vscode/launch.json
new file mode 100644
index 0000000..2a5aac0
--- /dev/null
+++ b/.vscode/launch.json
@@ -0,0 +1,35 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Debug current Script in Console",
+            "type": "php",
+            "request": "launch",
+            "program": "${file}",
+            "cwd": "${fileDirname}",
+            "port": 9003,
+            "runtimeArgs": [
+                "-dxdebug.start_with_request=yes"
+            ],
+            "env": {
+                "XDEBUG_MODE": "debug,develop",
+                "XDEBUG_CONFIG": "client_port=${port}"
+            }
+        },
+        {
+            "name": "PHPUnit Debug",
+            "type": "php",
+            "request": "launch",
+            "program": "${workspaceFolder}/vendor/bin/phpunit",
+            "cwd": "${workspaceFolder}",
+            "port": 9003,
+            "runtimeArgs": [
+                "-dxdebug.start_with_request=yes"
+            ],
+            "env": {
+                "XDEBUG_MODE": "debug,develop",
+                "XDEBUG_CONFIG": "client_port=${port}"
+            }
+        }
+    ]
+} 
\ No newline at end of file
diff --git a/README.md b/README.md
index 55544b5..85f706a 100644
--- a/README.md
+++ b/README.md
@@ -1,395 +1,83 @@
-# Database Migrations PHP
+# Database Migration
 
+[![Sponsor](https://img.shields.io/badge/Sponsor-%23ea4aaa?logo=githubsponsors&logoColor=white&labelColor=0d1117)](https://github.com/sponsors/byjg)
+[![Build Status](https://github.com/byjg/php-migration/actions/workflows/phpunit.yml/badge.svg?branch=master)](https://github.com/byjg/php-migration/actions/workflows/phpunit.yml)
 [![Opensource ByJG](https://img.shields.io/badge/opensource-byjg-success.svg)](http://opensource.byjg.com)
 [![GitHub source](https://img.shields.io/badge/Github-source-informational?logo=github)](https://github.com/byjg/php-migration/)
 [![GitHub license](https://img.shields.io/github/license/byjg/php-migration.svg)](https://opensource.byjg.com/opensource/licensing.html)
 [![GitHub release](https://img.shields.io/github/release/byjg/php-migration.svg)](https://github.com/byjg/php-migration/releases/)
-[![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/byjg/migration/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/byjg/migration/?branch=master)
-[![Build Status](https://github.com/byjg/migration/actions/workflows/phpunit.yml/badge.svg?branch=master)](https://github.com/byjg/migration/actions/workflows/phpunit.yml)
 
-## Features
+A simple, framework-agnostic database migration tool that uses pure SQL commands for versioning your database.
 
-This is a simple library written in PHP for database version control. Currently supports Sqlite, MySql, Sql Server and Postgres.
+## Key Features
 
-Database Migration can be used as:
+- **Pure SQL Migrations** - Use native SQL commands instead of framework-specific code
+- **Multiple Database Support** - Works with MySQL, PostgreSQL, SQLite, and SQL Server
+- **Framework Independent** - Can be used with any PHP framework or standalone
+- **CLI & Library Support** - Use as a command-line tool or integrate into your PHP application
+- **Transaction Support** - Ensures database consistency (where supported)
+- **Multi-Developer Friendly** - Supports parallel development with -dev suffixed versions
 
-* Command Line Interface
-* PHP Library to be integrated in your functional tests
-* Integrated in you CI/CD indenpent of your programming language or framework.
+## Quick Start
 
-Database Migrates uses only SQL commands for versioning your database.
-
-## Why pure SQL commands?
-
-The most of the frameworks tend to use programming statements for versioning your database instead of use pure SQL.
-
-There are some advantages to use the native programming language of your framework to maintain the database:
-
-* Framework commands have some trick codes to do complex tasks;
-* You can code once and deploy to different database systems;
-* And others
-
-But at the end despite these good features the reality in big projects someone will use the MySQL Workbench to change your database and then spend some hours translating that code for PHP. So, why do not use the feature existing in MySQL Workbench, JetBrains DataGrip and others that provides the SQL Commands necessary to update your database and put directly into the database versioning system?
-
-Because of that this is an agnostic project (independent of framework and Programming Language) and use pure and native SQL commands for migrate your database.
-
-## Installing
-
-### PHP Library
-
-If you want to use only the PHP Library in your project:
+### Installation
 
 ```bash
 composer require "byjg/migration"
 ```
 
-### Command Line Interface
-
-The command line interface is standalone and does not require you install with your project.
+### CLI Usage
 
-You can install global and create a symbolic lynk
+The package includes a built-in CLI tool:
 
 ```bash
-composer require "byjg/migration-cli"
-```
-
-Please visit [byjg/migration-cli](https://github.com/byjg/migration-cli) to get more informations about Migration CLI.
-
-## Supported databases
-
-| Database      | Driver                                                                          | Connection String                                        |
-| --------------| ------------------------------------------------------------------------------- | -------------------------------------------------------- |
-| Sqlite        | [pdo_sqlite](https://www.php.net/manual/en/ref.pdo-sqlite.php)                  | sqlite:///path/to/file                                   |
-| MySql/MariaDb | [pdo_mysql](https://www.php.net/manual/en/ref.pdo-mysql.php)                    | mysql://username:password@hostname:port/database         |
-| Postgres      | [pdo_pgsql](https://www.php.net/manual/en/ref.pdo-pgsql.php)                    | pgsql://username:password@hostname:port/database         |
-| Sql Server    | [pdo_dblib, pdo_sysbase](https://www.php.net/manual/en/ref.pdo-dblib.php) Linux | dblib://username:password@hostname:port/database         |
-| Sql Server    | [pdo_sqlsrv](http://msdn.microsoft.com/en-us/sqlserver/ff657782.aspx) Windows   | sqlsrv://username:password@hostname:port/database        |
-
-## How It Works?
-
-The Database Migration uses PURE SQL to manage the database versioning.
-In order to get working you need to:
-
-* Create the SQL Scripts
-* Manage using Command Line or the API.
-
-### The SQL Scripts
-
-The scripts are divided in three set of scripts:
-
-* The BASE script contains ALL sql commands for create a fresh database;
-* The UP scripts contain all sql migration commands for "up" the database version;
-* The DOWN scripts contain all sql migration commands for "down" or revert the database version;
-
-The directory scripts is :
-
-```text
- <root dir>
-     |
-     +-- base.sql
-     |
-     +-- /migrations
-              |
-              +-- /up
-                   |
-                   +-- 00001.sql
-                   +-- 00002.sql
-              +-- /down
-                   |
-                   +-- 00000.sql
-                   +-- 00001.sql
-```
-
-* "base.sql" is the base script
-* "up" folder contains the scripts for migrate up the version.
-   For example: 00002.sql is the script for move the database from version '1' to '2'.
-* "down" folder contains the scripts for migrate down the version.
-   For example: 00001.sql is the script for move the database from version '2' to '1'.
-   The "down" folder is optional.
-
-### Multi Development environment
-
-If you work with multiple developers and multiple branches it is to difficult to determine what is the next number.
-
-In that case you have the suffix "-dev" after the version number.
-
-See the scenario:
-
-* Developer 1 create a branch and the most recent version in e.g. 42.
-* Developer 2 create a branch at the same time and have the same database version number.
+# Show current database version
+vendor/bin/migrate version --connection mysql://user:pass@localhost/database
 
-In both case the developers will create a file called 43-dev.sql. Both developers will migrate UP and DOWN with
-no problem and your local version will be 43.
+# Update database to latest version
+vendor/bin/migrate update --connection mysql://user:pass@localhost/database --path ./migrations
 
-But developer 1 merged your changes and created a final version 43.sql (`git mv 43-dev.sql 43.sql`). If the developer 2
-update your local branch he will have a file 43.sql (from dev 1) and your file 43-dev.sql.
-If he is try to migrate UP or DOWN
-the migration script will down and alert him there a TWO versions 43. In that case, developer 2 will have to update your
-file do 44-dev.sql and continue to work until merge your changes and generate a final version.
-
-## Using the PHP API and Integrate it into your projects
-
-The basic usage is
-
-* Create a connection a ConnectionManagement object. For more information see the "byjg/anydataset" component
-* Create a Migration object with this connection and the folder where the scripts sql are located.
-* Use the proper command for "reset", "up" or "down" the migrations scripts.
-
-See an example:
-
-```php
-<?php
-// Create the Connection URI
-// See more: https://github.com/byjg/anydataset#connection-based-on-uri
-$connectionUri = new \ByJG\Util\Uri('mysql://migrateuser:migratepwd@localhost/migratedatabase');
-
-// Register the Database or Databases can handle that URI:
-\ByJG\DbMigration\Migration::registerDatabase(\ByJG\DbMigration\Database\MySqlDatabase::class);
-
-// Create the Migration instance
-$migration = new \ByJG\DbMigration\Migration($connectionUri, '.');
-
-// Add a callback progress function to receive info from the execution
-$migration->addCallbackProgress(function ($action, $currentVersion, $fileInfo) {
-    echo "$action, $currentVersion, ${fileInfo['description']}\n";
-});
-
-// Restore the database using the "base.sql" script
-// and run ALL existing scripts for up the database version to the latest version
-$migration->reset();
-
-// Run ALL existing scripts for up or down the database version
-// from the current version until the $version number;
-// If the version number is not specified migrate until the last database version
-$migration->update($version = null);
+# Reset database and run all migrations
+vendor/bin/migrate reset -c mysql://user:pass@localhost/database -p ./migrations
 ```
 
-The Migration object controls the database version.
+See [CLI Usage](docs/cli-usage.md) for complete documentation.
 
-### Creating a version control in your project
+### Library Usage
 
 ```php
 <?php
-// Register the Database or Databases can handle that URI:
+$connectionUri = new \ByJG\Util\Uri('mysql://user:pass@localhost/database');
 \ByJG\DbMigration\Migration::registerDatabase(\ByJG\DbMigration\Database\MySqlDatabase::class);
 
-// Create the Migration instance
 $migration = new \ByJG\DbMigration\Migration($connectionUri, '.');
-
-// This command will create the version table in your database
-$migration->createVersion();
-```
-
-### Getting the current version
-
-```php
-<?php
-$migration->getCurrentVersion();
-```
-
-### Add Callback to control the progress
-
-```php
-<?php
-$migration->addCallbackProgress(function ($command, $version, $fileInfo) {
-    echo "Doing Command: $command at version $version - ${fileInfo['description']}, ${fileInfo['exists']}, ${fileInfo['file']}, ${fileInfo['checksum']}\n";
-});
-```
-
-### Getting the Db Driver instance
-
-```php
-<?php
-$migration->getDbDriver();
-```
-
-To use it, please visit: [https://github.com/byjg/anydataset-db](https://github.com/byjg/anydataset-db)
-
-### Avoiding Partial Migration (not available for MySQL)
-
-A partial migration is when the migration script is interrupted in the middle of the process due to an error or a manual interruption.
-
-The migration table will be with the status `partial up` or `partial down` and it needs to be fixed manually before be able to migrate again. 
-
-To avoid this situation you can specify the migration will be run in a transactional context. 
-If the migration script fails, the transaction will be rolled back and the migration table will be marked as `complete` and 
-the version will be the immediately previous version before the script that causes the error.
-
-To enable this feature you need to call the method `withTransactionEnabled` passing `true` as parameter:
-
-```php
-<?php
-$migration->withTransactionEnabled(true);
-```
-
-**NOTE: This feature isn't available for MySQL as it doesn't support DDL commands inside a transaction.**
-If you use this method with MySQL the Migration will ignore it silently. 
-More info: [https://dev.mysql.com/doc/refman/8.0/en/cannot-roll-back.html](https://dev.mysql.com/doc/refman/8.0/en/cannot-roll-back.html)
-
-## Tips on writing SQL migrations for Postgres
-
-### On creating triggers and SQL functions
-
-```sql
--- DO
-CREATE FUNCTION emp_stamp() RETURNS trigger AS $emp_stamp$
-    BEGIN
-        -- Check that empname and salary are given
-        IF NEW.empname IS NULL THEN
-            RAISE EXCEPTION 'empname cannot be null'; -- it doesn't matter if these comments are blank or not
-        END IF; --
-        IF NEW.salary IS NULL THEN
-            RAISE EXCEPTION '% cannot have null salary', NEW.empname; --
-        END IF; --
-
-        -- Who works for us when they must pay for it?
-        IF NEW.salary < 0 THEN
-            RAISE EXCEPTION '% cannot have a negative salary', NEW.empname; --
-        END IF; --
-
-        -- Remember who changed the payroll when
-        NEW.last_date := current_timestamp; --
-        NEW.last_user := current_user; --
-        RETURN NEW; --
-    END; --
-$emp_stamp$ LANGUAGE plpgsql;
-
-
--- DON'T
-CREATE FUNCTION emp_stamp() RETURNS trigger AS $emp_stamp$
-    BEGIN
-        -- Check that empname and salary are given
-        IF NEW.empname IS NULL THEN
-            RAISE EXCEPTION 'empname cannot be null';
-        END IF;
-        IF NEW.salary IS NULL THEN
-            RAISE EXCEPTION '% cannot have null salary', NEW.empname;
-        END IF;
-
-        -- Who works for us when they must pay for it?
-        IF NEW.salary < 0 THEN
-            RAISE EXCEPTION '% cannot have a negative salary', NEW.empname;
-        END IF;
-
-        -- Remember who changed the payroll when
-        NEW.last_date := current_timestamp;
-        NEW.last_user := current_user;
-        RETURN NEW;
-    END;
-$emp_stamp$ LANGUAGE plpgsql;
-```
-
-Since the `PDO` database abstraction layer cannot run batches of SQL statements,
-when `byjg/migration` reads a migration file it has to split up the whole contents of the SQL
-file at the semicolons, and run the statements one by one. However, there is one kind of
-statement that can have multiple semicolons in-between its body: functions.
-
-In order to be able to parse functions correctly, `byjg/migration` 2.1.0 started splitting migration
-files at the `semicolon + EOL` sequence instead of just the semicolon. This way, if you append an empty
-comment after every inner semicolon of a function definition `byjg/migration` will be able to parse it.
-
-Unfortunately, if you forget to add any of these comments the library will split the `CREATE FUNCTION` statement in
-multiple parts and the migration will fail.
-
-### Avoid the colon character (`:`)
-
-```sql
--- DO
-CREATE TABLE bookings (
-  booking_id UUID PRIMARY KEY,
-  booked_at  TIMESTAMPTZ NOT NULL CHECK (CAST(booked_at AS DATE) <= check_in),
-  check_in   DATE NOT NULL
-);
-
-
--- DON'T
-CREATE TABLE bookings (
-  booking_id UUID PRIMARY KEY,
-  booked_at  TIMESTAMPTZ NOT NULL CHECK (booked_at::DATE <= check_in),
-  check_in   DATE NOT NULL
-);
+$migration->update();
 ```
 
-Since `PDO` uses the colon character to prefix named parameters in prepared statements, its use will trip it
-up in other contexts.
-
-For instance, PostgreSQL statements can use `::` to cast values between types. On the other hand `PDO` will
-read this as an invalid named parameter in an invalid context and fail when it tries to run it.
-
-The only way to fix this inconsistency is avoiding colons altogether (in this case, PostgreSQL also has an alternative
- syntax: `CAST(value AS type)`).
-
-### Use an SQL editor
+## Documentation
 
-Finally, writing manual SQL migrations can be tiresome, but it is significantly easier if
-you use an editor capable of understanding the SQL syntax, providing autocomplete,
-introspecting your current database schema and/or autoformatting your code.
+For detailed documentation, please visit:
 
-## Handling different migration inside one schema
+- [Getting Started](docs/getting-started.md) - Basic concepts and setup
+- [Database Setup](docs/database-setup.md) - Configure your database connection
+- [Migration Scripts](docs/migration-scripts.md) - Writing and organizing migrations
+- [CLI Usage](docs/cli-usage.md) - Command line interface guide
+- [API Reference](docs/api-reference.md) - Complete API documentation
 
-If you need to create different migration scripts and version inside the same schema it is possible
-but is too risky and I **do not** recommend at all.
+## Supported Databases
 
-To do this, you need to create different "migration tables" by passing the parameter to the constructor.
-
-```php
-<?php
-$migration = new \ByJG\DbMigration\Migration("db:/uri", "/path", true, "NEW_MIGRATION_TABLE_NAME");
-```
-
-For security reasons, this feature is not available at command line, but you can use the environment variable
-`MIGRATION_VERSION` to store the name.
-
-We really recommend do not use this feature. The recommendation is one migration for one schema.
-
-## Running Unit tests
-
-Basic unit tests can be running by:
-
-```bash
-vendor/bin/phpunit
-```
+- MySQL/MariaDB
+- PostgreSQL
+- SQLite
+- SQL Server (Windows and Linux)
 
-## Running database tests
-
-Run integration tests require you to have the databases up and running. We provided a basic `docker-compose.yml` and you
-can use to start the databases for test.
-
-### Running the databases
-
-```bash
-docker-compose up -d postgres mysql mssql
-```
-
-### Run the tests
-
-```bash
-vendor/bin/phpunit
-vendor/bin/phpunit tests/SqliteDatabase*
-vendor/bin/phpunit tests/MysqlDatabase*
-vendor/bin/phpunit tests/PostgresDatabase*
-vendor/bin/phpunit tests/SqlServerDblibDatabase*
-vendor/bin/phpunit tests/SqlServerSqlsrvDatabase*
-```
-
-Optionally you can set the host and password used by the unit tests
-
-```bash
-export MYSQL_TEST_HOST=localhost     # defaults to localhost
-export MYSQL_PASSWORD=newpassword    # use '.' if want have a null password
-export PSQL_TEST_HOST=localhost      # defaults to localhost
-export PSQL_PASSWORD=newpassword     # use '.' if want have a null password
-export MSSQL_TEST_HOST=localhost     # defaults to localhost
-export MSSQL_PASSWORD=Pa55word
-export SQLITE_TEST_HOST=/tmp/test.db      # defaults to /tmp/test.db
-```
+For connection strings and specific database setup, see our [database documentation](docs/database-setup.md).
 
 ## Related Projects
 
-* [Micro ORM](https://github.com/byjg/micro-orm)
-* [Anydataset](https://github.com/byjg/anydataset)
-* [PHP Rest Template](https://github.com/byjg/php-rest-template)
-* [USDocker](https://github.com/usdocker/usdocker)
+- [Micro ORM](https://github.com/byjg/micro-orm)
+- [Anydataset](https://github.com/byjg/anydataset)
+- [PHP Rest Template](https://github.com/byjg/php-rest-template)
 
 ## Dependencies
 
@@ -399,6 +87,5 @@ flowchart TD
     byjg/migration --> ext-pdo
 ```
 
-
 ----
 [Open source ByJG](http://opensource.byjg.com)
\ No newline at end of file
diff --git a/_config.yml b/_config.yml
deleted file mode 100644
index a0d7401..0000000
--- a/_config.yml
+++ /dev/null
@@ -1,66 +0,0 @@
-name: migration
-
-project:
-  version: 1.0.0
-  download_url: https://github.com/byjg/migration/releases
-
-license:
-  software: MIT
-  software_url: https://opensource.org/licenses/MIT
-  
-  docs: MIT
-  docs_url: https://opensource.org/licenses/MIT
-  
-git_edit_address: https://github.com/byjg/migration/blob/master/
-
-links:
-  header:
-  - title: GitHub
-    url: https://github.com/byjg/migration
-  - title: ByJG
-    url: https://opensource.byjg.com/
-  footer:
-  - title: GitHub
-    url: https://github.com/byjg/migration
-  - title: Issues
-    url: https://github.com/byjg/migration/issues
-
-ui:
-  header:
-    color1: "#080331"
-    color2: "#0033cc"
-    trianglify: true
-
-social:
-  github:
-    user: byjg
-    repo: migration
-  twitter:
-    enabled: false
-    via: 
-    hash: opensourcebyjg
-    account: 
-  facebook:
-    enabled: true
-    url: https://opensource.byjg.com/
-    profileUrl:
-
-author:
-  twitter: byjg
-
-twitter:
-  card: summary
-  username: byjg
-
-logo: https://opensource.byjg.com/images/logo_byjg.png
-
-analytics:
-  google: UA-130014324-1
-
-plugins:
-  - jekyll-seo-tag
-
-# Build settings
-markdown: kramdown
-remote_theme: byjg/jekyll-docs-theme
-
diff --git a/bin/migrate b/bin/migrate
new file mode 100755
index 0000000..e2639c8
--- /dev/null
+++ b/bin/migrate
@@ -0,0 +1,36 @@
+#!/usr/bin/env php
+<?php
+
+// Find the autoloader
+$autoloadPaths = [
+    __DIR__ . '/../vendor/autoload.php',
+    __DIR__ . '/../../../autoload.php',
+];
+
+$autoloadPath = null;
+foreach ($autoloadPaths as $path) {
+    if (file_exists($path)) {
+        $autoloadPath = $path;
+        break;
+    }
+}
+
+if (!$autoloadPath) {
+    fwrite(STDERR, "Error: Could not find autoload.php\n");
+    exit(1);
+}
+
+require_once $autoloadPath;
+
+use ByJG\DbMigration\Console\MigrateCommand;
+
+try {
+    $command = new MigrateCommand($argv);
+    exit($command->run());
+} catch (Exception $e) {
+    fwrite(STDERR, "Error: " . $e->getMessage() . "\n");
+    if (getenv('DEBUG') === 'true') {
+        fwrite(STDERR, $e->getTraceAsString() . "\n");
+    }
+    exit(1);
+}
diff --git a/composer.json b/composer.json
index 66a73ef..4215577 100644
--- a/composer.json
+++ b/composer.json
@@ -1,16 +1,16 @@
 {
   "name": "byjg/migration",
-  "description": "Simple library in PHP for database version control. Supports Sqlite, MySql, Sql Server and Postgres.",
+  "description": "A simple, framework-agnostic database migration tool that uses pure SQL commands for versioning your database.",
   "minimum-stability": "dev",
   "prefer-stable": true,
   "require": {
     "ext-pdo": "*",
-    "byjg/anydataset-db": "^5.0"
+    "byjg/anydataset-db": "^6.0",
+    "php": ">=8.3 <8.6"
   },
   "require-dev": {
-    "php": ">=8.1 <8.4",
-    "phpunit/phpunit": "^9.6",
-    "vimeo/psalm": "^5.9"
+    "phpunit/phpunit": "^10.5|^11.5",
+    "vimeo/psalm": "^6.13"
   },
   "autoload": {
     "psr-4": {
@@ -22,5 +22,12 @@
       "Tests\\": "tests/"
     }
   },
+  "bin": [
+    "bin/migrate"
+  ],
+  "scripts": {
+    "test": "vendor/bin/phpunit",
+    "psalm": "vendor/bin/psalm --threads=1"
+  },
   "license": "MIT"
 }
diff --git a/docker-compose.yml b/docker-compose.yml
index 8b1f7a7..80ab50d 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -1,7 +1,6 @@
 version: '3.4'
 services:
   mssql:
-    container_name: anydataset_db_mssql
     image: mcr.microsoft.com/mssql/server
     environment:
       - ACCEPT_EULA=Y
@@ -9,13 +8,12 @@ services:
     ports:
       - "1433:1433"
     healthcheck:
-      test: ["CMD", "/opt/mssql-tools/bin/sqlcmd", "-S", "localhost,1433", "-U", "sa", "-P", "Pa55word", "-Q", "SELECT 1"]
+      test: ["CMD", "/opt/mssql-tools18/bin/sqlcmd", "-C", "-S", "localhost,1433", "-U", "sa", "-P", "Pa55word", "-Q", "SELECT 1"]
       timeout: 20s
       interval: 10s
       retries: 10
 
   postgres:
-    container_name: anydataset_db_postgres
     image: postgres:14-alpine
     environment:
       - POSTGRES_USER=postgres
@@ -29,9 +27,7 @@ services:
       retries: 10
 
   mysql:
-    container_name: anydataset_db_mysql
     image: mysql:8
-    command: --default-authentication-plugin=mysql_native_password
     environment:
       - MYSQL_ROOT_PASSWORD=password
     ports:
diff --git a/docs/api-reference.md b/docs/api-reference.md
new file mode 100644
index 0000000..b41b5f3
--- /dev/null
+++ b/docs/api-reference.md
@@ -0,0 +1,180 @@
+---
+sidebar_position: 5
+title: API Reference
+description: Complete PHP API documentation for database migrations
+---
+
+# API Reference
+
+## Migration Class
+
+The main class for handling database migrations.
+
+### Constructor
+
+```php
+public function __construct(
+    UriInterface $uri,
+    string $folder,
+    bool $requiredBase = true,
+    string $migrationTable = 'migration_version'
+)
+```
+
+Parameters:
+- `$uri`: Database connection URI
+- `$folder`: Path to migration scripts
+- `$requiredBase`: Whether base.sql is required
+- `$migrationTable`: Name of migration tracking table
+
+### Core Methods
+
+#### Version Control
+
+```php
+// Create version tracking table
+public function createVersion(): void
+
+// Check if database is versioned
+public function isDatabaseVersioned(): bool
+
+// Get current version and status
+// Returns: ['version' => int, 'status' => string]
+public function getCurrentVersion(): array
+
+// Update version table structure
+public function updateTableVersion(): void
+```
+
+#### Migration Operations
+
+```php
+// Restore database and run all migrations
+public function reset(?int $upVersion = null): void
+
+// Migrate up to specific version
+public function up(?int $version = null, bool $force = false): void
+
+// Migrate down to specific version
+public function down(?int $version = null, bool $force = false): void
+
+// Smart migration up or down to target version
+public function update(?int $version = null, bool $force = false): void
+```
+
+#### Configuration
+
+```php
+// Enable/disable transaction support
+public function withTransactionEnabled(bool $enabled = true): static
+
+// Add progress callback
+public function addCallbackProgress(Closure $callback): void
+
+// Register database handler
+public static function registerDatabase(string $class): void
+```
+
+#### Database Operations
+
+```php
+// Get database driver instance
+public function getDbDriver(): DbDriverInterface
+
+// Get database command instance
+public function getDbCommand(): DatabaseInterface
+```
+
+### Progress Callback
+
+The progress callback receives three parameters:
+
+```php
+function (
+    string $action,        // Current action (reset, up, down)
+    int $currentVersion,   // Current version number
+    array $fileInfo        // File information array
+)
+```
+
+The `$fileInfo` array contains:
+```php
+[
+    'file' => string,        // Full path to migration file
+    'description' => string, // Migration description
+    'exists' => bool,        // Whether file exists
+    'checksum' => string,    // SHA1 hash of file contents
+    'content' => string      // File contents
+]
+```
+
+## Database Handlers
+
+Custom database handlers must implement `DatabaseInterface`:
+
+```php
+interface DatabaseInterface
+{
+    public function createVersion(): void;
+    public function updateTableVersion(): void;
+    public function getCurrentVersion(): int;
+    public function executeSql(string $sql): void;
+    public function getDbDriver(): DbDriverInterface;
+    // ... other methods
+}
+```
+
+### Built-in Handlers
+
+- `MySqlDatabase`: MySQL/MariaDB
+- `PgsqlDatabase`: PostgreSQL
+- `SqliteDatabase`: SQLite
+- `DblibDatabase`: Microsoft SQL Server (both dblib and sqlsrv)
+
+## Examples
+
+### Basic Migration
+
+```php
+$uri = new \ByJG\Util\Uri('mysql://user:pass@localhost/database');
+\ByJG\DbMigration\Migration::registerDatabase(\ByJG\DbMigration\Database\MySqlDatabase::class);
+
+$migration = new \ByJG\DbMigration\Migration($uri, '/migrations');
+$migration->update();
+```
+
+### With Progress Tracking
+
+```php
+$migration->addCallbackProgress(function ($action, $version, $fileInfo) {
+    echo sprintf(
+        "Executing %s to version %d: %s\n",
+        $action,
+        $version,
+        $fileInfo['description']
+    );
+});
+```
+
+### With Transaction Support
+
+:::note Transaction Support
+Transaction support is not available for MySQL as it doesn't support DDL commands inside transactions. The setting will be silently ignored for MySQL databases.
+:::
+
+```php
+$migration
+    ->withTransactionEnabled(true)
+    ->update();
+```
+
+### Custom Version Table
+
+```php
+$migration = new \ByJG\DbMigration\Migration(
+    $uri,
+    '/migrations',
+    true,
+    'custom_version_table'
+);
+``` 
\ No newline at end of file
diff --git a/docs/cli-usage.md b/docs/cli-usage.md
new file mode 100644
index 0000000..5387296
--- /dev/null
+++ b/docs/cli-usage.md
@@ -0,0 +1,511 @@
+---
+sidebar_position: 4
+title: CLI Usage
+description: Command line interface guide for database migrations
+---
+
+# Command Line Interface Usage
+
+The migration tool includes a built-in CLI with no external dependencies (pure PHP implementation).
+
+## Installation
+
+```bash
+composer require "byjg/migration"
+```
+
+The CLI tool is automatically available at `vendor/bin/migrate` after installation.
+
+## Commands
+
+### version / status
+
+Show the current database version and migration status.
+
+```bash
+vendor/bin/migrate version --connection <uri> [options]
+# or
+vendor/bin/migrate status --connection <uri> [options]
+```
+
+**Example:**
+```bash
+vendor/bin/migrate version -c mysql://user:pass@localhost/mydb
+```
+
+**Output:**
+```
+Current version: 5
+Status: complete
+```
+
+### create / install
+
+Create the migration version tracking table in your database. This should be run once before any migrations.
+
+```bash
+vendor/bin/migrate create --connection <uri> [options]
+# or
+vendor/bin/migrate install --connection <uri> [options]
+```
+
+**Example:**
+```bash
+vendor/bin/migrate create -c mysql://user:pass@localhost/mydb
+```
+
+### reset
+
+Reset the database to the base schema (from `base.sql`) and optionally migrate to a specific version.
+
+```bash
+vendor/bin/migrate reset --connection <uri> [options]
+```
+
+**Examples:**
+```bash
+# Reset and migrate to latest version
+vendor/bin/migrate reset -c mysql://user:pass@localhost/mydb -p ./migrations
+
+# Reset and migrate to version 5
+vendor/bin/migrate reset -c mysql://user:pass@localhost/mydb --version 5 -vv
+```
+
+### up
+
+Migrate up to a specific version or to the latest available version.
+
+```bash
+vendor/bin/migrate up --connection <uri> [options]
+```
+
+**Examples:**
+```bash
+# Migrate to latest version
+vendor/bin/migrate up -c mysql://user:pass@localhost/mydb
+
+# Migrate to version 10
+vendor/bin/migrate up -c mysql://user:pass@localhost/mydb --version 10
+
+# Migrate with verbose output
+vendor/bin/migrate up -c mysql://user:pass@localhost/mydb -vv
+```
+
+### down
+
+Migrate down to a specific version or to version 0.
+
+```bash
+vendor/bin/migrate down --connection <uri> [options]
+```
+
+**Examples:**
+```bash
+# Migrate down to version 3
+vendor/bin/migrate down -c mysql://user:pass@localhost/mydb --version 3
+
+# Migrate down to version 0 (undo all migrations)
+vendor/bin/migrate down -c mysql://user:pass@localhost/mydb --version 0
+```
+
+### update
+
+Intelligently migrate up or down to reach a specific version. If no version is specified, migrates to the latest version.
+
+```bash
+vendor/bin/migrate update --connection <uri> [options]
+```
+
+**Examples:**
+```bash
+# Update to latest version
+vendor/bin/migrate update -c mysql://user:pass@localhost/mydb
+
+# Update to version 7 (will migrate up or down as needed)
+vendor/bin/migrate update -c mysql://user:pass@localhost/mydb --version 7
+```
+
+## Options
+
+### Connection Options
+
+| Option | Short | Description | Required |
+|--------|-------|-------------|----------|
+| `--connection <uri>` | `-c` | Database connection URI | Yes (unless using env var) |
+| `--path <path>` | `-p` | Path to migration folder | No (default: `.`) |
+| `--table <name>` | `-t` | Migration version table name | No (default: `migration_version`) |
+
+### Migration Options
+
+| Option | Description |
+|--------|-------------|
+| `--version <n>` | `-u` | Target version for migration |
+| `--force` | Force migration even if database is in partial state |
+| `--no-transaction` | Disable transaction support |
+| `--no-base` | Skip base.sql validation |
+
+### Output Options
+
+| Option | Description |
+|--------|-------------|
+| `-v` | Verbose output (level 1) |
+| `-vv` | More verbose output (level 2) - shows connection details |
+| `-vvv` | Very verbose output (level 3) - shows stack traces on errors |
+| `--help` | `-h` | Show help message |
+
+## Connection Strings
+
+The `--connection` parameter accepts database URIs in the following formats:
+
+```bash
+# MySQL / MariaDB
+mysql://username:password@hostname:port/database
+mysql://username:password@hostname/database
+
+# PostgreSQL
+pgsql://username:password@hostname:port/database
+pgsql://username:password@hostname/database
+
+# SQLite
+sqlite:///path/to/database.sqlite
+sqlite:///absolute/path/to/database.db
+
+# SQL Server (Linux - dblib)
+dblib://username:password@hostname:port/database
+
+# SQL Server (Windows - sqlsrv)
+sqlsrv://username:password@hostname:port/database
+```
+
+## Environment Variables
+
+The CLI automatically uses environment variables when command-line options are not provided:
+
+### MIGRATION_CONNECTION
+
+Set the database connection URI to avoid repeating it:
+
+```bash
+export MIGRATION_CONNECTION="mysql://user:pass@localhost/mydb"
+
+# Now you can omit -c/--connection
+vendor/bin/migrate version
+vendor/bin/migrate up --version 5
+```
+
+### MIGRATION_PATH
+
+Set the default migration folder path:
+
+```bash
+export MIGRATION_PATH="./database/migrations"
+
+# Now you can omit -p/--path
+vendor/bin/migrate up -c mysql://user:pass@localhost/mydb
+```
+
+### MIGRATION_TABLE
+
+Set a custom migration version table name:
+
+```bash
+export MIGRATION_TABLE="custom_migration_version"
+
+# Uses custom table name instead of default 'migration_version'
+vendor/bin/migrate create -c mysql://user:pass@localhost/mydb
+```
+
+### DEBUG
+
+Enable stack traces on errors:
+
+```bash
+DEBUG=true vendor/bin/migrate up -c mysql://user:pass@localhost/mydb
+```
+
+### Combined Usage
+
+All environment variables can be used together:
+
+```bash
+export MIGRATION_CONNECTION="mysql://user:pass@localhost/mydb"
+export MIGRATION_PATH="./database/migrations"
+export MIGRATION_TABLE="app_migrations"
+
+# All settings applied automatically
+vendor/bin/migrate version
+vendor/bin/migrate up
+```
+
+## Integration with Composer Scripts
+
+You can add migration commands to your `composer.json` scripts section for easier execution:
+
+### Basic Setup
+
+Add migration scripts to your `composer.json`:
+
+```json
+{
+  "scripts": {
+    "migrate:version": "migrate version --connection ${MIGRATE_CONNECTION:-mysql://root@localhost/mydb}",
+    "migrate:up": "migrate up --connection ${MIGRATE_CONNECTION:-mysql://root@localhost/mydb} --path ./database/migrations",
+    "migrate:down": "migrate down --connection ${MIGRATE_CONNECTION:-mysql://root@localhost/mydb} --path ./database/migrations",
+    "migrate:reset": "migrate reset --connection ${MIGRATE_CONNECTION:-mysql://root@localhost/mydb} --path ./database/migrations",
+    "migrate:create": "migrate create --connection ${MIGRATE_CONNECTION:-mysql://root@localhost/mydb}"
+  }
+}
+```
+
+Then run migrations using:
+
+```bash
+composer migrate:version
+composer migrate:up
+composer migrate:reset
+```
+
+### Environment-Aware Setup
+
+For different environments (development, staging, production):
+
+```json
+{
+  "scripts": {
+    "migrate:version": "@php bin/migrate-wrapper.php version",
+    "migrate:up": "@php bin/migrate-wrapper.php up",
+    "migrate:down": "@php bin/migrate-wrapper.php down",
+    "migrate:reset": "@php bin/migrate-wrapper.php reset",
+    "migrate:create": "@php bin/migrate-wrapper.php create"
+  }
+}
+```
+
+Create `bin/migrate-wrapper.php`:
+
+```php
+<?php
+// Load environment-specific configuration
+$envFile = __DIR__ . '/../.env';
+if (file_exists($envFile)) {
+    $lines = file($envFile, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
+    foreach ($lines as $line) {
+        if (strpos(trim($line), '#') === 0) continue;
+        list($key, $value) = explode('=', $line, 2);
+        putenv(trim($key) . '=' . trim($value));
+    }
+}
+
+$connection = getenv('MIGRATION_CONNECTION') ?: 'mysql://root@localhost/mydb';
+$path = getenv('MIGRATION_PATH') ?: './database/migrations';
+$table = getenv('MIGRATION_TABLE') ?: 'migration_version';
+$command = $argv[1] ?? 'version';
+
+$cmd = sprintf(
+    '%s/migrate %s --connection %s --path %s --table %s',
+    __DIR__ . '/../vendor/bin',
+    escapeshellarg($command),
+    escapeshellarg($connection),
+    escapeshellarg($path),
+    escapeshellarg($table)
+);
+
+passthru($cmd, $exitCode);
+exit($exitCode);
+```
+
+### Advanced Setup with Parameters
+
+For scripts that accept parameters:
+
+```json
+{
+  "scripts": {
+    "migrate": "migrate --connection ${MIGRATE_CONNECTION:-mysql://root@localhost/mydb} --path ./database/migrations",
+    "migrate:version": "@migrate version",
+    "migrate:up": "@migrate up",
+    "migrate:to": "@migrate update"
+  }
+}
+```
+
+Usage:
+
+```bash
+# Check version
+composer migrate:version
+
+# Migrate up
+composer migrate:up
+
+# Migrate to specific version
+composer migrate:to -- --version 5
+```
+
+Note: The `--` is required to pass options to the underlying command.
+
+### CI/CD Pipeline Example
+
+For continuous integration:
+
+```json
+{
+  "scripts": {
+    "migrate:check": [
+      "@putenv MIGRATION_CONNECTION=mysql://ci_user:ci_pass@localhost/test_db",
+      "@putenv MIGRATION_PATH=./database/migrations",
+      "migrate version || migrate create",
+      "migrate up -v"
+    ],
+    "test:integration": [
+      "@migrate:check",
+      "phpunit --testsuite integration"
+    ]
+  }
+}
+```
+
+### With Verbosity
+
+```json
+{
+  "scripts": {
+    "migrate:up": "migrate up --connection ${MIGRATE_CONNECTION} --path ./database/migrations -vv",
+    "migrate:reset": "migrate reset --connection ${MIGRATE_CONNECTION} --path ./database/migrations -vv"
+  }
+}
+```
+
+### Tips
+
+1. **Use environment variables** for connection strings to avoid hardcoding credentials
+2. **Add default values** using `${VAR:-default}` syntax for local development
+3. **Create wrapper scripts** for complex setups with multiple environments
+4. **Document your scripts** in your project's README
+5. **Use `@` prefix** to reference other composer scripts
+
+## Complete Examples
+
+### Initial Setup
+
+```bash
+# 1. Create the version tracking table
+vendor/bin/migrate create \
+  --connection mysql://root:password@localhost/myapp \
+  --path ./database/migrations
+
+# 2. Check current version
+vendor/bin/migrate version -c mysql://root:password@localhost/myapp
+
+# 3. Migrate to latest version
+vendor/bin/migrate up -c mysql://root:password@localhost/myapp -p ./database/migrations -vv
+```
+
+### Using Environment Variables
+
+```bash
+# Set connection once
+export MIGRATION_CONNECTION="pgsql://postgres:password@localhost/myapp"
+export MIGRATION_PATH="./migrations"
+
+# Use for multiple commands without any arguments
+vendor/bin/migrate create
+vendor/bin/migrate reset
+vendor/bin/migrate version
+```
+
+### Development Workflow
+
+```bash
+# Check current version
+vendor/bin/migrate version -c sqlite:///./dev.db -p ./migrations
+
+# Apply new migration
+vendor/bin/migrate up -c sqlite:///./dev.db -p ./migrations -vv
+
+# Rollback if needed
+vendor/bin/migrate down -c sqlite:///./dev.db -p ./migrations --version 3
+```
+
+### Production Deployment
+
+```bash
+# Using environment variable for security
+export MIGRATE_CONNECTION="mysql://app_user:${DB_PASSWORD}@db.example.com/production"
+
+# Update to specific version with transaction support (default)
+vendor/bin/migrate update --path /app/migrations --version 42 -v
+
+# Check final version
+vendor/bin/migrate version
+```
+
+### Troubleshooting
+
+```bash
+# Force migration if database is in partial state
+vendor/bin/migrate up -c mysql://user:pass@localhost/mydb --force -vvv
+
+# Reset completely and start fresh
+vendor/bin/migrate reset -c mysql://user:pass@localhost/mydb -p ./migrations --version 0
+
+# Check version without running migrations
+vendor/bin/migrate version -c mysql://user:pass@localhost/mydb
+```
+
+## Migration Directory Structure
+
+The CLI expects the following directory structure:
+
+```text
+<migration-path>
+    |
+    +-- base.sql           # Initial database schema (required by default)
+    |
+    +-- /migrations
+            |
+            +-- /up        # Scripts to upgrade versions
+            |    |
+            |    +-- 1.sql
+            |    +-- 2-add-users.sql
+            |    +-- 3.sql
+            |
+            +-- /down      # Scripts to downgrade versions (optional)
+                 |
+                 +-- 1.sql
+                 +-- 2-add-users.sql
+                 +-- 3.sql
+```
+
+Use `--no-base` flag if you don't have a `base.sql` file.
+
+## Exit Codes
+
+| Code | Meaning |
+|------|---------|
+| 0 | Success |
+| 1 | Error (general error, database error, migration error, etc.) |
+
+## Comparison with Previous CLI
+
+If you were using the separate `byjg/migration-cli` package, here are the main differences:
+
+### Command Syntax Changes
+
+| Old Command | New Command |
+|-------------|-------------|
+| `migrate create-database {uri}` | `migrate create -c {uri}` |
+| `migrate version {uri}` | `migrate version -c {uri}` |
+| `migrate update {uri}` | `migrate update -c {uri}` |
+| `migrate up {uri} {version}` | `migrate up -c {uri} --version {version}` |
+| `migrate down {uri} {version}` | `migrate down -c {uri} --version {version}` |
+| `migrate reset {uri}` | `migrate reset -c {uri}` |
+
+### Key Improvements
+
+- **No Symfony Console dependency** - Pure PHP implementation
+- **Consistent option syntax** - All options use `--option value` format
+- **Better verbosity control** - Three levels: `-v`, `-vv`, `-vvv`
+- **Environment variable support** - `MIGRATE_CONNECTION` for easier automation
+- **Improved error messages** - Clearer error reporting
+- **Help system** - Built-in help with `--help` flag
diff --git a/docs/database-setup.md b/docs/database-setup.md
new file mode 100644
index 0000000..27d49f2
--- /dev/null
+++ b/docs/database-setup.md
@@ -0,0 +1,161 @@
+---
+sidebar_position: 2
+title: Database Setup
+description: Configure database connections for MySQL, PostgreSQL, SQLite, and SQL Server
+---
+
+# Database Setup and Configuration
+
+## Supported Databases
+
+The library supports the following databases:
+
+| Database      | Driver               | Connection String                                 |
+|---------------|----------------------|---------------------------------------------------|
+| MySQL/MariaDB | pdo_mysql            | mysql://username:password@hostname:port/database  |
+| PostgreSQL    | pdo_pgsql            | pgsql://username:password@hostname:port/database  |
+| SQLite        | pdo_sqlite           | sqlite:///path/to/file                            |
+| SQL Server    | pdo_dblib (Linux)    | dblib://username:password@hostname:port/database  |
+| SQL Server    | pdo_sqlsrv (Windows) | sqlsrv://username:password@hostname:port/database |
+
+## Database-Specific Setup
+
+### MySQL/MariaDB
+
+1. Required PDO Extension:
+   ```bash
+   sudo apt-get install php-mysql    # Debian/Ubuntu
+   sudo yum install php-mysql        # RHEL/CentOS
+   ```
+
+2. Connection String Format:
+   ```
+   mysql://username:password@hostname:port/database
+   ```
+
+3. Optional Parameters:
+   ```
+   mysql://username:password@hostname:port/database?param1=value1&param2=value2
+   ```
+
+4. Transaction Limitations:
+
+:::warning MySQL Transaction Limitations
+MySQL does not support DDL (Data Definition Language) statements within transactions. Any transaction settings will be ignored for DDL operations like CREATE TABLE, ALTER TABLE, etc.
+:::
+
+### PostgreSQL
+
+1. Required PDO Extension:
+   ```bash
+   sudo apt-get install php-pgsql    # Debian/Ubuntu
+   sudo yum install php-pgsql        # RHEL/CentOS
+   ```
+
+2. Connection String Format:
+   ```
+   pgsql://username:password@hostname:port/database
+   ```
+
+3. Transaction Support:
+   - Full DDL transaction support
+   - Recommended to use transactions for migrations
+
+### SQLite
+
+1. Required PDO Extension:
+   ```bash
+   sudo apt-get install php-sqlite3   # Debian/Ubuntu
+   sudo yum install php-sqlite3       # RHEL/CentOS
+   ```
+
+2. Connection String Format:
+   ```
+   sqlite:///path/to/database.sqlite
+   ```
+
+3. Transaction Support:
+   - Full DDL transaction support
+   - Transactions enabled by default
+
+### SQL Server
+
+#### Linux (FreeTDS)
+
+1. Required Packages:
+   ```bash
+   sudo apt-get install php-sybase    # Debian/Ubuntu
+   sudo yum install php-mssql         # RHEL/CentOS
+   ```
+
+2. Connection String:
+   ```
+   dblib://username:password@hostname:port/database
+   ```
+
+#### Windows (Native Driver)
+
+1. Required:
+   - Microsoft ODBC Driver for SQL Server
+   - PHP SQL Server extension
+
+2. Connection String:
+   ```
+   sqlsrv://username:password@hostname:port/database
+   ```
+
+## Connection Examples
+
+### Basic Connections
+
+```php
+// MySQL
+$uri = new \ByJG\Util\Uri('mysql://user:pass@localhost/database');
+
+// PostgreSQL
+$uri = new \ByJG\Util\Uri('pgsql://user:pass@localhost/database');
+
+// SQLite
+$uri = new \ByJG\Util\Uri('sqlite:///path/to/database.sqlite');
+
+// SQL Server (Linux)
+$uri = new \ByJG\Util\Uri('dblib://user:pass@localhost/database');
+
+// SQL Server (Windows)
+$uri = new \ByJG\Util\Uri('sqlsrv://user:pass@localhost/database');
+```
+
+### With Optional Parameters
+
+```php
+// MySQL with charset and SSL
+$uri = new \ByJG\Util\Uri(
+    'mysql://user:pass@localhost/database?charset=utf8mb4&ssl=true'
+);
+
+// PostgreSQL with schema and SSL mode
+$uri = new \ByJG\Util\Uri(
+    'pgsql://user:pass@localhost/database?search_path=public&sslmode=require'
+);
+```
+
+## Environment Variables
+
+For testing, you can configure database connections using environment variables:
+
+```bash
+# MySQL
+export MYSQL_TEST_HOST=localhost
+export MYSQL_PASSWORD=password
+
+# PostgreSQL
+export PSQL_TEST_HOST=localhost
+export PSQL_PASSWORD=password
+
+# SQL Server
+export MSSQL_TEST_HOST=localhost
+export MSSQL_PASSWORD=password
+
+# SQLite
+export SQLITE_TEST_HOST=/tmp/test.db
+``` 
\ No newline at end of file
diff --git a/docs/getting-started.md b/docs/getting-started.md
new file mode 100644
index 0000000..e6679fb
--- /dev/null
+++ b/docs/getting-started.md
@@ -0,0 +1,104 @@
+---
+sidebar_position: 1
+title: Getting Started
+description: Get started with PHP Database Migration - a framework-agnostic database versioning tool using pure SQL
+---
+
+# Getting Started with PHP Database Migration
+
+## Why Pure SQL Commands?
+
+Most frameworks use programming statements for database versioning instead of pure SQL. While framework-specific approaches have advantages like:
+
+* Framework commands for complex tasks
+* Database-agnostic code
+* Built-in framework integration
+
+However, in real-world projects, developers often use tools like MySQL Workbench or DataGrip to make database changes and then spend time translating SQL to framework code. This library embraces SQL-first approach, allowing you to use your database tools' native SQL output directly.
+
+## Installation
+
+```bash
+composer require "byjg/migration"
+```
+
+The package includes both the library and a built-in CLI tool (no additional packages needed).
+
+:::tip
+The CLI is automatically available at `vendor/bin/migrate`. See the [CLI documentation](cli-usage.md) for detailed commands and options.
+:::
+
+## Basic Usage
+
+1. Create your migration directory structure:
+```text
+<root dir>
+    |
+    +-- base.sql           # Initial database schema
+    |
+    +-- /migrations
+            |
+            +-- /up        # Scripts to upgrade version
+            |    |
+            |    +-- 00001.sql
+            |    +-- 00002.sql
+            |
+            +-- /down      # Scripts to downgrade version (optional)
+                 |
+                 +-- 00001.sql
+                 +-- 00000.sql
+```
+
+2. Initialize in your code:
+
+```php
+<?php
+// Create database connection
+$connectionUri = new \ByJG\Util\Uri('mysql://user:pass@localhost/database');
+
+// Register database handler
+\ByJG\DbMigration\Migration::registerDatabase(\ByJG\DbMigration\Database\MySqlDatabase::class);
+
+// Create migration instance
+$migration = new \ByJG\DbMigration\Migration($connectionUri, '/path/to/migrations');
+
+// Optional: Add progress callback
+$migration->addCallbackProgress(function ($action, $currentVersion, $fileInfo) {
+    echo "$action, $currentVersion, ${fileInfo['description']}\n";
+});
+
+// Create version table (first time only)
+$migration->createVersion();
+
+// Run migrations
+$migration->update();
+```
+
+## CLI Usage
+
+Alternatively, you can use the built-in command-line tool:
+
+```bash
+# Create version table
+vendor/bin/migrate create \
+  --connection mysql://user:pass@localhost/database \
+  --path /path/to/migrations
+
+# Run migrations to latest version
+vendor/bin/migrate update \
+  --connection mysql://user:pass@localhost/database \
+  --path /path/to/migrations
+
+# Check current version
+vendor/bin/migrate version \
+  --connection mysql://user:pass@localhost/database
+```
+
+For complete CLI documentation, see [CLI Usage](cli-usage.md).
+
+## Next Steps
+
+- Learn about [Migration Scripts](migration-scripts.md)
+- See [Database-specific setup](database-setup.md)
+- Explore the [API Reference](api-reference.md)
+- Check [CLI Usage](cli-usage.md) 
\ No newline at end of file
diff --git a/docs/migration-scripts.md b/docs/migration-scripts.md
new file mode 100644
index 0000000..d711853
--- /dev/null
+++ b/docs/migration-scripts.md
@@ -0,0 +1,141 @@
+---
+sidebar_position: 3
+title: Migration Scripts
+description: Learn how to write and organize database migration scripts
+---
+
+# Writing Migration Scripts
+
+## Script Types
+
+The migration system uses three types of SQL scripts:
+
+1. **Base Script** (`base.sql`): Contains the initial database schema
+2. **Up Scripts** (`migrations/up/*.sql`): Scripts to upgrade database version
+3. **Down Scripts** (`migrations/down/*.sql`): Scripts to downgrade database version (optional)
+
+## Script Naming
+
+Scripts in the `up` and `down` folders must follow the naming convention:
+
+- Format: `NNNNN[-description].sql`
+- Example: `00042-add-user-table.sql` or `00042.sql`
+
+The number represents the version that the script will migrate to (up) or from (down).
+
+## Multi-Developer Workflow
+
+:::info Handling Multiple Developers
+When multiple developers work on different branches, use the `-dev` suffix to avoid version conflicts.
+:::
+
+When multiple developers work on different branches:
+
+1. Use `-dev` suffix for work in progress:
+   ```
+   43-dev.sql  # Developer 1's WIP migration
+   43-dev.sql  # Developer 2's WIP migration (different branch)
+   ```
+
+2. When merging:
+   - First developer to merge renames to final version:
+     ```
+     git mv 43-dev.sql 43.sql
+     ```
+   - Second developer must update their version:
+     ```
+     git mv 43-dev.sql 44-dev.sql
+     ```
+
+## Script Writing Tips
+
+### General Tips
+
+1. Always include a description using SQL comments:
+   ```sql
+   -- @description: Add user authentication fields
+   ALTER TABLE users ADD COLUMN password_hash VARCHAR(255);
+   ```
+
+2. Make scripts idempotent when possible:
+   ```sql
+   -- Check if column exists before adding
+   IF NOT EXISTS (
+       SELECT 1 FROM information_schema.columns 
+       WHERE table_name = 'users' AND column_name = 'password_hash'
+   ) THEN
+       ALTER TABLE users ADD COLUMN password_hash VARCHAR(255);
+   END IF;
+   ```
+
+3. Include corresponding down migration:
+   ```sql
+   -- Up: 00042-add-user-auth.sql
+   ALTER TABLE users ADD COLUMN password_hash VARCHAR(255);
+   
+   -- Down: 00041.sql
+   ALTER TABLE users DROP COLUMN password_hash;
+   ```
+
+### PostgreSQL-Specific Tips
+
+:::warning Important for PostgreSQL Functions
+Always add `--` comments after semicolons inside function definitions to prevent parsing errors.
+:::
+
+1. Use `--` after semicolons in functions:
+   ```sql
+   CREATE FUNCTION update_timestamp() RETURNS trigger AS $$
+   BEGIN
+       NEW.updated_at = CURRENT_TIMESTAMP; --
+       RETURN NEW; --
+   END; --
+   $$ LANGUAGE plpgsql;
+   ```
+
+2. Avoid the colon operator, use CAST instead:
+   ```sql
+   -- DO
+   SELECT CAST(created_at AS DATE)
+   
+   -- DON'T
+   SELECT created_at::DATE
+   ```
+
+### MySQL-Specific Tips
+
+1. Remember that MySQL doesn't support transactions for DDL:
+   ```sql
+   -- These will run without transaction support
+   ALTER TABLE users ADD COLUMN email VARCHAR(255);
+   CREATE INDEX idx_user_email ON users(email);
+   ```
+
+2. Use IF EXISTS/IF NOT EXISTS clauses:
+   ```sql
+   DROP TABLE IF EXISTS temporary_table;
+   CREATE TABLE IF NOT EXISTS new_table ( ... );
+   ```
+
+## Best Practices
+
+1. **One Change Per Migration**
+   - Keep migrations focused and atomic
+   - Makes rollbacks and debugging easier
+
+2. **Include Description Comments**
+   - Document what the migration does
+   - Add any necessary warnings or prerequisites
+
+3. **Test Both Up and Down**
+   - Verify migrations work in both directions
+   - Test with representative data
+
+4. **Use Database-Specific Features Carefully**
+   - Document when using database-specific SQL
+   - Provide alternatives when possible
+
+5. **Version Control**
+   - Never modify committed migrations
+   - Create new migrations for changes
+   - Use descriptive file names 
\ No newline at end of file
diff --git a/phpunit.xml.dist b/phpunit.xml.dist
index 23c7c36..c090a6d 100644
--- a/phpunit.xml.dist
+++ b/phpunit.xml.dist
@@ -6,14 +6,21 @@ and open the template in the editor.
 -->
 
 <!-- see http://www.phpunit.de/wiki/Documentation -->
-<phpunit bootstrap="./vendor/autoload.php"
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         bootstrap="./vendor/autoload.php"
          colors="true"
          testdox="true"
-         convertErrorsToExceptions="true"
-         convertNoticesToExceptions="true"
-         convertWarningsToExceptions="true"
-         convertDeprecationsToExceptions="true"
-         stopOnFailure="false">
+         displayDetailsOnTestsThatTriggerDeprecations="true"
+         displayDetailsOnTestsThatTriggerErrors="true"
+         displayDetailsOnTestsThatTriggerNotices="true"
+         displayDetailsOnTestsThatTriggerWarnings="true"
+         displayDetailsOnPhpunitDeprecations="true"
+         failOnWarning="true"
+         failOnNotice="true"
+         failOnDeprecation="true"
+         failOnPhpunitDeprecation="true"
+         stopOnFailure="false"
+         xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/10.5/phpunit.xsd">
 
     <php>
         <ini name="display_errors" value="On" />
@@ -21,18 +28,15 @@ and open the template in the editor.
         <ini name="error_reporting" value="E_ALL" />
     </php>
 
-    <filter>
-        <whitelist>
-            <directory>./src</directory>
-        </whitelist>
-    </filter>
+    <source>
+        <include>
+            <directory>./src/</directory>
+        </include>
+    </source>
 
     <testsuites>
         <testsuite name="Test Suite">
-            <!--<directory>./tests/</directory>-->
-            <file>./tests/SqliteDatabaseTest.php</file>
-            <file>./tests/MigrationTest.php</file>
+            <directory>./tests/</directory>
         </testsuite>
     </testsuites>
-
-</phpunit>
+</phpunit>
\ No newline at end of file
diff --git a/psalm.xml b/psalm.xml
index ebabb1a..037de8b 100644
--- a/psalm.xml
+++ b/psalm.xml
@@ -1,16 +1,16 @@
 <?xml version="1.0"?>
 <psalm
-    errorLevel="4"
+    errorLevel="3"
     resolveFromConfigFile="true"
     findUnusedBaselineEntry="true"
     findUnusedCode="false"
+    cacheDirectory="/tmp/psalm"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns="https://getpsalm.org/schema/config"
     xsi:schemaLocation="https://getpsalm.org/schema/config vendor/vimeo/psalm/config.xsd"
 >
     <projectFiles>
         <directory name="src" />
-        <directory name="tests" />
         <ignoreFiles>
             <directory name="vendor" />
         </ignoreFiles>
diff --git a/src/Console/MigrateCommand.php b/src/Console/MigrateCommand.php
new file mode 100644
index 0000000..2ec8590
--- /dev/null
+++ b/src/Console/MigrateCommand.php
@@ -0,0 +1,325 @@
+<?php
+
+namespace ByJG\DbMigration\Console;
+
+use ByJG\DbMigration\Database\MySqlDatabase;
+use ByJG\DbMigration\Database\PgsqlDatabase;
+use ByJG\DbMigration\Database\SqliteDatabase;
+use ByJG\DbMigration\Database\DblibDatabase;
+use ByJG\DbMigration\Migration;
+use ByJG\Util\Uri;
+
+class MigrateCommand
+{
+    private array $argv;
+    private array $options = [];
+    private string $command = '';
+    private int $verbosity = 0;
+
+    public function __construct(array $argv)
+    {
+        $this->argv = $argv;
+        $this->parseArguments();
+    }
+
+    private function parseArguments(): void
+    {
+        $args = array_slice($this->argv, 1);
+
+        for ($i = 0; $i < count($args); $i++) {
+            $arg = $args[$i];
+
+            if ($arg === '--help' || $arg === '-h') {
+                $this->options['help'] = true;
+                continue;
+            }
+
+            if (str_starts_with($arg, '--')) {
+                $key = substr($arg, 2);
+                $value = true;
+
+                if (isset($args[$i + 1]) && !str_starts_with($args[$i + 1], '-')) {
+                    $value = $args[$i + 1];
+                    $i++;
+                }
+
+                $this->options[$key] = $value;
+            } elseif (str_starts_with($arg, '-')) {
+                $key = substr($arg, 1);
+
+                if ($key === 'v') {
+                    $this->verbosity = 1;
+                } elseif ($key === 'vv') {
+                    $this->verbosity = 2;
+                } elseif ($key === 'vvv') {
+                    $this->verbosity = 3;
+                } else {
+                    $value = true;
+                    if (isset($args[$i + 1]) && !str_starts_with($args[$i + 1], '-')) {
+                        $value = $args[$i + 1];
+                        $i++;
+                    }
+                    $this->options[$key] = $value;
+                }
+            } else {
+                if (empty($this->command)) {
+                    $this->command = $arg;
+                }
+            }
+        }
+    }
+
+    public function run(): int
+    {
+        if (isset($this->options['help']) || empty($this->command)) {
+            $this->showHelp();
+            return 0;
+        }
+
+        try {
+            return match ($this->command) {
+                'version', 'status' => $this->handleVersion(),
+                'reset' => $this->handleReset(),
+                'up' => $this->handleUp(),
+                'down' => $this->handleDown(),
+                'update' => $this->handleUpdate(),
+                'create', 'install' => $this->handleCreate(),
+                default => $this->showError("Unknown command: {$this->command}")
+            };
+        } catch (\Exception $e) {
+            $this->output("Error: " . $e->getMessage(), 0, STDERR);
+            if ($this->verbosity >= 3) {
+                $this->output($e->getTraceAsString(), 0, STDERR);
+            }
+            return 1;
+        }
+    }
+
+    private function getMigration(): Migration
+    {
+        $connection = $this->getOption('connection', 'c') ?: getenv('MIGRATION_CONNECTION');
+        $path = $this->getOption('path', 'p') ?: getenv('MIGRATION_PATH') ?: '.';
+        $migrationTable = $this->getOption('table', 't') ?: getenv('MIGRATION_TABLE') ?: 'migration_version';
+
+        if (!$connection) {
+            throw new \InvalidArgumentException(
+                "Database connection URI is required. Use --connection or set MIGRATION_CONNECTION environment variable."
+            );
+        }
+
+        $this->output("Connection: $connection", 2);
+        $this->output("Path: $path", 2);
+        $this->output("Table: $migrationTable", 2);
+
+        $uri = new Uri($connection);
+
+        // Register database drivers
+        Migration::registerDatabase(MySqlDatabase::class);
+        Migration::registerDatabase(PgsqlDatabase::class);
+        Migration::registerDatabase(SqliteDatabase::class);
+        Migration::registerDatabase(DblibDatabase::class);
+
+        $noBase = isset($this->options['no-base']);
+
+        $migration = new Migration($uri, $path, !$noBase, $migrationTable);
+
+        if (!isset($this->options['no-transaction'])) {
+            $migration->withTransactionEnabled(true);
+        }
+
+        if ($this->verbosity > 0) {
+            $migration->addCallbackProgress(function ($action, $version, $fileInfo) {
+                $status = $fileInfo['exists'] ? 'OK' : 'Not found';
+                $this->output("  [$action] Version $version - {$fileInfo['description']} [$status]", 1);
+            });
+        }
+
+        return $migration;
+    }
+
+    private function handleVersion(): int
+    {
+        $migration = $this->getMigration();
+
+        try {
+            $versionInfo = $migration->getCurrentVersion();
+            $this->output("Current version: {$versionInfo['version']}");
+            $this->output("Status: {$versionInfo['status']}");
+            return 0;
+        } catch (\Exception $e) {
+            $this->output("Database is not versioned. Run 'migrate create' first.", 0, STDERR);
+            return 1;
+        }
+    }
+
+    private function handleReset(): int
+    {
+        $migration = $this->getMigration();
+        $version = $this->getOptionAsInt('version', 'u');
+
+        $this->output("Resetting database" . ($version ? " to version $version" : "") . "...");
+        $migration->reset($version);
+        $this->output("Database reset successfully!");
+
+        return 0;
+    }
+
+    private function handleUp(): int
+    {
+        $migration = $this->getMigration();
+        $version = $this->getOptionAsInt('version', 'u');
+        $force = isset($this->options['force']);
+
+        $this->output("Migrating up" . ($version ? " to version $version" : " to latest version") . "...");
+        $migration->up($version, $force);
+
+        $versionInfo = $migration->getCurrentVersion();
+        $this->output("Migration completed! Current version: {$versionInfo['version']}");
+
+        return 0;
+    }
+
+    private function handleDown(): int
+    {
+        $migration = $this->getMigration();
+        $version = $this->getOptionAsInt('version', 'u');
+        $force = isset($this->options['force']);
+
+        $this->output("Migrating down" . ($version !== null ? " to version $version" : " to version 0") . "...");
+        $migration->down($version, $force);
+
+        $versionInfo = $migration->getCurrentVersion();
+        $this->output("Migration completed! Current version: {$versionInfo['version']}");
+
+        return 0;
+    }
+
+    private function handleUpdate(): int
+    {
+        $migration = $this->getMigration();
+        $version = $this->getOptionAsInt('version', 'u');
+        $force = isset($this->options['force']);
+
+        $this->output("Updating database" . ($version ? " to version $version" : "") . "...");
+        $migration->update($version, $force);
+
+        $versionInfo = $migration->getCurrentVersion();
+        $this->output("Update completed! Current version: {$versionInfo['version']}");
+
+        return 0;
+    }
+
+    private function handleCreate(): int
+    {
+        $migration = $this->getMigration();
+
+        $this->output("Creating migration version table...");
+        $migration->createVersion();
+        $this->output("Migration version table created successfully!");
+
+        return 0;
+    }
+
+    private function getOption(string $long, ?string $short = null, mixed $default = null): mixed
+    {
+        if (isset($this->options[$long])) {
+            return $this->options[$long];
+        }
+
+        if ($short && isset($this->options[$short])) {
+            return $this->options[$short];
+        }
+
+        return $default;
+    }
+
+    private function getOptionAsInt(string $long, ?string $short = null): ?int
+    {
+        $value = $this->getOption($long, $short);
+        return $value !== null ? (int)$value : null;
+    }
+
+    private function output(string $message, int $requiredVerbosity = 0, $stream = STDOUT): void
+    {
+        if ($this->verbosity >= $requiredVerbosity) {
+            fwrite($stream, $message . "\n");
+        }
+    }
+
+    private function showError(string $message): int
+    {
+        $this->output($message, 0, STDERR);
+        $this->output("Run 'migrate --help' for usage information.", 0, STDERR);
+        return 1;
+    }
+
+    private function showHelp(): void
+    {
+        $help = <<<'HELP'
+Database Migration Tool
+
+USAGE:
+  migrate <command> [options]
+
+COMMANDS:
+  version            Show current database version (alias: status)
+  create             Create migration version table (alias: install)
+  reset              Reset database to base.sql and optionally migrate to a version
+  up                 Migrate up to a specific version or latest
+  down               Migrate down to a specific version or 0
+  update             Intelligently migrate up or down to a specific version
+
+OPTIONS:
+  -c, --connection <uri>    Database connection URI (required)
+                            Examples:
+                              mysql://user:pass@localhost/dbname
+                              pgsql://user:pass@localhost/dbname
+                              sqlite:///path/to/database.db
+
+  -p, --path <path>         Path to migration folder (default: .)
+  -u, --version <version>   Target version for migration
+  -t, --table <name>        Migration version table name (default: migration_version)
+
+  --force                   Force migration even if database is in partial state
+  --no-transaction          Disable transaction support
+  --no-base                 Skip base.sql validation
+
+  -v, -vv, -vvv            Increase verbosity
+  -h, --help               Show this help message
+
+ENVIRONMENT VARIABLES:
+  MIGRATION_CONNECTION      Database connection URI (fallback if --connection not provided)
+  MIGRATION_PATH            Path to migration folder (fallback if --path not provided)
+  MIGRATION_TABLE           Migration version table name (fallback if --table not provided)
+  DEBUG=true                Show stack trace on errors
+
+EXAMPLES:
+  # Show current version
+  migrate version --connection mysql://user:pass@localhost/db
+
+  # Create version table
+  migrate create -c mysql://user:pass@localhost/db
+
+  # Reset database and migrate to version 5
+  migrate reset -c mysql://user:pass@localhost/db --version 5
+
+  # Migrate up to latest version
+  migrate up -c mysql://user:pass@localhost/db -vv
+
+  # Migrate down to version 3
+  migrate down -c mysql://user:pass@localhost/db --version 3
+
+  # Update to specific version (up or down automatically)
+  migrate update -c mysql://user:pass@localhost/db --version 10
+
+  # Using environment variables
+  export MIGRATION_CONNECTION="mysql://user:pass@localhost/db"
+  export MIGRATION_PATH="./migrations"
+  migrate version
+  migrate up
+
+HELP;
+
+        echo $help . "\n";
+    }
+}
\ No newline at end of file
diff --git a/src/Database/AbstractDatabase.php b/src/Database/AbstractDatabase.php
index 958bf22..d788e13 100644
--- a/src/Database/AbstractDatabase.php
+++ b/src/Database/AbstractDatabase.php
@@ -2,11 +2,12 @@
 
 namespace ByJG\DbMigration\Database;
 
-use ByJG\AnyDataset\Db\DbDriverInterface;
+use ByJG\AnyDataset\Db\Interfaces\DbDriverInterface;
 use ByJG\AnyDataset\Db\Factory;
 use ByJG\DbMigration\Exception\DatabaseNotVersionedException;
 use ByJG\DbMigration\Exception\OldVersionSchemaException;
 use ByJG\DbMigration\MigrationStatus;
+use ByJG\Util\Uri;
 use Exception;
 use Psr\Http\Message\UriInterface;
 
@@ -38,9 +39,20 @@ public function __construct(UriInterface $uri, string $migrationTable = 'migrati
         $this->migrationTable = $migrationTable;
     }
 
+    protected static function getDatabaseName(Uri $uri): string
+    {
+        return ltrim($uri->getPath(), '/');
+    }
+
+    protected static function getDbDriverWithoutDatabase(UriInterface $uri, string $database = ''): DbDriverInterface
+    {
+        return Factory::getDbInstance($uri->withPath("/$database")->__toString());
+    }
+
     /**
      * @return string
      */
+    #[\Override]
     public function getMigrationTable(): string
     {
         return $this->migrationTable;
@@ -49,6 +61,7 @@ public function getMigrationTable(): string
     /**
      * @return DbDriverInterface
      */
+    #[\Override]
     public function getDbDriver(): DbDriverInterface
     {
         if (is_null($this->dbDriver)) {
@@ -62,6 +75,7 @@ public function getDbDriver(): DbDriverInterface
      * @throws DatabaseNotVersionedException
      * @throws OldVersionSchemaException
      */
+    #[\Override]
     public function getVersion(): array
     {
         $result = [];
@@ -84,6 +98,7 @@ public function getVersion(): array
      * @param int $version
      * @param MigrationStatus $status
      */
+    #[\Override]
     public function setVersion(int $version, MigrationStatus $status): void
     {
         $this->getDbDriver()->execute(
@@ -115,6 +130,7 @@ protected function checkExistsVersion(): void
     /**
      *
      */
+    #[\Override]
     public function updateVersionTable(): void
     {
         $currentVersion = $this->getDbDriver()->getScalar(sprintf('select version from %s', $this->getMigrationTable()));
@@ -138,11 +154,13 @@ protected function isTableExists(?string $schema, string $table): bool
         return (intval($count) !== 0);
     }
 
+    #[\Override]
     public function isDatabaseVersioned(): bool
     {
-        return $this->isTableExists(ltrim($this->getDbDriver()->getUri()->getPath(), "/"), $this->getMigrationTable());
+        return $this->isTableExists(static::getDatabaseName($this->getDbDriver()->getUri()), $this->getMigrationTable());
     }
 
+    #[\Override]
     public function supportsTransaction(): bool
     {
         return true;
diff --git a/src/Database/DatabaseInterface.php b/src/Database/DatabaseInterface.php
index 9d6b5d7..4e124db 100644
--- a/src/Database/DatabaseInterface.php
+++ b/src/Database/DatabaseInterface.php
@@ -2,7 +2,7 @@
 
 namespace ByJG\DbMigration\Database;
 
-use ByJG\AnyDataset\Db\DbDriverInterface;
+use ByJG\AnyDataset\Db\Interfaces\DbDriverInterface;
 use ByJG\DbMigration\Exception\DatabaseNotVersionedException;
 use ByJG\DbMigration\Exception\OldVersionSchemaException;
 use ByJG\DbMigration\MigrationStatus;
diff --git a/src/Database/DblibDatabase.php b/src/Database/DblibDatabase.php
index 58f1dc8..f9381bf 100644
--- a/src/Database/DblibDatabase.php
+++ b/src/Database/DblibDatabase.php
@@ -10,32 +10,40 @@
 
 class DblibDatabase extends AbstractDatabase
 {
+    #[\Override]
     public static function schema(): array
     {
         return ['dblib', 'sqlsrv'];
     }
 
-    public static function prepareEnvironment(UriInterface $uri): void
+    #[\Override]
+    protected static function getDatabaseName(Uri $uri): string
     {
-        $database = preg_replace('~^/~', '', $uri->getPath());
-
-        $customUri = new Uri($uri->__toString());
+        return $uri->getQueryPart('dbname') ?? $uri->getQueryPart('Database') ?? ltrim($uri->getPath(), '/');
+    }
 
-        $dbDriver = Factory::getDbInstance($customUri->withPath('/')->__toString());
+    #[\Override]
+    public static function prepareEnvironment(UriInterface|Uri $uri): void
+    {
+        $uriInstance = $uri instanceof Uri ? $uri : new Uri($uri->__toString());
+        $database = static::getDatabaseName($uriInstance);
+        $dbDriver = static::getDbDriverWithoutDatabase($uri);
         $dbDriver->execute("IF NOT EXISTS(select * from sys.databases where name='$database') CREATE DATABASE $database");
     }
 
+    #[\Override]
     public function createDatabase(): void
     {
-        $database = preg_replace('~^/~', '', $this->getDbDriver()->getUri()->getPath());
+        $database = static::getDatabaseName($this->getDbDriver()->getUri());
 
         $this->getDbDriver()->execute("IF NOT EXISTS(select * from sys.databases where name='$database') CREATE DATABASE $database");
         $this->getDbDriver()->execute("USE $database");
     }
 
+    #[\Override]
     public function dropDatabase(): void
     {
-        $database = preg_replace('~^/~', '', $this->getDbDriver()->getUri()->getPath());
+        $database = static::getDatabaseName($this->getDbDriver()->getUri());
 
         $this->getDbDriver()->execute("use master");
         $this->getDbDriver()->execute("drop database $database");
@@ -60,18 +68,25 @@ protected function createTableIfNotExists(string $database, string $createTable)
      * @throws DatabaseNotVersionedException
      * @throws OldVersionSchemaException
      */
+    #[\Override]
     public function createVersion(): void
     {
-        $database = preg_replace('~^/~', '', $this->getDbDriver()->getUri()->getPath());
+        $database = static::getDatabaseName($this->getDbDriver()->getUri());
+
         $createTable = 'CREATE TABLE ' . $this->getMigrationTable() . ' (version int, status varchar(20), PRIMARY KEY (version))';
         $this->createTableIfNotExists($database, $createTable);
         $this->checkExistsVersion();
     }
 
+    #[\Override]
     public function executeSql(string $sql): void
     {
         $statements = preg_split("/;(\r\n|\r|\n)/", $sql);
 
+        if ($statements === false) {
+            $statements = [$sql];
+        }
+
         foreach ($statements as $sql) {
             $this->executeSqlInternal($sql);
         }
@@ -90,6 +105,7 @@ protected function executeSqlInternal(string $sql): void
      * @param string $table
      * @return bool
      */
+    #[\Override]
     protected function isTableExists(?string $schema, string $table): bool
     {
         $count = $this->getDbDriver()->getScalar(
diff --git a/src/Database/MySqlDatabase.php b/src/Database/MySqlDatabase.php
index 7a33543..b4647dd 100644
--- a/src/Database/MySqlDatabase.php
+++ b/src/Database/MySqlDatabase.php
@@ -10,32 +10,34 @@
 
 class MySqlDatabase extends AbstractDatabase
 {
+    #[\Override]
     public static function schema(): array
     {
         return ['mysql', 'mariadb'];
     }
 
-    public static function prepareEnvironment(UriInterface $uri): void
+    #[\Override]
+    public static function prepareEnvironment(UriInterface|Uri $uri): void
     {
-        $database = preg_replace('~^/~', '', $uri->getPath());
-
-        $customUri = new Uri($uri->__toString());
-
-        $dbDriver = Factory::getDbInstance($customUri->withPath('/')->__toString());
+        $uriInstance = $uri instanceof Uri ? $uri : new Uri($uri->__toString());
+        $database = static::getDatabaseName($uriInstance);
+        $dbDriver = static::getDbDriverWithoutDatabase($uri);
         $dbDriver->execute("CREATE SCHEMA IF NOT EXISTS `$database` DEFAULT CHARACTER SET utf8 ;");
     }
 
+    #[\Override]
     public function createDatabase(): void
     {
-        $database = preg_replace('~^/~', '', $this->getDbDriver()->getUri()->getPath());
+        $database = static::getDatabaseName($this->getDbDriver()->getUri());
 
         $this->getDbDriver()->execute("CREATE SCHEMA IF NOT EXISTS `$database` DEFAULT CHARACTER SET utf8 ;");
         $this->getDbDriver()->execute("USE `$database`");
     }
 
+    #[\Override]
     public function dropDatabase(): void
     {
-        $database = preg_replace('~^/~', '', $this->getDbDriver()->getUri()->getPath());
+        $database = static::getDatabaseName($this->getDbDriver()->getUri());
 
         $this->getDbDriver()->execute("drop database `$database`");
     }
@@ -44,17 +46,20 @@ public function dropDatabase(): void
      * @throws DatabaseNotVersionedException
      * @throws OldVersionSchemaException
      */
+    #[\Override]
     public function createVersion(): void
     {
         $this->getDbDriver()->execute('CREATE TABLE IF NOT EXISTS ' . $this->getMigrationTable() . ' (version int, status varchar(20), PRIMARY KEY (version))');
         $this->checkExistsVersion();
     }
 
+    #[\Override]
     public function executeSql(string $sql): void
     {
         $this->getDbDriver()->execute($sql);
     }
 
+    #[\Override]
     public function supportsTransaction(): bool
     {
         // MySQL doesn't support transaction for DDL commands
diff --git a/src/Database/PgsqlDatabase.php b/src/Database/PgsqlDatabase.php
index 80e7ff4..48e84dd 100644
--- a/src/Database/PgsqlDatabase.php
+++ b/src/Database/PgsqlDatabase.php
@@ -2,7 +2,7 @@
 
 namespace ByJG\DbMigration\Database;
 
-use ByJG\AnyDataset\Db\DbDriverInterface;
+use ByJG\AnyDataset\Db\Interfaces\DbDriverInterface;
 use ByJG\AnyDataset\Db\Factory;
 use ByJG\DbMigration\Exception\DatabaseNotVersionedException;
 use ByJG\DbMigration\Exception\OldVersionSchemaException;
@@ -11,24 +11,21 @@
 
 class PgsqlDatabase extends AbstractDatabase
 {
+    #[\Override]
     public static function schema(): string
     {
         return 'pgsql';
     }
 
-    public static function prepareEnvironment(UriInterface $uri): void
+    #[\Override]
+    public static function prepareEnvironment(UriInterface|Uri $uri): void
     {
-        $database = preg_replace('~^/~', '', $uri->getPath());
-        $dbDriver = static::getDbDriverWithoutDatabase($uri);
+        $uriInstance = $uri instanceof Uri ? $uri : new Uri($uri->__toString());
+        $database = static::getDatabaseName($uriInstance);
+        $dbDriver = static::getDbDriverWithoutDatabase($uri, 'postgres');
         static::createDatabaseIfNotExists($dbDriver, $database);
     }
 
-    protected static function getDbDriverWithoutDatabase(UriInterface $uri): DbDriverInterface
-    {
-        $customUri = new Uri($uri->__toString());
-        return Factory::getDbInstance($customUri->withPath('/postgres')->__toString());
-    }
-
     /**
      * @param DbDriverInterface $dbDriver
      * @param $database
@@ -45,12 +42,14 @@ protected static function createDatabaseIfNotExists(DbDriverInterface $dbDriver,
         }
     }
 
+    #[\Override]
     public function createDatabase(): void
     {
-        $database = preg_replace('~^/~', '', $this->getDbDriver()->getUri()->getPath());
+        $database = static::getDatabaseName($this->getDbDriver()->getUri());
         static::createDatabaseIfNotExists($this->getDbDriver(), $database);
     }
 
+    #[\Override]
     public function dropDatabase(): void
     {
         $iterator = $this->getDbDriver()->getIterator(
@@ -65,16 +64,22 @@ public function dropDatabase(): void
      * @throws DatabaseNotVersionedException
      * @throws OldVersionSchemaException
      */
+    #[\Override]
     public function createVersion(): void
     {
         $this->getDbDriver()->execute('CREATE TABLE IF NOT EXISTS ' . $this->getMigrationTable() . ' (version int, status varchar(20), PRIMARY KEY (version))');
         $this->checkExistsVersion();
     }
 
+    #[\Override]
     public function executeSql(string $sql): void
     {
         $statements = preg_split("/;(\r\n|\r|\n)/", $sql);
 
+        if ($statements === false) {
+            $statements = [$sql];
+        }
+
         foreach ($statements as $sql) {
             $this->executeSqlInternal($sql);
         }
@@ -88,6 +93,7 @@ protected function executeSqlInternal(string $sql): void
         $this->getDbDriver()->execute($sql);
     }
 
+    #[\Override]
     public function isDatabaseVersioned(): bool
     {
         return $this->isTableExists('public', $this->getMigrationTable());
diff --git a/src/Database/SqliteDatabase.php b/src/Database/SqliteDatabase.php
index 1979e45..7e97d75 100644
--- a/src/Database/SqliteDatabase.php
+++ b/src/Database/SqliteDatabase.php
@@ -8,21 +8,25 @@
 
 class SqliteDatabase extends AbstractDatabase
 {
+    #[\Override]
     public static function schema(): string
     {
         return 'sqlite';
     }
 
+    #[\Override]
     public static function prepareEnvironment(UriInterface $uri): void
     {
         // There is no need to prepare the database
     }
 
+    #[\Override]
     public function createDatabase(): void
     {
         // There is no need to create a database in SQLite
     }
 
+    #[\Override]
     public function dropDatabase(): void
     {
         $iterator = $this->getDbDriver()->getIterator("
@@ -49,16 +53,22 @@ public function dropDatabase(): void
      * @throws DatabaseNotVersionedException
      * @throws OldVersionSchemaException
      */
+    #[\Override]
     public function createVersion(): void
     {
         $this->getDbDriver()->execute('CREATE TABLE IF NOT EXISTS ' . $this->getMigrationTable() . ' (version int, status varchar(20), PRIMARY KEY (version))');
         $this->checkExistsVersion();
     }
 
+    #[\Override]
     public function executeSql(string $sql): void
     {
         $statements = preg_split("/;(\r\n|\r|\n)/", $sql);
 
+        if ($statements === false) {
+            $statements = [$sql];
+        }
+
         foreach ($statements as $sql) {
             $this->executeSqlInternal($sql);
         }
@@ -72,6 +82,7 @@ protected function executeSqlInternal(string $sql): void
         $this->getDbDriver()->execute($sql);
     }
 
+    #[\Override]
     protected function isTableExists(?string $schema, string $table): bool
     {
         $count = $this->getDbDriver()->getScalar(
@@ -84,6 +95,7 @@ protected function isTableExists(?string $schema, string $table): bool
         return (intval($count) !== 0);
     }
 
+    #[\Override]
     public function isDatabaseVersioned(): bool
     {
         return $this->isTableExists(null, $this->getMigrationTable());
diff --git a/src/Migration.php b/src/Migration.php
index 17d2f4c..b9ca5be 100644
--- a/src/Migration.php
+++ b/src/Migration.php
@@ -2,7 +2,7 @@
 
 namespace ByJG\DbMigration;
 
-use ByJG\AnyDataset\Db\DbDriverInterface;
+use ByJG\AnyDataset\Db\Interfaces\DbDriverInterface;
 use ByJG\DbMigration\Database\DatabaseInterface;
 use ByJG\DbMigration\Exception\DatabaseDoesNotRegistered;
 use ByJG\DbMigration\Exception\DatabaseIsIncompleteException;
@@ -82,7 +82,8 @@ public function withTransactionEnabled($enabled = true): static
      */
     public static function registerDatabase(string $class): void
     {
-        if (!in_array(DatabaseInterface::class, class_implements($class))) {
+        $implements = class_implements($class);
+        if ($implements === false || !in_array(DatabaseInterface::class, $implements)) {
             throw new InvalidArgumentException('Class not implements DatabaseInterface!');
         }
 
@@ -110,7 +111,9 @@ public function getDbCommand(): DatabaseInterface
     {
         if (is_null($this->dbCommand)) {
             $class = $this->getDatabaseClassName();
-            $this->dbCommand = new $class($this->uri, $this->migrationTable);
+            /** @var DatabaseInterface $instance */
+            $instance = new $class($this->uri, $this->migrationTable);
+            $this->dbCommand = $instance;
         }
         return $this->dbCommand;
     }
@@ -167,7 +170,12 @@ public function getMigrationSql(int $version, int $increment): ?string
             . "/" . ($increment < 0 ? "down" : "up")
             . "/*.sql";
 
-        $result = array_filter(glob($filePattern), function ($file) use ($version) {
+        $files = glob($filePattern);
+        if ($files === false) {
+            $files = [];
+        }
+
+        $result = array_filter($files, function ($file) use ($version) {
             return preg_match("/^0*$version(-[\w\d-]*)?\.sql$/", basename($file));
         });
 
@@ -186,10 +194,12 @@ public function getMigrationSql(int $version, int $increment): ?string
 
     /**
      * Get the file contents and metainfo
-     * @param $file
+     *
+     * @param null|string $file
+     *
      * @return array
      */
-    public function getFileContent($file): array
+    public function getFileContent(string|null $file): array
     {
         $data = [
             "file" => $file,
@@ -202,14 +212,20 @@ public function getFileContent($file): array
             return $data;
         }
 
-        $data["content"] = file_get_contents($file);
+        $content = file_get_contents($file);
+
+        if ($content === false) {
+            return $data;
+        }
+
+        $data["content"] = $content;
 
-        if (preg_match("/--\s*@description:\s*(?<name>.*)/", $data["content"], $description)) {
+        if (preg_match("/--\s*@description:\s*(?<name>.*)/", $content, $description)) {
             $data["description"] = $description["name"];
         }
 
         $data["exists"] = true;
-        $data["checksum"] = sha1($data["content"]);
+        $data["checksum"] = sha1($content);
 
         return $data;
     }
@@ -236,7 +252,7 @@ public function prepareEnvironment(): void
      * @throws InvalidMigrationFile
      * @throws OldVersionSchemaException
      */
-    public function reset(int $upVersion = null): void
+    public function reset(?int $upVersion = null): void
     {
         $fileInfo = $this->getFileContent($this->getBaseSql());
 
@@ -415,7 +431,7 @@ public function down(?int $upVersion = null, bool $force = false): void
      */
     public function addCallbackProgress(callable $callable): void
     {
-        $this->callableProgress = $callable;
+        $this->callableProgress = $callable instanceof Closure ? $callable : Closure::fromCallable($callable);
     }
 
     /**
diff --git a/tests/BaseDatabase.php b/tests/BaseDatabase.php
index a40a5a6..d0562d3 100644
--- a/tests/BaseDatabase.php
+++ b/tests/BaseDatabase.php
@@ -12,6 +12,7 @@
 use ByJG\Serializer\Exception\InvalidArgumentException;
 use PHPUnit\Framework\TestCase;
 use Psr\Http\Message\UriInterface;
+use Override;
 
 abstract class BaseDatabase extends TestCase
 {
@@ -24,21 +25,27 @@ abstract class BaseDatabase extends TestCase
 
     protected string $migrationTable = "migration_version";
 
+    protected string $skipTest = "";
+
     /**
      * @throws DatabaseDoesNotRegistered
      */
+    #[Override]
     public function setUp(): void
     {
         // create Migrate object in the parent!!!
-
         $this->migrate->prepareEnvironment();
     }
 
     /**
      * @throws DatabaseDoesNotRegistered
      */
+    #[Override]
     public function tearDown(): void
     {
+        if (!empty($this->skipTest)) {
+            return;
+        }
         $this->migrate->getDbCommand()->dropDatabase();
     }
 
@@ -49,14 +56,20 @@ public function tearDown(): void
      * @throws InvalidMigrationFile
      * @throws OldVersionSchemaException
      */
-    public function testVersion0()
+    public function testVersion0(): void
     {
+        if (!empty($this->skipTest)) {
+            $this->markTestSkipped($this->skipTest);
+        }
         $this->migrate->reset(0);
         $this->assertVersion0();
     }
 
-    public function testIsDatabaseVersioned()
+    public function testIsDatabaseVersioned(): void
     {
+        if (!empty($this->skipTest)) {
+            $this->markTestSkipped($this->skipTest);
+        }
         $this->assertFalse($this->migrate->isDatabaseVersioned());
         $this->migrate->reset();
         $this->assertTrue($this->migrate->isDatabaseVersioned());
@@ -69,8 +82,11 @@ public function testIsDatabaseVersioned()
      * @throws InvalidMigrationFile
      * @throws OldVersionSchemaException
      */
-    public function testUpVersion1()
+    public function testUpVersion1(): void
     {
+        if (!empty($this->skipTest)) {
+            $this->markTestSkipped($this->skipTest);
+        }
         $this->migrate->reset(0);
         $this->assertVersion0();
         $this->migrate->up(1);
@@ -85,8 +101,11 @@ public function testUpVersion1()
      * @throws OldVersionSchemaException
      * @throws InvalidArgumentException
      */
-    public function testUpVersion2()
+    public function testUpVersion2(): void
     {
+        if (!empty($this->skipTest)) {
+            $this->markTestSkipped($this->skipTest);
+        }
         $this->migrate->reset(0);
         $this->assertVersion0();
         $this->migrate->up(2);
@@ -101,8 +120,11 @@ public function testUpVersion2()
      * @throws OldVersionSchemaException
      * @throws InvalidArgumentException
      */
-    public function testDownVersion1()
+    public function testDownVersion1(): void
     {
+        if (!empty($this->skipTest)) {
+            $this->markTestSkipped($this->skipTest);
+        }
         $this->migrate->reset();
         $this->assertVersion2();
         $this->migrate->down(1);
@@ -117,8 +139,11 @@ public function testDownVersion1()
      * @throws OldVersionSchemaException
      * @throws InvalidArgumentException
      */
-    public function testDownVersion0()
+    public function testDownVersion0(): void
     {
+        if (!empty($this->skipTest)) {
+            $this->markTestSkipped($this->skipTest);
+        }
         $this->migrate->reset();
         $this->assertVersion2();
         $this->migrate->down(0);
@@ -133,6 +158,14 @@ protected function getExpectedUsersVersion0(): array
         ];
     }
 
+    /**
+     * @return string
+     */
+    protected function getSelectUsersVersion1(): string
+    {
+        return 'select * from users';
+    }
+
     protected function getExpectedUsersVersion1(): array
     {
         return [
@@ -160,21 +193,23 @@ protected function assertVersion0(): void
 
         $iterator = $this->migrate->getDbDriver()->getIterator('select * from users');
 
-        $this->assertTrue($iterator->hasNext());
-        $row = $iterator->moveNext();
+        $this->assertNotNull($iterator->current());
+        $row = $iterator->current();
         $this->assertEquals(
             $this->getExpectedUsersVersion0()[0],
             $row->toArray()
         );
 
-        $this->assertTrue($iterator->hasNext());
-        $row = $iterator->moveNext();
+        $iterator->next();
+        $this->assertNotNull($iterator->current());
+        $row = $iterator->current();
         $this->assertEquals(
             $this->getExpectedUsersVersion0()[1],
             $row->toArray()
         );
 
-        $this->assertFalse($iterator->hasNext());
+        $iterator->next();
+        $this->assertNull($iterator->current());
 
         try {
             $this->migrate->getDbDriver()->getIterator('select * from roles');
@@ -193,23 +228,25 @@ protected function assertVersion1(): void
         $status = $this->migrate->getDbDriver()->getScalar('select status from '. $this->migrationTable);
         $this->assertEquals(MigrationStatus::complete->value, $status);
 
-        $iterator = $this->migrate->getDbDriver()->getIterator('select * from users');
+        $iterator = $this->migrate->getDbDriver()->getIterator($this->getSelectUsersVersion1());
 
-        $this->assertTrue($iterator->hasNext());
-        $row = $iterator->moveNext();
+        $this->assertNotNull($iterator->current());
+        $row = $iterator->current();
         $this->assertEquals(
             $this->getExpectedUsersVersion1()[0],
             $row->toArray()
         );
 
-        $this->assertTrue($iterator->hasNext());
-        $row = $iterator->moveNext();
+        $iterator->next();
+        $this->assertNotNull($iterator->current());
+        $row = $iterator->current();
         $this->assertEquals(
             $this->getExpectedUsersVersion1()[1],
             $row->toArray()
         );
 
-        $this->assertFalse($iterator->hasNext());
+        $iterator->next();
+        $this->assertNull($iterator->current());
 
         try {
             $this->migrate->getDbDriver()->getIterator('select * from roles');
@@ -222,7 +259,7 @@ protected function assertVersion1(): void
      * @throws DatabaseDoesNotRegistered
      * @throws InvalidArgumentException
      */
-    protected function assertVersion2()
+    protected function assertVersion2(): void
     {
         $version = $this->migrate->getDbDriver()->getScalar('select version from '. $this->migrationTable);
         $this->assertEquals(2, $version);
@@ -230,29 +267,31 @@ protected function assertVersion2()
         $this->assertEquals(MigrationStatus::complete->value, $status);
 
         // Users
-        $iterator = $this->migrate->getDbDriver()->getIterator('select * from users');
+        $iterator = $this->migrate->getDbDriver()->getIterator($this->getSelectUsersVersion1());
 
-        $this->assertTrue($iterator->hasNext());
-        $row = $iterator->moveNext();
+        $this->assertNotNull($iterator->current());
+        $row = $iterator->current();
         $this->assertEquals(
             $this->getExpectedUsersVersion1()[0],
             $row->toArray()
         );
 
-        $this->assertTrue($iterator->hasNext());
-        $row = $iterator->moveNext();
+        $iterator->next();
+        $this->assertNotNull($iterator->current());
+        $row = $iterator->current();
         $this->assertEquals(
             $this->getExpectedUsersVersion1()[1],
             $row->toArray()
         );
 
-        $this->assertFalse($iterator->hasNext());
+        $iterator->next();
+        $this->assertNull($iterator->current());
 
         // Posts
         $iterator = $this->migrate->getDbDriver()->getIterator('select * from posts');
 
-        $this->assertTrue($iterator->hasNext());
-        $row = $iterator->moveNext();
+        $this->assertNotNull($iterator->current());
+        $row = $iterator->current();
         $this->assertEquals(
             $this->getExpectedPostsVersion2()[0],
             $row->toArray()
@@ -263,8 +302,11 @@ protected function assertVersion2()
      * @throws DatabaseDoesNotRegistered
      * @throws OldVersionSchemaException
      */
-    public function testGetCurrentVersionIsEmpty()
+    public function testGetCurrentVersionIsEmpty(): void
     {
+        if (!empty($this->skipTest)) {
+            $this->markTestSkipped($this->skipTest);
+        }
         $this->expectException(DatabaseNotVersionedException::class);
         $this->migrate->getCurrentVersion();
     }
@@ -272,8 +314,11 @@ public function testGetCurrentVersionIsEmpty()
     /**
      * @throws DatabaseDoesNotRegistered
      */
-    public function testCreateVersion()
+    public function testCreateVersion(): void
     {
+        if (!empty($this->skipTest)) {
+            $this->markTestSkipped($this->skipTest);
+        }
         $this->migrate->createVersion();
         $records = $this->migrate->getDbDriver()->getIterator("select * from " . $this->migrationTable)->toArray();
         $this->assertEquals([
diff --git a/tests/MigrateCommandTest.php b/tests/MigrateCommandTest.php
new file mode 100644
index 0000000..9238605
--- /dev/null
+++ b/tests/MigrateCommandTest.php
@@ -0,0 +1,280 @@
+<?php
+
+namespace Tests;
+
+use ByJG\DbMigration\Console\MigrateCommand;
+use Override;
+use PHPUnit\Framework\TestCase;
+
+class MigrateCommandTest extends TestCase
+{
+    protected string $testDir;
+    protected string $dbPath;
+
+    #[Override]
+    protected function setUp(): void
+    {
+        $this->testDir = sys_get_temp_dir() . '/migration-cli-test-' . uniqid();
+        $this->dbPath = $this->testDir . '/test.db';
+
+        // Create test migration directory structure
+        mkdir($this->testDir);
+        mkdir($this->testDir . '/migrations');
+        mkdir($this->testDir . '/migrations/up');
+        mkdir($this->testDir . '/migrations/down');
+
+        // Create base.sql
+        file_put_contents($this->testDir . '/base.sql', <<<'SQL'
+-- @description: Base schema for testing
+CREATE TABLE users (
+    id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL
+);
+SQL
+        );
+
+        // Create migration up script
+        file_put_contents($this->testDir . '/migrations/up/1.sql', <<<'SQL'
+-- @description: Add email column
+ALTER TABLE users ADD COLUMN email TEXT;
+SQL
+        );
+
+        // Create migration down script
+        file_put_contents($this->testDir . '/migrations/down/1.sql', <<<'SQL'
+-- @description: Remove email column
+ALTER TABLE users DROP COLUMN email;
+SQL
+        );
+    }
+
+    #[Override]
+    protected function tearDown(): void
+    {
+        // Clean up test directory
+        if (file_exists($this->testDir)) {
+            $this->rrmdir($this->testDir);
+        }
+    }
+
+    private function rrmdir($dir): void
+    {
+        if (is_dir($dir)) {
+            $objects = scandir($dir);
+            foreach ($objects as $object) {
+                if ($object != "." && $object != "..") {
+                    if (is_dir($dir . "/" . $object)) {
+                        $this->rrmdir($dir . "/" . $object);
+                    } else {
+                        unlink($dir . "/" . $object);
+                    }
+                }
+            }
+            rmdir($dir);
+        }
+    }
+
+    private function runCommand(array $args): int
+    {
+        $argv = array_merge(['migrate'], $args);
+        $command = new MigrateCommand($argv);
+
+        // Capture output
+        ob_start();
+        $exitCode = $command->run();
+        ob_end_clean();
+
+        return $exitCode;
+    }
+
+    public function testHelpCommand(): void
+    {
+        ob_start();
+        $exitCode = $this->runCommand(['--help']);
+        $output = ob_get_clean();
+
+        $this->assertEquals(0, $exitCode);
+    }
+
+    public function testCreateCommand(): void
+    {
+        $exitCode = $this->runCommand([
+            'create',
+            '-c', 'sqlite://' . $this->dbPath,
+            '-p', $this->testDir
+        ]);
+
+        $this->assertEquals(0, $exitCode);
+        $this->assertFileExists($this->dbPath);
+    }
+
+    public function testVersionCommand(): void
+    {
+        // Create version table first
+        $this->runCommand([
+            'create',
+            '-c', 'sqlite://' . $this->dbPath,
+            '-p', $this->testDir
+        ]);
+
+        // Check version
+        $exitCode = $this->runCommand([
+            'version',
+            '-c', 'sqlite://' . $this->dbPath,
+            '-p', $this->testDir
+        ]);
+
+        $this->assertEquals(0, $exitCode);
+    }
+
+    public function testResetCommand(): void
+    {
+        // Create version table first
+        $this->runCommand([
+            'create',
+            '-c', 'sqlite://' . $this->dbPath,
+            '-p', $this->testDir
+        ]);
+
+        // Reset database
+        $exitCode = $this->runCommand([
+            'reset',
+            '-c', 'sqlite://' . $this->dbPath,
+            '-p', $this->testDir
+        ]);
+
+        $this->assertEquals(0, $exitCode);
+    }
+
+    public function testUpCommand(): void
+    {
+        // Create and reset database
+        $this->runCommand([
+            'create',
+            '-c', 'sqlite://' . $this->dbPath,
+            '-p', $this->testDir
+        ]);
+
+        $this->runCommand([
+            'reset',
+            '-c', 'sqlite://' . $this->dbPath,
+            '-p', $this->testDir,
+            '--version', '0'
+        ]);
+
+        // Migrate up
+        $exitCode = $this->runCommand([
+            'up',
+            '-c', 'sqlite://' . $this->dbPath,
+            '-p', $this->testDir,
+            '--version', '1'
+        ]);
+
+        $this->assertEquals(0, $exitCode);
+    }
+
+    public function testDownCommand(): void
+    {
+        // Create and reset database
+        $this->runCommand([
+            'create',
+            '-c', 'sqlite://' . $this->dbPath,
+            '-p', $this->testDir
+        ]);
+
+        $this->runCommand([
+            'reset',
+            '-c', 'sqlite://' . $this->dbPath,
+            '-p', $this->testDir
+        ]);
+
+        // Migrate down
+        $exitCode = $this->runCommand([
+            'down',
+            '-c', 'sqlite://' . $this->dbPath,
+            '-p', $this->testDir,
+            '--version', '0'
+        ]);
+
+        $this->assertEquals(0, $exitCode);
+    }
+
+    public function testUpdateCommand(): void
+    {
+        // Create and reset database
+        $this->runCommand([
+            'create',
+            '-c', 'sqlite://' . $this->dbPath,
+            '-p', $this->testDir
+        ]);
+
+        $this->runCommand([
+            'reset',
+            '-c', 'sqlite://' . $this->dbPath,
+            '-p', $this->testDir,
+            '--version', '0'
+        ]);
+
+        // Update to version 1
+        $exitCode = $this->runCommand([
+            'update',
+            '-c', 'sqlite://' . $this->dbPath,
+            '-p', $this->testDir,
+            '--version', '1'
+        ]);
+
+        $this->assertEquals(0, $exitCode);
+    }
+
+    public function testEnvironmentVariableConnection(): void
+    {
+        putenv('MIGRATION_CONNECTION=sqlite://' . $this->dbPath);
+
+        $exitCode = $this->runCommand([
+            'create',
+            '-p', $this->testDir
+        ]);
+
+        $this->assertEquals(0, $exitCode);
+
+        putenv('MIGRATION_CONNECTION');
+    }
+
+    public function testEnvironmentVariablePath(): void
+    {
+        putenv('MIGRATION_CONNECTION=sqlite://' . $this->dbPath);
+        putenv('MIGRATION_PATH=' . $this->testDir);
+
+        $exitCode = $this->runCommand(['create']);
+
+        $this->assertEquals(0, $exitCode);
+
+        putenv('MIGRATION_CONNECTION');
+        putenv('MIGRATION_PATH');
+    }
+
+    public function testEnvironmentVariableTable(): void
+    {
+        putenv('MIGRATION_CONNECTION=sqlite://' . $this->dbPath);
+        putenv('MIGRATION_PATH=' . $this->testDir);
+        putenv('MIGRATION_TABLE=custom_migration_table');
+
+        $exitCode = $this->runCommand(['create']);
+
+        $this->assertEquals(0, $exitCode);
+
+        putenv('MIGRATION_CONNECTION');
+        putenv('MIGRATION_PATH');
+        putenv('MIGRATION_TABLE');
+    }
+
+    public function testMissingConnectionError(): void
+    {
+        $exitCode = $this->runCommand([
+            'version',
+            '-p', $this->testDir
+        ]);
+
+        $this->assertEquals(1, $exitCode);
+    }
+}
diff --git a/tests/MigrationTest.php b/tests/MigrationTest.php
index 45d2a2c..810c20a 100644
--- a/tests/MigrationTest.php
+++ b/tests/MigrationTest.php
@@ -5,95 +5,99 @@
 use ByJG\DbMigration\Exception\InvalidMigrationFile;
 use ByJG\DbMigration\Migration;
 use ByJG\Util\Uri;
+use PHPUnit\Framework\TestCase;
+use PHPUnit\Framework\Attributes\Override;
 
-class MigrationTest extends \PHPUnit\Framework\TestCase
+class MigrationTest extends TestCase
 {
     /**
      * @var Migration
      */
     protected $object;
 
+    #[\Override]
     public function setUp(): void
     {
         $this->object = new Migration(new Uri('mysql://localhost'), __DIR__ . '/dirstructure');
     }
 
+    #[\Override]
     public function tearDown(): void
     {
         $this->object = null;
     }
 
-    public function testGetBaseSql()
+    public function testGetBaseSql(): void
     {
         $base = $this->object->getBaseSql();
         $this->assertEquals(__DIR__ . '/dirstructure/base.sql', $base);
     }
 
-    public function testGetBaseSqlNotFound()
+    public function testGetBaseSqlNotFound(): void
     {
         $this->expectException(InvalidMigrationFile::class);
         $this->object = new Migration(new Uri('mysql://localhost'), __DIR__ . '/invalid');
         $this->object->getBaseSql();
     }
 
-    public function testGetBaseSqlNotFoundAndNotRequired()
+    public function testGetBaseSqlNotFoundAndNotRequired(): void
     {
         $this->object = new Migration(new Uri('mysql://localhost'), __DIR__ . '/invalid', false);
         $this->object->getBaseSql();
         $this->assertTrue(true);
     }
 
-    public function testGetMigrationSql1()
+    public function testGetMigrationSql1(): void
     {
         $version = $this->object->getMigrationSql(1, 1);
         $this->assertEquals(__DIR__ . '/dirstructure/migrations/up/00001.sql', $version);
     }
 
-    public function testGetMigrationSql2()
+    public function testGetMigrationSql2(): void
     {
         $version = $this->object->getMigrationSql(2, 1);
         $this->assertEquals(__DIR__ . '/dirstructure/migrations/up/00002.sql', $version);
     }
 
-    public function testGetMigrationSql3()
+    public function testGetMigrationSql3(): void
     {
         $version = $this->object->getMigrationSql(12, 1);
         $this->assertEquals(__DIR__ . '/dirstructure/migrations/up/00012-dev.sql', $version);
     }
 
-    public function testGetMigrationSql4()
+    public function testGetMigrationSql4(): void
     {
         $this->expectException(InvalidMigrationFile::class);
         $this->expectExceptionMessage("You have two files with the same version number '13'");
         $this->object->getMigrationSql(13, 1);
     }
 
-    public function testGetMigrationSqlDown1()
+    public function testGetMigrationSqlDown1(): void
     {
         $version = $this->object->getMigrationSql(1, -1);
         $this->assertEquals(__DIR__ . '/dirstructure/migrations/down/00001.sql', $version);
     }
 
-    public function testGetMigrationSqlDown2()
+    public function testGetMigrationSqlDown2(): void
     {
         $version = $this->object->getMigrationSql(2, -1);
         $this->assertEquals(__DIR__ . '/dirstructure/migrations/down/00002.sql', $version);
     }
 
-    public function testGetMigrationSqlDown3()
+    public function testGetMigrationSqlDown3(): void
     {
         $version = $this->object->getMigrationSql(12, -1);
         $this->assertEquals(__DIR__ . '/dirstructure/migrations/down/00012-dev.sql', $version);
     }
 
-    public function testGetMigrationSqlDown4()
+    public function testGetMigrationSqlDown4(): void
     {
         $this->expectException(InvalidMigrationFile::class);
         $this->expectExceptionMessage("version number '13'");
         $this->object->getMigrationSql(13, -1);
     }
 
-    public function testGetFileContent_NonExists()
+    public function testGetFileContent_NonExists(): void
     {
         $this->assertEquals(
             [
@@ -107,7 +111,7 @@ public function testGetFileContent_NonExists()
         );
     }
 
-    public function testGetFileContent_1()
+    public function testGetFileContent_1(): void
     {
         $this->assertEquals(
             [
@@ -121,7 +125,7 @@ public function testGetFileContent_1()
         );
     }
 
-    public function testGetFileContent_2()
+    public function testGetFileContent_2(): void
     {
         $this->assertEquals(
             [
@@ -135,7 +139,7 @@ public function testGetFileContent_2()
         );
     }
 
-    public function testGetFileContent_3()
+    public function testGetFileContent_3(): void
     {
         $this->assertEquals(
             [
@@ -149,7 +153,7 @@ public function testGetFileContent_3()
         );
     }
 
-    public function testReset()
+    public function testReset(): void
     {
         $this->expectException(\PDOException::class);
         Migration::registerDatabase(SqliteDatabase::class);
@@ -157,7 +161,7 @@ public function testReset()
         $this->object->reset();
     }
 
-    public function testResetWithoutTransactionCheck()
+    public function testResetWithoutTransactionCheck(): void
     {
         try {
             Migration::registerDatabase(SqliteDatabase::class);
@@ -168,7 +172,7 @@ public function testResetWithoutTransactionCheck()
         }
     }
 
-    public function testResetWithTransactionCheck()
+    public function testResetWithTransactionCheck(): void
     {
         try {
             Migration::registerDatabase(SqliteDatabase::class);
diff --git a/tests/MysqlDatabaseCustomTest.php b/tests/MysqlDatabaseCustomTest.php
index c313136..db0c892 100644
--- a/tests/MysqlDatabaseCustomTest.php
+++ b/tests/MysqlDatabaseCustomTest.php
@@ -2,9 +2,9 @@
 
 namespace Tests;
 
-/**
- * @requires extension pdo_mysql
- */
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
+
+#[RequiresPhpExtension('pdo_mysql')]
 class MysqlDatabaseCustomTest extends MysqlDatabaseTest
 {
     protected string $migrationTable = "some_table_version";
diff --git a/tests/MysqlDatabaseTest.php b/tests/MysqlDatabaseTest.php
index 58063b1..4c22e66 100644
--- a/tests/MysqlDatabaseTest.php
+++ b/tests/MysqlDatabaseTest.php
@@ -3,19 +3,25 @@
 namespace Tests;
 
 use ByJG\DbMigration\Database\MySqlDatabase;
+use ByJG\DbMigration\Exception\DatabaseDoesNotRegistered;
+use ByJG\DbMigration\Exception\InvalidMigrationFile;
 use ByJG\DbMigration\Migration;
 use ByJG\Util\Uri;
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 
-/**
- * @requires extension pdo_mysql
- */
+#[RequiresPhpExtension('pdo_mysql')]
 class MysqlDatabaseTest extends BaseDatabase
 {
     /**
-     * @var Migration
+     * @var Migration|null
      */
     protected ?Migration $migrate = null;
 
+    /**
+     * @throws DatabaseDoesNotRegistered
+     * @throws InvalidMigrationFile
+     */
+    #[\Override]
     public function setUp(): void
     {
         $host = getenv('MYSQL_TEST_HOST');
diff --git a/tests/PostgresDatabaseCustomTest.php b/tests/PostgresDatabaseCustomTest.php
index 29ddf86..0afbdc3 100644
--- a/tests/PostgresDatabaseCustomTest.php
+++ b/tests/PostgresDatabaseCustomTest.php
@@ -2,9 +2,10 @@
 
 namespace Tests;
 
-/**
- * @requires extension pdo_pgsql
- */
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
+use PHPUnit\Framework\Attributes\Override;
+
+#[RequiresPhpExtension('pdo_pgsql')]
 class PostgresDatabaseCustomTest extends PostgresDatabaseTest
 {
     protected string $migrationTable = "some_table_version";
diff --git a/tests/PostgresDatabaseTest.php b/tests/PostgresDatabaseTest.php
index 612ac90..73a11e3 100644
--- a/tests/PostgresDatabaseTest.php
+++ b/tests/PostgresDatabaseTest.php
@@ -5,17 +5,20 @@
 use ByJG\DbMigration\Database\PgsqlDatabase;
 use ByJG\DbMigration\Migration;
 use ByJG\Util\Uri;
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
 
 /**
  * @requires extension pdo_pgsql
  */
+#[RequiresPhpExtension('pdo_pgsql')]
 class PostgresDatabaseTest extends BaseDatabase
 {
     /**
-     * @var Migration
+     * @var Migration|null
      */
     protected ?Migration $migrate = null;
 
+    #[\Override]
     public function setUp(): void
     {
         $host = getenv('PSQL_TEST_HOST');
diff --git a/tests/SqlServerDblibDatabaseCustomTest.php b/tests/SqlServerDblibDatabaseCustomTest.php
index c75c2ae..e4ba330 100644
--- a/tests/SqlServerDblibDatabaseCustomTest.php
+++ b/tests/SqlServerDblibDatabaseCustomTest.php
@@ -2,9 +2,13 @@
 
 namespace Tests;
 
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
+use PHPUnit\Framework\Attributes\Override;
+
 /**
  * @requires extension pdo_dblib
  */
+#[RequiresPhpExtension('pdo_dblib')]
 class SqlServerDblibDatabaseCustomTest extends SqlServerDblibDatabaseTest
 {
     protected string $migrationTable = "some_table_version";
diff --git a/tests/SqlServerDblibDatabaseTest.php b/tests/SqlServerDblibDatabaseTest.php
index 38fe7ad..d8b36be 100644
--- a/tests/SqlServerDblibDatabaseTest.php
+++ b/tests/SqlServerDblibDatabaseTest.php
@@ -5,10 +5,13 @@
 use ByJG\DbMigration\Database\DblibDatabase;
 use ByJG\DbMigration\Migration;
 use ByJG\Util\Uri;
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
+use PHPUnit\Framework\Attributes\Override;
 
 /**
  * @requires extension pdo_dblib
  */
+#[RequiresPhpExtension('pdo_dblib')]
 class SqlServerDblibDatabaseTest extends BaseDatabase
 {
     /**
@@ -18,6 +21,7 @@ class SqlServerDblibDatabaseTest extends BaseDatabase
 
     protected string $scheme = "dblib";
 
+    #[\Override]
     public function setUp(): void
     {
         $host = getenv('MSSQL_TEST_HOST');
@@ -37,16 +41,12 @@ public function setUp(): void
         parent::setUp();
     }
 
-    public function getExpectedUsersVersion1(): array
+    #[\Override]
+    /**
+     * @return string
+     */
+    public function getSelectUsersVersion1(): string
     {
-        if ($this->scheme == "sqlsrv") {
-            return parent::getExpectedUsersVersion1();
-        }
-
-        return [
-            ["id" => 1, "name" => 'John Doe', 'createdate' => '2016-01-10 00:00:00'],
-            ["id" => 2, "name" => 'Jane Doe', 'createdate' => '2015-12-30 00:00:00']
-        ];
+        return "select id, name, FORMAT(createdate, 'yyyy-MM-dd') as createdate from users";
     }
-
 }
diff --git a/tests/SqlServerSqlsrvDatabaseCustomTest.php b/tests/SqlServerSqlsrvDatabaseCustomTest.php
index 788bfb8..0647839 100644
--- a/tests/SqlServerSqlsrvDatabaseCustomTest.php
+++ b/tests/SqlServerSqlsrvDatabaseCustomTest.php
@@ -2,9 +2,13 @@
 
 namespace Tests;
 
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
+use PHPUnit\Framework\Attributes\Override;
+
 /**
  * @requires extension pdo_dblib
  */
+#[RequiresPhpExtension('pdo_dblib')]
 class SqlServerSqlsrvDatabaseCustomTest extends SqlServerSqlsrvDatabaseTest
 {
     protected string $migrationTable = "some_table_version";
diff --git a/tests/SqlServerSqlsrvDatabaseTest.php b/tests/SqlServerSqlsrvDatabaseTest.php
index 3af5541..385a0ed 100644
--- a/tests/SqlServerSqlsrvDatabaseTest.php
+++ b/tests/SqlServerSqlsrvDatabaseTest.php
@@ -5,14 +5,22 @@
 use ByJG\DbMigration\Database\DblibDatabase;
 use ByJG\DbMigration\Migration;
 use ByJG\Util\Uri;
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
+use PHPUnit\Framework\Attributes\Override;
 
 /**
  * @requires extension pdo_dblib
  */
+#[RequiresPhpExtension('pdo_dblib')]
 class SqlServerSqlsrvDatabaseTest extends SqlServerDblibDatabaseTest
 {
+    #[\Override]
     public function setUp(): void
     {
+        if (!extension_loaded('pdo_sqlsrv')) {
+            $this->skipTest = "pdo_sqlsrv extension not loaded";
+            return;
+        }
         $this->scheme = "sqlsrv";
         parent::setUp();
     }
diff --git a/tests/SqliteDatabaseCustomTest.php b/tests/SqliteDatabaseCustomTest.php
index b49a717..4352686 100644
--- a/tests/SqliteDatabaseCustomTest.php
+++ b/tests/SqliteDatabaseCustomTest.php
@@ -2,9 +2,14 @@
 
 namespace Tests;
 
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
+use PHPUnit\Framework\Attributes\Override;
+use PHPUnit\Framework\TestCase;
+
 /**
  * @requires extension pdo_sqlite
  */
+#[RequiresPhpExtension('pdo_sqlite')]
 class SqliteDatabaseCustomTest extends SqliteDatabaseTest
 {
     protected string $migrationTable = "some_table_version";
diff --git a/tests/SqliteDatabaseTest.php b/tests/SqliteDatabaseTest.php
index 61da272..2fe2119 100644
--- a/tests/SqliteDatabaseTest.php
+++ b/tests/SqliteDatabaseTest.php
@@ -5,10 +5,13 @@
 use ByJG\DbMigration\Database\SqliteDatabase;
 use ByJG\DbMigration\Migration;
 use ByJG\Util\Uri;
+use PHPUnit\Framework\Attributes\RequiresPhpExtension;
+use PHPUnit\Framework\Attributes\Override;
 
 /**
  * @requires extension pdo_sqlite
  */
+#[RequiresPhpExtension('pdo_sqlite')]
 class SqliteDatabaseTest extends BaseDatabase
 {
     protected $path = '';
@@ -18,6 +21,7 @@ class SqliteDatabaseTest extends BaseDatabase
      */
     protected ?Migration $migrate = null;
 
+    #[\Override]
     public function setUp(): void
     {
         $this->path = getenv('SQLITE_TEST_HOST');
@@ -36,7 +40,7 @@ public function setUp(): void
         parent::setUp();
     }
 
-    public function testUsingCustomTable()
+    public function testUsingCustomTable(): void
     {
         $this->migrationTable = 'migration_table';
 
@@ -50,7 +54,7 @@ public function testUsingCustomTable()
         parent::testUpVersion1();
     }
 
-    protected function prepareDatabase() {
+    protected function prepareDatabase(): void {
         if ($this->path != ":memory:") {
             file_put_contents($this->path, '');
         }