@baimingtao/lbs-agent 1.0.0

package/scripts/check_llm_layer.py

@@ -0,0 +1,16 @@
+"""Offline LLM layer architecture check."""
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from config.config import load_config
+from interfaces.cli._impl.main import cmd_llm_inspect, cmd_llm_validate, cmd_llm_diagnostics
+
+if __name__ == "__main__":
+    config = load_config()
+    cmd_llm_inspect(config)
+    cmd_llm_validate(config)
+    cmd_llm_diagnostics(config)

package/scripts/check_orchestration_layer.py

@@ -0,0 +1,15 @@
+"""Offline orchestration layer architecture check."""
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from config.config import load_config
+from interfaces.cli._impl.main import cmd_orchestrator_inspect, cmd_llm_validate
+
+if __name__ == "__main__":
+    config = load_config()
+    cmd_orchestrator_inspect(config)
+    cmd_llm_validate(config)

package/scripts/clean-pycache.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+/**
+ * publish 前自动清理 __pycache__ 和 .pyc 文件
+ * npm package.json files 白名单模式下 .npmignore 对子目录 pycache 不可靠
+ * 这个脚本在 prepublishOnly / prepack 钩子触发，确保包干净
+ */
+const fs = require('fs');
+const path = require('path');
+
+const root = path.resolve(__dirname, '..');
+let removed = { dirs: 0, files: 0 };
+
+function walk(dir) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === '__pycache__' || entry.name === '.pytest_cache') {
+        rmrf(full);
+        removed.dirs++;
+      } else if (entry.name !== '.git' && entry.name !== 'node_modules') {
+        walk(full);
+      }
+    } else if (entry.isFile()) {
+      if (entry.name.endsWith('.pyc') || entry.name.endsWith('.pyo')) {
+        try { fs.unlinkSync(full); removed.files++; } catch {}
+      }
+    }
+  }
+}
+
+function rmrf(dir) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      rmrf(full);
+    } else {
+      try { fs.unlinkSync(full); } catch {}
+    }
+  }
+  try { fs.rmdirSync(dir); } catch {}
+}
+
+walk(root);
+console.log(`[clean-pycache] 删除 ${removed.dirs} 个缓存目录, ${removed.files} 个 .pyc 文件`);

package/scripts/init.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+/**
+ * LBS Agent 初始化脚本 — 跨平台 (Windows / macOS / Linux)
+ *
+ * 功能:
+ * 1. 检测系统 Python (3.10+)
+ * 2. 创建虚拟环境 venv/
+ * 3. 安装 requirements.txt 依赖
+ * 4. 创建 .lbs-initialized 标记文件
+ *
+ * 用法:
+ *   node scripts/init.js          # 正常初始化
+ *   LBS_PKG_ROOT=/path node scripts/init.js  # 指定项目根目录
+ */
+
+const { spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const PKG_ROOT = process.env.LBS_PKG_ROOT || path.resolve(__dirname, '..');
+const VENV_DIR = path.join(PKG_ROOT, 'venv');
+const INIT_FLAG = path.join(PKG_ROOT, '.lbs-initialized');
+const REQUIREMENTS = path.join(PKG_ROOT, 'requirements.txt');
+
+const isWin = process.platform === 'win32';
+const PYTHON = isWin ? path.join(VENV_DIR, 'Scripts', 'python.exe') : path.join(VENV_DIR, 'bin', 'python');
+const PIP = isWin ? path.join(VENV_DIR, 'Scripts', 'pip.exe') : path.join(VENV_DIR, 'bin', 'pip');
+
+function log(msg) { console.log(msg); }
+function err(msg) { console.error(msg); }
+
+function run(cmd, args, opts = {}) {
+  const result = spawnSync(cmd, args, {
+    stdio: opts.silent ? 'pipe' : 'inherit',
+    encoding: 'utf-8',
+    shell: isWin,
+    ...opts,
+  });
+  return result;
+}
+
+// ── Step 1: 检测系统 Python ──────────────────────────
+
+function findSystemPython() {
+  log('🔍 检测系统 Python...');
+
+  const candidates = isWin
+    ? ['python', 'python3', 'py -3']
+    : ['python3', 'python'];
+
+  for (const cmd of candidates) {
+    const result = run(cmd, ['--version'], { silent: true, shell: isWin });
+    if (result.status === 0) {
+      const version = (result.stdout || result.stderr || '').trim();
+      log(`  ✓ ${cmd}: ${version}`);
+
+      // 检查版本 >= 3.10
+      const match = version.match(/(\d+)\.(\d+)/);
+      if (match) {
+        const major = parseInt(match[1]);
+        const minor = parseInt(match[2]);
+        if (major >= 3 && minor >= 10) {
+          return cmd;
+        }
+      }
+      log(`  ⚠ 版本低于 3.10，继续寻找...`);
+    }
+  }
+
+  err('\n❌ 未找到 Python 3.10+');
+  err('   请安装 Python:');
+  err('   Windows: https://www.python.org/downloads/');
+  err('   macOS:   brew install python@3.12');
+  err('   Linux:   sudo apt install python3 python3-venv');
+  return null;
+}
+
+// ── Step 2: 创建虚拟环境 ─────────────────────────────
+
+function createVenv(sysPython) {
+  if (fs.existsSync(PYTHON)) {
+    log('✓ 虚拟环境已存在，跳过创建');
+    return true;
+  }
+
+  log('📦 创建 Python 虚拟环境...');
+  const result = run(sysPython, ['-m', 'venv', VENV_DIR]);
+  if (result.status !== 0 || !fs.existsSync(PYTHON)) {
+    err('❌ 创建虚拟环境失败');
+    return false;
+  }
+  log('  ✓ venv/ 已创建');
+  return true;
+}
+
+// ── Step 3: 安装依赖 ─────────────────────────────────
+
+function installDeps() {
+  if (!fs.existsSync(REQUIREMENTS)) {
+    err('❌ requirements.txt 不存在: ' + REQUIREMENTS);
+    return false;
+  }
+
+  log('📥 安装 Python 依赖 (可能需要 1-2 分钟)...');
+  const pipCmd = isWin ? PIP : PIP;
+  const result = run(pipCmd, ['install', '-r', REQUIREMENTS, '--disable-pip-version-check']);
+  if (result.status !== 0) {
+    err('❌ 依赖安装失败');
+    return false;
+  }
+  log('  ✓ 依赖安装完成');
+  return true;
+}
+
+// ── Step 4: 验证 ─────────────────────────────────────
+
+function verifyInstall() {
+  log('🔍 验证安装...');
+  const result = run(PYTHON, [path.join(PKG_ROOT, 'lbs.py'), 'status'], {
+    silent: true,
+    cwd: PKG_ROOT,
+  });
+  if (result.status === 0) {
+    log('  ✓ lbs status 运行正常');
+    return true;
+  }
+  err('  ⚠ lbs status 运行异常（可能是配置问题，不影响初始化）');
+  return true; // 不阻断
+}
+
+// ── Step 5: 写入标记 ─────────────────────────────────
+
+function writeFlag() {
+  fs.writeFileSync(INIT_FLAG, JSON.stringify({
+    initialized_at: new Date().toISOString(),
+    platform: os.platform(),
+    node_version: process.version,
+  }, null, 2));
+  log('  ✓ .lbs-initialized 已创建');
+}
+
+// ── 主流程 ───────────────────────────────────────────
+
+function main() {
+  console.log(`
+╔══════════════════════════════════════════════╗
+║   LBS Agent — 初始化                        ║
+║   Leaving Blank Space Agent                  ║
+╚══════════════════════════════════════════════╝
+`);
+
+  // Step 1: Python
+  const sysPython = findSystemPython();
+  if (!sysPython) process.exit(1);
+
+  // Step 2: venv
+  if (!createVenv(sysPython)) process.exit(1);
+
+  // Step 3: deps
+  if (!installDeps()) process.exit(1);
+
+  // Step 4: verify
+  verifyInstall();
+
+  // Step 5: flag
+  writeFlag();
+
+  console.log(`
+╔══════════════════════════════════════════════╗
+║   ✅ 初始化完成！                             ║
+║                                              ║
+║   使用方法:                                  ║
+║   lbs status          查看系统状态           ║
+║   lbs models          查看模型列表           ║
+║   lbs help            查看所有命令           ║
+║                                              ║
+║   启动 Web 端:                               ║
+║   lbs web             打开浏览器界面         ║
+║                                              ║
+║   如果 lbs 命令不可用，手动运行:              ║
+║   node bin/lbs.js status                     ║
+╚══════════════════════════════════════════════╝
+`);
+}
+
+main();

package/tools/__init__.py

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

package/tools/mcp/clients/__init__.py

@@ -0,0 +1,368 @@
+"""
+MCP Client — 真实 JSON-RPC over stdio 协议接入。
+
+支持：
+  1. stdio 传输：启动子进程，通过 stdin/stdout 交换 JSON-RPC 消息
+  2. tools/list：发现 MCP server 暴露的工具
+  3. tools/call：调用 MCP server 的工具
+  4. 注册表管理：注册/注销/查询 MCP server
+
+MCP 协议核心消息：
+  → {"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {...}}
+  ← {"jsonrpc": "2.0", "id": 1, "result": {"protocolVersion": "...", ...}}
+  → {"jsonrpc": "2.0", "method": "notifications/initialized"}
+  → {"jsonrpc": "2.0", "id": 2, "method": "tools/list"}
+  ← {"jsonrpc": "2.0", "id": 2, "result": {"tools": [...]}}
+  → {"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "...", "arguments": {...}}}
+  ← {"jsonrpc": "2.0", "id": 3, "result": {"content": [...]}}
+
+兼容：保留 MCPServerConfig / MCPToolSpec / MCPClientRegistry 向后兼容。
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import subprocess
+import threading
+import time
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class MCPServerConfig:
+    """一个 MCP server 的配置。"""
+    name: str
+    transport: str = "stdio"  # stdio | http | sse
+    command: str = ""         # stdio 模式的启动命令
+    args: list[str] = field(default_factory=list)
+    url: str = ""             # http/sse 模式的 endpoint
+    env: dict[str, str] = field(default_factory=dict)
+    enabled: bool = True
+
+
+@dataclass
+class MCPToolSpec:
+    """从 MCP server 发现的工具定义。"""
+    name: str
+    description: str = ""
+    input_schema: dict[str, Any] = field(default_factory=dict)
+    server_name: str = ""
+
+
+class MCPStdioClient:
+    """通过 stdio JSON-RPC 连接 MCP server 的客户端。
+
+    启动子进程 → 发送 JSON-RPC 消息 → 接收响应。
+    线程安全（每次请求用唯一的 id + 锁）。
+    """
+
+    def __init__(self, config: MCPServerConfig):
+        self.config = config
+        self._process: Optional[subprocess.Popen] = None
+        self._lock = threading.Lock()
+        self._request_id = 0
+        self._initialized = False
+
+    def connect(self) -> bool:
+        """启动 MCP server 子进程并完成握手。"""
+        if not self.config.command:
+            logger.error("[mcp] no command for server %s", self.config.name)
+            return False
+
+        try:
+            env = {**os.environ, **self.config.env}
+            self._process = subprocess.Popen(
+                [self.config.command] + self.config.args,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                env=env,
+                text=True,
+                bufsize=1,
+                encoding="utf-8",
+                errors="replace",
+            )
+            logger.info("[mcp] server %s started (pid=%s)", self.config.name, self._process.pid)
+
+            # 发送 initialize
+            resp = self._send_request("initialize", {
+                "protocolVersion": "2024-11-05",
+                "capabilities": {},
+                "clientInfo": {"name": "lbs-agent", "version": "1.0"},
+            })
+
+            if resp and "result" in resp:
+                # 发送 initialized 通知
+                self._send_notification("notifications/initialized")
+                self._initialized = True
+                logger.info("[mcp] server %s initialized", self.config.name)
+                return True
+            else:
+                logger.error("[mcp] server %s initialize failed: %s", self.config.name, resp)
+                return False
+
+        except Exception as e:
+            logger.error("[mcp] failed to start server %s: %s", self.config.name, e)
+            return False
+
+    def list_tools(self) -> list[MCPToolSpec]:
+        """发现 server 暴露的工具。"""
+        if not self._initialized:
+            return []
+
+        resp = self._send_request("tools/list", {})
+        if not resp or "result" not in resp:
+            return []
+
+        tools = []
+        for tool in resp["result"].get("tools", []):
+            tools.append(MCPToolSpec(
+                name=tool.get("name", ""),
+                description=tool.get("description", ""),
+                input_schema=tool.get("inputSchema", {}),
+                server_name=self.config.name,
+            ))
+        return tools
+
+    def call_tool(self, name: str, arguments: dict[str, Any]) -> str:
+        """调用 MCP server 的工具。"""
+        if not self._initialized:
+            return "ERROR: MCP server not initialized"
+
+        resp = self._send_request("tools/call", {"name": name, "arguments": arguments})
+        if not resp:
+            return "ERROR: No response from MCP server"
+
+        if "error" in resp:
+            return f"ERROR: {resp['error'].get('message', 'unknown')}"
+
+        result = resp.get("result", {})
+        content_parts = result.get("content", [])
+        text_parts = []
+        for part in content_parts:
+            if isinstance(part, dict) and part.get("type") == "text":
+                text_parts.append(part.get("text", ""))
+        return "\n".join(text_parts) if text_parts else json.dumps(result, ensure_ascii=False)
+
+    def close(self):
+        """关闭连接。"""
+        if self._process:
+            try:
+                self._process.terminate()
+                self._process.wait(timeout=5)
+            except Exception:
+                try:
+                    self._process.kill()
+                except Exception:
+                    pass
+            self._process = None
+        self._initialized = False
+
+    # ── JSON-RPC 内部 ────────────────────────────────
+
+    def _send_request(self, method: str, params: dict) -> dict | None:
+        """发送 JSON-RPC 请求并等待响应。"""
+        with self._lock:
+            self._request_id += 1
+            req_id = self._request_id
+
+            msg = {
+                "jsonrpc": "2.0",
+                "id": req_id,
+                "method": method,
+                "params": params,
+            }
+
+            try:
+                self._write_message(msg)
+                resp = self._read_message(timeout=30)
+                if resp and resp.get("id") == req_id:
+                    return resp
+                logger.warning("[mcp] response id mismatch: expected %s, got %s", req_id, resp.get("id") if resp else None)
+                return resp
+            except Exception as e:
+                logger.error("[mcp] request %s failed: %s", method, e)
+                return None
+
+    def _send_notification(self, method: str, params: dict = None):
+        """发送 JSON-RPC 通知（无 id，不等待响应）。"""
+        msg = {
+            "jsonrpc": "2.0",
+            "method": method,
+        }
+        if params:
+            msg["params"] = params
+        try:
+            self._write_message(msg)
+        except Exception as e:
+            logger.error("[mcp] notification %s failed: %s", method, e)
+
+    def _write_message(self, msg: dict):
+        """向子进程 stdin 写入 JSON-RPC 消息（Content-Length 格式）。"""
+        if not self._process or not self._process.stdin:
+            raise RuntimeError("Process not started")
+        data = json.dumps(msg, ensure_ascii=False)
+        # MCP 使用行分隔 JSON（非 Content-Length），和 LSP 不同
+        self._process.stdin.write(data + "\n")
+        self._process.stdin.flush()
+
+    def _read_message(self, timeout: float = 30) -> dict | None:
+        """从子进程 stdout 读取 JSON-RPC 响应。"""
+        if not self._process or not self._process.stdout:
+            return None
+
+        # 简单实现：读一行，解析 JSON
+        # 跳过非 JSON 行（如日志输出）
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            line = self._process.stdout.readline()
+            if not line:
+                time.sleep(0.1)
+                continue
+            line = line.strip()
+            if not line:
+                continue
+            # 尝试解析 JSON
+            try:
+                msg = json.loads(line)
+                if isinstance(msg, dict) and "jsonrpc" in msg:
+                    return msg
+            except json.JSONDecodeError:
+                # 可能是日志行，跳过
+                continue
+
+        return None
+
+
+# ── 向后兼容的注册表 ────────────────────────────────
+
+class MCPClientRegistry:
+    """MCP server 注册表 + 连接管理。"""
+
+    def __init__(self):
+        self._servers: dict[str, MCPServerConfig] = {}
+        self._clients: dict[str, MCPStdioClient] = {}  # 活跃连接
+        self._tools_cache: dict[str, list[MCPToolSpec]] = {}
+
+    def register(self, config: MCPServerConfig):
+        self._servers[config.name] = config
+        logger.info("MCP server registered: %s (%s)", config.name, config.transport)
+
+    def unregister(self, name: str):
+        self.disconnect(name)
+        self._servers.pop(name, None)
+        self._tools_cache.pop(name, None)
+
+    def get(self, name: str) -> Optional[MCPServerConfig]:
+        return self._servers.get(name)
+
+    def list_servers(self) -> list[MCPServerConfig]:
+        return [s for s in self._servers.values() if s.enabled]
+
+    def connect_server(self, name: str) -> bool:
+        """连接到 MCP server。"""
+        config = self._servers.get(name)
+        if not config:
+            logger.error("[mcp] server %s not found", name)
+            return False
+
+        client = MCPStdioClient(config)
+        if client.connect():
+            self._clients[name] = client
+            # 发现工具并缓存
+            tools = client.list_tools()
+            self._tools_cache[name] = tools
+            logger.info("[mcp] server %s connected, %d tools discovered", name, len(tools))
+            return True
+        return False
+
+    def disconnect(self, name: str):
+        client = self._clients.pop(name, None)
+        if client:
+            client.close()
+            logger.info("[mcp] server %s disconnected", name)
+
+    def disconnect_all(self):
+        for name in list(self._clients.keys()):
+            self.disconnect(name)
+
+    def discover_tools(self, server_name: str = "") -> list[MCPToolSpec]:
+        """发现 MCP server 暴露的工具。"""
+        if server_name:
+            # 如果已连接，实时发现
+            if server_name in self._clients:
+                return self._clients[server_name].list_tools()
+            return self._tools_cache.get(server_name, [])
+        all_tools = []
+        for tools in self._tools_cache.values():
+            all_tools.extend(tools)
+        return all_tools
+
+    def call_tool(self, server_name: str, tool_name: str, arguments: dict) -> str:
+        """调用 MCP server 的工具。"""
+        client = self._clients.get(server_name)
+        if not client:
+            return f"ERROR: MCP server {server_name} not connected"
+        return client.call_tool(tool_name, arguments)
+
+    def cache_tools(self, server_name: str, tools: list[MCPToolSpec]):
+        self._tools_cache[server_name] = tools
+
+    def status(self) -> dict[str, Any]:
+        return {
+            "total_servers": len(self._servers),
+            "connected": len(self._clients),
+            "servers": [
+                {
+                    "name": s.name,
+                    "transport": s.transport,
+                    "enabled": s.enabled,
+                    "connected": s.name in self._clients,
+                    "tools": len(self._tools_cache.get(s.name, [])),
+                }
+                for s in self._servers.values()
+            ],
+        }
+
+
+# 全局单例
+_registry = MCPClientRegistry()
+
+
+def get_mcp_registry() -> MCPClientRegistry:
+    return _registry
+
+
+def load_mcp_config(config_path: str = "") -> MCPClientRegistry:
+    """从 YAML 加载 MCP server 配置。"""
+    import os as _os
+    if not config_path:
+        config_path = _os.path.join(_os.path.dirname(_os.path.dirname(__file__)), "..", "mcp.yaml")
+
+    if not _os.path.exists(config_path):
+        return _registry
+
+    try:
+        import yaml
+        with open(config_path, "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f) or {}
+
+        for name, cfg in (data.get("servers") or {}).items():
+            _registry.register(MCPServerConfig(
+                name=name,
+                transport=cfg.get("transport", "stdio"),
+                command=cfg.get("command", ""),
+                args=cfg.get("args", []),
+                url=cfg.get("url", ""),
+                env=cfg.get("env", {}),
+                enabled=cfg.get("enabled", True),
+            ))
+    except Exception as e:
+        logger.error("Failed to load MCP config: %s", e)
+
+    return _registry