herolib-code 0.3.0

# herolib-code

Code analysis and parsing utilities for Rust source files.

## Overview

This crate provides tools for analyzing Rust codebases, extracting structured information about code elements such as:

- **Enumerators**: With variants, documentation, and attributes
- **Structs**: With fields, documentation, and attributes  
- **Methods**: As implemented on structs, with parameters and documentation
- **AI Analysis** (optional): AI-powered code analysis and documentation generation

## Installation

Add to your `Cargo.toml`:

```toml
[dependencies]
herolib-code = "0.1.0"

# With AI analysis support
herolib-code = { version = "0.1.0", features = ["ai"] }
```

## Usage

### Parse a Directory

```rust
use herolib_code::parser::CodebaseParser;

let parser = CodebaseParser::new();
let codebase = parser.parse_directory("./src").unwrap();

// Iterate over structs
for struct_info in &codebase.structs {
    println!("Struct: {}", struct_info.name);
    
    if let Some(doc) = &struct_info.doc_comment {
        println!("  Doc: {}", doc);
    }
    
    for field in &struct_info.fields {
        if let Some(name) = &field.name {
            println!("  Field: {} ({})", name, field.ty);
        }
    }
    
    for method in &struct_info.methods {
        println!("  Method: {}", method.name);
    }
}

// Iterate over enums
for enum_info in &codebase.enums {
    println!("Enum: {}", enum_info.name);
    
    for variant in &enum_info.variants {
        println!("  Variant: {}", variant.name);
    }
}
```

### Parse a Single File

```rust
use herolib_code::parser::CodebaseParser;

let parser = CodebaseParser::new();
let codebase = parser.parse_file("./src/lib.rs").unwrap();
```

### Parse Source Code String

```rust
use herolib_code::parser::CodebaseParser;

let source = r#"
/// A point in 2D space.
pub struct Point {
    /// X coordinate.
    pub x: f64,
    /// Y coordinate.
    pub y: f64,
}

impl Point {
    /// Creates a new point.
    pub fn new(x: f64, y: f64) -> Self {
        Self { x, y }
    }
}
"#;

let parser = CodebaseParser::new();
let codebase = parser.parse_source(source, "point.rs").unwrap();
```

### Configuration

```rust
use herolib_code::parser::{CodebaseParser, WalkerConfig};

// Configure directory walking
let walker_config = WalkerConfig::new()
    .skip_dir("tests")
    .skip_dir("examples")
    .max_depth(Some(5));

// Configure parsing
let parser = CodebaseParser::new()
    .walker_config(walker_config)
    .include_private(false)  // Only public items
    .continue_on_error(true); // Skip files with syntax errors
```

## Data Structures

### CodeBase

The main container for parsed code:

```rust
pub struct CodeBase {
    pub enums: Vec<EnumInfo>,
    pub structs: Vec<StructInfo>,
    pub files: Vec<FileInfo>,
}
```

### StructInfo

Information about a parsed struct:

```rust
pub struct StructInfo {
    pub name: String,
    pub doc_comment: Option<String>,
    pub file_path: String,
    pub line_number: usize,
    pub visibility: Visibility,
    pub generics: Vec<String>,
    pub derives: Vec<String>,
    pub attributes: Vec<String>,
    pub fields: Vec<FieldInfo>,
    pub methods: Vec<MethodInfo>,
}
```

### EnumInfo

Information about a parsed enum:

```rust
pub struct EnumInfo {
    pub name: String,
    pub doc_comment: Option<String>,
    pub file_path: String,
    pub line_number: usize,
    pub visibility: Visibility,
    pub generics: Vec<String>,
    pub derives: Vec<String>,
    pub attributes: Vec<String>,
    pub variants: Vec<EnumVariant>,
}
```

### MethodInfo

Information about a method:

```rust
pub struct MethodInfo {
    pub name: String,
    pub doc_comment: Option<String>,
    pub file_path: String,
    pub line_number: usize,
    pub visibility: Visibility,
    pub is_async: bool,
    pub is_const: bool,
    pub is_unsafe: bool,
    pub generics: Vec<String>,
    pub parameters: Vec<ParameterInfo>,
    pub return_type: Option<String>,
    pub receiver: Option<Receiver>,
}
```

## AI-Powered Analysis

Enable the `ai` feature for AI-powered code analysis:

```rust
use herolib_code::{CodeAnalyzer, CodebaseParser};

// Parse the codebase
let parser = CodebaseParser::new();
let codebase = parser.parse_directory("./src").unwrap();

// Create analyzer (uses environment variables for API keys)
let analyzer = CodeAnalyzer::from_env();

// Generate documentation for a struct
if let Some(struct_info) = codebase.structs.first() {
    let docs = analyzer.document_struct(struct_info).unwrap();
    println!("{}", docs);
}

// Summarize the entire codebase
let summary = analyzer.summarize_codebase(&codebase).unwrap();
println!("{}", summary);
```

Required environment variables (at least one):
- `GROQ_API_KEY`
- `OPENROUTER_API_KEY`
- `SAMBANOVA_API_KEY`

## Building

```bash
./build.sh
```

## Testing

```bash
./run.sh
```

## License

Apache-2.0