@baimingtao/lbs-agent 1.0.0

package/tools/tool/config.py

@@ -0,0 +1,191 @@
+"""工具域配置加载与 toolset/profile 解析。"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+import fnmatch
+from pathlib import Path
+from typing import Any
+
+try:
+    import yaml
+except ImportError:  # pragma: no cover
+    yaml = None
+
+from tools.tool.schema import ToolSafety, ToolSpec
+
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+DEFAULT_TOOLS_CONFIG = Path(__file__).with_name("tools.yaml")
+LEGACY_TOOLS_CONFIG = PROJECT_ROOT / "tools.yaml"
+
+
+@dataclass
+class ToolsetConfig:
+    name: str
+    description: str = ""
+    tools: list[str] = field(default_factory=list)
+
+
+@dataclass
+class ToolProfileConfig:
+    name: str
+    description: str = ""
+    include_toolsets: list[str] = field(default_factory=list)
+    include_tools: list[str] = field(default_factory=list)
+    deny_tools: list[str] = field(default_factory=list)
+    allow_safety: list[ToolSafety] = field(default_factory=list)
+    deny_safety: list[ToolSafety] = field(default_factory=list)
+    require_confirmation: list[ToolSafety] = field(default_factory=list)
+    auto_confirm: bool = False
+
+    def expanded_tool_names(self, toolsets: dict[str, ToolsetConfig]) -> list[str]:
+        names: list[str] = []
+        seen: set[str] = set()
+        for toolset_name in self.include_toolsets:
+            toolset = toolsets.get(toolset_name)
+            if not toolset:
+                continue
+            for tool in toolset.tools:
+                if tool not in seen:
+                    seen.add(tool)
+                    names.append(tool)
+        for tool in self.include_tools:
+            if tool not in seen:
+                seen.add(tool)
+                names.append(tool)
+        return [n for n in names if n not in set(self.deny_tools)]
+
+    def allows_spec(self, spec: ToolSpec, toolsets: dict[str, ToolsetConfig]) -> bool:
+        names = self.expanded_tool_names(toolsets)
+        if names and not any(fnmatch.fnmatch(spec.name, pattern) for pattern in names):
+            return False
+        if spec.name in set(self.deny_tools):
+            return False
+        if self.allow_safety and spec.safety not in set(self.allow_safety):
+            return False
+        if self.deny_safety and spec.safety in set(self.deny_safety):
+            return False
+        return True
+
+
+@dataclass
+class ToolsConfig:
+    default_profile: str = "default"
+    toolsets: dict[str, ToolsetConfig] = field(default_factory=dict)
+    profiles: dict[str, ToolProfileConfig] = field(default_factory=dict)
+    agent_profiles: dict[str, str] = field(default_factory=dict)
+    raw: dict[str, Any] = field(default_factory=dict)
+    config_path: str = ""
+    config_source: str = "built_in"
+
+    def resolve_agent_profile(self, agent_name: str, explicit_profile: str = "") -> ToolProfileConfig:
+        profile_name = explicit_profile or self.agent_profiles.get(agent_name) or self.default_profile
+        return self.profiles.get(profile_name) or self.profiles.get(self.default_profile) or ToolProfileConfig(name=profile_name or "default")
+
+    def list_specs_for_profile(self, registry, agent_or_profile: str, explicit_profile: str = "") -> list[ToolSpec]:
+        profile = self.resolve_agent_profile(agent_or_profile, explicit_profile=explicit_profile)
+        names = profile.expanded_tool_names(self.toolsets)
+        specs = [
+            spec
+            for candidate in registry.list_names()
+            if any(fnmatch.fnmatch(candidate, pattern) for pattern in names)
+            for spec in [registry.get_spec(candidate)]
+        ]
+        result = [s for s in specs if s and profile.allows_spec(s, self.toolsets)]
+        return result
+
+
+def _as_list(value: Any) -> list[Any]:
+    if value is None:
+        return []
+    if isinstance(value, list):
+        return value
+    return [value]
+
+
+def _safety_list(value: Any) -> list[ToolSafety]:
+    result: list[ToolSafety] = []
+    for item in _as_list(value):
+        if not item:
+            continue
+        result.append(ToolSafety(str(item)))
+    return result
+
+
+def _find_tools_yaml(path: str | None = None) -> tuple[str | None, str]:
+    if path:
+        return path, "explicit"
+    candidates = [
+        (Path.cwd() / "tools.yaml", "project_local"),
+        (Path.home() / ".config" / "lbs-agent" / "tools.yaml", "user_config"),
+        (DEFAULT_TOOLS_CONFIG, "domain_default"),
+        (LEGACY_TOOLS_CONFIG, "legacy_project"),
+    ]
+    for candidate, source in candidates:
+        if candidate.exists():
+            return str(candidate), source
+    return None, "built_in"
+
+
+def load_tools_config(path: str | None = None) -> ToolsConfig:
+    resolved, source = _find_tools_yaml(path)
+    if path and (not resolved or not Path(resolved).is_file()):
+        raise FileNotFoundError(f"显式 tools 配置不存在: {resolved or path}")
+    if not resolved or not Path(resolved).exists():
+        return default_tools_config(config_path=resolved or "", config_source=source)
+    if yaml is None:
+        raise ImportError("pip install pyyaml")
+    raw = yaml.safe_load(Path(resolved).read_text(encoding="utf-8")) or {}
+
+    toolsets: dict[str, ToolsetConfig] = {}
+    for name, spec in (raw.get("toolsets") or {}).items():
+        spec = spec or {}
+        toolsets[name] = ToolsetConfig(
+            name=name,
+            description=spec.get("description", ""),
+            tools=[str(x) for x in _as_list(spec.get("tools"))],
+        )
+    profiles: dict[str, ToolProfileConfig] = {}
+    for name, spec in (raw.get("profiles") or {}).items():
+        spec = spec or {}
+        profiles[name] = ToolProfileConfig(
+            name=name,
+            description=spec.get("description", ""),
+            include_toolsets=[str(x) for x in _as_list(spec.get("include_toolsets"))],
+            include_tools=[str(x) for x in _as_list(spec.get("include_tools"))],
+            deny_tools=[str(x) for x in _as_list(spec.get("deny_tools"))],
+            allow_safety=_safety_list(spec.get("allow_safety")),
+            deny_safety=_safety_list(spec.get("deny_safety")),
+            require_confirmation=_safety_list(spec.get("require_confirmation")),
+            auto_confirm=bool(spec.get("auto_confirm", False)),
+        )
+    cfg = ToolsConfig(
+        default_profile=str(raw.get("default_profile") or "default"),
+        toolsets=toolsets,
+        profiles=profiles,
+        agent_profiles={str(k): str(v) for k, v in (raw.get("agent_profiles") or {}).items()},
+        raw=raw,
+        config_path=resolved,
+        config_source=source,
+    )
+    if cfg.default_profile not in cfg.profiles:
+        cfg.profiles[cfg.default_profile] = ToolProfileConfig(name=cfg.default_profile)
+    return cfg
+
+
+def default_tools_config(config_path: str = "", config_source: str = "built_in") -> ToolsConfig:
+    return ToolsConfig(
+        default_profile="default",
+        toolsets={
+            "file_read": ToolsetConfig("file_read", "文件只读工具", ["read_file", "search_files", "list_dir"]),
+            "file_write": ToolsetConfig("file_write", "文件写入工具", ["write_file"]),
+            "shell": ToolsetConfig("shell", "本地命令执行", ["terminal"]),
+        },
+        profiles={
+            "default": ToolProfileConfig("default", "默认只读", ["file_read"], deny_safety=[ToolSafety.LOCAL_WRITE, ToolSafety.LOCAL_EXEC, ToolSafety.EXTERNAL_WRITE, ToolSafety.DESTRUCTIVE]),
+            "code": ToolProfileConfig("code", "代码修改", ["file_read", "file_write", "shell"]),
+            "audit": ToolProfileConfig("audit", "审计只读", ["file_read"], deny_safety=[ToolSafety.LOCAL_WRITE, ToolSafety.LOCAL_EXEC, ToolSafety.EXTERNAL_WRITE, ToolSafety.DESTRUCTIVE]),
+        },
+        agent_profiles={"code": "code", "audit": "audit", "security": "audit"},
+        config_path=config_path,
+        config_source=config_source,
+    )

package/tools/tool/hermes_migrated.py

@@ -0,0 +1,190 @@
+"""
+Hermes 对标工具迁移：memory / session_search。
+
+todo 工具已由 tools/tool/todo_provider.py 的 TodoProvider 提供（功能更完整，
+含 merge/dedupe/content cap/format_for_injection）。本模块不再重复注册 todo，
+只保留 memory 和 session_search 两个工具。
+
+迁移来源和方法：
+  - memory: Hermes MEMORY.md/USER.md pattern (agent-writable persistent notes)
+  - session_search: Hermes FTS5 session recall (search past conversations)
+"""
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass, field
+from typing import Any
+from pathlib import Path
+
+from tools.tool.providers.base import FunctionToolProvider
+from tools.tool.schema import ToolSource, ToolSafety
+
+
+# ═══════════════════════════════════════════════════
+# 1. Memory — Agent 可写持久记忆
+# ═══════════════════════════════════════════════════
+
+_MEMORY_ENTRY_DELIMITER = "\n§\n"
+
+
+def _get_memory_file(memory_type: str = "memory") -> Path:
+    """获取记忆文件路径。
+
+    memory: agent 个人笔记（环境事实、工具特性、经验教训）
+    user: 关于用户的知识（偏好、工作习惯、沟通风格）
+
+    不依赖 application 层：直接用 LBS_HOME 或项目根的 .lbs-agent 目录。
+    """
+    lbs_home = os.environ.get("LBS_HOME")
+    if lbs_home:
+        memory_dir = Path(lbs_home).resolve()
+    else:
+        memory_dir = Path.cwd().resolve() / ".lbs-agent"
+    memory_dir.mkdir(parents=True, exist_ok=True)
+    return memory_dir / f"{memory_type.upper()}.md"
+
+
+def _memory_tool(action: str = "read", content: str = "", old_text: str = "", target: str = "memory") -> str:
+    """Agent 持久记忆工具。
+
+    action:
+      read    — 读取当前记忆
+      add     — 添加一条记忆
+      replace — 替换包含 old_text 的记忆条目
+      remove  — 删除包含 old_text 的记忆条目
+
+    target: memory (agent 笔记) | user (用户画像)
+    """
+    path = _get_memory_file(target)
+
+    if action == "read":
+        if path.exists():
+            return path.read_text(encoding="utf-8")
+        return f"{target} 记忆为空。"
+
+    if action == "add":
+        existing = path.read_text(encoding="utf-8") if path.exists() else ""
+        entry = content.strip()
+        if existing:
+            new_content = existing + _MEMORY_ENTRY_DELIMITER + entry
+        else:
+            new_content = entry
+        path.write_text(new_content, encoding="utf-8")
+        return f"已添加到 {target} 记忆。当前共 {new_content.count(_MEMORY_ENTRY_DELIMITER) + 1} 条。"
+
+    if action in ("replace", "remove"):
+        existing = path.read_text(encoding="utf-8") if path.exists() else ""
+        if not existing:
+            return f"{target} 记忆为空，无法 {action}。"
+        entries = existing.split(_MEMORY_ENTRY_DELIMITER)
+        matched = False
+        new_entries = []
+        for entry in entries:
+            if old_text and old_text in entry:
+                matched = True
+                if action == "replace":
+                    new_entries.append(content.strip())
+                # remove: skip this entry
+            else:
+                new_entries.append(entry)
+        if not matched:
+            return f"未找到包含 '{old_text}' 的记忆条目。"
+        path.write_text(_MEMORY_ENTRY_DELIMITER.join(new_entries), encoding="utf-8")
+        return f"已{action} {target} 记忆中的条目。剩余 {len(new_entries)} 条。"
+
+    return f"未知 action: {action}"
+
+
+_MEMORY_SCHEMA = {
+    "type": "object",
+    "properties": {
+        "action": {"type": "string", "enum": ["read", "add", "replace", "remove"], "description": "操作类型", "default": "read"},
+        "content": {"type": "string", "description": "新增或替换的内容"},
+        "old_text": {"type": "string", "description": "要替换/删除的条目的唯一子串"},
+        "target": {"type": "string", "enum": ["memory", "user"], "description": "记忆存储：memory=agent笔记, user=用户画像", "default": "memory"},
+    },
+}
+
+
+# ═══════════════════════════════════════════════════
+# 3. Session Search — 历史会话搜索
+# ═══════════════════════════════════════════════════
+
+def _session_search_tool(query: str = "", limit: int = 5, *, _store_resolver=None) -> str:
+    """搜索历史会话。
+
+    传入 query 进行全文搜索；不传参数列出最近的会话。
+    _store_resolver 是注入的可调用对象，返回 SessionStore 实例。
+    工具层不直接依赖 runtime.memory.session 或 application.container。
+    """
+    if _store_resolver is not None:
+        store = _store_resolver()
+    else:
+        # 兜底：用 LazyImport 方式延迟加载，不形成模块级静态依赖
+        import importlib
+        cls = importlib.import_module("runtime.memory.session.session_store").SessionStore
+        lbs_home = os.environ.get("LBS_HOME")
+        project_root = Path.cwd()
+        store = cls(str(project_root), session_dir=Path(lbs_home) / "sessions" if lbs_home else None)
+
+    if not query:
+        sessions = store.list_sessions(limit=limit)
+        if not sessions:
+            return "没有历史会话。"
+        lines = [f"最近 {len(sessions)} 个会话:"]
+        for s in sessions:
+            lines.append(f"  [{s.session_id[:20]}...] {s.agent_name}: {s.task[:60]} ({'成功' if s.success else '失败'})")
+        return "\n".join(lines)
+
+    results = store.search_sessions(query, limit=limit)
+    if not results:
+        return f"未找到匹配 '{query}' 的会话。"
+
+    lines = [f"找到 {len(results)} 个匹配 '{query}' 的会话:"]
+    for r in results:
+        lines.append(f"  [{r.get('session_id', '')[:20]}...] {r.get('agent_name', '')}: {r.get('task', '')[:60]}")
+    return "\n".join(lines)
+
+
+_SESSION_SEARCH_SCHEMA = {
+    "type": "object",
+    "properties": {
+        "query": {"type": "string", "description": "搜索关键词。省略则列出最近会话。"},
+        "limit": {"type": "integer", "description": "最大返回数，默认 5", "default": 5},
+    },
+}
+
+
+# ═══════════════════════════════════════════════════
+# Provider 注册入口
+# ═══════════════════════════════════════════════════
+
+def create_hermes_migrated_provider() -> FunctionToolProvider:
+    """创建包含 memory / session_search 工具的 Provider。
+
+    注意：todo 工具由 TodoProvider 单独注册（功能更完整）。
+    在 create_default_registry() 中调用，注册到全局 ToolRegistry。
+    """
+    provider = FunctionToolProvider(
+        provider_id="builtin.hermes_migrated",
+        source=ToolSource.BUILTIN,
+    )
+    provider.register(
+        name="memory",
+        description="读写持久记忆。action: read/add/replace/remove。target: memory(agent笔记)/user(用户画像)。",
+        func=_memory_tool,
+        input_schema=_MEMORY_SCHEMA,
+        safety=ToolSafety.LOCAL_WRITE,
+        capability_tags=["memory", "persistence"],
+        requires_confirmation=False,
+    )
+    provider.register(
+        name="session_search",
+        description="搜索历史会话。传入 query 进行全文搜索；不传则列出最近的会话。",
+        func=_session_search_tool,
+        input_schema=_SESSION_SEARCH_SCHEMA,
+        safety=ToolSafety.LOCAL_READ,
+        capability_tags=["search", "recall"],
+    )
+    return provider

package/tools/tool/implementations/__init__.py

@@ -0,0 +1 @@
+"""智能体系统目标架构包。"""