adam-community 1.0.22__tar.gz → 1.0.24__tar.gz

{adam_community-1.0.22 → adam_community-1.0.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: adam_community
-Version: 1.0.22
+Version: 1.0.24
 Summary: Adam Community Tools and Utilities
 Home-page: https://github.com/yourusername/adam-community
 Author: Adam Community
@@ -80,6 +80,35 @@ classes = parse_directory(Path("./"))
 success, errors, zip_name = build_package(Path("./"))
 ```
 
+### States Management（任务状态管理）
+
+用于在任务执行过程中记录和读取状态，与服务端共享 `states.json` 文件。
+
+```python
+from adam_community.util import setState, getState, trackPath
+
+# 记录文件列表（自动与服务端和其他 Tool 的文件合并）
+setState("files", [
+    {"path": "output/result.json", "is_dir": False, "mtime": 1704100800},
+    {"path": "cache", "is_dir": True, "mtime": 1704100000}
+])
+
+# 获取合并后的文件列表（来自 server + 所有 tools）
+files = getState("files")
+
+# 记录自定义状态（支持嵌套 key）
+setState("stage", "data_cleaning")
+setState("config.threshold", 0.5)
+
+# 获取状态
+stage = getState("stage")              # -> "data_cleaning"
+threshold = getState("config.threshold")  # -> 0.5
+
+# 追踪文件/目录（自动检测 is_dir 和 mtime，先进先出，最多 30 条）
+trackPath("/path/to/output/result.json")
+trackPath("/path/to/cache")
+```
+
 ## 功能特性
 
 - **Python 文件解析**: 自动解析 Python 类和函数的文档字符串

{adam_community-1.0.22 → adam_community-1.0.24}/README.md

@@ -50,6 +50,35 @@ classes = parse_directory(Path("./"))
 success, errors, zip_name = build_package(Path("./"))
 ```
 
+### States Management（任务状态管理）
+
+用于在任务执行过程中记录和读取状态，与服务端共享 `states.json` 文件。
+
+```python
+from adam_community.util import setState, getState, trackPath
+
+# 记录文件列表（自动与服务端和其他 Tool 的文件合并）
+setState("files", [
+    {"path": "output/result.json", "is_dir": False, "mtime": 1704100800},
+    {"path": "cache", "is_dir": True, "mtime": 1704100000}
+])
+
+# 获取合并后的文件列表（来自 server + 所有 tools）
+files = getState("files")
+
+# 记录自定义状态（支持嵌套 key）
+setState("stage", "data_cleaning")
+setState("config.threshold", 0.5)
+
+# 获取状态
+stage = getState("stage")              # -> "data_cleaning"
+threshold = getState("config.threshold")  # -> 0.5
+
+# 追踪文件/目录（自动检测 is_dir 和 mtime，先进先出，最多 30 条）
+trackPath("/path/to/output/result.json")
+trackPath("/path/to/cache")
+```
+
 ## 功能特性
 
 - **Python 文件解析**: 自动解析 Python 类和函数的文档字符串

adam_community-1.0.24/adam_community/__version__.py

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

{adam_community-1.0.22 → adam_community-1.0.24}/adam_community/tool.py

@@ -22,6 +22,8 @@ class Tool:
             cls.CONDA_ENV = "base"
         if not hasattr(cls, "calltype"):
             cls.calltype = "bash"
+        if not hasattr(cls, "DISPLAY_NAME"):
+            cls.DISPLAY_NAME = cls.__name__
 
 
     def inputShow(self, **kwargs):
@@ -42,7 +44,7 @@ class Tool:
 
             scripts = '\n'.join(['bash -s << EOF', scripts, 'EOF'])
         else:
-            scripts = f"""python {self.__name__}.py"""
+            scripts = f"""python {self.DISPLAY_NAME}.py"""
         return Tool.markdown_terminal(scripts, workdir=kwargs["task_id"],
                 user=kwargs["user"], conda_env=self.CONDA_ENV)
 

{adam_community-1.0.22 → adam_community-1.0.24}/adam_community/util.py

@@ -10,6 +10,7 @@ import logging
 import ssl
 from functools import wraps
 from subprocess import run, CalledProcessError
+import time
 
 logger = logging.getLogger(__name__)
 
@@ -18,6 +19,7 @@ ADAM_API_TOKEN = os.getenv('ADAM_API_TOKEN')
 ADAM_TASK_ID = os.getenv('ADAM_TASK_ID')
 ADAM_USER_ID = os.getenv('ADAM_USER_ID')
 CONDA_ENV = os.getenv('CONDA_ENV')
+ADAM_TASK_DIR = os.getenv('ADAM_TASK_DIR')
 
 
 def _build_akb_query_command(query: str, collection: str) -> str:
@@ -368,3 +370,195 @@ def markdown_terminal(content, conda_env="base", user="Adam", workdir=""):
     user = markdown_color(f"{user}@Adam", "green")
     workdir = markdown_color(f":~/{workdir}", "blue")
     return f'({conda_env}) {user}{workdir}$ {content}'
+
+
+# ========== States Management ==========
+
+class _StatesManager:
+    """内部状态管理类"""
+    _tool_name = "tool"
+
+    def _get_states_file(self) -> str:
+        """获取 states.json 文件路径"""
+        # 1. 优先使用环境变量
+        task_dir = ADAM_TASK_DIR
+        if task_dir:
+            return os.path.join(task_dir, ".slurm", "states.json")
+
+        # 2. 尝试当前目录的 .slurm
+        current_dir = os.getcwd()
+        local_states = os.path.join(current_dir, ".slurm", "states.json")
+        if os.path.exists(local_states):
+            return local_states
+
+        # 3. 在当前目录创建
+        return local_states
+
+    def _read(self) -> dict:
+        """读取 states.json，保留所有来源的数据"""
+        states_file = self._get_states_file()
+        if not os.path.exists(states_file):
+            return {
+                "files": {"updated_at": None, "sources": {}},
+                "states": {"source": None, "updated_at": None, "data": {}}
+            }
+        try:
+            with open(states_file, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return {
+                "files": {"updated_at": None, "sources": {}},
+                "states": {"source": None, "updated_at": None, "data": {}}
+            }
+
+    def _write(self, data: dict):
+        """写入 states.json"""
+        states_file = self._get_states_file()
+        os.makedirs(os.path.dirname(states_file), exist_ok=True)
+        with open(states_file, 'w', encoding='utf-8') as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+
+    def _set_nested(self, data: dict, key: str, value):
+        """设置嵌套值，支持 dot notation"""
+        keys = key.split('.')
+        current = data
+        for k in keys[:-1]:
+            current = current.setdefault(k, {})
+        current[keys[-1]] = value
+
+    def _get_nested(self, data: dict, key: str, default=None):
+        """获取嵌套值，支持 dot notation"""
+        keys = key.split('.')
+        current = data
+        for k in keys:
+            if isinstance(current, dict):
+                current = current.get(k)
+            else:
+                return default
+            if current is None:
+                return default
+        return current
+
+    def set(self, key: str, value):
+        """
+        设置状态
+
+        特殊 key:
+            "files" - 记录文件列表，会自动补充到 files.sources[tool_name]
+            其他 - 记录到 states.data
+        """
+        data = self._read()
+
+        if key == "files":
+            data["files"]["sources"][self._tool_name] = {
+                "updated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+                "items": value
+            }
+        else:
+            self._set_nested(data["states"]["data"], key, value)
+
+        self._write(data)
+
+    def get(self, key: str):
+        """
+        获取状态
+
+        Returns:
+            状态值，不存在返回 None
+        """
+        data = self._read()
+
+        if key == "files":
+            # 合并所有来源的文件列表
+            merged = {}
+            for source, content in data["files"]["sources"].items():
+                for item in content.get("items", []):
+                    path = item.get("path")
+                    if not path:
+                        continue
+                    mtime = item.get("mtime", 0)
+                    if path not in merged or mtime > merged[path]["mtime"]:
+                        merged[path] = item
+            result = list(merged.values())
+            # 按 mtime 降序排序
+            result.sort(key=lambda x: x.get("mtime", 0), reverse=True)
+            return result
+
+        return self._get_nested(data["states"]["data"], key)
+
+    def cleanup(self):
+        """清理当前工具的所有记录"""
+        data = self._read()
+        data["files"]["sources"].pop(self._tool_name, None)
+        self._write(data)
+
+    def trackPath(self, path: str, max_items: int = 30):
+        """
+        追踪文件/目录，自动检测文件信息并记录
+
+        Args:
+            path: 文件或目录路径
+            max_items: 最大记录数量，先进先出
+        """
+        if not os.path.exists(path):
+            return
+
+        # 检测文件信息
+        try:
+            is_dir = os.path.isdir(path)
+            mtime = int(os.path.getmtime(path))
+            # 从环境变量获取 task_dir
+            task_dir = os.getenv('ADAM_TASK_DIR')
+            if task_dir:
+                rel_path = os.path.relpath(path, task_dir)
+            else:
+                rel_path = path
+        except (OSError, ValueError):
+            return
+
+        # 获取当前文件列表
+        data = self._read()
+        source = self._tool_name
+        items = data["files"]["sources"].get(source, {}).get("items", [])
+
+        # 检查是否已存在相同路径，存在则移除（后面会加到末尾，保持最新追踪的在最后）
+        items = [item for item in items if item.get("path") != rel_path]
+
+        # 添加到末尾（最新的位置）
+        items.append({"path": rel_path, "is_dir": is_dir, "mtime": mtime})
+
+        # 先进先出，保留最多 max_items 条
+        if len(items) > max_items:
+            items = items[-max_items:]
+
+        # 写回
+        data["files"]["sources"][source] = {
+            "updated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+            "items": items
+        }
+        self._write(data)
+
+
+# 全局实例
+_states = _StatesManager()
+
+
+def setState(key: str, value):
+    """设置状态"""
+    return _states.set(key, value)
+
+
+def getState(key: str):
+    """获取状态"""
+    return _states.get(key)
+
+
+def trackPath(path: str, max_items: int = 30):
+    """
+    追踪文件/目录，自动检测文件信息并记录
+
+    Args:
+        path: 文件或目录路径
+        max_items: 最大记录数量，先进先出，默认 30
+    """
+    return _states.trackPath(path, max_items)

{adam_community-1.0.22 → adam_community-1.0.24}/adam_community.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: adam_community
-Version: 1.0.22
+Version: 1.0.24
 Summary: Adam Community Tools and Utilities
 Home-page: https://github.com/yourusername/adam-community
 Author: Adam Community
@@ -80,6 +80,35 @@ classes = parse_directory(Path("./"))
 success, errors, zip_name = build_package(Path("./"))
 ```
 
+### States Management（任务状态管理）
+
+用于在任务执行过程中记录和读取状态，与服务端共享 `states.json` 文件。
+
+```python
+from adam_community.util import setState, getState, trackPath
+
+# 记录文件列表（自动与服务端和其他 Tool 的文件合并）
+setState("files", [
+    {"path": "output/result.json", "is_dir": False, "mtime": 1704100800},
+    {"path": "cache", "is_dir": True, "mtime": 1704100000}
+])
+
+# 获取合并后的文件列表（来自 server + 所有 tools）
+files = getState("files")
+
+# 记录自定义状态（支持嵌套 key）
+setState("stage", "data_cleaning")
+setState("config.threshold", 0.5)
+
+# 获取状态
+stage = getState("stage")              # -> "data_cleaning"
+threshold = getState("config.threshold")  # -> 0.5
+
+# 追踪文件/目录（自动检测 is_dir 和 mtime，先进先出，最多 30 条）
+trackPath("/path/to/output/result.json")
+trackPath("/path/to/cache")
+```
+
 ## 功能特性
 
 - **Python 文件解析**: 自动解析 Python 类和函数的文档字符串

adam_community-1.0.24/test/test_util_tool.py

@@ -0,0 +1,438 @@
+import unittest
+from unittest.mock import patch, MagicMock, PropertyMock
+import sys
+import os
+import tempfile
+import shutil
+import json
+import time
+
+# 设置环境变量
+os.environ['ADAM_API_TOKEN'] = 'test_token'
+os.environ['ADAM_API_HOST'] = 'https://test.com'
+
+# 添加项目根目录到 Python 路径
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Mock OpenAI client before importing util
+with patch('openai.OpenAI'):
+    from adam_community.util import knowledgeSearch, completionCreate, runCmd, setState, getState, trackPath, RAG
+    from adam_community.tool import Tool
+
+class TestUtil(unittest.TestCase):
+    def setUp(self):
+        self.test_params = {
+            "project": "test_project",
+            "name": "test_collection",
+            "query": "test query",
+            "limit": 10
+        }
+        
+    @patch('adam_community.util.RAG.call')
+    def test_knowledgeSearch(self, mock_rag_call):
+        """测试knowledgeSearch函数"""
+        mock_rag_call.return_value = "test result content"
+
+        result = knowledgeSearch(
+            query_info="test query",
+            messages_prev=[{"role": "user", "content": "test"}],
+            project_name="test_project",
+            collection_name="test_collection"
+        )
+
+        # 验证返回的是 JSON 格式
+        import json
+        data = json.loads(result)
+        self.assertEqual(data["code"], 0)
+        self.assertEqual(data["data"]["collection_name"], "test_collection")
+        mock_rag_call.assert_called_once_with("test query", "test_collection")
+
+    @patch('subprocess.Popen')
+    @patch.dict(os.environ, {'ADAM_OUTPUT_RAW': ''}, clear=True)
+    def test_runCmd_success(self, mock_popen):
+        """测试runCmd函数成功执行命令的情况"""
+        mock_process = MagicMock()
+        mock_process.poll.return_value = 0
+        mock_process.returncode = 0
+        mock_process.stdout.readline.return_value = "test output"
+        mock_process.stderr.readline.return_value = ""
+        mock_popen.return_value = mock_process
+        
+        process = runCmd('echo "test output"')
+        self.assertEqual(process.returncode, 0)
+        mock_popen.assert_called_once()
+
+    @patch('subprocess.Popen')
+    @patch.dict(os.environ, {'ADAM_OUTPUT_RAW': ''}, clear=True)
+    def test_runCmd_failure(self, mock_popen):
+        """测试runCmd函数执行失败的情况"""
+        mock_process = MagicMock()
+        mock_process.poll.return_value = 1
+        mock_process.returncode = 1
+        mock_process.stdout.readline.return_value = ""
+        mock_process.stderr.readline.return_value = "command not found"
+        mock_popen.return_value = mock_process
+        
+        with self.assertRaises(SystemExit) as cm:
+            runCmd('nonexistent_command_123456')
+        self.assertEqual(cm.exception.code, 1)
+
+    @patch.dict(os.environ, {'ADAM_OUTPUT_RAW': 'true'}, clear=True)
+    def test_runCmd_with_raw_output(self):
+        """测试runCmd函数在ADAM_OUTPUT_RAW环境变量设置时的情况"""
+        cmd = 'echo "test output"'
+        result = runCmd(cmd)
+        self.assertEqual(result, cmd)
+
+class TestTool(unittest.TestCase):
+    def setUp(self):
+        class TestToolImpl(Tool):
+            def call(self, kwargs):
+                return "test command"
+        
+        self.tool = TestToolImpl()
+        
+    def test_inputShow(self):
+        """测试inputShow方法"""
+        kwargs = {
+            "task_id": "test_task",
+            "user": "test_user",
+            "message": "test message"
+        }
+        
+        with patch.object(self.tool, 'call', return_value="test command"):
+            result = self.tool.inputShow(**kwargs)
+            self.assertIn("test_user@Adam", result)
+            self.assertIn("test_task", result)
+        
+    def test_resAlloc(self):
+        """测试resAlloc方法"""
+        kwargs = {
+            "tool_data": "test_data",
+            "tip": "test tip"
+        }
+        
+        result = self.tool.resAlloc(kwargs)
+        self.assertIn("CPU", result)
+        self.assertIn("MEM_PER_CPU", result)
+        self.assertIn("GPU", result)
+        self.assertIn("PARTITION", result)
+        
+    def test_outputShow(self):
+        """测试outputShow方法"""
+        kwargs = {
+            "stdout": "test stdout",
+            "stderr": "test stderr",
+            "exit_code": 0
+        }
+        
+        result, files = self.tool.outputShow(kwargs)
+        self.assertIn("test stdout", result)
+        self.assertIn("test stderr", result)
+        self.assertEqual(files, [])
+        
+    def test_markdown_color(self):
+        """测试markdown_color静态方法"""
+        result = Tool.markdown_color("test", "red")
+        self.assertEqual(result, '<span style="color: red">test</span>')
+        
+    def test_markdown_terminal(self):
+        """测试markdown_terminal静态方法"""
+        result = Tool.markdown_terminal("test command", "test_env", "test_user", "test_dir")
+        self.assertIn("test_user@Adam", result)
+        self.assertIn("test_dir", result)
+        self.assertIn("test command", result)
+
+
+class TestStatesManager(unittest.TestCase):
+    """测试 StatesManager 功能"""
+
+    def setUp(self):
+        """每个测试前创建临时目录"""
+        self.temp_dir = tempfile.mkdtemp()
+        self.original_cwd = os.getcwd()
+        os.chdir(self.temp_dir)
+
+        # 重置 _states 的缓存
+        from adam_community.util import _StatesManager
+        _StatesManager._states_file = None
+
+    def tearDown(self):
+        """每个测试后清理"""
+        os.chdir(self.original_cwd)
+        shutil.rmtree(self.temp_dir, ignore_errors=True)
+        # 重置 _states 的缓存
+        from adam_community.util import _StatesManager
+        _StatesManager._states_file = None
+
+    def test_set_and_get_state(self):
+        """测试设置和获取状态"""
+        setState("stage", "data_cleaning")
+        result = getState("stage")
+        self.assertEqual(result, "data_cleaning")
+
+    def test_set_nested_state(self):
+        """测试设置嵌套状态"""
+        setState("config.threshold", 0.5)
+        result = getState("config.threshold")
+        self.assertEqual(result, 0.5)
+
+    def test_set_object_state(self):
+        """测试设置对象状态"""
+        data = {"stage": "analysis", "rows": 1000}
+        setState("result", data)
+        result = getState("result")
+        self.assertEqual(result["stage"], "analysis")
+        self.assertEqual(result["rows"], 1000)
+
+    def test_get_nonexistent_state(self):
+        """测试获取不存在的状态"""
+        result = getState("nonexistent")
+        self.assertIsNone(result)
+
+    def test_set_files(self):
+        """测试设置文件列表"""
+        files = [
+            {"path": "output/result.json", "is_dir": False, "mtime": 1704100800},
+            {"path": "cache", "is_dir": True, "mtime": 1704100000}
+        ]
+        setState("files", files)
+
+        # 验证文件写入
+        states_file = os.path.join(self.temp_dir, ".slurm", "states.json")
+        self.assertTrue(os.path.exists(states_file))
+
+        with open(states_file, 'r') as f:
+            data = json.load(f)
+            self.assertIn("tool", data["files"]["sources"])
+            self.assertEqual(len(data["files"]["sources"]["tool"]["items"]), 2)
+
+    def test_get_files_merges_sources(self):
+        """测试获取文件列表时合并多个来源"""
+        # 先写入 server 的文件
+        server_file = os.path.join(self.temp_dir, ".slurm", "states.json")
+        os.makedirs(os.path.dirname(server_file), exist_ok=True)
+        with open(server_file, 'w') as f:
+            json.dump({
+                "files": {
+                    "updated_at": "2024-01-01T00:00:00Z",
+                    "sources": {
+                        "server": {
+                            "updated_at": "2024-01-01T00:00:00Z",
+                            "items": [
+                                {"path": "src/main.py", "is_dir": False, "mtime": 1704100000}
+                            ]
+                        }
+                    }
+                },
+                "states": {"source": None, "updated_at": None, "data": {}}
+            }, f)
+
+        # 写入 tool 的文件
+        setState("files", [
+            {"path": "output/result.json", "is_dir": False, "mtime": 1704100800}
+        ])
+
+        # 获取并验证合并
+        files = getState("files")
+        self.assertEqual(len(files), 2)
+        paths = [f["path"] for f in files]
+        self.assertIn("src/main.py", paths)
+        self.assertIn("output/result.json", paths)
+
+    def test_get_files_sorted_by_mtime(self):
+        """测试文件列表按 mtime 降序排序"""
+        setState("files", [
+            {"path": "old.txt", "is_dir": False, "mtime": 1704100000},
+            {"path": "new.txt", "is_dir": False, "mtime": 1704100800},
+            {"path": "middle.txt", "is_dir": False, "mtime": 1704100400}
+        ])
+
+        files = getState("files")
+        mtimes = [f["mtime"] for f in files]
+        self.assertEqual(mtimes, sorted(mtimes, reverse=True))
+
+    def test_preserve_existing_data(self):
+        """测试写入时保留已有数据"""
+        # 先写入 server 数据
+        server_file = os.path.join(self.temp_dir, ".slurm", "states.json")
+        os.makedirs(os.path.dirname(server_file), exist_ok=True)
+        with open(server_file, 'w') as f:
+            json.dump({
+                "files": {
+                    "updated_at": "2024-01-01T00:00:00Z",
+                    "sources": {
+                        "server": {
+                            "updated_at": "2024-01-01T00:00:00Z",
+                            "items": [{"path": "main.py", "is_dir": False, "mtime": 1704100000}]
+                        }
+                    }
+                },
+                "states": {
+                    "source": "server",
+                    "updated_at": "2024-01-01T00:00:00Z",
+                    "data": {"server_stage": "init"}
+                }
+            }, f)
+
+        # 写入 tool 状态
+        setState("stage", "processing")
+
+        # 验证 server 数据保留
+        with open(server_file, 'r') as f:
+            data = json.load(f)
+            self.assertIn("server", data["files"]["sources"])
+            self.assertEqual(data["states"]["data"]["server_stage"], "init")
+            self.assertEqual(data["states"]["data"]["stage"], "processing")
+
+    def test_nonexistent_directory_creates_slurm(self):
+        """测试不存在的目录会自动创建 .slurm"""
+        os.chdir(self.original_cwd)  # 切回非临时目录
+        test_dir = os.path.join(self.temp_dir, "new_task")
+        os.makedirs(test_dir)
+        os.chdir(test_dir)
+
+        setState("stage", "test")
+        states_file = os.path.join(test_dir, ".slurm", "states.json")
+        self.assertTrue(os.path.exists(states_file))
+
+    def test_trackPath_file(self):
+        """测试追踪文件"""
+        # 设置环境变量
+        os.environ['ADAM_TASK_DIR'] = self.temp_dir
+
+        try:
+            # 创建测试文件
+            test_file = os.path.join(self.temp_dir, "test.txt")
+            with open(test_file, 'w') as f:
+                f.write("test content")
+
+            trackPath(test_file)
+
+            files = getState("files")
+            self.assertEqual(len(files), 1)
+            self.assertEqual(files[0]["path"], "test.txt")
+            self.assertFalse(files[0]["is_dir"])
+        finally:
+            del os.environ['ADAM_TASK_DIR']
+
+    def test_trackPath_directory(self):
+        """测试追踪目录"""
+        # 设置环境变量
+        os.environ['ADAM_TASK_DIR'] = self.temp_dir
+
+        try:
+            # 创建测试目录
+            test_dir = os.path.join(self.temp_dir, "output")
+            os.makedirs(test_dir)
+
+            trackPath(test_dir)
+
+            files = getState("files")
+            self.assertEqual(len(files), 1)
+            self.assertEqual(files[0]["path"], "output")
+            self.assertTrue(files[0]["is_dir"])
+        finally:
+            del os.environ['ADAM_TASK_DIR']
+
+    def test_trackPath_nonexistent(self):
+        """测试追踪不存在的路径"""
+        trackPath("/nonexistent/path/file.txt")
+        files = getState("files")
+        self.assertEqual(len(files), 0)
+
+    def test_trackPath_updates_existing(self):
+        """测试追踪已存在的文件会更新 mtime 并移动到末尾"""
+        # 设置环境变量
+        os.environ['ADAM_TASK_DIR'] = self.temp_dir
+
+        try:
+            # 先创建几个文件
+            for name in ["a.txt", "b.txt", "file.txt"]:
+                with open(os.path.join(self.temp_dir, name), 'w') as f:
+                    f.write(name)
+
+            # 追踪这些文件
+            trackPath(os.path.join(self.temp_dir, "a.txt"))
+            trackPath(os.path.join(self.temp_dir, "b.txt"))
+            trackPath(os.path.join(self.temp_dir, "file.txt"))
+
+            files = getState("files")
+            self.assertEqual(len(files), 3)
+            # file.txt 应该在最后（最新追踪的）
+            self.assertEqual(files[2]["path"], "file.txt")
+
+            # 再次追踪 file.txt，它应该移动到末尾
+            time.sleep(0.1)  # 等待以确保 mtime 不同
+            with open(os.path.join(self.temp_dir, "file.txt"), 'w') as f:
+                f.write("v2")
+            mtime2 = int(os.path.getmtime(os.path.join(self.temp_dir, "file.txt")))
+
+            trackPath(os.path.join(self.temp_dir, "file.txt"))
+
+            files = getState("files")
+            self.assertEqual(len(files), 3)
+            # file.txt 仍然在最后
+            self.assertEqual(files[2]["path"], "file.txt")
+            # mtime 已更新
+            self.assertEqual(files[2]["mtime"], mtime2)
+        finally:
+            del os.environ['ADAM_TASK_DIR']
+
+    def test_trackPath_max_items_fifo(self):
+        """测试追踪超过最大数量时先进先出"""
+        # 设置环境变量
+        os.environ['ADAM_TASK_DIR'] = self.temp_dir
+
+        try:
+            # 创建 35 个文件
+            for i in range(35):
+                with open(os.path.join(self.temp_dir, f"file_{i}.txt"), 'w') as f:
+                    f.write(str(i))
+
+            # 追踪所有文件
+            for i in range(35):
+                trackPath(os.path.join(self.temp_dir, f"file_{i}.txt"))
+
+            files = getState("files")
+            # 应该保留 30 条（file_5 到 file_34）
+            self.assertEqual(len(files), 30)
+
+            # 检查最新追踪的文件是否保留
+            filenames = [f["path"] for f in files]
+            self.assertIn("file_34.txt", filenames)
+            self.assertIn("file_5.txt", filenames)
+
+            # 检查最早追踪的文件是否被移除
+            self.assertNotIn("file_0.txt", filenames)
+            self.assertNotIn("file_1.txt", filenames)
+            self.assertNotIn("file_2.txt", filenames)
+            self.assertNotIn("file_3.txt", filenames)
+            self.assertNotIn("file_4.txt", filenames)
+        finally:
+            del os.environ['ADAM_TASK_DIR']
+
+    def test_trackPath_with_task_dir_env(self):
+        """测试追踪时使用环境变量的 task_dir"""
+        # 设置环境变量
+        os.environ['ADAM_TASK_DIR'] = self.temp_dir
+
+        try:
+            # 在子目录中创建文件
+            sub_dir = os.path.join(self.temp_dir, "src")
+            os.makedirs(sub_dir)
+            test_file = os.path.join(sub_dir, "main.py")
+            with open(test_file, 'w') as f:
+                f.write("print('hello')")
+
+            trackPath(test_file)
+
+            files = getState("files")
+            self.assertEqual(len(files), 1)
+            self.assertEqual(files[0]["path"], "src/main.py")
+        finally:
+            del os.environ['ADAM_TASK_DIR']
+
+
+if __name__ == '__main__':
+    unittest.main() 

adam_community-1.0.22/adam_community/__version__.py

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

adam_community-1.0.22/test/test_util_tool.py

@@ -1,143 +0,0 @@
-import unittest
-from unittest.mock import patch, MagicMock, PropertyMock
-import sys
-import os
-
-# 设置环境变量
-os.environ['ADAM_API_TOKEN'] = 'test_token'
-os.environ['ADAM_API_HOST'] = 'https://test.com'
-
-# 添加项目根目录到 Python 路径
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-# Mock OpenAI client before importing util
-with patch('openai.OpenAI'):
-    from adam_community.util import knowledgeSearch, completionCreate, runCmd
-    from adam_community.tool import Tool
-
-class TestUtil(unittest.TestCase):
-    def setUp(self):
-        self.test_params = {
-            "project": "test_project",
-            "name": "test_collection",
-            "query": "test query",
-            "limit": 10
-        }
-        
-    @patch('urllib.request.urlopen')
-    def test_knowledgeSearch(self, mock_urlopen):
-        """测试knowledgeSearch函数"""
-        mock_response = MagicMock()
-        # 设置status属性为整数
-        type(mock_response).status = PropertyMock(return_value=200)
-        mock_response.read.return_value = b'{"result": "success"}'
-        mock_urlopen.return_value.__enter__.return_value = mock_response
-        
-        result = knowledgeSearch(
-            query_info="test query",
-            messages_prev=[{"role": "user", "content": "test"}],
-            project_name="test_project",
-            collection_name="test_collection"
-        )
-        
-        self.assertEqual(result, '{"result": "success"}')
-        mock_urlopen.assert_called_once()
-
-    @patch('subprocess.Popen')
-    @patch.dict(os.environ, {'ADAM_OUTPUT_RAW': ''}, clear=True)
-    def test_runCmd_success(self, mock_popen):
-        """测试runCmd函数成功执行命令的情况"""
-        mock_process = MagicMock()
-        mock_process.poll.return_value = 0
-        mock_process.returncode = 0
-        mock_process.stdout.readline.return_value = "test output"
-        mock_process.stderr.readline.return_value = ""
-        mock_popen.return_value = mock_process
-        
-        process = runCmd('echo "test output"')
-        self.assertEqual(process.returncode, 0)
-        mock_popen.assert_called_once()
-
-    @patch('subprocess.Popen')
-    @patch.dict(os.environ, {'ADAM_OUTPUT_RAW': ''}, clear=True)
-    def test_runCmd_failure(self, mock_popen):
-        """测试runCmd函数执行失败的情况"""
-        mock_process = MagicMock()
-        mock_process.poll.return_value = 1
-        mock_process.returncode = 1
-        mock_process.stdout.readline.return_value = ""
-        mock_process.stderr.readline.return_value = "command not found"
-        mock_popen.return_value = mock_process
-        
-        with self.assertRaises(SystemExit) as cm:
-            runCmd('nonexistent_command_123456')
-        self.assertEqual(cm.exception.code, 1)
-
-    @patch.dict(os.environ, {'ADAM_OUTPUT_RAW': 'true'}, clear=True)
-    def test_runCmd_with_raw_output(self):
-        """测试runCmd函数在ADAM_OUTPUT_RAW环境变量设置时的情况"""
-        cmd = 'echo "test output"'
-        result = runCmd(cmd)
-        self.assertEqual(result, cmd)
-
-class TestTool(unittest.TestCase):
-    def setUp(self):
-        class TestToolImpl(Tool):
-            def call(self, kwargs):
-                return "test command"
-        
-        self.tool = TestToolImpl()
-        
-    def test_inputShow(self):
-        """测试inputShow方法"""
-        kwargs = {
-            "task_id": "test_task",
-            "user": "test_user",
-            "message": "test message"
-        }
-        
-        with patch.object(self.tool, 'call', return_value="test command"):
-            result = self.tool.inputShow(**kwargs)
-            self.assertIn("test_user@Adam", result)
-            self.assertIn("test_task", result)
-        
-    def test_resAlloc(self):
-        """测试resAlloc方法"""
-        kwargs = {
-            "tool_data": "test_data",
-            "tip": "test tip"
-        }
-        
-        result = self.tool.resAlloc(kwargs)
-        self.assertIn("CPU", result)
-        self.assertIn("MEM_PER_CPU", result)
-        self.assertIn("GPU", result)
-        self.assertIn("PARTITION", result)
-        
-    def test_outputShow(self):
-        """测试outputShow方法"""
-        kwargs = {
-            "stdout": "test stdout",
-            "stderr": "test stderr",
-            "exit_code": 0
-        }
-        
-        result, files = self.tool.outputShow(kwargs)
-        self.assertIn("test stdout", result)
-        self.assertIn("test stderr", result)
-        self.assertEqual(files, [])
-        
-    def test_markdown_color(self):
-        """测试markdown_color静态方法"""
-        result = Tool.markdown_color("test", "red")
-        self.assertEqual(result, '<span style="color: red">test</span>')
-        
-    def test_markdown_terminal(self):
-        """测试markdown_terminal静态方法"""
-        result = Tool.markdown_terminal("test command", "test_env", "test_user", "test_dir")
-        self.assertIn("test_user@Adam", result)
-        self.assertIn("test_dir", result)
-        self.assertIn("test command", result)
-
-if __name__ == '__main__':
-    unittest.main()