sqlew 5.0.7 → 5.1.0

package/CHANGELOG.md

@@ -7,6 +7,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [5.1.0] - 2026-03-07
+
+### Changed
+
+**📁 `.sqlew.env` relocated to `~/.config/sqlew/.sqlew.env`**
+
+The cloud API key file (`~/.sqlew.env`) has been moved to `~/.config/sqlew/.sqlew.env` to align with the v5.1 unified global config path. Automatic migration copies the old file and deletes it (API key security: no stale copies). `saveCachedProjectId()` now calls `ensureGlobalConfigDir()` for directory safety.
+
+**🔒 db:export Project Scope Auto-Detection (Security)**
+
+`db:export` no longer exports all projects by default. With the global shared database (v5.1.0), the default "export everything" behavior risked leaking other projects' decision data.
+
+- **Auto-detect**: Project name resolved from `.sqlew/config.toml` `[project].name` when no `project=` option is given
+- **Explicit all**: `project=all` required to export all projects (escape hatch)
+- **Error on ambiguity**: If no project name is found (no CLI arg, no config.toml), the command exits with an actionable error message
+- **Breaking change**: Previously, omitting `project=` exported all projects silently
+
+### Resolution Priority
+
+```
+1. CLI argument: project=<name>     (highest)
+2. config.toml: [project].name
+3. Error exit                       (lowest)
+```
+
+---
+
 ## [5.0.6] - 2026-02-14
 
 ### Changed

package/README.md

@@ -5,176 +5,62 @@
 [![npm version](https://img.shields.io/npm/v/sqlew.svg)](https://www.npmjs.com/package/sqlew)
 [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 
-> **ADR (Architecture Decision Record) for AI Agents** – An MCP server that enables AI agents to create, query, and maintain architecture decision records in a structured SQL database
+> **Design decisions, remembered by SQL** — an MCP server for AI agents
 
-## 🚀 Quick Start
+## What is sqlew?
 
-### 1. Install MCP Server
+### The Problem
 
-```bash
-npm install -g sqlew
-```
+Every AI coding session starts from scratch. Your agent doesn't remember that you chose PostgreSQL over MongoDB last week, or that the team agreed on a specific API versioning strategy. Without persistent memory, agents repeat mistakes, contradict earlier decisions, and waste tokens re-discovering context.
 
-### 2. Install Plugin (Recommended)
+### The Solution
 
-In Claude Code, run the following commands:
+sqlew stores your architectural decisions in a structured SQL database. When a new session starts, the AI agent queries past decisions in milliseconds — not by reading through scattered Markdown files, but through efficient SQL lookups with metadata, tags, and similarity detection.
 
-```bash
-claude plugin marketplace add sqlew-io/sqlew-plugin
-claude plugin install sqlew
+```
+┌─────────────────────────────────────────────────────────────┐
+│  Before sqlew                 │  After sqlew                │
+│───────────────────────────────│─────────────────────────────│
+│  Session 1: "Use PostgreSQL"  │  Session 1: "Use PostgreSQL"│
+│  Session 2: "Use MongoDB?"    │    → decision recorded      │
+│  Session 3: "Use PostgreSQL"  │  Session 2: query → got it  │
+│  (same debate, every time)    │  Session 3: query → got it  │
+│                               │    (instant recall)         │
+└─────────────────────────────────────────────────────────────┘
 ```
 
-**That's it!** The plugin automatically sets up everything:
-
-- ✅ MCP server config (`.mcp.json`)
-- ✅ Claude Code Skills (Plan Mode guidance)
-- ✅ Claude Code Hooks (automatic decision capture)
-
-> **Note:** Plan mode enforcement is handled by the plugin's `UserPromptSubmit` hook — no manual configuration needed.
+sqlew is built on the [Model Context Protocol](https://modelcontextprotocol.io/) (MCP), so it works with any MCP-compatible AI coding tool.
 
-### 3. Connect to sqlew.io (For Teams) 🌐
+> _This software does not send any data to external networks. We NEVER collect any data or usage statistics._
 
-**NEW in v5.0.0**: Connect to the cloud for team-shared decisions!
+## Quick Start
 
-**Step 1: Get your API key** (one-time setup)
-
-Visit [sqlew.io](https://sqlew.io) and save your API key:
+### 1. Install
 
 ```bash
-# ~/.sqlew.env (shared across all projects)
-SQLEW_API_KEY=your-api-key
-```
-
-**Step 2: Configure each project**
-
-```toml
-# .sqlew/config.toml (per-project)
-[database]
-type = "cloud"
-
-[project]
-name = "your-project-name"
+npm install -g sqlew
 ```
 
-> **Note:** Each project needs its own `.sqlew/config.toml` to specify the project name.
-
-**Benefits:**
-- 👥 **Team sharing** - All team members share the same decision database
-- 🌳 **Git worktree ready** - Works seamlessly with multiple branches
-- ⚡ **Zero setup** - No local database required
-
-### Alternative: Local Database (Offline)
+### 2. Setup
 
-For offline or single-developer use, **no setup required**:
+Choose the setup that matches your environment:
 
-- Database (`.sqlew/sqlew.db`) is auto-created on first MCP server start
-- Config file (`.sqlew/config.toml`) is auto-generated with detected project name
-
-Just start using Claude Code - everything initializes automatically!
-
-### 4. Just use Plan Mode!
-
-**That's it!** Now every time you:
-
-1. Create a plan in Claude Code
-2. Get user approval (ExitPlanMode)
-
-→ Your architectural decisions are **automatically recorded** as ADR knowledge.
-
-No special commands needed. Just plan your work normally, and sqlew captures the decisions in the background.
-
-### Optional: /sqlew command
-
-For manual queries and explicit decision recording:
+#### Claude Code (Plugin)
 
 ```bash
-/sqlew                    # Show status
-/sqlew search auth        # Search past decisions
-/sqlew record use Redis   # Record a decision manually
+claude plugin marketplace add sqlew-io/sqlew-plugin
+claude plugin install sqlew
 ```
 
----
-
-## What is sqlew?
-
-**sqlew** is a Model Context Protocol (MCP) server that brings ADR (Architecture Decision Record) capabilities to AI agents through a shared SQL-backed repository.
-
-### The Problem: AI Agents Lack Decision Memory
-
-Every AI session starts with zero context. Agents must re-learn architectural decisions, can reintroduce previously rejected patterns, and have no systematic way to understand WHY past choices were made.
-
-Traditional ADR approaches use Markdown files scattered across repositories. While human-readable, this format creates challenges for AI agents:
-
-- **No structured querying** – AI must read entire files to find relevant decisions
-- **Context explosion** – Token costs grow linearly with decision history
-- **No duplicate detection** – AI cannot easily identify similar or conflicting decisions
-- **Poor discoverability** – Finding related decisions requires full-text search across many files
-
-### _sqlew_ brings structured ADR to AI agents
-
-sqlew transforms ADR from static documentation into a **queryable, AI-native decision database**:
-
-- **Structured records** – Decisions stored as relational data with metadata, tags, and relationships
-- **Efficient querying** – AI agents retrieve only relevant decisions via SQL queries
-- **Smart suggestions** – Three-tier similarity system detects duplicate or related decisions
-- **Constraint tracking** – Architectural rules and principles as first-class entities
-- **Auto-capture** – Claude Code Hooks automatically record decisions from Plan Mode
-
-> _This software does not send any data to external networks. We NEVER collect any data or usage statistics. Please use it with complete security._
-
-## Why sqlew?
-
-AI agents automatically accumulate project knowledge through Plan Mode. Decisions are stored in SQL for efficient querying.
-
-### 🌐 Team Development Made Easy (NEW in v5.0.0)
-
-- **Shared decision database** - All team members see the same architectural decisions
-- **Multiple AI agents** - Work simultaneously without conflicts
-- **No local setup** - Just add your API key and start
-
-### 🌳 Perfect for Git Worktree Workflows
+The plugin automatically configures MCP server, Skills (Plan Mode guidance), and Hooks (automatic decision capture).
 
-- **Automatic worktree detection** - Each worktree shares the same context
-- **Config inheritance** - Main repository settings apply everywhere
-- **Independent sessions** - Each worktree has its own cache
+#### Codex CLI
 
-**Perfect for:**
+See [sqlew-codex](https://github.com/sqlew-io/sqlew-codex) for Codex CLI integration.
 
-- 🏢 Large-scale projects with many architectural decisions
-- 🔧 Long-term maintenance where context must persist across sessions
-- 👥 **Team environments** where multiple AI agents share knowledge
-- 🌳 **Git worktree** workflows with multiple concurrent branches
+#### Manual
 
-**Key benefits:**
-
-- ⚡ **60-75% token reduction** vs reading Markdown ADRs
-- 🔍 **Millisecond queries** (2-50ms) even with thousands of decisions
-- 🛡️ **Duplicate prevention** via similarity detection
-- 📚 **Persistent memory** across all AI sessions
-- 👥 **Team sync** via sqlew.io cloud backend
-
-→ See [ADR Concepts](docs/ADR_CONCEPTS.md) for detailed architecture.
-
----
-
-**Technical Features**: 7 MCP tools (3 core: decision, constraint, suggest + 4 utility: help, example, use_case, queue), three-tier similarity detection (0-100 point scoring), ACID transaction support, multi-database backend (SQLite/PostgreSQL/MySQL/Cloud), metadata-driven organization with layers and tags
-
-## Installation
-
-### Requirements
-
-- Node.js 20.0.0 or higher
-- npm or npx
-
-### Recommended: Global Install
-
-```bash
-npm install -g sqlew
-```
-
-> **Why global install?** Claude Code Hooks call `sqlew` directly from shell. Global install ensures hooks work correctly without npx overhead.
-
-Then add to `.mcp.json` in your project root:
+Add to `.mcp.json` in your project root:
 
 ```json
 {
@@ -186,147 +72,119 @@ Then add to `.mcp.json` in your project root:
 }
 ```
 
-### Alternative: npx (Not Recommended)
-
-**⚠️ Not recommended**: npx usage prevents Claude Code Hooks from working, disabling Plan-to-ADR automatic decision capture. Use global install instead.
-
-**Note**: First run initializes the database. Restart Claude Code to load the MCP server.
-
-Each project maintains its own context database in `.sqlew/sqlew.db`.
+The database (`~/.config/sqlew/sqlew-shared.db`) and config are auto-created on first run. See [Shared Database](docs/SHARED_DATABASE.md) for details.
 
-**Custom database path:** Add path as argument: `"args": ["sqlew", "/path/to/db.db"]`
-**Default location:** `.sqlew/sqlew.db`
+### 3. Just use Plan Mode!
 
-## Configuration
+That's it. Every time you create a plan and get user approval, your architectural decisions are **automatically recorded**.
 
-sqlew supports multiple database backends:
+No special commands needed — just plan your work normally, and sqlew captures the decisions in the background.
 
-| Database                     | Use Case                 | Status       |
-| ---------------------------- | ------------------------ | ------------ |
-| **SQLite**                   | Personal/small projects  | ✅ Default   |
-| **MySQL 8.0+ / MariaDB 10+** | Production, team sharing | ✅ Supported |
-| **PostgreSQL 12+**           | Production, team sharing | ✅ Supported |
+## Features
 
-Configuration is managed via `.sqlew/config.toml` file and CLI arguments.
-
-→ **[Full Configuration Guide](docs/CONFIGURATION.md)** - All options, database setup, validation rules
-
-## Documentation
+- **Structured Records** — Decisions stored as relational data with metadata, tags, layers, and version history
+- **Fast Queries** — 2-50ms retrieval via SQL, even with thousands of decisions
+- **Duplicate Detection** — Three-tier similarity scoring (0-100) prevents redundant decisions
+- **Constraint Tracking** — Architectural rules and principles as first-class entities
+- **Auto-Capture** — Hooks automatically record decisions from Plan Mode (Claude Code plugin)
+- **Multi-Database** — SQLite (default), PostgreSQL, MySQL/MariaDB, or Cloud
+- **Git Worktree Ready** — Each worktree shares the same context database
 
-Each tool supports `action: "help"` for full documentation and `action: "example"` for comprehensive usage examples.
+## For Teams (sqlew.io)
 
-And `action: "use_case"` shows how to use the tool in a real-world scenario.
+Connect to [sqlew.io](https://sqlew.io) for team-shared decisions:
 
-### On-Demand Documentation
+**Step 1: Get your API key**
 
-All tools support:
-
-- `action: "help"` - Parameter reference and descriptions
-- `action: "example"` - Usage scenarios and examples
-- `action: "use_case"` - Real-world usage examples
-
-### For AI Agents
-
-**Essential Guides:**
-
-**Advanced Features:**
+Visit [sqlew.io](https://sqlew.io) and save your API key:
 
-- [Hooks Guide](docs/HOOKS_GUIDE.md) - Claude Code Hooks integration
-- [Cross Database](docs/CROSS_DATABASE.md) - Multi-database support
+```bash
+# ~/.config/sqlew/.sqlew.env (shared across all projects)
+SQLEW_API_KEY=your-api-key
+```
 
-**Reference:**
+**Step 2: Configure each project**
 
-- [Configuration](docs/CONFIGURATION.md) - Config file setup, all options
+```toml
+# .sqlew/config.toml
+[database]
+type = "cloud"
 
-### Advanced Usage
+[project]
+name = "your-project-name"
+```
 
-- [Configuration Guide](docs/CONFIGURATION.md) - TOML config file setup
-- [CLI Mode Overview](docs/cli/README.md) - Database migration, export/import commands
+**Benefits:**
+- All team members share the same decision database
+- Works seamlessly with Git worktree workflows
+- No local database setup required
 
-### Upgrade Guides
+## Performance
 
-- **[Upgrade from v4 to v5](docs/MIGRATION_CLEANUP_GUIDE.md)** - Cleanup legacy files after plugin migration
-- **[Migrating Local Data to SaaS](docs/MIGRATION_TO_SAAS.md)** - Export local v3.x/v4.x data to sqlew.io cloud
-- [Migration from v2](docs/MIGRATION_v2.md) - Version upgrade guides
+| Metric | Value |
+|--------|-------|
+| Query speed | 2-50ms |
+| Concurrent agents | 5+ simultaneous |
+| Storage efficiency | ~140 bytes/decision |
+| Token savings | 60-75% vs Markdown ADRs |
 
 ## Use Cases
 
-### ADR-Driven Development with AI
-
-- **Architecture Evolution** – Document major architectural decisions with full context and alternatives
-- **Pattern Standardization** – Establish coding patterns as constraints, enforce via AI code generation
-- **Technical Debt Tracking** – Record temporary decisions with deprecation paths and future plans
-- **Onboarding Acceleration** – New AI sessions instantly understand architectural history
+- **Architecture Evolution** — Document major decisions with full context and alternatives considered
+- **Pattern Standardization** — Establish coding patterns as constraints, enforce via AI code generation
+- **Cross-Session Continuity** — AI maintains context across days/weeks without re-reading docs
+- **Multi-Agent Coordination** — Multiple AI agents share architectural understanding
+- **Onboarding Acceleration** — New AI sessions instantly understand project history
 
-### Cross-Session AI Workflows
+## Documentation
 
-- **Multi-Session Projects** – AI maintains context across days/weeks without re-reading documentation
-- **Multi-Agent Coordination** – Multiple AI agents share architectural understanding through ADR database
-- **Breaking Change Management** – Document API changes, deprecations, and migration paths systematically
-- **Refactoring Guidance** – AI references past decisions to maintain architectural consistency during refactors
+| Guide | Description |
+|-------|-------------|
+| [ADR Concepts](docs/ADR_CONCEPTS.md) | Architecture Decision Records explained |
+| [Configuration](docs/CONFIGURATION.md) | Config file setup, database options |
+| [Hooks Guide](docs/HOOKS_GUIDE.md) | Claude Code Hooks integration |
+| [Cross Database](docs/CROSS_DATABASE.md) | Multi-database support |
+| [CLI Usage](docs/CLI_USAGE.md) | Database migration, export/import |
 
-### Real-World Examples
+### Upgrade Guides
 
-```bash
-# Document an architectural decision with alternatives
-/sqlew record we use PostgreSQL over MongoDB. MongoDB was rejected due to lack of ACID transactions for our financial data requirements.
+- [Migrating to SaaS](docs/MIGRATION_TO_SAAS.md) — Export local data to sqlew.io cloud
 
-# Search for past decisions before making new ones
-/sqlew search why did we choose JWT authentication
 
-# Create constraint to guide AI code generation
-/sqlew add constraint all API endpoints must use /v2/ prefix for versioning
+### MCP Tools
 
-# Plan implementation of a decision
-/sqlew plan implementing the PostgreSQL connection pool with pgBouncer
-```
+7 action-based tools: `decision`, `constraint`, `suggest`, `help`, `example`, `use_case`, `queue`
 
-## Performance
-
-- **Query speed**: 2-50ms
-- **Concurrent agents**: 5+ simultaneous
-- **Storage efficiency**: ~140 bytes per decision
-- **Token savings**: 60-75% in typical projects
+All tools support `action: "help"` for documentation.
 
 ## Support
 
-Support development via [GitHub Sponsors](https://github.com/sponsors/sqlew-io) - One-time or monthly options available.
+Support development via [GitHub Sponsors](https://github.com/sponsors/sqlew-io).
 
 ## Version
 
-Current version: **5.0.6**
-See [CHANGELOG.md](CHANGELOG.md) for release history.
+Current version: **5.0.8**
 
-**What's New in v5.0.6:**
+See [CHANGELOG.md](CHANGELOG.md) for release history.
 
-- 🧹 **CLAUDE.md injection removed** - Plan mode enforcement via `UserPromptSubmit` hook (no more global file pollution)
-- 🔌 **Plugin-first Architecture** - Simplified setup via sqlew-plugin
-- 🌐 **SaaS Backend** - Connect to [sqlew.io](https://sqlew.io) for team-shared decisions
-- 🌳 **Git Worktree Support** - Seamless multi-branch development
+**What's New in v5.0.8:**
 
-See [docs/HOOKS_GUIDE.md](docs/HOOKS_GUIDE.md) for Claude Code Hooks details.
+- **PR ADR enforcement** — PreToolUse Hook blocks `gh pr create` without ADR markers, file-grouped format
+- **Codex CLI support** — Works beyond Claude Code via [sqlew-codex](https://github.com/sqlew-io/sqlew-codex)
+- **Plugin-first architecture** — Simplified setup via sqlew-plugin
+- **Cloud backend** — Connect to [sqlew.io](https://sqlew.io) for team-shared decisions
 
 ## License
 
-Apache License 2.0 - Free for commercial and personal use. See [LICENSE](LICENSE) for details.
+Apache License 2.0 — Free for commercial and personal use. See [LICENSE](LICENSE) for details.
 
 ## Links
 
 - [npm package](https://www.npmjs.com/package/sqlew)
-- [GitHub repository](https://github.com/sqlew-io/sqlew)
+- [GitHub](https://github.com/sqlew-io/sqlew)
+- [Issues](https://github.com/sqlew-io/sqlew/issues)
 - [Model Context Protocol](https://modelcontextprotocol.io/)
 
-## Support & Documentation
-
-- Issues: [GitHub Issues](https://github.com/sqlew-io/sqlew/issues)
-- Docs: [docs/](docs/) directory
-
-## Acknowledgments
-
-Built with [Model Context Protocol SDK](https://github.com/modelcontextprotocol/sdk), [better-sqlite3](https://github.com/WiseLibs/better-sqlite3), and TypeScript.
-
-**Author**: sqlew-io
-
 ---
 
-<!-- Git Hooks Integration Test: 2025-12-22 - This line tests post-merge hook triggering mark-done --auto -->
+Built with [MCP SDK](https://github.com/modelcontextprotocol/sdk), [better-sqlite3](https://github.com/WiseLibs/better-sqlite3), and TypeScript.

package/dist/adapters/auth/auth-factory.d.ts

@@ -1,86 +1,7 @@
-/**
- * @fileoverview Authentication Provider Factory
- *
- * Factory module for creating appropriate authentication providers based on database configuration.
- * Supports direct connections and future IAM-based authentication.
- *
- * **Note:** SSH tunneling is not supported. Users must set up SSH tunnels manually.
- *
- * @module adapters/auth/auth-factory
- */
 import { BaseAuthProvider } from './base-auth-provider.js';
 import type { DatabaseConfig } from '../../config/types.js';
-/**
- * Create an authentication provider based on database configuration.
- *
- * Provider selection logic:
- * - SQLite: Returns null (no authentication needed for file-based database)
- * - MySQL/PostgreSQL: Returns DirectAuthProvider
- *
- * @param config - Database configuration
- * @returns Authentication provider instance or null for SQLite
- * @throws Error if database type is invalid
- *
- * @example
- * // Direct connection
- * const config: DatabaseConfig = {
- *   type: 'mysql',
- *   connection: {
- *     host: 'localhost',
- *     port: 3306,
- *     database: 'mydb'
- *   },
- *   auth: {
- *     type: 'direct',
- *     user: 'dbuser',
- *     password: 'dbpass'
- *   }
- * };
- * const provider = createAuthProvider(config);
- * // Returns DirectAuthProvider instance
- *
- * @example
- * // Connection via manual SSH tunnel
- * // Step 1: Set up tunnel manually:
- * //   ssh -L 3307:db.internal.company.com:3306 user@bastion.example.com
- * // Step 2: Configure to use localhost:
- * const config: DatabaseConfig = {
- *   type: 'mysql',
- *   connection: {
- *     host: 'localhost',  // Tunnel endpoint
- *     port: 3307,         // Forwarded port
- *     database: 'mydb'
- *   },
- *   auth: {
- *     type: 'direct',
- *     user: 'dbuser',
- *     password: 'dbpass'
- *   }
- * };
- * const provider = createAuthProvider(config);
- * // Returns DirectAuthProvider for localhost connection
- *
- * @example
- * // SQLite (no authentication)
- * const sqliteConfig: DatabaseConfig = {
- *   type: 'sqlite',
- *   path: './data.db'
- * };
- * const provider = createAuthProvider(sqliteConfig);
- * // Returns null
- */
+/** Create an authentication provider based on database configuration. */
 export declare function createAuthProvider(config: DatabaseConfig): BaseAuthProvider | null;
-/**
- * Check if database type requires authentication.
- *
- * @param config - Database configuration
- * @returns True if authentication is required (MySQL/PostgreSQL)
- *
- * @example
- * if (requiresAuthentication(config)) {
- *   const provider = createAuthProvider(config);
- *   await provider!.authenticate();
- * }
- */
+/** Check if database type requires authentication. */
 export declare function requiresAuthentication(config: DatabaseConfig): boolean;
 //# sourceMappingURL=auth-factory.d.ts.map

package/dist/adapters/auth/auth-factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auth-factory.d.ts","sourceRoot":"","sources":["../../../src/adapters/auth/auth-factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAE3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,cAAc,GAAG,gBAAgB,GAAG,IAAI,CAmBlF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAEtE"}
+{"version":3,"file":"auth-factory.d.ts","sourceRoot":"","sources":["../../../src/adapters/auth/auth-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAE3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,yEAAyE;AACzE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,cAAc,GAAG,gBAAgB,GAAG,IAAI,CAkBlF;AAED,sDAAsD;AACtD,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAEtE"}

package/dist/adapters/auth/auth-factory.js

@@ -1,73 +1,5 @@
-/**
- * @fileoverview Authentication Provider Factory
- *
- * Factory module for creating appropriate authentication providers based on database configuration.
- * Supports direct connections and future IAM-based authentication.
- *
- * **Note:** SSH tunneling is not supported. Users must set up SSH tunnels manually.
- *
- * @module adapters/auth/auth-factory
- */
 import { DirectAuthProvider } from './direct-auth-provider.js';
-/**
- * Create an authentication provider based on database configuration.
- *
- * Provider selection logic:
- * - SQLite: Returns null (no authentication needed for file-based database)
- * - MySQL/PostgreSQL: Returns DirectAuthProvider
- *
- * @param config - Database configuration
- * @returns Authentication provider instance or null for SQLite
- * @throws Error if database type is invalid
- *
- * @example
- * // Direct connection
- * const config: DatabaseConfig = {
- *   type: 'mysql',
- *   connection: {
- *     host: 'localhost',
- *     port: 3306,
- *     database: 'mydb'
- *   },
- *   auth: {
- *     type: 'direct',
- *     user: 'dbuser',
- *     password: 'dbpass'
- *   }
- * };
- * const provider = createAuthProvider(config);
- * // Returns DirectAuthProvider instance
- *
- * @example
- * // Connection via manual SSH tunnel
- * // Step 1: Set up tunnel manually:
- * //   ssh -L 3307:db.internal.company.com:3306 user@bastion.example.com
- * // Step 2: Configure to use localhost:
- * const config: DatabaseConfig = {
- *   type: 'mysql',
- *   connection: {
- *     host: 'localhost',  // Tunnel endpoint
- *     port: 3307,         // Forwarded port
- *     database: 'mydb'
- *   },
- *   auth: {
- *     type: 'direct',
- *     user: 'dbuser',
- *     password: 'dbpass'
- *   }
- * };
- * const provider = createAuthProvider(config);
- * // Returns DirectAuthProvider for localhost connection
- *
- * @example
- * // SQLite (no authentication)
- * const sqliteConfig: DatabaseConfig = {
- *   type: 'sqlite',
- *   path: './data.db'
- * };
- * const provider = createAuthProvider(sqliteConfig);
- * // Returns null
- */
+/** Create an authentication provider based on database configuration. */
 export function createAuthProvider(config) {
     // Validate database type
     if (!config.type) {
@@ -82,21 +14,9 @@ export function createAuthProvider(config) {
         return null;
     }
     // MySQL/PostgreSQL use direct authentication
-    // (Users must set up SSH tunnels manually if needed)
     return new DirectAuthProvider(config);
 }
-/**
- * Check if database type requires authentication.
- *
- * @param config - Database configuration
- * @returns True if authentication is required (MySQL/PostgreSQL)
- *
- * @example
- * if (requiresAuthentication(config)) {
- *   const provider = createAuthProvider(config);
- *   await provider!.authenticate();
- * }
- */
+/** Check if database type requires authentication. */
 export function requiresAuthentication(config) {
     return config.type !== 'sqlite';
 }

package/dist/adapters/auth/auth-factory.js.map

@@ -1 +1 @@
-{"version":3,"file":"auth-factory.js","sourceRoot":"","sources":["../../../src/adapters/auth/auth-factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAG/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAsB;IACvD,yBAAyB;IACzB,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;IAChE,CAAC;IAED,MAAM,UAAU,GAAG,CAAC,QAAQ,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;IACnD,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;QACtC,MAAM,IAAI,KAAK,CAAC,0BAA0B,MAAM,CAAC,IAAI,qBAAqB,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACrG,CAAC;IAED,kDAAkD;IAClD,IAAI,MAAM,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,6CAA6C;IAC7C,qDAAqD;IACrD,OAAO,IAAI,kBAAkB,CAAC,MAAM,CAAC,CAAC;AACxC,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,sBAAsB,CAAC,MAAsB;IAC3D,OAAO,MAAM,CAAC,IAAI,KAAK,QAAQ,CAAC;AAClC,CAAC"}
+{"version":3,"file":"auth-factory.js","sourceRoot":"","sources":["../../../src/adapters/auth/auth-factory.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAG/D,yEAAyE;AACzE,MAAM,UAAU,kBAAkB,CAAC,MAAsB;IACvD,yBAAyB;IACzB,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;IAChE,CAAC;IAED,MAAM,UAAU,GAAG,CAAC,QAAQ,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;IACnD,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;QACtC,MAAM,IAAI,KAAK,CAAC,0BAA0B,MAAM,CAAC,IAAI,qBAAqB,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACrG,CAAC;IAED,kDAAkD;IAClD,IAAI,MAAM,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,6CAA6C;IAC7C,OAAO,IAAI,kBAAkB,CAAC,MAAM,CAAC,CAAC;AACxC,CAAC;AAED,sDAAsD;AACtD,MAAM,UAAU,sBAAsB,CAAC,MAAsB;IAC3D,OAAO,MAAM,CAAC,IAAI,KAAK,QAAQ,CAAC;AAClC,CAAC"}