Crate ai_context_gen

Expand description

§AI Context Generator - Rust Library

A Rust library for generating structured context from code repositories, specifically designed for LLMs and AI agents. This library provides both simple convenience functions and advanced APIs for fine-grained control.

§When to Use This Library

Integrate context generation into your Rust applications
Build custom analysis workflows
Create automated documentation systems
Develop AI-powered developer tools

For standalone command-line usage, consider using the CLI tool instead.

§Features

🔍 Complete Scanning: Analyzes all .rs and .md files in repositories
🌳 AST Analysis: Extracts structures, functions, enums and implementations
📊 Token Control: Respects limits and prioritizes important content
📁 Project Structure: Generates file tree visualizations
📖 Documentation: Includes markdown files and code documentation
⚡ Async Processing: Non-blocking, high-performance analysis

§Quick Start

§Simple Usage

use ai_context_gen::generate_context;
use std::path::PathBuf;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Generate context for current directory
    generate_context(PathBuf::from("."), "context.md".to_string()).await?;
    println!("Context generated successfully!");
    Ok(())
}

§Advanced Usage with Configuration

use ai_context_gen::{Config, ContextGenerator, RepositoryScanner};
use std::path::PathBuf;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Custom configuration
    let config = Config {
        repo_path: PathBuf::from("./my-project"),
        max_tokens: 100000,
        output_file: "detailed_context.md".to_string(),
        include_hidden: true,
        include_deps: true,
    };

    // Step-by-step process for more control
    let scanner = RepositoryScanner::new(config.clone());
    let scan_result = scanner.scan().await?;
     
    println!("Found {} files", scan_result.files.len());
     
    let generator = ContextGenerator::new(config);
    generator.generate_context(scan_result).await?;
     
    Ok(())
}

§Using the Configuration Function

use ai_context_gen::{Config, generate_context_with_config};
use std::path::PathBuf;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let config = Config {
        repo_path: PathBuf::from("/path/to/analyze"),
        max_tokens: 75000,
        output_file: "analysis.md".to_string(),
        include_hidden: false,
        include_deps: true,
    };

    generate_context_with_config(config).await?;
    Ok(())
}

§API Overview

generate_context: Simple function for basic use cases
generate_context_with_config: Function with custom configuration
Config: Configuration structure for all options
RepositoryScanner: File scanning and discovery
ContextGenerator: Context generation with priorities
RustParser: Rust code AST analysis

§Integration Patterns

§Web Applications

use ai_context_gen::{Config, generate_context_with_config};
use std::path::PathBuf;

async fn analyze_repo_endpoint(repo_path: String) -> Result<String, Box<dyn std::error::Error>> {
    let config = Config {
        repo_path: PathBuf::from(repo_path),
        max_tokens: 50000,
        output_file: format!("/tmp/analysis_{}.md", chrono::Utc::now().timestamp()),
        include_hidden: false,
        include_deps: false,
    };
     
    generate_context_with_config(config.clone()).await?;
    Ok(config.output_file)
}

§Custom Workflows

use ai_context_gen::{Config, RepositoryScanner, ContextGenerator};
use std::path::PathBuf;

async fn custom_analysis_workflow(repo_path: PathBuf) -> anyhow::Result<()> {
    let config = Config {
        repo_path: repo_path.clone(),
        max_tokens: 100000,
        output_file: "temp_analysis.md".to_string(),
        include_hidden: true,
        include_deps: true,
    };

    // Scan first
    let scanner = RepositoryScanner::new(config.clone());
    let scan_result = scanner.scan().await?;
     
    // Custom filtering or processing here
    println!("Found {} Rust files", scan_result.files.iter()
        .filter(|f| matches!(f.file_type, ai_context_gen::FileType::Rust))
        .count());
     
    // Generate context
    let generator = ContextGenerator::new(config);
    generator.generate_context(scan_result).await?;
     
    Ok(())
}

Re-exports§

pub use config::Config;
pub use generator::ContextGenerator;
pub use parser::EnumInfo;
pub use parser::FunctionInfo;
pub use parser::ImplInfo;
pub use parser::RustAnalysis;
pub use parser::RustParser;
pub use parser::StructInfo;
pub use scanner::FileInfo;
pub use scanner::FileType;
pub use scanner::RepositoryScanner;
pub use scanner::ScanResult;
pub use token_counter::ContentPrioritizer;
pub use token_counter::ContentSection;
pub use token_counter::TokenCounter;

Modules§

config: Configuration module for the AI Context Generator.
generator: Context generation module for the AI Context Generator.
parser: Rust AST parsing module for the AI Context Generator.
scanner: Repository scanning module for the AI Context Generator.
token_counter: Token counting and content prioritization module.

Functions§

generate_context: Generates repository context with default configuration
generate_context_with_config: Generates repository context with custom configuration

Type Aliases§

Result: Default Result type used by the library

Crate ai_context_genCopy item path