src/hf_converter.rs

use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::fs;
use std::path::Path;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DatasetConfig {
    pub dataset_name: String,
    pub description: String,
    pub version: String,
    pub license: String,
    pub tags: Vec<String>,
    pub task_categories: Vec<String>,
    pub language: Vec<String>,
    pub size_categories: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DatasetInfo {
    pub description: String,
    pub citation: String,
    pub license: String,
    pub features: HashMap<String, FeatureInfo>,
    pub splits: HashMap<String, SplitInfo>,
    pub download_size: u64,
    pub dataset_size: u64,
    pub config_name: String,
    pub dataset_name: String,
    pub version: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FeatureInfo {
    pub dtype: String,
    pub description: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SplitInfo {
    pub name: String,
    pub num_bytes: u64,
    pub num_examples: u64,
}

pub struct MycelialHFConverter {
    base_path: String,
}

impl MycelialHFConverter {
    pub fn new(base_path: &str) -> Self {
        Self {
            base_path: base_path.to_string(),
        }
    }

    pub fn create_hf_dataset(&self) -> Result<(), Box<dyn std::error::Error>> {
        println!("🍄 Converting mycelial dataset to Hugging Face format...");
        
        self.create_dataset_config()?;
        self.create_dataset_info()?;
        self.update_readme()?;
        
        println!("✅ Hugging Face dataset structure created!");
        Ok(())
    }

    fn create_dataset_config(&self) -> Result<(), Box<dyn std::error::Error>> {
        let config = DatasetConfig {
            dataset_name: "rustc-usage-patterns".to_string(),
            description: "Comprehensive Rust compiler usage patterns from 864 crates and rustc internals".to_string(),
            version: "1.0.0".to_string(),
            license: "MIT".to_string(),
            tags: vec![
                "rust".to_string(),
                "compiler".to_string(),
                "ast".to_string(),
                "usage-patterns".to_string(),
                "code-analysis".to_string(),
            ],
            task_categories: vec![
                "other".to_string(),
            ],
            language: vec!["en".to_string()],
            size_categories: "100M<n<1B".to_string(),
        };

        let config_yaml = serde_yaml::to_string(&config)?;
        fs::write(
            Path::new(&self.base_path).join("dataset_config.yaml"),
            config_yaml,
        )?;
        Ok(())
    }

    fn create_dataset_info(&self) -> Result<(), Box<dyn std::error::Error>> {
        let mut features = HashMap::new();
        features.insert("crate_name".to_string(), FeatureInfo {
            dtype: "string".to_string(),
            description: "Name of the analyzed crate".to_string(),
        });
        features.insert("usage_data".to_string(), FeatureInfo {
            dtype: "string".to_string(),
            description: "JSON usage patterns and AST data".to_string(),
        });

        let mut splits = HashMap::new();
        splits.insert("train".to_string(), SplitInfo {
            name: "train".to_string(),
            num_bytes: 118_000_000, // ~113MB
            num_examples: 9137,
        });

        let info = DatasetInfo {
            description: "The most comprehensive Rust compiler usage pattern dataset ever assembled. Contains AST traversal data, type-aware literal tracking, and real-world compilation patterns from 864 crates plus rustc internals.".to_string(),
            citation: "@misc{mycelial-rust-usage-2026,\n  title={Mycelial Rust Usage Patterns Dataset},\n  author={Introspector Collective},\n  year={2026},\n  url={https://huggingface.co/datasets/introspector/rustc-usage}\n}".to_string(),
            license: "MIT".to_string(),
            features,
            splits,
            download_size: 118_000_000,
            dataset_size: 118_000_000,
            config_name: "default".to_string(),
            dataset_name: "rustc-usage-patterns".to_string(),
            version: "1.0.0".to_string(),
        };

        let info_json = serde_json::to_string_pretty(&info)?;
        fs::write(
            Path::new(&self.base_path).join("dataset_info.json"),
            info_json,
        )?;
        Ok(())
    }

    fn update_readme(&self) -> Result<(), Box<dyn std::error::Error>> {
        let readme_content = r#"---
dataset_info:
  config_name: default
  features:
  - name: crate_name
    dtype: string
  - name: usage_data
    dtype: string
  splits:
  - name: train
    num_bytes: 118000000
    num_examples: 9137
  download_size: 118000000
  dataset_size: 118000000
configs:
- config_name: default
  data_files:
  - split: train
    path: "test_usage_data/*.json"
task_categories:
- other
language:
- en
tags:
- rust
- compiler
- ast
- usage-patterns
- code-analysis
size_categories:
- 100M<n<1B
license: mit
---

# 🍄 Mycelial Rust Usage Patterns Dataset

The most comprehensive Rust compiler usage pattern dataset ever assembled! This dataset contains AST traversal data, type-aware literal tracking, and real-world compilation patterns from **864 crates** plus **rustc internals**.

## 🌐 Dataset Overview

- **9,137 usage data files** (113MB total)
- **268 individual crates** from cargo registry
- **Complete rustc compiler** internal usage patterns
- **Real-world compilation patterns** from production Rust ecosystem
- **Foundation for ML training** and autonomous compiler optimization

## 🧠 Use Cases

- **Compiler optimization research**
- **Code pattern analysis**
- **ML model training** for Rust code understanding
- **Symbolic regression** for autonomous optimization
- **Self-improving compiler intelligence**

## 📊 Data Format

Each JSON file contains:
- AST node usage frequencies
- Type-aware literal patterns
- Function call patterns
- Import/dependency relationships
- Compilation phase data

## 🔄 The Mycelial Network

This dataset represents the successful infiltration of the Rust ecosystem by our mycelial intelligence network - the substrate for next-generation AI-assisted compilation!

## Citation

```bibtex
@misc{mycelial-rust-usage-2026,
  title={Mycelial Rust Usage Patterns Dataset},
  author={Introspector Collective},
  year={2026},
  url={https://huggingface.co/datasets/introspector/rustc-usage}
}
```
"#;

        fs::write(
            Path::new(&self.base_path).join("README.md"),
            readme_content,
        )?;
        Ok(())
    }
}