xtc-app-knowledge-mcp 0.1.0__py3-none-any.whl

app_knowledge_mcp/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

app_knowledge_mcp/cli.py

@@ -0,0 +1,50 @@
+"""CLI 入口：app-knowledge-mcp init / enable / disable"""
+
+import argparse
+import sys
+from pathlib import Path
+
+from .installer import (
+    init_project,
+    enable_global,
+    disable_global,
+    log,
+)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="app-knowledge-mcp — 聚合 MCP 本地网关")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    init_p = sub.add_parser("init", help="为项目安装 MCP 能力")
+    init_p.add_argument("project_dir", nargs="?", default=".",
+                        help="业务仓库目录（默认当前目录）")
+    init_p.add_argument("--project", default=None,
+                        help="平台 project 标识（如 callwatch）")
+
+    sub.add_parser("enable", help="注册到全局 opencode config")
+    sub.add_parser("disable", help="从全局 opencode config 移除")
+
+    args = parser.parse_args()
+
+    if args.command == "init":
+        project_dir = Path(args.project_dir).resolve()
+        if not project_dir.is_dir():
+            log(f"目录不存在: {project_dir}", "ERROR")
+            return 1
+        init_project(project_dir, args.project)
+        return 0
+
+    if args.command == "enable":
+        enable_global()
+        return 0
+
+    if args.command == "disable":
+        disable_global()
+        return 0
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

app_knowledge_mcp/cloud_client.py

@@ -0,0 +1,387 @@
+import json
+import os
+import re
+from typing import Any
+
+import httpx
+
+CLOUD_MCP_URL = os.environ.get("CLOUD_MCP_URL", "http://172.28.4.103:18000/mcp")
+
+CLOUD_DOC_URL = os.environ.get("CLOUD_DOC_URL", "http://172.28.4.103:18001")
+
+CLOUD_SKILL_URL = os.environ.get("CLOUD_SKILL_URL", "http://172.28.4.103:18003")
+
+_HEADERS = {
+    "Accept": "application/json, text/event-stream",
+    "Content-Type": "application/json",
+}
+
+
+async def cloud_knowledge_search(
+    query: str,
+    knowledge_type: str = "",
+    platform: str = "",
+    domain: str = "",
+    project: str = "",
+    team: str = "",
+    scope: str = "",
+    status: str = "",
+    tags: list[str] | None = None,
+    files: list[str] | None = None,
+    top_k: int = 5,
+    exclude_doc_ids: list[str] | None = None,
+    client: httpx.AsyncClient | None = None,
+) -> dict[str, Any]:
+    """直连 retrieval:18001/search（平替 cloud MCP _knowledge_search）。"""
+    should_close = False
+    if client is None:
+        client = httpx.AsyncClient(timeout=10.0)
+        should_close = True
+    try:
+        r = await client.post(
+            f"{CLOUD_DOC_URL}/search",
+            json={
+                "query": query, "knowledge_type": knowledge_type, "platform": platform,
+                "domain": domain, "project": project, "team": team,
+                "scope": scope, "status": status, "tags": tags or [], "files": files or [],
+                "top_k": top_k, "exclude_doc_ids": exclude_doc_ids or [],
+            },
+        )
+        r.raise_for_status()
+        return r.json()
+    finally:
+        if should_close:
+            await client.aclose()
+
+
+async def cloud_skill_search(
+    query: str,
+    platform: str = "",
+    domain: str = "",
+    project: str = "",
+    task: str = "",
+    files: list[str] | None = None,
+    change_type: str = "",
+    when: str = "",
+    tags: list[str] | None = None,
+    top_k: int = 5,
+    client: httpx.AsyncClient | None = None,
+) -> dict[str, Any]:
+    """直连 skill:18003/search（平替 cloud MCP _skill_search）。"""
+    should_close = False
+    if client is None:
+        client = httpx.AsyncClient(timeout=10.0)
+        should_close = True
+    try:
+        r = await client.post(
+            f"{CLOUD_SKILL_URL}/search",
+            json={
+                "query": query, "platform": platform, "domain": domain,
+                "project": project, "task": task, "files": files or [],
+                "change_type": change_type, "when": when, "tags": tags or [], "top_k": top_k,
+            },
+        )
+        r.raise_for_status()
+        return r.json()
+    finally:
+        if should_close:
+            await client.aclose()
+
+def build_cloud_search_args(config: dict, query: str, top_k: int = 5, **overrides) -> dict:
+    """构建 cloud search 参数字典，profile 默认值 + LLM 显式覆盖。"""
+    user = config.get("user") or {}
+    profile = config.get("profile") or {}
+    repo = profile.get("repo") or {}
+    platforms = repo.get("platforms") or []
+    args = {
+        "query": query,
+        "_topic": query,
+        "_user_name": user.get("user_name", ""),
+        "_user_email": user.get("user_email", ""),
+        "platform": platforms[0] if platforms else "",
+        "domain": "",
+        "project": repo.get("project", ""),
+        "task": "",
+        "files": [],
+        "change_type": "",
+        "when": "on_request",
+        "knowledge_type": "",
+        "scope": "",
+        "status": "",
+        "tags": [],
+        "top_k": top_k,
+        "exclude_doc_ids": [],
+    }
+    args.update(overrides)
+    return args
+
+_INIT_PARAMS = {
+    "protocolVersion": "2024-11-05",
+    "capabilities": {},
+    "clientInfo": {"name": "app-knowledge-mcp", "version": "0.1.0"},
+}
+
+_MCP_ID = 0
+_initialize_done = False
+
+
+def _next_id() -> str:
+    global _MCP_ID
+    _MCP_ID += 1
+    return str(_MCP_ID)
+
+
+def _parse_sse(text: str) -> list[dict]:
+    events = []
+    for block in re.split(r"\n\n+", text.strip()):
+        data_match = re.search(r"^data:\s*(.+)$", block, re.MULTILINE)
+        if data_match:
+            try:
+                events.append(json.loads(data_match.group(1)))
+            except json.JSONDecodeError:
+                continue
+    return events
+
+
+def _parse_cloud_response(resp: httpx.Response) -> dict:
+    content_type = resp.headers.get("content-type", "")
+    if "text/event-stream" in content_type:
+        events = _parse_sse(resp.text)
+        data = events[0] if events else {}
+    else:
+        data = resp.json()
+
+    if "error" in data:
+        raise RuntimeError(f"Cloud MCP error: {data['error']}")
+
+    content = data.get("result", {}).get("content", [])
+    for item in content:
+        if item.get("type") == "text":
+            return json.loads(item["text"])
+    return data.get("result", {})
+
+
+async def _call_cloud(
+    name: str,
+    arguments: dict,
+    client: httpx.AsyncClient | None = None,
+) -> dict:
+    global _initialize_done
+    should_close = False
+    if client is None:
+        client = httpx.AsyncClient(timeout=15.0)
+        should_close = True
+
+    try:
+        payload = {
+            "jsonrpc": "2.0",
+            "method": "tools/call",
+            "params": {"name": name, "arguments": arguments},
+            "id": _next_id(),
+        }
+
+        if _initialize_done:
+            resp = await client.post(CLOUD_MCP_URL, headers=_HEADERS, json=payload)
+            if resp.status_code == 200:
+                return _parse_cloud_response(resp)
+
+        init_payload = {
+            "jsonrpc": "2.0",
+            "method": "initialize",
+            "params": _INIT_PARAMS,
+            "id": _next_id(),
+        }
+        init_resp = await client.post(CLOUD_MCP_URL, headers=_HEADERS, json=init_payload)
+        init_resp.raise_for_status()
+        _parse_sse(init_resp.text)
+        _initialize_done = True
+
+        resp = await client.post(CLOUD_MCP_URL, headers=_HEADERS, json=payload)
+        resp.raise_for_status()
+        return _parse_cloud_response(resp)
+    except Exception:
+        _initialize_done = False
+        raise
+    finally:
+        if should_close:
+            await client.aclose()
+
+
+async def cloud_search(
+    query: str,
+    _topic: str = "",
+    _user_name: str = "",
+    _user_email: str = "",
+    platform: str = "",
+    domain: str = "",
+    project: str = "",
+    task: str = "",
+    files: list[str] | None = None,
+    change_type: str = "",
+    when: str = "",
+    knowledge_type: str = "",
+    scope: str = "",
+    status: str = "",
+    tags: list[str] | None = None,
+    top_k: int = 5,
+    exclude_doc_ids: list[str] | None = None,
+    client: httpx.AsyncClient | None = None,
+) -> dict[str, Any]:
+    return await _call_cloud(
+        "search",
+        {
+            "query": query,
+            "_topic": _topic,
+            "_user_name": _user_name,
+            "_user_email": _user_email,
+            "platform": platform,
+            "domain": domain,
+            "project": project,
+            "task": task,
+            "files": files or [],
+            "change_type": change_type,
+            "when": when,
+            "knowledge_type": knowledge_type,
+            "scope": scope,
+            "status": status,
+            "tags": tags or [],
+            "top_k": top_k,
+            "exclude_doc_ids": exclude_doc_ids or [],
+        },
+        client=client,
+    )
+
+
+async def cloud_skill_get(
+    skill_id: str,
+    include_prompt: bool = False,
+    _topic: str = "",
+    _user_name: str = "",
+    _user_email: str = "",
+    client: httpx.AsyncClient | None = None,
+) -> dict[str, Any]:
+    return await _call_cloud(
+        "skill_get",
+        {
+            "skill_id": skill_id,
+            "include_prompt": include_prompt,
+            "_topic": _topic,
+            "_user_name": _user_name,
+            "_user_email": _user_email,
+        },
+        client=client,
+    )
+
+
+async def cloud_rule_check(
+    content: str,
+    rule_types: list[str] | None = None,
+    _topic: str = "",
+    _user_name: str = "",
+    _user_email: str = "",
+    client: httpx.AsyncClient | None = None,
+) -> dict[str, Any]:
+    return await _call_cloud(
+        "rule_check",
+        {
+            "content": content,
+            "rule_types": rule_types or [],
+            "_topic": _topic,
+            "_user_name": _user_name,
+            "_user_email": _user_email,
+        },
+        client=client,
+    )
+
+
+async def cloud_knowledge_sync(
+    repo_id: str,
+    profile: dict,
+    local_manifest: dict | None = None,
+    _topic: str = "",
+    _user_name: str = "",
+    _user_email: str = "",
+    client: httpx.AsyncClient | None = None,
+) -> dict[str, Any]:
+    return await _call_cloud(
+        "knowledge_sync",
+        {
+            "repo_id": repo_id,
+            "profile": profile,
+            "local_manifest": local_manifest or {},
+            "_topic": _topic,
+            "_user_name": _user_name,
+            "_user_email": _user_email,
+        },
+        client=client,
+    )
+
+
+async def cloud_knowledge_get(
+    doc_id: str,
+    canonical_path: str = "",
+    source_commit: str = "main",
+    _user_name: str = "",
+    _user_email: str = "",
+    _topic: str = "",
+    client: httpx.AsyncClient | None = None,
+) -> dict[str, Any]:
+    """获取云端知识文档全文（POST /doc 接口，直连 retrieval 服务）。"""
+    should_close = False
+    if client is None:
+        client = httpx.AsyncClient(timeout=15.0)
+        should_close = True
+
+    try:
+        body: dict[str, Any] = {"doc_id": doc_id}
+        if canonical_path:
+            body["canonical_path"] = canonical_path
+        if source_commit and source_commit != "main":
+            body["source_commit"] = source_commit
+        if _user_name:
+            body["_user_name"] = _user_name
+        if _user_email:
+            body["_user_email"] = _user_email
+        resp = await client.post(
+            f"{CLOUD_DOC_URL}/doc",
+            json=body,
+            headers={"Content-Type": "application/json"},
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        if data.get("error"):
+            raise ValueError(f"Document not found: {doc_id}")
+        return data
+    finally:
+        if should_close:
+            await client.aclose()
+
+
+async def cloud_skill_get_files(
+    skill_id: str,
+    client: httpx.AsyncClient | None = None,
+) -> dict[str, Any]:
+    """获取云端 Skill 的文件全文（POST /get-files 接口）。
+
+    Returns:
+        {"files": {"skill.md": {"content": "..."}}}, or {"files": {}, "error": "..."}
+    """
+    should_close = False
+    if client is None:
+        client = httpx.AsyncClient(timeout=15.0)
+        should_close = True
+
+    try:
+        resp = await client.post(
+            f"{CLOUD_SKILL_URL}/get-files",
+            json={"skill_id": skill_id},
+            headers={"Content-Type": "application/json"},
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        return data
+    except Exception as e:
+        return {"files": {}, "error": str(e)}
+    finally:
+        if should_close:
+            await client.aclose()

app_knowledge_mcp/frontmatter.py

@@ -0,0 +1,50 @@
+from typing import Any
+
+import yaml
+
+
+def parse_frontmatter(text: str) -> tuple[dict[str, Any], str]:
+    """解析 Markdown 文件的 YAML frontmatter。
+    
+    Args:
+        text: 文件原始内容。
+    
+    Returns:
+        (metadata, body) — metadata 为解析后的字典，body 为 frontmatter 之后的内容。
+        无 frontmatter 或解析失败时 metadata 为空字典，body 为原始文本。
+    """
+    if not text.startswith("---"):
+        return {}, text
+    
+    parts = text.split("---", 2)
+    if len(parts) < 3:
+        return {}, text
+    
+    raw_yaml = parts[1].strip()
+    try:
+        meta = yaml.safe_load(raw_yaml) or {}
+    except Exception:
+        meta = {}
+    
+    if not isinstance(meta, dict):
+        meta = {}
+    
+    return meta, parts[2].strip()
+
+
+def extract_title(meta: dict[str, Any], file_path: str) -> str:
+    """从 frontmatter 中提取标题，回退到文件名。"""
+    for key in ("name", "title", "id"):
+        val = meta.get(key)
+        if val and isinstance(val, str):
+            return val
+    return file_path.rsplit("/", 1)[-1].rsplit(".", 1)[0]
+
+
+def extract_description(meta: dict[str, Any], body: str, max_len: int = 160) -> str:
+    """从 frontmatter 或正文提取描述。"""
+    desc = meta.get("description", "")
+    if desc and isinstance(desc, str):
+        return desc[:max_len]
+    first_line = body.split("\n", 1)[0].strip().strip("#").strip()
+    return first_line[:max_len] if first_line else ""