autosnippet 1.1.14 → 1.1.16

package/bin/asnip.js

@@ -17,18 +17,9 @@ const share = require('./share.js');
 const init = require('./init.js');
 const config = require('./config.js');
 
-// 获取配置文件路径（测试模式优先使用 BiliDemo 配置）
+// 获取配置文件路径
 function getSpecFile(callback) {
-	// 测试模式下，优先使用 BiliDemo 的配置文件
-	if (config.isTestMode()) {
-		const configPath = config.getConfigPath();
-		if (configPath && fs.existsSync(configPath)) {
-			callback(configPath);
-			return;
-		}
-	}
-	
-	// 否则使用原有的查找逻辑
+	// 向上查找 AutoSnippet.boxspec.json 配置文件
 	findPath.findASSpecPath(CMD_PATH, callback);
 }
 

package/bin/cache.js

@@ -41,11 +41,12 @@ async function updateCache(specFile, content) {
 						linkCache[key] = element['{readme}'];
 					}
 
+					// ✅ SPM 模块：headName 已经包含相对路径，不需要 specHeadPath
 					if (element['{headName}']
-						&& element['{specHeadPath}']
 						&& element['{language}'] !== 'Xcode.SourceCodeLanguage.Swift') {
-
-						headCache[element['{headName}']] = element['{specHeadPath}'];
+						// headName 本身已经是相对路径，直接使用
+						const headerFileName = path.basename(element['{headName}']);
+						headCache[headerFileName] = element['{headName}'];
 					}
 				}
 			});

package/bin/config.js

@@ -3,87 +3,37 @@
 const path = require('path');
 const fs = require('fs');
 
-// 检测是否为测试模式
-// 通过环境变量 AUTOSNIPPET_TEST_MODE 或检测 BiliDemo 目录
-function isTestMode() {
-	// 优先检查环境变量
-	if (process.env.AUTOSNIPPET_TEST_MODE === 'true') {
-		return true;
-	}
-	
-	// 检查当前工作目录是否在 BiliDemo 项目内
-	const cwd = process.cwd();
-	if (cwd.includes('BiliDemo')) {
-		return true;
-	}
-	
-	return false;
-}
-
-// 获取 BiliDemo 项目根目录
-function getBiliDemoRoot() {
-	const cwd = process.cwd();
-	const parts = cwd.split(path.sep);
+// 获取代码片段输出路径（写入 Xcode CodeSnippets 目录）
+function getSnippetsPath() {
+	const USER_HOME = process.env.HOME || process.env.USERPROFILE;
+	const snippetsPath = path.join(USER_HOME, 'Library/Developer/Xcode/UserData/CodeSnippets');
 	
-	for (let i = parts.length; i > 0; i--) {
-		const testPath = parts.slice(0, i).join(path.sep);
-		if (fs.existsSync(path.join(testPath, 'BiliDili', 'AutoSnippet.boxspec.json'))) {
-			return testPath;
-		}
+	// 确保目录存在
+	try {
+		fs.accessSync(snippetsPath, fs.constants.F_OK);
+	} catch (err) {
+		fs.mkdirSync(snippetsPath, { recursive: true });
 	}
 	
-	return null;
+	return snippetsPath;
 }
 
-// 获取配置文件路径
-function getConfigPath() {
-	if (isTestMode()) {
-		const biliDemoRoot = getBiliDemoRoot();
-		if (biliDemoRoot) {
-			return path.join(biliDemoRoot, 'BiliDili', 'AutoSnippet.boxspec.json');
-		}
-	}
-	return null;
-}
-
-// 获取代码片段输出路径（测试模式写入 AutoSnippetCache，生产模式写入 Xcode）
-function getSnippetsPath() {
-	if (isTestMode()) {
-		// ✅ 测试模式：写入 AutoSnippetCache/Snippets/
-		// __dirname: AutoSnippet/bin
-		// 目标路径: AutoSnippet/AutoSnippetCache/Snippets
-		const cachePath = path.join(__dirname, '../../AutoSnippetCache/Snippets');
-		try {
-			fs.accessSync(cachePath, fs.constants.F_OK);
-		} catch (err) {
-			fs.mkdirSync(cachePath, { recursive: true });
-		}
-		return cachePath;
-	} else {
-		// 生产模式：写入 Xcode CodeSnippets 目录
-		const USER_HOME = process.env.HOME || process.env.USERPROFILE;
-		return path.join(USER_HOME, 'Library/Developer/Xcode/UserData/CodeSnippets');
-	}
-}
-
-// 获取缓存目录路径
+// 获取缓存目录路径（使用用户 home 目录下的缓存）
 function getCachePath() {
-	// ✅ 缓存始终在 AutoSnippetCache 目录
-	// __dirname: AutoSnippet/bin
-	// 目标路径: AutoSnippet/AutoSnippetCache
-	const cachePath = path.join(__dirname, '../../AutoSnippetCache');
+	const USER_HOME = process.env.HOME || process.env.USERPROFILE;
+	const cachePath = path.join(USER_HOME, '.autosnippet', 'cache');
+	
+	// 确保目录存在
 	try {
 		fs.accessSync(cachePath, fs.constants.F_OK);
 	} catch (err) {
 		fs.mkdirSync(cachePath, { recursive: true });
 	}
+	
 	return cachePath;
 }
 
 module.exports = {
-	isTestMode,
-	getBiliDemoRoot,
-	getConfigPath,
 	getSnippetsPath,
 	getCachePath
 };

package/bin/create.js

@@ -13,23 +13,32 @@ const CMD_PATH = process.cwd();
 
 /**
  * 根据文件路径确定模块名（SPM）
+ * 返回路径中最近的（最深的）target 名称
  */
 function determineModuleName(filePath, packageInfo) {
 	// 从路径中提取模块名
-	// 例如：Services/Services/BDNetworkControl/Code/... -> BDNetworkControl
+	// 例如：Business/BDNetworkAPI/Code/... -> BDNetworkAPI（不是 Business）
 	const packagePath = packageInfo.path;
 	const relativePath = path.relative(packagePath, filePath);
 	const segments = relativePath.split(path.sep);
 
-	// 查找匹配的 target
-	for (const segment of segments) {
+	// ✅ 从后向前查找匹配的 target（优先匹配路径中更深的 target）
+	// 这样可以避免匹配到聚合 target（如 Business），而匹配到实际的 target（如 BDNetworkAPI）
+	for (let i = segments.length - 1; i >= 0; i--) {
+		const segment = segments[i];
 		if (packageInfo.targets.includes(segment)) {
 			return segment;
 		}
 	}
 
-	// 如果找不到，使用第一个 target
-	return packageInfo.targets[0] || packageInfo.name;
+	// 如果找不到，使用第一个 target（排除包名，如果包名也是 target）
+	const firstTarget = packageInfo.targets[0];
+	if (firstTarget && firstTarget !== packageInfo.name) {
+		return firstTarget;
+	}
+	
+	// 最后回退到包名
+	return packageInfo.name;
 }
 
 function updateCodeSnippets(specFile, word, key, value) {
@@ -229,15 +238,14 @@ function readStream(specFile, filePathArr, snippet, isHaveHeader) {
 				const fileName = filePath.substring(slashIndex + 1, dotIndex + 1) + 'h';
 				const thePath = filePath.substring(0, slashIndex + 1);
 
-				const specSlashIndex = specFile.lastIndexOf('/');
-				const specFilePath = specFile.substring(0, specSlashIndex + 1);
-
 				// ✅ 使用 SPM 的 Package.swift 查找（替代 .boxspec）
 				findPath.findPackageSwiftPath(thePath).then(async function (packagePath) {
 					if (!packagePath) {
 						console.log('未找到 Package.swift 文件，请检查路径。');
 						snippet['{content}'] = codeList;
-						saveFromFile(specFile, snippet);
+						// ✅ SPM 模块：.boxspec 文件位置在模块根目录（与 Package.swift 同级）
+						const moduleSpecFile = path.join(path.dirname(packagePath), 'AutoSnippet.boxspec.json');
+						saveFromFile(moduleSpecFile, snippet);
 						return;
 					}
 
@@ -245,35 +253,51 @@ function readStream(specFile, filePathArr, snippet, isHaveHeader) {
 					const packageInfo = await findPath.parsePackageSwift(packagePath);
 					if (!packageInfo) {
 						snippet['{content}'] = codeList;
-						saveFromFile(specFile, snippet);
+						const moduleSpecFile = path.join(path.dirname(packagePath), 'AutoSnippet.boxspec.json');
+						saveFromFile(moduleSpecFile, snippet);
 						return;
 					}
 
 					// 根据当前文件路径确定模块名
 					const moduleName = determineModuleName(filePath, packageInfo);
-					const headerName = fileName.substring(0, fileName.length - 2); // 移除 .h
+					const headerNameWithoutExt = fileName.substring(0, fileName.length - 2); // 移除 .h
+
+					// ✅ 模块根目录就是 Package.swift 所在目录（packageInfo.path）
+					// .boxspec.json 文件将创建在这个目录下（与 Package.swift 同级）
+					const moduleRoot = packageInfo.path;
 
 					// ✅ 查找头文件（适配 SPM 的 include/ModuleName/ 结构）
-					const headerPath = await findPath.findSubHeaderPath(packageInfo.path, headerName, moduleName);
+					// 在 Package.swift 所在目录下查找（可能包含 Services/Services/... 这样的结构）
+					const headerPath = await findPath.findSubHeaderPath(moduleRoot, headerNameWithoutExt, moduleName);
 
 					snippet['{content}'] = codeList;
-					snippet['{specName}'] = moduleName;
-					snippet['{headName}'] = fileName;
+					snippet['{specName}'] = moduleName;  // ✅ specName 是 target 名称（如 BDNetworkAPI），不是包名（如 Business）
 
 					if (headerPath) {
-						snippet['{specHeadPath}'] = encodeURI(headerPath.replace(specFilePath, ''));
+						// ✅ headName 存储相对于 Package.swift 所在目录的相对路径
+						// 例如：如果 Package.swift 在 Business/，头文件在 Business/Business/BDNetworkAPI/Code/xxx.h
+						// 则 headName = "Business/BDNetworkAPI/Code/xxx.h"
+						const headerRelativePath = path.relative(moduleRoot, headerPath);
+						snippet['{headName}'] = headerRelativePath;
+					} else {
+						// 如果找不到头文件，使用文件名
+						snippet['{headName}'] = fileName;
 					}
 
 					// 查找 README.md
 					try {
 						const readmePath = path.join(packageInfo.path, README_NAME);
 						await fs.promises.access(readmePath);
-						snippet['{readme}'] = encodeURI(readmePath.replace(specFilePath, ''));
+						const moduleRoot = packageInfo.path;
+						const readmeRelativePath = path.relative(moduleRoot, readmePath);
+						snippet['{readme}'] = encodeURI(readmeRelativePath);
 					} catch {
 						// README.md 不存在，跳过
 					}
 
-					saveFromFile(specFile, snippet);
+					// ✅ SPM 模块：.boxspec 文件位置在模块根目录（与 Package.swift 同级）
+					const moduleSpecFile = path.join(packageInfo.path, 'AutoSnippet.boxspec.json');
+					saveFromFile(moduleSpecFile, snippet);
 				}).catch(function (err) {
 					console.error('Error finding Package.swift:', err);
 					snippet['{content}'] = codeList;
@@ -301,7 +325,23 @@ function saveFromFile(specFile, snippet) {
 			placeholder = JSON.parse(data);
 		}
 	} catch (err) {
-		console.error(err);
+		// ✅ 文件不存在或读取失败，创建新的配置文件
+		if (err.code === 'ENOENT') {
+			// 确保目录存在
+			const specFileDir = path.dirname(specFile);
+			try {
+				fs.mkdirSync(specFileDir, { recursive: true });
+			} catch (mkdirErr) {
+				// 目录可能已存在，忽略错误
+			}
+			// 创建空的配置文件结构
+			placeholder = {
+				list: []
+			};
+		} else {
+			console.error(err);
+			return;
+		}
 	}
 
 	if (placeholder != null) {

package/bin/findPath.js

@@ -51,46 +51,77 @@ async function getDirectoryEntries(dirPath) {
 	}
 }
 
-// 向上查找AutoSnippet配置文件（优化：找到配置文件后，最多再向上查找两层停止）
+/**
+ * 检测是否为工程根目录
+ * 通过查找常见的工程根目录标记来判断
+ */
+function isProjectRoot(dirPath, entries) {
+	if (!entries) {
+		return false;
+	}
+	
+	// 工程根目录标记（按优先级）
+	const rootMarkers = [
+		'.git',              // Git 仓库根目录
+		PACKAGE_SWIFT,       // SPM 项目根目录
+		'.xcodeproj',        // Xcode 项目根目录
+		'.xcworkspace',      // Xcode 工作空间根目录
+		'Podfile',           // CocoaPods 项目根目录
+		'.swiftpm',          // Swift Package Manager 元数据目录
+	];
+	
+	for (const entry of entries) {
+		const name = entry.name;
+		
+		// 检查文件标记
+		if (entry.isFile() && rootMarkers.includes(name)) {
+			return true;
+		}
+		
+		// 检查目录标记（.git 可能是目录）
+		if (entry.isDirectory() && rootMarkers.includes(name)) {
+			return true;
+		}
+	}
+	
+	return false;
+}
+
+// 向上查找AutoSnippet配置文件（优化：找到配置文件后，继续向上查找直到找到工程根目录）
 async function findASSpecPathAsync(filePath) {
 	let configPath = null;
-	let levelsUp = 0;
+	let configDir = null;
 	let currentPath = path.resolve(filePath);
+	const maxLevels = 20; // 安全限制：最多向上查找 20 层
+	let levelsChecked = 0;
 	
-	while (currentPath) {
+	while (currentPath && levelsChecked < maxLevels) {
 		try {
 			const entries = await getDirectoryEntries(currentPath);
-			if (!entries) {
-				// 目录不存在，继续向上
-				const parentPath = path.dirname(currentPath);
-				if (parentPath === currentPath) {
-					break;  // 已到达根目录
-				}
-				currentPath = parentPath;
-				continue;
-			}
 			
 			// 查找 AutoSnippet.boxspec.json
-			for (const entry of entries) {
-				if (entry.isFile() && entry.name === HOLDER_NAME) {
-					if (!configPath) {
-						// 第一次找到配置文件
-						configPath = path.join(currentPath, entry.name);
+			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 (configPath) {
-				if (path.resolve(currentPath) !== path.dirname(configPath)) {
-					// 当前目录不是配置文件所在目录，说明已经向上查找了
-					levelsUp++;
+				// 如果在配置文件所在目录或以上发现了工程根目录标记，停止查找
+				if (isProjectRoot(currentPath, entries)) {
+					return configPath;
 				}
 				
-				// 如果已经向上查找了两层，停止查找
-				if (levelsUp >= 2) {
-					return configPath;
+				// 如果已经向上查找了，但没有找到工程根目录标记，继续查找
+				if (path.resolve(currentPath) !== configDir) {
+					// 当前目录不是配置文件所在目录，继续向上查找
 				}
 			}
 			
@@ -101,6 +132,7 @@ async function findASSpecPathAsync(filePath) {
 				break;
 			}
 			currentPath = parentPath;
+			levelsChecked++;
 			
 		} catch (err) {
 			// 错误处理：权限错误继续查找
@@ -110,6 +142,7 @@ async function findASSpecPathAsync(filePath) {
 					break;
 				}
 				currentPath = parentPath;
+				levelsChecked++;
 				continue;
 			}
 			// 其他错误，抛出
@@ -117,73 +150,134 @@ async function findASSpecPathAsync(filePath) {
 		}
 	}
 	
+	// 如果找到配置文件，返回它（即使没有找到明确的工程根目录）
 	return configPath || null;
 }
 
+/**
+ * 同步版本：检测是否为工程根目录
+ */
+function isProjectRootSync(dirPath, files) {
+	if (!files || files.length === 0) {
+		return false;
+	}
+	
+	// 工程根目录标记（按优先级）
+	const rootMarkers = [
+		'.git',              // Git 仓库根目录
+		PACKAGE_SWIFT,       // SPM 项目根目录
+		'.xcodeproj',        // Xcode 项目根目录
+		'.xcworkspace',      // Xcode 工作空间根目录
+		'Podfile',           // CocoaPods 项目根目录
+	];
+	
+	// 检查文件名
+	for (const filename of files) {
+		if (rootMarkers.includes(filename)) {
+			// 检查是否为文件或目录
+			try {
+				const filePath = path.join(dirPath, filename);
+				const stats = fs.lstatSync(filePath);
+				if (stats.isFile() || stats.isDirectory()) {
+					return true;
+				}
+			} catch (err) {
+				// 忽略错误，继续检查
+			}
+		}
+	}
+	
+	return false;
+}
+
 // 向上查找AutoSnippet配置文件（保留回调版本，兼容现有代码）
-function findASSpecPath(filePath, callback, configPath, levelsUp) {
+function findASSpecPath(filePath, callback, configPath, configDir) {
 	// 初始化参数
 	if (configPath === undefined) configPath = null;
-	if (levelsUp === undefined) levelsUp = 0;
+	if (configDir === undefined) configDir = null;
 	
-	fs.readdir(filePath, function (err, files) {
-		if (err) {
-			console.log(err);
+	const maxLevels = 20; // 安全限制：最多向上查找 20 层
+	let levelsChecked = 0;
+	
+	function search(currentPath, foundConfigPath, foundConfigDir, level) {
+		if (level >= maxLevels) {
+			if (foundConfigPath) {
+				callback(foundConfigPath);
+			} else {
+				console.log('未找到 AutoSnippet.boxspec.json 文件，请检查路径。');
+			}
 			return;
 		}
-
-		let isFound = false;
-		let foundConfigPath = configPath;
-        files.forEach(function (filename) {
-			if (filename === HOLDER_NAME) {
-				isFound = true;
-				if (!foundConfigPath) {
-					// 第一次找到配置文件，记录路径并调用回调
-					foundConfigPath = path.resolve(filePath);
-					callback(path.join(filePath, filename));
+		
+		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);
 				}
-			}
-        });
-
-		// 如果已经找到配置文件，检查是否已经向上查找了两层
-		if (foundConfigPath) {
-			if (!isFound) {
-				// 当前目录不是配置文件所在目录，说明已经向上查找了
-				levelsUp++;
-			}
-			
-			// 如果已经向上查找了两层，停止查找
-			if (levelsUp >= 2) {
 				return;
 			}
-		}
 
-		// 如果还没找到配置文件，继续向上查找
-		if (!foundConfigPath) {
-			// 继续向上查找
-			const parentPath = path.join(filePath, '/..');
-			const parentResolvedPath = path.resolve(parentPath);
+			let isFound = false;
+			let currentConfigPath = foundConfigPath;
+			let currentConfigDir = foundConfigDir;
 			
-			// 如果已经到达根目录，停止查找
-			if (parentResolvedPath === path.resolve(filePath)) {
-				console.log('未找到 AutoSnippet.boxspec.json 文件，请检查路径。');
-				return;
+			// 查找 AutoSnippet.boxspec.json
+			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;
+				}
 			}
 
-			findASSpecPath(parentPath, callback, foundConfigPath, 0);
-		} else {
-			// 已经找到配置文件，继续向上查找（最多两层）
-			const parentPath = path.join(filePath, '/..');
+			// 继续向上查找
+			const parentPath = path.join(currentPath, '/..');
 			const parentResolvedPath = path.resolve(parentPath);
 			
 			// 如果已经到达根目录，停止查找
-			if (parentResolvedPath === path.resolve(filePath)) {
+			if (parentResolvedPath === path.resolve(currentPath)) {
+				// 如果找到了配置文件，即使没找到工程根目录标记，也调用回调
+				if (currentConfigPath) {
+					callback(currentConfigPath);
+				} else {
+					console.log('未找到 AutoSnippet.boxspec.json 文件，请检查路径。');
+				}
 				return;
 			}
 
-			findASSpecPath(parentPath, callback, foundConfigPath, levelsUp);
-		}
-    });
+			search(parentPath, currentConfigPath, currentConfigDir, level + 1);
+		});
+	}
+	
+	search(filePath, configPath, configDir, 0);
 }
 
 // 向上查找 Package.swift 文件（SPM 模块规范文件）

package/bin/init.js

@@ -47,11 +47,10 @@ async function initSpec() {
                             return false;
                         }
                     }
-                    idsArray.push(item['{identifier}']);
-					// 头文件相对路径需要补齐
-					if (item['{specHeadPath}']) {
-						item['{specHeadPath}'] = thePath + item['{specHeadPath}'];
-					}
+					idsArray.push(item['{identifier}']);
+					// ✅ SPM 模块：headName 已经是相对于模块根目录的相对路径，如果子模块与主配置不在同一目录，需要调整
+					// headName 保持相对于各自模块根目录的路径（不需要转换）
+					// 去掉 specHeadPath 的处理逻辑
                     return true;
                 });
                 specObj.list = specObj.list.concat(arr);

package/bin/injection.js

@@ -58,33 +58,117 @@ function handleHeaderLineSwift(specFile, updateFile, headerLine, importArray) {
 
 // specFile实际上是获取缓存的key，用来获取Snippet的模块空间信息，没有路径意义
 // updateFile是当前修改文件路径，用来获取当前模块空间信息
-function handleHeaderLine(specFile, updateFile, headerLine, importArray, isSwift) {
+async function handleHeaderLine(specFile, updateFile, headerLine, importArray, isSwift) {
     if (isSwift) {
         handleHeaderLineSwift(specFile, updateFile, headerLine, importArray);
         return;
     }
 	const header = createHeader(headerLine);
 
-	// 首先识别是否是组件内部修改，默认头文件间接等于模块名
-	cache.getHeadCache(specFile).then(function (headCache) {
-		if (headCache) {
-			const headPath = headCache[header.headerName];
+	// ✅ 重新设计：区分当前模块内部和外部
+	// 1. 获取当前文件所在的模块（通过 Package.swift）
+	// 2. 获取头文件所在的模块（从头文件路径查找 Package.swift，确定最近的 target 模块名）
+	// 3. 比较模块名：
+	//    - 相同模块 -> 使用相对路径 #import "Header.h"
+	//    - 不同模块 -> 使用 #import <ModuleName/Header.h>
+
+	// 获取当前文件所在的模块
+	const updateFileDir = path.dirname(updateFile);
+	const currentPackagePath = await findPath.findPackageSwiftPath(updateFileDir);
+	
+	if (!currentPackagePath) {
+		// 找不到当前模块的 Package.swift，默认使用 <> 格式
+		handleModuleHeader(specFile, updateFile, header, importArray, true);
+		return;
+	}
 
-			const dotIndex = headPath.lastIndexOf('.');
-			const slashIndex = headPath.lastIndexOf('/');
-			const currModuleName = headPath.substring(slashIndex + 1, dotIndex);
-			if (currModuleName === header.moduleName) {
-				handleModuleHeader(specFile, updateFile, header, importArray, false);
-			} else {
-				handleModuleHeader(specFile, updateFile, header, importArray, true);
-			}
+	const currentPackageInfo = await findPath.parsePackageSwift(currentPackagePath);
+	if (!currentPackageInfo) {
+		handleModuleHeader(specFile, updateFile, header, importArray, true);
+		return;
+	}
+
+	// 获取当前文件所在的模块名（通过路径判断）
+	const currentModuleName = determineCurrentModuleName(updateFile, currentPackageInfo);
+
+	// ✅ 获取头文件缓存，然后确定头文件所在的模块名
+	const headCache = await cache.getHeadCache(specFile);
+	const headerModuleName = await determineHeaderModuleName(specFile, header, headCache);
+
+	// ✅ 更新 header 中的模块名和 specName，确保使用正确的模块名（最近的 target 模块名）
+	header.moduleName = headerModuleName;
+	header.specName = '<' + headerModuleName + '/' + header.headerName + '>';
+
+	// ✅ 判断是否为同一模块
+	const isSameModule = currentModuleName === headerModuleName;
+
+	// 如果是同一模块，使用相对路径；否则使用 <> 格式
+	handleModuleHeader(specFile, updateFile, header, importArray, !isSameModule);
+}
+
+/**
+ * 根据文件路径确定当前模块名（SPM）
+ */
+function determineCurrentModuleName(filePath, packageInfo) {
+	const relativePath = path.relative(packageInfo.path, filePath);
+	const segments = relativePath.split(path.sep);
+
+	// 查找匹配的 target（最近的 target）
+	for (const segment of segments) {
+		if (packageInfo.targets.includes(segment)) {
+			return segment;
 		}
-	});
+	}
+
+	// 如果找不到，使用第一个 target
+	return packageInfo.targets[0] || packageInfo.name;
+}
+
+/**
+ * 确定头文件所在的模块名（SPM）
+ * 从头文件路径查找 Package.swift，确定最近的 target 模块名
+ */
+async function determineHeaderModuleName(specFile, header, headCache) {
+	if (!headCache) {
+		// 没有缓存，使用从 headerLine 解析的模块名（可能不准确）
+		return header.moduleName;
+	}
+
+	// 从头缓存中获取头文件的相对路径
+	const headRelativePath = headCache[header.headerName];
+	if (!headRelativePath) {
+		// 找不到头文件路径，使用从 headerLine 解析的模块名
+		return header.moduleName;
+	}
+
+	// ✅ specFile 位于模块根目录（如 ModuleRoot/AutoSnippet.boxspec.json）
+	const moduleRootDir = path.dirname(specFile);
+	const headPath = path.join(moduleRootDir, headRelativePath);
+
+	// 从头文件路径向上查找 Package.swift
+	const headerPackagePath = await findPath.findPackageSwiftPath(headPath);
+	if (!headerPackagePath) {
+		// 找不到 Package.swift，使用从 headerLine 解析的模块名
+		return header.moduleName;
+	}
+
+	// 解析 Package.swift 获取模块信息
+	const headerPackageInfo = await findPath.parsePackageSwift(headerPackagePath);
+	if (!headerPackageInfo) {
+		return header.moduleName;
+	}
+
+	// ✅ 根据头文件路径确定最近的 target 模块名
+	return determineCurrentModuleName(headPath, headerPackageInfo);
 }
 
 // isOuter区分模块内部引用""格式和模块外部引用<>格式
+// ✅ SPM 模块：
+//    - isOuter = false：同一模块内部，使用相对路径 #import "Header.h"
+//    - isOuter = true：不同模块之间，使用 #import <ModuleName/Header.h>
 function handleModuleHeader(specFile, updateFile, header, importArray, isOuter) {
-    const headName = isOuter ? header.name : header.headerStrName;
+	// ✅ 根据 isOuter 选择不同的引入格式
+	const headName = isOuter ? header.name : header.headerStrName;  // isOuter: <ModuleName/Header.h>, 否则: "Header.h"
 	const moduleName = isOuter ? header.specName : header.moduleStrName;
 
 	// 检查是否已经引入头文件
@@ -93,20 +177,21 @@ function handleModuleHeader(specFile, updateFile, header, importArray, isOuter)
 
 		if (importHeader === headName) {
 			// 已经引入头文件
-			handelAddHeaderStatus(specFile, updateFile, header, true, false);
+			handelAddHeaderStatus(specFile, updateFile, header, true, false, isOuter);
 			return;
 		} else if (importHeader === moduleName) {
-			// 已经引入spec头文件
-			handelAddHeaderStatus(specFile, updateFile, header, false, true);
+			// 已经引入模块头文件（如 <ModuleName/ModuleName.h>）
+			handelAddHeaderStatus(specFile, updateFile, header, false, true, isOuter);
 			return;
 		}
 	}
 
 	// 没有找到已引入的头文件，直接添加
-	addHeaderToFile(updateFile, header);
+	// addHeaderToFile 会根据 isOuter 使用不同的格式
+	addHeaderToFile(updateFile, header, isOuter);
 }
 
-function handelAddHeaderStatus(specFile, updateFile, header, isAddedHeader, isAddedSpecHeader) {
+function handelAddHeaderStatus(specFile, updateFile, header, isAddedHeader, isAddedSpecHeader, isOuter) {
 	if (isAddedHeader) {
 		// 已经引入头文件
 		removeMarkFromFile(updateFile, header, '依赖头文件已存在，不需要额外引入。');
@@ -117,21 +202,32 @@ function handelAddHeaderStatus(specFile, updateFile, header, isAddedHeader, isAd
 				// spec header足够了，不需要添加头文件
 				removeMarkFromFile(updateFile, header, '依赖模块头文件已存在，不需要额外引入。');
 			} else {
-				addHeaderToFile(updateFile, header);
+				// 使用传入的 isOuter 参数
+				addHeaderToFile(updateFile, header, isOuter);
 			}
 		});
 	} else {
 		// 都没找到，添加头文件
-		addHeaderToFile(updateFile, header);
+		// 使用传入的 isOuter 参数
+		addHeaderToFile(updateFile, header, isOuter);
 	}
 }
 
 function isAddedToSpecHeader(specFile, header, callback) {
 	cache.getHeadCache(specFile).then(function (headCache) {
 		if (headCache) {
-			const specSlashIndex = specFile.lastIndexOf('/');
-			const specFilePath = specFile.substring(0, specSlashIndex + 1);
-			const headPath = specFilePath + headCache[header.headerName];
+			// ✅ SPM 模块：headName 已经是相对于模块根目录的相对路径
+			// specFile 位于模块根目录（如 ModuleRoot/AutoSnippet.boxspec.json）
+			const moduleRootDir = path.dirname(specFile);
+			const headRelativePath = headCache[header.headerName];
+			
+			if (!headRelativePath) {
+				callback(false);
+				return;
+			}
+			
+			// 拼接头文件的完整路径
+			const headPath = path.join(moduleRootDir, headRelativePath);
 
 			try {
 				// 读取当前头文件所在工作空间里默认暴露的头文件
@@ -168,8 +264,15 @@ function removeMarkFromFile(updateFile, header, string) {
 	});
 }
 
-function addHeaderToFile(updateFile, header) {
-	readStream(updateFile, importMark + ' ' + header.name, importMark);
+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"
+	
+	readStream(updateFile, importLine, importMark);
 	checkDependency(updateFile, header.moduleName, '自动注入头文件完成。').catch(err => {
 		console.error('Error checking dependency:', err);
 	});

package/bin/install.js

@@ -80,7 +80,7 @@ function writeSingleSnippet(snippet, template) {
 		});
 
 		if (identifier && content) {
-			// ✅ 使用配置模块获取代码片段输出路径（测试模式写入 AutoSnippetCache）
+			// ✅ 使用配置模块获取代码片段输出路径（写入 Xcode CodeSnippets）
 			const snippetsPath = config.getSnippetsPath();
 			
 			try {
@@ -208,7 +208,7 @@ function addCodeSnippets(specFile, singleSnippet) {
 			});
 
 			if (identifier && content) {
-				// ✅ 使用配置模块获取代码片段输出路径（测试模式写入 AutoSnippetCache）
+				// ✅ 使用配置模块获取代码片段输出路径（写入 Xcode CodeSnippets）
 				const snippetsPath = config.getSnippetsPath();
 				
 				try {
@@ -219,11 +219,6 @@ function addCodeSnippets(specFile, singleSnippet) {
 				try {
 					const snippetFile = path.join(snippetsPath, identifier + '.codesnippet');
 					fs.writeFileSync(snippetFile, content);
-					
-					// 测试模式下显示提示信息
-					if (config.isTestMode()) {
-						console.log(`[测试模式] 代码片段已写入: ${snippetFile}`);
-					}
 				} catch (err) {
 					console.log(err);
 				}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "autosnippet",
-    "version": "1.1.14",
+    "version": "1.1.16",
     "description": "A iOS module management tool.",
     "main": "index.js",
     "scripts": {