@pubinfo-pr/devtools 0.1.1 → 0.171.2

package/dist/index.js

@@ -1,9 +1,10 @@
-import { t as DIR_CLIENT } from "./dirs-CGtxqpuD.js";
+import { t as DIR_CLIENT } from "./dirs2.js";
 import { basename, dirname, extname, join, relative } from "node:path";
 import { pathToFileURL } from "node:url";
 import sirv from "sirv";
-import { existsSync, readFileSync, statSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { readdir } from "node:fs/promises";
+import { js, ts, tsx } from "@ast-grep/napi";
 
 //#region src/server/controller/api.ts
 const REQUEST_MODULE_EXTENSIONS = [
@@ -191,7 +192,7 @@ async function loadOpenapiConfig(configPath) {
 * @returns 解析得到的 API 函数列表
 */
 function extractApiFunctions(content, filePath, requestClient, requestModulePath, requestModuleResolvedPath) {
-	const functions = [];
+	const functions$1 = [];
 	const functionRegex = /\/\*\*\s*\n([^*]*(?:\*(?!\/)[^*]*)*)\*\/\s*export\s+function\s+(\w+)[^(]*\(([^)]*)\)/g;
 	let match = functionRegex.exec(content);
 	while (match !== null) {
@@ -216,7 +217,7 @@ function extractApiFunctions(content, filePath, requestClient, requestModulePath
 		let returnType;
 		const returnTypeMatch = /R\s*=\s*(API\.\w+)/.exec(params);
 		if (returnTypeMatch) returnType = returnTypeMatch[1];
-		functions.push({
+		functions$1.push({
 			name: functionName,
 			description,
 			url,
@@ -231,7 +232,7 @@ function extractApiFunctions(content, filePath, requestClient, requestModulePath
 		});
 		match = functionRegex.exec(content);
 	}
-	return functions;
+	return functions$1;
 }
 /**
 * 将 TypeScript 类型（字面量对象类型）解析为简化的 JSON Schema 片段。
@@ -395,8 +396,8 @@ async function scanApiDirectory(dir, root, aliasEntries) {
 					module.types.push(...types);
 				}
 			} else if (entry.name !== "index.ts") {
-				const functions = extractApiFunctions(content, relativePath, requestClient, requestModulePath, requestModuleResolvedPath);
-				if (functions.length > 0) {
+				const functions$1 = extractApiFunctions(content, relativePath, requestClient, requestModulePath, requestModuleResolvedPath);
+				if (functions$1.length > 0) {
 					const moduleDir = relative(root, dir);
 					let module = modules.find((m) => m.path === moduleDir);
 					if (!module) {
@@ -407,7 +408,7 @@ async function scanApiDirectory(dir, root, aliasEntries) {
 						};
 						modules.push(module);
 					}
-					if (typingsContent) for (const func of functions) {
+					if (typingsContent) for (const func of functions$1) {
 						if (func.paramType) {
 							const schema = parseTypeToSchema(typingsContent, func.paramType);
 							if (schema) func.paramSchema = schema;
@@ -417,7 +418,7 @@ async function scanApiDirectory(dir, root, aliasEntries) {
 							if (schema) func.returnSchema = schema;
 						}
 					}
-					module.functions.push(...functions);
+					module.functions.push(...functions$1);
 				}
 			}
 		}
@@ -486,49 +487,1174 @@ async function getRequestList(root) {
 }
 
 //#endregion
-//#region src/server/utils/count-files.ts
+//#region src/@data/pubinfo.ts
+const pubinfoImport = [
+	{
+		type: "import",
+		name: "createPubinfoProvider",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "pubinfoInjectionKey",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "createRequest",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "defineIconModule",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "defineRouteModule",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "getAllIconModules",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "getAllRouteModules",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "readProjectModules",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "updateWatermark",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "cleanup",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "cleanupWithoutUser",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "clearPersistedState",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "createContext",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "createRawContext",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "getPersistedState",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "getPubinfoNamespace",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "publicKeyEncryption",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "setPersistedState",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "storage",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "wrapProxy",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "createPubinfo",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "useAuth",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "createLog",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "useError",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "useSuccess",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "useWarn",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "useInfo",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "useStart",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "useBox",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "usePartyLogin",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "useTheme",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "watchDiffObject",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "createPubinfoContext",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "usePubinfoContext",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "defineSystemRoutes",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "getSystemRoutes",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "defineAsyncRoutes",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "getAsyncRoutes",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "defineSettings",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "getSettings",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "useFavoritesStore",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "useIframeStore",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "useKeepAliveStore",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "useMenuStore",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "useRouteStore",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "useSettingsStore",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "useTabbarStore",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "useUserStore",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "formatBackRoutes",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "import",
+		name: "filterEmptyComponentRoutes",
+		package: "pubinfo-pr"
+	}
+];
+const pubinfoComponent = [
+	{
+		type: "component",
+		name: "PubinfoDev",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "component",
+		name: "Copyright",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "component",
+		name: "Layout",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "component",
+		name: "LayoutHeader",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "component",
+		name: "LayoutContent",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "component",
+		name: "LayoutProvider",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "component",
+		name: "LayoutSidebar",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "component",
+		name: "LayoutTopbar",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "component",
+		name: "Logo",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "component",
+		name: "NotAllowed",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "component",
+		name: "Tool",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "component",
+		name: "Tools",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "component",
+		name: "PageHeader",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "component",
+		name: "PageMain",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "component",
+		name: "PartyLoginModal",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "component",
+		name: "PassStrengthValidator",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "component",
+		name: "PubinfoApp",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "component",
+		name: "PubinfoIcon",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "component",
+		name: "PubinfoIconPrismBox",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "component",
+		name: "PubinfoIconSquareBox",
+		package: "pubinfo-pr"
+	},
+	{
+		type: "component",
+		name: "PubinfoProvider",
+		package: "pubinfo-pr"
+	}
+];
+
+//#endregion
+//#region src/@data/vue.ts
+const vueImport = [
+	{
+		type: "import",
+		name: "onActivated",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "onBeforeMount",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "onBeforeUnmount",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "onBeforeUpdate",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "onErrorCaptured",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "onDeactivated",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "onMounted",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "onServerPrefetch",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "onUnmounted",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "onUpdated",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "useAttrs",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "useSlots",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "computed",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "customRef",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "isReadonly",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "isRef",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "isShallow",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "isProxy",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "isReactive",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "markRaw",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "reactive",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "readonly",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "ref",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "shallowReactive",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "shallowReadonly",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "shallowRef",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "triggerRef",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "toRaw",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "toRef",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "toRefs",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "toValue",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "unref",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "watch",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "watchEffect",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "watchPostEffect",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "watchSyncEffect",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "defineComponent",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "defineAsyncComponent",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "getCurrentInstance",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "h",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "inject",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "nextTick",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "provide",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "useCssModule",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "createApp",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "effectScope",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "EffectScope",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "getCurrentScope",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "onScopeDispose",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "onRenderTracked",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "onRenderTriggered",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "resolveComponent",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "useCssVars",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "useModel",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "getCurrentWatcher",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "onWatcherCleanup",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "useId",
+		package: "vue"
+	},
+	{
+		type: "import",
+		name: "useTemplateRef",
+		package: "vue"
+	}
+];
+const vueComponent = [
+	{
+		type: "component",
+		name: "Transition",
+		package: "vue"
+	},
+	{
+		type: "component",
+		name: "TransitionGroup",
+		package: "vue"
+	},
+	{
+		type: "component",
+		name: "KeepAlive",
+		package: "vue"
+	},
+	{
+		type: "component",
+		name: "Teleport",
+		package: "vue"
+	},
+	{
+		type: "component",
+		name: "Suspense",
+		package: "vue"
+	}
+];
+
+//#endregion
+//#region src/@data/index.ts
+const functions = [...vueImport, ...pubinfoImport];
+const components = [...vueComponent, ...pubinfoComponent];
+
+//#endregion
+//#region src/server/utils/ast-analyzer.ts
 /**
-* 在统计项目文件数量时需要忽略的目录。
-* 这些目录通常体积较大或为构建产物，对健康检查意义不大。
+* 递归扫描目录获取所有源文件
 */
-const IGNORED_DIRECTORIES = new Set([
-	".git",
-	"dist",
-	"node_modules"
-]);
+function getAllSourceFiles(dir, extensions = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".vue"
+]) {
+	const files = [];
+	function scan(currentDir) {
+		try {
+			const entries = readdirSync(currentDir);
+			for (const entry of entries) {
+				const fullPath = join(currentDir, entry);
+				try {
+					const stat = statSync(fullPath);
+					if (stat.isDirectory()) {
+						if (![
+							"node_modules",
+							"dist",
+							"build",
+							".git",
+							"coverage",
+							".pubinfo"
+						].includes(entry)) scan(fullPath);
+					} else if (stat.isFile()) {
+						const ext = extname(fullPath);
+						if (extensions.includes(ext)) files.push(fullPath);
+					}
+				} catch (error) {
+					console.warn(`无法访问: ${fullPath}`, error);
+				}
+			}
+		} catch (error) {
+			console.warn(`无法读取目录: ${currentDir}`, error);
+		}
+	}
+	scan(dir);
+	return files;
+}
 /**
-* 递归统计目录下的文件数量。
-*
-* - 忽略符号链接，避免循环引用与跨盘符问题。
-* - 忽略 IGNORED_DIRECTORIES 列表中的目录。
-* - 遇到权限错误/不可读目录时返回 0（宽松模式，不抛错）。
-*
-* 用途：
-* - Devtools 首页/健康检查的一个轻量指标。
+* 根据文件扩展名选择解析器
+*/
+function getParser(filePath) {
+	switch (extname(filePath)) {
+		case ".tsx":
+		case ".jsx": return tsx;
+		case ".js": return js;
+		case ".ts":
+		case ".vue":
+		default: return ts;
+	}
+}
+/**
+* 分析 Vue 组件使用情况
+*/
+function analyzeComponentUsage(content, componentName, filePath) {
+	const locations = [];
+	try {
+		const matches = getParser(filePath).parse(content).root().findAll({ rule: {
+			kind: "jsx_opening_element",
+			pattern: `<${componentName}`
+		} });
+		for (const match of matches) {
+			const range = match.range();
+			locations.push({
+				file: filePath,
+				line: range.start.line + 1,
+				column: range.start.column + 1,
+				code: match.text().slice(0, 100)
+			});
+		}
+	} catch (error) {}
+	if (filePath.endsWith(".vue")) {
+		const templateRegex = new RegExp(`<${componentName}[\\s>]`, "g");
+		const lines = content.split("\n");
+		let match = templateRegex.exec(content);
+		while (match !== null) {
+			const pos = match.index;
+			let lineNum = 0;
+			let charCount = 0;
+			for (let i = 0; i < lines.length; i++) {
+				charCount += lines[i].length + 1;
+				if (charCount > pos) {
+					lineNum = i + 1;
+					break;
+				}
+			}
+			locations.push({
+				file: filePath,
+				line: lineNum,
+				column: pos - (charCount - lines[lineNum - 1].length - 1) + 1,
+				code: lines[lineNum - 1].trim().slice(0, 100)
+			});
+			match = templateRegex.exec(content);
+		}
+	}
+	return locations;
+}
+/**
+* 分析函数/方法使用情况
+*/
+function analyzeFunctionUsage(content, functionName, filePath) {
+	const locations = [];
+	try {
+		const root = getParser(filePath).parse(content);
+		const callMatches = root.root().findAll({ rule: {
+			kind: "call_expression",
+			pattern: `${functionName}($$$)`
+		} });
+		for (const match of callMatches) {
+			const range = match.range();
+			locations.push({
+				file: filePath,
+				line: range.start.line + 1,
+				column: range.start.column + 1,
+				code: match.text().slice(0, 100)
+			});
+		}
+		const importMatches = root.root().findAll({ rule: {
+			kind: "import_specifier",
+			pattern: functionName
+		} });
+		for (const match of importMatches) {
+			const range = match.range();
+			locations.push({
+				file: filePath,
+				line: range.start.line + 1,
+				column: range.start.column + 1,
+				code: match.text()
+			});
+		}
+	} catch (error) {}
+	return locations;
+}
+/**
+* 扫描项目中的使用情况
+* @param projectRoot 项目根目录
+* @param functionsToTrack 要追踪的函数列表
+* @param componentsToTrack 要追踪的组件列表
+*/
+async function scanUsageStats(projectRoot, functionsToTrack, componentsToTrack) {
+	const result = {
+		functions: [],
+		components: [],
+		totalFiles: 0,
+		scannedFiles: 0
+	};
+	const files = getAllSourceFiles(projectRoot);
+	result.totalFiles = files.length;
+	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: []
+	});
+	for (const comp of componentsToTrack) componentStatsMap.set(comp.name, {
+		name: comp.name,
+		type: "component",
+		package: comp.package,
+		count: 0,
+		locations: []
+	});
+	for (const file of files) try {
+		const content = readFileSync(file, "utf-8");
+		result.scannedFiles++;
+		for (const func of functionsToTrack) {
+			const locations = analyzeFunctionUsage(content, func.name, file);
+			if (locations.length > 0) {
+				const stats = functionStatsMap.get(func.name);
+				stats.locations.push(...locations);
+				stats.count += locations.length;
+			}
+		}
+		for (const comp of componentsToTrack) {
+			const locations = analyzeComponentUsage(content, comp.name, file);
+			if (locations.length > 0) {
+				const stats = componentStatsMap.get(comp.name);
+				stats.locations.push(...locations);
+				stats.count += locations.length;
+			}
+		}
+	} catch (error) {
+		console.warn(`无法读取文件: ${file}`, error);
+	}
+	result.functions = Array.from(functionStatsMap.values());
+	result.components = Array.from(componentStatsMap.values());
+	return result;
+}
+
+//#endregion
+//#region src/server/utils/module-counter.ts
+/**
+* 统计项目中通过 createPubinfo 注册的模块数量。
 *
-* @param root 目录绝对路径
-* @returns 统计到的文件总数
+* 解析项目里的所有源文件，查找 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 = getParser(filePath).parse(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
+/**
+* 将 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 statsPromise = scanUsageStats(projectRoot, functions, components);
+	const apiListPromise = getRequestList(projectRoot);
+	const [stats, apiList] = await Promise.all([statsPromise, apiListPromise]);
+	const apiMethodCount = apiList.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 countFiles(root) {
-	let total = 0;
-	let entries;
+async function getUsageStats(projectRoot) {
+	return await scanUsageStats(projectRoot, functions, components);
+}
+/**
+* 获取组件使用详情，附带统计摘要
+*/
+async function getComponentUsage(projectRoot) {
+	const componentsWithMeta = (await getUsageStats(projectRoot)).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
+		}
+	};
+}
+
+//#endregion
+//#region src/server/controller/version.ts
+/**
+* 从 node_modules 中查找实际安装的包版本
+* 这比从 package.json 读取更准确，因为反映了实际安装的版本
+*/
+function findPackageVersion(root, packageName) {
 	try {
-		entries = await readdir(root, {
-			withFileTypes: true,
-			encoding: "utf8"
-		});
-	} catch {
-		return 0;
+		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;
 	}
-	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;
+}
+/**
+* 从 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
@@ -549,7 +1675,7 @@ async function countFiles(root) {
 */
 function pubinfoDevtools() {
 	return {
-		name: "vite-plugin-client",
+		name: "vite-plugin-pubinfo-devtools",
 		enforce: "pre",
 		configureServer(server) {
 			const baseURL = "__pubinfo_devtools";
@@ -559,10 +1685,51 @@ function pubinfoDevtools() {
 			}));
 			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));
+				if (req.url === "/overview") {
+					try {
+						const overview = await getOverview(server.config.root);
+						res.setHeader("Content-Type", "application/json");
+						res.write(JSON.stringify(overview, null, 2));
+					} catch (error) {
+						res.statusCode = 500;
+						res.setHeader("Content-Type", "application/json");
+						res.write(JSON.stringify({
+							error: "Failed to get overview data",
+							message: error instanceof Error ? error.message : String(error)
+						}));
+					}
+					res.end();
+					return;
+				}
+				if (req.url === "/usage-stats") {
+					try {
+						const usageStats = await getUsageStats(server.config.root);
+						res.setHeader("Content-Type", "application/json");
+						res.write(JSON.stringify(usageStats, null, 2));
+					} catch (error) {
+						res.statusCode = 500;
+						res.setHeader("Content-Type", "application/json");
+						res.write(JSON.stringify({
+							error: "Failed to get usage statistics",
+							message: error instanceof Error ? error.message : String(error)
+						}));
+					}
+					res.end();
+					return;
+				}
+				if (req.url === "/component-usage") {
+					try {
+						const componentUsage = await getComponentUsage(server.config.root);
+						res.setHeader("Content-Type", "application/json");
+						res.write(JSON.stringify(componentUsage, null, 2));
+					} catch (error) {
+						res.statusCode = 500;
+						res.setHeader("Content-Type", "application/json");
+						res.write(JSON.stringify({
+							error: "Failed to get component usage",
+							message: error instanceof Error ? error.message : String(error)
+						}));
+					}
 					res.end();
 					return;
 				}
@@ -582,6 +1749,33 @@ function pubinfoDevtools() {
 					res.end();
 					return;
 				}
+				if (req.url.startsWith("/package-version")) {
+					try {
+						const packageName = new URLSearchParams(req.url.slice(16)).get("package") || "";
+						if (!packageName) {
+							res.statusCode = 400;
+							res.setHeader("Content-Type", "application/json");
+							res.write(JSON.stringify({
+								error: "Missing package parameter",
+								message: "Please provide a package name using ?package=<package-name>"
+							}));
+							res.end();
+							return;
+						}
+						const versionInfo = await getPackageVersion(server.config.root, packageName);
+						res.setHeader("Content-Type", "application/json");
+						res.write(JSON.stringify(versionInfo, null, 2));
+					} catch (error) {
+						res.statusCode = 500;
+						res.setHeader("Content-Type", "application/json");
+						res.write(JSON.stringify({
+							error: "Failed to get package version",
+							message: error instanceof Error ? error.message : String(error)
+						}));
+					}
+					res.end();
+					return;
+				}
 				next();
 			});
 		}