DbCli - Database CLI Tool for AI Agents Support for 30+ Databases

Universal Database CLI with Agent Skills Specification support

Cross-database command line tool based on .NET 10 and SqlSugar, designed for AI agent integration through Agent Skills Specification.

CLI routing is implemented with ConsoleAppFramework.

Features

Supports 30+ databases (see Supported Databases)
Multiple output formats: JSON, Table, CSV
Interactive SQL mode
Configurable connection strings (command line, config file, environment variables)
Single executable deployment (self-contained single-file binaries)
Agent Skills Specification support

Supported Databases

Supports 30+ databases including:

Relational Databases: SQLite, Microsoft SQL Server, MySQL, MySQL Connector, MariaDB, TiDB, PostgreSQL, Oracle, DaMeng (DM), KingbaseES (Kdbndp), Oscar, HighGo (HG), GaussDB, GBase, IBM DB2, SAP HANA, Microsoft Access
Distributed Databases: OceanBase, PolarDB, TDengine, ClickHouse, Doris
Analytics Databases: QuestDB, DuckDB
NoSQL Databases: MongoDB
MySQL Ecosystem (MySQL-compatible, use -t mysql): Percona Server, Amazon Aurora, Azure Database for MySQL, Google Cloud SQL for MySQL
Generic Connectors: ODBC, Custom database

🤖 AI Agent Integration

DbCli follows the Agent Skills Specification - a universal format for AI assistants to discover and use tools.

Agent Skills are standardized tool definitions that AI assistants can:

✅ Discover automatically - No manual configuration needed
✅ Understand context - Clear descriptions, examples, and error handling
✅ Execute safely - Built-in validation and backup recommendations
✅ Share across Platforms and Coding Agents - Works with Claude Code, GitHub Copilot, OpenAI Codex, Cursor, Gemini Code Assist, Gemini-Cli, Cline/Roo/Kilo, and more on Windows, macOS, Linux

🎯 Use Cases & Scenarios

1. Data Analysis & Reporting

AI Assistant → dbcli-query skill → Database
"Show me top 10 customers by revenue this month"
→ Generates: SELECT query with proper aggregation and filtering

2. Database Management

AI Assistant → dbcli-db-ddl skill → Database
"Create a users table with email validation"
→ Generates: CREATE TABLE with appropriate constraints

3. Automated Backups

AI Assistant → dbcli-export skill → SQL Files
"Export all critical tables before deployment"
→ Generates: Backup scripts with timestamps

4. Cross-Database Operations

Your App → AI Assistant → DbCli Skills → 30+ Databases
Works seamlessly with SQLite, PostgreSQL, MySQL, Oracle, Microsoft SQL Server,DaMeng, KingbaseES, Oscar, HighGo, GaussDB, GBase and more

Quick Setup

1) Download & Extract Release Zip

Download the matching zip from GitHub Releases and extract it to a folder.

Windows: dbcli-win-x64-vX.Y.Z.zip / dbcli-win-arm64-vX.Y.Z.zip
Linux: dbcli-linux-x64-vX.Y.Z.zip / dbcli-linux-arm64-vX.Y.Z.zip
macOS: dbcli-macos-x64-vX.Y.Z.zip / dbcli-macos-arm64-vX.Y.Z.zip

2) Install + Deploy Skills (recommended)

PowerShell (Windows / Linux / macOS with pwsh):

# Run inside the extracted zip folder
# -InstallScripts installs dbcli + scripts + skills to ~/tools/dbcli and adds it to PATH.
pwsh -NoProfile -ExecutionPolicy Bypass -File .\deploy-skills.ps1 -InstallScripts -Target all -WorkDir <workspace_dir> -Force

Linux / macOS / WSL (Python):

# Run inside the extracted zip folder
python3 ./install-dbcli.py --force

# Deploy skills: run from your project root (deploy-skills.py uses current directory for workspace output)
cd <workspace_dir>
python3 <path-to-extracted-zip>/deploy-skills.py --target all --force

Deployment targets: claude, copilot, codex, workspace, all
Common options: PowerShell -Force, -WorkDir (required for non-Codex-global targets), -CodexGlobalOnly (Codex user profile only); Python --force, --codex-global-only
Verify: dbcli --version and check your deployed files (.github/copilot-instructions.md, skills/dbcli/, workspace .claude/skills/dbcli/skills/).

Claude (Web/App) ZIP upload: pwsh ./deploy-skills.ps1 -PackageClaudeSkill dbcli-query -PackageOutDir . (or python3 ./deploy-skills.py --package-claude-skill dbcli-query --package-out-dir .), then upload the ZIP in Claude Settings → Capabilities → Skills.

Rules integration (summary): deployment appends DbCli execution rules (PATH + safety) into common rule files if present: CLAUDE.md, AGENTS.md, .cursorrules, .vscode/context.md, .gemini/skills.yaml, and .github/copilot-instructions.md. See skills/INTEGRATION.md for full details.

Development(Build-Publish-Deploy)

This is the simplest end-to-end workflow when you build DbCli from source and then deploy the skills to an AI assistant.

1) Publish

# Build self-contained single-file binaries + dist-* folders (recommended)
pwsh ./publish-all.ps1

Or publish only your current platform:

dotnet publish .\dbcli.csproj -c Release -r win-x64 --self-contained true -p:PublishSingleFile=true -p:IncludeNativeLibrariesForSelfExtract=true -o .\dist-win-x64

Linux / WSL (Install & Run)

If you're using WSL (or a Linux machine), publish the Linux binary inside WSL/Linux:

# Build linux-x64 into dist-linux-x64
dotnet publish ./dbcli.csproj -c Release -r linux-x64 --self-contained true -p:PublishSingleFile=true -p:IncludeNativeLibrariesForSelfExtract=true -o ./dist-linux-x64

Then inside WSL/Linux:

chmod +x ./dist-linux-x64/dbcli
mkdir -p ~/.local/bin
cp ./dist-linux-x64/dbcli ~/.local/bin/dbcli
export PATH="$HOME/.local/bin:$PATH"

dbcli --version
dbcli --help

Tip: for best performance on WSL, prefer working under the Linux filesystem (e.g. ~/src/...) instead of /mnt/c/....

macOS (Install & Run)

If you're on macOS, publish for your CPU:

# Apple Silicon
dotnet publish ./dbcli.csproj -c Release -r osx-arm64 --self-contained true -p:PublishSingleFile=true -p:IncludeNativeLibrariesForSelfExtract=true -o ./dist-macos-arm64

# Intel
dotnet publish ./dbcli.csproj -c Release -r osx-x64 --self-contained true -p:PublishSingleFile=true -p:IncludeNativeLibrariesForSelfExtract=true -o ./dist-macos-x64

Then:

chmod +x ./dist-macos-*/dbcli
mkdir -p ~/.local/bin
cp ./dist-macos-*/dbcli ~/.local/bin/dbcli
export PATH="$HOME/.local/bin:$PATH"

dbcli --version
dbcli --help

Deploy skills using the Python script (recommended on Linux/macOS/WSL):

# Install dbcli + scripts + skills into ~/tools/dbcli and add it to PATH
python3 ./deploy-skills.py --install-scripts --target copilot --force

# Or deploy to all supported targets
python3 ./deploy-skills.py --install-scripts --target all --force

Global Deploy (Claude) + Later Workspace Deploy (Recommended Flow)

Global deploy (Claude): extract the release to ~/tools/dbcli (or C:\Users\<you>\tools\dbcli), then run:

pwsh -File "$env:USERPROFILE\tools\dbcli\deploy-skills.ps1" -Target claude -WorkDir <workspace_dir> -Force

Global deploy (Codex, recommended): use the same install location, then run:

pwsh -File "$env:USERPROFILE\tools\dbcli\deploy-skills.ps1" -Target codex -CodexGlobalOnly -Force

Note: -CodexGlobalOnly deploys to the user profile (~/.codex) only. Other global-only targets are not supported. Or deploy to all supported targets:

pwsh -File "$env:USERPROFILE\tools\dbcli\deploy-skills.ps1" -Target all -WorkDir <workspace_dir> -Force

Deploy to any workspace later: reuse the scripts from tools/dbcli to copy into the target workspace:

pwsh -File "$env:USERPROFILE\tools\dbcli\deploy-skills.ps1" -Target claude -WorkDir "<workspace_dir>" -Force

Or deploy to all supported targets:

pwsh -File "$env:USERPROFILE\tools\dbcli\deploy-skills.ps1" -Target all -WorkDir "<workspace_dir>" -Force

Note: the script prefers tools/dbcli/skills as the source when present, and -WorkDir is the target workspace. Note: Claude workspace deploy copies skills only (no exe). Ensure dbcli is installed and on PATH.

2) Install + Deploy skills

PowerShell deployment works on Windows / Linux / macOS (with pwsh):

pwsh -NoProfile -ExecutionPolicy Bypass -File .\deploy-skills.ps1 -InstallScripts -Target copilot -WorkDir <workspace_dir> -Force

3) Verify

dbcli --help

# Set connection via environment variables
$env:DBCLI_CONNECTION = "Data Source=test.db"
$env:DBCLI_DBTYPE = "sqlite"
dbcli query "SELECT 'Hello' AS message"

⚠️ Backup & Restore

CRITICAL: Always create backups before performing DDL (DROP, ALTER) or DML (UPDATE, DELETE) operations!

DbCli provides built-in backup, restore, and export-schema commands for comprehensive backup strategies:

Schema Backup (Procedures, Functions, Triggers, Views, Indexes)

Export DDL scripts before dropping or modifying database objects:

# Set connection once
export DBCLI_CONNECTION="Server=.;Database=mydb"
export DBCLI_DBTYPE="sqlserver"

# Export all schema objects
dbcli export-schema all -o backup_schema.sql

# Export all schema objects as separate files (per object)
dbcli export-schema all --output-dir ./schema_export

# Export only stored procedures
dbcli export-schema procedure -o backup_procedures.sql

# Export specific procedure by name pattern
dbcli export-schema procedure --name "sp_User*"

# Export indexes for all tables
dbcli export-schema index -o backup_indexes.sql

# Export triggers
dbcli export-schema trigger -o backup_triggers.sql

Supported object types: all, procedure, function, trigger, view, index

Supported databases: Microsoft SQL Server, MySQL-family (incl. OceanBase/TiDB/PolarDB), PostgreSQL (incl. GaussDB/Kingbase), SQLite, Oracle, DB2, DM (coverage varies by database)

Data Backup Commands

DbCli provides backup and restore commands powered by SqlSugar Fastest() API with intelligent backup strategies:

Backup Command

# Set connection
export DBCLI_CONNECTION="Data Source=mydb.db"
export DBCLI_DBTYPE="sqlite"

# Auto backup (auto-generated timestamp table name)
dbcli backup Users
# Creates: Users_backup_20251227_161149

# Specify custom backup table name
dbcli backup Users -o Users_backup_before_migration

# Table format output for details
dbcli -f table backup Users

Restore Command

# Set connection
export DBCLI_CONNECTION="Data Source=mydb.db"
export DBCLI_DBTYPE="sqlite"

# Restore from backup (auto-deletes existing data)
dbcli restore Users --from Users_backup_20251227_161149

# Keep existing data, append restore
dbcli restore Users --from Users_backup_20251227_161149 --keep-data

# Table format output for details
dbcli -f table restore Users --from Users_backup_20251227_161149

Intelligent Backup Strategy (Auto-selects fastest method)

Priority	Method	Use Case	Performance
1	`CREATE TABLE AS SELECT`	SQLite, MySQL, PostgreSQL etc.	Fastest & compatible
2	`Fastest().BulkCopy` (DataTable)	Large data (>10k rows)	Extremely fast for big tables
3	Row-by-row INSERT	Compatibility mode	Slowest but guaranteed

Traditional Backup Methods (Still supported)

# SQL export (portable to other databases)
export DBCLI_CONNECTION="Data Source=mydb.db"
export DBCLI_DBTYPE="sqlite"
dbcli export Users > Users_backup_${TIMESTAMP}.sql

# Full database backup (SQLite file copy)
cp mydb.db mydb_backup_${TIMESTAMP}.db

Complete Backup & Restore Workflow

# Set connection once
export DBCLI_CONNECTION="Data Source=app.db"
export DBCLI_DBTYPE="sqlite"

# 1. Backup table
dbcli -f table backup Users
# ✅ Method: CreateTableAsSelect, Rows: 1000

# 2. Execute dangerous operation
dbcli exec "DELETE FROM Users WHERE Age < 18"

# 3. Found mistake, restore immediately
dbcli -f table restore Users --from Users_backup_20251227_161149
# ✅ Method: InsertIntoSelect, Rows: 1000, Deleted: True

See dbcli-export skill for complete backup automation scripts.

Command Reference

Command	Alias	Description
`query <sql>`	`q`	Execute SELECT query
`exec <sql>`	`e`	Execute INSERT/UPDATE/DELETE
`ddl <sql>`	-	Execute CREATE/ALTER/DROP (Skill: `dbcli-db-ddl`)
`procedure <name>`	`proc`, `sproc`	Execute stored procedure (non-query)
`procedure-query <name>`	`proc-query`, `sproc-query`	Execute stored procedure and return result set
`tables`	`ls`	List all tables
`views`	`view`	List views
`columns <table>`	`cols`	Show table structure
`export <table>`	-	Export table data as SQL
`backup <table>`	-	Backup table (auto-selects fastest method)
`restore <table>`	-	Restore table from backup
`export-schema <type>`	`schema`	Export schema objects (procedures, functions, triggers, views, indexes)
`interactive`	`i`	Interactive mode

Global Options

Options can appear either before or after the command. Command-first is recommended, and the legacy "options before command" style is also supported.

Note: options are defined per-command (see dbcli <command> --help). The table below lists the most commonly available options across commands.

Option	Short	Description
`--db-type`	`-t`	Database type
`--format`	`-f`	Output format (json/table/csv)
`--config`	-	Config file path
`--file`	`-F`	Read SQL from file (query/exec/ddl only)

Command Arguments & Options

This section lists the complete CLI surface for the built-in commands.

`query` / `q`

Arguments
- <sql>: SQL to execute (SELECT/CTE/etc). You can also use -F to read from a file.
Options
- -F, --file <path>: Read SQL from file
- -p, --params <json>: SQL parameters as JSON object (use @Param in SQL)
- -P, --params-file <path>: Read JSON parameters from file
- -t, --db-type <string>
- -f, --format <json|table|csv>
- --config <path>

`exec` / `e`

Arguments
- <sql>: SQL to execute (INSERT/UPDATE/DELETE). You can also use -F.
Options
- -F, --file <path>
- -p, --params <json>: SQL parameters as JSON object (use @Param in SQL)
- -P, --params-file <path>: Read JSON parameters from file
- -t, --db-type <string>
- -f, --format <json|table|csv>
- --config <path>

`ddl`

Arguments
- <sql>: SQL to execute (CREATE/ALTER/DROP). You can also use -F.
Options
- -F, --file <path>
- -t, --db-type <string>
- -f, --format <json|table|csv>
- --config <path>

`procedure` / `proc` / `sproc`

Arguments
- <name>: Stored procedure name
Options
- -p, --params <json>: Parameters as JSON object (use @Param)
- -P, --params-file <path>: Read JSON parameters from file
- -t, --db-type <string>
- -f, --format <json|table|csv>
- --config <path>

`procedure-query` / `proc-query` / `sproc-query`

Arguments
- <name>: Stored procedure name
Options
- -p, --params <json>: Parameters as JSON object (use @Param)
- -P, --params-file <path>: Read JSON parameters from file
- -t, --db-type <string>
- -f, --format <json|table|csv>
- --config <path>

`tables` / `ls`

Options
- -t, --db-type <string>
- -f, --format <json|table|csv>
- --config <path>

`views` / `view`

Options
- -n, --name <pattern>: filter by view name (LIKE %pattern%)
- --owner <schema>: filter by schema/owner
- --scope <user|all|dba>: listing scope (default: user)
- --with-definition: include view definition text
- -t, --db-type <string>
- -f, --format <json|table|csv>
- --config <path>

`columns` / `cols`

Arguments
- <table>: table name
Options
- -t, --db-type <string>
- -f, --format <json|table|csv>
- --config <path>

`export`

Arguments
- <table>: table name
Options
- -t, --db-type <string>
- --config <path>

`backup`

Arguments
- <table>: source table name
Options
- -o, --target <name>: backup table name (default: auto timestamp)
- -t, --db-type <string>
- -f, --format <json|table|csv>
- --config <path>

`restore`

Arguments
- <table>: target table name to restore
Options
- -s, --from <name>: backup table name (required)
- -k, --keep-data: keep existing data (append restore)
- -t, --db-type <string>
- -f, --format <json|table|csv>
- --config <path>

`export-schema` / `schema`

Arguments
- <type>: all, procedure, function, trigger, view, index
Options
- -n, --name <pattern>: filter by object name
- -o, --output <path>: save to file
- -t, --db-type <string>
- --config <path>

`interactive` / `i`

Options
- -t, --db-type <string>
- -f, --format <json|table|csv>
- --config <path>

Parameterized SQL Notes (SqlSugar ADO)

Use @Param placeholders for cross-database parameterization.
IN (...) supports JSON arrays (DbCli expands @Ids).
SQLite providers may require DisableClearParameters: true in config (maps to SqlSugar IsClearParameters=false).
SQL Server supports GO batch separators for ddl and non-parameterized exec (use -F for scripts). GO is not supported with -p/-P.
DbCli returns a single result set. SqlSugar supports multiple result sets/output parameters, but DbCli does not surface them yet. Use explicit SELECT in procedures when you need to return data.

Examples:

# IN (...) with array
dbcli query "SELECT * FROM Users WHERE Id IN (@Ids)" -p '{"Ids":[1,2,3]}'

# SQL Server GO batches (non-parameter)
dbcli -t sqlserver exec -F script_with_go.sql

Usage Examples

Basic Operations

# Set connection once
export DBCLI_CONNECTION="Data Source=app.db"
export DBCLI_DBTYPE="sqlite"

# Create table
dbcli ddl "CREATE TABLE Users (Id INTEGER PRIMARY KEY, Name TEXT, Email TEXT)"

# Insert data
dbcli exec "INSERT INTO Users (Name, Email) VALUES ('John', 'john@example.com')"

# Query data
dbcli query "SELECT * FROM Users" -f table

# List tables
dbcli tables

# Show table structure
dbcli -f table columns Users

# List views (different database)
export DBCLI_CONNECTION="Server=localhost;Database=mydb;User Id=SYSDBA;Password=xxxxxxxxxx"
export DBCLI_DBTYPE="dm"
dbcli views --scope all --owner DOC -f table

# Export data (back to SQLite)
export DBCLI_CONNECTION="Data Source=app.db"
export DBCLI_DBTYPE="sqlite"
dbcli export Users > backup.sql

Execute SQL from File

# Set connection
export DBCLI_CONNECTION="Data Source=app.db"
export DBCLI_DBTYPE="sqlite"

# Execute DDL script
dbcli ddl -F schema.sql

# Execute data script
dbcli exec -F seed.sql

Different Databases

# SQLite
export DBCLI_CONNECTION="Data Source=app.db"
export DBCLI_DBTYPE="sqlite"
dbcli query "SELECT * FROM Users"

# Microsoft SQL Server
export DBCLI_CONNECTION="Server=localhost;Database=mydb;Trusted_Connection=True"
export DBCLI_DBTYPE="sqlserver"
dbcli query "SELECT TOP 10 * FROM Users"

# MySQL
export DBCLI_CONNECTION="Server=localhost;Database=mydb;Uid=root;Pwd=xxxxxxxxxx"
export DBCLI_DBTYPE="mysql"
dbcli query "SELECT * FROM Users LIMIT 10"

# PostgreSQL
export DBCLI_CONNECTION="Host=localhost;Database=mydb;Username=postgres;Password=xxxxxxxxxx"
export DBCLI_DBTYPE="postgresql"
dbcli query "SELECT * FROM Users LIMIT 10"

Connection String Reference

Relational Databases

SQLite

Data Source=app.db

Microsoft SQL Server

Server=.;Database=mydb;Trusted_Connection=True;

Or with username/password:

Server=localhost;Database=mydb;User Id=sa;Password=xxxxxxxxxx;

MySQL

Server=localhost;Database=mydb;Uid=root;Pwd=xxxxxxxxxx;AllowLoadLocalInfile=true;

MySQL Connector

Server=localhost;Database=mydb;Uid=root;Pwd=xxxxxxxxxx;

PostgreSQL

Host=localhost;Port=5432;Database=mydb;Username=postgres;Password=xxxxxxxxxx;

Oracle

Data Source=(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=localhost)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=orcl)));User Id=system;Password=xxxxxxxxxx;

Or simplified:

Data Source=localhost:1521/orcl;User Id=system;Password=xxxxxxxxxx;

MariaDB

Server=localhost;Database=mydb;Uid=root;Pwd=xxxxxxxxxx;

TiDB

Server=localhost;Port=4000;Database=mydb;Uid=root;Pwd=xxxxxxxxxx;

DaMeng

Server=localhost;User Id=SYSDBA;PWD=xxxxxxxxxx;DATABASE=mydb;

KingbaseES

Server=localhost;Port=54321;UID=system;PWD=xxxxxxxxxx;database=mydb;

Oscar

Data Source=localhost;User Id=SYSDBA;Password=xxxxxxxxxx;Database=mydb;

HighGo

Host=localhost;Port=5866;Database=mydb;Username=highgo;Password=xxxxxxxxxx;

GaussDB

Host=localhost;Port=8000;Database=mydb;Username=gaussdb;Password=xxxxxxxxxx;

GBase

Server=localhost;Port=9088;Database=mydb;Uid=gbasedbt;Pwd=xxxxxxxxxx;

Distributed Databases

OceanBase

Server=localhost;Port=2883;Database=mydb;User Id=root;Password=xxxxxxxxxx;

PolarDB

Server=localhost;Database=mydb;Uid=root;Pwd=xxxxxxxxxx;Pooling=false;

TDengine

Host=localhost;Port=6030;Database=mydb;Username=root;Password=xxxxxxxxxx;

ClickHouse

Host=localhost;Port=8123;Database=default;User=default;Password=xxxxxxxxxx;Compress=True;

Doris

Server=localhost;Port=9030;Database=mydb;Uid=root;Pwd=xxxxxxxxxx;Pooling=false;

Analytics Databases

QuestDB

host=localhost;port=8812;username=admin;password=xxxxxxxxxx;database=qdb;ServerCompatibilityMode=NoTypeLoading;

DuckDB

Data Source=analytics.db

Enterprise Databases

IBM DB2

Server=localhost:50000;Database=mydb;UID=db2admin;PWD=xxxxxxxxxx;

SAP HANA

Server=localhost:30015;UserName=SYSTEM;Password=xxxxxxxxxx;Database=HDB;

Microsoft Access

Provider=Microsoft.ACE.OLEDB.12.0;Data Source=C:\mydb.accdb;

NoSQL Databases

MongoDB

mongodb://localhost:27017/mydb

Or with authentication:

mongodb://user:xxxxxxxxxx@localhost:27017/mydb?authSource=admin

Cloud Provider Databases

Amazon Aurora (MySQL)

Server=mydb.cluster-xxx.us-east-1.rds.amazonaws.com;Database=mydb;Uid=admin;Pwd=xxxxxxxxxx;

Azure Database for MySQL

Server=mydb.mysql.database.azure.com;Database=mydb;Uid=admin@mydb;Pwd=xxxxxxxxxx;SslMode=Required;

Google Cloud SQL for MySQL

Server=1.2.3.4;Database=mydb;Uid=root;Pwd=xxxxxxxxxx;SslMode=Required;

Percona Server

Server=localhost;Database=mydb;Uid=root;Pwd=xxxxxxxxxx;

Generic Connectors

ODBC

Driver={SQL Server};Server=localhost;Database=mydb;Uid=sa;Pwd=xxxxxxxxxx;

Custom

Custom connection string based on your driver

Config File Examples

appsettings.json (SQLite)

{
  "ConnectionString": "Data Source=app.db",
  "DbType": "sqlite",
  "DisableClearParameters": true
}

Use DisableClearParameters if parameterized queries fail on some SQLite providers.

appsettings.json (Microsoft SQL Server)

{
  "ConnectionString": "Server=.;Database=MyApp;Trusted_Connection=True;",
  "DbType": "sqlserver"
}

appsettings.json (MySQL)

{
  "ConnectionString": "Server=localhost;Database=myapp;Uid=root;Pwd=xxxxxxxxxx;",
  "DbType": "mysql"
}

appsettings.json (PostgreSQL)

{
  "ConnectionString": "Host=localhost;Port=5432;Database=myapp;Username=postgres;Password=xxxxxxxxxx;",
  "DbType": "postgresql"
}

Interactive Mode

# Set connection via environment variables
export DBCLI_CONNECTION="Data Source=app.db"
export DBCLI_DBTYPE="sqlite"
dbcli interactive

# Interactive commands:
# .tables                   - List all tables
# .views                    - List views
# .columns <table>          - Show table structure
# .format <type>            - Switch output format
# .help                     - Show help
# .query <sql>              - Execute SQL as query and show results
# .exec <sql>               - Execute SQL as non-query
# .ddl <sql>                - Execute DDL (CREATE/ALTER/DROP)
# .export <table> [output]  - Export table data as INSERT SQL
# .export-schema <type>     - Export schema objects
#   Options: -n <pattern> -o <file> --output-dir <dir>
# .exit/.quit               - Exit
# End SQL with ';' or blank line to execute

Using in CI/CD

🔒 Secure Connection Setup (Recommended)

For AI integration and production use, avoid -c parameter to prevent passwords in logs:

# GitHub Actions
- name: Run migrations securely
  env:
    DBCLI_CONNECTION: ${{ secrets.DB_CONNECTION }}
    DBCLI_DBTYPE: sqlserver
  run: |
    ./dbcli ddl -F migrations/001_init.sql

# PowerShell Script
$env:DBCLI_CONNECTION = "Data Source=app.db"
$env:DBCLI_DBTYPE = "sqlite"
$result = dbcli query "SELECT COUNT(*) as Count FROM Users" | ConvertFrom-Json
Write-Host "User count: $($result[0].Count)"

# Bash Script
export DBCLI_CONNECTION="Data Source=app.db"
export DBCLI_DBTYPE=sqlite
count=$(dbcli query "SELECT COUNT(*) as Count FROM Users" | jq '.[0].Count')
echo "User count: $count"

Why avoid -c parameter:

✅ Environment variables not visible in command line or logs
✅ Prevents passwords from appearing in AI conversation history
✅ Better security for CI/CD and production environments

Traditional Mode (Connection string in command)

# Secure - connection string from secret
- name: Run migrations
  run: |
    export DBCLI_CONNECTION="${{ secrets.DB_CONNECTION }}"
    export DBCLI_DBTYPE="${{ secrets.DB_TYPE }}"
    ./dbcli ddl -F migrations/001_init.sql

📚 Documentation

Document	Description
README.md	This file - Project overview and quick reference
skills/README.md	Skills overview and usage guide
skills/INTEGRATION.md	AI assistant integration for 10+ coding agents
skills/CONNECTION_STRINGS.md	Connection string examples for 30+ databases

🔗 Resources

Agent Skills Specification: https://agentskills.io
OpenAI Codex Skills: https://developers.openai.com/codex/skills
Claude Skills: https://support.claude.com/en/articles/12512180-using-skills-in-claude
SqlSugar: https://github.com/DotNetNext/SqlSugar
ConsoleAppFramework (CLI Framework): https://github.com/Cysharp/ConsoleAppFramework

License

MIT - See LICENSE for details

Name		Name	Last commit message	Last commit date
Latest commit History 2 Commits
.github		.github
skills		skills
DbContext.cs		DbContext.cs
LICENSE		LICENSE
OutputFormatter.cs		OutputFormatter.cs
Program.cs		Program.cs
README.md		README.md
appsettings.json		appsettings.json
dbcli.csproj		dbcli.csproj
dbcli.sln		dbcli.sln
deploy-skills.ps1		deploy-skills.ps1
deploy-skills.py		deploy-skills.py
install-dbcli.ps1		install-dbcli.ps1
install-dbcli.py		install-dbcli.py
publish-all.ps1		publish-all.ps1
test.ps1		test.ps1
test.sh		test.sh
test_interactive.ps1		test_interactive.ps1
test_interactive.sh		test_interactive.sh
test_localdb.ps1		test_localdb.ps1
test_localdb_rebuild_schema.ps1		test_localdb_rebuild_schema.ps1
update_docs_remove_c_param.ps1		update_docs_remove_c_param.ps1