devmate 2.5.1__tar.gz → 2.5.2__tar.gz

{devmate-2.5.1 → devmate-2.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devmate
-Version: 2.5.1
+Version: 2.5.2
 Summary: 程序员终端瑞士军刀 + AI 原生平台——替代 5 个独立工具，一个 CLI 搞定
 Author-email: DevMate Team <devmate@example.com>
 License: MIT

{devmate-2.5.1 → devmate-2.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devmate"
-version = "2.5.1"
+version = "2.5.2"
 description = "程序员终端瑞士军刀 + AI 原生平台——替代 5 个独立工具，一个 CLI 搞定"
 readme = "README.md"
 authors = [

{devmate-2.5.1 → devmate-2.5.2}/src/devmate/__init__.py

@@ -1,6 +1,6 @@
 """
 DevMate — 程序员终端瑞士军刀
 """
-__version__ = "2.5.1"
+__version__ = "2.5.2"
 __app_name__ = "DevMate"
 __description__ = "程序员终端瑞士军刀——替代 5 个独立工具，一个 CLI 搞定"

devmate-2.5.2/src/devmate/sub_agent/__init__.py

@@ -0,0 +1,237 @@
+"""devmate.sub_agent — Sub-agent 隔离（P0-⑥ · Context Isolate）
+
+方法论：Context Engineering 五动作之一「隔离（Isolate）」
+  - 旁支任务委派给独立上下文的 Sub-agent
+  - 主 Agent 不承载子任务细节，只拿回结构化结果摘要
+  - 长任务 → 拆子任务 → 各子任务独立上下文 → 汇总
+  - 输出契约（多 Agent 工程三原则）：每个子任务声明期望输出格式
+    缺失字段 → 标记 schema_failed（关键节点校验）
+
+设计：
+  - Sub-agent 复用 AgentRuntime（独立 SessionMemory，互不污染）
+  - 结果自动截断/摘要，只回传关键信息给主上下文
+  - 支持并行执行多个子任务（ThreadPoolExecutor）
+  - 输出契约：expected_schema 声明字段名→类型，结果校验缺字段/类型错
+"""
+
+import json
+import time
+from dataclasses import dataclass, field
+from pathlib import Path  # noqa: F401
+
+from devmate.bus.command import CommandResult
+
+# 允许的 schema 类型
+_SCHEMA_TYPES = {"string": str, "int": int, "float": (int, float),
+                 "bool": bool, "list": list, "dict": dict, "any": object}
+
+
+@dataclass
+class SubTask:
+    """子任务定义"""
+    name: str                       # 子任务名
+    prompt: str                     # 子任务指令（独立上下文）
+    max_steps: int = 5              # 最大步数
+    tool_whitelist: list[str] = field(default_factory=list)  # 允许的工具白名单
+    expected_schema: dict | None = None  # 输出契约 {字段: 类型}（如 {"host": "string"})
+    schema_required: bool = True    # 契约校验失败是否算任务失败
+
+    def to_dict(self) -> dict:
+        return {"name": self.name, "prompt": self.prompt,
+                "max_steps": self.max_steps,
+                "tool_whitelist": self.tool_whitelist,
+                "expected_schema": self.expected_schema}
+
+
+def validate_schema(output: str, schema: dict) -> tuple[bool, list[str]]:
+    """校验输出是否符合契约
+
+    策略（宽容解析）：
+      1. 尝试 JSON 解析（输出可能是 JSON）
+      2. 否则尝试 key: value 逐行解析
+      3. 从文本中按字段名查找
+
+    Returns:
+        (是否通过, 缺失/错误字段列表)
+    """
+    if not schema:
+        return True, []
+
+    # 尝试 JSON 解析
+    obj = None
+    try:
+        obj = json.loads(output)
+    except Exception:
+        pass
+
+    issues = []
+    for field_name, field_type in schema.items():
+        # 定位值
+        value = None
+        if isinstance(obj, dict):
+            value = obj.get(field_name)
+        elif obj is not None:
+            continue  # JSON 数组等，无法按字段校验
+        else:
+            # 行解析：key: value
+            for line in output.splitlines():
+                line = line.strip().lstrip("-• ")
+                if ":" in line:
+                    k, _, v = line.partition(":")
+                    if k.strip().strip('"').strip("'") == field_name:
+                        value = v.strip()
+                        break
+            if value is None:
+                # 全文包含字段名
+                if field_name in output:
+                    continue  # 出现但无法解析值，视为通过
+
+        if value is None or value == "":
+            issues.append(f"{field_name} 缺失")
+            continue
+
+        # 类型校验（宽容：去掉逗号/百分号/中文单位后缀）
+        expected_type = _SCHEMA_TYPES.get(field_type, object)
+        try:
+            clean = str(value).replace(",", "").replace("%", "")
+            # 去常见中英文单位后缀（核/GB/MB/秒/ms/元/%）
+            for unit in ("核", "个", "台", "GB", "MB", "KB", "秒", "ms", "元",
+                         "字节", "张", "条"):
+                clean = clean.removesuffix(unit)
+            clean = clean.strip()
+            if field_type == "int":
+                int(clean)
+            elif field_type == "float":
+                float(clean)
+            elif field_type == "string":
+                str(value)
+            elif field_type in ("list", "dict"):
+                if not isinstance(value, expected_type):
+                    issues.append(f"{field_name} 类型错误(期望 {field_type})")
+            elif field_type == "bool":
+                if str(value).lower() not in ("true", "false", "1", "0", "是", "否"):
+                    issues.append(f"{field_name} 类型错误(期望 bool)")
+            elif field_type == "any":
+                pass
+            elif not isinstance(value, expected_type):
+                issues.append(f"{field_name} 类型错误(期望 {field_type})")
+        except (ValueError, TypeError):
+            issues.append(f"{field_name} 类型错误(期望 {field_type})")
+
+    return not issues, issues
+
+
+@dataclass
+class SubTaskResult:
+    """子任务结果"""
+    name: str
+    success: bool
+    summary: str = ""
+    duration_ms: float = 0.0
+    steps: int = 0
+    error: str = ""
+    schema_ok: bool = True         # 输出契约校验是否通过
+    schema_missing: list[str] = field(default_factory=list)  # 缺失/错误字段
+
+    def to_dict(self) -> dict:
+        return {"name": self.name, "success": self.success,
+                "summary": self.summary[:300],
+                "duration_ms": round(self.duration_ms, 1),
+                "steps": self.steps, "error": self.error[:200],
+                "schema_ok": self.schema_ok,
+                "schema_missing": self.schema_missing}
+
+
+def run_subtask(task: SubTask, workdir: str = ".") -> SubTaskResult:
+    """执行单个子任务（独立上下文）
+
+    用 AgentRuntime 跑，但：
+      - 独立 SessionMemory（不污染主 Agent）
+      - 独立工具环境（tool_whitelist 过滤）
+      - 结果只回传摘要 + 输出契约校验（expected_schema）
+    """
+    start = time.time()
+    try:
+        from devmate_agent import AgentRuntime
+
+        runtime = AgentRuntime()
+
+        # 工具白名单过滤（隔离：子任务只看到允许的工具）
+        if task.tool_whitelist:
+            allowed = set(task.tool_whitelist)
+            for tname in list(runtime.tools.list_names()):
+                if tname not in allowed:
+                    runtime.tools.unregister(tname)
+
+        # 运行子任务（dry_run=False 真实执行）
+        result = runtime.run(task.prompt, max_steps=task.max_steps)
+
+        if result.success:
+            data = result.data
+            summary = str(data.get("final_output", data.get("output", "")))[:300]
+            # 输出契约校验（关键节点校验：缺失字段标记失败）
+            schema_ok, missing = True, []
+            if task.expected_schema:
+                schema_ok, missing = validate_schema(summary, task.expected_schema)
+                if not schema_ok and task.schema_required:
+                    return SubTaskResult(
+                        name=task.name, success=False,
+                        error=f"输出契约校验失败: 缺 {', '.join(missing)}",
+                        summary=summary, schema_ok=False,
+                        schema_missing=missing,
+                        duration_ms=(time.time() - start) * 1000,
+                        steps=data.get("step_count", data.get("total_steps", 0)),
+                    )
+            return SubTaskResult(
+                name=task.name, success=True, summary=summary,
+                duration_ms=(time.time() - start) * 1000,
+                steps=data.get("step_count", data.get("total_steps", 0)),
+                schema_ok=schema_ok, schema_missing=missing,
+            )
+        return SubTaskResult(
+            name=task.name, success=False,
+            error=str(result.error or "任务失败"),
+            duration_ms=(time.time() - start) * 1000,
+        )
+    except Exception as e:
+        return SubTaskResult(
+            name=task.name, success=False, error=str(e),
+            duration_ms=(time.time() - start) * 1000,
+        )
+
+
+def run_subtasks(tasks: list[SubTask], workdir: str = ".",
+                 parallel: bool = True) -> CommandResult:
+    """并行/串行执行多个子任务
+
+    Args:
+        tasks: 子任务列表
+        workdir: 工作目录
+        parallel: 是否并行（默认 True）
+    """
+    results = []
+    if parallel and len(tasks) > 1:
+        from concurrent.futures import ThreadPoolExecutor
+        with ThreadPoolExecutor(max_workers=min(len(tasks), 4)) as pool:
+            futures = {pool.submit(run_subtask, t, workdir): t.name
+                       for t in tasks}
+            # 保持任务顺序
+            ordered = [futures[f] for f in futures]
+            for f, name in zip(futures, ordered):
+                results.append(f.result())
+    else:
+        for t in tasks:
+            results.append(run_subtask(t, workdir))
+
+    success = sum(1 for r in results if r.success)
+    total = len(results)
+    return CommandResult(success=success == total, data={
+        "results": [r.to_dict() for r in results],
+        "success_count": success,
+        "total": total,
+        "message": f"Sub-agents: {success}/{total} 成功",
+        "summary": "\n".join(
+            f"[{'✅' if r.success else '❌'}] {r.name}: "
+            f"{r.summary or r.error}" for r in results
+        )[:800],
+    })

{devmate-2.5.1 → devmate-2.5.2}/src/devmate.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devmate
-Version: 2.5.1
+Version: 2.5.2
 Summary: 程序员终端瑞士军刀 + AI 原生平台——替代 5 个独立工具，一个 CLI 搞定
 Author-email: DevMate Team <devmate@example.com>
 License: MIT

devmate-2.5.1/src/devmate/sub_agent/__init__.py

@@ -1,130 +0,0 @@
-"""devmate.sub_agent — Sub-agent 隔离（P0-⑥ · Context Isolate）
-
-方法论：Context Engineering 五动作之一「隔离（Isolate）」
-  - 旁支任务委派给独立上下文的 Sub-agent
-  - 主 Agent 不承载子任务细节，只拿回结构化结果摘要
-  - 长任务 → 拆子任务 → 各子任务独立上下文 → 汇总
-
-设计：
-  - Sub-agent 复用 AgentRuntime（独立 SessionMemory，互不污染）
-  - 结果自动截断/摘要，只回传关键信息给主上下文
-  - 支持并行执行多个子任务（ThreadPoolExecutor）
-"""
-
-import time
-from dataclasses import dataclass, field
-from pathlib import Path  # noqa: F401
-
-from devmate.bus.command import CommandResult
-
-
-@dataclass
-class SubTask:
-    """子任务定义"""
-    name: str                       # 子任务名
-    prompt: str                     # 子任务指令（独立上下文）
-    max_steps: int = 5              # 最大步数
-    tool_whitelist: list[str] = field(default_factory=list)  # 允许的工具白名单
-
-    def to_dict(self) -> dict:
-        return {"name": self.name, "prompt": self.prompt,
-                "max_steps": self.max_steps,
-                "tool_whitelist": self.tool_whitelist}
-
-
-@dataclass
-class SubTaskResult:
-    """子任务结果"""
-    name: str
-    success: bool
-    summary: str = ""
-    duration_ms: float = 0.0
-    steps: int = 0
-    error: str = ""
-
-    def to_dict(self) -> dict:
-        return {"name": self.name, "success": self.success,
-                "summary": self.summary[:300],
-                "duration_ms": round(self.duration_ms, 1),
-                "steps": self.steps, "error": self.error[:200]}
-
-
-def run_subtask(task: SubTask, workdir: str = ".") -> SubTaskResult:
-    """执行单个子任务（独立上下文）
-
-    用 AgentRuntime 跑，但：
-      - 独立 SessionMemory（不污染主 Agent）
-      - 独立工具环境（tool_whitelist 过滤）
-      - 结果只回传摘要
-    """
-    start = time.time()
-    try:
-        from devmate_agent import AgentRuntime
-
-        runtime = AgentRuntime()
-
-        # 工具白名单过滤（隔离：子任务只看到允许的工具）
-        if task.tool_whitelist:
-            allowed = set(task.tool_whitelist)
-            for tname in list(runtime.tools.list_names()):
-                if tname not in allowed:
-                    runtime.tools.unregister(tname)
-
-        # 运行子任务（dry_run=False 真实执行）
-        result = runtime.run(task.prompt, max_steps=task.max_steps)
-
-        if result.success:
-            data = result.data
-            summary = str(data.get("final_output", data.get("output", "")))[:300]
-            return SubTaskResult(
-                name=task.name, success=True, summary=summary,
-                duration_ms=(time.time() - start) * 1000,
-                steps=data.get("step_count", data.get("total_steps", 0)),
-            )
-        return SubTaskResult(
-            name=task.name, success=False,
-            error=str(result.error or "任务失败"),
-            duration_ms=(time.time() - start) * 1000,
-        )
-    except Exception as e:
-        return SubTaskResult(
-            name=task.name, success=False, error=str(e),
-            duration_ms=(time.time() - start) * 1000,
-        )
-
-
-def run_subtasks(tasks: list[SubTask], workdir: str = ".",
-                 parallel: bool = True) -> CommandResult:
-    """并行/串行执行多个子任务
-
-    Args:
-        tasks: 子任务列表
-        workdir: 工作目录
-        parallel: 是否并行（默认 True）
-    """
-    results = []
-    if parallel and len(tasks) > 1:
-        from concurrent.futures import ThreadPoolExecutor
-        with ThreadPoolExecutor(max_workers=min(len(tasks), 4)) as pool:
-            futures = {pool.submit(run_subtask, t, workdir): t.name
-                       for t in tasks}
-            # 保持任务顺序
-            ordered = [futures[f] for f in futures]
-            for f, name in zip(futures, ordered):
-                results.append(f.result())
-    else:
-        for t in tasks:
-            results.append(run_subtask(t, workdir))
-
-    success = sum(1 for r in results if r.success)
-    total = len(results)
-    return CommandResult(success=success == total, data={
-        "results": [r.to_dict() for r in results],
-        "success_count": success,
-        "total": total,
-        "message": f"Sub-agents: {success}/{total} 成功",
-        "summary": "\n".join(
-            f"[{'✅' if r.success else '❌'}] {r.name}: "
-            f"{r.summary or r.error}" for r in results
-        )[:800],
-    })