adam-community 1.0.1__tar.gz → 1.0.3__tar.gz

adam_community-1.0.3/PKG-INFO

@@ -0,0 +1,104 @@
+Metadata-Version: 2.2
+Name: adam_community
+Version: 1.0.3
+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
+Requires-Dist: packaging>=21.0
+Requires-Dist: jsonschema>=4.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 .
+```
+
+更新 CLI 到最新版本：
+```bash
+adam-cli update
+```
+
+### 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.3/README.md

@@ -0,0 +1,76 @@
+# 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 .
+```
+
+更新 CLI 到最新版本：
+```bash
+adam-cli update
+```
+
+### 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.1 → adam_community-1.0.3}/adam_community/__init__.py

@@ -1,6 +1,7 @@
 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
+from .__version__ import __version__
 
 __all__ = [
     'Tool', 

adam_community-1.0.3/adam_community/__version__.py

@@ -0,0 +1 @@
+__version__ = "1.0.3"

{adam_community-1.0.1 → adam_community-1.0.3}/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.1 → adam_community-1.0.3}/adam_community/cli/cli.py

@@ -4,11 +4,13 @@ from pathlib import Path
 from .parser import parse_directory
 from .build import build_package
 from .init import init
+from .updater import check_and_notify_update, update_cli, set_update_disabled
 
 @click.group()
 def cli():
     """Adam Community CLI 工具"""
-    pass
+    # 检查更新（静默执行，不影响正常功能）
+    check_and_notify_update()
 
 @cli.command()
 @click.argument('directory', type=click.Path(exists=True, file_okay=False, dir_okay=True), default='.')
@@ -41,6 +43,33 @@ def build(directory):
             click.echo(f"- {error}")
         raise click.Abort()
 
+@cli.command()
+def update():
+    """更新 CLI 到最新版本"""
+    if update_cli():
+        click.echo("\n🎉 更新完成！重新运行命令以使用新版本。")
+    else:
+        click.echo("\n❌ 更新失败，请手动更新或检查网络连接。")
+        click.echo("手动更新命令：pip install --upgrade adam-community")
+
+@cli.command()
+@click.option('--disable-update-check', is_flag=True, help='禁用自动更新检查')
+@click.option('--enable-update-check', is_flag=True, help='启用自动更新检查')
+def config(disable_update_check, enable_update_check):
+    """配置 CLI 设置"""
+    if disable_update_check and enable_update_check:
+        click.echo("错误：不能同时启用和禁用更新检查")
+        return
+    
+    if disable_update_check:
+        set_update_disabled(True)
+        click.echo("✅ 已禁用自动更新检查")
+    elif enable_update_check:
+        set_update_disabled(False) 
+        click.echo("✅ 已启用自动更新检查")
+    else:
+        click.echo("请使用 --disable-update-check 或 --enable-update-check 选项")
+
 # 添加 init 命令
 cli.add_command(init)
 

{adam_community-1.0.1 → adam_community-1.0.3}/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.3/adam_community/cli/updater.py

@@ -0,0 +1,201 @@
+import json
+import subprocess
+import sys
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Optional, Tuple
+import requests
+from packaging import version
+import click
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+def get_cache_dir() -> Path:
+    """获取缓存目录"""
+    cache_dir = Path.home() / ".adam_cli" / "cache"
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    return cache_dir
+
+def get_current_version() -> str:
+    """获取当前版本"""
+    try:
+        # 尝试从 setup.py 或 __version__ 获取版本
+        from adam_community import __version__
+        return __version__
+    except ImportError:
+        # 如果无法导入，尝试从 pip 获取
+        try:
+            result = subprocess.run(
+                [sys.executable, "-m", "pip", "show", "adam-community"], 
+                capture_output=True, text=True, timeout=10
+            )
+            if result.returncode == 0:
+                for line in result.stdout.split('\n'):
+                    if line.startswith('Version:'):
+                        return line.split(':', 1)[1].strip()
+        except:
+            pass
+        return "unknown"
+
+def get_latest_version_from_pypi() -> Optional[str]:
+    """从 PyPI 获取最新版本"""
+    try:
+        response = requests.get(
+            "https://pypi.org/pypi/adam-community/json", 
+            timeout=5
+        )
+        if response.status_code == 200:
+            data = response.json()
+            return data['info']['version']
+    except:
+        pass
+    return None
+
+def should_check_update() -> bool:
+    """检查是否需要检查更新（基于缓存时间）"""
+    cache_file = get_cache_dir() / "last_update_check.json"
+    
+    if not cache_file.exists():
+        return True
+    
+    try:
+        with open(cache_file, 'r') as f:
+            data = json.load(f)
+        
+        last_check = datetime.fromisoformat(data['last_check'])
+        # 24小时检查一次
+        return datetime.now() - last_check > timedelta(hours=24)
+    except:
+        return True
+
+def save_check_time():
+    """保存检查时间"""
+    cache_file = get_cache_dir() / "last_update_check.json"
+    
+    try:
+        with open(cache_file, 'w') as f:
+            json.dump({
+                'last_check': datetime.now().isoformat()
+            }, f)
+    except:
+        pass
+
+def is_update_disabled() -> bool:
+    """检查是否禁用了自动更新检查"""
+    config_file = get_cache_dir() / "config.json"
+    
+    if not config_file.exists():
+        return False
+    
+    try:
+        with open(config_file, 'r') as f:
+            config = json.load(f)
+        return config.get('disable_update_check', False)
+    except:
+        return False
+
+def set_update_disabled(disabled: bool):
+    """设置是否禁用自动更新检查"""
+    config_file = get_cache_dir() / "config.json"
+    
+    try:
+        config = {}
+        if config_file.exists():
+            with open(config_file, 'r') as f:
+                config = json.load(f)
+        
+        config['disable_update_check'] = disabled
+        
+        with open(config_file, 'w') as f:
+            json.dump(config, f, indent=2)
+    except:
+        pass
+
+def check_for_update() -> Tuple[bool, Optional[str], Optional[str]]:
+    """检查更新，返回(有更新, 当前版本, 最新版本)"""
+    if is_update_disabled():
+        return False, None, None
+    
+    if not should_check_update():
+        return False, None, None
+    
+    current_ver = get_current_version()
+    latest_ver = get_latest_version_from_pypi()
+    
+    save_check_time()
+    
+    if current_ver == "unknown" or latest_ver is None:
+        return False, current_ver, latest_ver
+    
+    try:
+        has_update = version.parse(latest_ver) > version.parse(current_ver)
+        return has_update, current_ver, latest_ver
+    except:
+        return False, current_ver, latest_ver
+
+def show_update_notification(current_ver: str, latest_ver: str):
+    """显示更新通知"""
+    console.print()
+    console.print(Panel.fit(
+        f"[yellow]📦 发现新版本！[/yellow]\n"
+        f"当前版本: [red]{current_ver}[/red]\n"
+        f"最新版本: [green]{latest_ver}[/green]\n\n"
+        f"[dim]运行以下命令更新：[/dim]\n"
+        f"[cyan]adam-cli update[/cyan]\n\n"
+        f"[dim]或运行以下命令禁用更新检查：[/dim]\n"
+        f"[cyan]adam-cli config --disable-update-check[/cyan]",
+        border_style="yellow",
+        title="[yellow]🚀 更新提醒[/yellow]"
+    ))
+    console.print()
+
+def update_cli():
+    """更新 CLI 到最新版本"""
+    console.print("🔍 检查最新版本...")
+    
+    latest_ver = get_latest_version_from_pypi()
+    if latest_ver is None:
+        console.print("[red]❌ 无法获取最新版本信息，请检查网络连接[/red]")
+        return False
+    
+    current_ver = get_current_version()
+    
+    if current_ver != "unknown":
+        try:
+            if version.parse(current_ver) >= version.parse(latest_ver):
+                console.print(f"[green]✅ 已是最新版本 {current_ver}[/green]")
+                return True
+        except:
+            pass
+    
+    console.print(f"📦 开始更新到版本 {latest_ver}...")
+    
+    try:
+        # 使用 pip 更新
+        result = subprocess.run([
+            sys.executable, "-m", "pip", "install", "--upgrade", "adam-community"
+        ], capture_output=True, text=True)
+        
+        if result.returncode == 0:
+            console.print(f"[green]✅ 更新成功！[/green]")
+            console.print(f"[green]当前版本: {latest_ver}[/green]")
+            return True
+        else:
+            console.print(f"[red]❌ 更新失败：[/red]")
+            console.print(f"[red]{result.stderr}[/red]")
+            return False
+    except Exception as e:
+        console.print(f"[red]❌ 更新过程中出错：{str(e)}[/red]")
+        return False
+
+def check_and_notify_update():
+    """检查并通知更新（在 CLI 启动时调用）"""
+    try:
+        has_update, current_ver, latest_ver = check_for_update()
+        if has_update and current_ver and latest_ver:
+            show_update_notification(current_ver, latest_ver)
+    except:
+        # 静默处理错误，不影响正常功能
+        pass

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

@@ -0,0 +1,104 @@
+Metadata-Version: 2.2
+Name: adam_community
+Version: 1.0.3
+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
+Requires-Dist: packaging>=21.0
+Requires-Dist: jsonschema>=4.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 .
+```
+
+更新 CLI 到最新版本：
+```bash
+adam-cli update
+```
+
+### 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.1 → adam_community-1.0.3}/adam_community.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 README.md
 setup.py
 adam_community/__init__.py
+adam_community/__version__.py
 adam_community/tool.py
 adam_community/util.py
 adam_community.egg-info/PKG-INFO
@@ -14,5 +15,6 @@ adam_community/cli/build.py
 adam_community/cli/cli.py
 adam_community/cli/init.py
 adam_community/cli/parser.py
+adam_community/cli/updater.py
 adam_community/cli/templates/__init__.py
 test/test_util_tool.py

{adam_community-1.0.1 → adam_community-1.0.3}/adam_community.egg-info/requires.txt

@@ -2,3 +2,5 @@ requests>=2.31.0
 click>=8.0.0
 docstring-parser>=0.15
 rich>=13.0.0
+packaging>=21.0
+jsonschema>=4.0.0

{adam_community-1.0.1 → adam_community-1.0.3}/setup.py

@@ -1,15 +1,24 @@
 from setuptools import setup, find_packages
 import os
 
+# 读取版本号
+def get_version():
+    version = {}
+    with open(os.path.join("adam_community", "__version__.py")) as fp:
+        exec(fp.read(), version)
+    return version['__version__']
+
 setup(
     name="adam_community",
-    version="1.0.1",
+    version=get_version(),
     packages=find_packages(),
     install_requires=[
         "requests>=2.31.0",
         "click>=8.0.0",
         "docstring-parser>=0.15",
         "rich>=13.0.0",
+        "packaging>=21.0",
+        "jsonschema>=4.0.0",
     ],
     entry_points={
         'console_scripts': [

adam_community-1.0.1/PKG-INFO

@@ -1,53 +0,0 @@
-Metadata-Version: 2.2
-Name: adam_community
-Version: 1.0.1
-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.1/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.1/adam_community.egg-info/PKG-INFO

@@ -1,53 +0,0 @@
-Metadata-Version: 2.2
-Name: adam_community
-Version: 1.0.1
-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
-```