autosnippet 1.1.21 → 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,14 +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) {
-	// ✅ 优先查找 include/ModuleName/ 目录（SPM 结构）
+	const codePath = path.join(filePath, 'Code');
+	try {
+		const stats = await fs.promises.stat(codePath);
+		if (stats.isDirectory()) {
+			const result = await findSubHeaderPath(codePath, headerName, null);
+			if (result) {
+				return result;
+			}
+		}
+	} catch {
+		// 继续查找
+	}
+	
 	if (moduleName) {
 		const includePath = path.join(filePath, 'include', moduleName);
 		try {
@@ -394,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) {
@@ -413,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;
 				}
@@ -425,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;
@@ -484,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;
 				}
@@ -494,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);
+				startPath = path.dirname(startPath);
 			}
 		}
-		// 其他错误继续处理，可能是目录路径
 	}
 	
-	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;
-			}
-			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) {
@@ -682,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: []
 			};
@@ -706,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/bin/injection.js

@@ -91,16 +91,40 @@ async function handleHeaderLine(specFile, updateFile, headerLine, importArray, i
 	// 获取当前文件所在的模块名（通过路径判断）
 	const currentModuleName = determineCurrentModuleName(updateFile, currentPackageInfo);
 
-	// ✅ 获取头文件缓存，然后确定头文件所在的模块名
-	const headCache = await cache.getHeadCache(specFile);
-	const headerModuleName = await determineHeaderModuleName(specFile, header, headCache);
+	// ✅ 优先从标记中获取相对路径，如果没有则从缓存获取
+	// 标记格式：// ahead <Module/Header.h> relative/path/to/Header.h
+	let headRelativePath = header.headRelativePathFromMark;
+	if (!headRelativePath) {
+		// 标记中没有相对路径，尝试从缓存获取
+		const headCache = await cache.getHeadCache(specFile);
+		if (headCache && headCache[header.headerName]) {
+			headRelativePath = headCache[header.headerName];
+		}
+	}
+	
+	const headerInfo = await determineHeaderInfo(specFile, header, headRelativePath, currentPackageInfo, currentModuleName);
 
-	// ✅ 更新 header 中的模块名和 specName，确保使用正确的模块名（最近的 target 模块名）
-	header.moduleName = headerModuleName;
-	header.specName = '<' + headerModuleName + '/' + header.headerName + '>';
+	// ✅ 更新 header 中的模块名、相对路径和 specName
+	header.moduleName = headerInfo.moduleName;
+	header.headRelativePath = headerInfo.headRelativePath;  // 相对于模块根目录的相对路径
+	header.specName = '<' + headerInfo.moduleName + '/' + header.headerName + '>';
 
 	// ✅ 判断是否为同一模块
-	const isSameModule = currentModuleName === headerModuleName;
+	const isSameModule = currentModuleName === headerInfo.moduleName;
+
+	// ✅ 如果是同一模块，计算相对于当前文件的相对路径
+	if (isSameModule && headerInfo.headRelativePath) {
+		// 当前文件相对于模块根目录的路径
+		const currentFileRelativeToModuleRoot = path.relative(currentPackageInfo.path, updateFile);
+		// 头文件相对于模块根目录的路径
+		const headRelativeToModuleRoot = headerInfo.headRelativePath;
+		
+		// 计算从当前文件到头文件的相对路径
+		const currentFileDir = path.dirname(currentFileRelativeToModuleRoot);
+		const relativePathToHeader = path.relative(currentFileDir, headRelativeToModuleRoot).replace(/\\/g, '/');
+		
+		header.relativePathToCurrentFile = relativePathToHeader;
+	}
 
 	// 如果是同一模块，使用相对路径；否则使用 <> 格式
 	handleModuleHeader(specFile, updateFile, header, importArray, !isSameModule);
@@ -125,57 +149,112 @@ function determineCurrentModuleName(filePath, packageInfo) {
 }
 
 /**
- * 确定头文件所在的模块名（SPM）
+ * 确定头文件信息（模块名、相对路径等）
  * 从头文件路径查找 Package.swift，确定最近的 target 模块名
+ * 同时计算相对于当前文件的相对路径
+ * @param {string} specFile - 配置文件路径
+ * @param {object} header - 头文件信息对象
+ * @param {string} headRelativePath - 头文件相对路径（相对于模块根目录），可能来自标记或缓存
+ * @param {object} currentPackageInfo - 当前文件的 Package.swift 信息
+ * @param {string} currentModuleName - 当前模块名
  */
-async function determineHeaderModuleName(specFile, header, headCache) {
-	if (!headCache) {
-		// 没有缓存，使用从 headerLine 解析的模块名（可能不准确）
-		return header.moduleName;
-	}
+async function determineHeaderInfo(specFile, header, headRelativePath, currentPackageInfo, currentModuleName) {
+	// 默认值
+	let moduleName = header.moduleName;
+	let relativePathToCurrentFile = null;
 
-	// 从头缓存中获取头文件的相对路径
-	const headRelativePath = headCache[header.headerName];
 	if (!headRelativePath) {
-		// 找不到头文件路径，使用从 headerLine 解析的模块名
-		return header.moduleName;
+		// 没有相对路径，使用从 headerLine 解析的模块名（可能不准确）
+		return {
+			moduleName: moduleName,
+			headRelativePath: null,
+			relativePathToCurrentFile: null
+		};
 	}
 
-	// ✅ specFile 位于模块根目录（如 ModuleRoot/AutoSnippet.boxspec.json）
-	const moduleRootDir = path.dirname(specFile);
-	const headPath = path.join(moduleRootDir, headRelativePath);
+	// ✅ specFile 可能是根目录的 AutoSnippetRoot.boxspec.json，需要找到头文件所在的模块配置
+	// 尝试从根目录的配置文件查找头文件所在的模块
+	const rootSpecDir = path.dirname(specFile);
+	let headPath = null;
+	
+	// 尝试多种可能的路径
+	// 1. 直接使用根目录的相对路径
+	headPath = path.join(rootSpecDir, headRelativePath);
+	
+	// 2. 如果文件不存在，尝试从子模块中查找
+	if (!fs.existsSync(headPath)) {
+		// 从头文件路径向上查找 Package.swift
+		const headerPackagePath = await findPath.findPackageSwiftPath(headPath);
+		if (headerPackagePath) {
+			const headerPackageInfo = await findPath.parsePackageSwift(headerPackagePath);
+			if (headerPackageInfo) {
+				// 找到 Package.swift，使用它的路径作为模块根目录
+				const headerModuleRootDir = path.dirname(headerPackagePath);
+				headPath = path.join(headerModuleRootDir, headRelativePath);
+			}
+		}
+	}
 
 	// 从头文件路径向上查找 Package.swift
 	const headerPackagePath = await findPath.findPackageSwiftPath(headPath);
 	if (!headerPackagePath) {
 		// 找不到 Package.swift，使用从 headerLine 解析的模块名
-		return header.moduleName;
+		return {
+			moduleName: moduleName,
+			headRelativePath: headRelativePath,
+			relativePathToCurrentFile: null
+		};
 	}
 
 	// 解析 Package.swift 获取模块信息
 	const headerPackageInfo = await findPath.parsePackageSwift(headerPackagePath);
 	if (!headerPackageInfo) {
-		return header.moduleName;
+		return {
+			moduleName: moduleName,
+			headRelativePath: headRelativePath,
+			relativePathToCurrentFile: null
+		};
 	}
 
 	// ✅ 根据头文件路径确定最近的 target 模块名
-	return determineCurrentModuleName(headPath, headerPackageInfo);
+	moduleName = determineCurrentModuleName(headPath, headerPackageInfo);
+
+	// ✅ 如果是同一模块，计算相对于当前文件的相对路径
+	// 注意：这里需要知道当前文件的路径，所以需要从外部传入
+	// 但当前函数中还没有 updateFile，所以这部分逻辑在 handleHeaderLine 中完成
+
+	return {
+		moduleName: moduleName,
+		headRelativePath: headRelativePath,
+		relativePathToCurrentFile: null  // 将在 handleHeaderLine 中计算
+	};
 }
 
 // isOuter区分模块内部引用""格式和模块外部引用<>格式
 // ✅ SPM 模块：
-//    - isOuter = false：同一模块内部，使用相对路径 #import "Header.h"
+//    - isOuter = false：同一模块内部，使用相对路径 #import "relative/path/Header.h" 或 #import "Header.h"
 //    - isOuter = true：不同模块之间，使用 #import <ModuleName/Header.h>
 function handleModuleHeader(specFile, updateFile, header, importArray, isOuter) {
-	// ✅ 根据 isOuter 选择不同的引入格式
-	const headName = isOuter ? header.name : header.headerStrName;  // isOuter: <ModuleName/Header.h>, 否则: "Header.h"
+	// ✅ 根据 isOuter 选择不同的引入格式，用于检查是否已存在
+	let headNameToCheck;
+	if (isOuter) {
+		// 外部模块，使用 <> 格式
+		headNameToCheck = header.name;  // <ModuleName/Header.h>
+	} else {
+		// 同一模块内部，使用相对路径
+		if (header.relativePathToCurrentFile) {
+			headNameToCheck = '"' + header.relativePathToCurrentFile + '"';  // "relative/path/Header.h"
+		} else {
+			headNameToCheck = header.headerStrName;  // "Header.h"
+		}
+	}
 	const moduleName = isOuter ? header.specName : header.moduleStrName;
 
 	// 检查是否已经引入头文件
 	for (let i = 0; i < importArray.length; i++) {
 		const importHeader = importArray[i].split(importMark)[1].trim();
 
-		if (importHeader === headName) {
+		if (importHeader === headNameToCheck) {
 			// 已经引入头文件
 			handelAddHeaderStatus(specFile, updateFile, header, true, false, isOuter);
 			return;
@@ -267,10 +346,21 @@ function removeMarkFromFile(updateFile, header, string) {
 function addHeaderToFile(updateFile, header, isOuter) {
 	// ✅ 根据 isOuter 选择不同的引入格式
 	// isOuter = true: 使用 <> 格式（#import <ModuleName/Header.h>）
-	// isOuter = false: 使用相对路径（#import "Header.h"）
-	const importLine = isOuter 
-		? importMark + ' ' + header.name  // <ModuleName/Header.h>
-		: importMark + ' ' + header.headerStrName;  // "Header.h"
+	// isOuter = false: 使用相对路径（#import "relative/path/Header.h" 或 #import "Header.h"）
+	let importLine;
+	if (isOuter) {
+		// 外部模块，使用 <> 格式
+		importLine = importMark + ' ' + header.name;  // <ModuleName/Header.h>
+	} else {
+		// 同一模块内部，使用相对路径
+		if (header.relativePathToCurrentFile) {
+			// 使用计算出的相对路径（如 "SubDir/Header.h" 或 "../Header.h"）
+			importLine = importMark + ' "' + header.relativePathToCurrentFile + '"';
+		} else {
+			// 如果没有相对路径，使用文件名（如 "Header.h"）
+			importLine = importMark + ' ' + header.headerStrName;  // "Header.h"
+		}
+	}
 	
 	readStream(updateFile, importLine, importMark);
 	checkDependency(updateFile, header.moduleName, '自动注入头文件完成。').catch(err => {

package/bin/install.js

@@ -30,6 +30,11 @@ function writeSingleSnippet(snippet, template) {
 		// 例如：<BDVideoPlayer/BDVideoCacheManager.h> 而不是 <BDVideoPlayer/UI/BDVideoPlayer/Code/BDVideoCacheManager.h>
 		const headerFileName = path.basename(extPlace['{headName}']);
 		let header = '<' + extPlace['{specName}'] + '/' + headerFileName + '>';
+		
+		// ✅ 在标记中包含相对路径信息，格式：// ahead <Module/Header.h> relative/path/to/Header.h
+		// 这样即使没有缓存也能解析出完整信息
+		const headRelativePath = extPlace['{headName}'];  // 相对于模块根目录的相对路径
+		header = header + ' ' + headRelativePath;
 		header = escapeString(header);
 
 		// swift只需要考虑工作空间是否引入
@@ -42,7 +47,7 @@ function writeSingleSnippet(snippet, template) {
 		extPlace['{completion}'] = extPlace['{completion}'] + 'Z';
 		extPlace['{summary}'] = extPlace['{summary}'] + header;
 
-		// 添加替换header标识位
+		// 添加替换header标识位（格式：// ahead <Module/Header.h> relative/path/to/Header.h）
 		let array = ['// ahead ' + header];
 		extPlace['{content}'].forEach(element => {
 			array.push(element);
@@ -159,6 +164,11 @@ function addCodeSnippets(specFile, singleSnippet) {
 				// ✅ 从项目根目录找到模块，只使用模块名和头文件名
 				const headerFileName = path.basename(extPlace['{headName}']);
 				let header = '<' + extPlace['{specName}'] + '/' + headerFileName + '>';
+				
+				// ✅ 在标记中包含相对路径信息，格式：// ahead <Module/Header.h> relative/path/to/Header.h
+				// 这样即使没有缓存也能解析出完整信息
+				const headRelativePath = extPlace['{headName}'];  // 相对于模块根目录的相对路径
+				header = header + ' ' + headRelativePath;
 				header = escapeString(header);
 
 				// swift只需要考虑工作空间是否引入

package/bin/watch.js

@@ -14,7 +14,8 @@ const alinkMark = 'alink';
 const wellMark = '#';
 const atMark = '@';
 
-const headerReg = /^\/\/ ahead <\w+\/\w+.h>$/;
+// ✅ 更新正则以匹配包含相对路径的新格式：// ahead <Module/Header.h> relative/path/to/Header.h
+const headerReg = /^\/\/ ahead <\w+\/\w+.h>(\s+.+)?$/;
 const headerSwiftReg = /^\/\/ ahead \w+$/;
 const importReg = /^\#import\s*<\w+\/\w+.h>$/;
 const importSwiftReg = /^import\s*\w+$/;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "autosnippet",
-    "version": "1.1.21",
+    "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"
     }
 }