@intentsolutionsio/data-validation-engine 1.0.0

package/.claude-plugin/plugin.json

@@ -0,0 +1,17 @@
+{
+  "name": "data-validation-engine",
+  "version": "1.0.0",
+  "description": "Database plugin for data-validation-engine",
+  "author": {
+    "name": "Claude Code Plugins",
+    "email": "[email protected]"
+  },
+  "repository": "https://github.com/jeremylongshore/claude-code-plugins",
+  "license": "MIT",
+  "keywords": [
+    "database",
+    "backend",
+    "validation",
+    "agent-skills"
+  ]
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2026 Jeremy Longshore & Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,35 @@
+# Data Validation Engine Plugin
+
+Database plugin for data-validation-engine
+
+## Installation
+
+```bash
+/plugin install data-validation-engine@claude-code-plugins-plus
+```
+
+## Usage
+
+```bash
+/data-validation-engine
+```
+
+## Features
+
+- Database best practices
+- Multi-database support
+- Production-ready implementations
+- Comprehensive documentation
+
+## Requirements
+
+- Database access
+- Appropriate permissions
+
+## Files
+
+- `commands/data-validation-engine.md` or `agents/data-validation-engine-agent.md` - Main plugin logic
+
+## License
+
+MIT

package/agents/validation-agent.md

@@ -0,0 +1,19 @@
+---
+name: validation-agent
+description: Implement data validation rules
+---
+# Data Validation Engine
+
+Implement comprehensive data validation at database and application levels.
+
+## Validation Types
+
+1. **Type Validation**: Correct data types
+2. **Range Validation**: Min/max values
+3. **Format Validation**: Regex patterns
+4. **Referential Integrity**: Foreign key validation
+5. **Business Rules**: Custom validation logic
+
+## When to Activate
+
+Implement data validation for database integrity.

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@intentsolutionsio/data-validation-engine",
+  "version": "1.0.0",
+  "description": "Database plugin for data-validation-engine",
+  "keywords": [
+    "database",
+    "backend",
+    "validation",
+    "agent-skills",
+    "claude-code",
+    "claude-plugin",
+    "tonsofskills"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jeremylongshore/claude-code-plugins-plus-skills.git",
+    "directory": "plugins/database/data-validation-engine"
+  },
+  "homepage": "https://tonsofskills.com/plugins/data-validation-engine",
+  "bugs": "https://github.com/jeremylongshore/claude-code-plugins-plus-skills/issues",
+  "license": "MIT",
+  "author": {
+    "name": "Claude Code Plugins",
+    "email": "[email protected]"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "README.md",
+    ".claude-plugin",
+    "skills",
+    "agents"
+  ],
+  "scripts": {
+    "postinstall": "node -e \"console.log(\\\"\\\\n→ This npm package is a tracking/proof artifact. Install the plugin via:\\\\n  ccpi install data-validation-engine\\\\n  or /plugin install data-validation-engine@claude-code-plugins-plus in Claude Code\\\\n\\\")\""
+  }
+}

package/skills/validating-database-integrity/SKILL.md

@@ -0,0 +1,100 @@
+---
+name: validating-database-integrity
+description: |
+  Process use when you need to ensure database integrity through comprehensive data validation.
+  This skill validates data types, ranges, formats, referential integrity, and business rules.
+  Trigger with phrases like "validate database data", "implement data validation rules",
+  "enforce data integrity constraints", or "validate data formats".
+
+allowed-tools: Read, Write, Edit, Grep, Glob, Bash(psql:*), Bash(mysql:*)
+version: 1.0.0
+author: Jeremy Longshore <jeremy@intentsolutions.io>
+license: MIT
+compatible-with: claude-code, codex, openclaw
+tags: [database, validating-database]
+---
+# Data Validation Engine
+
+## Overview
+
+Implement and enforce data integrity rules at the database level using CHECK constraints, triggers, foreign keys, and custom validation functions across PostgreSQL and MySQL.
+
+## Prerequisites
+
+- Database credentials with ALTER TABLE and CREATE FUNCTION permissions
+- `psql` or `mysql` CLI for executing validation queries
+- Current schema documentation or access to `information_schema` for column specifications
+- Business rules document describing valid data ranges, formats, and relationships
+- Backup of production data before applying new constraints (constraints may reject existing invalid data)
+
+## Instructions
+
+1. Audit existing data quality by running validation queries before adding constraints. Check for NULL values in columns that should be required: `SELECT column_name, COUNT(*) FILTER (WHERE column_name IS NULL) AS null_count, COUNT(*) AS total FROM table_name GROUP BY column_name`.
+
+2. Detect orphaned records (broken referential integrity): `SELECT c.id FROM child_table c LEFT JOIN parent_table p ON c.parent_id = p.id WHERE p.id IS NULL`. Document all orphaned records for cleanup or archival before adding foreign key constraints.
+
+3. Validate data format compliance:
+   - Email format: `SELECT email FROM users WHERE email !~ '^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$'`
+   - Phone format: `SELECT phone FROM contacts WHERE phone !~ '^\+?[1-9]\d{6,14}$'`
+   - URL format: `SELECT url FROM links WHERE url !~ '^https?://.+'`
+   - Date ranges: `SELECT * FROM events WHERE start_date > end_date`
+
+4. Check numeric range violations: `SELECT * FROM products WHERE price < 0 OR price > 999999.99` and `SELECT * FROM users WHERE age < 0 OR age > 150`. Map each column to its valid range based on business rules.
+
+5. Identify duplicate records that violate intended uniqueness: `SELECT email, COUNT(*) FROM users GROUP BY email HAVING COUNT(*) > 1`. Determine which duplicate to keep (most recent, most complete) and plan deduplication.
+
+6. Generate CHECK constraints for validated rules:
+   - `ALTER TABLE products ADD CONSTRAINT chk_price_positive CHECK (price >= 0)`
+   - `ALTER TABLE users ADD CONSTRAINT chk_email_format CHECK (email ~ '^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$')`
+   - `ALTER TABLE events ADD CONSTRAINT chk_date_order CHECK (start_date <= end_date)`
+   - `ALTER TABLE orders ADD CONSTRAINT chk_status_valid CHECK (status IN ('pending', 'processing', 'shipped', 'delivered', 'cancelled'))`
+
+7. Create foreign key constraints with appropriate cascade behavior:
+   - `ALTER TABLE orders ADD CONSTRAINT fk_orders_customer FOREIGN KEY (customer_id) REFERENCES customers(id) ON DELETE RESTRICT`
+   - Use `ON DELETE CASCADE` for dependent data (order_items when order is deleted)
+   - Use `ON DELETE SET NULL` for optional relationships (assigned_to when user is deactivated)
+
+8. Implement complex business rule validation using database triggers when CHECK constraints are insufficient:
+   - Trigger that prevents order total from exceeding customer credit limit
+   - Trigger that enforces at least one admin user per organization
+   - Trigger that validates JSON schema for JSONB columns
+
+9. Apply constraints in a safe two-phase approach:
+   - Phase 1: Run validation queries to find all violations. Generate data cleanup scripts. Execute cleanup.
+   - Phase 2: Apply constraints with `NOT VALID` option (PostgreSQL): `ALTER TABLE users ADD CONSTRAINT chk_email CHECK (email ~ '...') NOT VALID` then `ALTER TABLE users VALIDATE CONSTRAINT chk_email` (validates existing data without blocking writes).
+
+10. Generate a data quality report summarizing: total records per table, violation counts by constraint type, cleanup actions taken, constraints applied, and remaining data quality issues requiring manual review.
+
+## Output
+
+- **Data quality audit report** with violation counts, examples, and severity ratings
+- **Data cleanup scripts** (SQL) to fix violations before constraint application
+- **Constraint DDL scripts** with CHECK, FOREIGN KEY, NOT NULL, and UNIQUE constraints
+- **Validation triggers** for complex business rules beyond simple constraints
+- **Ongoing validation queries** for periodic data quality monitoring
+
+## Error Handling
+
+| Error | Cause | Solution |
+|-------|-------|---------|
+| `check constraint violated by existing row` | Existing data fails the new constraint | Run the validation query first to find violations; clean up data; use `NOT VALID` option to add constraint without checking existing data, then validate separately |
+| `cannot add foreign key: referenced row not found` | Orphaned child records reference non-existent parent | Clean up orphaned records first with DELETE or UPDATE to valid parent; or insert missing parent records |
+| `column cannot be made NOT NULL: contains NULL values` | Existing rows have NULL in the target column | Backfill NULLs with `UPDATE table SET column = default_value WHERE column IS NULL` before adding NOT NULL |
+| Trigger function causes performance regression | Complex validation logic executes on every INSERT/UPDATE | Optimize trigger function; use WHEN clause to limit trigger firing; consider CHECK constraints instead of triggers for simple rules |
+| Circular foreign key prevents constraint creation | Tables reference each other, preventing creation order | Use `ALTER TABLE ADD CONSTRAINT` after both tables exist; or use `DEFERRABLE INITIALLY DEFERRED` constraints |
+
+## Examples
+
+**Auditing a legacy database with 50,000 invalid email addresses**: Validation query reveals 50,000 of 2M user records have invalid email formats (missing @, double dots, spaces). A cleanup script normalizes common issues (trim whitespace, lowercase) and flags 3,000 unfixable records for manual review. After cleanup, a CHECK constraint with regex validation is applied.
+
+**Enforcing referential integrity on a database without foreign keys**: An application relied on application-level FK enforcement, resulting in 12,000 orphaned order_items, 800 orphaned payments, and 200 orphaned reviews. Cleanup scripts archive orphaned records to backup tables, then foreign key constraints with `ON DELETE CASCADE` are added. A nightly validation job monitors for new orphans.
+
+**Implementing business rules for a financial application**: Constraints enforce: account balance cannot be negative (`CHECK (balance >= 0)`), transfer amount must be positive (`CHECK (amount > 0)`), transaction date cannot be in the future (`CHECK (transaction_date <= CURRENT_DATE)`), and a trigger prevents transfers between accounts owned by different customers unless explicitly authorized.
+
+## Resources
+
+- PostgreSQL CHECK constraints: https://www.postgresql.org/docs/current/ddl-constraints.html
+- PostgreSQL triggers: https://www.postgresql.org/docs/current/triggers.html
+- MySQL CHECK constraints (8.0.16+): https://dev.mysql.com/doc/refman/8.0/en/create-table-check-constraints.html
+- Data validation patterns: https://www.postgresql.org/docs/current/ddl-constraints.html#DDL-CONSTRAINTS-CHECK-CONSTRAINTS
+- NOT VALID constraint option: https://www.postgresql.org/docs/current/sql-altertable.html

package/skills/validating-database-integrity/assets/README.md

@@ -0,0 +1,5 @@
+# Assets
+
+Bundled resources for data-validation-engine skill
+
+- [ ] validation_report_template.html: HTML template for generating visually appealing and informative data validation reports.

package/skills/validating-database-integrity/references/README.md

@@ -0,0 +1,4 @@
+# References
+
+Bundled resources for data-validation-engine skill
+

package/skills/validating-database-integrity/scripts/README.md

@@ -0,0 +1,7 @@
+# Scripts
+
+Bundled resources for data-validation-engine skill
+
+- [x] validate_data.py: Script to execute data validation checks against a specified database and table, logging any discrepancies.
+- [x] generate_validation_report.py: Script to generate a comprehensive report of data validation results, including statistics and identified issues.
+- [x] configure_validation_rules.py: Script to interactively configure data validation rules for a given database and table, storing the rules in a configuration file.

package/skills/validating-database-integrity/scripts/configure_validation_rules.py

@@ -0,0 +1,481 @@
+#!/usr/bin/env python3
+"""
+Interactively configure data validation rules for a database table.
+
+This script allows users to define and customize validation rules for database tables,
+which are then saved in a configuration file for use by other validation scripts.
+"""
+
+import argparse
+import json
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Any, Optional
+
+
+class ValidationRuleConfigurator:
+    """Interactively configure validation rules."""
+
+    def __init__(self):
+        """Initialize configurator."""
+        self.rules = []
+        self.table_name = ""
+        self.database = ""
+
+    def add_not_null_rule(self, column: str):
+        """
+        Add a NOT NULL validation rule.
+
+        Args:
+            column: Column name
+        """
+        self.rules.append({
+            "rule": "not_null",
+            "column": column,
+            "description": f"Column {column} must not contain NULL values"
+        })
+
+    def add_unique_rule(self, column: str):
+        """
+        Add a UNIQUE validation rule.
+
+        Args:
+            column: Column name
+        """
+        self.rules.append({
+            "rule": "unique",
+            "column": column,
+            "description": f"Column {column} must contain unique values"
+        })
+
+    def add_range_rule(
+        self,
+        column: str,
+        min_value: float,
+        max_value: float
+    ):
+        """
+        Add a RANGE validation rule.
+
+        Args:
+            column: Column name
+            min_value: Minimum allowed value
+            max_value: Maximum allowed value
+        """
+        self.rules.append({
+            "rule": "range",
+            "column": column,
+            "min": min_value,
+            "max": max_value,
+            "description": f"Column {column} values must be between {min_value} and {max_value}"
+        })
+
+    def add_pattern_rule(self, column: str, pattern: str):
+        """
+        Add a PATTERN (regex) validation rule.
+
+        Args:
+            column: Column name
+            pattern: Regular expression pattern
+        """
+        self.rules.append({
+            "rule": "pattern",
+            "column": column,
+            "pattern": pattern,
+            "description": f"Column {column} values must match pattern: {pattern}"
+        })
+
+    def add_custom_rule(self, column: str, query: str):
+        """
+        Add a custom SQL validation rule.
+
+        Args:
+            column: Column name
+            query: Custom SQL query
+        """
+        self.rules.append({
+            "rule": "custom",
+            "column": column,
+            "query": query,
+            "description": f"Custom validation on {column}"
+        })
+
+    def remove_rule(self, index: int) -> bool:
+        """
+        Remove a rule by index.
+
+        Args:
+            index: Rule index
+
+        Returns:
+            True if successful, False otherwise
+        """
+        if 0 <= index < len(self.rules):
+            del self.rules[index]
+            return True
+        return False
+
+    def get_config_dict(self) -> Dict[str, Any]:
+        """
+        Get configuration as dictionary.
+
+        Returns:
+            Configuration dictionary
+        """
+        return {
+            "table": self.table_name,
+            "database": self.database,
+            "created_at": datetime.now().isoformat(),
+            "validations": self.rules
+        }
+
+    def load_config(self, filepath: str) -> bool:
+        """
+        Load configuration from JSON file.
+
+        Args:
+            filepath: Path to JSON file
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            with open(filepath, 'r') as f:
+                config = json.load(f)
+
+            self.table_name = config.get("table", "")
+            self.database = config.get("database", "")
+            self.rules = config.get("validations", [])
+
+            return True
+        except (FileNotFoundError, json.JSONDecodeError) as e:
+            print(f"Error loading config: {e}", file=sys.stderr)
+            return False
+
+    def save_config(self, filepath: str) -> bool:
+        """
+        Save configuration to JSON file.
+
+        Args:
+            filepath: Path to save JSON file
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            with open(filepath, 'w') as f:
+                json.dump(self.get_config_dict(), f, indent=2)
+            return True
+        except Exception as e:
+            print(f"Error saving config: {e}", file=sys.stderr)
+            return False
+
+
+def interactive_mode(configurator: ValidationRuleConfigurator):
+    """
+    Run interactive configuration mode.
+
+    Args:
+        configurator: ValidationRuleConfigurator instance
+    """
+    print("\n" + "="*60)
+    print("Data Validation Rule Configurator")
+    print("="*60 + "\n")
+
+    # Get table and database info
+    configurator.table_name = input("Enter table name: ").strip()
+    if not configurator.table_name:
+        print("Error: Table name is required")
+        sys.exit(1)
+
+    configurator.database = input("Enter database name (optional): ").strip()
+
+    print("\nConfigure validation rules for this table.")
+    print("Enter 'help' for rule descriptions, 'done' when finished.\n")
+
+    while True:
+        print("\nAvailable rules:")
+        print("  1. not-null   - Column cannot contain NULL values")
+        print("  2. unique     - Column values must be unique")
+        print("  3. range      - Column values must be within min/max")
+        print("  4. pattern    - Column values must match regex pattern")
+        print("  5. custom     - Custom SQL validation query")
+        print("  6. list       - Show current rules")
+        print("  7. remove     - Remove a rule")
+        print("  8. done       - Finish configuration")
+
+        choice = input("\nEnter rule type (1-8): ").strip().lower()
+
+        if choice in ["done", "8"]:
+            break
+        elif choice == "help":
+            print_help()
+        elif choice in ["1", "not-null"]:
+            column = input("Enter column name: ").strip()
+            if column:
+                configurator.add_not_null_rule(column)
+                print(f"✓ Added NOT NULL rule for {column}")
+        elif choice in ["2", "unique"]:
+            column = input("Enter column name: ").strip()
+            if column:
+                configurator.add_unique_rule(column)
+                print(f"✓ Added UNIQUE rule for {column}")
+        elif choice in ["3", "range"]:
+            column = input("Enter column name: ").strip()
+            try:
+                min_val = float(input("Enter minimum value: "))
+                max_val = float(input("Enter maximum value: "))
+                configurator.add_range_rule(column, min_val, max_val)
+                print(f"✓ Added RANGE rule for {column} [{min_val}, {max_val}]")
+            except ValueError:
+                print("Error: Invalid numeric values")
+        elif choice in ["4", "pattern"]:
+            column = input("Enter column name: ").strip()
+            pattern = input("Enter regex pattern: ").strip()
+            if column and pattern:
+                configurator.add_pattern_rule(column, pattern)
+                print(f"✓ Added PATTERN rule for {column}")
+        elif choice in ["5", "custom"]:
+            column = input("Enter column name: ").strip()
+            query = input("Enter SQL query: ").strip()
+            if column and query:
+                configurator.add_custom_rule(column, query)
+                print(f"✓ Added CUSTOM rule for {column}")
+        elif choice in ["6", "list"]:
+            list_rules(configurator)
+        elif choice in ["7", "remove"]:
+            list_rules(configurator)
+            try:
+                idx = int(input("Enter rule number to remove: ")) - 1
+                if configurator.remove_rule(idx):
+                    print(f"✓ Removed rule {idx + 1}")
+                else:
+                    print("Error: Invalid rule number")
+            except ValueError:
+                print("Error: Invalid input")
+        else:
+            print("Invalid choice. Please try again.")
+
+    # Summary and save
+    print("\n" + "="*60)
+    print("Configuration Summary")
+    print("="*60)
+    print(f"Table: {configurator.table_name}")
+    print(f"Database: {configurator.database or '(none specified)'}")
+    print(f"Total Rules: {len(configurator.rules)}\n")
+
+    list_rules(configurator)
+
+    # Save configuration
+    save_choice = input("\nSave configuration? (y/n): ").strip().lower()
+    if save_choice in ["y", "yes"]:
+        filepath = input("Enter filename to save (default: validation_rules.json): ").strip()
+        if not filepath:
+            filepath = "validation_rules.json"
+
+        if configurator.save_config(filepath):
+            print(f"✓ Configuration saved to {filepath}")
+        else:
+            print("Error: Failed to save configuration")
+            sys.exit(1)
+
+
+def list_rules(configurator: ValidationRuleConfigurator):
+    """
+    Display configured rules.
+
+    Args:
+        configurator: ValidationRuleConfigurator instance
+    """
+    if not configurator.rules:
+        print("No rules configured yet.")
+        return
+
+    print("\nConfigured Rules:")
+    print("-" * 60)
+    for i, rule in enumerate(configurator.rules, 1):
+        rule_type = rule.get("rule", "unknown").upper()
+        column = rule.get("column", "N/A")
+        description = rule.get("description", "")
+
+        print(f"{i}. [{rule_type}] {column}")
+        print(f"   {description}")
+
+        # Show additional details based on rule type
+        if rule.get("rule") == "range":
+            print(f"   Range: [{rule.get('min')}, {rule.get('max')}]")
+        elif rule.get("rule") == "pattern":
+            print(f"   Pattern: {rule.get('pattern')}")
+        elif rule.get("rule") == "custom":
+            print(f"   Query: {rule.get('query')}")
+
+    print("-" * 60)
+
+
+def print_help():
+    """Print help information."""
+    help_text = r"""
+Rule Types:
+
+NOT NULL
+  Description: Ensures column contains no NULL values
+  Example: Validate that 'user_id' is never NULL
+
+UNIQUE
+  Description: Ensures all values in column are unique
+  Example: Email addresses must be unique for user table
+
+RANGE
+  Description: Ensures numeric values fall within min/max bounds
+  Example: Age must be between 0 and 150
+           Price must be between 0 and 999999
+
+PATTERN
+  Description: Ensures values match a regular expression
+  Example: Email format: ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
+           Phone: ^\+?1?\d{9,15}$
+
+CUSTOM
+  Description: Run custom SQL query for complex validations
+  Example: SELECT COUNT(*) FROM users WHERE created_at > updated_at
+           (Ensures created_at is always before updated_at)
+"""
+    print(help_text)
+
+
+def create_from_args(args: argparse.Namespace) -> ValidationRuleConfigurator:
+    """
+    Create configurator from command-line arguments.
+
+    Args:
+        args: Parsed arguments
+
+    Returns:
+        Configured ValidationRuleConfigurator
+    """
+    configurator = ValidationRuleConfigurator()
+    configurator.table_name = args.table
+    configurator.database = args.database
+
+    # Add rules from arguments
+    if args.not_null:
+        for column in args.not_null.split(","):
+            configurator.add_not_null_rule(column.strip())
+
+    if args.unique:
+        for column in args.unique.split(","):
+            configurator.add_unique_rule(column.strip())
+
+    if args.range:
+        # Format: "column:min:max" or "column:min:max,column2:min2:max2"
+        for range_spec in args.range.split(","):
+            parts = range_spec.split(":")
+            if len(parts) == 3:
+                try:
+                    column = parts[0].strip()
+                    min_val = float(parts[1].strip())
+                    max_val = float(parts[2].strip())
+                    configurator.add_range_rule(column, min_val, max_val)
+                except ValueError:
+                    print(f"Warning: Invalid range specification: {range_spec}")
+
+    return configurator
+
+
+def main():
+    """Main entry point for rule configuration."""
+    parser = argparse.ArgumentParser(
+        description="Configure data validation rules for database tables",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Interactive mode (recommended)
+  %(prog)s
+
+  # Command-line mode with single table
+  %(prog)s --table users --database mydb \\
+    --not-null id,email \\
+    --unique email \\
+    --output rules.json
+
+  # With range validation
+  %(prog)s --table products --database catalog \\
+    --range "price:0:10000,quantity:0:1000000" \\
+    --output rules.json
+
+  # Load and modify existing rules
+  %(prog)s --load rules.json --not-null phone --output rules.json
+        """
+    )
+
+    parser.add_argument(
+        "--table",
+        help="Table name for non-interactive mode"
+    )
+    parser.add_argument(
+        "--database",
+        help="Database name"
+    )
+    parser.add_argument(
+        "--not-null",
+        help="Comma-separated columns that must not be NULL"
+    )
+    parser.add_argument(
+        "--unique",
+        help="Comma-separated columns that must be unique"
+    )
+    parser.add_argument(
+        "--range",
+        help="Range validations in format: col:min:max,col2:min2:max2"
+    )
+    parser.add_argument(
+        "--load",
+        help="Load existing configuration file"
+    )
+    parser.add_argument(
+        "--output",
+        help="Output file for configuration (JSON)"
+    )
+
+    args = parser.parse_args()
+
+    try:
+        # Determine mode
+        if args.load:
+            # Load existing config
+            configurator = ValidationRuleConfigurator()
+            if not configurator.load_config(args.load):
+                sys.exit(1)
+            print(f"Loaded configuration from {args.load}")
+            list_rules(configurator)
+        elif args.table:
+            # Command-line mode
+            configurator = create_from_args(args)
+        else:
+            # Interactive mode
+            configurator = ValidationRuleConfigurator()
+            interactive_mode(configurator)
+            sys.exit(0)
+
+        # If table specified, save configuration
+        if args.table or args.load:
+            if args.table and not configurator.table_name:
+                configurator.table_name = args.table
+
+            output_file = args.output or "validation_rules.json"
+
+            if configurator.save_config(output_file):
+                print(f"\n✓ Configuration saved to {output_file}")
+                print(f"Total rules: {len(configurator.rules)}")
+                sys.exit(0)
+            else:
+                sys.exit(1)
+
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/skills/validating-database-integrity/scripts/generate_validation_report.py

@@ -0,0 +1,385 @@
+#!/usr/bin/env python3
+"""
+Generate comprehensive report of data validation results.
+
+This script creates detailed HTML, JSON, or Markdown reports from validation results,
+including statistics, identified issues, trend analysis, and recommendations.
+"""
+
+import argparse
+import json
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Any, Optional
+
+
+class ValidationReportGenerator:
+    """Generates comprehensive validation reports."""
+
+    def __init__(self):
+        """Initialize report generator."""
+        self.results = []
+        self.metadata = {}
+
+    def load_results(self, filepath: str) -> bool:
+        """
+        Load validation results from JSON file.
+
+        Args:
+            filepath: Path to JSON results file
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            with open(filepath, 'r') as f:
+                data = json.load(f)
+
+            self.results = data.get("validations", [])
+            self.metadata = {
+                "table": data.get("table", "unknown"),
+                "timestamp": data.get("timestamp", datetime.now().isoformat()),
+                "statistics": data.get("statistics", {})
+            }
+
+            return True
+        except (FileNotFoundError, json.JSONDecodeError) as e:
+            print(f"Error loading results: {e}", file=sys.stderr)
+            return False
+
+    def generate_summary(self) -> Dict[str, Any]:
+        """
+        Generate summary statistics from results.
+
+        Returns:
+            Dictionary with summary stats
+        """
+        if not self.results:
+            return {
+                "total": 0,
+                "passed": 0,
+                "failed": 0,
+                "pass_rate": 0.0,
+                "issues": []
+            }
+
+        total = len(self.results)
+        passed = sum(1 for r in self.results if r.get("valid", False))
+        failed = total - passed
+
+        issues = []
+        for result in self.results:
+            if not result.get("valid", False):
+                details = result.get("details", {})
+                issues.append({
+                    "rule": details.get("rule", "unknown"),
+                    "column": details.get("column", "unknown"),
+                    "severity": self._determine_severity(details.get("rule"))
+                })
+
+        return {
+            "total": total,
+            "passed": passed,
+            "failed": failed,
+            "pass_rate": (passed / total * 100) if total > 0 else 0,
+            "issues": issues,
+            "critical_issues": sum(1 for i in issues if i["severity"] == "critical"),
+            "high_issues": sum(1 for i in issues if i["severity"] == "high"),
+            "medium_issues": sum(1 for i in issues if i["severity"] == "medium")
+        }
+
+    def _determine_severity(self, rule: str) -> str:
+        """
+        Determine issue severity based on rule type.
+
+        Args:
+            rule: Validation rule name
+
+        Returns:
+            Severity level (critical, high, medium, low)
+        """
+        critical_rules = ["not_null", "unique", "foreign_key"]
+        high_rules = ["range", "pattern"]
+        medium_rules = ["custom"]
+
+        if rule in critical_rules:
+            return "critical"
+        elif rule in high_rules:
+            return "high"
+        elif rule in medium_rules:
+            return "medium"
+        else:
+            return "low"
+
+    def generate_json_report(self) -> str:
+        """Generate JSON report."""
+        summary = self.generate_summary()
+
+        report = {
+            "metadata": self.metadata,
+            "summary": summary,
+            "timestamp": datetime.now().isoformat(),
+            "validations": self.results
+        }
+
+        return json.dumps(report, indent=2)
+
+    def generate_markdown_report(self) -> str:
+        """Generate Markdown report."""
+        summary = self.generate_summary()
+
+        md = []
+        md.append(f"# Data Validation Report")
+        md.append(f"\n**Table:** {self.metadata.get('table', 'Unknown')}")
+        md.append(f"**Generated:** {datetime.now().isoformat()}")
+        md.append("")
+
+        # Summary section
+        md.append("## Executive Summary\n")
+        md.append(f"| Metric | Value |")
+        md.append(f"|--------|-------|")
+        md.append(f"| Total Checks | {summary['total']} |")
+        md.append(f"| Passed | {summary['passed']} |")
+        md.append(f"| Failed | {summary['failed']} |")
+        md.append(f"| Pass Rate | {summary['pass_rate']:.1f}% |")
+        md.append("")
+
+        # Table statistics
+        stats = self.metadata.get("statistics", {})
+        if stats and "error" not in stats:
+            md.append("## Table Statistics\n")
+            md.append(f"- **Total Rows:** {stats.get('row_count', 'N/A')}")
+            md.append(f"- **Total Columns:** {stats.get('column_count', 'N/A')}")
+            md.append("")
+
+        # Issues section
+        if summary['failed'] > 0:
+            md.append("## Issues Identified\n")
+
+            if summary['critical_issues'] > 0:
+                md.append("### Critical Issues\n")
+                for issue in summary['issues']:
+                    if issue['severity'] == 'critical':
+                        md.append(f"- **{issue['rule']}** on column `{issue['column']}`")
+                md.append("")
+
+            if summary['high_issues'] > 0:
+                md.append("### High Priority Issues\n")
+                for issue in summary['issues']:
+                    if issue['severity'] == 'high':
+                        md.append(f"- **{issue['rule']}** on column `{issue['column']}`")
+                md.append("")
+
+            if summary['medium_issues'] > 0:
+                md.append("### Medium Priority Issues\n")
+                for issue in summary['issues']:
+                    if issue['severity'] == 'medium':
+                        md.append(f"- **{issue['rule']}** on column `{issue['column']}`")
+                md.append("")
+
+        # Detailed results
+        if summary['failed'] > 0:
+            md.append("## Detailed Validation Results\n")
+            for result in self.results:
+                if not result.get("valid", False):
+                    details = result.get("details", {})
+                    rule = details.get("rule", "unknown")
+                    column = details.get("column", "N/A")
+
+                    md.append(f"### {rule.replace('_', ' ').title()} - {column}\n")
+
+                    if "error" in details:
+                        md.append(f"**Error:** {details['error']}\n")
+                    elif rule == "not_null":
+                        md.append(f"**Issue:** Found {details.get('null_count', 0)} NULL values\n")
+                    elif rule == "unique":
+                        md.append(f"**Issue:** Found {details.get('duplicate_count', 0)} "
+                                f"duplicate groups\n")
+                    elif rule == "range":
+                        md.append(f"**Issue:** {details.get('out_of_range_count', 0)} values "
+                                f"outside range [{details.get('min')}, {details.get('max')}]\n")
+
+        # Recommendations
+        md.append("## Recommendations\n")
+        if summary['critical_issues'] > 0:
+            md.append("1. **Immediately address critical issues** - These indicate data integrity problems")
+        if summary['high_issues'] > 0:
+            md.append("2. **Resolve high priority issues within 1 week** - These affect data quality")
+        if summary['failed'] == 0:
+            md.append("✅ **All validations passed!** - Data integrity is maintained")
+        else:
+            md.append("3. **Review validation rules** - Ensure they match business requirements")
+            md.append("4. **Implement data quality monitoring** - Set up alerts for recurring issues")
+
+        md.append("")
+        md.append("---")
+        md.append("*Report generated by Data Validation Engine*")
+
+        return "\n".join(md)
+
+    def generate_html_report(self) -> str:
+        """Generate HTML report."""
+        summary = self.generate_summary()
+        stats = self.metadata.get("statistics", {})
+
+        html = [
+            "<!DOCTYPE html>",
+            "<html>",
+            "<head>",
+            "<meta charset='UTF-8'>",
+            "<meta name='viewport' content='width=device-width, initial-scale=1.0'>",
+            "<title>Data Validation Report</title>",
+            "<style>",
+            "body { font-family: Arial, sans-serif; margin: 20px; background-color: #f5f5f5; }",
+            ".container { max-width: 1000px; margin: 0 auto; background-color: white; padding: 20px; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }",
+            "h1 { color: #333; border-bottom: 3px solid #007bff; padding-bottom: 10px; }",
+            "h2 { color: #555; margin-top: 30px; }",
+            "table { width: 100%; border-collapse: collapse; margin: 15px 0; }",
+            "th, td { padding: 12px; text-align: left; border-bottom: 1px solid #ddd; }",
+            "th { background-color: #007bff; color: white; }",
+            "tr:hover { background-color: #f9f9f9; }",
+            ".summary { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 20px; margin: 20px 0; }",
+            ".metric { background-color: #f0f0f0; padding: 15px; border-radius: 5px; }",
+            ".metric .value { font-size: 24px; font-weight: bold; color: #007bff; }",
+            ".metric .label { color: #666; margin-top: 5px; }",
+            ".critical { color: #dc3545; font-weight: bold; }",
+            ".high { color: #ff6b6b; font-weight: bold; }",
+            ".medium { color: #ffc107; font-weight: bold; }",
+            ".success { color: #28a745; font-weight: bold; }",
+            ".issue-list { margin: 15px 0; }",
+            ".issue { background-color: #fff3cd; padding: 10px; margin: 5px 0; border-left: 4px solid #ffc107; border-radius: 3px; }",
+            ".footer { text-align: center; color: #999; margin-top: 30px; padding-top: 15px; border-top: 1px solid #ddd; }",
+            "</style>",
+            "</head>",
+            "<body>",
+            "<div class='container'>",
+            f"<h1>Data Validation Report</h1>",
+            f"<p><strong>Table:</strong> {self.metadata.get('table', 'Unknown')}</p>",
+            f"<p><strong>Generated:</strong> {datetime.now().isoformat()}</p>"
+        ]
+
+        # Summary metrics
+        html.append("<h2>Summary</h2>")
+        html.append("<div class='summary'>")
+        html.append(f"<div class='metric'><div class='value'>{summary['total']}</div><div class='label'>Total Checks</div></div>")
+        html.append(f"<div class='metric'><div class='value success'>{summary['passed']}</div><div class='label'>Passed</div></div>")
+        html.append(f"<div class='metric'><div class='value critical'>{summary['failed']}</div><div class='label'>Failed</div></div>")
+        html.append(f"<div class='metric'><div class='value'>{summary['pass_rate']:.1f}%</div><div class='label'>Pass Rate</div></div>")
+        html.append("</div>")
+
+        # Table statistics
+        if stats and "error" not in stats:
+            html.append("<h2>Table Statistics</h2>")
+            html.append("<table>")
+            html.append("<tr><th>Metric</th><th>Value</th></tr>")
+            html.append(f"<tr><td>Total Rows</td><td>{stats.get('row_count', 'N/A')}</td></tr>")
+            html.append(f"<tr><td>Total Columns</td><td>{stats.get('column_count', 'N/A')}</td></tr>")
+            html.append("</table>")
+
+        # Issues
+        if summary['failed'] > 0:
+            html.append("<h2>Issues</h2>")
+            html.append("<div class='issue-list'>")
+
+            for issue in summary['issues']:
+                severity_class = issue['severity']
+                html.append(
+                    f"<div class='issue'>"
+                    f"<span class='{severity_class}'>{issue['severity'].upper()}</span>: "
+                    f"<strong>{issue['rule']}</strong> on column <code>{issue['column']}</code>"
+                    f"</div>"
+                )
+
+            html.append("</div>")
+        else:
+            html.append("<h2>Results</h2>")
+            html.append("<p class='success'>✅ All validations passed!</p>")
+
+        # Footer
+        html.append("<div class='footer'>")
+        html.append("<p>Report generated by Data Validation Engine</p>")
+        html.append("</div>")
+
+        html.append("</div>")
+        html.append("</body>")
+        html.append("</html>")
+
+        return "\n".join(html)
+
+
+def main():
+    """Main entry point for report generation."""
+    parser = argparse.ArgumentParser(
+        description="Generate comprehensive data validation reports",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s --results validation.json
+  %(prog)s --results validation.json --format markdown
+  %(prog)s --results validation.json --format html --output report.html
+  %(prog)s --results validation.json --format json --output report.json
+        """
+    )
+
+    parser.add_argument(
+        "--results",
+        required=True,
+        help="Path to JSON file containing validation results"
+    )
+    parser.add_argument(
+        "--format",
+        default="markdown",
+        choices=["json", "markdown", "html"],
+        help="Report format"
+    )
+    parser.add_argument(
+        "--output",
+        help="Output file for report"
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Print detailed output"
+    )
+
+    args = parser.parse_args()
+
+    try:
+        generator = ValidationReportGenerator()
+
+        # Load results
+        if args.verbose:
+            print(f"Loading results from {args.results}...", file=sys.stderr)
+
+        if not generator.load_results(args.results):
+            sys.exit(1)
+
+        # Generate report
+        if args.format == "json":
+            report = generator.generate_json_report()
+        elif args.format == "html":
+            report = generator.generate_html_report()
+        else:  # markdown
+            report = generator.generate_markdown_report()
+
+        # Print report
+        print(report)
+
+        # Save to file if requested
+        if args.output:
+            with open(args.output, 'w') as f:
+                f.write(report)
+
+            if args.verbose:
+                print(f"\nReport saved to {args.output}", file=sys.stderr)
+
+        sys.exit(0)
+
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()