Csv Data Visualizer

export default async function csv_data_visualizer(input) {
  console.log("🧠 Running skill: csv-data-visualizer");
  
  // TODO: implement actual logic for this skill
  return {
    message: "Skill 'csv-data-visualizer' executed successfully!",
    input
  };
}

{
  "name": "@ai-labs-claude-skills/csv-data-visualizer",
  "version": "1.0.0",
  "description": "Claude AI skill: csv-data-visualizer",
  "main": "index.js",
  "files": [
    "."
  ],
  "license": "MIT",
  "author": "AI Labs"
}

#!/usr/bin/env python3
"""
CSV Dashboard Creator - Multi-plot dashboard generator
Creates comprehensive interactive dashboards with multiple visualizations
"""

import pandas as pd
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import argparse
import sys
from pathlib import Path
import json


class DashboardCreator:
    """Create multi-plot dashboards from CSV data"""

    def __init__(self, csv_path):
        """Initialize with CSV file path"""
        try:
            self.df = pd.read_csv(csv_path)
            self.csv_path = Path(csv_path)
            print(f"✓ Loaded CSV: {csv_path}")
            print(f"  Rows: {len(self.df)}, Columns: {len(self.df.columns)}")
        except Exception as e:
            print(f"✗ Error loading CSV: {e}", file=sys.stderr)
            sys.exit(1)

    def create_auto_dashboard(self, output=None, max_plots=6):
        """Automatically create dashboard based on data types"""
        print("🔍 Analyzing data to create automatic dashboard...")

        numeric_cols = self.df.select_dtypes(include=['number']).columns.tolist()
        categorical_cols = self.df.select_dtypes(include=['object']).columns.tolist()

        plots = []

        # Add distribution plots for numeric columns (up to 2)
        for col in numeric_cols[:2]:
            plots.append(('histogram', col, None))

        # Add box plots for numeric columns grouped by first categorical (up to 2)
        if len(categorical_cols) > 0 and len(numeric_cols) > 0:
            for col in numeric_cols[:2]:
                plots.append(('box', col, categorical_cols[0]))

        # Add correlation heatmap if multiple numeric columns
        if len(numeric_cols) >= 2:
            plots.append(('correlation', None, None))

        # Add categorical distribution (up to 1)
        for col in categorical_cols[:1]:
            plots.append(('bar', col, None))

        # Limit to max_plots
        plots = plots[:max_plots]

        print(f"📊 Creating dashboard with {len(plots)} plots...")
        return self._create_dashboard(plots, output, title="Automatic Dashboard")

    def create_custom_dashboard(self, config_path, output=None):
        """Create dashboard from JSON configuration"""
        try:
            with open(config_path, 'r') as f:
                config = json.load(f)
        except Exception as e:
            print(f"✗ Error loading config: {e}", file=sys.stderr)
            sys.exit(1)

        plots = []
        for plot_config in config.get('plots', []):
            plot_type = plot_config.get('type')
            column = plot_config.get('column')
            group_by = plot_config.get('group_by')
            plots.append((plot_type, column, group_by))

        title = config.get('title', 'Custom Dashboard')
        return self._create_dashboard(plots, output, title=title)

    def _create_dashboard(self, plots, output, title="Dashboard"):
        """Create dashboard with specified plots"""
        n_plots = len(plots)

        # Determine grid layout
        if n_plots <= 2:
            rows, cols = 1, n_plots
        elif n_plots <= 4:
            rows, cols = 2, 2
        elif n_plots <= 6:
            rows, cols = 2, 3
        else:
            rows, cols = 3, 3

        # Create subplots
        fig = make_subplots(
            rows=rows,
            cols=cols,
            subplot_titles=[self._get_plot_title(p) for p in plots],
            vertical_spacing=0.12,
            horizontal_spacing=0.10
        )

        # Add each plot
        for idx, (plot_type, column, group_by) in enumerate(plots):
            row = idx // cols + 1
            col = idx % cols + 1

            try:
                self._add_plot_to_dashboard(fig, plot_type, column, group_by, row, col)
            except Exception as e:
                print(f"⚠ Warning: Could not create {plot_type} plot for {column}: {e}")

        # Update layout
        fig.update_layout(
            title_text=title,
            title_font_size=24,
            showlegend=True,
            height=400 * rows,
            width=1400
        )

        # Save dashboard
        if output is None:
            output = self.csv_path.parent / f"dashboard_{self.csv_path.stem}.html"
        else:
            output = Path(output)

        fig.write_html(str(output))
        print(f"✓ Dashboard saved: {output}")
        return str(output)

    def _get_plot_title(self, plot_info):
        """Generate plot title from plot info"""
        plot_type, column, group_by = plot_info

        if plot_type == 'histogram':
            return f"Distribution of {column}"
        elif plot_type == 'box':
            return f"{column} by {group_by}" if group_by else f"Box Plot: {column}"
        elif plot_type == 'scatter':
            return f"{column} vs {group_by}"
        elif plot_type == 'bar':
            return f"Count of {column}"
        elif plot_type == 'correlation':
            return "Correlation Matrix"
        else:
            return column or plot_type

    def _add_plot_to_dashboard(self, fig, plot_type, column, group_by, row, col):
        """Add a specific plot to the dashboard"""
        if plot_type == 'histogram':
            self._add_histogram(fig, column, row, col)
        elif plot_type == 'box':
            self._add_box_plot(fig, column, group_by, row, col)
        elif plot_type == 'scatter':
            self._add_scatter(fig, column, group_by, row, col)
        elif plot_type == 'bar':
            self._add_bar_chart(fig, column, row, col)
        elif plot_type == 'correlation':
            self._add_correlation_heatmap(fig, row, col)

    def _add_histogram(self, fig, column, row, col):
        """Add histogram to dashboard"""
        fig.add_trace(
            go.Histogram(x=self.df[column], name=column, showlegend=False),
            row=row, col=col
        )

    def _add_box_plot(self, fig, column, group_by, row, col):
        """Add box plot to dashboard"""
        if group_by and group_by in self.df.columns:
            for category in self.df[group_by].unique():
                data = self.df[self.df[group_by] == category][column]
                fig.add_trace(
                    go.Box(y=data, name=str(category)),
                    row=row, col=col
                )
        else:
            fig.add_trace(
                go.Box(y=self.df[column], name=column, showlegend=False),
                row=row, col=col
            )

    def _add_scatter(self, fig, x_col, y_col, row, col):
        """Add scatter plot to dashboard"""
        fig.add_trace(
            go.Scatter(
                x=self.df[x_col],
                y=self.df[y_col],
                mode='markers',
                name=f"{y_col} vs {x_col}",
                showlegend=False
            ),
            row=row, col=col
        )

    def _add_bar_chart(self, fig, column, row, col):
        """Add bar chart to dashboard"""
        value_counts = self.df[column].value_counts().head(10)
        fig.add_trace(
            go.Bar(x=value_counts.index, y=value_counts.values, name=column, showlegend=False),
            row=row, col=col
        )

    def _add_correlation_heatmap(self, fig, row, col):
        """Add correlation heatmap to dashboard"""
        numeric_df = self.df.select_dtypes(include=['number'])
        corr_matrix = numeric_df.corr()

        fig.add_trace(
            go.Heatmap(
                z=corr_matrix.values,
                x=corr_matrix.columns,
                y=corr_matrix.columns,
                colorscale='RdBu_r',
                zmid=0,
                showscale=True
            ),
            row=row, col=col
        )


def main():
    parser = argparse.ArgumentParser(
        description='Create interactive multi-plot dashboards from CSV data',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  # Auto-generate dashboard
  %(prog)s data.csv

  # Auto-generate with custom output
  %(prog)s data.csv -o my_dashboard.html

  # Create from config file
  %(prog)s data.csv --config dashboard_config.json

Dashboard Config JSON format:
{
  "title": "My Custom Dashboard",
  "plots": [
    {"type": "histogram", "column": "age"},
    {"type": "box", "column": "salary", "group_by": "department"},
    {"type": "scatter", "column": "height", "group_by": "weight"},
    {"type": "bar", "column": "category"},
    {"type": "correlation"}
  ]
}
        """
    )

    parser.add_argument('csv_file', help='Path to CSV file')
    parser.add_argument('-o', '--output', help='Output HTML file path')
    parser.add_argument('--config', help='JSON config file for custom dashboard')
    parser.add_argument('--max-plots', type=int, default=6,
                       help='Maximum number of plots in auto dashboard (default: 6)')

    args = parser.parse_args()

    # Create dashboard
    creator = DashboardCreator(args.csv_file)

    if args.config:
        creator.create_custom_dashboard(args.config, output=args.output)
    else:
        creator.create_auto_dashboard(output=args.output, max_plots=args.max_plots)


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
CSV Data Profiler - Automatic data profiling and statistical analysis
Generates comprehensive reports about CSV data quality and statistics
"""

import pandas as pd
import numpy as np
import argparse
import sys
from pathlib import Path
import json
from datetime import datetime


class DataProfiler:
    """Automatic data profiling for CSV files"""

    def __init__(self, csv_path):
        """Initialize with CSV file path"""
        try:
            self.df = pd.read_csv(csv_path)
            self.csv_path = Path(csv_path)
            print(f"✓ Loaded CSV: {csv_path}")
        except Exception as e:
            print(f"✗ Error loading CSV: {e}", file=sys.stderr)
            sys.exit(1)

    def generate_profile(self, output_format='text'):
        """Generate comprehensive data profile"""
        profile = {
            'file_info': self._file_info(),
            'overview': self._overview(),
            'columns': self._column_analysis(),
            'missing_data': self._missing_data_analysis(),
            'numeric_summary': self._numeric_summary(),
            'categorical_summary': self._categorical_summary(),
            'data_quality': self._data_quality_checks()
        }

        if output_format == 'json':
            return json.dumps(profile, indent=2, default=str)
        elif output_format == 'html':
            return self._generate_html_report(profile)
        else:
            return self._generate_text_report(profile)

    def _file_info(self):
        """Basic file information"""
        return {
            'filename': self.csv_path.name,
            'file_size': f"{self.csv_path.stat().st_size / 1024:.2f} KB",
            'rows': len(self.df),
            'columns': len(self.df.columns)
        }

    def _overview(self):
        """Dataset overview"""
        memory_usage = self.df.memory_usage(deep=True).sum() / 1024 / 1024
        return {
            'shape': f"{self.df.shape[0]} rows × {self.df.shape[1]} columns",
            'memory_usage': f"{memory_usage:.2f} MB",
            'duplicate_rows': int(self.df.duplicated().sum()),
            'column_names': list(self.df.columns)
        }

    def _column_analysis(self):
        """Detailed column-by-column analysis"""
        columns_info = {}

        for col in self.df.columns:
            col_data = self.df[col]
            info = {
                'dtype': str(col_data.dtype),
                'non_null_count': int(col_data.notna().sum()),
                'null_count': int(col_data.isna().sum()),
                'null_percentage': f"{(col_data.isna().sum() / len(col_data) * 100):.2f}%",
                'unique_values': int(col_data.nunique()),
                'unique_percentage': f"{(col_data.nunique() / len(col_data) * 100):.2f}%"
            }

            # Add type-specific info
            if pd.api.types.is_numeric_dtype(col_data):
                info['min'] = float(col_data.min()) if not pd.isna(col_data.min()) else None
                info['max'] = float(col_data.max()) if not pd.isna(col_data.max()) else None
                info['mean'] = float(col_data.mean()) if not pd.isna(col_data.mean()) else None
                info['median'] = float(col_data.median()) if not pd.isna(col_data.median()) else None
                info['std'] = float(col_data.std()) if not pd.isna(col_data.std()) else None
            elif pd.api.types.is_object_dtype(col_data):
                # String/categorical analysis
                if col_data.notna().sum() > 0:
                    info['most_common'] = col_data.value_counts().head(5).to_dict()
                    info['avg_length'] = float(col_data.astype(str).str.len().mean())

            columns_info[col] = info

        return columns_info

    def _missing_data_analysis(self):
        """Analyze missing data patterns"""
        missing = self.df.isna().sum()
        missing_pct = (missing / len(self.df)) * 100

        missing_data = {}
        for col in missing[missing > 0].index:
            missing_data[col] = {
                'count': int(missing[col]),
                'percentage': f"{missing_pct[col]:.2f}%"
            }

        return {
            'total_missing_values': int(self.df.isna().sum().sum()),
            'columns_with_missing': missing_data,
            'complete_rows': int(self.df.notna().all(axis=1).sum()),
            'rows_with_any_missing': int(self.df.isna().any(axis=1).sum())
        }

    def _numeric_summary(self):
        """Statistical summary for numeric columns"""
        numeric_cols = self.df.select_dtypes(include=['number']).columns

        if len(numeric_cols) == 0:
            return {}

        summary = {}
        for col in numeric_cols:
            col_data = self.df[col].dropna()
            if len(col_data) > 0:
                summary[col] = {
                    'count': int(len(col_data)),
                    'mean': float(col_data.mean()),
                    'std': float(col_data.std()),
                    'min': float(col_data.min()),
                    '25%': float(col_data.quantile(0.25)),
                    '50%': float(col_data.quantile(0.50)),
                    '75%': float(col_data.quantile(0.75)),
                    'max': float(col_data.max()),
                    'skewness': float(col_data.skew()),
                    'kurtosis': float(col_data.kurtosis())
                }

        return summary

    def _categorical_summary(self):
        """Summary for categorical/text columns"""
        categorical_cols = self.df.select_dtypes(include=['object']).columns

        if len(categorical_cols) == 0:
            return {}

        summary = {}
        for col in categorical_cols:
            col_data = self.df[col].dropna()
            if len(col_data) > 0:
                value_counts = col_data.value_counts()
                summary[col] = {
                    'unique_values': int(col_data.nunique()),
                    'most_frequent': str(value_counts.index[0]) if len(value_counts) > 0 else None,
                    'most_frequent_count': int(value_counts.iloc[0]) if len(value_counts) > 0 else None,
                    'least_frequent': str(value_counts.index[-1]) if len(value_counts) > 0 else None,
                    'least_frequent_count': int(value_counts.iloc[-1]) if len(value_counts) > 0 else None,
                    'top_5_values': value_counts.head(5).to_dict()
                }

        return summary

    def _data_quality_checks(self):
        """Perform data quality checks"""
        issues = []

        # Check for high missing data
        missing_pct = (self.df.isna().sum() / len(self.df)) * 100
        high_missing = missing_pct[missing_pct > 50]
        if len(high_missing) > 0:
            issues.append({
                'type': 'HIGH_MISSING_DATA',
                'severity': 'WARNING',
                'columns': list(high_missing.index),
                'message': f"{len(high_missing)} column(s) have >50% missing data"
            })

        # Check for duplicate rows
        duplicates = self.df.duplicated().sum()
        if duplicates > 0:
            issues.append({
                'type': 'DUPLICATE_ROWS',
                'severity': 'INFO',
                'count': int(duplicates),
                'message': f"{duplicates} duplicate rows found"
            })

        # Check for constant columns
        constant_cols = [col for col in self.df.columns if self.df[col].nunique() == 1]
        if len(constant_cols) > 0:
            issues.append({
                'type': 'CONSTANT_COLUMNS',
                'severity': 'WARNING',
                'columns': constant_cols,
                'message': f"{len(constant_cols)} column(s) have constant values"
            })

        # Check for high cardinality
        for col in self.df.select_dtypes(include=['object']).columns:
            unique_ratio = self.df[col].nunique() / len(self.df)
            if unique_ratio > 0.95:
                issues.append({
                    'type': 'HIGH_CARDINALITY',
                    'severity': 'INFO',
                    'column': col,
                    'message': f"Column '{col}' has very high cardinality ({unique_ratio*100:.1f}%)"
                })

        return issues

    def _generate_text_report(self, profile):
        """Generate human-readable text report"""
        lines = []
        lines.append("=" * 80)
        lines.append("CSV DATA PROFILE REPORT")
        lines.append("=" * 80)
        lines.append("")

        # File Info
        lines.append("FILE INFORMATION")
        lines.append("-" * 80)
        for key, value in profile['file_info'].items():
            lines.append(f"{key.replace('_', ' ').title()}: {value}")
        lines.append("")

        # Overview
        lines.append("DATASET OVERVIEW")
        lines.append("-" * 80)
        for key, value in profile['overview'].items():
            if key != 'column_names':
                lines.append(f"{key.replace('_', ' ').title()}: {value}")
        lines.append("")

        # Missing Data
        lines.append("MISSING DATA ANALYSIS")
        lines.append("-" * 80)
        lines.append(f"Total Missing Values: {profile['missing_data']['total_missing_values']}")
        lines.append(f"Complete Rows: {profile['missing_data']['complete_rows']}")
        lines.append(f"Rows with Missing: {profile['missing_data']['rows_with_any_missing']}")
        if profile['missing_data']['columns_with_missing']:
            lines.append("\nColumns with Missing Data:")
            for col, info in profile['missing_data']['columns_with_missing'].items():
                lines.append(f"  - {col}: {info['count']} ({info['percentage']})")
        lines.append("")

        # Numeric Summary
        if profile['numeric_summary']:
            lines.append("NUMERIC COLUMNS SUMMARY")
            lines.append("-" * 80)
            for col, stats in profile['numeric_summary'].items():
                lines.append(f"\n{col}:")
                for stat, value in stats.items():
                    lines.append(f"  {stat}: {value:.4f}" if isinstance(value, float) else f"  {stat}: {value}")
            lines.append("")

        # Categorical Summary
        if profile['categorical_summary']:
            lines.append("CATEGORICAL COLUMNS SUMMARY")
            lines.append("-" * 80)
            for col, stats in profile['categorical_summary'].items():
                lines.append(f"\n{col}:")
                for key, value in stats.items():
                    if key != 'top_5_values':
                        lines.append(f"  {key.replace('_', ' ').title()}: {value}")
            lines.append("")

        # Data Quality
        if profile['data_quality']:
            lines.append("DATA QUALITY ISSUES")
            lines.append("-" * 80)
            for issue in profile['data_quality']:
                lines.append(f"[{issue['severity']}] {issue['message']}")
            lines.append("")

        lines.append("=" * 80)
        lines.append(f"Report generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        lines.append("=" * 80)

        return "\n".join(lines)

    def _generate_html_report(self, profile):
        """Generate HTML report"""
        html = f"""
<!DOCTYPE html>
<html>
<head>
    <title>Data Profile Report</title>
    <style>
        body {{ font-family: Arial, sans-serif; margin: 20px; background: #f5f5f5; }}
        .container {{ max-width: 1200px; margin: 0 auto; background: white; padding: 20px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }}
        h1 {{ color: #333; border-bottom: 3px solid #4CAF50; padding-bottom: 10px; }}
        h2 {{ color: #555; border-bottom: 2px solid #ddd; padding-bottom: 8px; margin-top: 30px; }}
        .info-grid {{ display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px; margin: 20px 0; }}
        .info-card {{ background: #f9f9f9; padding: 15px; border-left: 4px solid #4CAF50; }}
        .info-card strong {{ display: block; color: #666; font-size: 0.9em; margin-bottom: 5px; }}
        .info-card span {{ font-size: 1.2em; color: #333; }}
        table {{ width: 100%; border-collapse: collapse; margin: 20px 0; }}
        th, td {{ padding: 12px; text-align: left; border-bottom: 1px solid #ddd; }}
        th {{ background: #4CAF50; color: white; }}
        tr:hover {{ background: #f5f5f5; }}
        .issue {{ padding: 10px; margin: 10px 0; border-left: 4px solid; }}
        .issue.WARNING {{ background: #fff3cd; border-color: #ffc107; }}
        .issue.INFO {{ background: #d1ecf1; border-color: #17a2b8; }}
        .issue.ERROR {{ background: #f8d7da; border-color: #dc3545; }}
    </style>
</head>
<body>
    <div class="container">
        <h1>CSV Data Profile Report</h1>
        <p><strong>Generated:</strong> {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}</p>

        <h2>File Information</h2>
        <div class="info-grid">
            <div class="info-card"><strong>Filename</strong><span>{profile['file_info']['filename']}</span></div>
            <div class="info-card"><strong>File Size</strong><span>{profile['file_info']['file_size']}</span></div>
            <div class="info-card"><strong>Rows</strong><span>{profile['file_info']['rows']:,}</span></div>
            <div class="info-card"><strong>Columns</strong><span>{profile['file_info']['columns']}</span></div>
        </div>

        <h2>Dataset Overview</h2>
        <div class="info-grid">
            <div class="info-card"><strong>Shape</strong><span>{profile['overview']['shape']}</span></div>
            <div class="info-card"><strong>Memory Usage</strong><span>{profile['overview']['memory_usage']}</span></div>
            <div class="info-card"><strong>Duplicate Rows</strong><span>{profile['overview']['duplicate_rows']}</span></div>
        </div>

        <h2>Missing Data Analysis</h2>
        <div class="info-grid">
            <div class="info-card"><strong>Total Missing</strong><span>{profile['missing_data']['total_missing_values']:,}</span></div>
            <div class="info-card"><strong>Complete Rows</strong><span>{profile['missing_data']['complete_rows']:,}</span></div>
            <div class="info-card"><strong>Rows with Missing</strong><span>{profile['missing_data']['rows_with_any_missing']:,}</span></div>
        </div>

        <h2>Data Quality Issues</h2>
        {''.join([f'<div class="issue {issue["severity"]}">[{issue["severity"]}] {issue["message"]}</div>' for issue in profile['data_quality']]) if profile['data_quality'] else '<p>No issues detected</p>'}
    </div>
</body>
</html>
"""
        return html


def main():
    parser = argparse.ArgumentParser(
        description='Generate comprehensive data profile for CSV files',
        formatter_class=argparse.RawDescriptionHelpFormatter
    )

    parser.add_argument('csv_file', help='Path to CSV file')
    parser.add_argument('-f', '--format', choices=['text', 'json', 'html'],
                       default='text', help='Output format (default: text)')
    parser.add_argument('-o', '--output', help='Output file path (default: print to stdout)')

    args = parser.parse_args()

    # Generate profile
    profiler = DataProfiler(args.csv_file)
    report = profiler.generate_profile(output_format=args.format)

    # Output
    if args.output:
        output_path = Path(args.output)
        output_path.write_text(report)
        print(f"✓ Report saved: {output_path}")
    else:
        print(report)


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
CSV Data Visualizer - Interactive visualization tool using Plotly
Supports statistical plots, relationships, time series, and categorical data
"""

import pandas as pd
import plotly.express as px
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import argparse
import sys
from pathlib import Path
import json


class CSVVisualizer:
    """Main visualization class for CSV data"""

    def __init__(self, csv_path):
        """Initialize with CSV file path"""
        try:
            self.df = pd.read_csv(csv_path)
            self.csv_path = Path(csv_path)
            print(f"✓ Loaded CSV: {csv_path}")
            print(f"  Rows: {len(self.df)}, Columns: {len(self.df.columns)}")
        except Exception as e:
            print(f"✗ Error loading CSV: {e}", file=sys.stderr)
            sys.exit(1)

    def histogram(self, column, bins=30, output=None):
        """Create histogram for a numeric column"""
        fig = px.histogram(
            self.df,
            x=column,
            nbins=bins,
            title=f"Distribution of {column}",
            labels={column: column, 'count': 'Frequency'}
        )
        fig.update_layout(showlegend=False)
        return self._save_figure(fig, output, f"histogram_{column}")

    def box_plot(self, column, group_by=None, output=None):
        """Create box plot for numeric column, optionally grouped"""
        if group_by:
            fig = px.box(
                self.df,
                x=group_by,
                y=column,
                title=f"Box Plot: {column} by {group_by}"
            )
        else:
            fig = px.box(
                self.df,
                y=column,
                title=f"Box Plot: {column}"
            )
        return self._save_figure(fig, output, f"boxplot_{column}")

    def scatter_plot(self, x_col, y_col, color=None, size=None, output=None):
        """Create scatter plot showing relationship between two variables"""
        fig = px.scatter(
            self.df,
            x=x_col,
            y=y_col,
            color=color,
            size=size,
            title=f"{y_col} vs {x_col}",
            trendline="ols" if color is None else None
        )
        return self._save_figure(fig, output, f"scatter_{x_col}_{y_col}")

    def correlation_heatmap(self, columns=None, output=None):
        """Create correlation heatmap for numeric columns"""
        if columns:
            numeric_df = self.df[columns]
        else:
            numeric_df = self.df.select_dtypes(include=['number'])

        corr_matrix = numeric_df.corr()

        fig = px.imshow(
            corr_matrix,
            text_auto='.2f',
            aspect="auto",
            color_continuous_scale='RdBu_r',
            title="Correlation Heatmap"
        )
        return self._save_figure(fig, output, "correlation_heatmap")

    def line_chart(self, x_col, y_cols, output=None):
        """Create line chart for time series or sequential data"""
        if isinstance(y_cols, str):
            y_cols = [y_cols]

        fig = go.Figure()
        for y_col in y_cols:
            fig.add_trace(go.Scatter(
                x=self.df[x_col],
                y=self.df[y_col],
                mode='lines+markers',
                name=y_col
            ))

        fig.update_layout(
            title=f"Time Series: {', '.join(y_cols)}",
            xaxis_title=x_col,
            yaxis_title="Value"
        )
        return self._save_figure(fig, output, f"timeseries_{x_col}")

    def bar_chart(self, x_col, y_col=None, output=None):
        """Create bar chart for categorical data"""
        if y_col is None:
            # Count occurrences
            value_counts = self.df[x_col].value_counts().reset_index()
            value_counts.columns = [x_col, 'count']
            fig = px.bar(
                value_counts,
                x=x_col,
                y='count',
                title=f"Count of {x_col}"
            )
        else:
            fig = px.bar(
                self.df,
                x=x_col,
                y=y_col,
                title=f"{y_col} by {x_col}"
            )
        return self._save_figure(fig, output, f"bar_{x_col}")

    def pie_chart(self, column, output=None):
        """Create pie chart for categorical data"""
        value_counts = self.df[column].value_counts().reset_index()
        value_counts.columns = [column, 'count']

        fig = px.pie(
            value_counts,
            values='count',
            names=column,
            title=f"Distribution of {column}"
        )
        return self._save_figure(fig, output, f"pie_{column}")

    def violin_plot(self, column, group_by=None, output=None):
        """Create violin plot showing distribution with probability density"""
        if group_by:
            fig = px.violin(
                self.df,
                x=group_by,
                y=column,
                box=True,
                title=f"Violin Plot: {column} by {group_by}"
            )
        else:
            fig = px.violin(
                self.df,
                y=column,
                box=True,
                title=f"Violin Plot: {column}"
            )
        return self._save_figure(fig, output, f"violin_{column}")

    def _save_figure(self, fig, output_path, default_name):
        """Save figure to file"""
        if output_path is None:
            output_path = self.csv_path.parent / f"{default_name}.html"
        else:
            output_path = Path(output_path)

        # Determine format from extension
        suffix = output_path.suffix.lower()

        if suffix == '.html':
            fig.write_html(str(output_path))
        elif suffix in ['.png', '.jpg', '.jpeg', '.svg', '.pdf']:
            fig.write_image(str(output_path))
        else:
            # Default to HTML
            output_path = output_path.with_suffix('.html')
            fig.write_html(str(output_path))

        print(f"✓ Saved: {output_path}")
        return str(output_path)


def main():
    parser = argparse.ArgumentParser(
        description='Create interactive visualizations from CSV data',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  # Histogram of a column
  %(prog)s data.csv --histogram age --bins 20

  # Scatter plot with trend line
  %(prog)s data.csv --scatter height weight

  # Box plot grouped by category
  %(prog)s data.csv --boxplot salary --group-by department

  # Correlation heatmap
  %(prog)s data.csv --correlation

  # Time series line chart
  %(prog)s data.csv --line date "sales,revenue"

  # Bar chart of categories
  %(prog)s data.csv --bar category

  # Pie chart
  %(prog)s data.csv --pie region
        """
    )

    parser.add_argument('csv_file', help='Path to CSV file')
    parser.add_argument('-o', '--output', help='Output file path')

    # Visualization types
    parser.add_argument('--histogram', metavar='COLUMN', help='Create histogram')
    parser.add_argument('--bins', type=int, default=30, help='Number of bins for histogram')
    parser.add_argument('--boxplot', metavar='COLUMN', help='Create box plot')
    parser.add_argument('--violin', metavar='COLUMN', help='Create violin plot')
    parser.add_argument('--scatter', nargs=2, metavar=('X', 'Y'), help='Create scatter plot')
    parser.add_argument('--line', nargs=2, metavar=('X', 'Y'), help='Create line chart (Y can be comma-separated)')
    parser.add_argument('--bar', metavar='COLUMN', help='Create bar chart')
    parser.add_argument('--pie', metavar='COLUMN', help='Create pie chart')
    parser.add_argument('--correlation', action='store_true', help='Create correlation heatmap')

    # Optional parameters
    parser.add_argument('--group-by', help='Column to group by (for box/violin plots)')
    parser.add_argument('--color', help='Column for color encoding (scatter plot)')
    parser.add_argument('--size', help='Column for size encoding (scatter plot)')

    args = parser.parse_args()

    # Initialize visualizer
    viz = CSVVisualizer(args.csv_file)

    # Create requested visualization
    if args.histogram:
        viz.histogram(args.histogram, bins=args.bins, output=args.output)
    elif args.boxplot:
        viz.box_plot(args.boxplot, group_by=args.group_by, output=args.output)
    elif args.violin:
        viz.violin_plot(args.violin, group_by=args.group_by, output=args.output)
    elif args.scatter:
        viz.scatter_plot(args.scatter[0], args.scatter[1],
                        color=args.color, size=args.size, output=args.output)
    elif args.line:
        y_cols = args.line[1].split(',')
        viz.line_chart(args.line[0], y_cols, output=args.output)
    elif args.bar:
        viz.bar_chart(args.bar, output=args.output)
    elif args.pie:
        viz.pie_chart(args.pie, output=args.output)
    elif args.correlation:
        viz.correlation_heatmap(output=args.output)
    else:
        parser.print_help()
        sys.exit(1)


if __name__ == '__main__':
    main()