@weapp-vite/mcp 1.0.1 → 1.1.1

package/README.md

@@ -2,42 +2,75 @@
 
 ## 简介
 
-`@weapp-vite/mcp` 是一个基于 Model Context Protocol (MCP) SDK 的示例服务包，展示如何通过 stdio 传输方式注册工具并响应调用。
+`@weapp-vite/mcp` 是面向 `weapp-vite` / `wevu` monorepo 的 MCP 服务端实现，目标是把核心研发能力暴露给 AI：
 
-> 该包目前以示例为主，适合用于学习/验证 MCP 工具服务的基本结构。
+- 包目录与能力发现
+- 源码读取、检索、按行裁剪
+- 包级脚本执行
+- `weapp-vite` CLI 执行
+- 文档/变更记录资源暴露
+- 调试/改造提示词模板
 
-## 特性
+默认通过 `stdio` 运行，适合接入任意 MCP Client，也支持 `streamable-http`。
 
-- 使用 MCP SDK 创建服务
-- 基于 zod 的入参校验
-- 内置示例工具（`calculate-bmi`、`fetch-weather`）
-- stdio 传输，方便被 MCP Client 集成
-
-## 安装
+## 启动
 
 ```bash
-pnpm add @weapp-vite/mcp
+pnpm --filter @weapp-vite/mcp start
 ```
 
-## 使用
+也可以在 Node 脚本里直接调用：
 
-在仓库内启动示例服务：
+```ts
+import { startWeappViteMcpServer } from '@weapp-vite/mcp'
 
-```bash
-pnpm --filter @weapp-vite/mcp start
+const handle = await startWeappViteMcpServer({
+  workspaceRoot: process.cwd(),
+  transport: 'streamable-http',
+  host: '127.0.0.1',
+  port: 3088,
+  endpoint: '/mcp',
+})
+
+await handle.close?.()
 ```
 
-然后由 MCP Client 通过 stdio 连接并调用工具。
+## 主要 Tools
+
+- `workspace_catalog`: 输出 `weapp-vite / wevu / wevu-compiler` 目录、版本、脚本
+- `list_source_files`: 列出包内文件（默认 `src`）
+- `read_source_file`: 读取包内文件，支持 `startLine/endLine/maxChars`
+- `search_source_code`: 在包源码中检索关键词
+- `run_package_script`: 在指定包目录执行 `pnpm run <script>`
+- `run_weapp_vite_cli`: 执行 `node packages/weapp-vite/bin/weapp-vite.js ...`
+- `run_repo_command`: 执行仓库级命令（`pnpm/node/git/rg`）
+
+## 主要 Resources
 
-## 配置
+- `weapp-vite://workspace/catalog`
+- `weapp-vite://docs/{package}/README.md`
+- `weapp-vite://docs/{package}/CHANGELOG.md`
+- `weapp-vite://source/{package}?path={path}`
 
-目前没有独立配置文件。请直接修改 `src/index.ts` 来：
+其中 `{package}` 支持：
 
-- 添加/移除工具
-- 调整工具参数与逻辑
-- 修改服务名称与版本
+- `weapp-vite`
+- `wevu`
+- `wevu-compiler`
+
+## Prompts
+
+- `plan-weapp-vite-change`: 生成 weapp-vite/wevu 改造计划提示词
+- `debug-wevu-runtime`: 生成 wevu runtime 排查提示词
+
+## 开发
+
+```bash
+pnpm --filter @weapp-vite/mcp test
+pnpm --filter @weapp-vite/mcp build
+```
 
 ## 相关链接
 
-- MCP SDK：https://github.com/modelcontextprotocol/sdk
-- 仓库：https://github.com/weapp-vite/weapp-vite
+- MCP SDK: https://github.com/modelcontextprotocol/sdk
+- 仓库: https://github.com/weapp-vite/weapp-vite

package/dist/index.d.mts

@@ -1,2 +1,131 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 
-export { };
+declare const MCP_SERVER_NAME = "@weapp-vite/mcp";
+declare const MCP_SERVER_VERSION = "2.0.0";
+declare const EXPOSED_PACKAGES: {
+    readonly 'weapp-vite': {
+        readonly id: "weapp-vite";
+        readonly label: "weapp-vite";
+        readonly relativePath: string;
+    };
+    readonly wevu: {
+        readonly id: "wevu";
+        readonly label: "wevu";
+        readonly relativePath: string;
+    };
+    readonly 'wevu-compiler': {
+        readonly id: "wevu-compiler";
+        readonly label: "wevu-compiler";
+        readonly relativePath: string;
+    };
+};
+type ExposedPackageId = keyof typeof EXPOSED_PACKAGES;
+declare const DEFAULT_TIMEOUT_MS = 120000;
+declare const DEFAULT_MAX_OUTPUT_CHARS = 120000;
+declare const DEFAULT_MAX_FILE_CHARS = 80000;
+declare const DEFAULT_MAX_RESULTS = 200;
+declare const SKIPPED_DIR_NAMES: Set<string>;
+
+interface ExposedPackageSummary {
+    id: ExposedPackageId;
+    label: string;
+    packageName: string;
+    version: string;
+    absolutePath: string;
+    relativePath: string;
+    scripts: string[];
+    docs: {
+        readme?: string;
+        changelog?: string;
+    };
+}
+declare function loadPackageSummary(workspaceRoot: string, id: ExposedPackageId): Promise<ExposedPackageSummary>;
+declare function loadExposedCatalog(workspaceRoot: string): Promise<ExposedPackageSummary[]>;
+
+interface CommandResult {
+    command: string;
+    args: string[];
+    cwd: string;
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+}
+declare function runCommand(workspaceRoot: string, command: string, args: string[], options?: {
+    cwdRelative?: string;
+    timeoutMs?: number;
+    maxOutputChars?: number;
+}): Promise<CommandResult>;
+
+interface SearchMatch {
+    filePath: string;
+    line: number;
+    column: number;
+    text: string;
+}
+declare function listFilesInDirectory(root: string, relativeDirectory?: string, maxResults?: number): Promise<string[]>;
+declare function readFileContent(root: string, relativeFilePath: string, options?: {
+    startLine?: number;
+    endLine?: number;
+    maxChars?: number;
+}): Promise<{
+    filePath: string;
+    content: string;
+}>;
+declare function searchTextInDirectory(root: string, query: string, options?: {
+    relativeDirectory?: string;
+    maxResults?: number;
+}): Promise<SearchMatch[]>;
+
+interface CreateServerOptions {
+    workspaceRoot?: string;
+}
+declare function createWeappViteMcpServer(options?: CreateServerOptions): Promise<{
+    server: McpServer;
+    workspaceRoot: string;
+}>;
+
+declare const DEFAULT_MCP_HOST = "127.0.0.1";
+declare const DEFAULT_MCP_PORT = 3088;
+declare const DEFAULT_MCP_ENDPOINT = "/mcp";
+interface StartMcpServerOptions extends CreateServerOptions {
+    transport?: 'stdio' | 'streamable-http';
+    host?: string;
+    port?: number;
+    endpoint?: string;
+    unref?: boolean;
+    quiet?: boolean;
+    onReady?: (message: string) => void;
+}
+interface McpServerHandle {
+    transport: 'stdio' | 'streamable-http';
+    close?: () => Promise<void>;
+}
+declare function startStdioServer(options?: CreateServerOptions): Promise<void>;
+declare function startWeappViteMcpServer(options?: StartMcpServerOptions): Promise<McpServerHandle>;
+
+declare function formatJson(value: unknown): string;
+declare function normalizeErrorMessage(error: unknown): string;
+declare function toToolResult(data: unknown, text?: string): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: {
+        result: unknown;
+    };
+};
+declare function toToolError(error: unknown): {
+    isError: boolean;
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};
+
+declare function resolveWorkspaceRoot(start?: string): string;
+declare function assertInsideRoot(root: string, targetPath: string): string;
+declare function resolveSubPath(root: string, relativePath: string): string;
+
+export { DEFAULT_MAX_FILE_CHARS, DEFAULT_MAX_OUTPUT_CHARS, DEFAULT_MAX_RESULTS, DEFAULT_MCP_ENDPOINT, DEFAULT_MCP_HOST, DEFAULT_MCP_PORT, DEFAULT_TIMEOUT_MS, EXPOSED_PACKAGES, MCP_SERVER_NAME, MCP_SERVER_VERSION, SKIPPED_DIR_NAMES, assertInsideRoot, createWeappViteMcpServer, formatJson, listFilesInDirectory, loadExposedCatalog, loadPackageSummary, normalizeErrorMessage, readFileContent, resolveSubPath, resolveWorkspaceRoot, runCommand, searchTextInDirectory, startStdioServer, startWeappViteMcpServer, toToolError, toToolResult };
+export type { CommandResult, CreateServerOptions, ExposedPackageId, ExposedPackageSummary, McpServerHandle, SearchMatch, StartMcpServerOptions };

package/dist/index.d.ts

@@ -1,2 +1,131 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 
-export { };
+declare const MCP_SERVER_NAME = "@weapp-vite/mcp";
+declare const MCP_SERVER_VERSION = "2.0.0";
+declare const EXPOSED_PACKAGES: {
+    readonly 'weapp-vite': {
+        readonly id: "weapp-vite";
+        readonly label: "weapp-vite";
+        readonly relativePath: string;
+    };
+    readonly wevu: {
+        readonly id: "wevu";
+        readonly label: "wevu";
+        readonly relativePath: string;
+    };
+    readonly 'wevu-compiler': {
+        readonly id: "wevu-compiler";
+        readonly label: "wevu-compiler";
+        readonly relativePath: string;
+    };
+};
+type ExposedPackageId = keyof typeof EXPOSED_PACKAGES;
+declare const DEFAULT_TIMEOUT_MS = 120000;
+declare const DEFAULT_MAX_OUTPUT_CHARS = 120000;
+declare const DEFAULT_MAX_FILE_CHARS = 80000;
+declare const DEFAULT_MAX_RESULTS = 200;
+declare const SKIPPED_DIR_NAMES: Set<string>;
+
+interface ExposedPackageSummary {
+    id: ExposedPackageId;
+    label: string;
+    packageName: string;
+    version: string;
+    absolutePath: string;
+    relativePath: string;
+    scripts: string[];
+    docs: {
+        readme?: string;
+        changelog?: string;
+    };
+}
+declare function loadPackageSummary(workspaceRoot: string, id: ExposedPackageId): Promise<ExposedPackageSummary>;
+declare function loadExposedCatalog(workspaceRoot: string): Promise<ExposedPackageSummary[]>;
+
+interface CommandResult {
+    command: string;
+    args: string[];
+    cwd: string;
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+}
+declare function runCommand(workspaceRoot: string, command: string, args: string[], options?: {
+    cwdRelative?: string;
+    timeoutMs?: number;
+    maxOutputChars?: number;
+}): Promise<CommandResult>;
+
+interface SearchMatch {
+    filePath: string;
+    line: number;
+    column: number;
+    text: string;
+}
+declare function listFilesInDirectory(root: string, relativeDirectory?: string, maxResults?: number): Promise<string[]>;
+declare function readFileContent(root: string, relativeFilePath: string, options?: {
+    startLine?: number;
+    endLine?: number;
+    maxChars?: number;
+}): Promise<{
+    filePath: string;
+    content: string;
+}>;
+declare function searchTextInDirectory(root: string, query: string, options?: {
+    relativeDirectory?: string;
+    maxResults?: number;
+}): Promise<SearchMatch[]>;
+
+interface CreateServerOptions {
+    workspaceRoot?: string;
+}
+declare function createWeappViteMcpServer(options?: CreateServerOptions): Promise<{
+    server: McpServer;
+    workspaceRoot: string;
+}>;
+
+declare const DEFAULT_MCP_HOST = "127.0.0.1";
+declare const DEFAULT_MCP_PORT = 3088;
+declare const DEFAULT_MCP_ENDPOINT = "/mcp";
+interface StartMcpServerOptions extends CreateServerOptions {
+    transport?: 'stdio' | 'streamable-http';
+    host?: string;
+    port?: number;
+    endpoint?: string;
+    unref?: boolean;
+    quiet?: boolean;
+    onReady?: (message: string) => void;
+}
+interface McpServerHandle {
+    transport: 'stdio' | 'streamable-http';
+    close?: () => Promise<void>;
+}
+declare function startStdioServer(options?: CreateServerOptions): Promise<void>;
+declare function startWeappViteMcpServer(options?: StartMcpServerOptions): Promise<McpServerHandle>;
+
+declare function formatJson(value: unknown): string;
+declare function normalizeErrorMessage(error: unknown): string;
+declare function toToolResult(data: unknown, text?: string): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: {
+        result: unknown;
+    };
+};
+declare function toToolError(error: unknown): {
+    isError: boolean;
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};
+
+declare function resolveWorkspaceRoot(start?: string): string;
+declare function assertInsideRoot(root: string, targetPath: string): string;
+declare function resolveSubPath(root: string, relativePath: string): string;
+
+export { DEFAULT_MAX_FILE_CHARS, DEFAULT_MAX_OUTPUT_CHARS, DEFAULT_MAX_RESULTS, DEFAULT_MCP_ENDPOINT, DEFAULT_MCP_HOST, DEFAULT_MCP_PORT, DEFAULT_TIMEOUT_MS, EXPOSED_PACKAGES, MCP_SERVER_NAME, MCP_SERVER_VERSION, SKIPPED_DIR_NAMES, assertInsideRoot, createWeappViteMcpServer, formatJson, listFilesInDirectory, loadExposedCatalog, loadPackageSummary, normalizeErrorMessage, readFileContent, resolveSubPath, resolveWorkspaceRoot, runCommand, searchTextInDirectory, startStdioServer, startWeappViteMcpServer, toToolError, toToolResult };
+export type { CommandResult, CreateServerOptions, ExposedPackageId, ExposedPackageSummary, McpServerHandle, SearchMatch, StartMcpServerOptions };

package/dist/index.mjs

@@ -1,37 +1,818 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import fs$1 from 'node:fs/promises';
+import path from 'node:path';
+import fs from 'node:fs';
+import { spawn } from 'node:child_process';
+import { Buffer } from 'node:buffer';
+import http from 'node:http';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 
-const server = new McpServer({
-  name: "Demo",
-  version: "1.0.0"
-});
-server.tool(
-  "calculate-bmi",
-  {
-    weightKg: z.number(),
-    heightM: z.number()
+const MCP_SERVER_NAME = "@weapp-vite/mcp";
+const MCP_SERVER_VERSION = "2.0.0";
+const EXPOSED_PACKAGES = {
+  "weapp-vite": {
+    id: "weapp-vite",
+    label: "weapp-vite",
+    relativePath: path.join("packages", "weapp-vite")
   },
-  async ({ weightKg, heightM }) => ({
+  "wevu": {
+    id: "wevu",
+    label: "wevu",
+    relativePath: path.join("packages", "wevu")
+  },
+  "wevu-compiler": {
+    id: "wevu-compiler",
+    label: "wevu-compiler",
+    relativePath: path.join("packages", "wevu-compiler")
+  }
+};
+const DEFAULT_TIMEOUT_MS = 12e4;
+const DEFAULT_MAX_OUTPUT_CHARS = 12e4;
+const DEFAULT_MAX_FILE_CHARS = 8e4;
+const DEFAULT_MAX_RESULTS = 200;
+const SKIPPED_DIR_NAMES = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".turbo",
+  "dist",
+  "coverage"
+]);
+
+function hasWorkspaceMarkers(dir) {
+  return fs.existsSync(path.join(dir, "pnpm-workspace.yaml")) && fs.existsSync(path.join(dir, "package.json"));
+}
+function resolveWorkspaceRoot(start = process.cwd()) {
+  let current = path.resolve(start);
+  while (true) {
+    if (hasWorkspaceMarkers(current)) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return path.resolve(start);
+    }
+    current = parent;
+  }
+}
+function assertInsideRoot(root, targetPath) {
+  const resolvedRoot = path.resolve(root);
+  const resolvedTarget = path.resolve(targetPath);
+  const relative = path.relative(resolvedRoot, resolvedTarget);
+  if (relative === "" || relative === ".") {
+    return resolvedTarget;
+  }
+  if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    throw new Error(`\u8DEF\u5F84\u8D8A\u754C\uFF1A${targetPath}`);
+  }
+  return resolvedTarget;
+}
+function resolveSubPath(root, relativePath) {
+  if (!relativePath || relativePath === ".") {
+    return path.resolve(root);
+  }
+  if (path.isAbsolute(relativePath)) {
+    throw new Error("\u4EC5\u652F\u6301\u76F8\u5BF9\u8DEF\u5F84");
+  }
+  return assertInsideRoot(root, path.resolve(root, relativePath));
+}
+
+async function readJsonFile(filePath) {
+  const content = await fs$1.readFile(filePath, "utf8");
+  return JSON.parse(content);
+}
+async function pathExists(filePath) {
+  try {
+    await fs$1.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadPackageSummary(workspaceRoot, id) {
+  const config = EXPOSED_PACKAGES[id];
+  const absolutePath = assertInsideRoot(workspaceRoot, path.join(workspaceRoot, config.relativePath));
+  const packageJsonPath = path.join(absolutePath, "package.json");
+  const packageJson = await readJsonFile(packageJsonPath);
+  const readmePath = path.join(absolutePath, "README.md");
+  const changelogPath = path.join(absolutePath, "CHANGELOG.md");
+  return {
+    id,
+    label: config.label,
+    packageName: packageJson.name ?? config.label,
+    version: packageJson.version ?? "0.0.0",
+    absolutePath,
+    relativePath: config.relativePath,
+    scripts: Object.keys(packageJson.scripts ?? {}),
+    docs: {
+      readme: await pathExists(readmePath) ? readmePath : void 0,
+      changelog: await pathExists(changelogPath) ? changelogPath : void 0
+    }
+  };
+}
+async function loadExposedCatalog(workspaceRoot) {
+  const summaries = await Promise.all(
+    Object.keys(EXPOSED_PACKAGES).map((id) => loadPackageSummary(workspaceRoot, id))
+  );
+  return summaries.sort((a, b) => a.id.localeCompare(b.id));
+}
+
+const ALLOWED_COMMANDS = /* @__PURE__ */ new Set([
+  "pnpm",
+  "node",
+  "git",
+  "rg"
+]);
+function resolveExecutable(command) {
+  if (process.platform === "win32") {
+    if (command === "pnpm") {
+      return "pnpm.cmd";
+    }
+    if (command === "git") {
+      return "git.exe";
+    }
+    if (command === "rg") {
+      return "rg.exe";
+    }
+  }
+  return command;
+}
+function truncateOutput(text, maxChars) {
+  if (text.length <= maxChars) {
+    return text;
+  }
+  return `${text.slice(0, maxChars)}
+
+[truncated: ${text.length - maxChars} chars omitted]`;
+}
+async function runCommand(workspaceRoot, command, args, options) {
+  if (!ALLOWED_COMMANDS.has(command)) {
+    throw new Error(`\u4E0D\u5141\u8BB8\u7684\u547D\u4EE4\uFF1A${command}`);
+  }
+  const cwd = resolveSubPath(workspaceRoot, options?.cwdRelative ?? ".");
+  const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const maxOutputChars = options?.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
+  const executable = resolveExecutable(command);
+  const child = spawn(executable, args, {
+    cwd,
+    env: process.env,
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: false
+  });
+  let stdout = "";
+  let stderr = "";
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    child.kill("SIGTERM");
+  }, timeoutMs);
+  child.stdout.on("data", (chunk) => {
+    stdout += chunk.toString();
+  });
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk.toString();
+  });
+  const exitCode = await new Promise((resolve, reject) => {
+    child.on("error", reject);
+    child.on("close", (code) => {
+      resolve(code ?? -1);
+    });
+  }).finally(() => {
+    clearTimeout(timer);
+  });
+  return {
+    command,
+    args,
+    cwd: path.resolve(cwd),
+    exitCode,
+    stdout: truncateOutput(stdout.trim(), maxOutputChars),
+    stderr: truncateOutput(stderr.trim(), maxOutputChars),
+    timedOut
+  };
+}
+
+async function walkFilesRecursive(root, current, output, maxResults) {
+  if (output.length >= maxResults) {
+    return;
+  }
+  const entries = await fs$1.readdir(current, { withFileTypes: true });
+  for (const entry of entries) {
+    if (output.length >= maxResults) {
+      return;
+    }
+    if (entry.isDirectory()) {
+      if (SKIPPED_DIR_NAMES.has(entry.name)) {
+        continue;
+      }
+      await walkFilesRecursive(root, path.join(current, entry.name), output, maxResults);
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    const absolutePath = path.join(current, entry.name);
+    const relativePath = path.relative(root, absolutePath).split(path.sep).join("/");
+    output.push(relativePath);
+  }
+}
+async function listFilesInDirectory(root, relativeDirectory = ".", maxResults = DEFAULT_MAX_RESULTS) {
+  const dirPath = resolveSubPath(root, relativeDirectory);
+  const files = [];
+  await walkFilesRecursive(root, dirPath, files, maxResults);
+  return files;
+}
+function sliceLines(content, startLine, endLine) {
+  if (!startLine && !endLine) {
+    return content;
+  }
+  const lines = content.split("\n");
+  const safeStart = Math.max(1, startLine ?? 1);
+  const safeEnd = Math.max(safeStart, endLine ?? lines.length);
+  return lines.slice(safeStart - 1, safeEnd).join("\n");
+}
+async function readFileContent(root, relativeFilePath, options) {
+  const filePath = assertInsideRoot(root, path.join(root, relativeFilePath));
+  const content = await fs$1.readFile(filePath, "utf8");
+  const selected = sliceLines(content, options?.startLine, options?.endLine);
+  const maxChars = options?.maxChars ?? DEFAULT_MAX_FILE_CHARS;
+  const clipped = selected.length > maxChars ? `${selected.slice(0, maxChars)}
+
+[truncated: ${selected.length - maxChars} chars omitted]` : selected;
+  return {
+    filePath,
+    content: clipped
+  };
+}
+function collectMatchesFromText(query, relativeFilePath, content, maxResults, output) {
+  const lines = content.split("\n");
+  for (let index = 0; index < lines.length; index += 1) {
+    if (output.length >= maxResults) {
+      return;
+    }
+    const lineText = lines[index] ?? "";
+    const column = lineText.toLowerCase().indexOf(query.toLowerCase());
+    if (column === -1) {
+      continue;
+    }
+    output.push({
+      filePath: relativeFilePath,
+      line: index + 1,
+      column: column + 1,
+      text: lineText.trim()
+    });
+  }
+}
+async function searchTextInDirectory(root, query, options) {
+  const maxResults = options?.maxResults ?? DEFAULT_MAX_RESULTS;
+  const files = await listFilesInDirectory(root, options?.relativeDirectory ?? ".", Math.max(400, maxResults));
+  const matches = [];
+  for (const file of files) {
+    if (matches.length >= maxResults) {
+      break;
+    }
+    const absolutePath = path.join(root, file);
+    let content = "";
+    try {
+      content = await fs$1.readFile(absolutePath, "utf8");
+    } catch {
+      continue;
+    }
+    collectMatchesFromText(query, file, content, maxResults, matches);
+  }
+  return matches;
+}
+
+function formatJson(value) {
+  return JSON.stringify(value, null, 2);
+}
+function normalizeErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function toToolResult(data, text) {
+  return {
+    content: [{
+      type: "text",
+      text: text ?? formatJson(data)
+    }],
+    structuredContent: {
+      result: data
+    }
+  };
+}
+function toToolError(error) {
+  const message = normalizeErrorMessage(error);
+  return {
+    isError: true,
     content: [{
       type: "text",
-      text: String(weightKg / (heightM * heightM))
+      text: message
     }]
-  })
-);
-server.tool(
-  "fetch-weather",
-  { city: z.string() },
-  async ({ city }) => {
-    const response = await fetch(`https://api.weather.com/${city}`);
-    const data = await response.text();
+  };
+}
+
+const packageIds = Object.keys(EXPOSED_PACKAGES);
+const packageIdSchema = z.enum(packageIds);
+function resolvePackageRoot(workspaceRoot, packageId) {
+  return assertInsideRoot(workspaceRoot, path.join(workspaceRoot, EXPOSED_PACKAGES[packageId].relativePath));
+}
+function toDocsUri(packageId, fileName) {
+  return `weapp-vite://docs/${packageId}/${fileName}`;
+}
+async function readTextFile(filePath) {
+  return fs$1.readFile(filePath, "utf8");
+}
+async function createWeappViteMcpServer(options) {
+  const workspaceRoot = resolveWorkspaceRoot(options?.workspaceRoot);
+  const server = new McpServer({
+    name: MCP_SERVER_NAME,
+    version: MCP_SERVER_VERSION
+  });
+  server.registerTool("workspace_catalog", {
+    title: "Workspace Catalog",
+    description: "\u8BFB\u53D6 weapp-vite / wevu \u76F8\u5173\u5305\u76EE\u5F55\u4E0E\u811A\u672C\u80FD\u529B\u6E05\u5355"
+  }, async () => {
+    try {
+      const catalog2 = await loadExposedCatalog(workspaceRoot);
+      return toToolResult({
+        workspaceRoot,
+        packages: catalog2
+      });
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("list_source_files", {
+    title: "List Source Files",
+    description: "\u5217\u51FA weapp-vite / wevu \u5305\u4E0B\u6307\u5B9A\u76EE\u5F55\u6587\u4EF6\u5217\u8868",
+    inputSchema: {
+      packageId: packageIdSchema,
+      directory: z.string().optional().describe("\u5305\u5185\u76F8\u5BF9\u76EE\u5F55\uFF0C\u9ED8\u8BA4 src"),
+      maxResults: z.number().int().positive().max(2e3).optional()
+    }
+  }, async ({ packageId, directory, maxResults }) => {
+    try {
+      const packageRoot = resolvePackageRoot(workspaceRoot, packageId);
+      const files = await listFilesInDirectory(packageRoot, directory ?? "src", maxResults ?? DEFAULT_MAX_RESULTS);
+      return toToolResult({
+        packageId,
+        directory: directory ?? "src",
+        count: files.length,
+        files
+      });
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("read_source_file", {
+    title: "Read Source File",
+    description: "\u8BFB\u53D6 weapp-vite / wevu \u5305\u5185\u6E90\u7801\u6587\u4EF6\uFF0C\u652F\u6301\u884C\u533A\u95F4\u88C1\u526A",
+    inputSchema: {
+      packageId: packageIdSchema,
+      filePath: z.string().describe("\u5305\u5185\u76F8\u5BF9\u6587\u4EF6\u8DEF\u5F84"),
+      startLine: z.number().int().positive().optional(),
+      endLine: z.number().int().positive().optional(),
+      maxChars: z.number().int().positive().max(2e5).optional()
+    }
+  }, async ({ packageId, filePath, startLine, endLine, maxChars }) => {
+    try {
+      const packageRoot = resolvePackageRoot(workspaceRoot, packageId);
+      const { filePath: absolutePath, content } = await readFileContent(packageRoot, filePath, {
+        startLine,
+        endLine,
+        maxChars: maxChars ?? DEFAULT_MAX_FILE_CHARS
+      });
+      return toToolResult({
+        packageId,
+        filePath,
+        absolutePath,
+        startLine: startLine ?? null,
+        endLine: endLine ?? null,
+        content
+      }, content);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("search_source_code", {
+    title: "Search Source Code",
+    description: "\u5728 weapp-vite / wevu \u4EE3\u7801\u4E2D\u641C\u7D22\u5173\u952E\u8BCD",
+    inputSchema: {
+      query: z.string().min(1),
+      packageId: packageIdSchema.optional(),
+      directory: z.string().optional(),
+      maxResults: z.number().int().positive().max(2e3).optional()
+    }
+  }, async ({ query, packageId, directory, maxResults }) => {
+    try {
+      const targetPackageIds = packageId ? [packageId] : packageIds;
+      const allMatches = [];
+      const safeMax = maxResults ?? DEFAULT_MAX_RESULTS;
+      for (const id of targetPackageIds) {
+        if (allMatches.length >= safeMax) {
+          break;
+        }
+        const packageRoot = resolvePackageRoot(workspaceRoot, id);
+        const matches = await searchTextInDirectory(packageRoot, query, {
+          relativeDirectory: directory ?? "src",
+          maxResults: safeMax - allMatches.length
+        });
+        allMatches.push(...matches.map((match) => ({
+          packageId: id,
+          ...match
+        })));
+      }
+      return toToolResult({
+        query,
+        total: allMatches.length,
+        matches: allMatches
+      });
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("run_package_script", {
+    title: "Run Package Script",
+    description: "\u5728 weapp-vite / wevu \u5305\u76EE\u5F55\u6267\u884C pnpm script",
+    inputSchema: {
+      packageId: packageIdSchema,
+      script: z.string().min(1),
+      args: z.array(z.string()).optional(),
+      timeoutMs: z.number().int().positive().max(9e5).optional()
+    }
+  }, async ({ packageId, script, args, timeoutMs }) => {
+    try {
+      const cwdRelative = EXPOSED_PACKAGES[packageId].relativePath;
+      const result = await runCommand(workspaceRoot, "pnpm", ["run", script, ...args ?? []], {
+        cwdRelative,
+        timeoutMs: timeoutMs ?? DEFAULT_TIMEOUT_MS
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("run_weapp_vite_cli", {
+    title: "Run weapp-vite CLI",
+    description: "\u6267\u884C weapp-vite CLI\uFF08build/dev/open/analyze \u7B49\uFF09",
+    inputSchema: {
+      subCommand: z.string().min(1),
+      projectPath: z.string().optional().describe("\u76F8\u5BF9 workspace \u6839\u8DEF\u5F84\uFF0C\u5982 e2e-apps/auto-routes-define-app-json"),
+      platform: z.string().optional(),
+      args: z.array(z.string()).optional(),
+      timeoutMs: z.number().int().positive().max(9e5).optional()
+    }
+  }, async ({ subCommand, projectPath, platform, args, timeoutMs }) => {
+    try {
+      const cliPath = path.join("packages", "weapp-vite", "bin", "weapp-vite.js");
+      const finalArgs = [cliPath, subCommand];
+      if (projectPath) {
+        finalArgs.push(resolveSubPath(workspaceRoot, projectPath));
+      }
+      if (platform) {
+        finalArgs.push("--platform", platform);
+      }
+      if (Array.isArray(args) && args.length > 0) {
+        finalArgs.push(...args);
+      }
+      const result = await runCommand(workspaceRoot, "node", finalArgs, {
+        timeoutMs: timeoutMs ?? DEFAULT_TIMEOUT_MS
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerTool("run_repo_command", {
+    title: "Run Repo Command",
+    description: "\u6267\u884C\u4ED3\u5E93\u7EA7\u547D\u4EE4\uFF08\u652F\u6301 pnpm/node/git/rg\uFF09",
+    inputSchema: {
+      command: z.enum(["pnpm", "node", "git", "rg"]),
+      args: z.array(z.string()).optional(),
+      cwdRelative: z.string().optional(),
+      timeoutMs: z.number().int().positive().max(9e5).optional()
+    }
+  }, async ({ command, args, cwdRelative, timeoutMs }) => {
+    try {
+      const result = await runCommand(workspaceRoot, command, args ?? [], {
+        cwdRelative,
+        timeoutMs: timeoutMs ?? DEFAULT_TIMEOUT_MS
+      });
+      return toToolResult(result);
+    } catch (error) {
+      return toToolError(error);
+    }
+  });
+  server.registerPrompt("plan-weapp-vite-change", {
+    title: "Plan weapp-vite Change",
+    description: "\u6839\u636E\u53D8\u66F4\u76EE\u6807\u751F\u6210 weapp-vite / wevu \u4FEE\u6539\u8BA1\u5212\u63D0\u793A\u8BCD",
+    argsSchema: {
+      objective: z.string().min(1),
+      focusPackage: packageIdSchema.optional()
+    }
+  }, async ({ objective, focusPackage }) => {
+    const targets = focusPackage ? [focusPackage] : packageIds;
+    return {
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: [
+              "\u4F60\u662F weapp-vite monorepo \u7EF4\u62A4\u8005\uFF0C\u8BF7\u7ED9\u51FA\u53EF\u6267\u884C\u7684\u6539\u9020\u8BA1\u5212\u3002",
+              `\u76EE\u6807\uFF1A${objective}`,
+              `\u805A\u7126\u5305\uFF1A${targets.join(", ")}`,
+              "\u8BF7\u5305\u542B\uFF1A\u5F71\u54CD\u9762\u3001\u98CE\u9669\u70B9\u3001\u6D4B\u8BD5\u7B56\u7565\u3001\u56DE\u6EDA\u7B56\u7565\u3002"
+            ].join("\n")
+          }
+        }
+      ]
+    };
+  });
+  server.registerPrompt("debug-wevu-runtime", {
+    title: "Debug wevu Runtime",
+    description: "\u7528\u4E8E\u5B9A\u4F4D wevu runtime \u751F\u547D\u5468\u671F/\u54CD\u5E94\u5F0F\u95EE\u9898\u7684\u6807\u51C6\u63D0\u793A\u8BCD",
+    argsSchema: {
+      symptom: z.string().min(1)
+    }
+  }, async ({ symptom }) => {
+    return {
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: [
+              "\u8BF7\u57FA\u4E8E wevu runtime \u4EE3\u7801\u8DEF\u5F84\u8FDB\u884C\u5206\u5C42\u6392\u67E5\uFF1A",
+              "1. \u590D\u73B0\u573A\u666F\u4E0E\u6700\u5C0F\u6837\u4F8B",
+              "2. \u751F\u547D\u5468\u671F\u94A9\u5B50\u89E6\u53D1\u94FE",
+              "3. \u54CD\u5E94\u5F0F\u4E0E setData \u5DEE\u91CF\u540C\u6B65\u94FE",
+              "4. \u5355\u6D4B\u4E0E e2e \u56DE\u5F52\u8865\u4E01",
+              `\u73B0\u8C61\uFF1A${symptom}`
+            ].join("\n")
+          }
+        }
+      ]
+    };
+  });
+  server.registerResource("workspace-catalog", "weapp-vite://workspace/catalog", {
+    title: "Workspace Catalog",
+    description: "weapp-vite / wevu \u5305\u76EE\u5F55\u3001\u7248\u672C\u548C\u811A\u672C\u5217\u8868",
+    mimeType: "application/json"
+  }, async () => {
+    const catalog2 = await loadExposedCatalog(workspaceRoot);
+    const text = JSON.stringify({ workspaceRoot, packages: catalog2 }, null, 2);
     return {
-      content: [{ type: "text", text: data }]
+      contents: [{
+        uri: "weapp-vite://workspace/catalog",
+        mimeType: "application/json",
+        text
+      }]
     };
+  });
+  const catalog = await loadExposedCatalog(workspaceRoot);
+  for (const summary of catalog) {
+    if (summary.docs.readme) {
+      const uri = toDocsUri(summary.id, "README.md");
+      server.registerResource(`docs-${summary.id}-readme`, uri, {
+        title: `${summary.id} README`,
+        mimeType: "text/markdown"
+      }, async () => {
+        const text = await readTextFile(summary.docs.readme);
+        return {
+          contents: [{ uri, mimeType: "text/markdown", text }]
+        };
+      });
+    }
+    if (summary.docs.changelog) {
+      const uri = toDocsUri(summary.id, "CHANGELOG.md");
+      server.registerResource(`docs-${summary.id}-changelog`, uri, {
+        title: `${summary.id} CHANGELOG`,
+        mimeType: "text/markdown"
+      }, async () => {
+        const text = await readTextFile(summary.docs.changelog);
+        return {
+          contents: [{ uri, mimeType: "text/markdown", text }]
+        };
+      });
+    }
+  }
+  const sourceTemplate = new ResourceTemplate("weapp-vite://source/{package}?path={path}", {
+    list: void 0,
+    complete: {
+      package: () => packageIds
+    }
+  });
+  server.registerResource("source-template", sourceTemplate, {
+    title: "Source Template",
+    description: "\u8BFB\u53D6 weapp-vite / wevu \u4EFB\u610F\u6E90\u7801\u6587\u4EF6\uFF08\u901A\u8FC7 package + path \u53C2\u6570\uFF09",
+    mimeType: "text/plain"
+  }, async (uri, variables) => {
+    try {
+      const packageId = String(variables.package ?? "");
+      if (!packageIds.includes(packageId)) {
+        throw new Error(`\u672A\u77E5 package\uFF1A${packageId}`);
+      }
+      const relativePath = decodeURIComponent(String(variables.path ?? ""));
+      const packageRoot = resolvePackageRoot(workspaceRoot, packageId);
+      const { content } = await readFileContent(packageRoot, relativePath, {
+        maxChars: DEFAULT_MAX_FILE_CHARS
+      });
+      return {
+        contents: [{
+          uri: uri.toString(),
+          mimeType: "text/plain",
+          text: content
+        }]
+      };
+    } catch (error) {
+      return {
+        contents: [{
+          uri: uri.toString(),
+          mimeType: "text/plain",
+          text: `[resource-error] ${normalizeErrorMessage(error)}`
+        }]
+      };
+    }
+  });
+  return {
+    server,
+    workspaceRoot
+  };
+}
+
+const DEFAULT_MCP_HOST = "127.0.0.1";
+const DEFAULT_MCP_PORT = 3088;
+const DEFAULT_MCP_ENDPOINT = "/mcp";
+function normalizeEndpoint(input) {
+  const value = typeof input === "string" ? input.trim() : "";
+  if (!value) {
+    return DEFAULT_MCP_ENDPOINT;
+  }
+  return value.startsWith("/") ? value : `/${value}`;
+}
+function normalizePort(input) {
+  if (typeof input === "number" && Number.isInteger(input) && input > 0 && input <= 65535) {
+    return input;
   }
-);
-const transport = new StdioServerTransport();
-async function main() {
-  await server.connect(transport);
+  return DEFAULT_MCP_PORT;
 }
-main();
+async function parseJsonBody(req) {
+  if (req.method !== "POST") {
+    return void 0;
+  }
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  if (chunks.length === 0) {
+    return void 0;
+  }
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (!raw) {
+    return void 0;
+  }
+  return JSON.parse(raw);
+}
+function writeJson(res, statusCode, payload) {
+  if (res.headersSent) {
+    return;
+  }
+  res.statusCode = statusCode;
+  res.setHeader("content-type", "application/json");
+  res.end(JSON.stringify(payload));
+}
+async function startStdioServer$1(options) {
+  const previousCwd = process.cwd();
+  if (options?.workspaceRoot) {
+    process.chdir(options.workspaceRoot);
+  }
+  try {
+    const { server } = await createWeappViteMcpServer(options);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+  } finally {
+    if (options?.workspaceRoot) {
+      process.chdir(previousCwd);
+    }
+  }
+}
+async function startStreamableHttpServer(options) {
+  const {
+    endpoint = DEFAULT_MCP_ENDPOINT,
+    host = DEFAULT_MCP_HOST,
+    port = DEFAULT_MCP_PORT,
+    workspaceRoot,
+    unref = false,
+    quiet = false,
+    onReady
+  } = options;
+  const normalizedEndpoint = normalizeEndpoint(endpoint);
+  const normalizedPort = normalizePort(port);
+  const { server: mcpServer } = await createWeappViteMcpServer({ workspaceRoot });
+  const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: void 0
+  });
+  await mcpServer.connect(transport);
+  const httpServer = http.createServer(async (req, res) => {
+    try {
+      const hostHeader = req.headers.host ?? `${host}:${normalizedPort}`;
+      const url = new URL(req.url ?? "/", `http://${hostHeader}`);
+      if (url.pathname !== normalizedEndpoint) {
+        writeJson(res, 404, {
+          jsonrpc: "2.0",
+          error: {
+            code: -32004,
+            message: `Not Found: ${url.pathname}`
+          },
+          id: null
+        });
+        return;
+      }
+      const method = req.method ?? "GET";
+      if (!["GET", "POST", "DELETE"].includes(method)) {
+        writeJson(res, 405, {
+          jsonrpc: "2.0",
+          error: {
+            code: -32005,
+            message: `Method Not Allowed: ${method}`
+          },
+          id: null
+        });
+        return;
+      }
+      const body = await parseJsonBody(req);
+      await transport.handleRequest(req, res, body);
+    } catch (error) {
+      writeJson(res, 500, {
+        jsonrpc: "2.0",
+        error: {
+          code: -32603,
+          message: error instanceof Error ? error.message : String(error)
+        },
+        id: null
+      });
+    }
+  });
+  await new Promise((resolve, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(normalizedPort, host, () => {
+      resolve();
+    });
+  });
+  if (unref) {
+    httpServer.unref();
+  }
+  if (!quiet) {
+    onReady?.(`[mcp] streamable-http ready at http://${host}:${normalizedPort}${normalizedEndpoint}`);
+  }
+  return {
+    transport: "streamable-http",
+    close: async () => {
+      await transport.close();
+      await new Promise((resolve, reject) => {
+        httpServer.close((error) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve();
+        });
+      });
+    }
+  };
+}
+async function startWeappViteMcpServer(options) {
+  const transport = options?.transport ?? "stdio";
+  if (transport === "streamable-http") {
+    return startStreamableHttpServer(options ?? {});
+  }
+  await startStdioServer$1(options);
+  return {
+    transport: "stdio"
+  };
+}
+
+function isDirectExecution() {
+  const entry = process.argv[1];
+  if (!entry) {
+    return false;
+  }
+  return fileURLToPath(import.meta.url) === entry;
+}
+if (isDirectExecution()) {
+  startStdioServer().catch((error) => {
+    const message = error instanceof Error ? error.stack ?? error.message : String(error);
+    process.stderr.write(`[mcp] server start failed
+${message}
+`);
+    process.exitCode = 1;
+  });
+}
+
+export { DEFAULT_MAX_FILE_CHARS, DEFAULT_MAX_OUTPUT_CHARS, DEFAULT_MAX_RESULTS, DEFAULT_MCP_ENDPOINT, DEFAULT_MCP_HOST, DEFAULT_MCP_PORT, DEFAULT_TIMEOUT_MS, EXPOSED_PACKAGES, MCP_SERVER_NAME, MCP_SERVER_VERSION, SKIPPED_DIR_NAMES, assertInsideRoot, createWeappViteMcpServer, formatJson, listFilesInDirectory, loadExposedCatalog, loadPackageSummary, normalizeErrorMessage, readFileContent, resolveSubPath, resolveWorkspaceRoot, runCommand, searchTextInDirectory, startStdioServer$1 as startStdioServer, startWeappViteMcpServer, toToolError, toToolResult };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@weapp-vite/mcp",
   "type": "module",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "mcp",
   "author": "ice breaker <1324318532@qq.com>",
   "license": "ISC",
@@ -31,7 +31,7 @@
     "node": "^20.19.0 || >=22.12.0"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.25.3",
+    "@modelcontextprotocol/sdk": "^1.27.1",
     "zod": "^4.3.6"
   },
   "scripts": {
@@ -40,6 +40,7 @@
     "build": "unbuild",
     "test": "vitest run",
     "test:dev": "vitest",
+    "typecheck": "tsc --noEmit",
     "release": "pnpm publish",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",