UrlCategorise 0.1.3 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dcb05d79b6bc09b5b338183d412cd309d9634a342c95b14ea25df5926d8609fb
-  data.tar.gz: effa4c7a010ee574fe6a41653af553a68710ceca46ebdb9dd5352096af5fa7e1
+  metadata.gz: c1271c16022cb3fb5e9efe9af22deca404204ee54e1b23243c4ebd862565c76b
+  data.tar.gz: '082814ad46484b87027e0a1d0042f3f37ab20a3d491f4a8e39a585e14fb40ac8'
 SHA512:
-  metadata.gz: a527c801cbf6318305d640925dd75922c2ac1bcc76a5de75c75e3ad24698305c3d7d885d7da8dd280e61ceb1fe91a57eac185c5c209e11685f2ddb6833b120b9
-  data.tar.gz: de81765d20a0b36c54b71b935928777140f86f6e0a130c71ec7804ed28c1b3d8f12ca30fff5cf8c93952aaed7a9c279fe35a0d32bc83a851aad2556b55fd7942
+  metadata.gz: 8f74b667ba1d993237e224d3db7fcb0323816716961280e5fd27fbf162ecb162f83fd126af89ce812e98fbf8fe48a15c47697b656e345d23465a23ab9913581e
+  data.tar.gz: 57ed94a3e9a9be6db60c3d48dd9d4ac4da52836951b06a9e6937c44968e5509cda43193491c9ec20039649e01d5bb4a6214f769aab2d6c27c8d047d7b9bd5273

data/.claude/settings.local.json

@@ -7,10 +7,15 @@
       "Bash(bundle exec ruby:*)",
       "Bash(find:*)",
       "Bash(grep:*)",
-      "Read(//Users/trex22/development/rubygems/kaggle/**)",
       "Bash(for file in test/url_categorise/*dataset*test.rb)",
       "Bash(do echo \"Checking $file...\")",
-      "Bash(done)"
+      "Bash(done)",
+      "Bash(bundle exec rubocop:*)",
+      "Bash(rubocop:*)",
+      "Bash(timeout 30 ruby dataset_loading_example.rb)",
+      "Bash(timeout:*)",
+      "Bash(DEBUG=1 timeout 300 ruby correct_usage_example.rb)",
+      "Bash(chmod:*)"
     ],
     "deny": []
   }

data/.gitignore

@@ -54,3 +54,4 @@ build-iPhoneSimulator/
 
 # Used by RuboCop. Remote config files pulled in from inherit_from directive.
 # .rubocop-https?--*
+url_cache/*

data/CLAUDE.md

@@ -84,14 +84,89 @@ The gem includes automatic monitoring and cleanup of broken URLs:
 - **Data Hashing**: SHA256 content hashing for dataset change detection
 - **Category Mapping**: Flexible column detection and category mapping for datasets
 - **Credential Warnings**: Helpful warnings when Kaggle credentials are missing but functionality continues
+- **IAB Compliance**: Full support for IAB Content Taxonomy v2.0 and v3.0 standards
+- **Dataset-Specific Metrics**: Separate counting methods for dataset vs DNS list categorization
+- **Enhanced Statistics**: Extended helper methods for comprehensive data insights
+- **ActiveAttr Settings**: In-memory modification of client settings using attribute setters
+- **Data Export**: Multiple export formats including hosts files per category and CSV data exports
+- **CLI Commands**: Command-line utilities for data export and list checking
 
 ### Architecture
-- `Client` class: Main interface for categorization
+- `Client` class: Main interface for categorization with IAB compliance support and ActiveAttr attributes
 - `DatasetProcessor` class: Handles Kaggle and CSV dataset processing
+- `IabCompliance` module: Maps categories to IAB Content Taxonomy v2.0/v3.0 standards
 - `Constants` module: Contains default list URLs and categories
 - `ActiveRecordClient` class: Database-backed client with dataset history
 - Modular design allows extending with new list sources and datasets
-- Support for custom list directories, caching, and dataset integration
+- Support for custom list directories, caching, dataset integration, IAB compliance, and data export
+- ActiveAttr integration for dynamic setting modification and attribute validation
+
+### New Features (Latest Version)
+
+#### Dynamic Settings with ActiveAttr
+The Client class now uses ActiveAttr to provide dynamic attribute modification:
+
+```ruby
+client = UrlCategorise::Client.new
+
+# Modify settings in-memory
+client.smart_categorization_enabled = true
+client.iab_compliance_enabled = true
+client.iab_version = :v2
+client.request_timeout = 30
+client.dns_servers = ['8.8.8.8', '8.8.4.4']
+
+# Settings take effect immediately
+categories = client.categorise('reddit.com') # Uses new smart categorization rules
+```
+
+#### Data Export Features
+
+##### Hosts File Export
+Export all categorized domains as separate hosts files per category:
+
+```ruby
+# Export to default location (cache_dir/exports/hosts or ./exports/hosts)
+result = client.export_hosts_files
+
+# Export to custom location
+result = client.export_hosts_files('/custom/export/path')
+
+# Returns hash with file information:
+# {
+#   malware: { path: '/path/malware.hosts', filename: 'malware.hosts', count: 1500 },
+#   advertising: { path: '/path/advertising.hosts', filename: 'advertising.hosts', count: 25000 },
+#   _summary: { total_categories: 15, total_domains: 50000, export_directory: '/path' }
+# }
+```
+
+##### CSV Data Export
+Export all data as a single CSV file for AI training and analysis:
+
+```ruby
+# Export to default location (cache_dir/exports/csv or ./exports/csv)
+result = client.export_csv_data
+
+# Export to custom location  
+result = client.export_csv_data('/custom/export/path')
+
+# CSV includes: domain, category, source_type, is_dataset_category, iab_category_v2, iab_category_v3, export_timestamp
+# Metadata file includes: export info, client settings, data summary, dataset metadata
+```
+
+#### CLI Commands
+New command-line utilities for data export:
+
+```bash
+# Export hosts files
+$ bundle exec export_hosts --output /tmp/hosts --verbose
+
+# Export CSV data with IAB compliance
+$ bundle exec export_csv --output /tmp/csv --iab-compliance --verbose
+
+# Check URL health (existing)
+$ bundle exec check_lists
+```
 
 ### List Sources
 Primary sources include:

data/Gemfile.lock

@@ -1,13 +1,15 @@
 PATH
   remote: .
   specs:
-    UrlCategorise (0.1.3)
+    UrlCategorise (0.1.6)
+      active_attr (>= 0.17.1, < 1.0)
       api_pattern (>= 0.0.6, < 1.0)
       csv (>= 3.3.0, < 4.0)
       digest (>= 3.1.0, < 4.0)
       fileutils (>= 1.7.0, < 2.0)
       httparty (>= 0.22.0, < 1.0)
       json (>= 2.7.0, < 3.0)
+      kaggle (>= 0.0.3, < 1.0)
       nokogiri (>= 1.18.9, < 2.0)
       resolv (>= 0.4.0, < 1.0)
       rubyzip (>= 2.3.0, < 3.0)
@@ -87,6 +89,12 @@ GEM
     i18n (1.14.7)
       concurrent-ruby (~> 1.0)
     json (2.13.2)
+    kaggle (0.0.3)
+      csv (>= 3.3)
+      fileutils (>= 1.7)
+      httparty (>= 0.23)
+      oj (= 3.16.11)
+      rubyzip (>= 2.0)
     logger (1.7.0)
     loofah (2.24.1)
       crass (~> 1.0.2)
@@ -107,6 +115,10 @@ GEM
       bigdecimal (~> 3.1)
     nokogiri (1.18.9-arm64-darwin)
       racc (~> 1.4)
+    oj (3.16.11)
+      bigdecimal (>= 3.0)
+      ostruct (>= 0.2)
+    ostruct (0.6.3)
     pry (0.15.2)
       coderay (~> 1.1)
       method_source (~> 1.0)

data/README.md

@@ -5,6 +5,8 @@ A comprehensive Ruby gem for categorizing URLs and domains based on various secu
 ## Features
 
 - **Comprehensive Coverage**: 60+ high-quality categories including security, content, and specialized lists
+- **Kaggle Dataset Integration**: Automatic loading and processing of machine learning datasets from Kaggle
+- **Multiple Data Sources**: Supports blocklists, CSV datasets, and Kaggle ML datasets  
 - **Multiple List Formats**: Supports hosts files, pfSense, AdSense, uBlock Origin, dnsmasq, and plain text formats
 - **Intelligent Caching**: Hash-based file update detection with configurable local cache
 - **DNS Resolution**: Resolve domains to IPs and check against IP-based blocklists  
@@ -14,6 +16,10 @@ A comprehensive Ruby gem for categorizing URLs and domains based on various secu
 - **Metadata Tracking**: Track last update times, ETags, and content hashes
 - **Health Monitoring**: Automatic detection and removal of broken blocklist sources
 - **List Validation**: Built-in tools to verify all configured URLs are accessible
+- **Auto-Loading Datasets**: Automatic processing of predefined datasets during client initialization
+- **ActiveAttr Settings**: In-memory modification of client settings using attribute setters
+- **Data Export**: Export categorized data as hosts files per category or comprehensive CSV exports
+- **CLI Commands**: Command-line utilities for data export and list checking
 
 ## Installation
 
@@ -44,6 +50,15 @@ puts "Total hosts: #{client.count_of_hosts}"
 puts "Categories: #{client.count_of_categories}"  
 puts "Data size: #{client.size_of_data} MB"
 
+# Get detailed size breakdown
+puts "Total data size: #{client.size_of_data} MB (#{client.size_of_data_bytes} bytes)"
+puts "Blocklist data size: #{client.size_of_blocklist_data} MB (#{client.size_of_blocklist_data_bytes} bytes)"
+puts "Dataset data size: #{client.size_of_dataset_data} MB (#{client.size_of_dataset_data_bytes} bytes)"
+
+# Get dataset-specific statistics (if datasets are loaded)
+puts "Dataset hosts: #{client.count_of_dataset_hosts}"
+puts "Dataset categories: #{client.count_of_dataset_categories}"
+
 # Categorize a URL or domain
 categories = client.categorise("badsite.com")
 puts "Categories: #{categories}" # => [:malware, :phishing]
@@ -57,6 +72,83 @@ ip_categories = client.categorise_ip("192.168.1.100")
 puts "IP categories: #{ip_categories}"
 ```
 
+## New Features
+
+### Dynamic Settings with ActiveAttr
+
+The Client class now supports in-memory modification of settings using ActiveAttr:
+
+```ruby
+client = UrlCategorise::Client.new
+
+# Modify settings dynamically
+client.smart_categorization_enabled = true
+client.iab_compliance_enabled = true
+client.iab_version = :v2
+client.request_timeout = 30
+client.dns_servers = ['8.8.8.8', '8.8.4.4']
+
+# Settings take effect immediately - no need to recreate the client
+categories = client.categorise('reddit.com') # Uses new smart categorization rules
+```
+
+### Data Export Features
+
+#### Hosts File Export
+
+Export all categorized domains as separate hosts files per category:
+
+```ruby
+# Export to default location
+result = client.export_hosts_files
+
+# Export to custom location
+result = client.export_hosts_files('/custom/export/path')
+
+# Result includes file information and summary
+puts "Exported #{result[:_summary][:total_categories]} categories"
+puts "Total domains: #{result[:_summary][:total_domains]}"
+puts "Files saved to: #{result[:_summary][:export_directory]}"
+```
+
+Each category gets its own hosts file (e.g., `malware.hosts`, `advertising.hosts`) with proper headers and sorted domains.
+
+#### CSV Data Export
+
+Export all data as a single CSV file for AI training and analysis:
+
+```ruby
+# Export to default location
+result = client.export_csv_data
+
+# Export to custom location with IAB compliance
+client.iab_compliance_enabled = true
+result = client.export_csv_data('/custom/export/path')
+
+# CSV includes comprehensive data:
+# - domain, category, source_type, is_dataset_category
+# - iab_category_v2, iab_category_v3, export_timestamp
+# - smart_categorization_enabled
+
+# Metadata file includes:
+# - Export info, client settings, data summary, dataset metadata
+```
+
+#### CLI Commands
+
+New command-line utilities for data export:
+
+```bash
+# Export hosts files
+$ bundle exec export_hosts --output /tmp/hosts --verbose
+
+# Export CSV data with IAB compliance
+$ bundle exec export_csv --output /tmp/csv --iab-compliance --verbose
+
+# Check URL health (existing command)
+$ bundle exec check_lists
+```
+
 ## Advanced Configuration
 
 ### File Caching
@@ -113,7 +205,11 @@ client = UrlCategorise::Client.new(
   cache_dir: "./url_cache",                                # Enable local caching
   force_download: false,                                   # Use cache when available
   dns_servers: ['1.1.1.1', '1.0.0.1'],                   # Cloudflare DNS servers
-  request_timeout: 15                                      # 15 second HTTP timeout
+  request_timeout: 15,                                     # 15 second HTTP timeout
+  iab_compliance: true,                                    # Enable IAB compliance
+  iab_version: :v3,                                        # Use IAB Content Taxonomy v3.0
+  auto_load_datasets: false,                               # Disable automatic dataset loading (default)
+  smart_categorization: false                              # Disable smart post-processing (default)
 )
 ```
 
@@ -132,6 +228,165 @@ host_urls = {
 client = UrlCategorise::Client.new(host_urls: host_urls)
 ```
 
+### Smart Categorization (Post-Processing)
+
+Smart categorization solves the problem of overly broad domain-level categorization. For example, `reddit.com` might appear in health & fitness blocklists, but not all Reddit content is health-related.
+
+#### The Problem
+
+```ruby
+# Without smart categorization
+client.categorise("reddit.com")
+# => [:reddit, :social_media, :health_and_fitness, :forums]  # Too broad!
+
+client.categorise("reddit.com/r/technology") 
+# => [:reddit, :social_media, :health_and_fitness, :forums]  # Still wrong!
+```
+
+#### The Solution
+
+```ruby
+# Enable smart categorization
+client = UrlCategorise::Client.new(
+  smart_categorization: true  # Remove overly broad categories
+)
+
+client.categorise("reddit.com")
+# => [:reddit, :social_media]  # Much more accurate!
+```
+
+#### How It Works
+
+Smart categorization automatically removes overly broad categories for known platforms:
+
+- **Social Media Platforms** (Reddit, Facebook, Twitter, etc.): Removes categories like `:health_and_fitness`, `:forums`, `:news`, `:technology`, `:education`
+- **Search Engines** (Google, Bing, etc.): Removes categories like `:news`, `:shopping`, `:travel`
+- **Video Platforms** (YouTube, Vimeo, etc.): Removes categories like `:education`, `:entertainment`, `:music`
+
+#### Custom Smart Rules
+
+You can define custom rules for specific domains or URL patterns:
+
+```ruby
+custom_rules = {
+  reddit_subreddits: {
+    domains: ['reddit.com'],
+    remove_categories: [:health_and_fitness, :forums],
+    add_categories_by_path: {
+      /\/r\/fitness/ => [:health_and_fitness],      # Add back for /r/fitness
+      /\/r\/technology/ => [:technology],           # Add technology for /r/technology 
+      /\/r\/programming/ => [:technology, :programming]
+    }
+  },
+  my_company_domains: {
+    domains: ['mycompany.com'],
+    allowed_categories_only: [:business, :technology]  # Only allow specific categories
+  }
+}
+
+client = UrlCategorise::Client.new(
+  smart_categorization: true,
+  smart_rules: custom_rules
+)
+
+# Now path-based categorization works
+client.categorise('reddit.com')           # => [:reddit, :social_media]
+client.categorise('reddit.com/r/fitness') # => [:reddit, :social_media, :health_and_fitness]
+client.categorise('reddit.com/r/technology') # => [:reddit, :social_media, :technology]
+```
+
+#### Available Rule Types
+
+- **`remove_categories`**: Remove specific categories for domains
+- **`keep_primary_only`**: Keep only specified categories, remove others
+- **`allowed_categories_only`**: Only allow specific categories, block all others
+- **`add_categories_by_path`**: Add categories based on URL path patterns
+
+#### Smart Rules with IAB Compliance
+
+Smart categorization works seamlessly with IAB compliance:
+
+```ruby
+client = UrlCategorise::Client.new(
+  smart_categorization: true,
+  iab_compliance: true,
+  iab_version: :v3
+)
+
+# Returns clean IAB codes after smart processing
+categories = client.categorise("reddit.com")  # => ["14"] (Society - Social Media)
+```
+
+## IAB Content Taxonomy Compliance
+
+UrlCategorise supports IAB (Interactive Advertising Bureau) Content Taxonomy compliance for standardized content categorization:
+
+### Basic IAB Compliance
+
+```ruby
+# Enable IAB v3.0 compliance (default)
+client = UrlCategorise::Client.new(
+  iab_compliance: true,
+  iab_version: :v3
+)
+
+# Enable IAB v2.0 compliance
+client = UrlCategorise::Client.new(
+  iab_compliance: true,
+  iab_version: :v2
+)
+
+# Categorization returns IAB codes instead of custom categories
+categories = client.categorise("badsite.com")
+puts categories # => ["626"] (IAB v3 code for illegal content)
+
+# Check IAB compliance status
+puts client.iab_compliant? # => true
+
+# Get IAB mapping for a specific category
+puts client.get_iab_mapping(:malware) # => "626" (v3) or "IAB25" (v2)
+```
+
+### IAB Category Mappings
+
+The gem maps security and content categories to appropriate IAB codes:
+
+**IAB Content Taxonomy v3.0 (recommended):**
+- `malware`, `phishing`, `illegal` → `626` (Illegal Content)
+- `advertising`, `mobile_ads` → `3` (Advertising)
+- `gambling` → `7-39` (Gambling)
+- `pornography` → `626` (Adult Content)
+- `social_media` → `14` (Society)
+- `technology` → `19` (Technology & Computing)
+
+**IAB Content Taxonomy v2.0:**
+- `malware`, `phishing` → `IAB25` (Non-Standard Content)
+- `advertising` → `IAB3` (Advertising)
+- `gambling` → `IAB7-39` (Gambling)
+- `pornography` → `IAB25-3` (Pornography)
+
+### Integration with Datasets
+
+IAB compliance works seamlessly with dataset processing:
+
+```ruby
+client = UrlCategorise::Client.new(
+  iab_compliance: true,
+  iab_version: :v3,
+  dataset_config: {
+    kaggle: { username: 'user', api_key: 'key' }
+  },
+  auto_load_datasets: true  # Automatically load predefined datasets with IAB mapping
+)
+
+# Load additional datasets - categories will be mapped to IAB codes
+client.load_kaggle_dataset('owner', 'dataset-name')
+client.load_csv_dataset('https://example.com/data.csv')
+
+# All categorization methods return IAB codes
+categories = client.categorise("example.com") # => ["3", "626"]
+```
+
 ## Available Categories
 
 ### Security & Threat Intelligence
@@ -194,9 +449,43 @@ ruby bin/check_lists
 
 ## Dataset Processing
 
-UrlCategorise now supports processing external datasets from Kaggle and CSV files to expand categorization data:
+UrlCategorise supports processing external datasets from Kaggle and CSV files to expand categorization data beyond traditional blocklists. This allows integration of machine learning datasets and custom URL classification data:
+
+### Automatic Dataset Loading
+
+Enable automatic loading of predefined datasets during client initialization:
+
+```ruby
+# Enable automatic dataset loading from constants
+client = UrlCategorise::Client.new(
+  dataset_config: {
+    kaggle: {
+      username: ENV['KAGGLE_USERNAME'], 
+      api_key: ENV['KAGGLE_API_KEY']
+    },
+    cache_path: './dataset_cache',
+    download_path: './downloads'
+  },
+  auto_load_datasets: true  # Automatically loads all predefined datasets
+)
+
+# Datasets are now automatically integrated and ready for use
+categories = client.categorise('https://example.com')
+puts "Dataset categories loaded: #{client.count_of_dataset_categories}"
+puts "Dataset hosts: #{client.count_of_dataset_hosts}"
+```
+
+The gem includes predefined high-quality datasets in constants:
+- **`shaurov/website-classification-using-url`** - Comprehensive URL classification dataset
+- **`hetulmehta/website-classification`** - Website categorization with cleaned text data  
+- **`shawon10/url-classification-dataset-dmoz`** - DMOZ-based URL classification
+- **Data.world CSV dataset** - Additional URL categorization data
+
+### Manual Dataset Loading
+
+You can also load datasets manually for more control over the process:
 
-### Kaggle Dataset Integration
+#### Kaggle Dataset Integration
 
 Load datasets directly from Kaggle using three authentication methods:
 
@@ -244,7 +533,7 @@ client.load_kaggle_dataset('owner', 'dataset-name', {
 categories = client.categorise('https://example.com')
 ```
 
-### CSV Dataset Processing
+#### CSV Dataset Processing
 
 Load datasets from direct CSV URLs:
 
@@ -286,7 +575,10 @@ dataset_config = {
   timeout: 30                       # HTTP timeout for downloads
 }
 
-client = UrlCategorise::Client.new(dataset_config: dataset_config)
+client = UrlCategorise::Client.new(
+  dataset_config: dataset_config,
+  auto_load_datasets: true          # Enable automatic loading of predefined datasets
+)
 ```
 
 ### Disabling Kaggle Functionality
@@ -485,7 +777,18 @@ class UrlCategorizerService
       cache_dir: Rails.root.join('tmp', 'url_cache'),
       use_database: true,
       force_download: Rails.env.development?,
-      request_timeout: Rails.env.production? ? 30 : 10  # Longer timeout in production
+      request_timeout: Rails.env.production? ? 30 : 10,  # Longer timeout in production
+      iab_compliance: Rails.env.production?,              # Enable IAB compliance in production
+      iab_version: :v3,                                   # Use IAB Content Taxonomy v3.0
+      auto_load_datasets: Rails.env.production?,          # Auto-load datasets in production
+      dataset_config: {
+        kaggle: {
+          username: ENV['KAGGLE_USERNAME'],
+          api_key: ENV['KAGGLE_API_KEY']
+        },
+        cache_path: Rails.root.join('tmp', 'dataset_cache'),
+        download_path: Rails.root.join('tmp', 'dataset_downloads')
+      }
     )
   end
 
@@ -508,12 +811,34 @@ class UrlCategorizerService
   end
 
   def stats
-    @client.database_stats
+    base_stats = @client.database_stats
+    base_stats.merge({
+      dataset_hosts: @client.count_of_dataset_hosts,
+      dataset_categories: @client.count_of_dataset_categories,
+      iab_compliant: @client.iab_compliant?,
+      iab_version: @client.iab_version
+    })
   end
 
   def refresh_lists!
     @client.update_database
   end
+
+  def load_dataset(type, identifier, options = {})
+    case type.to_s
+    when 'kaggle'
+      owner, dataset = identifier.split('/')
+      @client.load_kaggle_dataset(owner, dataset, options)
+    when 'csv'
+      @client.load_csv_dataset(identifier, options)
+    else
+      raise ArgumentError, "Unsupported dataset type: #{type}"
+    end
+  end
+
+  def get_iab_mapping(category)
+    @client.get_iab_mapping(category)
+  end
 end
 ```
 

data/bin/export_csv

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'optparse'
+require_relative '../lib/url_categorise'
+
+options = {
+  output_path: nil,
+  cache_dir: nil,
+  verbose: false,
+  iab_compliance: false,
+  smart_categorization: false
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{$0} [options]"
+  opts.separator ""
+  opts.separator "Export all categorized domains and metadata as a single CSV file for AI training"
+  opts.separator ""
+  
+  opts.on("-o", "--output PATH", "Output directory path (default: cache_dir/exports/csv or ./exports/csv)") do |path|
+    options[:output_path] = path
+  end
+  
+  opts.on("-c", "--cache-dir PATH", "Cache directory path for client initialization") do |path|
+    options[:cache_dir] = path
+  end
+  
+  opts.on("--iab-compliance", "Enable IAB compliance for category mapping") do
+    options[:iab_compliance] = true
+  end
+  
+  opts.on("--smart-categorization", "Enable smart categorization") do
+    options[:smart_categorization] = true
+  end
+  
+  opts.on("-v", "--verbose", "Verbose output") do
+    options[:verbose] = true
+  end
+  
+  opts.on("-h", "--help", "Show this help message") do
+    puts opts
+    exit
+  end
+end.parse!
+
+puts "=== UrlCategorise CSV Data Export ===" if options[:verbose]
+puts "Initializing client..." if options[:verbose]
+
+begin
+  client = UrlCategorise::Client.new(
+    cache_dir: options[:cache_dir],
+    iab_compliance: options[:iab_compliance],
+    smart_categorization: options[:smart_categorization]
+  )
+  
+  puts "Exporting CSV data..." if options[:verbose]
+  
+  result = client.export_csv_data(options[:output_path])
+  
+  puts "\n✅ Export completed successfully!"
+  puts "📁 Export directory: #{result[:export_directory]}"
+  puts "📄 CSV file: #{result[:csv_file]}"
+  puts "📄 Metadata file: #{result[:metadata_file]}"
+  
+  puts "\n📊 Data Summary:"
+  puts "  Total domains: #{result[:summary][:total_domains]}"
+  puts "  Total categories: #{result[:summary][:total_categories]}"
+  puts "  Dataset categories: #{result[:summary][:dataset_categories_count]}"
+  puts "  Blocklist categories: #{result[:summary][:blocklist_categories_count]}"
+  
+  if options[:verbose]
+    puts "\n🏷️  Categories included:"
+    result[:summary][:categories].each do |category|
+      puts "    - #{category}"
+    end
+  end
+  
+rescue StandardError => e
+  puts "❌ Error: #{e.message}"
+  puts e.backtrace if options[:verbose]
+  exit 1
+end