@hasna/skills 0.1.61 → 0.1.63

package/skills/ad-creative-pack/SKILL.md

@@ -1,55 +0,0 @@
----
-name: ad-creative-pack
-description: Generate paid-ad copy, creative concepts, image prompts, audience angles, and test matrices.
-kind: instruction
----
-
-# Ad Creative Pack
-
-Generate a paid-ad launch package for Meta, Google, and LinkedIn.
-
-## Requirements
-
-None. This is an instruction skill: it is prose an agent follows, so it needs no
-credentials, no network access, and no local runtime.
-
-## Usage
-
-Ask an agent for the deliverables below and give it the inputs. Reading this file
-IS the invocation; `skills run` refuses instruction skills on purpose.
-
-## Inputs
-
-| Input | Description | Default |
-|--------|-------------|---------|
-| `product` | Product, service, or campaign brief. Positional text also works. | required |
-| `audience` | Target buyer or segment. | software teams |
-| `offer` | Campaign promise or offer. | derived from product |
-| `goal` | Conversion goal. | book demos |
-| `platforms` | Comma-separated platforms. | Meta, Google, LinkedIn |
-| `tone` | `direct`, `premium`, `friendly`, or `technical`. | direct |
-
-## Deliverables
-
-- `platform-copy.md`
-- `ad-copy.json`
-- `creative-concepts.md`
-- `image-prompts.md`
-- `audience-angles.csv`
-- `test-matrix.csv`
-- `launch-checklist.md`
-- `manifest.json`
-
-## Method
-
-1. Restate the offer, audience and platform mix in one line, and name the single
-   conversion action every asset drives toward.
-2. Draft 3-5 distinct creative concepts. Each needs a different *angle* (pain,
-   aspiration, proof, novelty, objection), not a different adjective.
-3. For each platform, write copy to that platform's real limits — headline and
-   primary text lengths differ, so do not reuse one block everywhere.
-4. Write image prompts as briefs a designer or an image model could act on:
-   subject, composition, mood, colour, text placement.
-5. Build the test matrix so exactly one variable changes per row; a matrix that
-   varies two things at once cannot attribute a win.
-6. Close with a launch checklist covering tracking, naming, and budget split.

package/skills/ad-creative-pack/package.json

@@ -1,10 +0,0 @@
-{
-  "name": "ad-creative-pack",
-  "version": "0.1.0",
-  "private": true,
-  "description": "Hosted premium paid ad creative artifact generator",
-  "type": "module",
-  "skills": {
-    "kind": "instruction"
-  }
-}

package/skills/analyze-data/CLAUDE.md

@@ -1,16 +0,0 @@
-# analyze-data
-
-Data science insights for CSV and JSON.
-
-## Development
-
-- Runtime: Bun
-- Use `bun install` to install dependencies
-- Use `bun run dev` to run in development
-- Use `bun run build` to build for production
-
-## Structure
-
-- `src/` - Source code
-- `bin/cli.ts` - CLI entry point using Commander.js
-- `SKILL.md` - Skill definition and prompts

package/skills/analyze-data/SKILL.md

@@ -1,112 +0,0 @@
----
-name: analyze-data
-version: 0.1.0
-description: Instant data science insights for CSV and JSON files with statistical summaries, quality audits, and trend detection
-author: Hasna
-category: Data & Analytics
-tags:
-  - data
-  - analytics
-  - statistics
-  - csv
-  - json
-  - insights
-  - quality-assurance
-credits: 5
----
-
-# Analyze Data
-
-Instant data science insights for your CSV and JSON files. Automatically generates comprehensive reports including statistical summaries, data quality audits, correlation matrices, and trend detection without sending your data to external APIs.
-
-> **This is a CLI skill.** It requires the `skills` CLI to execute. Install it with `npm install -g @hasna/skills`, then run the commands below.
-
-## Features
-
-- **Statistical Profiling**: Calculates mean, median, mode, standard deviation, quartiles, and custom percentiles for all numeric columns.
-- **Data Quality Audit**: Detects missing values, duplicates, mixed data types, and outliers to assess dataset health.
-- **Correlation Discovery**: Identifies relationships between variables using Pearson correlation coefficients.
-- **Trend Detection**: Automatically spots time-series patterns, seasonality, and growth trends.
-- **Visualization Ready**: Recommends the best chart types (histograms, line charts, scatter plots) based on data distribution.
-- **Multi-Format Reports**: Exports findings as interactive HTML, structured JSON, or readable Markdown.
-- **Scalable**: Efficiently processes large files using stream processing and sampling options.
-
-## Usage
-
-```bash
-skills run analyze-data -- <file-path> [options]
-```
-
-## Options
-
-| Option          | Description                                                  | Default              |
-| --------------- | ------------------------------------------------------------ | -------------------- |
-| `--format`      | Output format: `markdown`, `json`, or `html`                 | `markdown`           |
-| `--output`      | Save report to file path                                     | (prints to console)  |
-| `--correlations`| Calculate correlation matrix for numeric columns             | `false`              |
-| `--outliers`    | Detect and report outliers using IQR method                  | `false`              |
-| `--trends`      | Analyze trends if time-series data is detected               | `false`              |
-| `--sample`      | Analyze only the first N rows (for large files)              | (all rows)           |
-| `--percentiles` | Custom percentiles to calculate (comma-separated)            | `25,50,75,90,95`     |
-| `--verbose`     | Show detailed processing logs                                | `false`              |
-
-## Examples
-
-### Quick Health Check
-```bash
-# Analyze a CSV file and print report to console
-skills run analyze-data -- sales-data.csv
-```
-
-### Deep Dive Analysis
-```bash
-# Full analysis with correlations, outliers, and HTML report
-skills run analyze-data -- dataset.csv \
-  --correlations \
-  --outliers \
-  --format html \
-  --output report.html
-```
-
-### Large File Sampling
-```bash
-# Quickly analyze the first 10,000 rows of a large dataset
-skills run analyze-data -- huge-log-file.json \
-  --sample 10000 \
-  --verbose
-```
-
-### JSON Export for Pipelines
-```bash
-# Generate JSON stats for downstream processing
-skills run analyze-data -- metrics.json \
-  --format json \
-  --output analysis.json
-```
-
-## Report Sections
-
-1.  **Dataset Overview**: File size, row/column counts, memory usage.
-2.  **Column Analysis**: Data types, unique values, null counts, and sample data.
-3.  **Statistical Summary**: Detailed metrics for numeric columns (mean, std dev, etc.).
-4.  **Data Quality**: Quality score (0-100), missing data summary, and duplicate detection.
-5.  **Correlations**: (Optional) Matrix of relationships between variables.
-6.  **Trends**: (Optional) Time-series patterns and anomalies.
-7.  **Visualization Recommendations**: Suggested charts for exploring the data.
-8.  **Key Insights**: Auto-generated observations about the dataset.
-
-## Supported Formats
-
-- **CSV**: Standard comma-separated, TSV, and custom delimiters.
-- **JSON**: Arrays of objects or objects containing data arrays.
-
-## Performance
-
-- **Small (<10MB)**: Instant analysis.
-- **Medium (10-100MB)**: 2-10 seconds.
-- **Large (>100MB)**: Use `--sample` for best performance.
-
-## Requirements
-
-- Bun runtime.
-- No external API keys required (runs locally).

package/skills/analyze-data/package.json

@@ -1,23 +0,0 @@
-{
-  "name": "analyze-data",
-  "version": "0.1.0",
-  "description": "Data science insights for CSV and JSON",
-  "type": "module",
-  "bin": {
-    "analyze-data": "./src/index.ts"
-  },
-  "scripts": {
-    "dev": "bun run src/index.ts",
-    "build": "bun build src/index.ts --outdir dist --target node",
-    "start": "bun run src/index.ts"
-  },
-  "dependencies": {},
-  "devDependencies": {
-    "@types/bun": "latest",
-    "typescript": "^5.7.0"
-  },
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org",
-    "access": "restricted"
-  }
-}

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,
-    }
-  };
-}