@pubinfo-pr/devtools 0.220.2 → 0.220.4

package/dist/index.mjs

@@ -1,9 +1,14 @@
 import { DIR_CLIENT } from "./dirs.mjs";
+import { Buffer } from "node:buffer";
 import sirv from "sirv";
 import { basename, dirname, extname, join, relative } from "node:path";
 import { pathToFileURL } from "node:url";
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { readdir } from "node:fs/promises";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { execSync } from "node:child_process";
+import { arch, platform, release } from "node:os";
+import process from "node:process";
+import { Lang, parse } from "@ast-grep/napi";
 
 //#region src/server/controller/api.ts
 const REQUEST_MODULE_EXTENSIONS = [
@@ -486,49 +491,1852 @@ async function getRequestList(root) {
 }
 
 //#endregion
-//#region src/server/utils/count-files.ts
+//#region src/server/controller/issue.ts
 /**
-* 在统计项目文件数量时需要忽略的目录。
-* 这些目录通常体积较大或为构建产物，对健康检查意义不大。
+* 安全执行 git 命令，失败时返回 null
 */
-const IGNORED_DIRECTORIES = new Set([
-	".git",
+function execGit(command, cwd) {
+	try {
+		return execSync(command, {
+			cwd,
+			encoding: "utf-8",
+			timeout: 5e3
+		}).trim() || null;
+	} catch {
+		return null;
+	}
+}
+/**
+* 采集 Git 信息
+*/
+function collectGitInfo(root) {
+	return {
+		userName: execGit("git config user.name", root),
+		userEmail: execGit("git config user.email", root),
+		branch: execGit("git rev-parse --abbrev-ref HEAD", root),
+		commitHash: execGit("git rev-parse --short HEAD", root),
+		remoteUrl: execGit("git remote get-url origin", root)
+	};
+}
+/**
+* 读取项目 package.json
+*/
+function collectPackageJson(root) {
+	try {
+		const pkgPath = join(root, "package.json");
+		if (!existsSync(pkgPath)) return {};
+		return JSON.parse(readFileSync(pkgPath, "utf-8"));
+	} catch {
+		return {};
+	}
+}
+/**
+* 采集完整的环境信息
+*/
+function getEnvironmentInfo(root) {
+	return {
+		nodeVersion: process.version,
+		platform: platform(),
+		arch: arch(),
+		osVersion: release(),
+		packageJson: collectPackageJson(root),
+		git: collectGitInfo(root)
+	};
+}
+/**
+* 将环境信息格式化为 Markdown 文本，用于 Issue body
+*/
+function formatEnvironmentMarkdown(env) {
+	const envObj = {
+		node: env.nodeVersion,
+		os: `${env.platform} ${env.arch} (${env.osVersion})`,
+		git: {
+			branch: env.git.branch,
+			commit: env.git.commitHash,
+			user: env.git.userName ? `${env.git.userName}${env.git.userEmail ? ` <${env.git.userEmail}>` : ""}` : null,
+			remote: env.git.remoteUrl
+		}
+	};
+	const lines = [];
+	lines.push(`### 环境信息`);
+	lines.push("");
+	lines.push("```json");
+	lines.push(JSON.stringify(envObj, null, 2));
+	lines.push("```");
+	lines.push("");
+	lines.push(`### package.json`);
+	lines.push("");
+	lines.push("```json");
+	lines.push(JSON.stringify(env.packageJson, null, 2));
+	lines.push("```");
+	return lines.join("\n");
+}
+/**
+* 将表单数据格式化为 Issue body（Markdown）
+*/
+function formatIssueBody(body, environment) {
+	const sections = [];
+	sections.push(`## 问题描述`);
+	sections.push(body.description || "_未填写_");
+	sections.push("");
+	if (body.steps) {
+		sections.push(`## 复现步骤`);
+		sections.push(body.steps);
+		sections.push("");
+	}
+	if (body.expected) {
+		sections.push(`## 期望行为`);
+		sections.push(body.expected);
+		sections.push("");
+	}
+	if (body.actual) {
+		sections.push(`## 实际行为`);
+		sections.push(body.actual);
+		sections.push("");
+	}
+	sections.push(formatEnvironmentMarkdown(environment));
+	return sections.join("\n");
+}
+/**
+* 处理 Issue 提交，采集环境信息后转发到 issue.elonehoo.cn
+*/
+async function submitIssue(root, body) {
+	const issueBody = formatIssueBody(body, getEnvironmentInfo(root));
+	const response = await fetch("https://issue.elonehoo.cn/issue", {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			title: `[Bug] ${body.title}`,
+			body: issueBody
+		})
+	});
+	if (!response.ok) throw new Error(`Issue API responded with ${response.status}: ${response.statusText}`);
+	const result = await response.json();
+	if (!result.success) throw new Error("Issue API returned success: false");
+	return result;
+}
+
+//#endregion
+//#region src/@data/pubinfo.ts
+const pubinfoImport = [
+	{
+		type: "import",
+		name: "createPubinfoProvider",
+		package: "pubinfo-pr",
+		meta: { category: "provider" }
+	},
+	{
+		type: "import",
+		name: "pubinfoInjectionKey",
+		package: "pubinfo-pr",
+		meta: { category: "provider" }
+	},
+	{
+		type: "import",
+		name: "createPubinfoContext",
+		package: "pubinfo-pr",
+		meta: { category: "context" }
+	},
+	{
+		type: "import",
+		name: "usePubinfoContext",
+		package: "pubinfo-pr",
+		meta: { category: "context" }
+	},
+	{
+		type: "import",
+		name: "createContext",
+		package: "pubinfo-pr",
+		meta: { category: "context" }
+	},
+	{
+		type: "import",
+		name: "createRawContext",
+		package: "pubinfo-pr",
+		meta: { category: "context" }
+	},
+	{
+		type: "import",
+		name: "createPubinfo",
+		package: "pubinfo-pr",
+		meta: { category: "provider" }
+	},
+	{
+		type: "import",
+		name: "createRequest",
+		package: "pubinfo-pr",
+		meta: { category: "request" }
+	},
+	{
+		type: "import",
+		name: "defineIconModule",
+		package: "pubinfo-pr",
+		meta: { category: "module" }
+	},
+	{
+		type: "import",
+		name: "defineRouteModule",
+		package: "pubinfo-pr",
+		meta: { category: "module" }
+	},
+	{
+		type: "import",
+		name: "getAllIconModules",
+		package: "pubinfo-pr",
+		meta: { category: "module" }
+	},
+	{
+		type: "import",
+		name: "getAllRouteModules",
+		package: "pubinfo-pr",
+		meta: { category: "module" }
+	},
+	{
+		type: "import",
+		name: "readProjectModules",
+		package: "pubinfo-pr",
+		meta: { category: "module" }
+	},
+	{
+		type: "import",
+		name: "updateWatermark",
+		package: "pubinfo-pr",
+		meta: { category: "utility" }
+	},
+	{
+		type: "import",
+		name: "cleanup",
+		package: "pubinfo-pr",
+		meta: { category: "utility" }
+	},
+	{
+		type: "import",
+		name: "cleanupWithoutUser",
+		package: "pubinfo-pr",
+		meta: { category: "utility" }
+	},
+	{
+		type: "import",
+		name: "wrapProxy",
+		package: "pubinfo-pr",
+		meta: { category: "utility" }
+	},
+	{
+		type: "import",
+		name: "watchDiffObject",
+		package: "pubinfo-pr",
+		meta: { category: "utility" }
+	},
+	{
+		type: "import",
+		name: "clearPersistedState",
+		package: "pubinfo-pr",
+		meta: { category: "storage" }
+	},
+	{
+		type: "import",
+		name: "getPersistedState",
+		package: "pubinfo-pr",
+		meta: { category: "storage" }
+	},
+	{
+		type: "import",
+		name: "setPersistedState",
+		package: "pubinfo-pr",
+		meta: { category: "storage" }
+	},
+	{
+		type: "import",
+		name: "storage",
+		package: "pubinfo-pr",
+		meta: { category: "storage" }
+	},
+	{
+		type: "import",
+		name: "getPubinfoNamespace",
+		package: "pubinfo-pr",
+		meta: { category: "storage" }
+	},
+	{
+		type: "import",
+		name: "publicKeyEncryption",
+		package: "pubinfo-pr",
+		meta: { category: "crypto" }
+	},
+	{
+		type: "import",
+		name: "useAuth",
+		package: "pubinfo-pr",
+		meta: { category: "composable" }
+	},
+	{
+		type: "import",
+		name: "useError",
+		package: "pubinfo-pr",
+		meta: { category: "composable" }
+	},
+	{
+		type: "import",
+		name: "useSuccess",
+		package: "pubinfo-pr",
+		meta: { category: "composable" }
+	},
+	{
+		type: "import",
+		name: "useWarn",
+		package: "pubinfo-pr",
+		meta: { category: "composable" }
+	},
+	{
+		type: "import",
+		name: "useInfo",
+		package: "pubinfo-pr",
+		meta: { category: "composable" }
+	},
+	{
+		type: "import",
+		name: "useStart",
+		package: "pubinfo-pr",
+		meta: { category: "composable" }
+	},
+	{
+		type: "import",
+		name: "useBox",
+		package: "pubinfo-pr",
+		meta: { category: "composable" }
+	},
+	{
+		type: "import",
+		name: "usePartyLogin",
+		package: "pubinfo-pr",
+		meta: { category: "composable" }
+	},
+	{
+		type: "import",
+		name: "useTheme",
+		package: "pubinfo-pr",
+		meta: { category: "composable" }
+	},
+	{
+		type: "import",
+		name: "createLog",
+		package: "pubinfo-pr",
+		meta: { category: "log" }
+	},
+	{
+		type: "import",
+		name: "defineSystemRoutes",
+		package: "pubinfo-pr",
+		meta: { category: "route" }
+	},
+	{
+		type: "import",
+		name: "getSystemRoutes",
+		package: "pubinfo-pr",
+		meta: { category: "route" }
+	},
+	{
+		type: "import",
+		name: "defineAsyncRoutes",
+		package: "pubinfo-pr",
+		meta: { category: "route" }
+	},
+	{
+		type: "import",
+		name: "getAsyncRoutes",
+		package: "pubinfo-pr",
+		meta: { category: "route" }
+	},
+	{
+		type: "import",
+		name: "formatBackRoutes",
+		package: "pubinfo-pr",
+		meta: { category: "route" }
+	},
+	{
+		type: "import",
+		name: "filterEmptyComponentRoutes",
+		package: "pubinfo-pr",
+		meta: { category: "route" }
+	},
+	{
+		type: "import",
+		name: "defineSettings",
+		package: "pubinfo-pr",
+		meta: { category: "settings" }
+	},
+	{
+		type: "import",
+		name: "getSettings",
+		package: "pubinfo-pr",
+		meta: { category: "settings" }
+	},
+	{
+		type: "import",
+		name: "useFavoritesStore",
+		package: "pubinfo-pr",
+		meta: { category: "store" }
+	},
+	{
+		type: "import",
+		name: "useIframeStore",
+		package: "pubinfo-pr",
+		meta: { category: "store" }
+	},
+	{
+		type: "import",
+		name: "useKeepAliveStore",
+		package: "pubinfo-pr",
+		meta: { category: "store" }
+	},
+	{
+		type: "import",
+		name: "useMenuStore",
+		package: "pubinfo-pr",
+		meta: { category: "store" }
+	},
+	{
+		type: "import",
+		name: "useRouteStore",
+		package: "pubinfo-pr",
+		meta: { category: "store" }
+	},
+	{
+		type: "import",
+		name: "useSettingsStore",
+		package: "pubinfo-pr",
+		meta: { category: "store" }
+	},
+	{
+		type: "import",
+		name: "useTabbarStore",
+		package: "pubinfo-pr",
+		meta: { category: "store" }
+	},
+	{
+		type: "import",
+		name: "useUserStore",
+		package: "pubinfo-pr",
+		meta: { category: "store" }
+	}
+];
+const pubinfoComponent = [
+	{
+		type: "component",
+		name: "PubinfoDev",
+		package: "pubinfo-pr",
+		meta: { category: "dev" }
+	},
+	{
+		type: "component",
+		name: "Copyright",
+		package: "pubinfo-pr",
+		meta: { category: "layout" }
+	},
+	{
+		type: "component",
+		name: "Layout",
+		package: "pubinfo-pr",
+		meta: { category: "layout" }
+	},
+	{
+		type: "component",
+		name: "LayoutHeader",
+		package: "pubinfo-pr",
+		meta: { category: "layout" }
+	},
+	{
+		type: "component",
+		name: "LayoutContent",
+		package: "pubinfo-pr",
+		meta: { category: "layout" }
+	},
+	{
+		type: "component",
+		name: "LayoutProvider",
+		package: "pubinfo-pr",
+		meta: { category: "layout" }
+	},
+	{
+		type: "component",
+		name: "LayoutSidebar",
+		package: "pubinfo-pr",
+		meta: { category: "layout" }
+	},
+	{
+		type: "component",
+		name: "LayoutTopbar",
+		package: "pubinfo-pr",
+		meta: { category: "layout" }
+	},
+	{
+		type: "component",
+		name: "Logo",
+		package: "pubinfo-pr",
+		meta: { category: "layout" }
+	},
+	{
+		type: "component",
+		name: "NotAllowed",
+		package: "pubinfo-pr",
+		meta: { category: "layout" }
+	},
+	{
+		type: "component",
+		name: "Tool",
+		package: "pubinfo-pr",
+		meta: { category: "layout" }
+	},
+	{
+		type: "component",
+		name: "Tools",
+		package: "pubinfo-pr",
+		meta: { category: "layout" }
+	},
+	{
+		type: "component",
+		name: "PageHeader",
+		package: "pubinfo-pr",
+		meta: { category: "page" }
+	},
+	{
+		type: "component",
+		name: "PageMain",
+		package: "pubinfo-pr",
+		meta: { category: "page" }
+	},
+	{
+		type: "component",
+		name: "PartyLoginModal",
+		package: "pubinfo-pr",
+		meta: { category: "auth" }
+	},
+	{
+		type: "component",
+		name: "PassStrengthValidator",
+		package: "pubinfo-pr",
+		meta: { category: "auth" }
+	},
+	{
+		type: "component",
+		name: "PubinfoApp",
+		package: "pubinfo-pr",
+		meta: { category: "core" }
+	},
+	{
+		type: "component",
+		name: "PubinfoIcon",
+		package: "pubinfo-pr",
+		meta: { category: "icon" }
+	},
+	{
+		type: "component",
+		name: "PubinfoIconPrismBox",
+		package: "pubinfo-pr",
+		meta: { category: "icon" }
+	},
+	{
+		type: "component",
+		name: "PubinfoIconSquareBox",
+		package: "pubinfo-pr",
+		meta: { category: "icon" }
+	},
+	{
+		type: "component",
+		name: "PubinfoProvider",
+		package: "pubinfo-pr",
+		meta: { category: "provider" }
+	}
+];
+
+//#endregion
+//#region src/@data/vue.ts
+const VUE_DOCS_BASE = "https://cn.vuejs.org/api";
+const vueImport = [
+	{
+		type: "import",
+		name: "onActivated",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-lifecycle.html#onactivated`,
+			category: "lifecycle"
+		}
+	},
+	{
+		type: "import",
+		name: "onBeforeMount",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-lifecycle.html#onbeforemount`,
+			category: "lifecycle"
+		}
+	},
+	{
+		type: "import",
+		name: "onBeforeUnmount",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-lifecycle.html#onbeforeunmount`,
+			category: "lifecycle"
+		}
+	},
+	{
+		type: "import",
+		name: "onBeforeUpdate",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-lifecycle.html#onbeforeupdate`,
+			category: "lifecycle"
+		}
+	},
+	{
+		type: "import",
+		name: "onErrorCaptured",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-lifecycle.html#onerrorcaptured`,
+			category: "lifecycle"
+		}
+	},
+	{
+		type: "import",
+		name: "onDeactivated",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-lifecycle.html#ondeactivated`,
+			category: "lifecycle"
+		}
+	},
+	{
+		type: "import",
+		name: "onMounted",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-lifecycle.html#onmounted`,
+			category: "lifecycle"
+		}
+	},
+	{
+		type: "import",
+		name: "onServerPrefetch",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-lifecycle.html#onserverprefetch`,
+			category: "lifecycle"
+		}
+	},
+	{
+		type: "import",
+		name: "onUnmounted",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-lifecycle.html#onunmounted`,
+			category: "lifecycle"
+		}
+	},
+	{
+		type: "import",
+		name: "onUpdated",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-lifecycle.html#onupdated`,
+			category: "lifecycle"
+		}
+	},
+	{
+		type: "import",
+		name: "useAttrs",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-helpers.html#useattrs`,
+			category: "helper"
+		}
+	},
+	{
+		type: "import",
+		name: "useSlots",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-helpers.html#useslots`,
+			category: "helper"
+		}
+	},
+	{
+		type: "import",
+		name: "computed",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-core.html#computed`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "customRef",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-advanced.html#customref`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "isReadonly",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-utilities.html#isreadonly`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "isRef",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-utilities.html#isref`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "isShallow",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-utilities.html#isshallow`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "isProxy",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-utilities.html#isproxy`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "isReactive",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-utilities.html#isreactive`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "markRaw",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-advanced.html#markraw`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "reactive",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-core.html#reactive`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "readonly",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-core.html#readonly`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "ref",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-core.html#ref`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "shallowReactive",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-advanced.html#shallowreactive`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "shallowReadonly",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-advanced.html#shallowreadonly`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "shallowRef",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-advanced.html#shallowref`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "triggerRef",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-advanced.html#triggerref`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "toRaw",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-advanced.html#toraw`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "toRef",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-utilities.html#toref`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "toRefs",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-utilities.html#torefs`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "toValue",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-utilities.html#tovalue`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "unref",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-utilities.html#unref`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "watch",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-core.html#watch`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "watchEffect",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-core.html#watcheffect`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "watchPostEffect",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-core.html#watchposteffect`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "watchSyncEffect",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-core.html#watchsynceffect`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "defineComponent",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/general.html#definecomponent`,
+			category: "component"
+		}
+	},
+	{
+		type: "import",
+		name: "defineAsyncComponent",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/general.html#defineasynccomponent`,
+			category: "component"
+		}
+	},
+	{
+		type: "import",
+		name: "getCurrentInstance",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-helpers.html#getcurrentinstance`,
+			category: "component"
+		}
+	},
+	{
+		type: "import",
+		name: "h",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/render-function.html#h`,
+			category: "component"
+		}
+	},
+	{
+		type: "import",
+		name: "inject",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-dependency-injection.html#inject`,
+			category: "component"
+		}
+	},
+	{
+		type: "import",
+		name: "nextTick",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/general.html#nexttick`,
+			category: "component"
+		}
+	},
+	{
+		type: "import",
+		name: "provide",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-dependency-injection.html#provide`,
+			category: "component"
+		}
+	},
+	{
+		type: "import",
+		name: "useCssModule",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/sfc-css-features.html#css-modules`,
+			category: "component"
+		}
+	},
+	{
+		type: "import",
+		name: "createApp",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/application.html#createapp`,
+			category: "component"
+		}
+	},
+	{
+		type: "import",
+		name: "effectScope",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-advanced.html#effectscope`,
+			category: "effect-scope"
+		}
+	},
+	{
+		type: "import",
+		name: "EffectScope",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-advanced.html#effectscope`,
+			category: "effect-scope"
+		}
+	},
+	{
+		type: "import",
+		name: "getCurrentScope",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-advanced.html#getcurrentscope`,
+			category: "effect-scope"
+		}
+	},
+	{
+		type: "import",
+		name: "onScopeDispose",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-advanced.html#onscopedispose`,
+			category: "effect-scope"
+		}
+	},
+	{
+		type: "import",
+		name: "onRenderTracked",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-lifecycle.html#onrendertracked`,
+			category: "lifecycle"
+		}
+	},
+	{
+		type: "import",
+		name: "onRenderTriggered",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-lifecycle.html#onrendertriggered`,
+			category: "lifecycle"
+		}
+	},
+	{
+		type: "import",
+		name: "resolveComponent",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/render-function.html#resolvecomponent`,
+			category: "component"
+		}
+	},
+	{
+		type: "import",
+		name: "useCssVars",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/sfc-css-features.html#v-bind-in-css`,
+			category: "component"
+		}
+	},
+	{
+		type: "import",
+		name: "useModel",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-helpers.html#usemodel`,
+			category: "helper"
+		}
+	},
+	{
+		type: "import",
+		name: "getCurrentWatcher",
+		package: "vue",
+		meta: { category: "reactivity" }
+	},
+	{
+		type: "import",
+		name: "onWatcherCleanup",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/reactivity-core.html#onwatchercleanup`,
+			category: "reactivity"
+		}
+	},
+	{
+		type: "import",
+		name: "useId",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-helpers.html#useid`,
+			category: "helper"
+		}
+	},
+	{
+		type: "import",
+		name: "useTemplateRef",
+		package: "vue",
+		meta: {
+			docs: `${VUE_DOCS_BASE}/composition-api-helpers.html#usetemplateref`,
+			category: "helper"
+		}
+	}
+];
+const vueComponent = [
+	{
+		type: "component",
+		name: "Transition",
+		package: "vue",
+		meta: { docs: `${VUE_DOCS_BASE}/built-in-components.html#transition` }
+	},
+	{
+		type: "component",
+		name: "TransitionGroup",
+		package: "vue",
+		meta: { docs: `${VUE_DOCS_BASE}/built-in-components.html#transitiongroup` }
+	},
+	{
+		type: "component",
+		name: "KeepAlive",
+		package: "vue",
+		meta: { docs: `${VUE_DOCS_BASE}/built-in-components.html#keepalive` }
+	},
+	{
+		type: "component",
+		name: "Teleport",
+		package: "vue",
+		meta: { docs: `${VUE_DOCS_BASE}/built-in-components.html#teleport` }
+	},
+	{
+		type: "component",
+		name: "Suspense",
+		package: "vue",
+		meta: { docs: `${VUE_DOCS_BASE}/built-in-components.html#suspense` }
+	}
+];
+
+//#endregion
+//#region src/@data/index.ts
+const functions = [...vueImport, ...pubinfoImport];
+const components = [...vueComponent, ...pubinfoComponent];
+
+//#endregion
+//#region src/server/utils/ast-analyzer.ts
+/** 跳过的目录 */
+const IGNORED_DIRS = new Set([
+	"node_modules",
 	"dist",
-	"node_modules"
+	"build",
+	".git",
+	"coverage",
+	".pubinfo"
+]);
+/** 默认源码扩展名 */
+const SOURCE_EXTENSIONS$2 = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".vue"
 ]);
+/** 单次并发读取文件数（防止文件描述符爆满） */
+const FILE_READ_CONCURRENCY = 64;
+/**
+* 递归扫描目录获取所有源文件（同步版本，保留给 module-counter 使用）
+*/
+function getAllSourceFiles(dir, extensions = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".vue"
+]) {
+	const extSet = new Set(extensions);
+	const files = [];
+	function scan(currentDir) {
+		try {
+			const entries = readdirSync(currentDir);
+			for (const entry of entries) {
+				const fullPath = join(currentDir, entry);
+				try {
+					const s = statSync(fullPath);
+					if (s.isDirectory()) {
+						if (!IGNORED_DIRS.has(entry)) scan(fullPath);
+					} else if (s.isFile() && extSet.has(extname(fullPath))) files.push(fullPath);
+				} catch {}
+			}
+		} catch {}
+	}
+	scan(dir);
+	return files;
+}
+/**
+* 异步递归扫描目录获取所有源文件
+*/
+async function getAllSourceFilesAsync(dir) {
+	const files = [];
+	async function scan(currentDir) {
+		let entries;
+		try {
+			entries = await readdir(currentDir);
+		} catch {
+			return;
+		}
+		const statJobs = entries.map(async (entry) => {
+			const fullPath = join(currentDir, entry);
+			try {
+				const s = await stat(fullPath);
+				if (s.isDirectory()) {
+					if (!IGNORED_DIRS.has(entry)) await scan(fullPath);
+				} else if (s.isFile() && SOURCE_EXTENSIONS$2.has(extname(fullPath))) files.push(fullPath);
+			} catch {}
+		});
+		await Promise.all(statJobs);
+	}
+	await scan(dir);
+	return files;
+}
+/**
+* 根据文件扩展名选择语言类型
+*/
+function getLang(filePath) {
+	switch (extname(filePath)) {
+		case ".tsx":
+		case ".jsx": return Lang.Tsx;
+		case ".js": return Lang.JavaScript;
+		default: return Lang.TypeScript;
+	}
+}
+/**
+* 在文件内容上做一次快速字符串检查，返回内容中可能出现的追踪项名称集合。
+* 通过这一步可以跳过绝大部分不相关的文件，避免无效 AST 解析。
+*/
+function quickFilterNames(content, names) {
+	const hits = /* @__PURE__ */ new Set();
+	for (const name of names) if (content.includes(name)) hits.add(name);
+	return hits;
+}
 /**
-* 递归统计目录下的文件数量。
+* 对单个文件做一次性全量分析，返回该文件中出现的所有追踪名的使用位置。
 *
-* - 忽略符号链接，避免循环引用与跨盘符问题。
-* - 忽略 IGNORED_DIRECTORIES 列表中的目录。
-* - 遇到权限错误/不可读目录时返回 0（宽松模式，不抛错）。
+* 优化点：
+* 1. 先用字符串 includes 快速预过滤，跳过不相关名称。
+* 2. AST 只解析一次，遍历一次 rootNode，收集所有 call_expression / import_specifier / jsx。
+* 3. Vue template 部分改为一次性合并正则匹配（而非 N 次独立正则）。
+*/
+function analyzeFile(content, filePath, functionNames, componentNames) {
+	const result = {
+		functions: /* @__PURE__ */ new Map(),
+		components: /* @__PURE__ */ new Map()
+	};
+	const hitFunctions = quickFilterNames(content, functionNames);
+	const hitComponents = quickFilterNames(content, componentNames);
+	if (hitFunctions.size === 0 && hitComponents.size === 0) return result;
+	try {
+		const rootNode = parse(getLang(filePath), content).root();
+		if (hitFunctions.size > 0) {
+			const callMatches = rootNode.findAll({ rule: { kind: "call_expression" } });
+			for (const match of callMatches) {
+				const calleeName = match.field("function")?.text();
+				if (calleeName && hitFunctions.has(calleeName)) {
+					const range = match.range();
+					const loc = {
+						file: filePath,
+						line: range.start.line + 1,
+						column: range.start.column + 1,
+						code: match.text().slice(0, 100)
+					};
+					if (!result.functions.has(calleeName)) result.functions.set(calleeName, []);
+					result.functions.get(calleeName).push(loc);
+				}
+			}
+		}
+		if (hitComponents.size > 0) {
+			const jsxMatches = rootNode.findAll({ rule: { kind: "jsx_opening_element" } });
+			for (const match of jsxMatches) {
+				const text = match.text();
+				const nameMatch = text.match(/^<(\w+)/);
+				if (nameMatch && hitComponents.has(nameMatch[1])) {
+					const compName = nameMatch[1];
+					const range = match.range();
+					const loc = {
+						file: filePath,
+						line: range.start.line + 1,
+						column: range.start.column + 1,
+						code: text.slice(0, 100)
+					};
+					if (!result.components.has(compName)) result.components.set(compName, []);
+					result.components.get(compName).push(loc);
+				}
+			}
+		}
+	} catch {}
+	if (filePath.endsWith(".vue") && hitComponents.size > 0) {
+		const names = Array.from(hitComponents);
+		const unionRegex = new RegExp(`<(${names.map(escapeRegex).join("|")})[\\s>/]`, "g");
+		const lines = content.split("\n");
+		const lineOffsets = buildLineOffsets(lines);
+		let match = unionRegex.exec(content);
+		while (match !== null) {
+			const compName = match[1];
+			const pos = match.index;
+			const lineNum = findLineNumber(lineOffsets, pos);
+			const loc = {
+				file: filePath,
+				line: lineNum,
+				column: pos - lineOffsets[lineNum - 1] + 1,
+				code: lines[lineNum - 1].trim().slice(0, 100)
+			};
+			if (!result.components.has(compName)) result.components.set(compName, []);
+			result.components.get(compName).push(loc);
+			match = unionRegex.exec(content);
+		}
+	}
+	return result;
+}
+/** 转义正则特殊字符 */
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** 构建每行起始偏移量数组，索引 0 = 第 1 行起始偏移 */
+function buildLineOffsets(lines) {
+	const offsets = Array.from({ length: lines.length });
+	offsets[0] = 0;
+	for (let i = 1; i < lines.length; i++) offsets[i] = offsets[i - 1] + lines[i - 1].length + 1;
+	return offsets;
+}
+/** 通过二分查找快速定位字符偏移所在的行号（1-based） */
+function findLineNumber(lineOffsets, pos) {
+	let lo = 0;
+	let hi = lineOffsets.length - 1;
+	while (lo < hi) {
+		const mid = lo + hi + 1 >> 1;
+		if (lineOffsets[mid] <= pos) lo = mid;
+		else hi = mid - 1;
+	}
+	return lo + 1;
+}
+/**
+* 以指定并发度分批执行异步任务
+*/
+async function processBatched(items, concurrency, fn) {
+	const results = [];
+	for (let i = 0; i < items.length; i += concurrency) {
+		const batch = items.slice(i, i + concurrency);
+		const batchResults = await Promise.all(batch.map(fn));
+		results.push(...batchResults);
+	}
+	return results;
+}
+/**
+* 扫描单个文件的使用情况。用于增量更新场景。
+*/
+async function scanSingleFile(filePath, functionsToTrack, componentsToTrack) {
+	const ext = extname(filePath);
+	if (!SOURCE_EXTENSIONS$2.has(ext)) return null;
+	try {
+		return analyzeFile(await readFile(filePath, "utf-8"), filePath, new Set(functionsToTrack.map((f) => f.name)), new Set(componentsToTrack.map((c) => c.name)));
+	} catch {
+		return null;
+	}
+}
+/**
+* 扫描项目中的使用情况（优化版）
 *
-* 用途：
-* - Devtools 首页/健康检查的一个轻量指标。
+* 相比旧版的优化：
+* 1. 异步 I/O + 并发读取文件，不阻塞 Vite dev server。
+* 2. 每文件只做一次 AST 解析，遍历一次收集所有命中。
+* 3. 快速预过滤（string.includes）跳过不相关文件。
+* 4. Vue template 使用联合正则一次匹配，二分法定位行号。
 *
-* @param root 目录绝对路径
-* @returns 统计到的文件总数
+* @param projectRoot 项目根目录
+* @param functionsToTrack 要追踪的函数列表
+* @param componentsToTrack 要追踪的组件列表
 */
-async function countFiles(root) {
-	let total = 0;
-	let entries;
-	try {
-		entries = await readdir(root, {
-			withFileTypes: true,
-			encoding: "utf8"
+async function scanUsageStats(projectRoot, functionsToTrack, componentsToTrack) {
+	const result = {
+		functions: [],
+		components: [],
+		totalFiles: 0,
+		scannedFiles: 0
+	};
+	const files = await getAllSourceFilesAsync(projectRoot);
+	result.totalFiles = files.length;
+	const functionNames = new Set(functionsToTrack.map((f) => f.name));
+	const componentNames = new Set(componentsToTrack.map((c) => c.name));
+	const functionStatsMap = /* @__PURE__ */ new Map();
+	const componentStatsMap = /* @__PURE__ */ new Map();
+	for (const func of functionsToTrack) functionStatsMap.set(func.name, {
+		name: func.name,
+		type: "import",
+		package: func.package,
+		count: 0,
+		locations: [],
+		meta: func.meta
+	});
+	for (const comp of componentsToTrack) componentStatsMap.set(comp.name, {
+		name: comp.name,
+		type: "component",
+		package: comp.package,
+		count: 0,
+		locations: [],
+		meta: comp.meta
+	});
+	await processBatched(files, FILE_READ_CONCURRENCY, async (file) => {
+		try {
+			const content = await readFile(file, "utf-8");
+			result.scannedFiles++;
+			const analysis = analyzeFile(content, file, functionNames, componentNames);
+			for (const [name, locations] of analysis.functions) {
+				const stats = functionStatsMap.get(name);
+				if (stats) {
+					stats.locations.push(...locations);
+					stats.count += locations.length;
+				}
+			}
+			for (const [name, locations] of analysis.components) {
+				const stats = componentStatsMap.get(name);
+				if (stats) {
+					stats.locations.push(...locations);
+					stats.count += locations.length;
+				}
+			}
+		} catch {}
+	});
+	result.functions = Array.from(functionStatsMap.values());
+	result.components = Array.from(componentStatsMap.values());
+	return result;
+}
+
+//#endregion
+//#region src/server/utils/module-counter.ts
+/**
+* 统计项目中通过 createPubinfo 注册的模块数量。
+*
+* 解析项目里的所有源文件，查找 createPubinfo 调用，并分析其 options.modules
+* 字段（含本地变量引用与展开语法）来估算注册的模块个数。
+*/
+function countRegisteredModules(projectRoot) {
+	const files = getAllSourceFiles(projectRoot);
+	let totalModules = 0;
+	for (const filePath of files) {
+		let content;
+		try {
+			content = readFileSync(filePath, "utf-8");
+		} catch {
+			continue;
+		}
+		if (!content.includes("createPubinfo")) continue;
+		try {
+			const rootNode = parse(getLang(filePath), content).root();
+			const context = {
+				rootNode,
+				initializerCache: /* @__PURE__ */ new Map()
+			};
+			const callExpressions = rootNode.findAll({ rule: { kind: "call_expression" } });
+			for (const call of callExpressions) {
+				if (!isCreatePubinfoCall(call)) continue;
+				totalModules += extractModulesFromCall(call, context);
+			}
+		} catch {
+			continue;
+		}
+	}
+	return totalModules;
+}
+function isCreatePubinfoCall(callNode) {
+	const name = callNode.field("function")?.text() ?? "";
+	return name === "createPubinfo" || name.endsWith(".createPubinfo");
+}
+function extractModulesFromCall(callNode, context) {
+	const optionsNode = resolveOptionsObject(callNode, context);
+	if (!optionsNode) return 0;
+	const modulesPair = findModulesPair(optionsNode);
+	if (!modulesPair) return 0;
+	const valueNode = modulesPair.field("value");
+	if (!valueNode) return 0;
+	return countModulesFromValue(valueNode, context, /* @__PURE__ */ new Set());
+}
+function resolveOptionsObject(callNode, context) {
+	const argsNode = callNode.field("arguments");
+	if (!argsNode) return null;
+	const directObject = argsNode.children().find((child) => child.kind() === "object");
+	if (directObject) return directObject;
+	const firstArg = getFirstNamedChild(argsNode);
+	if (firstArg?.kind() === "identifier") {
+		const initializer = findInitializer(context, firstArg.text());
+		if (initializer?.kind() === "object") return initializer;
+	}
+	return null;
+}
+function findModulesPair(objectNode) {
+	const pairs = objectNode.children().filter((child) => child.kind() === "pair");
+	for (const pair of pairs) {
+		const key = pair.field("key");
+		if ((key ? normalizeKeyText(key.text()) : null) === "modules") return pair;
+	}
+	return null;
+}
+function normalizeKeyText(raw) {
+	if (raw.startsWith("'") || raw.startsWith("\"") || raw.startsWith("`")) return raw.slice(1, -1);
+	return raw;
+}
+function countModulesFromValue(valueNode, context, visited) {
+	switch (valueNode.kind()) {
+		case "array": return countArrayEntries(valueNode, context, visited);
+		case "identifier": return countIdentifierReference(valueNode.text(), context, visited);
+		case "parenthesized_expression":
+		case "as_expression":
+		case "type_assertion":
+		case "non_null_expression": {
+			const inner = getFirstNamedChild(valueNode);
+			return inner ? countModulesFromValue(inner, context, visited) : 0;
+		}
+		default: return 0;
+	}
+}
+function countArrayEntries(arrayNode, context, visited) {
+	let count = 0;
+	for (const child of arrayNode.children()) {
+		if (!child.isNamed()) continue;
+		if (child.kind() === "spread_element") {
+			const spreadTarget = getFirstNamedChild(child);
+			if (spreadTarget) count += countModulesFromValue(spreadTarget, context, visited);
+			continue;
+		}
+		count += 1;
+	}
+	return count;
+}
+function countIdentifierReference(identifierName, context, visited) {
+	if (!identifierName || visited.has(identifierName)) return 0;
+	visited.add(identifierName);
+	const initializer = findInitializer(context, identifierName);
+	let result = 0;
+	if (initializer) result = countModulesFromValue(initializer, context, visited);
+	visited.delete(identifierName);
+	return result;
+}
+function findInitializer(context, identifierName) {
+	if (context.initializerCache.has(identifierName)) return context.initializerCache.get(identifierName) ?? null;
+	let found = null;
+	const stack = [context.rootNode];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (node.kind() === "variable_declarator") {
+			if (node.field("name")?.text() === identifierName) {
+				const valueNode = node.field("value");
+				if (valueNode) {
+					found = valueNode;
+					break;
+				}
+			}
+		}
+		stack.push(...node.children());
+	}
+	context.initializerCache.set(identifierName, found);
+	return found;
+}
+function getFirstNamedChild(node) {
+	for (const child of node.children()) if (child.isNamed()) return child;
+	return null;
+}
+
+//#endregion
+//#region src/server/controller/usage.ts
+/** 源码扩展名集合，用于判断文件变更是否需要触发增量更新 */
+const SOURCE_EXTENSIONS$1 = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".vue"
+]);
+let _cache = null;
+let _scanPromise = null;
+/**
+* 获取或初始化缓存。
+* 多个并发请求只会触发一次扫描（Promise 去重）。
+*/
+async function getOrCreateCache(projectRoot) {
+	if (_cache) return _cache;
+	if (_scanPromise) return _scanPromise;
+	_scanPromise = (async () => {
+		const stats = await scanUsageStats(projectRoot, functions, components);
+		_cache = {
+			stats,
+			fileHits: buildFileHitsIndex(stats),
+			timestamp: Date.now()
+		};
+		_scanPromise = null;
+		return _cache;
+	})();
+	return _scanPromise;
+}
+/**
+* 从扫描结果构建 "文件 → 命中" 索引，用于增量更新时快速清除旧数据。
+*/
+function buildFileHitsIndex(stats) {
+	const map = /* @__PURE__ */ new Map();
+	for (const item of stats.functions) for (const loc of item.locations) {
+		if (!map.has(loc.file)) map.set(loc.file, {
+			functions: /* @__PURE__ */ new Map(),
+			components: /* @__PURE__ */ new Map()
 		});
-	} catch {
-		return 0;
+		const entry = map.get(loc.file);
+		entry.functions.set(item.name, (entry.functions.get(item.name) ?? 0) + 1);
 	}
-	for (const entry of entries) {
-		const name = String(entry.name);
-		if (entry.isSymbolicLink()) continue;
-		if (entry.isDirectory()) {
-			if (IGNORED_DIRECTORIES.has(name)) continue;
-			total += await countFiles(join(root, name));
-		} else if (entry.isFile()) total += 1;
+	for (const item of stats.components) for (const loc of item.locations) {
+		if (!map.has(loc.file)) map.set(loc.file, {
+			functions: /* @__PURE__ */ new Map(),
+			components: /* @__PURE__ */ new Map()
+		});
+		const entry = map.get(loc.file);
+		entry.components.set(item.name, (entry.components.get(item.name) ?? 0) + 1);
+	}
+	return map;
+}
+/**
+* 增量更新：当单个文件发生变更时，只重新扫描该文件。
+*
+* 流程：
+* 1. 从缓存中清除该文件的旧贡献值。
+* 2. 重新扫描该文件。
+* 3. 把新结果合并回缓存。
+*/
+async function incrementalUpdate(filePath) {
+	if (!_cache) return;
+	const ext = extname(filePath);
+	if (!SOURCE_EXTENSIONS$1.has(ext)) return;
+	const { stats, fileHits } = _cache;
+	const oldEntry = fileHits.get(filePath);
+	if (oldEntry) {
+		for (const [name, count] of oldEntry.functions) {
+			const item = stats.functions.find((f) => f.name === name);
+			if (item) {
+				item.count -= count;
+				item.locations = item.locations.filter((loc) => loc.file !== filePath);
+			}
+		}
+		for (const [name, count] of oldEntry.components) {
+			const item = stats.components.find((c) => c.name === name);
+			if (item) {
+				item.count -= count;
+				item.locations = item.locations.filter((loc) => loc.file !== filePath);
+			}
+		}
+		fileHits.delete(filePath);
+	}
+	const result = await scanSingleFile(filePath, functions, components);
+	if (!result) return;
+	const newEntry = {
+		functions: /* @__PURE__ */ new Map(),
+		components: /* @__PURE__ */ new Map()
+	};
+	for (const [name, locations] of result.functions) {
+		const item = stats.functions.find((f) => f.name === name);
+		if (item) {
+			item.locations.push(...locations);
+			item.count += locations.length;
+		}
+		newEntry.functions.set(name, locations.length);
+	}
+	for (const [name, locations] of result.components) {
+		const item = stats.components.find((c) => c.name === name);
+		if (item) {
+			item.locations.push(...locations);
+			item.count += locations.length;
+		}
+		newEntry.components.set(name, locations.length);
+	}
+	if (newEntry.functions.size > 0 || newEntry.components.size > 0) fileHits.set(filePath, newEntry);
+	_cache.timestamp = Date.now();
+}
+/**
+* 增量删除：当文件被删除时，清除其贡献。
+*/
+async function incrementalRemove(filePath) {
+	if (!_cache) return;
+	const { stats, fileHits } = _cache;
+	const oldEntry = fileHits.get(filePath);
+	if (!oldEntry) return;
+	for (const [name, count] of oldEntry.functions) {
+		const item = stats.functions.find((f) => f.name === name);
+		if (item) {
+			item.count -= count;
+			item.locations = item.locations.filter((loc) => loc.file !== filePath);
+		}
+	}
+	for (const [name, count] of oldEntry.components) {
+		const item = stats.components.find((c) => c.name === name);
+		if (item) {
+			item.count -= count;
+			item.locations = item.locations.filter((loc) => loc.file !== filePath);
+		}
+	}
+	fileHits.delete(filePath);
+	_cache.timestamp = Date.now();
+}
+/**
+* 将 PascalCase/CamelCase 名称转换为 kebab-case（用于搜索匹配）
+*/
+function toKebabCase(name) {
+	return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+/**
+* 获取 Overview 数据
+* 返回项目中实际使用的 functions 和 components（仅 count > 0）
+*/
+async function getOverview(projectRoot) {
+	const stats = (await getOrCreateCache(projectRoot)).stats;
+	const apiMethodCount = (await getRequestList(projectRoot)).modules.reduce((total, module) => {
+		return total + module.functions.length;
+	}, 0);
+	const moduleCount = countRegisteredModules(projectRoot);
+	return {
+		functions: stats.functions.filter((item) => item.count > 0),
+		components: stats.components.filter((item) => item.count > 0),
+		totalFiles: stats.totalFiles,
+		scannedFiles: stats.scannedFiles,
+		apiMethodCount,
+		moduleCount
+	};
+}
+/**
+* 获取完整的使用统计数据
+* 返回所有追踪项的使用情况（包括未使用的 count = 0）
+*/
+async function getUsageStats(projectRoot) {
+	return (await getOrCreateCache(projectRoot)).stats;
+}
+/**
+* 获取组件使用详情，附带统计摘要
+*/
+async function getComponentUsage(projectRoot) {
+	const componentsWithMeta = (await getOrCreateCache(projectRoot)).stats.components.map((component) => {
+		const dependents = Array.from(new Set(component.locations.map((location) => location.file))).sort();
+		const componentFilePath = component.locations[0]?.file;
+		return {
+			...component,
+			pascalName: component.name,
+			kebabName: toKebabCase(component.name),
+			filePath: componentFilePath,
+			dependents,
+			dependencies: []
+		};
+	});
+	const used = componentsWithMeta.filter((item) => item.count > 0).length;
+	return {
+		components: componentsWithMeta,
+		stats: {
+			total: componentsWithMeta.length,
+			used,
+			unused: componentsWithMeta.length - used
+		}
+	};
+}
+/**
+* 获取 Import/Hook 使用详情，附带统计摘要
+*/
+async function getImportUsage(projectRoot) {
+	const importsWithMeta = (await getOrCreateCache(projectRoot)).stats.functions.map((importItem) => {
+		const dependents = Array.from(new Set(importItem.locations.map((location) => location.file))).sort();
+		const importFilePath = importItem.locations[0]?.file;
+		return {
+			...importItem,
+			camelName: importItem.name,
+			filePath: importFilePath,
+			dependents
+		};
+	});
+	const used = importsWithMeta.filter((item) => item.count > 0).length;
+	return {
+		imports: importsWithMeta,
+		stats: {
+			total: importsWithMeta.length,
+			used,
+			unused: importsWithMeta.length - used
+		}
+	};
+}
+
+//#endregion
+//#region src/server/controller/version.ts
+/**
+* 从 node_modules 中查找实际安装的包版本
+* 这比从 package.json 读取更准确，因为反映了实际安装的版本
+*/
+function findPackageVersion(root, packageName) {
+	try {
+		const nodeModulesPath = join(root, "node_modules", packageName, "package.json");
+		if (!existsSync(nodeModulesPath)) {
+			const parentNodeModulesPath = join(root, "..", "node_modules", packageName, "package.json");
+			if (!existsSync(parentNodeModulesPath)) return null;
+			return JSON.parse(readFileSync(parentNodeModulesPath, "utf-8")).version || null;
+		}
+		return JSON.parse(readFileSync(nodeModulesPath, "utf-8")).version || null;
+	} catch (error) {
+		console.error(`Error reading package version from node_modules: ${error}`);
+		return null;
+	}
+}
+/**
+* 从 fast-npm-meta 服务获取包的最新版本
+*/
+async function fetchLatestVersion(packageName) {
+	try {
+		const response = await fetch(`https://npm.elonehoo.cn/${packageName}`);
+		if (!response.ok) {
+			console.error(`Failed to fetch package info: ${response.status} ${response.statusText}`);
+			return null;
+		}
+		return (await response.json()).version || null;
+	} catch (error) {
+		console.error(`Error fetching latest version from npm meta service: ${error}`);
+		return null;
+	}
+}
+/**
+* 比较两个语义化版本号
+* 返回 true 如果 current 版本低于 latest 版本
+*/
+function isOutdated(current, latest) {
+	if (!current || !latest) return false;
+	try {
+		const currentParts = current.split(".").map(Number);
+		const latestParts = latest.split(".").map(Number);
+		for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
+			const currentPart = currentParts[i] || 0;
+			const latestPart = latestParts[i] || 0;
+			if (currentPart < latestPart) return true;
+			if (currentPart > latestPart) return false;
+		}
+		return false;
+	} catch (error) {
+		console.error(`Error comparing versions: ${error}`);
+		return false;
+	}
+}
+/**
+* 获取包的版本信息
+*/
+async function getPackageVersion(root, packageName) {
+	try {
+		if (!packageName || typeof packageName !== "string") return {
+			packageName: packageName || "",
+			currentVersion: null,
+			latestVersion: null,
+			isOutdated: false,
+			error: "Package name is required"
+		};
+		const currentVersion = findPackageVersion(root, packageName);
+		const latestVersion = await fetchLatestVersion(packageName);
+		return {
+			packageName,
+			currentVersion,
+			latestVersion,
+			isOutdated: isOutdated(currentVersion, latestVersion)
+		};
+	} catch (error) {
+		return {
+			packageName,
+			currentVersion: null,
+			latestVersion: null,
+			isOutdated: false,
+			error: error instanceof Error ? error.message : String(error)
+		};
 	}
-	return total;
 }
 
 //#endregion
@@ -539,47 +2347,137 @@ async function countFiles(root) {
 * 能力概览：
 * - 提供一个轻量 UI（iframe）静态资源服务：`/__pubinfo_devtools`。
 * - 提供 devtools 专用的 API：`/__pubinfo_devtools_api`。
-*   - `/` → 返回项目文件数量（用于示例与健康检查）。
+*   - `/overview` → 返回项目中实际使用的方法和组件。
+*   - `/usage-stats` → 返回完整使用统计。
+*   - `/component-usage` → 返回组件使用详情。
+*   - `/import-usage` → 返回 Import/Hook 使用详情。
 *   - `/api-list` → 返回解析的 OpenAPI 配置与扫描到的 API 函数/类型清单。
+*   - `/package-version` → 返回包版本信息。
+*
+* 性能优化：
+* - 首次请求时执行全量扫描并缓存结果。
+* - 借助 Vite watcher 监听文件变化，仅对变更文件做增量更新。
+* - 所有 API 共享同一份缓存，避免重复扫描。
+* - JSON 响应不做美化格式化（减少 ~30% 体积）。
 *
 * 注意：本插件默认以 `enforce: 'pre'` 注入，避免被其他中间件拦截。
 * 路由均在开发服务器中间件阶段生效，不影响生产构建输出。
 *
 * 安全说明：这些接口仅用于本地开发环境调试，不应暴露到公网。
 */
+/** 源码文件扩展名，与 ast-analyzer 保持一致 */
+const SOURCE_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".vue"
+]);
+function isSourceFile(path) {
+	const dot = path.lastIndexOf(".");
+	return dot !== -1 && SOURCE_EXTENSIONS.has(path.slice(dot));
+}
 function pubinfoDevtools() {
 	return {
-		name: "vite-plugin-client",
+		name: "vite-plugin-pubinfo-devtools",
 		enforce: "pre",
 		configureServer(server) {
 			const baseURL = "__pubinfo_devtools";
+			server.watcher.on("change", (filePath) => {
+				if (isSourceFile(filePath)) incrementalUpdate(filePath).catch(() => {});
+			});
+			server.watcher.on("add", (filePath) => {
+				if (isSourceFile(filePath)) incrementalUpdate(filePath).catch(() => {});
+			});
+			server.watcher.on("unlink", (filePath) => {
+				if (isSourceFile(filePath)) incrementalRemove(filePath).catch(() => {});
+			});
 			server.middlewares.use(`/${baseURL}`, sirv(DIR_CLIENT, {
 				single: true,
 				dev: true
 			}));
 			server.middlewares.use(`/${baseURL}_api`, async (req, res, next) => {
 				if (!req.url) return next();
-				if (req.url === "/") {
-					const info = { count: await countFiles(server.config.root) };
-					res.setHeader("Content-Type", "application/json");
-					res.write(JSON.stringify(info));
-					res.end();
+				if (req.url === "/overview") {
+					try {
+						sendJSON(res, await getOverview(server.config.root));
+					} catch (error) {
+						sendError(res, "Failed to get overview data", error);
+					}
+					return;
+				}
+				if (req.url === "/usage-stats") {
+					try {
+						sendJSON(res, await getUsageStats(server.config.root));
+					} catch (error) {
+						sendError(res, "Failed to get usage statistics", error);
+					}
+					return;
+				}
+				if (req.url === "/component-usage") {
+					try {
+						sendJSON(res, await getComponentUsage(server.config.root));
+					} catch (error) {
+						sendError(res, "Failed to get component usage", error);
+					}
+					return;
+				}
+				if (req.url === "/import-usage") {
+					try {
+						sendJSON(res, await getImportUsage(server.config.root));
+					} catch (error) {
+						sendError(res, "Failed to get import usage", error);
+					}
 					return;
 				}
 				if (req.url.startsWith("/api-list")) {
 					try {
-						const apiList = await getRequestList(server.config.root);
-						res.setHeader("Content-Type", "application/json");
-						res.write(JSON.stringify(apiList, null, 2));
+						sendJSON(res, await getRequestList(server.config.root));
 					} catch (error) {
-						res.statusCode = 500;
-						res.setHeader("Content-Type", "application/json");
-						res.write(JSON.stringify({
-							error: "Failed to get API list",
-							message: error instanceof Error ? error.message : String(error)
-						}));
+						sendError(res, "Failed to get API list", error);
+					}
+					return;
+				}
+				if (req.url.startsWith("/package-version")) {
+					try {
+						const packageName = new URLSearchParams(req.url.slice(16)).get("package") || "";
+						if (!packageName) {
+							res.statusCode = 400;
+							sendJSON(res, {
+								error: "Missing package parameter",
+								message: "Please provide a package name using ?package=<package-name>"
+							});
+							return;
+						}
+						sendJSON(res, await getPackageVersion(server.config.root, packageName));
+					} catch (error) {
+						sendError(res, "Failed to get package version", error);
+					}
+					return;
+				}
+				if (req.url === "/environment-info") {
+					try {
+						sendJSON(res, getEnvironmentInfo(server.config.root));
+					} catch (error) {
+						sendError(res, "Failed to get environment info", error);
+					}
+					return;
+				}
+				if (req.url === "/issue" && req.method === "POST") {
+					try {
+						const chunks = [];
+						req.on("data", (chunk) => chunks.push(chunk));
+						req.on("end", async () => {
+							try {
+								const body = JSON.parse(Buffer.concat(chunks).toString());
+								sendJSON(res, await submitIssue(server.config.root, body));
+							} catch (error) {
+								sendError(res, "Failed to submit issue", error);
+							}
+						});
+					} catch (error) {
+						sendError(res, "Failed to submit issue", error);
 					}
-					res.end();
 					return;
 				}
 				next();
@@ -587,6 +2485,24 @@ function pubinfoDevtools() {
 		}
 	};
 }
+/**
+* 发送 JSON 响应（不做美化，减小体积）
+*/
+function sendJSON(res, data) {
+	res.setHeader("Content-Type", "application/json");
+	res.end(JSON.stringify(data));
+}
+/**
+* 发送 500 错误响应
+*/
+function sendError(res, defaultMessage, error) {
+	res.statusCode = 500;
+	res.setHeader("Content-Type", "application/json");
+	res.end(JSON.stringify({
+		error: defaultMessage,
+		message: error instanceof Error ? error.message : String(error)
+	}));
+}
 
 //#endregion
 export { pubinfoDevtools };