autosnippet 1.1.22 → 1.1.23

package/bin/create.js

@@ -61,8 +61,6 @@ async function findTargetRootDir(filePath) {
 			// 检查当前目录是否包含 Code 或 Sources 目录
 			for (const entry of entries) {
 				if (entry.isDirectory() && (entry.name === 'Code' || entry.name === 'Sources')) {
-					// 找到包含 Code 或 Sources 的目录，这就是 target 根目录
-					console.log(`[findTargetRootDir] 找到 target 根目录: ${currentPath} (包含 ${entry.name})`);
 					return currentPath;
 				}
 			}
@@ -82,7 +80,6 @@ async function findTargetRootDir(filePath) {
 		}
 	}
 	
-	console.log(`[findTargetRootDir] 未找到 target 根目录（Code 或 Sources）`);
 	return null;
 }
 
@@ -324,7 +321,6 @@ function readStream(specFile, filePathArr, snippet, isHaveHeader) {
 						// 如果找不到 target 根目录，使用 Package.swift 所在目录作为后备
 						targetRootDir = packageInfo.path;
 					}
-					console.log(`[createCodeSnippets] target 根目录: ${targetRootDir}`);
 					const moduleRoot = targetRootDir;
 
 					// ✅ 查找头文件（适配 SPM 的 include/ModuleName/ 结构）
@@ -332,7 +328,7 @@ function readStream(specFile, filePathArr, snippet, isHaveHeader) {
 					const headerPath = await findPath.findSubHeaderPath(targetRootDir, headerNameWithoutExt, moduleName);
 
 					snippet['{content}'] = codeList;
-					snippet['{specName}'] = moduleName;  // ✅ specName 是 target 名称（如 BDNetworkAPI），不是包名（如 Business）
+					snippet['{specName}'] = moduleName;
 
 					if (headerPath) {
 						// ✅ headName 存储相对于 target 根目录的相对路径
@@ -447,7 +443,7 @@ async function saveFromFile(specFile, snippet) {
 						if (err.code === 'ENOENT') {
 							rootPlaceholder = { list: [] };
 						} else {
-							console.error(`[saveFromFile] 读取根配置文件失败: ${err.message}`);
+							// 忽略错误
 						}
 					}
 					
@@ -475,11 +471,10 @@ async function saveFromFile(specFile, snippet) {
 						// 写入根配置文件
 						const rootContent = JSON.stringify(rootPlaceholder, null, 4);
 						fs.writeFileSync(rootSpecFile, rootContent, 'utf8');
-						console.log(`[saveFromFile] 已同步 snippet 到根目录配置文件: ${rootSpecFile}`);
 					}
 				}
 			} catch (err) {
-				console.error(`[saveFromFile] 同步到根配置文件失败: ${err.message}`);
+					// 忽略错误
 			}
 			
 			// ✅ 只写入刚创建的单个代码片段

package/bin/findPath.js

@@ -12,9 +12,6 @@ const README_NAME = 'readme.md';
 const directoryCache = new Map();
 const CACHE_TTL = 60000; // 缓存 60 秒
 
-/**
- * 获取目录内容（带缓存）
- */
 async function getDirectoryEntries(dirPath) {
 	const cacheKey = path.resolve(dirPath);
 	
@@ -23,15 +20,11 @@ async function getDirectoryEntries(dirPath) {
 	try {
 		const stats = await fs.promises.stat(dirPath);
 		if (stats.isFile()) {
-			// 如果是文件，清除可能的错误缓存，然后返回 null
-			console.log(`[getDirectoryEntries] 路径是文件，返回 null: ${dirPath}`);
 			directoryCache.delete(cacheKey);
 			return null;
 		}
 	} catch (err) {
-		// 如果 stat 失败，可能是路径不存在或其他错误，继续处理
-		// 如果是 ENOTDIR，会在下面的 readdir 中被捕获
-		console.log(`[getDirectoryEntries] stat 失败: ${dirPath}, 错误: ${err.code || err.message}`);
+		// 继续
 	}
 	
 	const cached = directoryCache.get(cacheKey);
@@ -41,12 +34,10 @@ async function getDirectoryEntries(dirPath) {
 	}
 	
 	try {
-		console.log(`[getDirectoryEntries] 尝试读取目录: ${dirPath}`);
 		const entries = await fs.promises.readdir(dirPath, {
-			withFileTypes: true  // 返回 Dirent 对象，减少 stat 调用
+			withFileTypes: true
 		});
 		
-		// 清理过期缓存（保持缓存大小合理）
 		if (directoryCache.size > 1000) {
 			const now = Date.now();
 			for (const [key, value] of directoryCache.entries()) {
@@ -63,19 +54,13 @@ async function getDirectoryEntries(dirPath) {
 		
 		return entries;
 	} catch (err) {
-		// ✅ 处理各种文件系统错误
-		console.log(`[getDirectoryEntries] readdir 失败: ${dirPath}, 错误: ${err.code || err.message}`);
 		if (err.code === 'ENOENT' || err.code === 'EACCES' || err.code === 'ENOTDIR') {
-			return null;  // 路径不存在、权限不足或不是目录
+			return null;
 		}
 		throw err;
 	}
 }
 
-/**
- * 检测是否为工程根目录
- * 通过查找常见的工程根目录标记来判断
- */
 function isProjectRoot(dirPath, entries) {
 	if (!entries) {
 		return false;
@@ -83,24 +68,17 @@ function isProjectRoot(dirPath, entries) {
 	
 	// 工程根目录标记（按优先级）
 	const rootMarkers = [
-		'.git',              // Git 仓库根目录
-		PACKAGE_SWIFT,       // SPM 项目根目录
-		'.xcodeproj',        // Xcode 项目根目录
-		'.xcworkspace',      // Xcode 工作空间根目录
-		'Podfile',           // CocoaPods 项目根目录
-		'.swiftpm',          // Swift Package Manager 元数据目录
+		'.git',
+		PACKAGE_SWIFT,
+		'.xcodeproj',
+		'.xcworkspace',
+		'Podfile',
+		'.swiftpm',
 	];
 	
 	for (const entry of entries) {
 		const name = entry.name;
-		
-		// 检查文件标记
-		if (entry.isFile() && rootMarkers.includes(name)) {
-			return true;
-		}
-		
-		// 检查目录标记（.git 可能是目录）
-		if (entry.isDirectory() && rootMarkers.includes(name)) {
+		if (rootMarkers.includes(name) && (entry.isFile() || entry.isDirectory())) {
 			return true;
 		}
 	}
@@ -108,55 +86,29 @@ function isProjectRoot(dirPath, entries) {
 	return false;
 }
 
-// 向上查找AutoSnippet配置文件（优化：找到配置文件后，继续向上查找直到找到工程根目录）
-async function findASSpecPathAsync(filePath) {
-	let configPath = null;
-	let configDir = null;
+async function searchUpwardForFile(filePath, fileName) {
 	let currentPath = path.resolve(filePath);
-	const maxLevels = 20; // 安全限制：最多向上查找 20 层
+	const maxLevels = 20;
 	let levelsChecked = 0;
 	
 	while (currentPath && levelsChecked < maxLevels) {
 		try {
 			const entries = await getDirectoryEntries(currentPath);
-			
-			// 查找 AutoSnippet.boxspec.json
 			if (entries) {
 				for (const entry of entries) {
-					if (entry.isFile() && entry.name === HOLDER_NAME) {
-						if (!configPath) {
-							// 第一次找到配置文件
-							configPath = path.join(currentPath, entry.name);
-							configDir = currentPath;
-						}
+					if (entry.isFile() && entry.name === fileName) {
+						return path.join(currentPath, entry.name);
 					}
 				}
 			}
 			
-			// 如果已经找到配置文件，检查是否到达工程根目录
-			if (configPath) {
-				// 如果在配置文件所在目录或以上发现了工程根目录标记，停止查找
-				if (isProjectRoot(currentPath, entries)) {
-					return configPath;
-				}
-				
-				// 如果已经向上查找了，但没有找到工程根目录标记，继续查找
-				if (path.resolve(currentPath) !== configDir) {
-					// 当前目录不是配置文件所在目录，继续向上查找
-				}
-			}
-			
-			// 继续向上查找
 			const parentPath = path.dirname(currentPath);
 			if (parentPath === currentPath) {
-				// 已到达根目录
 				break;
 			}
 			currentPath = parentPath;
 			levelsChecked++;
-			
 		} catch (err) {
-			// 错误处理：权限错误继续查找
 			if (err.code === 'ENOENT' || err.code === 'EACCES') {
 				const parentPath = path.dirname(currentPath);
 				if (parentPath === currentPath) {
@@ -166,18 +118,22 @@ async function findASSpecPathAsync(filePath) {
 				levelsChecked++;
 				continue;
 			}
-			// 其他错误，抛出
 			throw err;
 		}
 	}
 	
-	// 如果找到配置文件，返回它（即使没有找到明确的工程根目录）
-	return configPath || null;
+	return null;
+}
+
+async function findASSpecPathAsync(filePath) {
+	const holderPath = await searchUpwardForFile(filePath, HOLDER_NAME);
+	if (holderPath) {
+		return holderPath;
+	}
+	
+	return await searchUpwardForFile(filePath, ROOT_MARKER_NAME);
 }
 
-/**
- * 同步版本：检测是否为工程根目录
- */
 function isProjectRootSync(dirPath, files) {
 	if (!files || files.length === 0) {
 		return false;
@@ -185,17 +141,15 @@ function isProjectRootSync(dirPath, files) {
 	
 	// 工程根目录标记（按优先级）
 	const rootMarkers = [
-		'.git',              // Git 仓库根目录
-		PACKAGE_SWIFT,       // SPM 项目根目录
-		'.xcodeproj',        // Xcode 项目根目录
-		'.xcworkspace',      // Xcode 工作空间根目录
-		'Podfile',           // CocoaPods 项目根目录
+		'.git',
+		PACKAGE_SWIFT,
+		'.xcodeproj',
+		'.xcworkspace',
+		'Podfile',
 	];
 	
-	// 检查文件名
 	for (const filename of files) {
 		if (rootMarkers.includes(filename)) {
-			// 检查是否为文件或目录
 			try {
 				const filePath = path.join(dirPath, filename);
 				const stats = fs.lstatSync(filePath);
@@ -203,7 +157,7 @@ function isProjectRootSync(dirPath, files) {
 					return true;
 				}
 			} catch (err) {
-				// 忽略错误，继续检查
+				// 继续检查
 			}
 		}
 	}
@@ -211,45 +165,35 @@ function isProjectRootSync(dirPath, files) {
 	return false;
 }
 
-// 向上查找AutoSnippet配置文件（保留回调版本，兼容现有代码）
 function findASSpecPath(filePath, callback, configPath, configDir) {
-	// 初始化参数
 	if (configPath === undefined) configPath = null;
 	if (configDir === undefined) configDir = null;
 	
-	const maxLevels = 20; // 安全限制：最多向上查找 20 层
+	const maxLevels = 20;
 	let levelsChecked = 0;
 	
 	function search(currentPath, foundConfigPath, foundConfigDir, level) {
 		if (level >= maxLevels) {
 			if (foundConfigPath) {
 				callback(foundConfigPath);
-			} else {
-				console.log('未找到 AutoSnippet.boxspec.json 文件，请检查路径。');
 			}
 			return;
 		}
 
 		fs.readdir(currentPath, function (err, files) {
 			if (err) {
-				// 错误处理：权限错误继续查找
 				if (err.code === 'ENOENT' || err.code === 'EACCES') {
 					const parentPath = path.join(currentPath, '/..');
 					const parentResolvedPath = path.resolve(parentPath);
 					
-					// 如果已经到达根目录，停止查找
 					if (parentResolvedPath === path.resolve(currentPath)) {
 						if (foundConfigPath) {
 							callback(foundConfigPath);
-		} else {
-							console.log('未找到 AutoSnippet.boxspec.json 文件，请检查路径。');
 						}
 						return;
 					}
 					
 					search(parentPath, foundConfigPath, foundConfigDir, level + 1);
-				} else {
-			console.log(err);
 				}
 			return;
 		}
@@ -258,41 +202,32 @@ function findASSpecPath(filePath, callback, configPath, configDir) {
 			let currentConfigPath = foundConfigPath;
 			let currentConfigDir = foundConfigDir;
 			
-			// 查找 AutoSnippet.boxspec.json
-        files.forEach(function (filename) {
-			if (filename === HOLDER_NAME) {
+			files.forEach(function (filename) {
+				if (filename === HOLDER_NAME) {
 					isFound = true;
 					if (!currentConfigPath) {
-						// 第一次找到配置文件，记录路径（不立即调用回调）
 						currentConfigPath = path.join(currentPath, filename);
 						currentConfigDir = path.resolve(currentPath);
-                }
-			}
-        });
+					}
+				}
+			});
 
-			// 如果已经找到配置文件，检查是否到达工程根目录
 			if (currentConfigPath) {
-				// 如果在配置文件所在目录或以上发现了工程根目录标记，停止查找并调用回调
 				if (isProjectRootSync(currentPath, files)) {
 					callback(currentConfigPath);
-			return;
-		}
+					return;
+				}
 			}
 
-			// 继续向上查找
 			const parentPath = path.join(currentPath, '/..');
 			const parentResolvedPath = path.resolve(parentPath);
 			
-			// 如果已经到达根目录，停止查找
 			if (parentResolvedPath === path.resolve(currentPath)) {
-				// 如果找到了配置文件，即使没找到工程根目录标记，也调用回调
 				if (currentConfigPath) {
 					callback(currentConfigPath);
-				} else {
-					console.log('未找到 AutoSnippet.boxspec.json 文件，请检查路径。');
 				}
-			return;
-		}
+				return;
+			}
 
 			search(parentPath, currentConfigPath, currentConfigDir, level + 1);
 		});
@@ -301,7 +236,6 @@ function findASSpecPath(filePath, callback, configPath, configDir) {
 	search(filePath, configPath, configDir, 0);
 }
 
-// 向上查找 Package.swift 文件（SPM 模块规范文件）
 async function findPackageSwiftPath(filePath) {
 	let currentPath = path.resolve(filePath);
 	
@@ -317,14 +251,12 @@ async function findPackageSwiftPath(filePath) {
 				continue;
 			}
 			
-			// 查找 Package.swift 文件
 			for (const entry of entries) {
 				if (entry.isFile() && entry.name === PACKAGE_SWIFT) {
 					return path.join(currentPath, entry.name);
 				}
 			}
 			
-			// 继续向上查找
 			const parentPath = path.dirname(currentPath);
 			if (parentPath === currentPath) {
 				break;
@@ -347,14 +279,9 @@ async function findPackageSwiftPath(filePath) {
 	return null;
 }
 
-/**
- * 解析 Package.swift 文件，提取模块信息
- */
 async function parsePackageSwift(packagePath) {
 	try {
 		const content = await fs.promises.readFile(packagePath, 'utf8');
-		
-		// 简单解析 Package.swift（实际可以使用 Swift AST 解析器）
 		const packageNameMatch = content.match(/name:\s*"([^"]+)"/);
 		const targetsMatch = content.match(/\.target\s*\([^)]+name:\s*"([^"]+)"/g);
 		
@@ -376,31 +303,24 @@ async function parsePackageSwift(packagePath) {
 			path: path.dirname(packagePath)
 		};
 	} catch (err) {
-		console.error('Error parsing Package.swift:', err);
 		return null;
 	}
 }
 
-// 向下查找模块头文件（优化：适配 SPM 结构，优先查找 include/ModuleName/ 目录）
 async function findSubHeaderPath(filePath, headerName, moduleName) {
-	// ✅ 优先查找 Code/ 目录（实际源代码位置）
-	// 按照用户期望的顺序：target根目录 → Code → 子文件夹/头文件
 	const codePath = path.join(filePath, 'Code');
 	try {
 		const stats = await fs.promises.stat(codePath);
 		if (stats.isDirectory()) {
-			// 在 Code 目录中递归查找头文件
 			const result = await findSubHeaderPath(codePath, headerName, null);
 			if (result) {
 				return result;
 			}
 		}
 	} catch {
-		// Code 目录不存在，继续查找
+		// 继续查找
 	}
 	
-	// ✅ 降级：查找 include/ModuleName/ 目录（SPM 公共头文件结构）
-	// 注意：include/ 目录通常是符号链接，但作为后备方案保留
 	if (moduleName) {
 		const includePath = path.join(filePath, 'include', moduleName);
 		try {
@@ -411,15 +331,14 @@ async function findSubHeaderPath(filePath, headerName, moduleName) {
 					await fs.promises.access(headerPath);
 					return headerPath;
 				} catch {
-					// 头文件不存在，继续查找
+					// 继续查找
 				}
 			}
 		} catch {
-			// include 目录不存在，继续查找
+			// 继续查找
 		}
 	}
 	
-	// ✅ 最后：在整个模块目录中查找（深度限制）
 	try {
 		const entries = await getDirectoryEntries(filePath);
 		if (!entries) {
@@ -430,7 +349,6 @@ async function findSubHeaderPath(filePath, headerName, moduleName) {
 			if (entry.isFile() && entry.name === `${headerName}.h`) {
 				return path.join(filePath, entry.name);
 			} else if (entry.isDirectory()) {
-				// 跳过 node_modules、.git 等目录
 				if (entry.name.startsWith('.') || entry.name === 'node_modules') {
 					continue;
 				}
@@ -442,56 +360,36 @@ async function findSubHeaderPath(filePath, headerName, moduleName) {
 			}
 		}
 	} catch (err) {
-		console.error(err);
+		// 忽略错误
 	}
 	
 	return null;
 }
 
-// 向下查找AutoSnippet配置文件（优化：异步 I/O）
 async function findSubASSpecPath(filePath) {
-	console.log(`[findSubASSpecPath] 开始查找，传入路径: ${filePath}`);
 	let resultArray = [];
 
 	try {
-		// ✅ 确保 filePath 是目录路径，而不是文件路径
-		// 如果传入的是文件路径，获取其所在目录
 		let dirPath = filePath;
 		
-		// 首先检查路径是否存在，并确定是文件还是目录
 		try {
 			const stats = await fs.promises.stat(filePath);
 			if (stats.isFile()) {
-				// 如果是文件，使用其所在目录
 				dirPath = path.dirname(filePath);
-				console.log(`[findSubASSpecPath] 检测到文件路径，转换为目录: ${filePath} -> ${dirPath}`);
 			} else if (!stats.isDirectory()) {
-				// 既不是文件也不是目录，直接返回空数组
-				console.log(`[findSubASSpecPath] 路径既不是文件也不是目录，返回空数组: ${filePath}`);
 				return resultArray;
 			}
 		} catch (err) {
-			console.log(`[findSubASSpecPath] stat 失败: ${filePath}, 错误: ${err.code || err.message}`);
-			// 如果 stat 失败（路径不存在、权限错误等），尝试使用 dirname
 			if (err.code === 'ENOENT' || err.code === 'EACCES') {
-				// 如果路径看起来像文件路径（包含文件名），尝试使用 dirname
 				if (path.basename(filePath) === HOLDER_NAME || path.extname(filePath) !== '') {
 					dirPath = path.dirname(filePath);
-					console.log(`[findSubASSpecPath] 根据路径特征转换为目录: ${filePath} -> ${dirPath}`);
 				} else {
-					// 可能是目录路径，但不存在，直接返回空数组
-					console.log(`[findSubASSpecPath] 路径不存在，返回空数组: ${filePath}`);
 					return resultArray;
 				}
 			} else {
-				// 其他错误，直接返回空数组
-				console.log(`[findSubASSpecPath] stat 错误，返回空数组: ${filePath}, 错误: ${err.code || err.message}`);
 				return resultArray;
 			}
 		}
-
-		// ✅ 再次确认 dirPath 是目录（防止 ENOTDIR 错误）
-		console.log(`[findSubASSpecPath] 调用 getDirectoryEntries: ${dirPath}`);
 		const entries = await getDirectoryEntries(dirPath);
 		if (!entries) {
 			return resultArray;
@@ -501,7 +399,6 @@ async function findSubASSpecPath(filePath) {
 			if (entry.isFile() && entry.name === HOLDER_NAME) {
 				resultArray.push(path.join(dirPath, entry.name));
 			} else if (entry.isDirectory()) {
-				// 跳过 node_modules、.git 等目录
 				if (entry.name.startsWith('.') || entry.name === 'node_modules') {
 					continue;
 				}
@@ -511,187 +408,34 @@ async function findSubASSpecPath(filePath) {
 			}
 		}
 	} catch (err) {
-		// ✅ 忽略 ENOTDIR 错误（传入的是文件路径）和其他文件系统错误
 		if (err.code !== 'ENOTDIR') {
-			console.log(err);
+			// 忽略错误
 		}
 	}
 	
 	return resultArray;
 }
 
-/**
- * 向上查找项目根目录（查找 AutoSnippetRoot.boxspec.json 文件）
- * @param {string} filePath - 起始文件路径或目录路径
- * @returns {Promise<string|null>} 项目根目录路径（AutoSnippetRoot.boxspec.json 所在目录），如果找不到返回 null
- */
 async function findProjectRoot(filePath) {
-	console.log(`[findProjectRoot] 开始查找，传入路径: ${filePath}`);
-	// ✅ 简化逻辑：向上查找 AutoSnippetRoot.boxspec.json 文件
-	let currentPath = path.resolve(filePath);
+	let startPath = path.resolve(filePath);
 	
-	// 检查路径是文件还是目录
 	try {
-		const stats = await fs.promises.stat(currentPath);
+		const stats = await fs.promises.stat(startPath);
 		if (stats.isFile()) {
-			// 如果是文件，使用其所在目录
-			currentPath = path.dirname(currentPath);
-			console.log(`[findProjectRoot] 检测到文件路径，转换为目录: ${filePath} -> ${currentPath}`);
+			startPath = path.dirname(startPath);
 		}
 	} catch (err) {
-		console.log(`[findProjectRoot] stat 失败: ${currentPath}, 错误: ${err.code || err.message}`);
-		// 如果 stat 失败，假设是目录路径，或者使用 dirname 作为后备
 		if (err.code === 'ENOENT' || err.code === 'EACCES') {
-			// 如果路径看起来像文件路径，使用 dirname
 			if (path.basename(filePath).includes('.') || path.extname(filePath) !== '') {
-				currentPath = path.dirname(currentPath);
-			}
-		}
-		// 其他错误继续处理，可能是目录路径
-	}
-	
-	const maxLevels = 20;
-	let levelsChecked = 0;
-	
-	while (currentPath && levelsChecked < maxLevels) {
-		try {
-			// ✅ 查找 AutoSnippetRoot.boxspec.json 文件
-			const rootMarkerPath = path.join(currentPath, ROOT_MARKER_NAME);
-			try {
-				const stats = await fs.promises.stat(rootMarkerPath);
-				if (stats.isFile()) {
-					console.log(`[findProjectRoot] 找到根目录标记文件: ${rootMarkerPath}`);
-					return currentPath;
-				}
-			} catch (err) {
-				// 文件不存在，继续向上查找
-			}
-			
-			const parentPath = path.dirname(currentPath);
-			if (parentPath === currentPath) {
-				break;
-			}
-			currentPath = parentPath;
-			levelsChecked++;
-		} catch (err) {
-			// ✅ 处理各种文件系统错误
-			if (err.code === 'ENOENT' || err.code === 'EACCES' || err.code === 'ENOTDIR') {
-				const parentPath = path.dirname(currentPath);
-				if (parentPath === currentPath) {
-					break;
-				}
-				currentPath = parentPath;
-				levelsChecked++;
-				continue;
+				startPath = path.dirname(startPath);
 			}
-			throw err;
 		}
 	}
 	
-	console.log(`[findProjectRoot] 未找到根目录标记文件 ${ROOT_MARKER_NAME}`);
-	return null;
-}
-
-/**
- * 从项目根目录找到模块，并返回模块名和头文件名
- * @param {string} projectRoot - 项目根目录
- * @param {string} specName - 模块名（target 名称）
- * @param {string} headName - 头文件相对路径（相对于模块根目录）
- * @returns {Promise<{moduleName: string, headerFileName: string}|null>}
- */
-async function findModuleHeaderFromRoot(projectRoot, specName, headName) {
-	if (!projectRoot || !specName || !headName) {
-		return null;
-	}
-	
-	// 从项目根目录向下查找包含 specName 的目录（可能是模块目录）
-	// 例如：BDVideoPlayer、UI/BDVideoPlayer 等
-	const headerFileName = path.basename(headName);
-	
-	// 尝试在项目根目录下查找模块目录
-	// 1. 直接查找 specName 目录
-	const directModulePath = path.join(projectRoot, specName);
-	try {
-		const entries = await getDirectoryEntries(directModulePath);
-		if (entries) {
-			// 检查是否有 include/ModuleName/ 目录
-			const includePath = path.join(directModulePath, 'include', specName, headerFileName);
-			try {
-				await fs.promises.access(includePath);
-				return {
-					moduleName: specName,
-					headerFileName: headerFileName
-				};
-			} catch (err) {
-				// 继续查找
-			}
-		}
-	} catch (err) {
-		// 继续查找
-	}
-	
-	// 2. 递归查找包含 specName 的目录
-	const foundModule = await findModuleDirectory(projectRoot, specName, headerFileName);
-	if (foundModule) {
-		return foundModule;
-	}
-	
-	// 如果找不到，返回默认值（使用 specName 和 headerFileName）
-	return {
-		moduleName: specName,
-		headerFileName: headerFileName
-	};
-}
-
-/**
- * 递归查找模块目录
- */
-async function findModuleDirectory(dirPath, moduleName, headerFileName) {
-	try {
-		const entries = await getDirectoryEntries(dirPath);
-		if (!entries) {
-			return null;
-		}
-		
-		for (const entry of entries) {
-			if (entry.isDirectory()) {
-				const dirName = entry.name;
-				// 跳过隐藏目录和常见目录
-				if (dirName.startsWith('.') || dirName === 'node_modules') {
-					continue;
-				}
-				
-				const fullPath = path.join(dirPath, dirName);
-				
-				// 检查是否是模块目录（包含 include/ModuleName/ 结构）
-				const includePath = path.join(fullPath, 'include', moduleName, headerFileName);
-				try {
-					await fs.promises.access(includePath);
-					return {
-						moduleName: moduleName,
-						headerFileName: headerFileName
-					};
-				} catch (err) {
-					// 继续递归查找
-					const found = await findModuleDirectory(fullPath, moduleName, headerFileName);
-					if (found) {
-						return found;
-					}
-				}
-			}
-		}
-	} catch (err) {
-		// 忽略错误
-	}
-	
-	return null;
+	const rootMarkerPath = await searchUpwardForFile(startPath, ROOT_MARKER_NAME);
+	return rootMarkerPath ? path.dirname(rootMarkerPath) : null;
 }
 
-/**
- * 获取根目录的 AutoSnippetRoot.boxspec.json 文件路径
- * @param {string} filePath - 起始文件路径或目录路径
- * @returns {Promise<string|null>} 根目录的 AutoSnippetRoot.boxspec.json 文件路径，如果找不到返回 null
- */
 async function getRootSpecFilePath(filePath) {
 	const projectRoot = await findProjectRoot(filePath);
 	if (!projectRoot) {
@@ -699,12 +443,10 @@ async function getRootSpecFilePath(filePath) {
 	}
 	const rootSpecFile = path.join(projectRoot, ROOT_MARKER_NAME);
 	
-	// 检查文件是否存在，如果不存在则创建
 	try {
 		await fs.promises.access(rootSpecFile);
 	} catch (err) {
 		if (err.code === 'ENOENT') {
-			// 文件不存在，创建它
 			const specObj = {
 				list: []
 			};
@@ -723,6 +465,5 @@ exports.parsePackageSwift = parsePackageSwift;
 exports.findSubHeaderPath = findSubHeaderPath;
 exports.findSubASSpecPath = findSubASSpecPath;
 exports.findProjectRoot = findProjectRoot;
-exports.findModuleHeaderFromRoot = findModuleHeaderFromRoot;
 exports.getRootSpecFilePath = getRootSpecFilePath;
 exports.ROOT_MARKER_NAME = ROOT_MARKER_NAME;

package/bin/init.js

@@ -16,27 +16,18 @@ async function mergeSubSpecs(mainSpecFile) {
 		list: []
 	};
 
-	// ✅ 找到项目根目录的 AutoSnippetRoot.boxspec.json 文件
-	console.log(`[mergeSubSpecs] 主配置文件路径: ${mainSpecFile}`);
 	const rootSpecFile = await findPath.getRootSpecFilePath(mainSpecFile);
 	if (!rootSpecFile) {
-		console.error(`[mergeSubSpecs] 未找到项目根目录，无法聚合配置`);
 		return;
 	}
-	console.log(`[mergeSubSpecs] 根目录配置文件: ${rootSpecFile}`);
 	
 	const projectRoot = path.dirname(rootSpecFile);
 	const searchRoot = projectRoot;
-	console.log(`[mergeSubSpecs] 项目根目录: ${projectRoot}`);
-	console.log(`[mergeSubSpecs] 搜索根目录: ${searchRoot}`);
 
 	const specSlashIndex = rootSpecFile.lastIndexOf('/');
 	const specFilePath = rootSpecFile.substring(0, specSlashIndex + 1);
 
-	// ✅ 从项目根目录向下查找子模块的 AutoSnippet.boxspec.json
-	console.log(`[mergeSubSpecs] 开始查找子模块配置，搜索根目录: ${searchRoot}`);
 	const array = await findPath.findSubASSpecPath(searchRoot);
-	console.log(`[mergeSubSpecs] 找到 ${array.length} 个子模块配置文件`);
 
 	for (let i = 0; i < array.length; i++) {
 		const filename = array[i];
@@ -62,8 +53,6 @@ async function mergeSubSpecs(mainSpecFile) {
 						}
 					}
 					idsArray.push(item['{identifier}']);
-					// ✅ SPM 模块：headName 已经是相对于模块根目录的相对路径
-					// headName 保持相对于各自模块根目录的路径（不需要转换）
 					return true;
 				});
 				specObj.list = specObj.list.concat(arr);
@@ -76,12 +65,10 @@ async function mergeSubSpecs(mainSpecFile) {
 	try {
 		const content = JSON.stringify(specObj, null, 4);
 		if (content) {
-			// ✅ 写入根目录的 AutoSnippetRoot.boxspec.json
 			fs.writeFileSync(rootSpecFile, content, 'utf8');
-			console.log(`[mergeSubSpecs] 已聚合 ${specObj.list.length} 个 snippet 到根目录配置文件`);
 		}
 	} catch (err) {
-		console.error(err);
+		// 忽略错误
 	}
 }
 
@@ -104,7 +91,6 @@ async function findTargetRootDirFromPath(dirPath) {
 			for (const entry of entries) {
 				if (entry.isDirectory() && (entry.name === 'Code' || entry.name === 'Sources')) {
 					// 找到包含 Code 或 Sources 的目录，这就是 target 根目录
-					console.log(`[findTargetRootDirFromPath] 找到 target 根目录: ${currentPath} (包含 ${entry.name})`);
 					return currentPath;
 				}
 			}
@@ -124,7 +110,6 @@ async function findTargetRootDirFromPath(dirPath) {
 		}
 	}
 	
-	console.log(`[findTargetRootDirFromPath] 未找到 target 根目录（Code 或 Sources）`);
 	return null;
 }
 
@@ -137,31 +122,22 @@ async function initSpec() {
 		let packagePath = await findPath.findPackageSwiftPath(CMD_PATH);
 		if (packagePath) {
 			targetRootDir = path.dirname(packagePath);
-			console.log(`[initSpec] 使用 Package.swift 所在目录作为 target 根目录: ${targetRootDir}`);
 		} else {
-			// 如果都找不到，使用当前目录
 			targetRootDir = CMD_PATH;
-			console.log(`[initSpec] 使用当前目录作为 target 根目录: ${targetRootDir}`);
 		}
 	}
 	
 	const filePath = path.join(targetRootDir, 'AutoSnippet.boxspec.json');
-	console.log(`[initSpec] 将在 target 根目录创建配置文件: ${filePath}`);
 	
-	// 如果配置文件不存在，创建一个空的
 	try {
 		await fs.promises.access(filePath);
-		console.log(`[initSpec] 配置文件已存在: ${filePath}`);
 	} catch (error) {
 		const specObj = {
 			list: []
 		};
 		const content = JSON.stringify(specObj, null, 4);
 		fs.writeFileSync(filePath, content, 'utf8');
-		console.log(`[initSpec] 已创建配置文件: ${filePath}`);
 	}
-
-	// ✅ 聚合子模块配置到根目录的 AutoSnippetRoot.boxspec.json
 	await mergeSubSpecs(filePath);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "autosnippet",
-    "version": "1.1.22",
+    "version": "1.1.23",
     "description": "A iOS module management tool.",
     "main": "index.js",
     "scripts": {
@@ -31,5 +31,8 @@
     "devDependencies": {},
     "bugs": {
         "url": "https://github.com/GxFn/AutoSnippet/issues"
+    },
+    "directories": {
+        "doc": "docs"
     }
 }