feat: adapt the newest struct (cloudwego#19)

Author: welkeyever

src/compress/compress.rs

@@ -8,90 +8,104 @@ use serde::{Deserialize, Serialize};
 
 use crate::compress::compress;
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Repository {
+    #[serde(rename = "ModName")]
+    mod_name: String,
+    #[serde(rename = "Packages")]
+    packages: HashMap<String, Package>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Package {
+    #[serde(rename = "Functions")]
+    functions: HashMap<String, Function>,
+    #[serde(rename = "Types")]
+    types: HashMap<String, Struct>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
 pub struct Function {
     #[serde(rename = "IsMethod")]
     is_method: bool,
-    #[serde(rename = "Name")]
-    name: String,
     #[serde(rename = "PkgPath")]
     pkg_path: String,
-    #[serde(rename = "FilePath")]
-    file_path: String,
+    #[serde(rename = "Name")]
+    name: String,
     #[serde(rename = "Content")]
     content: String,
     #[serde(rename = "AssociatedStruct")]
-    associated_struct: Option<Box<Struct>>,
+    associated_struct: Option<Identity>,
     #[serde(rename = "InternalFunctionCalls")]
-    internal_function_calls: Option<HashMap<String, Box<Function>>>,
+    internal_function_calls: Option<HashMap<String, Identity>>,
     #[serde(rename = "ThirdPartyFunctionCalls")]
-    third_party_function_calls: Option<HashMap<String, ThirdPartyIdentity>>,
+    third_party_function_calls: Option<HashMap<String, Identity>>,
     #[serde(rename = "InternalMethodCalls")]
-    internal_method_calls: Option<HashMap<String, Box<Function>>>,
+    internal_method_calls: Option<HashMap<String, Identity>>,
     #[serde(rename = "ThirdPartyMethodCalls")]
-    third_party_method_calls: Option<HashMap<String, ThirdPartyIdentity>>,
-
-    compress_info: Option<String>,
+    third_party_method_calls: Option<HashMap<String, Identity>>,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-pub struct ThirdPartyIdentity {
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Struct {
+    #[serde(rename = "TypeKind")]
+    type_kind: u8,
     #[serde(rename = "PkgPath")]
     pkg_path: String,
-    #[serde(rename = "Identity")]
-    identity: String,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Struct {
     #[serde(rename = "Name")]
     name: String,
-    #[serde(rename = "PkgPath")]
-    pkg_path: String,
     #[serde(rename = "Content")]
     content: String,
-    #[serde(rename = "InternalStruct")]
-    internal_structs: Option<HashMap<String, Box<Struct>>>,
-    #[serde(rename = "ThirdPartyChildren")]
-    third_party_children: Option<HashMap<String, ThirdPartyIdentity>>,
+    #[serde(rename = "SubStruct")]
+    sub_struct: Option<HashMap<String, Identity>>,
+    #[serde(rename = "InlineStruct")]
+    inline_struct: Option<HashMap<String, Identity>>,
     #[serde(rename = "Methods")]
-    methods: Option<HashMap<String, Box<Function>>>,
+    methods: Option<HashMap<String, Identity>>,
 }
 
-pub fn from_json(json: &str) -> Result<Function, Box<dyn Error>> {
-    let f: Function = serde_json::from_str(json)?;
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Identity {
+    #[serde(rename = "PkgPath")]
+    pkg_path: String,
+    #[serde(rename = "Name")]
+    name: String,
+}
+
+pub fn from_json(json: &str) -> Result<Repository, Box<dyn Error>> {
+    let f: Repository = serde_json::from_str(json)?;
     Ok(f)
 }
 
 
 #[async_recursion]
 pub async fn cascade_compress_function(func: &mut Function) {
-    if func.internal_function_calls.is_none() {
-        llm_compress(func);
-        return;
-    }
-
-    for (_, mut f) in func.internal_function_calls.as_mut().unwrap() {
-        if f.compress_info.is_none() {
-            cascade_compress_function(&mut f).await
-        }
-    }
-
-    llm_compress(func).await;
-
-    return;
+    // if func.internal_function_calls.is_none() {
+    //     llm_compress(func);
+    //     return;
+    // }
+    //
+    // for (_, mut f) in func.internal_function_calls.as_mut().unwrap() {
+    //     if f.compress_info.is_none() {
+    //         cascade_compress_function(&mut f).await
+    //     }
+    // }
+    //
+    // llm_compress(func).await;
+    //
+    // return;
 }
 
 async fn llm_compress(func: &mut Function) {
-    let mut map = HashMap::new(); // 创建一个空的 HashMap
-    if func.internal_function_calls.is_some() {
-        for (k, ff) in func.internal_function_calls.as_ref().unwrap() {
-            map.insert(k.clone(), ff.compress_info.clone().unwrap());
-        }
-    }
-
-    let compress_data = _ollama_compress(func.content.clone(), map).await;
-    func.compress_info = Option::from(compress_data);
+    // let mut map = HashMap::new(); // 创建一个空的 HashMap
+    // if func.internal_function_calls.is_some() {
+    //     for (k, ff) in func.internal_function_calls.as_ref().unwrap() {
+    //         map.insert(k.clone(), ff.compress_info.clone().unwrap());
+    //     }
+    // }
+    //
+    // let compress_data = _ollama_compress(func.content.clone(), map).await;
+    // func.compress_info = Option::from(compress_data);
 }
 
 pub async fn _ollama_compress(func: String, ctx: HashMap<String, String>) -> String {