@hasna/skills 0.1.62 → 0.1.64

package/skills/analyze-data/src/analysis.ts

@@ -1,401 +0,0 @@
-import { readFileSync, statSync } from 'fs';
-import { basename, extname } from 'path';
-
-import { parseCSV, parseJSON } from './parsers';
-import { log } from './logger';
-import {
-  calculateCorrelation,
-  calculatePercentiles,
-  calculateStats,
-  detectDataType,
-  detectOutliers,
-  formatBytes,
-  roundTo,
-} from './stats';
-import type { AnalysisOptions, AnalysisReport, ColumnStats } from './types';
-
-function analyzeColumn(columnName: string, values: any[], options: AnalysisOptions): ColumnStats {
-  const dataType = detectDataType(values);
-  const nonNullValues = values.filter(v => v !== null && v !== undefined && v !== '');
-  const nullCount = values.length - nonNullValues.length;
-
-  const uniqueValues = new Set(nonNullValues);
-  const stats: ColumnStats = {
-    name: columnName,
-    dataType,
-    count: values.length,
-    nullCount,
-    nullPercentage: roundTo((nullCount / values.length) * 100, 2),
-    uniqueCount: uniqueValues.size,
-    uniquePercentage: roundTo((uniqueValues.size / nonNullValues.length) * 100, 2),
-    sampleValues: nonNullValues.slice(0, 5),
-  };
-
-  // Numeric analysis
-  if (dataType === 'numeric') {
-    const numericValues = nonNullValues.map(Number).filter(v => !isNaN(v));
-    Object.assign(stats, calculateStats(numericValues));
-
-    if (options.percentiles.length > 0) {
-      stats.percentiles = calculatePercentiles(numericValues, options.percentiles);
-    }
-
-    if (options.outliers && stats.q1 !== undefined && stats.q3 !== undefined) {
-      stats.outliers = detectOutliers(numericValues, stats.q1, stats.q3);
-    }
-  }
-
-  // String analysis
-  if (dataType === 'string') {
-    const lengths = nonNullValues.map(v => String(v).length);
-    stats.avgLength = roundTo(lengths.reduce((a, b) => a + b, 0) / lengths.length, 2);
-    stats.minLength = Math.min(...lengths);
-    stats.maxLength = Math.max(...lengths);
-  }
-
-  // Distribution (for categorical data)
-  if (uniqueValues.size <= 50) {
-    const distribution: Record<string, number> = {};
-    nonNullValues.forEach(val => {
-      const key = String(val);
-      distribution[key] = (distribution[key] || 0) + 1;
-    });
-    stats.distribution = distribution;
-
-    const topValues = Object.entries(distribution)
-      .map(([value, count]) => ({
-        value,
-        count,
-        percentage: roundTo((count / nonNullValues.length) * 100, 2),
-      }))
-      .sort((a, b) => b.count - a.count)
-      .slice(0, 10);
-
-    stats.topValues = topValues;
-  }
-
-  return stats;
-}
-
-function analyzeCorrelations(data: any[], numericColumns: string[]): {
-  matrix: number[][];
-  pairs: Array<{ col1: string; col2: string; correlation: number }>;
-} {
-  const n = numericColumns.length;
-  const matrix: number[][] = Array(n).fill(0).map(() => Array(n).fill(0));
-  const pairs: Array<{ col1: string; col2: string; correlation: number }> = [];
-
-  for (let i = 0; i < n; i++) {
-    for (let j = i; j < n; j++) {
-      if (i === j) {
-        matrix[i][j] = 1;
-      } else {
-        const col1Values = data.map(row => Number(row[numericColumns[i]])).filter(v => !isNaN(v));
-        const col2Values = data.map(row => Number(row[numericColumns[j]])).filter(v => !isNaN(v));
-
-        const correlation = calculateCorrelation(col1Values, col2Values);
-        matrix[i][j] = roundTo(correlation, 4);
-        matrix[j][i] = roundTo(correlation, 4);
-
-        if (Math.abs(correlation) > 0.5) {
-          pairs.push({
-            col1: numericColumns[i],
-            col2: numericColumns[j],
-            correlation: roundTo(correlation, 4),
-          });
-        }
-      }
-    }
-  }
-
-  pairs.sort((a, b) => Math.abs(b.correlation) - Math.abs(a.correlation));
-
-  return { matrix, pairs };
-}
-
-function detectTrends(data: any[], columnStats: ColumnStats[]): {
-  detected: boolean;
-  patterns: string[];
-  insights: string[];
-} {
-  const patterns: string[] = [];
-  const insights: string[] = [];
-
-  // Check for time-series columns
-  const dateColumns = columnStats.filter(col => col.dataType === 'date');
-  const numericColumns = columnStats.filter(col => col.dataType === 'numeric');
-
-  if (dateColumns.length > 0 && numericColumns.length > 0) {
-    patterns.push('Time-series data detected');
-    insights.push('Consider visualizing trends over time');
-  }
-
-  // Check for monotonic trends
-  numericColumns.forEach(col => {
-    if (col.skewness && Math.abs(col.skewness) > 1) {
-      patterns.push(`${col.name} shows ${col.skewness > 0 ? 'positive' : 'negative'} skew`);
-    }
-  });
-
-  return {
-    detected: patterns.length > 0,
-    patterns,
-    insights,
-  };
-}
-
-function generateVisualizationRecommendations(columnStats: ColumnStats[]): Array<{
-  column: string;
-  chartType: string;
-  reason: string;
-}> {
-  const recommendations: Array<{ column: string; chartType: string; reason: string }> = [];
-
-  columnStats.forEach(col => {
-    if (col.dataType === 'numeric') {
-      if (col.uniqueCount > 20) {
-        recommendations.push({
-          column: col.name,
-          chartType: 'Histogram',
-          reason: 'Shows distribution of continuous numeric values',
-        });
-      } else {
-        recommendations.push({
-          column: col.name,
-          chartType: 'Bar Chart',
-          reason: 'Shows distribution of discrete numeric values',
-        });
-      }
-    } else if (col.dataType === 'string' && col.uniqueCount <= 20) {
-      recommendations.push({
-        column: col.name,
-        chartType: 'Pie Chart / Bar Chart',
-        reason: 'Shows category distribution',
-      });
-    } else if (col.dataType === 'date') {
-      recommendations.push({
-        column: col.name,
-        chartType: 'Line Chart',
-        reason: 'Shows trends over time',
-      });
-    }
-  });
-
-  return recommendations;
-}
-
-function calculateDataQuality(columnStats: ColumnStats[], data: any[]): {
-  totalCells: number;
-  missingCells: number;
-  missingPercentage: number;
-  duplicateRows: number;
-  duplicatePercentage: number;
-  dataQualityScore: number;
-  issues: string[];
-} {
-  const totalCells = data.length * columnStats.length;
-  const missingCells = columnStats.reduce((sum, col) => sum + col.nullCount, 0);
-  const missingPercentage = roundTo((missingCells / totalCells) * 100, 2);
-
-  // Detect duplicates
-  const rowStrings = data.map(row => JSON.stringify(row));
-  const uniqueRows = new Set(rowStrings);
-  const duplicateRows = data.length - uniqueRows.size;
-  const duplicatePercentage = roundTo((duplicateRows / data.length) * 100, 2);
-
-  // Quality issues
-  const issues: string[] = [];
-
-  if (missingPercentage > 10) {
-    issues.push(`High missing data rate: ${missingPercentage}%`);
-  }
-
-  if (duplicateRows > 0) {
-    issues.push(`${duplicateRows} duplicate rows found`);
-  }
-
-  columnStats.forEach(col => {
-    if (col.dataType === 'mixed') {
-      issues.push(`Column "${col.name}" has mixed data types`);
-    }
-    if (col.nullPercentage > 50) {
-      issues.push(`Column "${col.name}" has ${col.nullPercentage}% missing values`);
-    }
-  });
-
-  // Calculate quality score (0-100)
-  let score = 100;
-  score -= Math.min(missingPercentage * 2, 30);
-  score -= Math.min(duplicatePercentage * 1.5, 20);
-  score -= Math.min(issues.length * 5, 30);
-
-  return {
-    totalCells,
-    missingCells,
-    missingPercentage,
-    duplicateRows,
-    duplicatePercentage,
-    dataQualityScore: Math.max(0, Math.round(score)),
-    issues,
-  };
-}
-
-function generateInsights(report: AnalysisReport): string[] {
-  const insights: string[] = [];
-
-  // Dataset size insights
-  if (report.overview.rowCount < 100) {
-    insights.push('Small dataset - consider collecting more data for robust analysis');
-  } else if (report.overview.rowCount > 10000) {
-    insights.push('Large dataset - suitable for machine learning applications');
-  }
-
-  // Data quality insights
-  if (report.quality.dataQualityScore >= 90) {
-    insights.push('Excellent data quality - ready for analysis');
-  } else if (report.quality.dataQualityScore >= 70) {
-    insights.push('Good data quality - minor cleaning recommended');
-  } else {
-    insights.push('Data quality issues detected - cleaning required before analysis');
-  }
-
-  // Column insights
-  const numericCols = report.columns.filter(col => col.dataType === 'numeric');
-  const categoricalCols = report.columns.filter(col => col.dataType === 'string' && (col.uniqueCount || 0) <= 20);
-
-  if (numericCols.length > 3) {
-    insights.push(`${numericCols.length} numeric columns - suitable for correlation and regression analysis`);
-  }
-
-  if (categoricalCols.length > 0) {
-    insights.push(`${categoricalCols.length} categorical columns - consider segmentation analysis`);
-  }
-
-  // Correlation insights
-  if (report.correlationPairs && report.correlationPairs.length > 0) {
-    const strongPairs = report.correlationPairs.filter(p => Math.abs(p.correlation) > 0.7);
-    if (strongPairs.length > 0) {
-      insights.push(`${strongPairs.length} strong correlations found - potential feature engineering opportunities`);
-    }
-  }
-
-  // Outlier insights
-  const colsWithOutliers = report.columns.filter(col => col.outliers && col.outliers.length > 0);
-  if (colsWithOutliers.length > 0) {
-    insights.push(`Outliers detected in ${colsWithOutliers.length} columns - review for data errors or special cases`);
-  }
-
-  return insights;
-}
-
-// ============================================================================
-
-export async function analyzeData(filePath: string, options: AnalysisOptions): Promise<AnalysisReport> {
-  const startTime = Date.now();
-
-  // Read file
-  if (options.verbose) {
-    log(`Reading file: ${filePath}`);
-  }
-
-  const fileStats = statSync(filePath);
-  const fileExt = extname(filePath).toLowerCase();
-  const content = readFileSync(filePath, 'utf-8');
-
-  // Parse data
-  let data: any[];
-  if (fileExt === '.csv') {
-    data = parseCSV(content);
-  } else if (fileExt === '.json') {
-    data = parseJSON(content);
-  } else {
-    throw new Error(`Unsupported file type: ${fileExt}`);
-  }
-
-  // Apply sampling
-  if (options.sample && data.length > options.sample) {
-    if (options.verbose) {
-      log(`Sampling first ${options.sample} rows out of ${data.length}`);
-    }
-    data = data.slice(0, options.sample);
-  }
-
-  if (data.length === 0) {
-    throw new Error('No data found in file');
-  }
-
-  // Get column names
-  const columnNames = Object.keys(data[0]);
-
-  if (options.verbose) {
-    log(`Analyzing ${data.length} rows and ${columnNames.length} columns...`);
-  }
-
-  // Analyze each column
-  const columnStats: ColumnStats[] = columnNames.map(colName => {
-    const values = data.map(row => row[colName]);
-    return analyzeColumn(colName, values, options);
-  });
-
-  // Correlation analysis
-  let correlations: number[][] | undefined;
-  let correlationPairs: Array<{ col1: string; col2: string; correlation: number }> | undefined;
-
-  if (options.correlations) {
-    const numericColumns = columnStats
-      .filter(col => col.dataType === 'numeric')
-      .map(col => col.name);
-
-    if (numericColumns.length >= 2) {
-      if (options.verbose) {
-        log(`Calculating correlations for ${numericColumns.length} numeric columns...`);
-      }
-      const corrResult = analyzeCorrelations(data, numericColumns);
-      correlations = corrResult.matrix;
-      correlationPairs = corrResult.pairs;
-    }
-  }
-
-  // Trend analysis
-  let trends: AnalysisReport['trends'];
-  if (options.trends) {
-    if (options.verbose) {
-      log('Analyzing trends...');
-    }
-    trends = detectTrends(data, columnStats);
-  }
-
-  // Data quality
-  const quality = calculateDataQuality(columnStats, data);
-
-  // Visualization recommendations
-  const visualizationRecommendations = generateVisualizationRecommendations(columnStats);
-
-  // Build report
-  const report: AnalysisReport = {
-    overview: {
-      fileName: basename(filePath),
-      fileSize: formatBytes(fileStats.size),
-      fileType: fileExt.slice(1).toUpperCase(),
-      rowCount: data.length,
-      columnCount: columnNames.length,
-      memoryUsage: formatBytes(JSON.stringify(data).length),
-      processingTime: Date.now() - startTime,
-      timestamp: new Date().toISOString(),
-    },
-    columns: columnStats,
-    correlations,
-    correlationPairs,
-    quality,
-    trends,
-    visualizationRecommendations,
-    insights: [],
-  };
-
-  // Generate insights
-  report.insights = generateInsights(report);
-
-  return report;
-}
-
-// ============================================================================

package/skills/analyze-data/src/cli.ts

@@ -1,66 +0,0 @@
-import { resolve } from 'path';
-import { parseArgs } from 'util';
-
-import { log } from './logger';
-import type { AnalysisOptions } from './types';
-
-export function parseArguments(): { filePath: string; options: AnalysisOptions } {
-  const { values, positionals } = parseArgs({
-    args: process.argv.slice(2),
-    options: {
-      format: { type: 'string', default: 'markdown' },
-      output: { type: 'string' },
-      correlations: { type: 'boolean', default: false },
-      outliers: { type: 'boolean', default: false },
-      trends: { type: 'boolean', default: false },
-      sample: { type: 'string' },
-      percentiles: { type: 'string', default: '25,50,75,90,95' },
-      verbose: { type: 'boolean', default: false },
-      help: { type: 'boolean', short: 'h' },
-    },
-    allowPositionals: true,
-  });
-
-  if (values.help) {
-    console.log(`
-Analyze Data - Comprehensive data analysis for CSV and JSON files
-
-Usage:
-  skills run analyze-data -- <file-path> [options]
-
-Options:
-  --format <fmt>       Output format: markdown, json, html (default: markdown)
-  --output <path>      Save report to file
-  --correlations       Calculate correlations
-  --outliers           Detect outliers
-  --trends             Detect trends
-  --sample <n>         Analyze only first n rows
-  --percentiles <list> Comma-separated percentiles (default: 25,50,75,90,95)
-  --verbose            Show detailed progress
-  --help, -h           Show this help
-`);
-    process.exit(0);
-  }
-
-  if (positionals.length === 0) {
-    log('Error: File path is required', 'error');
-    console.log('Usage: skills run analyze-data -- <file-path> [options]');
-    process.exit(1);
-  }
-
-  const filePath = resolve(process.cwd(), positionals[0]);
-
-  return {
-    filePath,
-    options: {
-      format: values.format as 'markdown' | 'json' | 'html',
-      output: values.output as string,
-      correlations: values.correlations as boolean,
-      outliers: values.outliers as boolean,
-      trends: values.trends as boolean,
-      sample: values.sample ? parseInt(values.sample as string) : undefined,
-      percentiles: (values.percentiles as string).split(',').map(Number),
-      verbose: values.verbose as boolean,
-    }
-  };
-}

package/skills/analyze-data/src/formatters.ts

@@ -1,235 +0,0 @@
-import type { AnalysisReport } from './types';
-
-export function formatMarkdown(report: AnalysisReport): string {
-  let md = '# Data Analysis Report\n\n';
-
-  md += `**Generated**: ${report.overview.timestamp}  \n`;
-  md += `**Processing Time**: ${report.overview.processingTime}ms\n\n`;
-
-  // Overview
-  md += '## Dataset Overview\n\n';
-  md += `- **File**: ${report.overview.fileName}\n`;
-  md += `- **Size**: ${report.overview.fileSize}\n`;
-  md += `- **Type**: ${report.overview.fileType}\n`;
-  md += `- **Rows**: ${report.overview.rowCount.toLocaleString()}\n`;
-  md += `- **Columns**: ${report.overview.columnCount}\n`;
-  md += `- **Memory Usage**: ${report.overview.memoryUsage}\n\n`;
-
-  // Column Analysis
-  md += '## Column Analysis\n\n';
-
-  report.columns.forEach(col => {
-    md += `### ${col.name}\n\n`;
-    md += `- **Type**: ${col.dataType}\n`;
-    md += `- **Count**: ${col.count.toLocaleString()}\n`;
-    md += `- **Null**: ${col.nullCount} (${col.nullPercentage}%)\n`;
-    md += `- **Unique**: ${col.uniqueCount} (${col.uniquePercentage}%)\n`;
-    md += `- **Sample**: ${col.sampleValues.join(', ')}\n`;
-
-    if (col.dataType === 'numeric') {
-      md += '\n**Statistics**:\n\n';
-      md += `| Metric | Value |\n`;
-      md += `|--------|-------|\n`;
-      md += `| Mean | ${col.mean} |\n`;
-      md += `| Median | ${col.median} |\n`;
-      md += `| Std Dev | ${col.stdDev} |\n`;
-      md += `| Min | ${col.min} |\n`;
-      md += `| Max | ${col.max} |\n`;
-      md += `| Q1 | ${col.q1} |\n`;
-      md += `| Q3 | ${col.q3} |\n`;
-
-      if (col.outliers && col.outliers.length > 0) {
-        md += `\n**Outliers**: ${col.outliers.length} detected\n`;
-      }
-    }
-
-    if (col.topValues && col.topValues.length > 0) {
-      md += '\n**Top Values**:\n\n';
-      md += `| Value | Count | Percentage |\n`;
-      md += `|-------|-------|------------|\n`;
-      col.topValues.forEach(tv => {
-        md += `| ${tv.value} | ${tv.count} | ${tv.percentage}% |\n`;
-      });
-    }
-
-    md += '\n';
-  });
-
-  // Correlations
-  if (report.correlationPairs && report.correlationPairs.length > 0) {
-    md += '## Correlation Analysis\n\n';
-    md += '**Strong Correlations** (|r| > 0.5):\n\n';
-    md += `| Column 1 | Column 2 | Correlation |\n`;
-    md += `|----------|----------|-------------|\n`;
-    report.correlationPairs.forEach(pair => {
-      md += `| ${pair.col1} | ${pair.col2} | ${pair.correlation} |\n`;
-    });
-    md += '\n';
-  }
-
-  // Data Quality
-  md += '## Data Quality\n\n';
-  md += `- **Quality Score**: ${report.quality.dataQualityScore}/100\n`;
-  md += `- **Missing Cells**: ${report.quality.missingCells} (${report.quality.missingPercentage}%)\n`;
-  md += `- **Duplicate Rows**: ${report.quality.duplicateRows} (${report.quality.duplicatePercentage}%)\n\n`;
-
-  if (report.quality.issues.length > 0) {
-    md += '**Issues Found**:\n\n';
-    report.quality.issues.forEach(issue => {
-      md += `- ${issue}\n`;
-    });
-    md += '\n';
-  }
-
-  // Visualization Recommendations
-  if (report.visualizationRecommendations.length > 0) {
-    md += '## Visualization Recommendations\n\n';
-    md += `| Column | Chart Type | Reason |\n`;
-    md += `|--------|------------|--------|\n`;
-    report.visualizationRecommendations.forEach(rec => {
-      md += `| ${rec.column} | ${rec.chartType} | ${rec.reason} |\n`;
-    });
-    md += '\n';
-  }
-
-  // Insights
-  if (report.insights.length > 0) {
-    md += '## Key Insights\n\n';
-    report.insights.forEach((insight, idx) => {
-      md += `${idx + 1}. ${insight}\n`;
-    });
-    md += '\n';
-  }
-
-  md += '---\n\n';
-  md += '*Generated by the analyze-data skill*\n';
-
-  return md;
-}
-
-export function formatHTML(report: AnalysisReport): string {
-  return `<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Data Analysis Report - ${report.overview.fileName}</title>
-    <style>
-        * { margin: 0; padding: 0; box-sizing: border-box; }
-        body {
-            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
-            line-height: 1.6;
-            color: #333;
-            background: #f5f5f5;
-            padding: 20px;
-        }
-        .container { max-width: 1200px; margin: 0 auto; background: white; padding: 40px; border-radius: 8px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
-        h1 { color: #2563eb; border-bottom: 3px solid #2563eb; padding-bottom: 10px; margin-bottom: 20px; }
-        h2 { color: #1e40af; margin-top: 30px; margin-bottom: 15px; border-left: 4px solid #2563eb; padding-left: 10px; }
-        h3 { color: #3b82f6; margin-top: 20px; margin-bottom: 10px; }
-        .meta { color: #666; font-size: 14px; margin-bottom: 30px; }
-        .overview { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 20px; margin-bottom: 30px; }
-        .overview-item { background: #f8fafc; padding: 15px; border-radius: 6px; border-left: 3px solid #2563eb; }
-        .overview-item strong { display: block; color: #1e40af; margin-bottom: 5px; }
-        table { width: 100%; border-collapse: collapse; margin: 15px 0; }
-        th, td { padding: 12px; text-align: left; border-bottom: 1px solid #e5e7eb; }
-        th { background: #f8fafc; color: #1e40af; font-weight: 600; }
-        tr:hover { background: #f8fafc; }
-        .quality-score { font-size: 48px; font-weight: bold; color: #10b981; text-align: center; margin: 20px 0; }
-        .quality-score.medium { color: #f59e0b; }
-        .quality-score.low { color: #ef4444; }
-        .issue { background: #fef2f2; border-left: 3px solid #ef4444; padding: 10px; margin: 5px 0; border-radius: 4px; }
-        .insight { background: #f0f9ff; border-left: 3px solid #3b82f6; padding: 10px; margin: 5px 0; border-radius: 4px; }
-        .column-card { background: #fafafa; padding: 20px; margin: 15px 0; border-radius: 6px; border: 1px solid #e5e7eb; }
-        .badge { display: inline-block; padding: 4px 8px; border-radius: 4px; font-size: 12px; font-weight: 600; margin-right: 5px; }
-        .badge.numeric { background: #dbeafe; color: #1e40af; }
-        .badge.string { background: #fce7f3; color: #9f1239; }
-        .badge.date { background: #d1fae5; color: #065f46; }
-        .badge.boolean { background: #fef3c7; color: #92400e; }
-        footer { text-align: center; margin-top: 40px; padding-top: 20px; border-top: 1px solid #e5e7eb; color: #666; font-size: 14px; }
-    </style>
-</head>
-<body>
-    <div class="container">
-        <h1>📊 Data Analysis Report</h1>
-        <div class="meta">
-            Generated: ${report.overview.timestamp} | Processing Time: ${report.overview.processingTime}ms
-        </div>
-
-        <h2>Dataset Overview</h2>
-        <div class="overview">
-            <div class="overview-item"><strong>File</strong>${report.overview.fileName}</div>
-            <div class="overview-item"><strong>Size</strong>${report.overview.fileSize}</div>
-            <div class="overview-item"><strong>Type</strong>${report.overview.fileType}</div>
-            <div class="overview-item"><strong>Rows</strong>${report.overview.rowCount.toLocaleString()}</div>
-            <div class="overview-item"><strong>Columns</strong>${report.overview.columnCount}</div>
-            <div class="overview-item"><strong>Memory</strong>${report.overview.memoryUsage}</div>
-        </div>
-
-        <h2>Data Quality</h2>
-        <div class="quality-score ${report.quality.dataQualityScore >= 70 ? '' : report.quality.dataQualityScore >= 50 ? 'medium' : 'low'}">
-            ${report.quality.dataQualityScore}/100
-        </div>
-        <table>
-            <tr><th>Metric</th><th>Value</th></tr>
-            <tr><td>Missing Cells</td><td>${report.quality.missingCells} (${report.quality.missingPercentage}%)</td></tr>
-            <tr><td>Duplicate Rows</td><td>${report.quality.duplicateRows} (${report.quality.duplicatePercentage}%)</td></tr>
-        </table>
-        ${report.quality.issues.length > 0 ? `
-            <h3>Issues Found</h3>
-            ${report.quality.issues.map(issue => `<div class="issue">${issue}</div>`).join('')}
-        ` : ''}
-
-        <h2>Column Analysis</h2>
-        ${report.columns.map(col => `
-            <div class="column-card">
-                <h3>${col.name} <span class="badge ${col.dataType}">${col.dataType}</span></h3>
-                <table>
-                    <tr><td><strong>Count</strong></td><td>${col.count.toLocaleString()}</td></tr>
-                    <tr><td><strong>Null</strong></td><td>${col.nullCount} (${col.nullPercentage}%)</td></tr>
-                    <tr><td><strong>Unique</strong></td><td>${col.uniqueCount} (${col.uniquePercentage}%)</td></tr>
-                    ${col.dataType === 'numeric' ? `
-                        <tr><td><strong>Mean</strong></td><td>${col.mean}</td></tr>
-                        <tr><td><strong>Median</strong></td><td>${col.median}</td></tr>
-                        <tr><td><strong>Std Dev</strong></td><td>${col.stdDev}</td></tr>
-                        <tr><td><strong>Min / Max</strong></td><td>${col.min} / ${col.max}</td></tr>
-                        <tr><td><strong>Q1 / Q3</strong></td><td>${col.q1} / ${col.q3}</td></tr>
-                    ` : ''}
-                </table>
-            </div>
-        `).join('')}
-
-        ${report.correlationPairs && report.correlationPairs.length > 0 ? `
-            <h2>Correlation Analysis</h2>
-            <table>
-                <tr><th>Column 1</th><th>Column 2</th><th>Correlation</th></tr>
-                ${report.correlationPairs.map(pair => `
-                    <tr><td>${pair.col1}</td><td>${pair.col2}</td><td>${pair.correlation}</td></tr>
-                `).join('')}
-            </table>
-        ` : ''}
-
-        ${report.visualizationRecommendations.length > 0 ? `
-            <h2>Visualization Recommendations</h2>
-            <table>
-                <tr><th>Column</th><th>Chart Type</th><th>Reason</th></tr>
-                ${report.visualizationRecommendations.map(rec => `
-                    <tr><td>${rec.column}</td><td>${rec.chartType}</td><td>${rec.reason}</td></tr>
-                `).join('')}
-            </table>
-        ` : ''}
-
-        ${report.insights.length > 0 ? `
-            <h2>Key Insights</h2>
-            ${report.insights.map(insight => `<div class="insight">${insight}</div>`).join('')}
-        ` : ''}
-
-        <footer>
-            Generated by <strong>the analyze-data skill</strong>
-        </footer>
-    </div>
-</body>
-</html>`;
-}
-
-// ============================================================================