reproto 0.0.7__py3-none-any.whl → 0.0.8__py3-none-any.whl

.git/COMMIT_EDITMSG

@@ -1,29 +1 @@
-feat: 重构字段类型识别系统，实现基于Java源码的精确类型解析
-
-🎯 **核心改进**
-- 删除google_protobuf_types.py，采用基于Java源码的动态类型识别
-- 实现枚举类型的精确识别（Access、Gender、Badge等）
-- 修复map类型和repeated类型的处理逻辑
-- 增强错误处理和统计报告
-
-🔧 **技术修复**
-- JavaSourceAnalyzer: 增强setter方法分析，支持枚举类型推断
-- InfoDecoder: 重构字段类型转换，优先使用Java源码信息
-- ProtoReconstructor: 添加枚举解析器，完善依赖追踪
-- ProtoGenerator: 修复基础类型判断，避免错误导入
-
-🚀 **功能增强**
-- 支持Internal.ProtobufList<T> -> repeated T 转换
-- 支持MapFieldLite<K,V> -> map<k,v> 转换
-- 支持Internal.IntList -> repeated enum 转换
-- 增强包名匹配算法，避免第三方库误匹配
-
-📊 **统计改进**
-- 详细的成功/失败/跳过统计
-- 错误原因分类和报告
-- 支持verbose模式的详细日志
-
-🐛 **Bug修复**
-- 修复基础类型被误认为自定义类型的问题
-- 修复map类型repeated规则错误
-- 修复Unity3D等第三方库误匹配问题
+feat(build): update version

.git/logs/HEAD

@@ -2,3 +2,5 @@
 2e11d561668286f3d6d48f399ffab1943a5cdcb2 f22bfffda9fb6a7f37bed04b7c40c9466ef09454 iyue <ys1231@126.com> 1750925875 +0800	commit: feat: 完善Protobuf类型推断系统，支持map和未知类型处理
 f22bfffda9fb6a7f37bed04b7c40c9466ef09454 e82f42ea26b8bf4f0bc92c0648ac8f190f14226d iyue <ys1231@126.com> 1750927650 +0800	commit: feat: rename reproto
 e82f42ea26b8bf4f0bc92c0648ac8f190f14226d 9ae313cdf64cd82416c1238eb493e6396f799f12 iyue <ys1231@126.com> 1750942828 +0800	commit: feat: 重构字段类型识别系统，实现基于Java源码的精确类型解析
+9ae313cdf64cd82416c1238eb493e6396f799f12 4d6d457bfabc4af842e5ddc2d56eb059d5dfdc9d iyue <ys1231@126.com> 1750946357 +0800	commit: feat: 优化proto生成性能和字段排序
+4d6d457bfabc4af842e5ddc2d56eb059d5dfdc9d fce15b9dbffd9f37b1f2d46944ee2d0394df6565 iyue <ys1231@126.com> 1750946542 +0800	commit: feat(build): update version

.git/logs/refs/heads/iyue

@@ -2,3 +2,5 @@
 2e11d561668286f3d6d48f399ffab1943a5cdcb2 f22bfffda9fb6a7f37bed04b7c40c9466ef09454 iyue <ys1231@126.com> 1750925875 +0800	commit: feat: 完善Protobuf类型推断系统，支持map和未知类型处理
 f22bfffda9fb6a7f37bed04b7c40c9466ef09454 e82f42ea26b8bf4f0bc92c0648ac8f190f14226d iyue <ys1231@126.com> 1750927650 +0800	commit: feat: rename reproto
 e82f42ea26b8bf4f0bc92c0648ac8f190f14226d 9ae313cdf64cd82416c1238eb493e6396f799f12 iyue <ys1231@126.com> 1750942828 +0800	commit: feat: 重构字段类型识别系统，实现基于Java源码的精确类型解析
+9ae313cdf64cd82416c1238eb493e6396f799f12 4d6d457bfabc4af842e5ddc2d56eb059d5dfdc9d iyue <ys1231@126.com> 1750946357 +0800	commit: feat: 优化proto生成性能和字段排序
+4d6d457bfabc4af842e5ddc2d56eb059d5dfdc9d fce15b9dbffd9f37b1f2d46944ee2d0394df6565 iyue <ys1231@126.com> 1750946542 +0800	commit: feat(build): update version

.git/logs/refs/remotes/gitlab/iyue

@@ -1,3 +1,5 @@
 0000000000000000000000000000000000000000 f22bfffda9fb6a7f37bed04b7c40c9466ef09454 iyue <ys1231@126.com> 1750926057 +0800	update by push
 f22bfffda9fb6a7f37bed04b7c40c9466ef09454 e82f42ea26b8bf4f0bc92c0648ac8f190f14226d iyue <ys1231@126.com> 1750927662 +0800	update by push
 e82f42ea26b8bf4f0bc92c0648ac8f190f14226d 9ae313cdf64cd82416c1238eb493e6396f799f12 iyue <ys1231@126.com> 1750942950 +0800	update by push
+9ae313cdf64cd82416c1238eb493e6396f799f12 4d6d457bfabc4af842e5ddc2d56eb059d5dfdc9d iyue <ys1231@126.com> 1750946407 +0800	update by push
+4d6d457bfabc4af842e5ddc2d56eb059d5dfdc9d fce15b9dbffd9f37b1f2d46944ee2d0394df6565 iyue <ys1231@126.com> 1750946551 +0800	update by push

.git/logs/refs/remotes/origin/iyue

@@ -1,3 +1,5 @@
 2e11d561668286f3d6d48f399ffab1943a5cdcb2 f22bfffda9fb6a7f37bed04b7c40c9466ef09454 iyue <ys1231@126.com> 1750925918 +0800	update by push
 f22bfffda9fb6a7f37bed04b7c40c9466ef09454 e82f42ea26b8bf4f0bc92c0648ac8f190f14226d iyue <ys1231@126.com> 1750927669 +0800	update by push
 e82f42ea26b8bf4f0bc92c0648ac8f190f14226d 9ae313cdf64cd82416c1238eb493e6396f799f12 iyue <ys1231@126.com> 1750942915 +0800	update by push
+9ae313cdf64cd82416c1238eb493e6396f799f12 4d6d457bfabc4af842e5ddc2d56eb059d5dfdc9d iyue <ys1231@126.com> 1750946393 +0800	update by push
+4d6d457bfabc4af842e5ddc2d56eb059d5dfdc9d fce15b9dbffd9f37b1f2d46944ee2d0394df6565 iyue <ys1231@126.com> 1750946560 +0800	update by push

.git/objects/fc/e15b9dbffd9f37b1f2d46944ee2d0394df6565

@@ -0,0 +1,2 @@
+x
��[
+�0@Q����T�k�FD�J23��}ЦBwo�����a�Xӝ�"	m�l0�$E*cpB1Fr숄�t��Nj΋�

.git/refs/heads/iyue

@@ -1 +1 @@
-9ae313cdf64cd82416c1238eb493e6396f799f12
+fce15b9dbffd9f37b1f2d46944ee2d0394df6565

.git/refs/remotes/gitlab/iyue

@@ -1 +1 @@
-9ae313cdf64cd82416c1238eb493e6396f799f12
+fce15b9dbffd9f37b1f2d46944ee2d0394df6565

.git/refs/remotes/origin/iyue

@@ -1 +1 @@
-9ae313cdf64cd82416c1238eb493e6396f799f12
+fce15b9dbffd9f37b1f2d46944ee2d0394df6565

core/reconstructor.py

@@ -31,6 +31,9 @@ class JavaSourceAnalyzer:
         self._current_class_name = None
         # 初始化JavaParser用于字段类型解析
         self.java_parser = JavaParser()
+        # 使用文件缓存系统优化I/O性能
+        from utils.file_cache import get_file_cache
+        self.file_cache = get_file_cache()
     
     def set_current_class(self, class_name: str):
         """设置当前分析的类"""
@@ -295,19 +298,21 @@ class JavaSourceAnalyzer:
         return None
     
     def _load_class_content(self, class_name: str) -> Optional[str]:
-        """加载类的源码内容"""
+        """加载类的源码内容（使用缓存优化）"""
         try:
             # 标准路径：com.example.Model -> com/example/Model.java
             file_path = class_name.replace('.', '/') + '.java'
             full_path = self.sources_dir / file_path
             
-            if full_path.exists():
-                return full_path.read_text(encoding='utf-8')
+            # 使用缓存系统获取文件内容
+            content = self.file_cache.get_content(full_path)
+            if content:
+                return content
             
             # 备选方案：按简单类名搜索
             simple_name = class_name.split('.')[-1]
             for java_file in self.sources_dir.rglob(f"{simple_name}.java"):
-                return java_file.read_text(encoding='utf-8')
+                return self.file_cache.get_content(java_file)
             
             return None
         except Exception:
@@ -346,6 +351,10 @@ class ProtoReconstructor:
         self.java_source_analyzer = JavaSourceAnalyzer(sources_dir)
         self.info_decoder.java_source_analyzer = self.java_source_analyzer
         
+        # 初始化类型索引（延迟加载）
+        from utils.type_index import get_type_index
+        self.type_index = get_type_index(sources_dir)
+        
         # 任务调度状态
         self.processed_classes: Set[str] = set()  # 已处理的类
         self.pending_classes: deque = deque()     # 待处理的类队列
@@ -383,7 +392,15 @@ class ProtoReconstructor:
         # 4. 生成proto文件
         self._generate_all_proto_files()
         
-        # 5. 返回统计信息
+        # 5. 输出性能统计信息
+        from utils.file_cache import get_file_cache
+        file_cache = get_file_cache()
+        file_cache.print_stats()
+        
+        # 输出类型索引统计
+        self.type_index.print_stats()
+        
+        # 6. 返回统计信息
         # 报告未知类型统计
         self._report_unknown_types()
         
@@ -913,7 +930,7 @@ class ProtoReconstructor:
 
     def _find_best_matching_class(self, type_name: str, current_package: str, current_class: str = None) -> Optional[str]:
         """
-        查找最佳匹配的类（用于处理推断失败的情况）
+        查找最佳匹配的类（使用索引优化）
         
         Args:
             type_name: 类型名（如 IdData）
@@ -935,7 +952,28 @@ class ProtoReconstructor:
             self.logger.info(f"    🔍 基础字段类型检测: {type_name} -> 跳过类匹配")
             return None
         
-        # 如果源码分析失败，回退到模糊匹配
+        # 使用类型索引进行快速匹配
+        best_match = self.type_index.find_best_match(type_name, current_package)
+        
+        if best_match:
+            self.logger.info(f"    🔍 索引匹配: {type_name} -> {best_match}")
+            return best_match
+        
+        # 索引未找到匹配，回退到传统方法（保留兼容性）
+        self.logger.debug(f"    ⚠️  索引未找到匹配，回退到目录扫描: {type_name}")
+        return self._fallback_directory_search(type_name, current_package)
+    
+    def _fallback_directory_search(self, type_name: str, current_package: str) -> Optional[str]:
+        """
+        回退的目录扫描方法（当索引匹配失败时使用）
+        
+        Args:
+            type_name: 类型名
+            current_package: 当前包名
+            
+        Returns:
+            匹配的类名或None
+        """
         matching_classes = []
         
         # 在源码目录中搜索
@@ -961,7 +999,7 @@ class ProtoReconstructor:
         matching_classes.sort(key=lambda x: x[1], reverse=True)
         best_match = matching_classes[0][0]
         
-        self.logger.info(f"    🔍 智能匹配: {type_name} -> {best_match}")
+        self.logger.info(f"    🔍 目录扫描匹配: {type_name} -> {best_match}")
         return best_match
 
     def _is_basic_field_type(self, type_name: str, current_class: str = None) -> bool:
@@ -1125,8 +1163,12 @@ class ProtoReconstructor:
             if not java_file:
                 return None
                 
-            # 读取Java源码
-            content = java_file.read_text(encoding='utf-8')
+            # 使用缓存读取Java源码
+            from utils.file_cache import get_file_cache
+            file_cache = get_file_cache()
+            content = file_cache.get_content(java_file)
+            if not content:
+                return None
             
             # 查找字段声明模式：private SomeType fieldName_;
             # 我们要找的是以inferred_type结尾的类型声明

generation/proto_generator.py

@@ -158,12 +158,13 @@ class ProtoGenerator:
         """
         lines = [f'message {message_def.name} {{']
         
-        # 生成oneof字段
+        # 生成oneof字段（oneof字段内部也按tag排序）
         for oneof in message_def.oneofs:
             lines.extend(self._generate_oneof_definition(oneof))
         
-        # 生成常规字段
-        for field in message_def.fields:
+        # 生成常规字段（按tag排序）
+        sorted_fields = sorted(message_def.fields, key=lambda field: field.tag)
+        for field in sorted_fields:
             lines.append(self._generate_field_definition(field))
         
         lines.append('}')
@@ -181,19 +182,24 @@ class ProtoGenerator:
         """
         lines = [f'enum {enum_def.name} {{']
         
-        # 生成枚举值
-        for enum_value in enum_def.values:
+        # 生成枚举值（按value排序）
+        sorted_values = sorted(enum_def.values, key=lambda enum_value: enum_value.value)
+        for enum_value in sorted_values:
             lines.append(f'  {enum_value.name} = {enum_value.value};')
         
         lines.append('}')
         return lines
     
     def _generate_oneof_definition(self, oneof) -> List[str]:
-        """生成oneof字段定义"""
+        """生成oneof字段定义（字段按tag排序）"""
         lines = [f'  oneof {oneof.name} {{']
-        for field in oneof.fields:
+        
+        # 对oneof内部的字段按tag排序
+        sorted_fields = sorted(oneof.fields, key=lambda field: field.tag)
+        for field in sorted_fields:
             field_type = self._resolve_field_type(field)
             lines.append(f'    {field_type} {field.name} = {field.tag};')
+        
         lines.append('  }')
         return lines
     

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "reproto"
-version = "0.0.7"
+version = "0.0.8"
 description = "一个强大的逆向工程工具, 能够从任何使用Google Protobuf Lite的Android应用中自动重构出完整的.proto文件结构."
 readme = "README.md"
 license = "Proprietary"

{reproto-0.0.7.dist-info → reproto-0.0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: reproto
-Version: 0.0.7
+Version: 0.0.8
 Summary: 一个强大的逆向工程工具, 能够从任何使用Google Protobuf Lite的Android应用中自动重构出完整的.proto文件结构.
 License: Proprietary
 Keywords: protobuf,reverse-engineering,android,jadx,proto

{reproto-0.0.7.dist-info → reproto-0.0.8.dist-info}/RECORD

@@ -1,4 +1,4 @@
-.git/COMMIT_EDITMSG,sha256=vWBgg8c4nJUTpGorLmdBiJ660gt2AqgexEmYUvl51Aw,1153
+.git/COMMIT_EDITMSG,sha256=OJTijUraf8zRGEsGyQ_Q3EFxeT206AEhvBZe9ph_cdI,28
 .git/HEAD,sha256=ly8yuQLWQE8njkYAapHLPJ1xVg6_fMgQjCoHqKvFIdw,21
 .git/config,sha256=9ZAySfDWBdI-K9eOXyrEQOhiX68AiaP0Z4CLzH07H10,399
 .git/description,sha256=hatsFj1DoX6pz3eIMIvKFGbxsKjRzJLibpv2PaQGKu4,73
@@ -16,27 +16,37 @@
 .git/hooks/push-to-checkout.sample,sha256=pT0HQXmLKHxt16-mSu5HPzBeZdP0lGO7nXQI7DsSv18,2783
 .git/hooks/sendemail-validate.sample,sha256=ROv8kj3FRmvACWAvDs8Ge5xlRZq_6IaN3Em3jmztepI,2308
 .git/hooks/update.sample,sha256=jV8vqD4QPPCLV-qmdSHfkZT0XL28s32lKtWGCXoU0QY,3650
-.git/index,sha256=nckmwqmC8EqH_vLPAej3d-XaBtUVlxCzKL8Qt6yYvz8,1991
+.git/index,sha256=B1Rzt_0WDkah8dDUat5W191JgMFWphX94SqRGFNaulo,2167
 .git/info/exclude,sha256=ZnH-g7egfIky7okWTR8nk7IxgFjri5jcXAbuClo7DsE,240
-.git/logs/HEAD,sha256=T-dzLHXLLB7bROtDGZibbNa290si245Rh_CjOspA7GQ,726
-.git/logs/refs/heads/iyue,sha256=T-dzLHXLLB7bROtDGZibbNa290si245Rh_CjOspA7GQ,726
-.git/logs/refs/remotes/gitlab/iyue,sha256=VcwPRaWPyufhVnQ-14cf2KAMQR70LHcxgpuhcJauhYY,408
+.git/logs/HEAD,sha256=xX-tAof-O9a3m9JXQU75r2QrQBSxtRQ3Vj2UoNr_qxM,1057
+.git/logs/refs/heads/iyue,sha256=xX-tAof-O9a3m9JXQU75r2QrQBSxtRQ3Vj2UoNr_qxM,1057
+.git/logs/refs/remotes/gitlab/iyue,sha256=UPB7A4ZXzkMHpkWp5AG846jGDLEBUY_hr0fMbb4h_V0,680
 .git/logs/refs/remotes/origin/HEAD,sha256=4vCPTgC0N80jhmkFXNUlYvHtGllYJkQTGZEn6LlqZgs,163
-.git/logs/refs/remotes/origin/iyue,sha256=p6LGJyJ8YWca4RQ6etXUQ3DjwoYp7oN3aBz1vYIa8fw,408
+.git/logs/refs/remotes/origin/iyue,sha256=J3u7O9zrNOAvsYpwKq0BCIPq1sDWaw7mTbhPD-tAxog,680
 .git/objects/09/a92517fe9eeb33d2fd7c979e01d163665f7abc,sha256=wyFL5jJ16f0xCpL1MB5EiJvs2opieE0hMEmyDpUV3ps,9356
 .git/objects/14/d323d58fb90c209a730c17e23fd82a6c735fc1,sha256=rTCuhPM5LYusLIMDv7CLC557SlRFvvbBzgr4jwrjMVg,426
+.git/objects/15/eb3f02479e633439ec83c143e703f8448043a1,sha256=duJXtvq_NNhYKG7WdejXgoMlyHIaCUG5jv9SJpU_orc,14711
 .git/objects/18/89a4fb55eb3abdc528ce87f0cea039278c06fd,sha256=Uz8TPtDNnPWR5pfsIx7tMDCDFBdWLIkaPcnYPIJ12oM,2880
 .git/objects/20/cf56ec106bcd66420dd000279f983571b918b6,sha256=0dwZwG7CpR7yYYNvgYDxHLPj2P7eRLK7fTW_En419pk,166
 .git/objects/21/55b64d52922c88527c102d62f23e5c2abbae79,sha256=6LLW2HrSfqqVwvO59yc-EcUp6MHw6zfHwu8TB775dII,13853
 .git/objects/23/bfbca38e177bcbb423dd782c35b19d127a5ab0,sha256=hYW2b3t3bVGNh4pqyyA7DMlyF4LfNZco5NwedWMwwuI,3700
+.git/objects/26/1f67f3b731b32f6d77de9dd7be2d61e2a14ace,sha256=mcasCBpCulVy2N-X_d2hg8567PdhZRof4ea5nYoelJM,96
+.git/objects/2e/2c1c42f5ac5d665cc672d3792078b756d9ab0e,sha256=5LG3jHGORJeswNw0lz5dc6QSsxztyMstbRDADhZDnZY,166
 .git/objects/33/181441ab38eded005db356da89b54c7d29f452,sha256=iIM6a2aGs_TGZjxHKnkYYyZj_hA77nAF7r2lMOtN1VA,2021
 .git/objects/33/52dfa8f5d9eb46cc98ea7ccecf02e4d9df95f7,sha256=KNAvQNdSalt8CxCZVVb8e6KBC4zqVtusT5MriFLPbIQ,4409
+.git/objects/35/8bace20b731ff1bbb256d2a0158dfc84720978,sha256=hEPGT0bRzT1GlXErWRWJ7ogflTWj3SutlHRKCBH1TII,426
 .git/objects/3c/6f0120229cc2cd8123efbeb7f186eb0a485f29,sha256=iyh7Xt-m7vou3slm58k8xSl3Cn2yYXTuv5WziSWHrW0,802
 .git/objects/40/84f4567d983a977c49598b7d886e46b13ff50b,sha256=R3w6EvxpJRcVuJvbCslrGDK07kcOjECGGosj5tO-JBo,426
 .git/objects/48/369b05749e384be9be58e5f943f3a0040d0f37,sha256=KP9dXx-XniZuIEXESlrL_MWWi55zGiFr7xtmp3oD67o,8551
+.git/objects/4d/6d457bfabc4af842e5ddc2d56eb059d5dfdc9d,sha256=HLQ8aGvln8ZuhdINhhbr_aTt2BttkJOY8k6LhciAMLE,672
+.git/objects/55/6723fdd4f525eed41c52fa80defca3f0c81c47,sha256=vwGNz5lxU_wrrRWVPU64TccYo4Vo4uUGC3-GwVIs1xs,4520
+.git/objects/65/a4f0ada7519f8b1e6a7c7e287541b8effde9fd,sha256=jSGkVjAMcm2nrF6w_0U7lmzoBgwIJaf4P8POOlABxEQ,188
 .git/objects/76/311aa8e59d780763e0d66787067cc5d9613a67,sha256=J9Xy8ESXbWUbC_4sA0KumGVKm09tzlqA8C5oJ63a_b4,2167
 .git/objects/7c/00eec7ae9ef5f94fc337e5c8f9793a2a48810d,sha256=Ju-Yuy5EARcIThU4vkHrZuHQWu3MjXSZYGtBDTWR18c,96
 .git/objects/8c/809c42c7ae13007fd885ee7bcffae7acf2c520,sha256=HYoU3_cZUGur3rWrgRvzHRAv0JfrXgc34R8UeGbC5Bc,14180
+.git/objects/8d/44142ae2d6dbb59d4ebed8587bccd051e5766b,sha256=l1G5ZzQBQW8Lxd3WvGLRcY6quM6dBL4zdNT5ovjv3Dc,802
+.git/objects/8d/4a5767bef0c342f1660526f9671c0944922c40,sha256=kP0nfEnyNmuEJ4wLQabhPPx60OIa5Dxqn7R9Ni89CqY,1900
+.git/objects/95/295a15779ebefd563ec777c3d3cced7e8d0209,sha256=IIN8_K0K-3LAkUI4Ra3DS8yUsfpsqteSDGhgvRpSfZ4,426
 .git/objects/97/56fe0931216a7c40cbf250e1ab8a6dfd589f13,sha256=Su7Q-bXO0K9QKEGC249NVuUS62xmQs5TgWfEmdbauaI,97
 .git/objects/9a/e313cdf64cd82416c1238eb493e6396f799f12,sha256=9bPRhebwMVqtGqJUxfVq-TEUxceuOdSvicWe1H8F7Ks,876
 .git/objects/a3/cedc28e563a1845a7860161b39b0fe58d5f0d3,sha256=Vee0H8dhSj4ERNDSAnRU6vebs0tbY1-lgYr1Nz5X7bc,122
@@ -44,6 +54,7 @@
 .git/objects/cd/2d6c229438c6b1c694b9392a85888d89ef49c1,sha256=IW9iGk3Eb-i_Ht64HQcltVp27ziQHz5IP6k5p57YFtY,122
 .git/objects/d0/9c84ad2142a187bf26a1714b7041b62e404c8f,sha256=twhhaZbfU_mgu5LIlt9ZeGjp_PT_gri_9H231H5nrNc,2172
 .git/objects/d9/6d7456245232b3e159dcf691f11e51224c557a,sha256=3w45hxiT2rn6ljSdgo36fHMMWZt30r5C1FPvbnjq9tc,597
+.git/objects/db/beedb30613f79ae3ff67df1428cf8ade223711,sha256=tTGayiwSvdy-uBiXQKRhNnToZ_dc1BmeXZ2mltuRfxY,3812
 .git/objects/e8/1433b6ad92206cdadbee1f474b4f99383314cb,sha256=mRMdmx6wCs6b-63QL72Iutm2AUVCOIYs7J5XbAsLluc,426
 .git/objects/e8/2f42ea26b8bf4f0bc92c0648ac8f190f14226d,sha256=xtbEwloZnqXdNdViAevzyprosfPQ1P--xAu6URGlaYI,155
 .git/objects/e9/a15996cb55ac72aeb6611d26e8d22246589943,sha256=sTn6X3xMp3_WYpj1CmP2hDqviX86aJHTCzzi_ZTpBKw,4643
@@ -52,14 +63,15 @@
 .git/objects/f2/2bfffda9fb6a7f37bed04b7c40c9466ef09454,sha256=goQNyEV3NqzS28mMXuus1SWzwb8yXnvEPef14Ugzh5Q,750
 .git/objects/f5/18c69a6e1bf3052b79da01502b2837ea58f0f4,sha256=r98SFbCvw7yeAYTjzkw-2VMhOVbpm79FLZQiC5A1-pw,123
 .git/objects/f7/25a430eb3364460ba854dbc8809edc21dc6c70,sha256=LdyMmAWGLWbn5G5fC7eAPi4NFOboKcJ6iJJdxENSUCk,2505
+.git/objects/fc/e15b9dbffd9f37b1f2d46944ee2d0394df6565,sha256=81qdzKkVZ5C_1oej2Mm0q2RLifilVFolIs95mrUfpg4,163
 .git/objects/pack/pack-289f7bb06603881c49190e6036de6390223baf77.idx,sha256=KRv1SBEe9bYL9d5V301LwPOBqFs3tMnB0dl4PriMMIw,2416
 .git/objects/pack/pack-289f7bb06603881c49190e6036de6390223baf77.pack,sha256=R4oMXhr-NcPAUBXStCbAaUvGUDW_SBECmPIbiB9Gy48,42003
 .git/objects/pack/pack-289f7bb06603881c49190e6036de6390223baf77.rev,sha256=22_3sqyTNB5IbwAK5oCqNz0UxDDqoZ5jcF7p_44Lalo,244
 .git/packed-refs,sha256=4H0m4wd6q98wZkBk7WfvVeTBuuxQdTE65XxsswYP-oQ,112
-.git/refs/heads/iyue,sha256=uNzTlIGt4yrSLvXubuKKl8nJyDrxCK3ADGlq4CVVWTM,41
-.git/refs/remotes/gitlab/iyue,sha256=uNzTlIGt4yrSLvXubuKKl8nJyDrxCK3ADGlq4CVVWTM,41
+.git/refs/heads/iyue,sha256=3yox20YC-z9tSZ5Qrjy3DA1_ZXUQcLCKXhdXBcw7sno,41
+.git/refs/remotes/gitlab/iyue,sha256=3yox20YC-z9tSZ5Qrjy3DA1_ZXUQcLCKXhdXBcw7sno,41
 .git/refs/remotes/origin/HEAD,sha256=G8pFPTbCqnJ2IkCzz9J-STqOXWU6TrlXfpt1wx5bUWE,30
-.git/refs/remotes/origin/iyue,sha256=uNzTlIGt4yrSLvXubuKKl8nJyDrxCK3ADGlq4CVVWTM,41
+.git/refs/remotes/origin/iyue,sha256=3yox20YC-z9tSZ5Qrjy3DA1_ZXUQcLCKXhdXBcw7sno,41
 .gitignore,sha256=ThRUL1E38Z_Q4Lww0xYYl9ziFaPUvvwwqxbmp2cuwco,2068
 .python-version,sha256=NxOs_9lT1XG8y-FjlRru-YinX5RcBJt_ulPwgDESZ_o,7
 ARCHITECTURE.md,sha256=JALnUdREwdLRAmcUit5CGAPLpeZ6UfoYpAQkxil3NJc,8322
@@ -67,21 +79,23 @@ README.md,sha256=1EC39Oeth4evP26KNWEMFG-hSrFNhJIAVOSSOBhc9cY,4244
 core/__init__.py,sha256=ajz1GSNU9xYVrFEDSz6Xwg7amWQ_yvW75tQa1ZvRIWc,3
 core/bytecode_parser.py,sha256=87ZGhnyBNGP-gRjIyRUcGfWS2HR1YA_e1OBKafLEEDc,11532
 core/info_decoder.py,sha256=wQMZoiQ7adK1xrAhZ0GOIqeLzvf3-TO7_EAERy4EX6g,52682
-core/reconstructor.py,sha256=jm7XvZ3IcQosM42yG4Q-GVcQBaFtqABQ4-O63dJGRZA,51705
+core/reconstructor.py,sha256=RAA8ugrzNWg6Yc3cXu_i3ietc8aNzwh2ocGHTsEVgp8,53354
 generation/__init__.py,sha256=ajz1GSNU9xYVrFEDSz6Xwg7amWQ_yvW75tQa1ZvRIWc,3
-generation/proto_generator.py,sha256=KQjSxy8CGIwMEUJhEypa1xXbJ97yoGu_NIAYDf8sMLQ,16863
+generation/proto_generator.py,sha256=aeqKebkZ-GZAFSt2WWApC0CB3rk8iiaxYeVDm4ZD6E0,17264
 main.py,sha256=3G649-aTByEjMS4tb1A9wcO9NVUxXVSvdwGTq9hXxBI,7081
 models/__init__.py,sha256=WScv63rvEl65y5CWjpb6__hvjNvjpCkl6lz1Z2u0IYc,811
 models/message_definition.py,sha256=AszUZnNPSBn9SMXne5ORDBiGZz1W2pcYmU8ftGC3Mks,4873
 parsing/__init__.py,sha256=ajz1GSNU9xYVrFEDSz6Xwg7amWQ_yvW75tQa1ZvRIWc,3
 parsing/enum_parser.py,sha256=4BjMk1NIYgt2FDZUjTZyOvFfC1uJp_MBZipVdk1tqes,6175
 parsing/java_parser.py,sha256=ECaiU9cZMNUZqoV1mrKRvaSFjZXha-lVgB59w6MuwxY,14761
-pyproject.toml,sha256=J5gcdLZazkYd26QZJRYQ0VK3vXcEtfvdgEJQ9VkU4Fc,1378
+pyproject.toml,sha256=U3UQ2y7O9hz_q3yMTFvBulIUdAPNroQzrVCIr4LciCc,1378
 requirements.txt,sha256=cQGj3IS6Kj88jbwj_jeKkokMnG-fEezWve91mfW4CJs,96
 utils/__init__.py,sha256=ajz1GSNU9xYVrFEDSz6Xwg7amWQ_yvW75tQa1ZvRIWc,3
+utils/file_cache.py,sha256=eOBkfrumWg0EU1EfLESnRN1kcidi_MocxV_EWP8lEhQ,5207
 utils/file_utils.py,sha256=N1Ei7hmyeOkIyZJFEXyNbtTrfeVF2hP-U8evXAVW2MA,4085
 utils/logger.py,sha256=473DfzFVXzdGpiRTJGY6bBd-V5G80_P07gQqcvDChpQ,2447
-reproto-0.0.7.dist-info/METADATA,sha256=0x4j3WCrdeg5DO7oDV9wi9-kNaoBJTgj-NvWlFEpATg,5193
-reproto-0.0.7.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-reproto-0.0.7.dist-info/entry_points.txt,sha256=6Oro9lK_2DXDgHiB3andNuIE78wxfooqacqp8yY1C-g,37
-reproto-0.0.7.dist-info/RECORD,,
+utils/type_index.py,sha256=So8FYyGtR0ff-ZhVHjXUdhXiXQEujlcCEJlj7OPQMsg,12128
+reproto-0.0.8.dist-info/METADATA,sha256=Eo2Hrl1W_fX0u4AaPgKXk2Im_hYvu_snqG1HyTqOz_Y,5193
+reproto-0.0.8.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+reproto-0.0.8.dist-info/entry_points.txt,sha256=6Oro9lK_2DXDgHiB3andNuIE78wxfooqacqp8yY1C-g,37
+reproto-0.0.8.dist-info/RECORD,,

utils/file_cache.py

@@ -0,0 +1,165 @@
+"""
+文件内容缓存系统
+
+用于缓存Java源码文件内容，避免重复的文件I/O操作
+这是解决reproto性能瓶颈的核心优化组件
+
+Author: AI Assistant
+"""
+
+from pathlib import Path
+from typing import Optional, Dict
+import threading
+from utils.logger import get_logger
+
+
+class FileContentCache:
+    """
+    文件内容缓存系统
+    
+    提供线程安全的文件内容缓存，显著减少重复的文件I/O操作
+    特别适用于需要多次读取同一Java文件的场景
+    """
+    
+    def __init__(self):
+        """初始化缓存系统"""
+        self._cache: Dict[str, str] = {}
+        self._stats = {
+            'hits': 0,
+            'misses': 0,
+            'errors': 0
+        }
+        self._lock = threading.RLock()  # 使用可重入锁
+        self.logger = get_logger("file_cache")
+    
+    def get_content(self, file_path: Path) -> Optional[str]:
+        """
+        获取文件内容，优先从缓存读取
+        
+        Args:
+            file_path: 文件路径
+            
+        Returns:
+            文件内容字符串，如果读取失败则返回None
+        """
+        cache_key = str(file_path.resolve())
+        
+        with self._lock:
+            # 检查缓存
+            if cache_key in self._cache:
+                self._stats['hits'] += 1
+                return self._cache[cache_key]
+            
+            # 缓存未命中，读取文件
+            try:
+                if not file_path.exists():
+                    self._stats['errors'] += 1
+                    return None
+                
+                content = file_path.read_text(encoding='utf-8')
+                self._cache[cache_key] = content
+                self._stats['misses'] += 1
+                
+                # 定期输出缓存统计
+                total_requests = self._stats['hits'] + self._stats['misses']
+                if total_requests % 50 == 0 and total_requests > 0:
+                    hit_rate = self._stats['hits'] / total_requests * 100
+                    self.logger.debug(f"📊 缓存统计: {total_requests} 次请求, 命中率 {hit_rate:.1f}%")
+                
+                return content
+                
+            except Exception as e:
+                self._stats['errors'] += 1
+                self.logger.warning(f"⚠️  读取文件失败 {file_path}: {e}")
+                return None
+    
+    def preload_files(self, file_paths: list[Path]) -> int:
+        """
+        预加载文件列表到缓存
+        
+        Args:
+            file_paths: 要预加载的文件路径列表
+            
+        Returns:
+            成功预加载的文件数量
+        """
+        loaded_count = 0
+        
+        for file_path in file_paths:
+            if self.get_content(file_path) is not None:
+                loaded_count += 1
+        
+        self.logger.info(f"📁 预加载完成: {loaded_count}/{len(file_paths)} 个文件")
+        return loaded_count
+    
+    def clear_cache(self):
+        """清空缓存"""
+        with self._lock:
+            self._cache.clear()
+            self.logger.info("🗑️  缓存已清空")
+    
+    def get_stats(self) -> dict:
+        """
+        获取缓存统计信息
+        
+        Returns:
+            包含缓存统计的字典
+        """
+        with self._lock:
+            total_requests = self._stats['hits'] + self._stats['misses']
+            hit_rate = (self._stats['hits'] / total_requests * 100) if total_requests > 0 else 0
+            
+            return {
+                'total_requests': total_requests,
+                'cache_hits': self._stats['hits'],
+                'cache_misses': self._stats['misses'],
+                'hit_rate_percent': hit_rate,
+                'errors': self._stats['errors'],
+                'cached_files': len(self._cache)
+            }
+    
+    def print_stats(self):
+        """打印缓存统计信息"""
+        stats = self.get_stats()
+        
+        self.logger.info("📊 文件缓存统计:")
+        self.logger.info(f"   总请求数: {stats['total_requests']}")
+        self.logger.info(f"   缓存命中: {stats['cache_hits']}")
+        self.logger.info(f"   缓存未命中: {stats['cache_misses']}")
+        self.logger.info(f"   命中率: {stats['hit_rate_percent']:.1f}%")
+        self.logger.info(f"   错误数: {stats['errors']}")
+        self.logger.info(f"   已缓存文件: {stats['cached_files']}")
+        
+        # 计算性能提升
+        if stats['cache_hits'] > 0:
+            io_saved = stats['cache_hits']
+            self.logger.info(f"   🚀 节省I/O操作: {io_saved} 次")
+
+
+# 全局缓存实例
+_global_cache = None
+_cache_lock = threading.Lock()
+
+
+def get_file_cache() -> FileContentCache:
+    """
+    获取全局文件缓存实例（单例模式）
+    
+    Returns:
+        FileContentCache实例
+    """
+    global _global_cache
+    
+    if _global_cache is None:
+        with _cache_lock:
+            if _global_cache is None:
+                _global_cache = FileContentCache()
+    
+    return _global_cache
+
+
+def clear_global_cache():
+    """清空全局缓存"""
+    global _global_cache
+    if _global_cache is not None:
+        _global_cache.clear_cache() 

utils/type_index.py

@@ -0,0 +1,341 @@
+"""
+类型匹配索引系统
+
+用于快速查找Java类型，避免重复的目录扫描操作
+这是解决reproto性能瓶颈的第二个核心优化组件
+
+Author: AI Assistant
+"""
+
+from pathlib import Path
+from typing import Dict, List, Optional, Set
+import threading
+from utils.logger import get_logger
+
+
+class TypeMatchingIndex:
+    """
+    类型匹配索引系统
+    
+    构建从类型名到完整类名的多级索引，支持：
+    - 精确匹配（完整类名）
+    - 简单名匹配（类名）
+    - 后缀匹配（如 IdData -> ContactIdData）
+    - 包名相似度匹配
+    """
+    
+    def __init__(self, sources_dir: Path):
+        """
+        初始化索引系统
+        
+        Args:
+            sources_dir: Java源码根目录
+        """
+        self.sources_dir = sources_dir
+        self.logger = get_logger("type_index")
+        
+        # 多级索引结构
+        self._exact_index: Dict[str, str] = {}          # 完整类名 -> 完整类名
+        self._simple_index: Dict[str, List[str]] = {}   # 简单类名 -> [完整类名列表]
+        self._suffix_index: Dict[str, List[str]] = {}   # 后缀 -> [完整类名列表]
+        self._package_index: Dict[str, List[str]] = {}  # 包名 -> [完整类名列表]
+        
+        # 基础类型集合（快速过滤）
+        self._basic_types: Set[str] = {
+            'int', 'long', 'float', 'double', 'boolean', 'byte', 'short', 'char',
+            'String', 'Object', 'Integer', 'Long', 'Float', 'Double', 'Boolean',
+            'Byte', 'Short', 'Character', 'List', 'Map', 'Set', 'Collection'
+        }
+        
+        # 索引统计
+        self._stats = {
+            'total_classes': 0,
+            'index_hits': 0,
+            'index_misses': 0,
+            'basic_type_skips': 0
+        }
+        
+        self._lock = threading.RLock()
+        self._is_built = False
+    
+    def build_index(self) -> None:
+        """构建所有索引"""
+        if self._is_built:
+            return
+            
+        with self._lock:
+            if self._is_built:
+                return
+                
+            self.logger.info("🏗️  开始构建类型索引...")
+            
+            # 扫描所有Java文件
+            java_files = list(self.sources_dir.rglob("*.java"))
+            self.logger.info(f"📁 发现 {len(java_files)} 个Java文件")
+            
+            for java_file in java_files:
+                self._index_single_file(java_file)
+            
+            self._stats['total_classes'] = len(self._exact_index)
+            self._is_built = True
+            
+            self.logger.info(f"✅ 索引构建完成: {self._stats['total_classes']} 个类")
+            self._print_index_stats()
+    
+    def _index_single_file(self, java_file: Path) -> None:
+        """
+        为单个Java文件建立索引
+        
+        Args:
+            java_file: Java文件路径
+        """
+        try:
+            # 获取类名和包名
+            class_name = java_file.stem
+            relative_path = java_file.relative_to(self.sources_dir)
+            package_parts = relative_path.parts[:-1]  # 排除文件名
+            
+            if package_parts:
+                package_name = '.'.join(package_parts)
+                full_class_name = f"{package_name}.{class_name}"
+            else:
+                package_name = ""
+                full_class_name = class_name
+            
+            # 1. 精确索引：完整类名
+            self._exact_index[full_class_name] = full_class_name
+            
+            # 2. 简单名索引
+            if class_name not in self._simple_index:
+                self._simple_index[class_name] = []
+            self._simple_index[class_name].append(full_class_name)
+            
+            # 3. 后缀索引（用于匹配如 IdData -> ContactIdData）
+            if len(class_name) > 4:
+                for suffix_len in [4, 6, 8]:  # 多种后缀长度
+                    if len(class_name) >= suffix_len:
+                        suffix = class_name[-suffix_len:]
+                        if suffix not in self._suffix_index:
+                            self._suffix_index[suffix] = []
+                        self._suffix_index[suffix].append(full_class_name)
+            
+            # 4. 包名索引
+            if package_name:
+                if package_name not in self._package_index:
+                    self._package_index[package_name] = []
+                self._package_index[package_name].append(full_class_name)
+                
+        except Exception as e:
+            self.logger.warning(f"⚠️  索引文件失败 {java_file}: {e}")
+    
+    def find_best_match(self, type_name: str, current_package: str = "") -> Optional[str]:
+        """
+        查找类型名的最佳匹配
+        
+        Args:
+            type_name: 要查找的类型名
+            current_package: 当前包名（用于相似度计算）
+            
+        Returns:
+            最佳匹配的完整类名，如果没有找到则返回None
+        """
+        if not self._is_built:
+            self.build_index()
+        
+        # 快速过滤基础类型
+        if type_name in self._basic_types:
+            self._stats['basic_type_skips'] += 1
+            return None
+        
+        with self._lock:
+            # 1. 精确匹配
+            if type_name in self._exact_index:
+                self._stats['index_hits'] += 1
+                return self._exact_index[type_name]
+            
+            # 2. 简单名匹配
+            if type_name in self._simple_index:
+                candidates = self._simple_index[type_name]
+                if len(candidates) == 1:
+                    self._stats['index_hits'] += 1
+                    return candidates[0]
+                else:
+                    # 多个候选，选择包名最相似的
+                    best_match = self._select_best_by_package(candidates, current_package)
+                    if best_match:
+                        self._stats['index_hits'] += 1
+                        return best_match
+            
+            # 3. 后缀匹配
+            for suffix_len in [4, 6, 8]:
+                if len(type_name) >= suffix_len:
+                    suffix = type_name[-suffix_len:]
+                    if suffix in self._suffix_index:
+                        candidates = self._suffix_index[suffix]
+                        # 过滤：确保候选类名以type_name结尾
+                        filtered_candidates = [
+                            c for c in candidates 
+                            if c.split('.')[-1].endswith(type_name)
+                        ]
+                        if filtered_candidates:
+                            best_match = self._select_best_by_package(filtered_candidates, current_package)
+                            if best_match:
+                                self._stats['index_hits'] += 1
+                                return best_match
+            
+            # 4. 未找到匹配
+            self._stats['index_misses'] += 1
+            return None
+    
+    def _select_best_by_package(self, candidates: List[str], current_package: str) -> Optional[str]:
+        """
+        根据包名相似度选择最佳候选
+        
+        Args:
+            candidates: 候选类名列表
+            current_package: 当前包名
+            
+        Returns:
+            最佳匹配的类名
+        """
+        if not candidates:
+            return None
+        
+        if len(candidates) == 1:
+            return candidates[0]
+        
+        if not current_package:
+            return candidates[0]  # 无包名信息时返回第一个
+        
+        # 计算包名相似度
+        best_candidate = None
+        best_similarity = -1
+        
+        for candidate in candidates:
+            candidate_package = '.'.join(candidate.split('.')[:-1])
+            similarity = self._calculate_package_similarity(candidate_package, current_package)
+            
+            if similarity > best_similarity:
+                best_similarity = similarity
+                best_candidate = candidate
+        
+        return best_candidate
+    
+    def _calculate_package_similarity(self, package1: str, package2: str) -> float:
+        """
+        计算两个包名的相似度
+        
+        Args:
+            package1: 第一个包名
+            package2: 第二个包名
+            
+        Returns:
+            相似度分数（0-1）
+        """
+        if not package1 or not package2:
+            return 0.0
+        
+        parts1 = package1.split('.')
+        parts2 = package2.split('.')
+        
+        # 计算公共前缀长度
+        common_prefix = 0
+        for i in range(min(len(parts1), len(parts2))):
+            if parts1[i] == parts2[i]:
+                common_prefix += 1
+            else:
+                break
+        
+        # 相似度 = 公共前缀长度 / 最大包深度
+        max_depth = max(len(parts1), len(parts2))
+        return common_prefix / max_depth if max_depth > 0 else 0.0
+    
+    def get_classes_in_package(self, package_name: str) -> List[str]:
+        """
+        获取指定包中的所有类
+        
+        Args:
+            package_name: 包名
+            
+        Returns:
+            类名列表
+        """
+        if not self._is_built:
+            self.build_index()
+        
+        return self._package_index.get(package_name, [])
+    
+    def get_stats(self) -> dict:
+        """
+        获取索引统计信息
+        
+        Returns:
+            包含索引统计的字典
+        """
+        with self._lock:
+            total_requests = self._stats['index_hits'] + self._stats['index_misses']
+            hit_rate = (self._stats['index_hits'] / total_requests * 100) if total_requests > 0 else 0
+            
+            return {
+                'total_classes': self._stats['total_classes'],
+                'total_requests': total_requests,
+                'index_hits': self._stats['index_hits'],
+                'index_misses': self._stats['index_misses'],
+                'hit_rate_percent': hit_rate,
+                'basic_type_skips': self._stats['basic_type_skips'],
+                'is_built': self._is_built
+            }
+    
+    def _print_index_stats(self):
+        """打印索引构建统计"""
+        self.logger.info("📊 索引统计:")
+        self.logger.info(f"   精确索引: {len(self._exact_index)} 个类")
+        self.logger.info(f"   简单名索引: {len(self._simple_index)} 个条目")
+        self.logger.info(f"   后缀索引: {len(self._suffix_index)} 个条目")
+        self.logger.info(f"   包名索引: {len(self._package_index)} 个包")
+    
+    def print_stats(self):
+        """打印使用统计信息"""
+        stats = self.get_stats()
+        
+        self.logger.info("📊 类型索引统计:")
+        self.logger.info(f"   总类数: {stats['total_classes']}")
+        self.logger.info(f"   查询请求: {stats['total_requests']}")
+        self.logger.info(f"   索引命中: {stats['index_hits']}")
+        self.logger.info(f"   索引未命中: {stats['index_misses']}")
+        self.logger.info(f"   命中率: {stats['hit_rate_percent']:.1f}%")
+        self.logger.info(f"   基础类型跳过: {stats['basic_type_skips']}")
+
+
+# 全局索引实例
+_global_index = None
+_index_lock = threading.Lock()
+
+
+def get_type_index(sources_dir: Path = None) -> TypeMatchingIndex:
+    """
+    获取全局类型索引实例（单例模式）
+    
+    Args:
+        sources_dir: 源码目录（仅在首次调用时需要）
+        
+    Returns:
+        TypeMatchingIndex实例
+    """
+    global _global_index
+    
+    if _global_index is None:
+        with _index_lock:
+            if _global_index is None:
+                if sources_dir is None:
+                    raise ValueError("首次调用 get_type_index 时必须提供 sources_dir 参数")
+                _global_index = TypeMatchingIndex(sources_dir)
+                _global_index.build_index()
+    
+    return _global_index
+
+
+def clear_global_index():
+    """清空全局索引"""
+    global _global_index
+    _global_index = None