devmate 2.3.0__tar.gz → 2.5.0__tar.gz

{devmate-2.3.0 → devmate-2.5.0}/PKG-INFO

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

{devmate-2.3.0 → devmate-2.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devmate"
-version = "2.3.0"
+version = "2.5.0"
 description = "程序员终端瑞士军刀 + AI 原生平台——替代 5 个独立工具，一个 CLI 搞定"
 readme = "README.md"
 authors = [
@@ -89,6 +89,13 @@ audit = "devmate_audit"
 plugin = "devmate_plugin_engine"
 publisher = "devmate_publisher"
 
+[project.entry-points."devmate.plugins"]
+code-stats = "devmate_plugins.code_stats:CodeStatsPlugin"
+pomodoro = "devmate_plugins.pomodoro:PomodoroPlugin"
+env-switch = "devmate_plugins.env_switch:EnvSwitchPlugin"
+port-scan = "devmate_plugins.port_scan:PortScanPlugin"
+file-watch = "devmate_plugins.file_watch:FileWatchPlugin"
+
 [tool.setuptools.packages.find]
 where = ["src"]
 include = ["devmate*", "devmate_*"]

{devmate-2.3.0 → devmate-2.5.0}/src/devmate/__init__.py

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

devmate-2.5.0/src/devmate/agent/validators.py

@@ -0,0 +1,197 @@
+"""devmate.agent.validators — 验证信号注入（P0）
+
+确定性校验器集合：写文件后自动校验，反馈给 Agent 自纠。
+遵循原则：能用计算型信号解决的优先交给确定性程序。
+
+校验器：
+  - python_syntax: py_compile 语法检查
+  - python_style:  ruff check 代码风格（可用时）
+  - json_valid:    json.loads 合法 JSON
+  - shell_syntax: bash -n 语法检查
+  - yaml_valid:   yaml 解析（可用时）
+"""
+
+import json
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class ValidatorResult:
+    """校验结果"""
+    ok: bool
+    validator: str
+    file: str
+    errors: list[str] = field(default_factory=list)
+    suggestions: list[str] = field(default_factory=list)
+
+    def to_feedback(self) -> str:
+        """转为反馈给 Agent 的文本（含修复建议）"""
+        if self.ok:
+            return f"✅ 校验通过 [{self.validator}]: {self.file}"
+        lines = [f"❌ 校验失败 [{self.validator}]: {self.file}"]
+        for e in self.errors[:10]:
+            lines.append(f"   - {e}")
+        if self.suggestions:
+            lines.append("   修复建议:")
+            for s in self.suggestions[:5]:
+                lines.append(f"     * {s}")
+        return "\n".join(lines)
+
+
+class BaseValidator:
+    """校验器基类"""
+    name = "base"
+
+    def validate(self, path: str) -> ValidatorResult:
+        raise NotImplementedError
+
+
+class PythonSyntaxValidator(BaseValidator):
+    """Python 语法检查（py_compile，零依赖）"""
+    name = "python_syntax"
+
+    def validate(self, path: str) -> ValidatorResult:
+        import py_compile
+        try:
+            py_compile.compile(path, doraise=True)
+            return ValidatorResult(True, self.name, path)
+        except py_compile.PyCompileError as e:
+            return ValidatorResult(
+                False, self.name, path,
+                errors=[str(e).splitlines()[0] if str(e) else "语法错误"],
+                suggestions=["检查缩进、括号配对、引号闭合",
+                             "可用 `python -m py_compile <file>` 本地复现"],
+            )
+        except Exception as e:
+            return ValidatorResult(False, self.name, path, errors=[str(e)])
+
+
+class PythonStyleValidator(BaseValidator):
+    """Python 代码风格（ruff，可用时）"""
+    name = "python_style"
+
+    def validate(self, path: str) -> ValidatorResult:
+        try:
+            result = subprocess.run(
+                ["ruff", "check", path],
+                capture_output=True, text=True, timeout=15,
+            )
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            return ValidatorResult(True, self.name, path)  # ruff 不可用跳过
+        if result.returncode == 0:
+            return ValidatorResult(True, self.name, path)
+        errors = [l for l in result.stdout.splitlines() if ":" in l][:10]  # noqa: E741
+        return ValidatorResult(
+            False, self.name, path,
+            errors=errors,
+            suggestions=["运行 `ruff check --fix <file>` 自动修复",
+                         "常见：未使用导入/过长行/命名不规范"],
+        )
+
+
+class JsonValidator(BaseValidator):
+    """JSON 合法性"""
+    name = "json_valid"
+
+    def validate(self, path: str) -> ValidatorResult:
+        try:
+            Path(path).read_text(encoding="utf-8")
+            json.loads(Path(path).read_text(encoding="utf-8"))
+            return ValidatorResult(True, self.name, path)
+        except json.JSONDecodeError as e:
+            return ValidatorResult(
+                False, self.name, path,
+                errors=[f"行 {e.lineno} 列 {e.colno}: {e.msg}"],
+                suggestions=["检查逗号、引号、括号配对",
+                             "可用 `python -m json.tool <file>` 定位错误"],
+            )
+        except Exception as e:
+            return ValidatorResult(False, self.name, path, errors=[str(e)])
+
+
+class ShellSyntaxValidator(BaseValidator):
+    """Shell 语法检查（bash -n）"""
+    name = "shell_syntax"
+
+    def validate(self, path: str) -> ValidatorResult:
+        try:
+            result = subprocess.run(
+                ["bash", "-n", path],
+                capture_output=True, text=True, timeout=10,
+            )
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            return ValidatorResult(True, self.name, path)  # bash 不可用跳过
+        if result.returncode == 0:
+            return ValidatorResult(True, self.name, path)
+        return ValidatorResult(
+            False, self.name, path,
+            errors=[l for l in result.stderr.splitlines()[:10] if l.strip()],  # noqa: E741
+            suggestions=["检查引号/括号配对、if/for 语句闭合"],
+        )
+
+
+class YamlValidator(BaseValidator):
+    """YAML 合法性（pyyaml 可用时）"""
+    name = "yaml_valid"
+
+    def validate(self, path: str) -> ValidatorResult:
+        try:
+            import yaml
+        except ImportError:
+            return ValidatorResult(True, self.name, path)  # yaml 不可用跳过
+        try:
+            yaml.safe_load(Path(path).read_text(encoding="utf-8"))
+            return ValidatorResult(True, self.name, path)
+        except yaml.YAMLError as e:
+            return ValidatorResult(
+                False, self.name, path,
+                errors=[str(e).splitlines()[0] if str(e) else "YAML 错误"],
+                suggestions=["检查缩进一致性（YAML 对缩进敏感）"],
+            )
+
+
+# 按扩展名注册校验器
+EXT_VALIDATORS: dict[str, list[BaseValidator]] = {
+    ".py": [PythonSyntaxValidator(), PythonStyleValidator()],
+    ".json": [JsonValidator()],
+    ".sh": [ShellSyntaxValidator()],
+    ".bash": [ShellSyntaxValidator()],
+    ".yml": [YamlValidator()],
+    ".yaml": [YamlValidator()],
+}
+
+
+def get_validators(path: str) -> list[BaseValidator]:
+    """获取文件对应的校验器列表"""
+    ext = Path(path).suffix.lower()
+    return EXT_VALIDATORS.get(ext, [])
+
+
+def validate_file(path: str) -> list[ValidatorResult]:
+    """校验单个文件，返回全部结果"""
+    results = []
+    for v in get_validators(path):
+        try:
+            results.append(v.validate(path))
+        except Exception as e:
+            results.append(ValidatorResult(False, v.name, path, errors=[str(e)]))
+    return results
+
+
+def validate_file_feedback(path: str) -> str:
+    """校验文件并返回组合反馈（空 = 全部通过）"""
+    results = validate_file(path)
+    failed = [r for r in results if not r.ok]
+    if not failed:
+        return ""
+    return "\n".join(r.to_feedback() for r in failed)
+
+
+def summarize_validation(results: list[ValidatorResult]) -> str:
+    """汇总校验结果（供审计）"""
+    if not results:
+        return "无适用校验器"
+    ok_count = sum(1 for r in results if r.ok)
+    return f"{ok_count}/{len(results)} 校验通过"

devmate-2.5.0/src/devmate/agent_eval/__init__.py

@@ -0,0 +1,267 @@
+"""devmate.agent_eval — Agent 评测体系（P0 补充）
+
+借鉴 Anthropic 对抗评估方法论：
+  - 行为清单（Checklist）：把任务拆成 200+ 条具体行为描述（JSON）
+  - 每条标 pass/fail，禁止删条目或降标准
+  - Planner/Generator/Evaluator 三角色分工
+
+核心思路：用确定性信号（校验器/文件存在/命令输出）自动判定 pass/fail，
+不依赖 LLM 判断，保证评测可复现、可追踪。
+"""
+
+import json
+import time
+from collections.abc import Callable
+from dataclasses import dataclass, field  # noqa: F401
+from pathlib import Path
+
+from devmate.bus.command import CommandResult
+
+EVAL_DIR = Path.home() / ".devmate" / "eval"
+REPORTS_DIR = EVAL_DIR / "reports"
+
+
+@dataclass
+class BehaviorItem:
+    """行为清单条目"""
+    id: str                       # 如 B-001
+    description: str              # 行为描述
+    category: str = "general"     # 分类
+    check: str = ""               # 检查方式（shell 命令或特殊标识）
+    required: bool = True         # 是否必过
+
+    def to_dict(self) -> dict:
+        return {"id": self.id, "description": self.description,
+                "category": self.category, "check": self.check,
+                "required": self.required}
+
+
+@dataclass
+class EvalResult:
+    """单条行为评测结果"""
+    item: BehaviorItem
+    passed: bool
+    detail: str = ""
+
+    def to_dict(self) -> dict:
+        return {"id": self.item.id, "description": self.item.description,
+                "category": self.item.category, "passed": self.passed,
+                "detail": self.detail, "required": self.item.required}
+
+
+# ── 检查器（确定性验证信号） ─────────────────────
+
+def _check_file_exists(path: str) -> bool:
+    return Path(path).expanduser().exists()
+
+
+def _check_file_contains(path: str, text: str) -> bool:
+    p = Path(path).expanduser()
+    if not p.exists():
+        return False
+    try:
+        return text in p.read_text(errors="replace")
+    except Exception:
+        return False
+
+
+def _check_command(cmd: str) -> tuple[bool, str]:
+    """执行 shell 命令检查（返回码 0 = pass）"""
+    import subprocess
+    try:
+        result = subprocess.run(
+            ["bash", "-c", cmd], capture_output=True, text=True, timeout=30)
+        return result.returncode == 0, (result.stdout + result.stderr)[:200]
+    except Exception as e:
+        return False, str(e)
+
+
+def _check_python_syntax(path: str) -> bool:
+    import py_compile
+    try:
+        py_compile.compile(path, doraise=True)
+        return True
+    except Exception:
+        return False
+
+
+def _check_json_valid(path: str) -> bool:
+    try:
+        json.loads(Path(path).read_text())
+        return True
+    except Exception:
+        return False
+
+
+# ── 行为清单执行器 ──────────────────────────────
+
+def run_checklist(items: list[BehaviorItem], workdir: str = ".") -> CommandResult:
+    """执行行为清单评测
+
+    Args:
+        items: 行为条目列表
+        workdir: 工作目录（相对路径基准）
+    """
+    results = []
+    passed = 0
+    failed = 0
+    skipped = []
+
+    for item in items:
+        check = item.check.strip()
+        ok = False
+        detail = ""
+
+        try:
+            if check.startswith("file_exists:"):
+                path = check.split(":", 1)[1].strip()
+                if not Path(path).is_absolute():
+                    path = str(Path(workdir) / path)
+                ok = _check_file_exists(path)
+                detail = f"文件存在: {path}" if ok else f"文件不存在: {path}"
+            elif check.startswith("file_contains:"):
+                _, rest = check.split(":", 1)
+                path, _, text = rest.partition("::")
+                if not Path(path).is_absolute():
+                    path = str(Path(workdir) / path)
+                ok = _check_file_contains(path.strip(), text.strip())
+                detail = f"含文本: {text.strip()}" if ok else f"缺文本: {text.strip()}"
+            elif check.startswith("python_syntax:"):
+                path = check.split(":", 1)[1].strip()
+                if not Path(path).is_absolute():
+                    path = str(Path(workdir) / path)
+                ok = _check_python_syntax(path)
+                detail = f"Python 语法: {path}" if ok else f"语法错误: {path}"
+            elif check.startswith("json_valid:"):
+                path = check.split(":", 1)[1].strip()
+                if not Path(path).is_absolute():
+                    path = str(Path(workdir) / path)
+                ok = _check_json_valid(path)
+                detail = f"JSON 合法: {path}" if ok else f"JSON 无效: {path}"
+            elif check.startswith("cmd:"):
+                ok, detail = _check_command(check.split(":", 1)[1].strip())
+            elif check:
+                # 未知检查方式 → 跳过（不降标准）
+                skipped.append(item.id)
+                continue
+            else:
+                # 无检查 → 视为描述性条目（由评估者人工/LLM 判定）
+                skipped.append(item.id)
+                continue
+        except Exception as e:
+            ok = False
+            detail = str(e)
+
+        results.append(EvalResult(item=item, passed=ok, detail=detail))
+        if ok:
+            passed += 1
+        else:
+            failed += 1
+
+    total = len(results)
+    score = round(passed / total * 100, 1) if total else 0.0
+    required_failed = [r for r in results if not r.passed and r.item.required]
+
+    report = {
+        "time": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "total": total, "passed": passed, "failed": failed,
+        "skipped": skipped, "score": score,
+        "pass_rate": f"{score}%",
+        "required_failed": len(required_failed),
+        "status": "PASS" if not required_failed else "FAIL",
+        "results": [r.to_dict() for r in results],
+    }
+
+    # 保存报告
+    REPORTS_DIR.mkdir(parents=True, exist_ok=True)
+    report_path = REPORTS_DIR / f"eval-{time.strftime('%Y%m%d-%H%M%S')}.json"
+    report_path.write_text(json.dumps(report, ensure_ascii=False, indent=2))
+
+    return CommandResult(success=not required_failed, data={
+        "report": report,
+        "report_path": str(report_path),
+        "message": (f"评测 {'✅ PASS' if not required_failed else '❌ FAIL'}: "
+                    f"{passed}/{total} 通过 ({score}%)"),
+    })
+
+
+# ── 内置评测套件 ────────────────────────────────
+
+def _suite_write_python_file() -> list[BehaviorItem]:
+    """B1: Agent 写 Python 文件 → 语法/文件/内容正确"""
+    return [
+        BehaviorItem("B1-001", "生成 app.py 文件", "write",
+                     "file_exists:app.py"),
+        BehaviorItem("B1-002", "app.py 语法正确", "write",
+                     "python_syntax:app.py"),
+        BehaviorItem("B1-003", "包含 Flask 应用", "write",
+                     "file_contains:app.py::Flask"),
+        BehaviorItem("B1-004", "包含路由定义", "write",
+                     "file_contains:app.py::@app.route"),
+        BehaviorItem("B1-005", "包含主入口", "write",
+                     "file_contains:app.py::__main__"),
+    ]
+
+
+def _suite_generate_config() -> list[BehaviorItem]:
+    """B2: Agent 生成 JSON 配置 → 合法/字段正确"""
+    return [
+        BehaviorItem("B2-001", "生成 config.json", "write",
+                     "file_exists:config.json"),
+        BehaviorItem("B2-002", "config.json 合法 JSON", "write",
+                     "json_valid:config.json"),
+        BehaviorItem("B2-003", "含 server 字段", "write",
+                     "file_contains:config.json::server"),
+        BehaviorItem("B2-004", "含 port 字段", "write",
+                     "file_contains:config.json::port"),
+    ]
+
+
+def _suite_git_operations() -> list[BehaviorItem]:
+    """B3: Agent 在 Git 仓库操作 → 仓库状态正确"""
+    return [
+        BehaviorItem("B3-001", "仓库存在", "git", "cmd:test -d .git"),
+        BehaviorItem("B3-002", "有提交记录", "git", "cmd:test -n \"$(git log --oneline -1 2>/dev/null)\""),  # noqa: E501
+        BehaviorItem("B3-003", "工作区无未提交变更", "git",
+                     "cmd:test -z \"$(git status --porcelain 2>/dev/null)\""),
+    ]
+
+
+def _suite_report_generation() -> list[BehaviorItem]:
+    """B4: Agent 生成 Markdown 报告 → 结构完整"""
+    return [
+        BehaviorItem("B4-001", "生成 report.md", "report",
+                     "file_exists:report.md"),
+        BehaviorItem("B4-002", "含标题", "report",
+                     "file_contains:report.md::#"),
+        BehaviorItem("B4-003", "含结论", "report",
+                     "file_contains:report.md::结论"),
+    ]
+
+
+BUILTIN_SUITES: dict[str, Callable[[], list[BehaviorItem]]] = {
+    "write-python": _suite_write_python_file,
+    "generate-config": _suite_generate_config,
+    "git-operations": _suite_git_operations,
+    "report-generation": _suite_report_generation,
+}
+
+
+def list_suites() -> CommandResult:
+    """列出评测套件"""
+    return CommandResult(success=True, data={
+        "suites": [
+            {"name": name, "items": len(fn()), "checks": [
+                i.check.split(":")[0] for i in fn()]}
+            for name, fn in BUILTIN_SUITES.items()
+        ],
+        "total": len(BUILTIN_SUITES),
+    })
+
+
+def run_suite(name: str, workdir: str = ".") -> CommandResult:
+    """运行指定评测套件"""
+    if name not in BUILTIN_SUITES:
+        return CommandResult(success=False, error=f"评测套件不存在: {name}")
+    items = BUILTIN_SUITES[name]()
+    return run_checklist(items, workdir=workdir)