reproto 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

.git/COMMIT_EDITMSG

@@ -0,0 +1 @@
+feat: rename reproto

.git/config

@@ -10,3 +10,6 @@
 	remote = origin
 	merge = refs/heads/iyue
 	vscode-merge-base = origin/iyue
+[remote "gitlab"]
+	url = git@ys1231.cn:tools/generate_protobuf.git
+	fetch = +refs/heads/*:refs/remotes/gitlab/*

.git/logs/HEAD

@@ -1 +1,3 @@
-0000000000000000000000000000000000000000 514d3a743bced9f5c012a21032b49b81daec78ff iyue <ys1231@126.com> 1750903749 +0800	clone: from github.com:ys1231/reproto.git
+0000000000000000000000000000000000000000 2e11d561668286f3d6d48f399ffab1943a5cdcb2 iyue <ys1231@126.com> 1750922365 +0800	clone: from github.com:ys1231/reproto.git
+2e11d561668286f3d6d48f399ffab1943a5cdcb2 f22bfffda9fb6a7f37bed04b7c40c9466ef09454 iyue <ys1231@126.com> 1750925875 +0800	commit: feat: 完善Protobuf类型推断系统，支持map和未知类型处理
+f22bfffda9fb6a7f37bed04b7c40c9466ef09454 e82f42ea26b8bf4f0bc92c0648ac8f190f14226d iyue <ys1231@126.com> 1750927650 +0800	commit: feat: rename reproto

.git/logs/refs/heads/iyue

@@ -1 +1,3 @@
-0000000000000000000000000000000000000000 514d3a743bced9f5c012a21032b49b81daec78ff iyue <ys1231@126.com> 1750903749 +0800	clone: from github.com:ys1231/reproto.git
+0000000000000000000000000000000000000000 2e11d561668286f3d6d48f399ffab1943a5cdcb2 iyue <ys1231@126.com> 1750922365 +0800	clone: from github.com:ys1231/reproto.git
+2e11d561668286f3d6d48f399ffab1943a5cdcb2 f22bfffda9fb6a7f37bed04b7c40c9466ef09454 iyue <ys1231@126.com> 1750925875 +0800	commit: feat: 完善Protobuf类型推断系统，支持map和未知类型处理
+f22bfffda9fb6a7f37bed04b7c40c9466ef09454 e82f42ea26b8bf4f0bc92c0648ac8f190f14226d iyue <ys1231@126.com> 1750927650 +0800	commit: feat: rename reproto

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

@@ -0,0 +1,2 @@
+0000000000000000000000000000000000000000 f22bfffda9fb6a7f37bed04b7c40c9466ef09454 iyue <ys1231@126.com> 1750926057 +0800	update by push
+f22bfffda9fb6a7f37bed04b7c40c9466ef09454 e82f42ea26b8bf4f0bc92c0648ac8f190f14226d iyue <ys1231@126.com> 1750927662 +0800	update by push

.git/logs/refs/remotes/origin/HEAD

@@ -1 +1 @@
-0000000000000000000000000000000000000000 514d3a743bced9f5c012a21032b49b81daec78ff iyue <ys1231@126.com> 1750903749 +0800	clone: from github.com:ys1231/reproto.git
+0000000000000000000000000000000000000000 2e11d561668286f3d6d48f399ffab1943a5cdcb2 iyue <ys1231@126.com> 1750922365 +0800	clone: from github.com:ys1231/reproto.git

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

@@ -0,0 +1,2 @@
+2e11d561668286f3d6d48f399ffab1943a5cdcb2 f22bfffda9fb6a7f37bed04b7c40c9466ef09454 iyue <ys1231@126.com> 1750925918 +0800	update by push
+f22bfffda9fb6a7f37bed04b7c40c9466ef09454 e82f42ea26b8bf4f0bc92c0648ac8f190f14226d iyue <ys1231@126.com> 1750927669 +0800	update by push

.git/packed-refs

@@ -1,2 +1,2 @@
 # pack-refs with: peeled fully-peeled sorted 
-514d3a743bced9f5c012a21032b49b81daec78ff refs/remotes/origin/iyue
+2e11d561668286f3d6d48f399ffab1943a5cdcb2 refs/remotes/origin/iyue

.git/refs/heads/iyue

@@ -1 +1 @@
-514d3a743bced9f5c012a21032b49b81daec78ff
+e82f42ea26b8bf4f0bc92c0648ac8f190f14226d

.git/refs/remotes/gitlab/iyue

@@ -0,0 +1 @@
+e82f42ea26b8bf4f0bc92c0648ac8f190f14226d

.git/refs/remotes/origin/iyue

@@ -0,0 +1 @@
+e82f42ea26b8bf4f0bc92c0648ac8f190f14226d

README.md

@@ -36,7 +36,7 @@ python main.py <java_sources_dir> <root_class> <output_dir>
 pip install -e .
 
 # 使用命令行工具
-proto-reconstructor <java_sources_dir> <root_class> <output_dir>
+reproto <java_sources_dir> <root_class> <output_dir>
 ```
 
 ## 📖 使用方法
@@ -87,7 +87,7 @@ Java源码 → 字节码提取 → 类型解码 → 依赖发现 → 源码验
 ## 📁 项目结构
 
 ```
-proto_reconstructor/
+reproto/
 ├── main.py                     # 主程序入口
 ├── core/                       # 核心组件
 │   ├── reconstructor.py        # 主协调器
@@ -188,8 +188,8 @@ reproto/
 # 指定日志目录
 python main.py sources/ com.example.Model output/ --log-dir ./my_logs
 
-# 日志文件格式: proto_reconstructor-YYYY-MM-DD-HH-MM-SS.log
-# 例如: proto_reconstructor-2024-01-15-14-30-25.log
+# 日志文件格式: reproto-YYYY-MM-DD-HH-MM-SS.log
+# 例如: reproto-2024-01-15-14-30-25.log
 ```
 
 ### 输出格式

core/info_decoder.py

@@ -36,8 +36,10 @@ class InfoDecoder:
         """
         self.logger = get_logger("info_decoder")
         
-        # 字节码到Protobuf类型的映射表（逆向工程的核心成果）
+        # Protobuf字段类型映射表
+        # 键：字节码中的类型值，值：对应的protobuf字段类型
         self.type_mapping = {
+            0: 'double',      # 64位浮点数 (double) - 基于ContactAddress.latitude_和longitude_的分析
             1: 'float',      # FLOAT
             2: 'int64',      # INT64  
             3: 'int32',      # INT32
@@ -48,12 +50,16 @@ class InfoDecoder:
             27: 'message',   # REPEATED MESSAGE
             39: 'int32',     # REPEATED INT32 (packed)
             44: 'enum',      # PACKED ENUM
-            520: 'string',   # STRING (Ȉ = 520)
+            50: 'map',       # Map字段 - 基于BulkSearchResult.contacts的分析
+            520: 'string',   # UTF-8字符串
             538: 'string',   # REPEATED STRING (Ț = 538)  
         }
         
         # Java源码分析器
         self.java_source_analyzer = java_source_analyzer
+        
+        # 统计未知类型（用于持续改进）
+        self.unknown_types_stats = {}  # {byte_code: count}
     
     def decode_message_info(self, class_name: str, info_string: str, objects: List[str]) -> Optional[MessageDefinition]:
         """
@@ -151,7 +157,7 @@ class InfoDecoder:
         
         Args:
             message_def: 消息定义对象
-            bytes_data: 字节数组
+            bytes_data: 字节码数据
             objects: 对象数组
         """
         # 跳过前10个字节的元数据
@@ -163,11 +169,17 @@ class InfoDecoder:
             field_tag = bytes_data[i]
             field_type_byte = bytes_data[i + 1]
             
-            # 查找类型映射
+            # 查找类型映射，对未知类型进行智能处理
             if field_type_byte not in self.type_mapping:
-                continue
+                # 统计未知类型
+                self.unknown_types_stats[field_type_byte] = self.unknown_types_stats.get(field_type_byte, 0) + 1
                 
-            field_type = self.type_mapping[field_type_byte]
+                # 记录未知类型，但不跳过字段
+                self.logger.warning(f"    ⚠️  发现未知字节码类型: {field_type_byte} (0x{field_type_byte:02x})")
+                field_type = self._analyze_unknown_type_with_source_priority(field_type_byte, objects, object_index)
+                self.logger.info(f"    🔍 推断未知类型: {field_type_byte} -> {field_type}")
+            else:
+                field_type = self.type_mapping[field_type_byte]
             
             # 从对象数组获取字段信息
             field_info = self._extract_field_info(objects, object_index, field_type)
@@ -218,15 +230,20 @@ class InfoDecoder:
         # 确定字段类型名
         field_type_name = field_type  # 默认使用基础类型
         
-        # 对于消息类型和枚举类型，检查objects数组中是否有具体的类型引用
-        if field_type in ['message', 'enum']:
+        # 对于消息类型、枚举类型和map类型，检查objects数组中是否有具体的类型引用
+        if field_type in ['message', 'enum', 'map']:
             if object_index < len(objects):
                 next_obj = objects[object_index]
                 if self._is_type_reference(next_obj):
                     # 直接使用objects数组中的类型引用，这是最准确的信息源
-                    field_type_name = self._clean_type_reference(next_obj)
+                    if field_type == 'map':
+                        # 对于map类型，从MapEntry引用中推断键值类型
+                        field_type_name = self._extract_map_type_from_entry(next_obj, field_name_raw)
+                        self.logger.info(f"    🗺️ 从MapEntry获取map类型: {field_name} -> {field_type_name}")
+                    else:
+                        field_type_name = self._clean_type_reference(next_obj)
+                        self.logger.info(f"    🔗 从objects数组获取类型: {field_name} -> {field_type_name}")
                     object_index += 1
-                    self.logger.info(f"    🔗 从objects数组获取类型: {field_name} -> {field_type_name}")
                 else:
                     # 没有显式引用，优先从Java源码中获取真实类型
                     real_type = self._get_real_field_type_from_source(field_name_raw, field_type)
@@ -241,6 +258,9 @@ class InfoDecoder:
                         elif field_type == 'message':
                             field_type_name = self._infer_message_type_from_field_name(field_name_raw)
                             self.logger.info(f"    🔍 推断消息类型: {field_name} -> {field_type_name}")
+                        elif field_type == 'map':
+                            field_type_name = self._infer_map_type_from_source(field_name_raw)
+                            self.logger.info(f"    🔍 推断map类型: {field_name} -> {field_type_name}")
             else:
                 # objects数组已结束，优先从Java源码中获取真实类型
                 real_type = self._get_real_field_type_from_source(field_name_raw, field_type)
@@ -255,6 +275,9 @@ class InfoDecoder:
                     elif field_type == 'message':
                         field_type_name = self._infer_message_type_from_field_name(field_name_raw)
                         self.logger.info(f"    🔍 推断消息类型: {field_name} -> {field_type_name}")
+                    elif field_type == 'map':
+                        field_type_name = self._infer_map_type_from_source(field_name_raw)
+                        self.logger.info(f"    🔍 推断map类型: {field_name} -> {field_type_name}")
         
         return field_name, field_type_name, object_index
 
@@ -486,6 +509,305 @@ class InfoDecoder:
         if oneof_def.fields:
             message_def.oneofs.append(oneof_def)
     
+    def _extract_map_type_from_entry(self, entry_ref: str, field_name_raw: str) -> str:
+        """
+        从MapEntry引用中提取map的键值类型
+        
+        Args:
+            entry_ref: MapEntry引用，如 "qux.f107553a"
+            field_name_raw: 原始字段名，用于推断类型
+            
+        Returns:
+            map类型字符串，如 "map<string, Contact>"
+        """
+        try:
+            # 优先从Java源码中获取真实的map类型
+            if self.java_source_analyzer:
+                real_type = self.java_source_analyzer.get_field_type(field_name_raw, 'map')
+                if real_type and real_type.startswith('map<'):
+                    return real_type
+            
+            # 如果无法从源码获取，进行智能推断
+            return self._infer_map_type_from_source(field_name_raw)
+            
+        except Exception as e:
+            self.logger.warning(f"    ⚠️  从MapEntry提取类型失败: {e}")
+            return self._infer_map_type_from_source(field_name_raw)
+    
+    def _infer_map_type_from_source(self, field_name_raw: str) -> str:
+        """
+        从字段名推断map类型
+        
+        Args:
+            field_name_raw: 原始字段名（如 contacts_）
+            
+        Returns:
+            推断的map类型字符串
+        """
+        # 移除末尾的下划线
+        clean_name = field_name_raw.rstrip('_')
+        
+        # 基于字段名的通用推断规则
+        if clean_name.lower().endswith('map') or clean_name.lower().endswith('mapping'):
+            # xxxMap -> map<string, Xxx>
+            base_name = clean_name[:-3] if clean_name.lower().endswith('map') else clean_name[:-7]
+            value_type = self._camel_to_pascal_case(base_name) if base_name else 'string'
+            return f"map<string, {value_type}>"
+        elif clean_name.lower() in ['contacts', 'users', 'profiles']:
+            # 常见的复数形式字段，推断为实体映射
+            singular = clean_name[:-1] if clean_name.endswith('s') else clean_name
+            value_type = self._camel_to_pascal_case(singular)
+            return f"map<string, {value_type}>"
+        elif clean_name.lower().endswith('tags'):
+            # xxxTags -> map<string, string> (标签通常是字符串到字符串的映射)
+            return "map<string, string>"
+        elif clean_name.lower().endswith('ids'):
+            # xxxIds -> map<string, string> (ID映射)
+            return "map<string, string>"
+        else:
+            # 默认推断：字段名作为值类型
+            value_type = self._camel_to_pascal_case(clean_name)
+            return f"map<string, {value_type}>"
+
+    def _analyze_unknown_type_with_source_priority(self, field_type_byte: int, objects: List[str], object_index: int) -> str:
+        """
+        分析未知字节码类型，进行智能推断，优先使用Java源码分析结果
+        
+        Args:
+            field_type_byte: 未知的字节码类型
+            objects: 对象数组
+            object_index: 当前对象索引
+            
+        Returns:
+            推断的字段类型
+        """
+        # 分析字节码的结构
+        wire_type = field_type_byte & 7  # 低3位是wire type
+        field_number = field_type_byte >> 3  # 高位是field number
+        
+        self.logger.debug(f"    🔬 字节码分析: byte={field_type_byte}, wire_type={wire_type}, field_number={field_number}")
+        
+        # 第一步：尝试从Java源码获取真实类型
+        java_type = None
+        if object_index < len(objects) and self.java_source_analyzer:
+            field_name_raw = objects[object_index]
+            try:
+                java_type = self._get_java_field_type_for_unknown(field_name_raw)
+                if java_type:
+                    self.logger.info(f"    ✅ Java源码分析: {field_name_raw} -> {java_type}")
+            except Exception as e:
+                self.logger.debug(f"    ⚠️  Java源码分析失败: {e}")
+        
+        # 第二步：基于wire type进行字节码推断
+        bytecode_type = self._analyze_unknown_type_by_wire_type(wire_type, objects, object_index, field_type_byte)
+        
+        # 第三步：交叉校验和最终决策
+        final_type = self._cross_validate_types(java_type, bytecode_type, wire_type, field_type_byte)
+        
+        if java_type and java_type != final_type:
+            self.logger.info(f"    🔄 类型校验: Java({java_type}) vs 字节码({bytecode_type}) -> 最终({final_type})")
+        
+        return final_type
+    
+    def _get_java_field_type_for_unknown(self, field_name_raw: str) -> Optional[str]:
+        """
+        从Java源码中获取未知字段的真实类型
+        
+        Args:
+            field_name_raw: 原始字段名（如 latitude_）
+            
+        Returns:
+            Java字段的proto类型，如果无法获取则返回None
+        """
+        if not self.java_source_analyzer:
+            return None
+            
+        try:
+            # 获取Java字段的原始类型
+            java_raw_type = self.java_source_analyzer.get_raw_field_type(field_name_raw)
+            if not java_raw_type:
+                return None
+            
+            # 将Java类型转换为proto类型
+            proto_type = self._java_type_to_proto_type(java_raw_type)
+            return proto_type
+            
+        except Exception as e:
+            self.logger.debug(f"    ⚠️  获取Java字段类型失败: {e}")
+            return None
+    
+    def _java_type_to_proto_type(self, java_type: str) -> str:
+        """
+        将Java类型转换为proto类型
+        
+        Args:
+            java_type: Java类型字符串
+            
+        Returns:
+            对应的proto类型
+        """
+        # 基础类型映射
+        type_mapping = {
+            'boolean': 'bool',
+            'byte': 'int32',
+            'short': 'int32', 
+            'int': 'int32',
+            'long': 'int64',
+            'float': 'float',
+            'double': 'double',
+            'String': 'string',
+            'ByteString': 'bytes',
+        }
+        
+        # 直接映射
+        if java_type in type_mapping:
+            return type_mapping[java_type]
+        
+        # 处理复杂类型
+        if java_type.startswith('MapFieldLite<'):
+            return 'map'
+        elif java_type.startswith('Internal.ProtobufList<') or java_type.startswith('List<'):
+            return 'message'  # repeated message
+        elif java_type.endswith('[]'):
+            return 'message'  # repeated
+        elif '.' in java_type and java_type.split('.')[-1][0].isupper():
+            # 看起来像是类名，可能是message或enum
+            return 'message'  # 默认为message，具体类型由其他逻辑确定
+        
+        # 默认返回string
+        return 'string'
+    
+    def _analyze_unknown_type_by_wire_type(self, wire_type: int, objects: List[str], object_index: int, field_type_byte: int) -> str:
+        """
+        基于wire type分析未知字节码类型
+        
+        Args:
+            wire_type: wire type (0-5)
+            objects: 对象数组
+            object_index: 当前对象索引
+            field_type_byte: 原始字节码类型
+            
+        Returns:
+            推断的字段类型
+        """
+        if wire_type == 0:
+            # VARINT: int32, int64, uint32, uint64, sint32, sint64, bool, enum
+            return self._infer_varint_type(objects, object_index)
+        elif wire_type == 1:
+            # 64-BIT: fixed64, sfixed64, double
+            return 'double'  # 默认为double（比int64更常见）
+        elif wire_type == 2:
+            # LENGTH_DELIMITED: string, bytes, embedded messages, packed repeated fields
+            return self._infer_length_delimited_type(objects, object_index, field_type_byte)
+        elif wire_type == 5:
+            # 32-BIT: fixed32, sfixed32, float
+            return 'float'  # 默认为float
+        else:
+            # 其他未知wire type
+            self.logger.warning(f"    ⚠️  未知wire type: {wire_type}")
+            return self._fallback_type_inference(objects, object_index)
+    
+    def _cross_validate_types(self, java_type: Optional[str], bytecode_type: str, wire_type: int, field_type_byte: int) -> str:
+        """
+        交叉校验Java类型和字节码类型，返回最终类型
+        
+        Args:
+            java_type: Java源码分析得到的类型
+            bytecode_type: 字节码分析得到的类型
+            wire_type: wire type
+            field_type_byte: 原始字节码类型
+            
+        Returns:
+            最终确定的字段类型
+        """
+        # 如果没有Java类型信息，使用字节码推断
+        if not java_type:
+            return bytecode_type
+        
+        # 如果Java类型和字节码类型一致，直接返回
+        if java_type == bytecode_type:
+            return java_type
+        
+        # 类型不一致时的校验逻辑
+        if wire_type == 0:  # VARINT
+            # 对于VARINT类型，Java源码更准确
+            if java_type in ['bool', 'int32', 'int64', 'uint32', 'uint64', 'sint32', 'sint64']:
+                return java_type
+            elif java_type == 'message':  # 可能是enum
+                return 'enum' if bytecode_type == 'enum' else java_type
+        elif wire_type == 1:  # 64-BIT
+            # 对于64位类型，Java源码更准确
+            if java_type in ['double', 'fixed64', 'sfixed64']:
+                return java_type
+        elif wire_type == 2:  # LENGTH_DELIMITED
+            # 对于长度分隔类型，Java源码更准确
+            if java_type in ['string', 'bytes', 'message', 'map']:
+                return java_type
+        elif wire_type == 5:  # 32-BIT
+            # 对于32位类型，Java源码更准确
+            if java_type in ['float', 'fixed32', 'sfixed32']:
+                return java_type
+        
+        # 默认优先使用Java类型
+        self.logger.info(f"    🔧 类型冲突，优先使用Java类型: {java_type} (字节码推断: {bytecode_type})")
+        return java_type
+
+    def _infer_varint_type(self, objects: List[str], object_index: int) -> str:
+        """推断VARINT类型字段"""
+        # 检查objects数组中是否有类型提示
+        if object_index < len(objects):
+            field_name = objects[object_index].rstrip('_')
+            
+            # 基于字段名推断
+            if any(keyword in field_name.lower() for keyword in ['type', 'status', 'mode', 'enum']):
+                return 'enum'
+            elif field_name.lower() in ['count', 'size', 'length', 'number']:
+                return 'int32'
+            elif field_name.lower().endswith('_id') or field_name.lower() == 'id':
+                return 'int64'
+            elif field_name.lower() in ['enabled', 'visible', 'active', 'valid']:
+                return 'bool'
+        
+        return 'int32'  # 默认为int32
+    
+    def _infer_length_delimited_type(self, objects: List[str], object_index: int, field_type_byte: int) -> str:
+        """推断LENGTH_DELIMITED类型字段"""
+        # 检查是否可能是map类型（基于已知的map类型字节码模式）
+        if field_type_byte == 50 or field_type_byte in range(48, 60):  # 扩展map类型的可能范围
+            return 'map'
+        
+        # 检查objects数组中是否有类型提示
+        if object_index < len(objects):
+            field_name = objects[object_index].rstrip('_')
+            
+            # 基于字段名推断
+            if field_name.lower().endswith('map') or field_name.lower().endswith('mapping'):
+                return 'map'
+            elif field_name.lower() in ['name', 'title', 'description', 'text', 'url', 'email']:
+                return 'string'
+            elif field_name.lower().endswith('data') or field_name.lower().endswith('bytes'):
+                return 'bytes'
+            elif field_name.lower().endswith('s') and len(field_name) > 2:
+                # 复数形式，可能是repeated字段
+                return 'message'  # repeated message
+        
+        return 'string'  # 默认为string
+    
+    def _fallback_type_inference(self, objects: List[str], object_index: int) -> str:
+        """兜底类型推断"""
+        if object_index < len(objects):
+            field_name = objects[object_index].rstrip('_')
+            
+            # 基于字段名的通用推断
+            if any(keyword in field_name.lower() for keyword in ['id', 'count', 'size', 'number']):
+                return 'int32'
+            elif any(keyword in field_name.lower() for keyword in ['name', 'title', 'text', 'url']):
+                return 'string'
+            elif field_name.lower().endswith('s'):
+                return 'message'  # 可能是repeated字段
+        
+        return 'string'  # 最终兜底
+
     @staticmethod
     def _to_snake_case(camel_str: str) -> str:
         """

core/reconstructor.py

@@ -15,6 +15,7 @@ from collections import deque
 from typing import Set, Dict, List, Optional
 
 from parsing.java_parser import JavaParser
+from parsing.enum_parser import EnumParser
 from core.info_decoder import InfoDecoder
 from generation.proto_generator import ProtoGenerator
 from models.message_definition import MessageDefinition, EnumDefinition, EnumValueDefinition
@@ -28,19 +29,44 @@ class JavaSourceAnalyzer:
         self.sources_dir = sources_dir
         self._current_class_content = None
         self._current_class_name = None
+        # 初始化JavaParser用于字段类型解析
+        self.java_parser = JavaParser()
     
     def set_current_class(self, class_name: str):
         """设置当前分析的类"""
         self._current_class_name = class_name
         self._current_class_content = self._load_class_content(class_name)
     
+    def get_raw_field_type(self, field_name_raw: str) -> Optional[str]:
+        """
+        获取字段的原始Java类型
+        
+        Args:
+            field_name_raw: 原始字段名（如 latitude_）
+            
+        Returns:
+            字段的Java原始类型，如果找不到则返回None
+        """
+        if not self._current_class_name:
+            return None
+        
+        # 构建Java文件路径
+        file_path = self._current_class_name.replace('.', '/') + '.java'
+        java_file_path = self.sources_dir / file_path
+        
+        if not java_file_path.exists():
+            return None
+        
+        # 使用JavaParser获取字段类型
+        return self.java_parser.get_raw_field_type(java_file_path, field_name_raw)
+    
     def get_field_type(self, field_name_raw: str, expected_type: str) -> Optional[str]:
         """
         从Java源码中获取字段的真实类型
         
         Args:
             field_name_raw: 原始字段名（如 id_）
-            expected_type: 期望的基础类型（message 或 enum）
+            expected_type: 期望的基础类型（message、enum 或 map）
             
         Returns:
             真实的类型名，如果无法获取则返回None
@@ -51,6 +77,12 @@ class JavaSourceAnalyzer:
         # 清理字段名
         field_name = field_name_raw.rstrip('_')
         
+        # 对于map类型，特殊处理MapFieldLite声明
+        if expected_type == 'map':
+            map_type = self._get_map_type_from_field(field_name)
+            if map_type:
+                return map_type
+        
         # 对于枚举类型，优先从setter方法中获取类型
         if expected_type == 'enum':
             setter_type = self._get_type_from_setter(field_name)
@@ -82,6 +114,63 @@ class JavaSourceAnalyzer:
         
         return None
     
+    def _get_map_type_from_field(self, field_name: str) -> Optional[str]:
+        """
+        从MapFieldLite字段声明中获取map的键值类型
+        
+        Args:
+            field_name: 字段名（如 contacts）
+            
+        Returns:
+            map类型字符串，如 "map<string, Contact>"
+        """
+        # 查找MapFieldLite字段声明：private MapFieldLite<String, Contact> contacts_ = ...
+        pattern = rf'private\s+MapFieldLite<([^,]+),\s*([^>]+)>\s+{re.escape(field_name)}_\s*='
+        matches = re.findall(pattern, self._current_class_content)
+        
+        if matches:
+            key_type, value_type = matches[0]
+            key_type = key_type.strip()
+            value_type = value_type.strip()
+            
+            # 转换Java类型到protobuf类型
+            proto_key_type = self._java_type_to_proto_type(key_type)
+            proto_value_type = self._java_type_to_proto_type(value_type)
+            
+            return f"map<{proto_key_type}, {proto_value_type}>"
+        
+        return None
+    
+    def _java_type_to_proto_type(self, java_type: str) -> str:
+        """
+        将Java类型转换为protobuf类型
+        
+        Args:
+            java_type: Java类型名
+            
+        Returns:
+            protobuf类型名
+        """
+        # 基础类型映射
+        basic_types = {
+            'String': 'string',
+            'Integer': 'int32',
+            'Long': 'int64',
+            'Boolean': 'bool',
+            'Float': 'float',
+            'Double': 'double',
+            'ByteString': 'bytes'
+        }
+        
+        if java_type in basic_types:
+            return basic_types[java_type]
+        
+        # 对于其他类型，去掉包名，只保留类名
+        if '.' in java_type:
+            return java_type.split('.')[-1]
+        
+        return java_type
+
     def _get_type_from_setter(self, field_name: str) -> Optional[str]:
         """
         从setter方法中获取字段的真实类型（特别适用于枚举类型）
@@ -189,16 +278,19 @@ class ProtoReconstructor:
         # 广度优先处理所有依赖类
         self._process_all_classes()
         
-        # 生成最终的proto文件
+                # 生成最终的proto文件
         self._generate_all_proto_files()
         
+        # 报告未知类型统计
+        self._report_unknown_types()
+        
         # 返回处理结果
         results = {}
         for class_name, message_def in self.message_definitions.items():
             results[class_name] = message_def
         for class_name, enum_def in self.enum_definitions.items():
             results[class_name] = enum_def
-        
+            
         return results
         
     def _process_all_classes(self) -> None:
@@ -666,6 +758,18 @@ class ProtoReconstructor:
         
         return self.output_dir / package_path / proto_name
     
+    def _report_unknown_types(self) -> None:
+        """报告未知字节码类型的统计信息"""
+        if not self.info_decoder.unknown_types_stats:
+            return
+            
+        self.logger.warning("📊 发现未知字节码类型统计:")
+        for byte_code, count in sorted(self.info_decoder.unknown_types_stats.items()):
+            wire_type = byte_code & 7
+            self.logger.warning(f"   类型 {byte_code} (0x{byte_code:02x}, wire_type={wire_type}): {count} 次")
+        
+        self.logger.warning("💡 建议: 请将这些信息反馈给开发者，以便完善类型映射表")
+
     @staticmethod
     def _to_snake_case(camel_str: str) -> str:
         """

generation/proto_generator.py

@@ -262,6 +262,23 @@ class ProtoGenerator:
         if field.type_name in basic_types:
             return None
         
+        # 处理map类型：map<string, Contact> -> 提取值类型Contact
+        if field.type_name.startswith('map<'):
+            # 解析map类型：map<key_type, value_type>
+            import re
+            match = re.match(r'map<([^,]+),\s*([^>]+)>', field.type_name)
+            if match:
+                key_type, value_type = match.groups()
+                key_type = key_type.strip()
+                value_type = value_type.strip()
+                
+                # 只处理值类型的导入（键类型通常是基础类型）
+                if value_type not in basic_types:
+                    full_class_name = self._resolve_full_class_name(value_type, current_package, all_messages)
+                    if full_class_name:
+                        return self._class_name_to_import_path(full_class_name)
+            return None
+        
         # 解析完整类名
         full_class_name = self._resolve_full_class_name(field.type_name, current_package, all_messages)
         if full_class_name:
@@ -325,6 +342,23 @@ class ProtoGenerator:
         if basic_type:
             return basic_type
         
+        # 处理map类型：map<string, Contact> -> map<string, Contact>
+        if field.type_name.startswith('map<'):
+            # 解析map类型并清理值类型名
+            import re
+            match = re.match(r'map<([^,]+),\s*([^>]+)>', field.type_name)
+            if match:
+                key_type, value_type = match.groups()
+                key_type = key_type.strip()
+                value_type = value_type.strip()
+                
+                # 如果值类型是完整类名，提取简单类型名
+                if '.' in value_type:
+                    value_type = value_type.split('.')[-1]
+                
+                return f"map<{key_type}, {value_type}>"
+            return field.type_name
+        
         # 枚举类型：根据字段名生成枚举类型名
         if field.type_name == 'enum':
             return self._generate_enum_type_name(field.name)

main.py

@@ -6,10 +6,10 @@ Protobuf重构器 - 命令行入口
 支持任意Android应用，完全基于Java字节码推断
 
 Usage:
-    python -m proto_reconstructor.main <java_sources_dir> <root_class> <output_dir> [--log-dir LOG_DIR]
+    python -m reproto.main <java_sources_dir> <root_class> <output_dir> [--log-dir LOG_DIR]
 
 Example:
-    python -m proto_reconstructor.main ./out_jadx/sources com.example.Model ./protos_generated --log-dir ./logs
+    python -m reproto.main ./out_jadx/sources com.example.Model ./protos_generated --log-dir ./logs
 
 Author: AI Assistant
 """

parsing/enum_parser.py

@@ -8,8 +8,8 @@
 import re
 import os
 from typing import List, Optional, Dict, Tuple
-from ..models.message_definition import EnumDefinition, EnumValue
-from ..utils.logger import get_logger
+from models.message_definition import EnumDefinition, EnumValueDefinition
+from utils.logger import get_logger
 
 
 class EnumParser:
@@ -129,7 +129,7 @@ class EnumParser:
         
         return enum_def
     
-    def _extract_enum_values(self, content: str) -> List[EnumValue]:
+    def _extract_enum_values(self, content: str) -> List[EnumValueDefinition]:
         """
         从Java内容中提取枚举值
         
@@ -161,7 +161,7 @@ class EnumParser:
                 
             try:
                 value = int(value_str)
-                enum_values.append(EnumValue(name=name, value=value))
+                enum_values.append(EnumValueDefinition(name=name, value=value))
             except ValueError:
                 continue
         

parsing/java_parser.py

@@ -253,4 +253,104 @@ class JavaParser:
         # 按数值排序
         enum_values.sort(key=lambda x: x[1])
         
-        return enum_values 
+        return enum_values
+
+    def get_raw_field_type(self, java_file_path: Path, field_name_raw: str) -> Optional[str]:
+        """
+        从Java文件中获取指定字段的原始类型
+        
+        Args:
+            java_file_path: Java文件路径
+            field_name_raw: 原始字段名（如 latitude_）
+            
+        Returns:
+            字段的Java原始类型，如果找不到则返回None
+        """
+        try:
+            # 读取Java文件内容
+            content = java_file_path.read_text(encoding='utf-8')
+            
+            # 查找字段声明
+            field_type = self._extract_field_type_from_content(content, field_name_raw)
+            return field_type
+            
+        except Exception as e:
+            self.logger.debug(f"获取字段类型失败 {java_file_path} - {field_name_raw}: {e}")
+            return None
+    
+    def _extract_field_type_from_content(self, content: str, field_name_raw: str) -> Optional[str]:
+        """
+        从Java文件内容中提取指定字段的类型
+        
+        Args:
+            content: Java文件内容
+            field_name_raw: 原始字段名（如 latitude_）
+            
+        Returns:
+            字段的Java类型，如果找不到则返回None
+        """
+        # 构建字段声明的正则表达式模式
+        # 匹配: private Type fieldName_ = ...;
+        # 或: private Type fieldName_;
+        
+        # 转义字段名中的特殊字符
+        escaped_field_name = re.escape(field_name_raw)
+        
+        # 字段声明模式
+        patterns = [
+            # 标准字段声明: private Type fieldName_ = value;
+            rf'private\s+([^\s]+(?:<[^>]*>)?(?:\[\])?)\s+{escaped_field_name}\s*=',
+            # 简单字段声明: private Type fieldName_;
+            rf'private\s+([^\s]+(?:<[^>]*>)?(?:\[\])?)\s+{escaped_field_name}\s*;',
+            # 其他访问修饰符
+            rf'(?:public|protected|package)\s+([^\s]+(?:<[^>]*>)?(?:\[\])?)\s+{escaped_field_name}\s*[=;]',
+            # 无访问修饰符
+            rf'([^\s]+(?:<[^>]*>)?(?:\[\])?)\s+{escaped_field_name}\s*[=;]',
+        ]
+        
+        for pattern in patterns:
+            matches = re.finditer(pattern, content, re.MULTILINE)
+            for match in matches:
+                field_type = match.group(1).strip()
+                
+                # 清理类型字符串
+                cleaned_type = self._clean_field_type(field_type)
+                if cleaned_type:
+                    self.logger.debug(f"找到字段类型: {field_name_raw} -> {cleaned_type}")
+                    return cleaned_type
+        
+        self.logger.debug(f"未找到字段类型: {field_name_raw}")
+        return None
+    
+    def _clean_field_type(self, field_type: str) -> Optional[str]:
+        """
+        清理和标准化字段类型字符串
+        
+        Args:
+            field_type: 原始字段类型字符串
+            
+        Returns:
+            清理后的字段类型，如果无效则返回None
+        """
+        if not field_type:
+            return None
+        
+        # 移除多余的空白字符
+        field_type = field_type.strip()
+        
+        # 跳过明显不是类型的字符串
+        if field_type in ['private', 'public', 'protected', 'static', 'final', 'volatile', 'transient']:
+            return None
+        
+        # 处理泛型类型，保留完整的泛型信息
+        # 例如: MapFieldLite<String, Contact> 保持不变
+        
+        # 处理数组类型
+        # 例如: String[] 保持不变
+        
+        # 处理完全限定类名，提取简单类名
+        if '.' in field_type and not field_type.startswith('java.'):
+            # 对于非java包的类，保留完整路径以便后续处理
+            pass
+        
+        return field_type 

pyproject.toml

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

{reproto-0.0.4.dist-info → reproto-0.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: reproto
-Version: 0.0.4
+Version: 0.0.6
 Summary: 一个强大的逆向工程工具, 能够从任何使用Google Protobuf Lite的Android应用中自动重构出完整的.proto文件结构.
 License: MIT
 Author: iyue
@@ -51,7 +51,7 @@ python main.py <java_sources_dir> <root_class> <output_dir>
 pip install -e .
 
 # 使用命令行工具
-proto-reconstructor <java_sources_dir> <root_class> <output_dir>
+reproto <java_sources_dir> <root_class> <output_dir>
 ```
 
 ## 📖 使用方法
@@ -102,7 +102,7 @@ Java源码 → 字节码提取 → 类型解码 → 依赖发现 → 源码验
 ## 📁 项目结构
 
 ```
-proto_reconstructor/
+reproto/
 ├── main.py                     # 主程序入口
 ├── core/                       # 核心组件
 │   ├── reconstructor.py        # 主协调器
@@ -203,8 +203,8 @@ reproto/
 # 指定日志目录
 python main.py sources/ com.example.Model output/ --log-dir ./my_logs
 
-# 日志文件格式: proto_reconstructor-YYYY-MM-DD-HH-MM-SS.log
-# 例如: proto_reconstructor-2024-01-15-14-30-25.log
+# 日志文件格式: reproto-YYYY-MM-DD-HH-MM-SS.log
+# 例如: reproto-2024-01-15-14-30-25.log
 ```
 
 ### 输出格式

reproto-0.0.6.dist-info/RECORD

@@ -0,0 +1,75 @@
+.git/COMMIT_EDITMSG,sha256=Hea4DGHC9RyGOOEnEt-_pfDdB3L7RtWaxnPnBx2rnlk,21
+.git/HEAD,sha256=ly8yuQLWQE8njkYAapHLPJ1xVg6_fMgQjCoHqKvFIdw,21
+.git/config,sha256=9ZAySfDWBdI-K9eOXyrEQOhiX68AiaP0Z4CLzH07H10,399
+.git/description,sha256=hatsFj1DoX6pz3eIMIvKFGbxsKjRzJLibpv2PaQGKu4,73
+.git/hooks/applypatch-msg.sample,sha256=AiNJeguLAzqlijpSG4YphpOGz3qw4vEBlj0yiqYhk_c,478
+.git/hooks/commit-msg.sample,sha256=H3TV6SkpebVz69WXQdRsuT_zkazdCD00C5Q3B1PZJDc,896
+.git/hooks/fsmonitor-watchman.sample,sha256=4FSZZOk4l7UZvY4zPAN-Uf_w-IuhPghqMxWSv4AfodA,4726
+.git/hooks/post-update.sample,sha256=gXZa8trvMjBh3LxeYfwWSBy3SzusmtihdLGGUjWG9sU,189
+.git/hooks/pre-applypatch.sample,sha256=4VxbRp6j4KaVvqbyyCvPjmKCEHSTnd2Ft34AB_8WVHU,424
+.git/hooks/pre-commit.sample,sha256=Vxhbe58FI516tS2wRfW4nrMTSNeyF36rIU9euHLhlxs,1649
+.git/hooks/pre-merge-commit.sample,sha256=04JacDN5QOu9ClwHKYThMkWSDN-ImL0iXI0npt_Jy1M,416
+.git/hooks/pre-push.sample,sha256=7M6cfgTT9d2ditqBdT3R1UmpY0smdwBCtY3aACF9CGo,1374
+.git/hooks/pre-rebase.sample,sha256=T-vOhneQBSM4B29OZsxH77FIedGAl9HWHIJhhZ6qp7M,4898
+.git/hooks/pre-receive.sample,sha256=pMPSuce7P9jRRBwxvU7nGlldZrRPz0ndsxAlIyAWmYk,544
+.git/hooks/prepare-commit-msg.sample,sha256=6d3KpBif3dJe2X_Ix4nsp7bKFjkLI5KuMnbwyOGqRhk,1492
+.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=YTfUxO97azpqKz93n54JOz0EQrxW2d7pC4DiyZIneSA,1991
+.git/info/exclude,sha256=ZnH-g7egfIky7okWTR8nk7IxgFjri5jcXAbuClo7DsE,240
+.git/logs/HEAD,sha256=DPBwJI-_VLEGt3MjtwCVyFMm-ib4-HXdOfihB3ghdKQ,514
+.git/logs/refs/heads/iyue,sha256=DPBwJI-_VLEGt3MjtwCVyFMm-ib4-HXdOfihB3ghdKQ,514
+.git/logs/refs/remotes/gitlab/iyue,sha256=QBjy4D_3oChB5vr-wT4YakTTJnYxfU2yqdXbi2IPJBM,272
+.git/logs/refs/remotes/origin/HEAD,sha256=4vCPTgC0N80jhmkFXNUlYvHtGllYJkQTGZEn6LlqZgs,163
+.git/logs/refs/remotes/origin/iyue,sha256=p8CXhH9pCCyFVXjXK6XHxgAPZmVmm6KmcdrZ5aFAxgA,272
+.git/objects/09/a92517fe9eeb33d2fd7c979e01d163665f7abc,sha256=wyFL5jJ16f0xCpL1MB5EiJvs2opieE0hMEmyDpUV3ps,9356
+.git/objects/14/d323d58fb90c209a730c17e23fd82a6c735fc1,sha256=rTCuhPM5LYusLIMDv7CLC557SlRFvvbBzgr4jwrjMVg,426
+.git/objects/18/89a4fb55eb3abdc528ce87f0cea039278c06fd,sha256=Uz8TPtDNnPWR5pfsIx7tMDCDFBdWLIkaPcnYPIJ12oM,2880
+.git/objects/23/bfbca38e177bcbb423dd782c35b19d127a5ab0,sha256=hYW2b3t3bVGNh4pqyyA7DMlyF4LfNZco5NwedWMwwuI,3700
+.git/objects/33/181441ab38eded005db356da89b54c7d29f452,sha256=iIM6a2aGs_TGZjxHKnkYYyZj_hA77nAF7r2lMOtN1VA,2021
+.git/objects/40/84f4567d983a977c49598b7d886e46b13ff50b,sha256=R3w6EvxpJRcVuJvbCslrGDK07kcOjECGGosj5tO-JBo,426
+.git/objects/48/369b05749e384be9be58e5f943f3a0040d0f37,sha256=KP9dXx-XniZuIEXESlrL_MWWi55zGiFr7xtmp3oD67o,8551
+.git/objects/7c/00eec7ae9ef5f94fc337e5c8f9793a2a48810d,sha256=Ju-Yuy5EARcIThU4vkHrZuHQWu3MjXSZYGtBDTWR18c,96
+.git/objects/a3/cedc28e563a1845a7860161b39b0fe58d5f0d3,sha256=Vee0H8dhSj4ERNDSAnRU6vebs0tbY1-lgYr1Nz5X7bc,122
+.git/objects/a5/b7e4e1b63bfb65288f6553687aaabcfb4d51b1,sha256=9tl9xb48EdvQk9GIg6mEzXSwqUgD6yEVZx-sVxaQVKw,1064
+.git/objects/d0/9c84ad2142a187bf26a1714b7041b62e404c8f,sha256=twhhaZbfU_mgu5LIlt9ZeGjp_PT_gri_9H231H5nrNc,2172
+.git/objects/d9/6d7456245232b3e159dcf691f11e51224c557a,sha256=3w45hxiT2rn6ljSdgo36fHMMWZt30r5C1FPvbnjq9tc,597
+.git/objects/e8/2f42ea26b8bf4f0bc92c0648ac8f190f14226d,sha256=xtbEwloZnqXdNdViAevzyprosfPQ1P--xAu6URGlaYI,155
+.git/objects/ed/fb5bbf938de738d1f658f80e23c675bb8b3fae,sha256=MOYiuXKTxnd9YcqU3-HUVUq2g9fPU1-AKZOQ-3xsWCk,4237
+.git/objects/ef/4844af55f7f64b8dd24b81b5a8322a8c80208e,sha256=hO8yllVMOtIE4HeOvwKSqQUByH6lvaA4L-RYrSU4vlg,167
+.git/objects/f2/2bfffda9fb6a7f37bed04b7c40c9466ef09454,sha256=goQNyEV3NqzS28mMXuus1SWzwb8yXnvEPef14Ugzh5Q,750
+.git/objects/f5/18c69a6e1bf3052b79da01502b2837ea58f0f4,sha256=r98SFbCvw7yeAYTjzkw-2VMhOVbpm79FLZQiC5A1-pw,123
+.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=fqogai84mA-74wSv8UR7XVOxAU72CKbFfMD-1g_-tW0,41
+.git/refs/remotes/gitlab/iyue,sha256=fqogai84mA-74wSv8UR7XVOxAU72CKbFfMD-1g_-tW0,41
+.git/refs/remotes/origin/HEAD,sha256=G8pFPTbCqnJ2IkCzz9J-STqOXWU6TrlXfpt1wx5bUWE,30
+.git/refs/remotes/origin/iyue,sha256=fqogai84mA-74wSv8UR7XVOxAU72CKbFfMD-1g_-tW0,41
+.gitignore,sha256=ThRUL1E38Z_Q4Lww0xYYl9ziFaPUvvwwqxbmp2cuwco,2068
+.python-version,sha256=NxOs_9lT1XG8y-FjlRru-YinX5RcBJt_ulPwgDESZ_o,7
+ARCHITECTURE.md,sha256=JALnUdREwdLRAmcUit5CGAPLpeZ6UfoYpAQkxil3NJc,8322
+README.md,sha256=t7zYDpLSOC7VDFPlQKOOoqe09GN38wLl0fbbJUT5sNg,6019
+core/__init__.py,sha256=ajz1GSNU9xYVrFEDSz6Xwg7amWQ_yvW75tQa1ZvRIWc,3
+core/bytecode_parser.py,sha256=87ZGhnyBNGP-gRjIyRUcGfWS2HR1YA_e1OBKafLEEDc,11532
+core/info_decoder.py,sha256=DgXDlMaNudOYXKJiPKfE3PeIrzN3Da-PlsQkkrnV2Hs,33959
+core/reconstructor.py,sha256=eOJg6rx0Gkb3bzeuIKB_myt3mC61dsn7AP30EAJyqfg,29377
+generation/__init__.py,sha256=ajz1GSNU9xYVrFEDSz6Xwg7amWQ_yvW75tQa1ZvRIWc,3
+generation/proto_generator.py,sha256=nd9rkjoOAJiY-aOSJz8RQd0z5WLN28zOi_vavwvpjes,16131
+main.py,sha256=1qRMdQjetlqowe8HsEh46MCbat3NMx1ym0Nb9MOEFuE,5272
+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=6J16XlLIV-qktPDT1ccY70BngpP9VhwlXH0Z76TWHqM,11714
+pyproject.toml,sha256=ZBqGZxCm8ldtItBhMb5pxKEvnP1IHrvhPWhHKpRkzR0,901
+requirements.txt,sha256=cQGj3IS6Kj88jbwj_jeKkokMnG-fEezWve91mfW4CJs,96
+utils/__init__.py,sha256=ajz1GSNU9xYVrFEDSz6Xwg7amWQ_yvW75tQa1ZvRIWc,3
+utils/file_utils.py,sha256=N1Ei7hmyeOkIyZJFEXyNbtTrfeVF2hP-U8evXAVW2MA,4085
+utils/logger.py,sha256=473DfzFVXzdGpiRTJGY6bBd-V5G80_P07gQqcvDChpQ,2447
+reproto-0.0.6.dist-info/METADATA,sha256=_RJz-0nYSnt5nxAkqCQoZPf8t-ybLJYOGzqQsYTT3r0,6577
+reproto-0.0.6.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+reproto-0.0.6.dist-info/entry_points.txt,sha256=6Oro9lK_2DXDgHiB3andNuIE78wxfooqacqp8yY1C-g,37
+reproto-0.0.6.dist-info/RECORD,,

utils/logger.py

@@ -35,9 +35,9 @@ class LoggerManager:
         log_path = Path(log_dir)
         log_path.mkdir(exist_ok=True)
         
-        # 生成日志文件名：proto_reconstructor-YYYY-MM-DD-HH-MM-SS.log
+        # 生成日志文件名：reproto-YYYY-MM-DD-HH-MM-SS.log
         timestamp = datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
-        log_file = log_path / f"proto_reconstructor-{timestamp}.log"
+        log_file = log_path / f"reproto-{timestamp}.log"
         
         # 控制台输出 - 彩色格式
         logger.add(

reproto-0.0.4.dist-info/RECORD

@@ -1,53 +0,0 @@
-.git/HEAD,sha256=ly8yuQLWQE8njkYAapHLPJ1xVg6_fMgQjCoHqKvFIdw,21
-.git/config,sha256=6mE3z55UjVFEIsUWmiN6Bw_IJPK92slDZMSanpih0ok,287
-.git/description,sha256=hatsFj1DoX6pz3eIMIvKFGbxsKjRzJLibpv2PaQGKu4,73
-.git/hooks/applypatch-msg.sample,sha256=AiNJeguLAzqlijpSG4YphpOGz3qw4vEBlj0yiqYhk_c,478
-.git/hooks/commit-msg.sample,sha256=H3TV6SkpebVz69WXQdRsuT_zkazdCD00C5Q3B1PZJDc,896
-.git/hooks/fsmonitor-watchman.sample,sha256=4FSZZOk4l7UZvY4zPAN-Uf_w-IuhPghqMxWSv4AfodA,4726
-.git/hooks/post-update.sample,sha256=gXZa8trvMjBh3LxeYfwWSBy3SzusmtihdLGGUjWG9sU,189
-.git/hooks/pre-applypatch.sample,sha256=4VxbRp6j4KaVvqbyyCvPjmKCEHSTnd2Ft34AB_8WVHU,424
-.git/hooks/pre-commit.sample,sha256=Vxhbe58FI516tS2wRfW4nrMTSNeyF36rIU9euHLhlxs,1649
-.git/hooks/pre-merge-commit.sample,sha256=04JacDN5QOu9ClwHKYThMkWSDN-ImL0iXI0npt_Jy1M,416
-.git/hooks/pre-push.sample,sha256=7M6cfgTT9d2ditqBdT3R1UmpY0smdwBCtY3aACF9CGo,1374
-.git/hooks/pre-rebase.sample,sha256=T-vOhneQBSM4B29OZsxH77FIedGAl9HWHIJhhZ6qp7M,4898
-.git/hooks/pre-receive.sample,sha256=pMPSuce7P9jRRBwxvU7nGlldZrRPz0ndsxAlIyAWmYk,544
-.git/hooks/prepare-commit-msg.sample,sha256=6d3KpBif3dJe2X_Ix4nsp7bKFjkLI5KuMnbwyOGqRhk,1492
-.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=uNpkl4Ngnok-FuwXpx-733gwa0mDR3EJQHNSWlKGVY4,1991
-.git/info/exclude,sha256=ZnH-g7egfIky7okWTR8nk7IxgFjri5jcXAbuClo7DsE,240
-.git/logs/HEAD,sha256=8inae4CFVxR4Psim5jd6PmrnSmipVxT3rS8zFAe0Cnc,163
-.git/logs/refs/heads/iyue,sha256=8inae4CFVxR4Psim5jd6PmrnSmipVxT3rS8zFAe0Cnc,163
-.git/logs/refs/remotes/origin/HEAD,sha256=8inae4CFVxR4Psim5jd6PmrnSmipVxT3rS8zFAe0Cnc,163
-.git/objects/pack/pack-55d9855fa45cb686f64bef472f9a7940ef78b8d6.idx,sha256=dM0mT5EXOaEswaA71NFzz6Fh3B9iF9IN1SXVxeD80aw,2304
-.git/objects/pack/pack-55d9855fa45cb686f64bef472f9a7940ef78b8d6.pack,sha256=RkehkvasbBDavK-cSTnrVcGGYGUiWgUxZVhjsDbYrT4,41437
-.git/objects/pack/pack-55d9855fa45cb686f64bef472f9a7940ef78b8d6.rev,sha256=rIyIFQiRY9AcV_xf0UA4im0PAeyvHtrkew59RQ5QaFU,228
-.git/packed-refs,sha256=NZVl-0AkdTQlT4H1r599fFDdUKwCjFwzQYxAYwUrSvg,112
-.git/refs/heads/iyue,sha256=G3DrpPS-kI_DVAakJCukrkaQcp3JNpkozc-HEtV7qEI,41
-.git/refs/remotes/origin/HEAD,sha256=G8pFPTbCqnJ2IkCzz9J-STqOXWU6TrlXfpt1wx5bUWE,30
-.gitignore,sha256=ThRUL1E38Z_Q4Lww0xYYl9ziFaPUvvwwqxbmp2cuwco,2068
-.python-version,sha256=NxOs_9lT1XG8y-FjlRru-YinX5RcBJt_ulPwgDESZ_o,7
-ARCHITECTURE.md,sha256=JALnUdREwdLRAmcUit5CGAPLpeZ6UfoYpAQkxil3NJc,8322
-README.md,sha256=P71PU1DNUaLUAR15ja18AdZL0gobBh7xrUJeVZdlCbc,6067
-core/__init__.py,sha256=ajz1GSNU9xYVrFEDSz6Xwg7amWQ_yvW75tQa1ZvRIWc,3
-core/bytecode_parser.py,sha256=87ZGhnyBNGP-gRjIyRUcGfWS2HR1YA_e1OBKafLEEDc,11532
-core/info_decoder.py,sha256=n_U7c4syhDkfez5WXOxXi-CVQ3AMUISpGqixcHqzHHA,19214
-core/reconstructor.py,sha256=9mNV_6YRLNjlSGxzrS4lU3yE8bzu-mwCD3zmw973nIk,25666
-generation/__init__.py,sha256=ajz1GSNU9xYVrFEDSz6Xwg7amWQ_yvW75tQa1ZvRIWc,3
-generation/proto_generator.py,sha256=en-BAgikOzkDH7gdagX97iNIb5pTBN0ieVt5MnuL_BI,14535
-main.py,sha256=3hQ-_YmW5Weq14h040V48_W5DSb-xTXpMMb6vRjCbF8,5296
-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=tBflR9bjC8LRe4cWw19i_ibCedWWB7ICQtbOQdpiWVc,6149
-parsing/java_parser.py,sha256=Rk5_S02rqlqNU3OF7BMK57NynFAoxIHINyhnA6rUuhI,7897
-pyproject.toml,sha256=Rw3OlS4oKb05Fas7SFxlmZRSttTWoQELZ2U0jgN8PQg,901
-requirements.txt,sha256=cQGj3IS6Kj88jbwj_jeKkokMnG-fEezWve91mfW4CJs,96
-utils/__init__.py,sha256=ajz1GSNU9xYVrFEDSz6Xwg7amWQ_yvW75tQa1ZvRIWc,3
-utils/file_utils.py,sha256=N1Ei7hmyeOkIyZJFEXyNbtTrfeVF2hP-U8evXAVW2MA,4085
-utils/logger.py,sha256=TaDXUHq5BQAsolswwHDeFUbXAfgL_fhXgxAcs901xmQ,2471
-reproto-0.0.4.dist-info/METADATA,sha256=h0ISgdD0h4xYwQ6zGoX_DsEnEmS6NyKg8oKdjh2VEjk,6625
-reproto-0.0.4.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-reproto-0.0.4.dist-info/entry_points.txt,sha256=6Oro9lK_2DXDgHiB3andNuIE78wxfooqacqp8yY1C-g,37
-reproto-0.0.4.dist-info/RECORD,,