adam-community 1.0.0__tar.gz → 1.0.2__tar.gz

adam_community-1.0.2/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.2
+Name: adam_community
+Version: 1.0.2
+Summary: Adam Community Tools and Utilities
+Home-page: https://github.com/yourusername/adam-community
+Author: Adam Community
+Author-email: admin@sidereus-ai.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0
+Requires-Dist: click>=8.0.0
+Requires-Dist: docstring-parser>=0.15
+Requires-Dist: rich>=13.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Adam Community
+
+Adam Community 是一个 Python 工具包，提供了 CLI 命令行工具和 Python 模块，用于解析和构建 Python 项目包。
+
+## 安装
+
+```bash
+pip install -e .
+```
+
+## 使用方式
+
+### CLI 命令行
+
+查看帮助：
+```bash
+adam-cli --help
+```
+
+初始化新项目：
+```bash
+adam-cli init
+```
+
+解析 Python 文件生成 functions.json：
+```bash
+adam-cli parse .
+```
+
+构建项目包：
+```bash
+adam-cli build .
+```
+
+### Python 模块导入
+
+```python
+from adam_community.cli.parser import parse_directory, parse_python_file
+from adam_community.cli.build import build_package
+
+# 解析目录下的 Python 文件
+classes = parse_directory(Path("./"))
+
+# 构建项目包
+success, errors, zip_name = build_package(Path("./"))
+```
+
+## 功能特性
+
+- **Python 文件解析**: 自动解析 Python 类和函数的文档字符串
+- **JSON Schema 验证**: 将 Python 类型转换为 JSON Schema 并验证
+- **项目构建**: 检查配置文件、文档文件并创建 zip 包
+- **类型检查**: 支持多种 Python 类型注解格式
+
+## 开发
+
+安装依赖：
+```bash
+make install
+```
+
+运行测试：
+```bash
+make test
+```
+
+构建包：
+```bash
+make build
+```

adam_community-1.0.2/README.md

@@ -0,0 +1,70 @@
+# Adam Community
+
+Adam Community 是一个 Python 工具包，提供了 CLI 命令行工具和 Python 模块，用于解析和构建 Python 项目包。
+
+## 安装
+
+```bash
+pip install -e .
+```
+
+## 使用方式
+
+### CLI 命令行
+
+查看帮助：
+```bash
+adam-cli --help
+```
+
+初始化新项目：
+```bash
+adam-cli init
+```
+
+解析 Python 文件生成 functions.json：
+```bash
+adam-cli parse .
+```
+
+构建项目包：
+```bash
+adam-cli build .
+```
+
+### Python 模块导入
+
+```python
+from adam_community.cli.parser import parse_directory, parse_python_file
+from adam_community.cli.build import build_package
+
+# 解析目录下的 Python 文件
+classes = parse_directory(Path("./"))
+
+# 构建项目包
+success, errors, zip_name = build_package(Path("./"))
+```
+
+## 功能特性
+
+- **Python 文件解析**: 自动解析 Python 类和函数的文档字符串
+- **JSON Schema 验证**: 将 Python 类型转换为 JSON Schema 并验证
+- **项目构建**: 检查配置文件、文档文件并创建 zip 包
+- **类型检查**: 支持多种 Python 类型注解格式
+
+## 开发
+
+安装依赖：
+```bash
+make install
+```
+
+运行测试：
+```bash
+make test
+```
+
+构建包：
+```bash
+make build
+```

adam_community-1.0.2/adam_community/__init__.py

@@ -0,0 +1,14 @@
+from .util import messageSend, knowledgeSearch, completionCreate, runCmd
+from .tool import Tool
+from .cli.parser import parse_python_file, parse_directory, convert_python_type_to_json_schema
+
+__all__ = [
+    'Tool', 
+    'messageSend', 
+    'knowledgeSearch', 
+    'completionCreate', 
+    'runCmd',
+    'parse_python_file',
+    'parse_directory', 
+    'convert_python_type_to_json_schema'
+]

adam_community-1.0.2/adam_community/cli/__init__.py

@@ -0,0 +1 @@
+

{adam_community-1.0.0 → adam_community-1.0.2}/adam_community/cli/build.py

@@ -1,4 +1,5 @@
 import json
+import sys
 import zipfile
 from pathlib import Path
 from typing import Tuple, List
@@ -14,29 +15,40 @@ def check_python_files(directory: Path) -> Tuple[bool, List[str]]:
     tree = Tree("📦 Python 文件检查")
     errors = []
     warnings = []
-    functions = parse_directory(directory)
     
-    tree.add(f"找到 {len(functions)} 个类定义")
+    # 解析 Python 文件，如果出现错误则退出
+    try:
+        functions = parse_directory(directory)
+    except Exception as e:
+        console.print(Panel.fit(
+            f"[bold red]❌ 解析 Python 文件时出错[/bold red]\n{str(e)}",
+            border_style="red"
+        ))
+        console.print("[red]构建失败，请检查并修复上述错误后重试。[/red]")
+        sys.exit(1)
+    
+    # 统计信息
+    total_functions = len(functions)
+    functions_with_desc = 0
+    functions_with_params = 0
+    
     for func in functions:
         func_info = func["function"]
         
         # 检查描述长度
         description = func_info.get("description")
         if description is None or not description:
-            warning_msg = f"⚠️ {func_info['file']}: {func_info['name']} 没有描述"
-            tree.add(warning_msg)
+            warning_msg = f"⚠️ {func_info['name']} 没有描述"
             warnings.append(warning_msg)
         elif len(description) > 1024:
-            error_msg = f"❌ {func_info['file']}: {func_info['name']} 描述长度超过1024字符 ({len(description)})"
-            tree.add(error_msg)
+            error_msg = f"❌ {func_info['name']} 描述长度超过1024字符 ({len(description)})"
             errors.append(error_msg)
         else:
-            tree.add(f"✓ {func_info['file']}: {func_info['name']} 描述长度: {len(description)}")
+            functions_with_desc += 1
 
         # 检查参数定义
         if not func_info["parameters"]["properties"]:
-            warning_msg = f"⚠️ {func_info['file']}: {func_info['name']} 没有参数定义"
-            tree.add(warning_msg)
+            warning_msg = f"⚠️ {func_info['name']} 没有参数定义"
             warnings.append(warning_msg)
         else:
             # 检查参数类型是否都是有效的JSON Schema类型
@@ -49,33 +61,43 @@ def check_python_files(directory: Path) -> Tuple[bool, List[str]]:
             
             if param_errors:
                 for param_error in param_errors:
-                    error_msg = f"❌ {func_info['file']}: {func_info['name']} - {param_error}"
-                    tree.add(error_msg)
+                    error_msg = f"❌ {func_info['name']} - {param_error}"
                     errors.append(error_msg)
             else:
-                tree.add(f"✓ {func_info['file']}: {func_info['name']} 参数类型验证通过")
+                functions_with_params += 1
     
+    # 显示简化的统计信息
+    console.print(f"📦 Python 文件检查: 找到 {total_functions} 个类定义")
+    console.print(f"   ✓ 描述完整: {functions_with_desc}/{total_functions}")
+    console.print(f"   ✓ 参数完整: {functions_with_params}/{total_functions}")
+    
+    # 显示错误和警告
     if errors:
-        tree.add("❌ 检查未通过")
-    else:
-        tree.add("✅ 检查通过")
+        console.print(f"   ❌ {len(errors)} 个错误:")
+        for error in errors[:5]:  # 只显示前5个错误
+            console.print(f"      {error}")
+        if len(errors) > 5:
+            console.print(f"      ... 还有 {len(errors) - 5} 个错误")
     
-    # 显示警告信息
     if warnings:
-        tree.add(f"⚠️ 发现 {len(warnings)} 个警告（不影响构建）")
-    
-    console.print(tree)
+        console.print(f"   ⚠️ {len(warnings)} 个警告 (不影响构建)")
+        if len(warnings) <= 3:
+            for warning in warnings:
+                console.print(f"      {warning}")
+        else:
+            console.print(f"      {warnings[0]}")
+            console.print(f"      ... 还有 {len(warnings) - 1} 个警告")
     return len(errors) == 0, errors
 
 def check_configuration(directory: Path) -> Tuple[bool, List[str]]:
     """检查 configure.json 文件"""
-    tree = Tree("📄 配置文件检查")
     errors = []
     config_path = directory / "config" / "configure.json"
     
+    console.print("📄 配置文件检查:")
+    
     if not config_path.exists():
-        tree.add("❌ 未找到 configure.json 文件")
-        console.print(tree)
+        console.print("   ❌ 未找到 configure.json 文件")
         return False, ["configure.json 文件不存在"]
     
     try:
@@ -83,28 +105,30 @@ def check_configuration(directory: Path) -> Tuple[bool, List[str]]:
             config = json.load(f)
         
         required_fields = ["name", "version", "display_name"]
+        valid_fields = 0
+        
         for field in required_fields:
             if field not in config:
                 errors.append(f"configure.json 缺少必要字段: {field}")
-                tree.add(f"❌ 缺少字段: {field}")
             else:
-                tree.add(f"✓ {field}: {config[field]}")
+                valid_fields += 1
+        
+        console.print(f"   ✓ 字段完整: {valid_fields}/{len(required_fields)}")
         
         if errors:
-            tree.add("❌ 检查未通过")
+            console.print(f"   ❌ {len(errors)} 个错误:")
+            for error in errors:
+                console.print(f"      {error}")
         else:
-            tree.add("✅ 检查通过")
+            console.print(f"   ✓ 包信息: {config['name']} v{config['version']}")
         
-        console.print(tree)
         return len(errors) == 0, errors
     except json.JSONDecodeError:
-        tree.add("❌ 配置文件格式错误")
-        console.print(tree)
+        console.print("   ❌ 配置文件格式错误")
         return False, ["configure.json 文件格式错误"]
 
 def check_markdown_files(directory: Path) -> Tuple[bool, List[str]]:
     """检查必要的 Markdown 文件"""
-    tree = Tree("📑 Markdown 文件检查")
     errors = []
     
     # 先读取配置文件中的 type 字段
@@ -133,88 +157,88 @@ def check_markdown_files(directory: Path) -> Tuple[bool, List[str]]:
             "long_description.md"
         ]
     
-    tree.add(f"检查类型: {config_type}")
+    console.print(f"📑 文档文件检查 ({config_type} 类型):")
     
+    valid_files = 0
     for file in required_files:
         file_path = directory / "config" / file
         if not file_path.exists():
             errors.append(f"缺少必要文件: {file}")
-            tree.add(f"❌ {file}")
         else:
             # 对于 input.json，额外检查 JSON 格式
             if file == "input.json":
                 try:
                     with open(file_path, 'r', encoding='utf-8') as f:
                         json.load(f)
-                    tree.add(f"✓ {file} (JSON 格式正确)")
+                    valid_files += 1
                 except json.JSONDecodeError:
                     errors.append(f"{file} JSON 格式错误")
-                    tree.add(f"❌ {file} (JSON 格式错误)")
             else:
-                tree.add(f"✓ {file}")
+                valid_files += 1
+    
+    console.print(f"   ✓ 文件完整: {valid_files}/{len(required_files)}")
     
     if errors:
-        tree.add("❌ 检查未通过")
-    else:
-        tree.add("✅ 检查通过")
+        console.print(f"   ❌ {len(errors)} 个错误:")
+        for error in errors:
+            console.print(f"      {error}")
     
-    console.print(tree)
     return len(errors) == 0, errors
 
 def create_zip_package(directory: Path) -> str:
     """创建 zip 包"""
-    tree = Tree("📦 创建压缩包")
     with open(directory / "config" / "configure.json", 'r', encoding='utf-8') as f:
         config = json.load(f)
     
     zip_name = f"{config['name']}_{config['version']}.zip"
     zip_path = directory / zip_name
     
-    tree.add(f"包名: {zip_name}")
+    console.print("📦 创建压缩包:")
+    console.print(f"   包名: {zip_name}")
     
     # 获取配置类型
     config_type = config.get("type", "agent")
+    file_count = 0
     
     with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
         # 添加所有 Python 文件
-        py_files = list(directory.rglob('*.py'))
-        py_tree = tree.add("Python 文件")
+        py_files = [f for f in directory.rglob('*.py') if not f.name.startswith('_')]
         for py_file in py_files:
-            if not py_file.name.startswith('_'):
-                zipf.write(py_file, py_file.relative_to(directory))
-                py_tree.add(f"+ {py_file.relative_to(directory)}")
+            zipf.write(py_file, py_file.relative_to(directory))
+            file_count += 1
         
         # 添加配置文件
-        config_tree = tree.add("配置文件")
         zipf.write(directory / "config" / "configure.json", "config/configure.json")
-        config_tree.add("+ config/configure.json")
+        file_count += 1
         
         # 添加 demos 目录
-        demos_tree = tree.add("Demos 文件")
         demos_dir = directory / "demos"
+        demos_files = 0
         if demos_dir.exists() and demos_dir.is_dir():
             for demos_file in demos_dir.rglob('*'):
                 if demos_file.is_file():
                     zipf.write(demos_file, demos_file.relative_to(directory))
-                    demos_tree.add(f"+ {demos_file.relative_to(directory)}")
+                    file_count += 1
+                    demos_files += 1
         
         # 根据类型添加不同的文件
-        md_tree = tree.add("其他文件")
         if config_type == "kit":
-            # kit 类型需要添加的文件
             other_files = ["long_description.md", "input.json"]
         else:
-            # agent 类型需要添加的文件
             other_files = ["initial_assistant_message.md", "initial_system_prompt.md", "long_description.md"]
         
         for file in other_files:
             file_path = directory / "config" / file
             if file_path.exists():
                 zipf.write(file_path, f"config/{file}")
-                md_tree.add(f"+ config/{file}")
+                file_count += 1
+    
+    console.print(f"   ✓ Python 文件: {len(py_files)} 个")
+    console.print(f"   ✓ 配置文件: 1 个")
+    if demos_files > 0:
+        console.print(f"   ✓ 演示文件: {demos_files} 个")
+    console.print(f"   ✓ 总计: {file_count} 个文件")
     
-    tree.add("✅ 压缩包创建完成")
-    console.print(tree)
     return zip_name
 
 def build_package(directory: Path) -> Tuple[bool, List[str], str]:
@@ -236,18 +260,21 @@ def build_package(directory: Path) -> Tuple[bool, List[str], str]:
     if not py_passed:
         all_passed = False
         all_errors.extend(py_errors)
+    console.print()  # 添加空行
     
     # 2. 检查配置文件
     config_passed, config_errors = check_configuration(directory)
     if not config_passed:
         all_passed = False
         all_errors.extend(config_errors)
+    console.print()  # 添加空行
     
     # 3. 检查 Markdown 文件
     md_passed, md_errors = check_markdown_files(directory)
     if not md_passed:
         all_passed = False
         all_errors.extend(md_errors)
+    console.print()  # 添加空行
     
     # 如果所有检查都通过，创建 zip 包
     zip_name = ""
@@ -262,7 +289,8 @@ def build_package(directory: Path) -> Tuple[bool, List[str], str]:
         ))
     else:
         console.print(Panel.fit(
-            "[bold red]❌ 构建失败！[/bold red]\n" + "\n".join(all_errors),
+            f"[bold red]❌ 构建失败！[/bold red]\n"
+            f"共发现 {len(all_errors)} 个错误，请修复后重试。",
             border_style="red"
         ))
     

{adam_community-1.0.0 → adam_community-1.0.2}/adam_community/cli/parser.py

@@ -2,6 +2,7 @@ import ast
 from pathlib import Path
 from typing import List, Dict, Any
 from docstring_parser import parse as dsp
+import jsonschema
 
 def convert_python_type_to_json_schema(python_type: str) -> Dict[str, Any]:
     """将 Python 类型转换为 JSON Schema 类型
@@ -13,7 +14,7 @@ def convert_python_type_to_json_schema(python_type: str) -> Dict[str, Any]:
         Dict[str, Any]: JSON Schema 类型定义
         
     Raises:
-        ValueError: 当无法转换类型时抛出异常
+        ValueError: 当无法转换类型或生成的 schema 不符合规范时抛出异常
     """
     python_type = python_type.lower().strip()
     
@@ -40,7 +41,13 @@ def convert_python_type_to_json_schema(python_type: str) -> Dict[str, Any]:
     
     # 处理基本类型
     if python_type in basic_types:
-        return {"type": basic_types[python_type]}
+        schema_type = basic_types[python_type]
+        if schema_type == "array":
+            # 对于没有指定元素类型的数组，应该报错要求明确指定
+            raise ValueError(f"数组类型 '{python_type}' 缺少元素类型定义，请使用 List[ElementType] 格式明确指定元素类型")
+        else:
+            schema = {"type": schema_type}
+        return _create_and_validate_schema(schema, python_type)
     
     # 处理 Literal[T1, T2, ...] 格式
     if python_type.startswith('literal[') and python_type.endswith(']'):
@@ -50,22 +57,22 @@ def convert_python_type_to_json_schema(python_type: str) -> Dict[str, Any]:
         # 尝试推断类型
         if all(v.isdigit() or (v.startswith('-') and v[1:].isdigit()) for v in values):
             # 所有值都是整数
-            return {
+            return _create_and_validate_schema({
                 "type": "integer",
                 "enum": [int(v) for v in values]
-            }
+            }, python_type)
         elif all(v.replace('.', '').replace('-', '').isdigit() for v in values):
             # 所有值都是数字
-            return {
+            return _create_and_validate_schema({
                 "type": "number",
                 "enum": [float(v) for v in values]
-            }
+            }, python_type)
         else:
             # 字符串类型
-            return {
+            return _create_and_validate_schema({
                 "type": "string",
                 "enum": values
-            }
+            }, python_type)
     
     # 处理 Union[T1, T2, ...] 或 T1 | T2 格式
     if python_type.startswith('union[') and python_type.endswith(']'):
@@ -83,12 +90,12 @@ def convert_python_type_to_json_schema(python_type: str) -> Dict[str, Any]:
         inner_type = python_type[9:-1].strip()
         try:
             inner_schema = convert_python_type_to_json_schema(inner_type)
-            return {
+            return _create_and_validate_schema({
                 "oneOf": [
                     inner_schema,
                     {"type": "null"}
                 ]
-            }
+            }, python_type)
         except ValueError as e:
             raise ValueError(f"无法转换Optional类型 '{python_type}': {str(e)}")
     
@@ -97,10 +104,10 @@ def convert_python_type_to_json_schema(python_type: str) -> Dict[str, Any]:
         inner_type = python_type[5:-1]  # 提取 List[ 和 ] 之间的内容
         try:
             items_schema = convert_python_type_to_json_schema(inner_type)
-            return {
+            return _create_and_validate_schema({
                 "type": "array",
                 "items": items_schema
-            }
+            }, python_type)
         except ValueError as e:
             raise ValueError(f"无法转换列表元素类型 '{inner_type}': {str(e)}")
     
@@ -109,10 +116,10 @@ def convert_python_type_to_json_schema(python_type: str) -> Dict[str, Any]:
         inner_type = python_type[5:-1]
         try:
             items_schema = convert_python_type_to_json_schema(inner_type)
-            return {
+            return _create_and_validate_schema({
                 "type": "array",
                 "items": items_schema
-            }
+            }, python_type)
         except ValueError as e:
             raise ValueError(f"无法转换列表元素类型 '{inner_type}': {str(e)}")
     
@@ -128,29 +135,90 @@ def convert_python_type_to_json_schema(python_type: str) -> Dict[str, Any]:
             try:
                 key_schema = convert_python_type_to_json_schema(key_type)
                 value_schema = convert_python_type_to_json_schema(value_type)
-                return {
+                return _create_and_validate_schema({
                     "type": "object",
                     "additionalProperties": value_schema
-                }
+                }, python_type)
             except ValueError as e:
                 raise ValueError(f"无法转换字典类型 '{python_type}': {str(e)}")
         else:
             # 只有值类型的情况
             try:
                 value_schema = convert_python_type_to_json_schema(content.strip())
-                return {
+                return _create_and_validate_schema({
                     "type": "object",
                     "additionalProperties": value_schema
-                }
+                }, python_type)
             except ValueError as e:
                 raise ValueError(f"无法转换字典值类型 '{content}': {str(e)}")
     
     # 处理枚举类型
     if python_type == 'enum':
-        return {"type": "string"}
+        return _create_and_validate_schema({"type": "string"}, python_type)
+    
+    # 如果无法识别，返回基本的 object 类型
+    schema = {"type": "object"}
+    
+    # 验证生成的 schema
+    try:
+        validate_json_schema(schema)
+        return schema
+    except ValueError as e:
+        raise ValueError(f"生成的 JSON Schema 不符合规范 (类型: '{python_type}'): {str(e)}")
+    
+def _create_and_validate_schema(schema: Dict[str, Any], python_type: str) -> Dict[str, Any]:
+    """创建并验证 JSON Schema
     
-    # 如果无法识别，抛出异常
-    raise ValueError(f"无法转换的Python类型: '{python_type}'")
+    Args:
+        schema: 要验证的 schema
+        python_type: 原始 Python 类型（用于错误信息）
+        
+    Returns:
+        Dict[str, Any]: 验证通过的 schema
+        
+    Raises:
+        ValueError: 当 schema 不符合规范时抛出异常
+    """
+    try:
+        validate_json_schema(schema)
+        return schema
+    except ValueError as e:
+        raise ValueError(f"生成的 JSON Schema 不符合规范 (类型: '{python_type}'): {str(e)}")
+
+def validate_json_schema(schema: Dict[str, Any], context: str = "") -> None:
+    """验证生成的 JSON Schema 是否符合规范
+    
+    Args:
+        schema: 要验证的 JSON Schema
+        context: 上下文信息，用于错误报告
+        
+    Raises:
+        ValueError: 当 schema 不符合规范时抛出异常
+    """
+    try:
+        # 使用 JSON Schema Draft 7 验证器
+        jsonschema.Draft7Validator.check_schema(schema)
+        
+        # 额外的自定义验证
+        if schema.get("type") == "array" and "items" not in schema:
+            raise ValueError(f"array schema missing items{f' in {context}' if context else ''}")
+            
+        if schema.get("type") == "object":
+            if "properties" in schema:
+                for prop_name, prop_schema in schema["properties"].items():
+                    validate_json_schema(prop_schema, f"{context}.{prop_name}" if context else prop_name)
+            if "additionalProperties" in schema and isinstance(schema["additionalProperties"], dict):
+                validate_json_schema(schema["additionalProperties"], f"{context}.additionalProperties" if context else "additionalProperties")
+                
+        if "oneOf" in schema:
+            for i, sub_schema in enumerate(schema["oneOf"]):
+                validate_json_schema(sub_schema, f"{context}.oneOf[{i}]" if context else f"oneOf[{i}]")
+                
+        if "items" in schema:
+            validate_json_schema(schema["items"], f"{context}.items" if context else "items")
+            
+    except jsonschema.SchemaError as e:
+        raise ValueError(f"Invalid JSON Schema{f' in {context}' if context else ''}: {str(e)}")
 
 def convert_union_types(types: List[str]) -> Dict[str, Any]:
     """转换联合类型为 JSON Schema
@@ -174,7 +242,9 @@ def convert_union_types(types: List[str]) -> Dict[str, Any]:
     if len(schemas) == 1:
         return schemas[0]
     else:
-        return {"oneOf": schemas}
+        result_schema = {"oneOf": schemas}
+        validate_json_schema(result_schema)
+        return result_schema
 
 def validate_description_length(description: str, function_name: str, file_path: str) -> None:
     """验证函数描述长度
@@ -285,6 +355,15 @@ def parse_python_file(file_path: Path) -> List[Dict[str, Any]]:
                                 f"参数 '{p.arg_name}' 的类型转换失败: {str(e)}"
                             )
                 
+                # 验证最终的 parameters schema
+                try:
+                    validate_json_schema(parameters, f"function '{node.name}' parameters")
+                except ValueError as e:
+                    raise ValueError(
+                        f"在文件 '{file_path}' 的函数 '{node.name}' 中，"
+                        f"生成的参数 schema 不符合规范: {str(e)}"
+                    )
+                
                 class_info = {
                     "function": {
                         "name": f"{file_path.stem}.{node.name}",
@@ -305,8 +384,8 @@ def parse_python_file(file_path: Path) -> List[Dict[str, Any]]:
         
         return classes
     except Exception as e:
-        print(f"解析文件 {file_path} 时出错: {str(e)}")
-        return []
+        print(f"解析文件 {file_path.name} 时出错: {str(e)}")
+        raise  # 重新抛出异常，让上层处理
 
 def parse_directory(directory: Path) -> List[Dict[str, Any]]:
     """解析目录下的所有 Python 文件

adam_community-1.0.2/adam_community.egg-info/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.2
+Name: adam_community
+Version: 1.0.2
+Summary: Adam Community Tools and Utilities
+Home-page: https://github.com/yourusername/adam-community
+Author: Adam Community
+Author-email: admin@sidereus-ai.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0
+Requires-Dist: click>=8.0.0
+Requires-Dist: docstring-parser>=0.15
+Requires-Dist: rich>=13.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Adam Community
+
+Adam Community 是一个 Python 工具包，提供了 CLI 命令行工具和 Python 模块，用于解析和构建 Python 项目包。
+
+## 安装
+
+```bash
+pip install -e .
+```
+
+## 使用方式
+
+### CLI 命令行
+
+查看帮助：
+```bash
+adam-cli --help
+```
+
+初始化新项目：
+```bash
+adam-cli init
+```
+
+解析 Python 文件生成 functions.json：
+```bash
+adam-cli parse .
+```
+
+构建项目包：
+```bash
+adam-cli build .
+```
+
+### Python 模块导入
+
+```python
+from adam_community.cli.parser import parse_directory, parse_python_file
+from adam_community.cli.build import build_package
+
+# 解析目录下的 Python 文件
+classes = parse_directory(Path("./"))
+
+# 构建项目包
+success, errors, zip_name = build_package(Path("./"))
+```
+
+## 功能特性
+
+- **Python 文件解析**: 自动解析 Python 类和函数的文档字符串
+- **JSON Schema 验证**: 将 Python 类型转换为 JSON Schema 并验证
+- **项目构建**: 检查配置文件、文档文件并创建 zip 包
+- **类型检查**: 支持多种 Python 类型注解格式
+
+## 开发
+
+安装依赖：
+```bash
+make install
+```
+
+运行测试：
+```bash
+make test
+```
+
+构建包：
+```bash
+make build
+```

{adam_community-1.0.0 → adam_community-1.0.2}/setup.py

@@ -3,7 +3,7 @@ import os
 
 setup(
     name="adam_community",
-    version="1.0.0",
+    version="1.0.2",
     packages=find_packages(),
     install_requires=[
         "requests>=2.31.0",

adam_community-1.0.0/PKG-INFO

@@ -1,53 +0,0 @@
-Metadata-Version: 2.2
-Name: adam_community
-Version: 1.0.0
-Summary: Adam Community Tools and Utilities
-Home-page: https://github.com/yourusername/adam-community
-Author: Adam Community
-Author-email: admin@sidereus-ai.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-Requires-Dist: requests>=2.31.0
-Requires-Dist: click>=8.0.0
-Requires-Dist: docstring-parser>=0.15
-Requires-Dist: rich>=13.0.0
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# Adam Community
-
-Adam Community 是一个 Python 工具包，提供了一系列实用工具和功能，用于与 Adam 社区相关的开发工作。
-
-安装依赖：
-```bash
-make install
-```
-
-
-## 使用方法
-
-安装完成后，您可以在 Python 代码中导入并使用该包：
-
-```python
-from adam_community import tool
-from adam_community import util
-
-# 使用相关功能
-```
-
-## 开发
-
-运行测试：
-```bash
-make test
-```

adam_community-1.0.0/README.md

@@ -1,27 +0,0 @@
-# Adam Community
-
-Adam Community 是一个 Python 工具包，提供了一系列实用工具和功能，用于与 Adam 社区相关的开发工作。
-
-安装依赖：
-```bash
-make install
-```
-
-
-## 使用方法
-
-安装完成后，您可以在 Python 代码中导入并使用该包：
-
-```python
-from adam_community import tool
-from adam_community import util
-
-# 使用相关功能
-```
-
-## 开发
-
-运行测试：
-```bash
-make test
-```

adam_community-1.0.0/adam_community/__init__.py

@@ -1,4 +0,0 @@
-from .util import messageSend, knowledgeSearch, completionCreate, runCmd
-from .tool import Tool
-
-__all__ = ['Tool', 'messageSend', 'knowledgeSearch', 'completionCreate', 'runCmd']

adam_community-1.0.0/adam_community.egg-info/PKG-INFO

@@ -1,53 +0,0 @@
-Metadata-Version: 2.2
-Name: adam_community
-Version: 1.0.0
-Summary: Adam Community Tools and Utilities
-Home-page: https://github.com/yourusername/adam-community
-Author: Adam Community
-Author-email: admin@sidereus-ai.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-Requires-Dist: requests>=2.31.0
-Requires-Dist: click>=8.0.0
-Requires-Dist: docstring-parser>=0.15
-Requires-Dist: rich>=13.0.0
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# Adam Community
-
-Adam Community 是一个 Python 工具包，提供了一系列实用工具和功能，用于与 Adam 社区相关的开发工作。
-
-安装依赖：
-```bash
-make install
-```
-
-
-## 使用方法
-
-安装完成后，您可以在 Python 代码中导入并使用该包：
-
-```python
-from adam_community import tool
-from adam_community import util
-
-# 使用相关功能
-```
-
-## 开发
-
-运行测试：
-```bash
-make test
-```