beswarm 0.2.42__tar.gz → 0.2.44__tar.gz

{beswarm-0.2.42 → beswarm-0.2.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: beswarm
-Version: 0.2.42
+Version: 0.2.44
 Summary: MAS
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{beswarm-0.2.42 → beswarm-0.2.44}/beswarm/agents/chatgroup.py

@@ -100,7 +100,7 @@ class Tee:
 
 class ChatGroupWorker:
     """The 'glue' class that orchestrates agents via a MessageBroker."""
-    def __init__(self, tools: List[Union[str, Dict]], work_dir: str, cache_messages: Union[bool, List[Dict]] = None, broker: MessageBroker = None, mcp_manager: MCPManager = None, task_manager = None):
+    def __init__(self, tools: List[Union[str, Dict]], work_dir: str, cache_messages: Union[bool, List[Dict]] = None, broker: MessageBroker = None, mcp_manager: MCPManager = None, task_manager = None, kgm = None):
         self.tools = tools
         self.work_dir = Path(work_dir)
         self.cache_messages = cache_messages
@@ -108,6 +108,7 @@ class ChatGroupWorker:
         self.broker = broker
         self.mcp_manager = mcp_manager
         self.task_manager = task_manager
+        self.kgm = kgm
         self.task_completion_event = asyncio.Event()
         self.final_result = None
         self._status_subscription = None
@@ -122,6 +123,7 @@ class ChatGroupWorker:
         cache_dir = self.work_dir / ".beswarm"
         cache_dir.mkdir(parents=True, exist_ok=True)
         self.task_manager.set_root_path(self.work_dir)
+        self.kgm.set_root_path(self.work_dir)
         self.cache_file = cache_dir / "work_agent_conversation_history.json"
         if not self.cache_file.exists():
             self.cache_file.write_text("[]", encoding="utf-8")

{beswarm-0.2.42 → beswarm-0.2.44}/beswarm/agents/planact.py

@@ -188,7 +188,7 @@ class WorkerAgent(BaseAgent):
 
 class BrokerWorker:
     """The 'glue' class that orchestrates agents via a MessageBroker."""
-    def __init__(self, goal: str, tools: List[Union[str, Dict]], work_dir: str, cache_messages: Union[bool, List[Dict]] = None, broker = None, mcp_manager = None, task_manager = None):
+    def __init__(self, goal: str, tools: List[Union[str, Dict]], work_dir: str, cache_messages: Union[bool, List[Dict]] = None, broker = None, mcp_manager = None, task_manager = None, kgm = None):
         self.goal = goal
         self.tools = tools
         self.work_dir = Path(work_dir)
@@ -197,6 +197,7 @@ class BrokerWorker:
         self.broker = broker
         self.mcp_manager = mcp_manager
         self.task_manager = task_manager
+        self.kgm = kgm
         self.task_completion_event = asyncio.Event()
         self.final_result = None
         self._status_subscription = None
@@ -211,6 +212,7 @@ class BrokerWorker:
         cache_dir = self.work_dir / ".beswarm"
         cache_dir.mkdir(parents=True, exist_ok=True)
         self.task_manager.set_root_path(self.work_dir)
+        self.kgm.set_root_path(self.work_dir)
         self.cache_file = cache_dir / "work_agent_conversation_history.json"
         if not self.cache_file.exists():
             self.cache_file.write_text("[]", encoding="utf-8")

{beswarm-0.2.42 → beswarm-0.2.44}/beswarm/core.py

@@ -1,11 +1,13 @@
-from .taskmanager import TaskManager
 from .broker import MessageBroker
 from .bemcp.bemcp import MCPManager
+from .taskmanager import TaskManager
+from .knowledge_graph import KnowledgeGraphManager
 
 """
 全局共享实例
 """
 
-task_manager = TaskManager()
 broker = MessageBroker()
-mcp_manager = MCPManager()
+mcp_manager = MCPManager()
+task_manager = TaskManager()
+kgm = KnowledgeGraphManager()

beswarm-0.2.44/beswarm/knowledge_graph.py

@@ -0,0 +1,199 @@
+import uuid
+import networkx as nx
+from pathlib import Path
+
+class KnowledgeGraphManager:
+    """
+    一个使用 NetworkX 管理知识图谱的管理器。
+    - 图数据存储在 networkx.DiGraph 对象中。
+    - 数据持久化为 GraphML 文件。
+    - 提供添加、删除、重命名、移动节点和渲染树状图的功能。
+    """
+    def __init__(self, storage_path="knowledge_graph.graphml"):
+        """
+        初始化知识图谱管理器。
+
+        Args:
+            storage_path (str, optional): GraphML文件的存储路径。
+                                          默认为 'knowledge_graph.graphml'。
+        """
+        self.storage_path = Path(storage_path)
+        self.graph = nx.DiGraph()
+        self.root_path = None
+        # self._load_graph()
+
+    def set_root_path(self, root_path):
+        """设置工作根目录并加载持久化的任务状态。"""
+        if self.root_path is not None:
+            return
+        self.root_path = Path(root_path)
+        self.cache_dir = self.root_path / ".beswarm"
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        self.storage_path = self.cache_dir / "knowledge_graph.graphml"
+
+        self._load_graph()
+
+    def _load_graph(self):
+        """从文件加载图，如果文件不存在或加载失败，则创建一个新的。"""
+        if self.storage_path.exists():
+            try:
+                self.graph = nx.read_graphml(self.storage_path, node_type=str)
+            except Exception:
+                self._create_new_graph()
+        else:
+            self._create_new_graph()
+
+    def _create_new_graph(self):
+        """创建一个带有根节点的新图谱并保存。"""
+        self.graph = nx.DiGraph()
+        self.graph.add_node("root", name=".", description="知识图谱根节点")
+        self._save_graph()
+
+    def _save_graph(self):
+        """将当前图的状态保存到文件。"""
+        nx.write_graphml(self.graph, self.storage_path)
+
+    def _get_node_id_by_path(self, path: str):
+        """通过'/'分隔的路径查找节点的唯一ID，支持前缀匹配。"""
+        if path is None or not path.strip() or path.strip() in ['.', '/']:
+            return "root"
+
+        segments = path.strip('/').split('/')
+        current_node_id = "root"
+
+        for segment in segments:
+            # 首先尝试完全匹配
+            found_child = False
+            for child_id in self.graph.successors(current_node_id):
+                if self.graph.nodes[child_id].get('name') == segment:
+                    current_node_id = child_id
+                    found_child = True
+                    break
+            
+            if found_child:
+                continue
+                
+            # 如果完全匹配失败，尝试前缀匹配
+            prefix_matches = []
+            for child_id in self.graph.successors(current_node_id):
+                child_name = self.graph.nodes[child_id].get('name', '')
+                if child_name.startswith(segment):
+                    prefix_matches.append(child_id)
+            
+            if len(prefix_matches) == 1:
+                # 只有一个前缀匹配，使用这个节点
+                current_node_id = prefix_matches[0]
+            elif len(prefix_matches) > 1:
+                # 多个前缀匹配，存在歧义，返回None
+                return None
+            else:
+                # 没有前缀匹配，节点不存在
+                return None
+                
+        return current_node_id
+
+    def add_node(self, parent_path: str, node_name: str, description: str = "") -> str:
+        """在指定父节点下添加一个新节点。"""
+        if not node_name.strip():
+            return "❌ 错误：节点名称不能为空。"
+        if '/' in node_name:
+            return f"❌ 错误：节点名称 '{node_name}' 不能包含'/'。"
+
+        parent_id = self._get_node_id_by_path(parent_path)
+        if parent_id is None:
+            return f"❌ 错误：父路径 '{parent_path}' 不存在。"
+
+        for child_id in self.graph.successors(parent_id):
+            if self.graph.nodes[child_id].get('name') == node_name:
+                return f"❌ 错误：在 '{parent_path}' 下已存在名为 '{node_name}' 的节点。"
+
+        new_node_id = str(uuid.uuid4())
+        self.graph.add_node(new_node_id, name=node_name, description=description)
+        self.graph.add_edge(parent_id, new_node_id)
+        self._save_graph()
+        return f"✅ 成功在 '{parent_path}' 下添加节点 '{node_name}'。"
+
+    def delete_node(self, node_path: str) -> str:
+        """删除一个节点及其所有子孙节点。"""
+        if node_path is None or node_path.strip() in ['.', '/']:
+            return "❌ 错误：不能删除根节点。"
+
+        node_id = self._get_node_id_by_path(node_path)
+        if node_id is None:
+            return f"❌ 错误：路径 '{node_path}' 不存在。"
+        if node_id == "root":
+            return "❌ 错误：不能删除根节点。"
+
+        descendants = nx.descendants(self.graph, node_id)
+        self.graph.remove_nodes_from(descendants.union({node_id}))
+        self._save_graph()
+        return f"✅ 成功删除节点 '{node_path}' 及其所有子节点。"
+
+    def rename_node(self, node_path: str, new_name: str) -> str:
+        """重命名一个节点。"""
+        if not new_name.strip():
+            return "❌ 错误：新名称不能为空。"
+        if '/' in new_name:
+            return f"❌ 错误：新名称 '{new_name}' 不能包含'/'。"
+
+        node_id = self._get_node_id_by_path(node_path)
+        if node_id is None:
+            return f"❌ 错误：路径 '{node_path}' 不存在。"
+        if node_id == "root":
+            return "❌ 错误：不能重命名根节点。"
+
+        parent_id = list(self.graph.predecessors(node_id))[0]
+        for sibling_id in self.graph.successors(parent_id):
+            if sibling_id != node_id and self.graph.nodes[sibling_id].get('name') == new_name:
+                return f"❌ 错误：同级目录下已存在名为 '{new_name}' 的节点。"
+
+        self.graph.nodes[node_id]['name'] = new_name
+        self._save_graph()
+        return f"✅ 成功将节点 '{node_path}' 重命名为 '{new_name}'。"
+
+    def move_node(self, source_path: str, target_parent_path: str) -> str:
+        """将一个节点移动到另一个父节点下。"""
+        source_id = self._get_node_id_by_path(source_path)
+        if source_id is None:
+            return f"❌ 错误：源路径 '{source_path}' 不存在。"
+        if source_id == "root":
+            return "❌ 错误：不能移动根节点。"
+
+        target_parent_id = self._get_node_id_by_path(target_parent_path)
+        if target_parent_id is None:
+            return f"❌ 错误：目标父路径 '{target_parent_path}' 不存在。"
+
+        if source_id == target_parent_id or target_parent_id in nx.descendants(self.graph, source_id):
+            return "❌ 错误：不能将节点移动到其自身或其子孙节点下。"
+
+        source_name = self.graph.nodes[source_id]['name']
+        for child_id in self.graph.successors(target_parent_id):
+            if self.graph.nodes[child_id].get('name') == source_name:
+                return f"❌ 错误：目标目录 '{target_parent_path}' 下已存在同名节点 '{source_name}'。"
+
+        old_parent_id = list(self.graph.predecessors(source_id))[0]
+        self.graph.remove_edge(old_parent_id, source_id)
+        self.graph.add_edge(target_parent_id, source_id)
+        self._save_graph()
+        return f"✅ 成功将节点 '{source_path}' 移动到 '{target_parent_path}' 下。"
+
+    def render_tree(self) -> str:
+        """渲染整个知识图谱为树状结构的文本。"""
+        if not self.graph or "root" not in self.graph:
+            return "图谱为空或未正确初始化。"
+
+        root_name = self.graph.nodes["root"].get("name", ".")
+        tree_lines = [root_name]
+        self._build_tree_string_recursive("root", "", tree_lines)
+        return "\n".join(tree_lines)
+
+    def _build_tree_string_recursive(self, parent_id, prefix, tree_lines):
+        """递归辅助函数，用于构建树状图字符串。"""
+        children = sorted(list(self.graph.successors(parent_id)), key=lambda n: self.graph.nodes[n].get('name', ''))
+        for i, child_id in enumerate(children):
+            is_last = (i == len(children) - 1)
+            connector = "└── " if is_last else "├── "
+            node_name = self.graph.nodes[child_id].get('name', '[Unnamed Node]')
+            tree_lines.append(f"{prefix}{connector}{node_name}")
+            new_prefix = prefix + "    " if is_last else prefix + "│   "
+            self._build_tree_string_recursive(child_id, new_prefix, tree_lines)

{beswarm-0.2.42 → beswarm-0.2.44}/beswarm/taskmanager.py

@@ -1,3 +1,4 @@
+import os
 import json
 import uuid
 import asyncio
@@ -21,11 +22,12 @@ class TaskManager:
     一个带并发控制的异步任务管理器。
     它管理任务的生命周期，并通过一个固定大小的工作者池来控制并发执行的任务数量。
     """
-    def __init__(self, concurrency_limit=3):
-        if concurrency_limit <= 0:
+    def __init__(self, concurrency_limit=None):
+        self.concurrency_limit = concurrency_limit or int(os.getenv("BESWARM_CONCURRENCY_LIMIT", "3"))
+
+        if self.concurrency_limit <= 0:
             raise ValueError("并发限制必须大于0")
 
-        self.concurrency_limit = concurrency_limit
         self.tasks_cache = {}          # 存储所有任务的状态和元数据, key: task_id
 
         self._pending_queue = asyncio.Queue() # 内部待办任务队列
@@ -101,7 +103,7 @@ class TaskManager:
                     self._pending_queue.task_done()
 
             except asyncio.CancelledError:
-                print(f"[{worker_name}] 被取消，正在退出...")
+                # print(f"[{worker_name}] 被取消，正在退出...")
                 break
             except Exception as e:
                 print(f"[{worker_name}] 循环中遇到严重错误: {e}")

{beswarm-0.2.42 → beswarm-0.2.44}/beswarm/tools/__init__.py

@@ -4,6 +4,7 @@ from .completion import task_complete
 from .search_arxiv import search_arxiv
 from .repomap import get_code_repo_map
 from .write_csv import append_row_to_csv
+from .graph import add_knowledge_node, delete_knowledge_node, rename_knowledge_node, move_knowledge_node, get_knowledge_graph_tree
 from .request_input import request_admin_input
 from .screenshot import save_screenshot_to_file
 from .worker import worker, worker_gen, chatgroup
@@ -48,6 +49,11 @@ __all__ = [
     "list_directory",
     "get_task_result",
     "get_url_content",
+    "add_knowledge_node",
+    "move_knowledge_node",
+    "delete_knowledge_node",
+    "rename_knowledge_node",
+    "get_knowledge_graph_tree",
     "append_row_to_csv",
     "set_readonly_path",
     "get_code_repo_map",

beswarm-0.2.44/beswarm/tools/graph.py

@@ -0,0 +1,71 @@
+from ..aient.src.aient.plugins import register_tool
+from ..core import kgm
+
+@register_tool()
+def add_knowledge_node(parent_path: str, node_name: str, description: str = "") -> str:
+    """
+    在知识图谱的指定父路径下添加一个新节点。
+
+    Args:
+        parent_path (str): 父节点的路径。路径由'/'分隔，例如 'a/b'。根节点路径为 '.' 或 '/'。
+        node_name (str): 新节点的名称。名称中不能包含'/'字符。
+        description (str, optional): 节点的可选描述信息。默认为空字符串。
+
+    Returns:
+        str: 操作结果的描述信息，例如成功或失败的原因。
+    """
+    return kgm.add_node(parent_path, node_name, description)
+
+@register_tool()
+def delete_knowledge_node(node_path: str) -> str:
+    """
+    从知识图谱中删除一个节点及其所有后代节点。
+
+    Args:
+        node_path (str): 要删除的节点的完整路径，例如 'a/b/c'。不允许删除根节点。
+
+    Returns:
+        str: 操作结果的描述信息，例如成功或失败的原因。
+    """
+    return kgm.delete_node(node_path)
+
+@register_tool()
+def rename_knowledge_node(node_path: str, new_name: str) -> str:
+    """
+    重命名知识图谱中的一个现有节点。
+
+    Args:
+        node_path (str): 要重命名的节点的当前完整路径。
+        new_name (str): 节点的新名称。名称中不能包含'/'字符。
+
+    Returns:
+        str: 操作结果的描述信息，例如成功或失败的原因。
+    """
+    return kgm.rename_node(node_path, new_name)
+
+@register_tool()
+def move_knowledge_node(source_path: str, target_parent_path: str) -> str:
+    """
+    将一个节点（及其整个子树）移动到知识图谱中的另一个父节点下。
+
+    Args:
+        source_path (str): 要移动的节点的当前完整路径。
+        target_parent_path (str): 目标父节点的完整路径。节点将被移动到这个新父节点之下。
+
+    Returns:
+        str: 操作结果的描述信息，例如成功或失败的原因。
+    """
+    return kgm.move_node(source_path, target_parent_path)
+
+@register_tool()
+def get_knowledge_graph_tree() -> str:
+    """
+    渲染并返回整个知识图谱的文本树状图。
+
+    此工具不需要任何参数，它会读取当前的图状态并生成一个易于阅读的、
+    表示层级结构的字符串。
+
+    Returns:
+        str: 表示整个知识图谱的、格式化的树状结构字符串。
+    """
+    return kgm.render_tree()

{beswarm-0.2.42 → beswarm-0.2.44}/beswarm/tools/subtasks.py

@@ -67,27 +67,68 @@ def get_all_tasks_status():
     return task_manager.tasks_cache
 
 @register_tool()
-async def get_task_result():
+async def get_task_result(reduce: bool = False):
     """
-    等待并获取子任务的执行结果。如果需要等待子任务完成，请使用这个工具。一旦有任务完成，会自动获取结果。如果调用时没有任务完成，会等待直到有任务完成。
+    等待并获取子任务的执行结果。
+
+    如果 `reduce` 为 `False`（默认），此工具会等待并返回任何一个子任务完成的结果。
+    一旦有任务完成，它会立即获取并返回该任务的结果。如果调用时没有任务完成，它会阻塞并等待。
+
+    如果 `reduce` 为 `True`，此工具会进入“规约”模式，等待 **所有** 正在运行或待处理的子任务都执行完毕后，
+    才将所有任务的结果汇总并返回。这在子任务之间无依赖、可以完全并行执行的场景下非常有用，
+    可以避免为了获取每个任务的结果而进行多次轮询，从而节省token。
+
+    警告：当子任务之间存在依赖关系，或者需要根据一个任务的结果来决定下一步操作时，**禁止** 使用 `reduce=True`。
+
+    Args:
+        reduce (bool, optional): 是否启用规约模式。默认为 `False`。
 
     Returns:
-        str: 子任务的执行结果。
+        str:
+        - 当 `reduce=False` 时，返回单个子任务的执行结果。
+        - 当 `reduce=True` 时，返回一个包含所有任务最终状态和结果的汇总字符串。
     """
-    running_tasks_num = len([task_id for task_id, task in task_manager.tasks_cache.items() if task_id != "root_path" and task.get("status") in ["PENDING", "RUNNING"]])
-    if running_tasks_num == 0:
-        return "All tasks are finished."
-    task_id, status, result = await task_manager.get_next_result()
+    def get_running_tasks_count():
+        return len([
+            task_id for task_id, task in task_manager.tasks_cache.items()
+            if task_id != "root_path" and task.get("status") in ["PENDING", "RUNNING"]
+        ])
 
-    unfinished_tasks = [task_id for task_id, task in task_manager.tasks_cache.items() if task_id != "root_path" and task.get("status") != "DONE"]
-    text = "".join([
-        f"Task ID: {task_id}\n",
-        f"Status: {status.value}\n",
-        f"Result: {result}\n\n",
-        f"There are {len(unfinished_tasks)} unfinished tasks, unfinished task ids: {unfinished_tasks[:5]} ..." if unfinished_tasks else "All tasks are finished.",
-    ])
+    if get_running_tasks_count() == 0:
+        return "All tasks are finished."
 
-    return text
+    if not reduce:
+        # 默认行为：获取下一个完成的任务结果
+        task_id, status, result = await task_manager.get_next_result()
+
+        unfinished_tasks = [tid for tid, task in task_manager.tasks_cache.items() if tid != "root_path" and task.get("status") not in ["DONE", "ERROR"]]
+        text = "".join([
+            f"Task ID: {task_id}\n",
+            f"Status: {status.value}\n",
+            f"Result: {result}\n\n",
+            f"There are {len(unfinished_tasks)} unfinished tasks, unfinished task ids: {unfinished_tasks[:5]} ..." if unfinished_tasks else "All tasks are finished.",
+        ])
+        return text
+    else:
+        # 规约模式：等待所有任务完成
+        while get_running_tasks_count() > 0:
+            await task_manager.get_next_result()
+
+        # 收集所有任务的结果
+        all_results = []
+        for task_id, task in task_manager.tasks_cache.items():
+            if task_id == "root_path":
+                continue
+
+            status = task.get('status', 'UNKNOWN')
+            result = task.get('result', 'No result available')
+            all_results.append(
+                f"Task ID: {task_id}\nStatus: {status}\nResult: {result}"
+            )
+
+        summary = f"All {len(all_results)} subtasks have been completed.\n\n"
+        summary += "\n\n".join(all_results)
+        return summary
 
 import os
 import csv
@@ -97,6 +138,7 @@ def create_tasks_from_csv(goal_template: str, csv_file_path: str, tools_json_str
     """
     从一个CSV文件批量创建子任务。
     此工具读取CSV文件的每一行，使用行数据填充goal模板，然后为每一行创建一个新的子任务。
+    可以使用 get_task_result 工具获取每个子任务的运行结果。
 
     Args:
         goal_template (str): 一个包含占位符的字符串模板。占位符的格式应为 `{column_name}`，
@@ -127,6 +169,8 @@ def create_tasks_from_csv(goal_template: str, csv_file_path: str, tools_json_str
 
     try:
         # 2. 读取并处理CSV文件
+        # 增加CSV字段大小限制以处理大字段
+        csv.field_size_limit(min(2**31-1, 2**20))  # 设置为1MB或系统最大值
         with open(csv_file_path, mode='r', encoding='utf-8') as csvfile:
             # 使用 DictReader 可以方便地通过列名访问数据
             reader = csv.DictReader(csvfile)

{beswarm-0.2.42 → beswarm-0.2.44}/beswarm/tools/worker.py

@@ -1,7 +1,7 @@
 from datetime import datetime
 from typing import List, Dict, Union
 
-from ..core import mcp_manager, broker, task_manager
+from ..core import mcp_manager, broker, task_manager, kgm
 from ..agents.planact import BrokerWorker
 from ..agents.chatgroup import ChatGroupWorker
 from ..aient.src.aient.plugins import register_tool
@@ -10,7 +10,7 @@ from ..aient.src.aient.plugins import register_tool
 @register_tool()
 async def worker(goal: str, tools: List[Union[str, Dict]], work_dir: str, cache_messages: Union[bool, List[Dict]] = None):
     start_time = datetime.now()
-    worker_instance = BrokerWorker(goal, tools, work_dir, cache_messages, broker, mcp_manager, task_manager)
+    worker_instance = BrokerWorker(goal, tools, work_dir, cache_messages, broker, mcp_manager, task_manager, kgm)
     result = await worker_instance.run()
     end_time = datetime.now()
     print(f"\n任务开始时间: {start_time.strftime('%Y-%m-%d %H:%M:%S')}")
@@ -21,7 +21,7 @@ async def worker(goal: str, tools: List[Union[str, Dict]], work_dir: str, cache_
 @register_tool()
 async def worker_gen(goal: str, tools: List[Union[str, Dict]], work_dir: str, cache_messages: Union[bool, List[Dict]] = None):
     start_time = datetime.now()
-    worker_instance = BrokerWorker(goal, tools, work_dir, cache_messages, broker, mcp_manager, task_manager)
+    worker_instance = BrokerWorker(goal, tools, work_dir, cache_messages, broker, mcp_manager, task_manager, kgm)
     async for result in worker_instance.stream_run():
         yield result
     end_time = datetime.now()
@@ -32,7 +32,7 @@ async def worker_gen(goal: str, tools: List[Union[str, Dict]], work_dir: str, ca
 @register_tool()
 async def chatgroup(tools: List[Union[str, Dict]], work_dir: str, cache_messages: Union[bool, List[Dict]] = None):
     start_time = datetime.now()
-    worker_instance = ChatGroupWorker(tools, work_dir, cache_messages, broker, mcp_manager, task_manager)
+    worker_instance = ChatGroupWorker(tools, work_dir, cache_messages, broker, mcp_manager, task_manager, kgm)
     result = await worker_instance.run()
     end_time = datetime.now()
     print(f"\n任务开始时间: {start_time.strftime('%Y-%m-%d %H:%M:%S')}")

{beswarm-0.2.42 → beswarm-0.2.44}/beswarm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: beswarm
-Version: 0.2.42
+Version: 0.2.44
 Summary: MAS
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{beswarm-0.2.42 → beswarm-0.2.44}/beswarm.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 beswarm/__init__.py
 beswarm/broker.py
 beswarm/core.py
+beswarm/knowledge_graph.py
 beswarm/prompt.py
 beswarm/taskmanager.py
 beswarm/utils.py
@@ -142,6 +143,7 @@ beswarm/tools/__init__.py
 beswarm/tools/click.py
 beswarm/tools/completion.py
 beswarm/tools/edit_file.py
+beswarm/tools/graph.py
 beswarm/tools/planner.py
 beswarm/tools/repomap.py
 beswarm/tools/request_input.py
@@ -153,4 +155,5 @@ beswarm/tools/worker.py
 beswarm/tools/write_csv.py
 test/test_TaskManager.py
 test/test_broker.py
+test/test_graph.py
 test/test_new_TaskManager.py

{beswarm-0.2.42 → beswarm-0.2.44}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "beswarm"
-version = "0.2.42"
+version = "0.2.44"
 description = "MAS"
 readme = "README.md"
 requires-python = ">=3.11"