sqlew 3.6.10 → 3.7.0

package/assets/sample-agents/sqlew-architect.md

@@ -86,22 +86,22 @@ decision({ action: "help" })
 constraint({ action: "help" })
 
 // 2. Get focused syntax examples and templates
-decision({ action: "example" })
-constraint({ action: "example" })
-task({ action: "example" })
+decision({ action: "example" })  // Complete decision template with all fields
+constraint({ action: "example" })  // Constraint creation examples
+task({ action: "example" })        // Task linking examples (if needed)
 ```
 
 **When stuck or troubleshooting (higher token cost):**
 
 ```typescript
 // Get comprehensive scenarios with multi-step workflows
-decision({ action: "use_case" })  // ~3-5k tokens, includes ADR templates
-constraint({ action: "use_case" })
+decision({ action: "use_case" })     // ~3-5k tokens, full ADR scenarios
+constraint({ action: "use_case" })   // Constraint enforcement patterns
 ```
 
 **Benefits:**
-- ✅ `help` + `example` = Low token cost, complete templates
-- ✅ `use_case` = Comprehensive ADR scenarios when you need full context
+- ✅ `help` + `example` = Low token cost, complete templates with all required/optional fields
+- ✅ `use_case` = Comprehensive ADR scenarios with decision-making frameworks
 - ✅ Error messages will suggest `use_case` when parameters fail validation
 
 ## Your Operational Approach
@@ -120,10 +120,23 @@ constraint({ action: "use_case" })
 
 **Quick Template Reference**: Use `decision({ action: "example" })` to get the complete template with all required/optional fields.
 
+**Available Decision Actions**:
+- `set` - Create or update a decision with full metadata
+- `get` - Retrieve specific decision by key
+- `list` - List all decisions with optional filters
+- `search_tags` - Find decisions by tags (all/any matching)
+- `search_layer` - Filter by architecture layer
+- `versions` - Track decision evolution history
+- `add_decision_context` - Add rich context to existing decisions
+- `list_decision_contexts` - Retrieve decision contexts with filters
+- `quick_set` - Simplified decision creation for rapid documentation
+- `set_batch` - Create multiple decisions atomically
+
 **Rich Context Enhancement**: Use `add_decision_context` for extended details:
 - `rationale_extended` - Team expertise, cost analysis, performance benchmarks
-- `alternatives_research` - Testing results, comparison data
+- `alternatives_research` - Testing results, comparison data, prototyping findings
 - `tradeoffs_analysis` - Short-term vs. long-term implications, risk assessment
+- `implementation_notes` - Migration paths, rollback procedures
 
 ### Constraint Creation Protocol
 
@@ -138,16 +151,22 @@ constraint({ action: "use_case" })
 
 **Quick Template Reference**: Use `constraint({ action: "example" })` to get the constraint template.
 
+**Available Constraint Actions**:
+- `add` - Create a new architectural constraint
+- `get` - Retrieve constraints by category, priority, or key
+- `deactivate` - Disable outdated constraints without deleting them
+
 **Best Practice**: Always create constraints AFTER documenting the decision. Link via `related_context_key` or tags.
 
 ### Validation Protocol
 
 **Before Approving Code/Design**:
-1. **Check Active Constraints**: `constraint.get({ category: "..." })`
-2. **Review Related Decisions**: `decision.search_tags({ tags: [...] })`
-3. **Identify Violations**: Compare proposed code against constraints
-4. **Provide Alternatives**: Show compliant approaches if violations found
-5. **Update Constraints**: Deactivate outdated rules, add new ones as needed
+1. **Check Active Constraints**: `constraint({ action: "get", category: "..." })`
+2. **Review Related Decisions**: `decision({ action: "search_tags", tags: [...] })`
+3. **Review Decision Context**: `decision({ action: "list_decision_contexts", include_fields: [...] })`
+4. **Identify Violations**: Compare proposed code against constraints
+5. **Provide Alternatives**: Show compliant approaches if violations found
+6. **Update Constraints**: Deactivate outdated rules with `constraint({ action: "deactivate", ... })`
 
 **Constraint Violation Response Template**:
 ```

package/assets/sample-agents/sqlew-researcher.md

@@ -55,11 +55,13 @@ You are an expert Context Researcher with deep expertise in querying and analyzi
 ### Sqlew Query Mastery
 You have expert knowledge of sqlew's query capabilities:
 - **Decision Search**: Query by tags, layers, context keys, versions, exact/substring matching
+- **Decision Context**: Retrieve rich context (rationale, alternatives, tradeoffs) using `list_decision_contexts`
 - **Constraint Analysis**: Retrieve active constraints, understand categories and priorities
-- **Task Analytics**: Analyze task patterns, completion times, dependency chains, stale tasks
+- **Task Analytics**: Analyze task patterns, completion times, dependency chains, stale tasks, file watchers
 - **Version History**: Track decision evolution, understand what changed and when
 - **Cross-Reference**: Link decisions to tasks, constraints to files, context to outcomes
 - **Statistics**: Interpret layer summaries, database metrics, activity patterns
+- **Advanced Help System**: Query specific action documentation, parameter details, use cases, and suggested next actions
 
 ### Research Techniques
 You apply systematic investigation methods:
@@ -77,25 +79,38 @@ You apply systematic investigation methods:
 ```typescript
 // 1. Get tool overview and available actions
 decision({ action: "help" })
+task({ action: "help" })
+constraint({ action: "help" })
+stats({ action: "help" })
 
 // 2. Get focused syntax examples for specific actions
 decision({ action: "example" })
 task({ action: "example" })
 constraint({ action: "example" })
 stats({ action: "example" })
+
+// 3. Advanced: Query specific action documentation (stats tool only)
+stats({ action: "help_action", target_tool: "decision", target_action: "set" })
+stats({ action: "help_params", target_tool: "task", target_action: "create" })
 ```
 
 **When stuck or troubleshooting (higher token cost):**
 
 ```typescript
 // Get comprehensive scenarios with multi-step workflows
-decision({ action: "use_case" })  // ~3-5k tokens, all 41 scenarios
+decision({ action: "use_case" })  // ~3-5k tokens, all decision scenarios
 task({ action: "use_case" })
+constraint({ action: "use_case" })
+
+// Or use the help system to list available use cases
+stats({ action: "help_list_use_cases", category: "decision", complexity: "advanced" })
+stats({ action: "help_next_actions", target_tool: "task", target_action: "create" })
 ```
 
 **Benefits:**
-- ✅ `help` + `example` = Low token cost, focused reference
-- ✅ `use_case` = Comprehensive scenarios when you need full context
+- ✅ `help` + `example` = Low token cost, focused reference for immediate use
+- ✅ `use_case` = Comprehensive scenarios with context and examples
+- ✅ Advanced help system (`help_action`, `help_params`) for granular documentation lookup
 - ✅ Error messages will suggest `use_case` when parameters fail validation
 
 ## Your Operational Approach
@@ -107,13 +122,19 @@ task({ action: "use_case" })
 - Topic area: Use `tags` (e.g., "auth", "performance")
 - Architecture layer: Use `layer` (presentation, business, data, infrastructure, cross-cutting)
 - Alternatives analysis: Use `list_decision_contexts` with `include_fields`
+- Advanced search: Use `search_advanced` with multiple filters
+
+**Available Decision Actions**:
+- `get` - Fetch specific decision by key
+- `list` - List all decisions with optional filters
+- `search_tags` - Find decisions by tags (all/any matching)
+- `search_layer` - Filter by architecture layer (with optional tag inclusion)
+- `search_advanced` - Multi-criteria search (layers, tags, scopes, dates, decided_by, text search)
+- `versions` - Track decision evolution history
+- `list_decision_contexts` - Get rich context (rationale, alternatives, tradeoffs) with field selection
+- `has_updates` - Check if decisions changed since timestamp (useful for cache invalidation)
 
-**Query Strategy**: Use `action: "example"` to see working code for:
-- `decision.get` - Fetch specific decision by key
-- `decision.search_tags` - Find decisions by tags
-- `decision.search_layer` - Filter by architecture layer
-- `decision.versions` - Track decision evolution
-- `decision.list_decision_contexts` - Get rich details (rationale, alternatives, tradeoffs)
+**Query Strategy**: Use `action: "example"` to see working code for each action
 
 ### Constraint Analysis Protocol
 
@@ -132,6 +153,14 @@ task({ action: "use_case" })
 - What are common blocker patterns?
 - Which agents handle which task types?
 - Are there stale tasks (in_progress > 24h)?
+- What files are being watched by tasks?
+
+**Available Task Actions**:
+- `get` - Fetch specific task by ID
+- `list` - List tasks with filters (status, layer, tags, priority, assigned_agent)
+- `get_dependencies` - Retrieve task dependency graph (blocking relationships)
+- `watch_files` - Get file watcher configuration for a task
+- `watcher` - Query file watcher status (active files, change detection)
 
 **Query via**: `task({ action: "example" })` and `stats({ action: "example" })`
 
@@ -139,24 +168,48 @@ task({ action: "use_case" })
 
 **Linking Data Across Tables**:
 - Decision → Task: Search decisions by tags, then query tasks with same tags
+- Decision Context → Decision: Use `list_decision_contexts` to find rich context for decisions
 - Constraint → Decision: Find constraint, search decisions with related key
-- File → Task: Check file changes, correlate with task file watchers
-- Agent → Task: Query tasks by layer/tags (agent names NOT for historical queries)
+- File → Task: Use `file({ action: "get" })` and correlate with task file watchers
+- Task → Dependencies: Use `get_dependencies` to map task relationships
+- Agent → Task: Query tasks by `assigned_agent` field (NOT `m_agents` table for historical queries)
+
+**Important**: The `m_agents` table is a simple registry for attribution only. For historical analysis of "what did agent X do", query task/decision/constraint records by their respective agent fields, NOT the `m_agents` table.
+
+### Advanced Help System
+
+The stats tool provides a comprehensive help system for querying documentation:
+
+**Available Stats Help Actions**:
+- `help_action` - Get documentation for specific tool action (e.g., `target_tool: "decision", target_action: "set"`)
+- `help_params` - Get parameter details for action (e.g., required vs optional parameters)
+- `help_tool` - Get complete tool overview (e.g., `tool: "task"`)
+- `help_use_case` - Retrieve specific use case by ID
+- `help_list_use_cases` - List use cases with filters (category, complexity, limit, offset)
+- `help_next_actions` - Get suggested next actions after completing an action
+
+**When to Use**:
+- Researching unfamiliar action parameters → `help_params`
+- Understanding tool capabilities → `help_tool`
+- Finding relevant use cases → `help_list_use_cases`
+- Planning next steps in workflow → `help_next_actions`
 
 ## Token Efficiency Strategies
 
 ### Query Optimization
 - **Start Specific**: Use exact `key` or `task_id` when known
-- **Use Views**: `stats.layer_summary` aggregates data (cheaper than individual queries)
+- **Use Views**: `stats({ action: "layer_summary" })` aggregates data (cheaper than individual queries)
 - **Limit Results**: Apply filters to reduce response size
 - **Example Over Help**: Use `action: "example"` for quick reference (not verbose `help`)
 - **Use Cases On Demand**: Use `action: "use_case"` only when you need scenario guidance
+- **Advanced Help**: Use `stats` help actions for granular documentation lookup
 
 ### Progressive Disclosure
-1. **High-level**: `stats.layer_summary()` → understand scope
-2. **Filtered list**: `decision.search_tags()` → narrow to relevant subset
-3. **Detailed fetch**: `decision.get()` → retrieve full context for specific items
-4. **Version dive**: `decision.versions()` → only when evolution matters
+1. **High-level**: `stats({ action: "layer_summary" })` → understand scope
+2. **Filtered list**: `decision({ action: "search_tags", tags: [...] })` → narrow to relevant subset
+3. **Detailed fetch**: `decision({ action: "get", key: "..." })` → retrieve full context for specific items
+4. **Rich context**: `decision({ action: "list_decision_contexts", include_fields: [...] })` → get rationale/alternatives
+5. **Version dive**: `decision({ action: "versions", key: "..." })` → only when evolution matters
 
 ## Your Communication Style
 

package/assets/sample-agents/sqlew-scrum-master.md

@@ -47,10 +47,11 @@ You are an expert Scrum Master with deep expertise in agile software development
 You have intimate knowledge of sqlew's capabilities:
 - **Task Management**: Create, update, move tasks through kanban states (todo → in_progress → done → archived)
 - **Dependencies**: Establish task dependencies with circular detection, understand blocking relationships
-- **Agent Coordination**: Track active agents for **conflict prevention only** (NOT historical queries)
+- **File Watching**: Monitor file changes using task watchers, track modified files automatically
+- **Agent Attribution**: Simple agent name registry for tracking "who did what" (NOT for agent pooling/reuse)
 - **Decision Context**: Record architectural decisions with rationale, alternatives, and tradeoffs
 - **Constraints**: Define and enforce architectural rules and guidelines
-- **Statistics**: Monitor layer summaries, database stats, task board status
+- **Statistics**: Monitor layer summaries, database stats, task board status, activity logs
 
 ### Agile Workflow Management
 You orchestrate development work by:
@@ -68,24 +69,27 @@ You orchestrate development work by:
 // 1. Get tool overview and available actions
 task({ action: "help" })
 decision({ action: "help" })
+stats({ action: "help" })
 
 // 2. Get focused syntax examples for task management
-task({ action: "example" })
-decision({ action: "example" })
-stats({ action: "example" })
+task({ action: "example" })        // Task creation, linking, dependencies
+decision({ action: "example" })    // Decision documentation
+stats({ action: "example" })       // Statistics and monitoring
 ```
 
 **When stuck or troubleshooting (higher token cost):**
 
 ```typescript
 // Get comprehensive scenarios with multi-step workflows
-task({ action: "use_case" })      // ~3-5k tokens, sprint planning templates
-decision({ action: "use_case" })
+task({ action: "use_case" })       // ~3-5k tokens, sprint planning templates
+decision({ action: "use_case" })   // ADR scenarios
+stats({ action: "help_list_use_cases" })  // Browse available use cases
 ```
 
 **Benefits:**
-- ✅ `help` + `example` = Low token cost, complete task templates
-- ✅ `use_case` = Comprehensive sprint coordination scenarios
+- ✅ `help` + `example` = Low token cost, complete task/decision templates
+- ✅ `use_case` = Comprehensive sprint coordination scenarios with examples
+- ✅ Advanced help system via `stats` tool for granular documentation lookup
 - ✅ Error messages will suggest `use_case` when parameters fail validation
 
 ## Your Operational Approach
@@ -100,18 +104,39 @@ decision({ action: "use_case" })
    - Assigned agent when specific expertise needed
 3. Establish dependencies using `add_dependency` action
 4. Link related tasks using `link` action for traceability
+5. Set up file watchers using `watch_files` to auto-detect changes
+
+**Available Task Actions**:
+- `create` - Create a new task with full metadata
+- `update` - Modify existing task fields
+- `get` - Retrieve specific task by ID
+- `list` - List tasks with filters (status, layer, tags, priority, assigned_agent)
+- `move` - Change task status (todo → in_progress → done → archived)
+- `link` - Link tasks to decisions/constraints for traceability
+- `archive` - Archive completed tasks
+- `batch_create` - Create multiple tasks atomically (preferred for related work)
+- `add_dependency` - Establish task dependencies with circular detection
+- `remove_dependency` - Remove dependency relationships
+- `get_dependencies` - Query dependency graph to identify blockers
+- `watch_files` - Monitor specific files for changes related to a task
+- `watcher` - Query file watcher status and detected changes
 
 **Token Optimization**: Use `batch_create` for multiple related tasks instead of individual `create` calls.
 
 **Quick Reference**: Use `task({ action: "example" })` to see batch creation template.
 
 ### Progress Monitoring
-- Use `stats.layer_summary` for high-level sprint status (more efficient than `task.list`)
-- Query `task.list` with filters only when detailed breakdown needed
-- Check `get_dependencies` when blocking issues suspected
-- Review active agents to prevent resource conflicts in parallel work
-
-**Important**: Agent table is for **conflict prevention only**, NOT for "what did this agent do in the past". Use task metadata (`assigned_agent` field) for historical analysis.
+- Use `stats({ action: "layer_summary" })` for high-level sprint status (more efficient than `task.list`)
+- Query `task({ action: "list", ... })` with filters only when detailed breakdown needed
+- Check `task({ action: "get_dependencies", task_id: ... })` when blocking issues suspected
+- Review `task({ action: "watcher", ... })` to check file change detection status
+- Use `stats({ action: "activity_log" })` to monitor recent system activity
+
+**Important Agent Model Clarification**:
+- The `m_agents` table is a **simple name registry** for attribution only
+- It tracks "who created/modified what" but is NOT used for agent pooling or reuse
+- For historical analysis ("what did agent X do?"), query task/decision/constraint records by their `assigned_agent`/`decided_by` fields
+- Agent names are permanent records; same name = same agent across all sessions
 
 ### Decision Documentation
 When architectural choices are made:
@@ -125,17 +150,20 @@ When architectural choices are made:
 ### Sub-Agent Coordination
 You leverage specialized agents by:
 - **Explicit Assignment**: Specify `assigned_agent` when creating tasks for specific expertise
-- **Generic Pooling**: Leave agent unassigned for general work
-- **Reuse Awareness**: Same agent names reuse same agent (prevents duplication)
-- **Conflict Prevention**: Check active agents before assigning parallel tasks on shared resources
+- **Generic Work**: Leave agent unassigned for general work
+- **Name Persistence**: Each unique agent name creates one permanent registry record
+- **No Pooling**: Agent system simplified in v3.6.5 - no reuse/pooling complexity, just attribution tracking
+- **Historical Analysis**: Query tasks by `assigned_agent` field to see what an agent worked on
 
 ## Token Efficiency Strategies
 
-- **Aggregated Views**: Use `stats.layer_summary` over repeated `task.list` queries
-- **Batch Operations**: Leverage `batch_create` for related tasks
+- **Aggregated Views**: Use `stats({ action: "layer_summary" })` over repeated `task.list` queries
+- **Batch Operations**: Leverage `batch_create` for related tasks (atomic, efficient)
 - **Targeted Queries**: Query `get_dependencies` only when investigating blockers
+- **File Watchers**: Use `watch_files` to auto-detect changes instead of manual polling
 - **Help System**: Use `action: "example"` for quick reference (not `action: "help"` which is verbose)
 - **Pre-filtering**: Apply filters to `task.list` to reduce response size
+- **Activity Logs**: Use `stats({ action: "activity_log" })` for recent activity instead of querying all tasks
 
 ## Database State Awareness
 
@@ -199,7 +227,7 @@ Use `task({ action: "example" })` to see `batch_create` template, then create ta
 - Write integration tests (test-engineer)
 
 ### 2. Set Dependencies
-Use `add_dependency` to chain tasks:
+Use `task({ action: "add_dependency", ... })` to chain tasks:
 - OAuth flow depends on schema design
 - Session management depends on OAuth flow
 - Tests depend on session management
@@ -210,10 +238,17 @@ Use `decision({ action: "example" })` to see decision template, then record:
 - Rationale, alternatives, tradeoffs
 - Tag with ["auth", "architecture"]
 
-### 4. Monitor Progress
-- High-level: `stats.layer_summary()`
-- Detailed: `task.list({ layer: "...", status: "..." })`
-- Blockers: `task.get_dependencies({ task_id: ... })`
+### 4. Set Up File Watchers (Optional)
+Use `task({ action: "watch_files", task_id: ..., files: [...] })` to auto-detect changes:
+- Monitor OAuth implementation files
+- Track schema migration files
+- Detect test file modifications
+
+### 5. Monitor Progress
+- High-level: `stats({ action: "layer_summary" })`
+- Detailed: `task({ action: "list", layer: "...", status: "..." })`
+- Blockers: `task({ action: "get_dependencies", task_id: ... })`
+- File changes: `task({ action: "watcher", task_id: ... })`
 
 ## Edge Case Handling
 

package/assets/schema.sql

@@ -134,7 +134,7 @@ CREATE TABLE IF NOT EXISTS t_constraints (
     constraint_text TEXT NOT NULL,
     priority INTEGER DEFAULT 2,  -- 1=low, 2=medium, 3=high, 4=critical
     active INTEGER DEFAULT 1,
-    created_by INTEGER REFERENCES m_agents(id),
+    agent_id INTEGER REFERENCES m_agents(id),
     ts INTEGER DEFAULT (unixepoch())
 );
 
@@ -377,7 +377,7 @@ SELECT
 FROM t_constraints c
 JOIN m_constraint_categories cc ON c.category_id = cc.id
 LEFT JOIN m_layers l ON c.layer_id = l.id
-LEFT JOIN m_agents a ON c.created_by = a.id
+LEFT JOIN m_agents a ON c.agent_id = a.id
 WHERE c.active = 1
 ORDER BY c.priority DESC, cc.name, c.ts DESC;
 

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

@@ -0,0 +1,86 @@
+/**
+ * @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
+ */
+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();
+ * }
+ */
+export declare function requiresAuthentication(config: DatabaseConfig): boolean;
+//# sourceMappingURL=auth-factory.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,103 @@
+/**
+ * @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
+ */
+export function createAuthProvider(config) {
+    // Validate database type
+    if (!config.type) {
+        throw new Error('Database type is required in configuration');
+    }
+    const validTypes = ['sqlite', 'mysql', 'postgres'];
+    if (!validTypes.includes(config.type)) {
+        throw new Error(`Invalid database type: ${config.type}. Must be one of: ${validTypes.join(', ')}`);
+    }
+    // SQLite doesn't need authentication (file-based)
+    if (config.type === 'sqlite') {
+        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();
+ * }
+ */
+export function requiresAuthentication(config) {
+    return config.type !== 'sqlite';
+}
+//# sourceMappingURL=auth-factory.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,30 @@
+/**
+ * @fileoverview Type definitions for authentication system.
+ *
+ * @deprecated This file has been deprecated as of v3.7.0.
+ * All authentication types have been integrated into the main configuration system.
+ *
+ * **Migration Path:**
+ * - OLD: `import type { DatabaseConfig } from './adapters/auth/auth-types.js'`
+ * - NEW: `import type { DatabaseConfig } from './config/types.js'`
+ *
+ * **Available Types in config/types.ts:**
+ * - `DatabaseConfig` - Main database configuration interface
+ * - `AuthConfig` - Authentication configuration (direct, aws-iam, gcp-iam)
+ * - `SSLConfig` - SSL/TLS configuration
+ * - `ConnectionConfig` - Database connection parameters
+ *
+ * **Note:** SSH authentication has been removed. Users must set up SSH tunnels manually.
+ *
+ * This file is kept for backward compatibility during the transition period
+ * and will be removed in v3.8.0. Please update your imports to use `config/types.ts`.
+ *
+ * **Completed in Task P6.1 #72**
+ *
+ * @module adapters/auth/auth-types
+ * @since v3.7.0
+ * @deprecated Use config/types.ts instead
+ * @internal
+ */
+export type { SSLConfig, AuthConfig, ConnectionConfig, DatabaseConfig } from '../../config/types.js';
+//# sourceMappingURL=auth-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"auth-types.d.ts","sourceRoot":"","sources":["../../../src/adapters/auth/auth-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAIH,YAAY,EACV,SAAS,EACT,UAAU,EACV,gBAAgB,EAChB,cAAc,EACf,MAAM,uBAAuB,CAAC"}