e_ai_summarize 0.1.22

A Rust code analyzer that summarizes functionality, crate usage, safety, and file operations.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use clap::Parser;
use std::path::Path;
use tokio;
#[derive(Parser, Debug)]
pub struct GenScriptArgs {
    /// Crate location to start the upward search for Cargo.toml.
    #[arg(short, long, value_hint = clap::ValueHint::DirPath)]
    pub crate_location: String,
    /// Language for the generated script ("py", "rs", or "summarize").
    #[arg(short = 'l', long = "language", default_value = "rs")]
    pub language: String,
    /// Process only the 'src' subfolder.
    #[arg(long = "src-only")]
    pub src_only: bool,
    /// Model to use when summarizing (only used if language is "summarize").
    #[arg(short = 'm', long = "model", default_value = "gpt-4o-mini")]
    pub model: String,
    /// Enable streaming mode (only used if language is "summarize").
    #[arg(short = 's', long = "streaming")]
    pub streaming: bool,
    /// System prompt to use when summarizing (only used if language is "summarize").
    #[arg(
        short = 'S',
        long = "system",
        default_value = "You are a Rust code analyst."
    )]
    pub system: String,
}

pub fn run(args: GenScriptArgs) -> anyhow::Result<()> {
    match args.language.to_lowercase().as_str() {
        "py" => {
            crate::crate_recreator_py::recreate_crate_py(
                Path::new(&args.crate_location),
                args.src_only,
            )?;
        }
        "rs" => {
            crate::crate_recreator_rs::recreate_crate_rs(
                Path::new(&args.crate_location),
                args.src_only,
            )?;
        }
        "summarize" => {
            // For summarization, create a ChatSession with the provided parameters.
            let rt = tokio::runtime::Runtime::new()?;
            rt.block_on(async {
                let mut session =
                    crate::summarizer::ChatSession::new(&args.system, &args.model, args.streaming);
                let summary =
                    crate::summarizer::summarize_a_crate(&args.crate_location, &mut session)
                        .await?;
                println!("Summary:\n{}\n", summary);
                anyhow::Ok(())
            })?;
        }
        other => {
            eprintln!(
                "Unknown language option: {}. Supported options: py, rs, summarize",
                other
            );
        }
    }
    Ok(())
}
pub async fn run_async(args: GenScriptArgs) -> anyhow::Result<()> {
    match args.language.to_lowercase().as_str() {
        "py" => {
            // These functions are synchronous, so we call them directly.
            crate::crate_recreator_py::recreate_crate_py(
                Path::new(&args.crate_location),
                args.src_only,
            )?;
            Ok(())
        }
        "rs" => {
            crate::crate_recreator_rs::recreate_crate_rs(
                Path::new(&args.crate_location),
                args.src_only,
            )?;
            Ok(())
        }
        "summarize" => {
            // Run the async summarization directly.
            let mut session =
                crate::summarizer::ChatSession::new(&args.system, &args.model, args.streaming);
            let summary =
                crate::summarizer::summarize_a_crate(&args.crate_location, &mut session).await?;
            println!("Summary:\n{}\n", summary);
            Ok(())
        }
        other => {
            eprintln!(
                "Unknown language option: {}. Supported options: py, rs, summarize",
                other
            );
            Ok(())
        }
    }
}

// use clap::Parser;
// use std::path::Path;
// use crate::summarizer::summarize_a_crate;

// #[derive(Parser, Debug)]
// pub struct GenScriptArgs {
//     /// Crate location to start the upward search for Cargo.toml.
//     #[arg(short, long, value_hint = clap::ValueHint::DirPath)]
//     pub crate_location: String,
//     /// Language for the generated script ("py" or "rs" or "summarize").
//     #[arg(short = 'l', long = "language", default_value = "rs")]
//     pub language: String,
//     /// Process only the 'src' subfolder.
//     #[arg(long = "src-only")]
//     pub src_only: bool,
// }

// pub fn run(args: GenScriptArgs) -> anyhow::Result<()> {
//     match args.language.to_lowercase().as_str() {
//         "py" => {
//             crate::crate_recreator_py::recreate_crate_py(Path::new(&args.crate_location), args.src_only)?;
//         }
//         "rs" => {
//             crate::crate_recreator_rs::recreate_crate_rs(Path::new(&args.crate_location), args.src_only)?;
//         }
//         "summarize" => {
//             // Fallback: summarize the crate.
//             let rt = tokio::runtime::Runtime::new()?;
//             rt.block_on(async {
//                 let (summary, _) =
//                     summarize_a_crate(&args.crate_location).await?;
//                 println!("Summary:\n{}\n", summary);
//                 Ok(())
//             })?;
//         }
//         other => {
//             eprintln!("Unknown language option: {}. Supported options: py, rs, summarize", other);
//         }
//     }
//     Ok(())
// }