autosnippet 1.1.18 → 1.1.20

package/bin/asnip.js

@@ -226,4 +226,31 @@ commander
 		});
 	});
 
+commander
+	.command('root')
+	.description('mark current directory as project root by creating AutoSnippetRoot.boxspec.json')
+	.action(() => {
+		const fs = require('fs');
+		const path = require('path');
+		const rootMarkerPath = path.join(CMD_PATH, 'AutoSnippetRoot.boxspec.json');
+		
+		try {
+			// 检查文件是否已存在
+			fs.accessSync(rootMarkerPath, fs.constants.F_OK);
+			console.log(`根目录标记文件已存在: ${rootMarkerPath}`);
+		} catch (err) {
+			// 文件不存在，创建它
+			try {
+				// 创建一个空的标记文件
+				fs.writeFileSync(rootMarkerPath, JSON.stringify({
+					root: true,
+					description: 'This file marks the project root directory for AutoSnippet'
+				}, null, 2), 'utf8');
+				console.log(`已创建根目录标记文件: ${rootMarkerPath}`);
+			} catch (writeErr) {
+				console.error(`创建根目录标记文件失败: ${writeErr.message}`);
+			}
+		}
+	});
+
 commander.parse(process.argv);

package/bin/create.js

@@ -41,6 +41,51 @@ function determineModuleName(filePath, packageInfo) {
 	return packageInfo.name;
 }
 
+/**
+ * 从文件路径确定 target 的根目录（包含 Code 或 Sources 的目录）
+ * @param {string} filePath - 文件路径
+ * @returns {Promise<string|null>} target 根目录路径，如果找不到返回 null
+ */
+async function findTargetRootDir(filePath) {
+	const fs = require('fs');
+	let currentPath = path.dirname(path.resolve(filePath));
+	const maxLevels = 10;
+	let levelsChecked = 0;
+	
+	// ✅ 向上查找包含 Code 或 Sources 目录的目录（target 根目录）
+	// 例如：BDNetworkAPI/Code/xxx.m -> BDNetworkAPI/
+	while (currentPath && levelsChecked < maxLevels) {
+		try {
+			const entries = await fs.promises.readdir(currentPath, { withFileTypes: true });
+			
+			// 检查当前目录是否包含 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;
+				}
+			}
+			
+			// 继续向上查找
+			const parentPath = path.dirname(currentPath);
+			if (parentPath === currentPath) {
+				break;
+			}
+			currentPath = parentPath;
+			levelsChecked++;
+		} catch (err) {
+			if (err.code === 'ENOENT' || err.code === 'EACCES') {
+				break;
+			}
+			throw err;
+		}
+	}
+	
+	console.log(`[findTargetRootDir] 未找到 target 根目录（Code 或 Sources）`);
+	return null;
+}
+
 function updateCodeSnippets(specFile, word, key, value) {
 	if (key && key !== 'title' && key !== 'link' && key !== 'summary') {
 		console.log('此项属性不存在或不可修改。');
@@ -224,7 +269,7 @@ function readStream(specFile, filePathArr, snippet, isHaveHeader) {
 		}
 	});
 
-	rl.on('close', function () {
+	rl.on('close', async function () {
 		if (codeList.length > 1) {
 			codeList.pop();
 
@@ -243,9 +288,14 @@ function readStream(specFile, filePathArr, snippet, isHaveHeader) {
 					if (!packagePath) {
 						console.log('未找到 Package.swift 文件，请检查路径。');
 						snippet['{content}'] = codeList;
-						// ✅ SPM 模块：.boxspec 文件位置在模块根目录（与 Package.swift 同级）
-						const moduleSpecFile = path.join(path.dirname(packagePath), 'AutoSnippet.boxspec.json');
-						saveFromFile(moduleSpecFile, snippet);
+						// ✅ 查找 target 根目录（Code 或 Sources 的父目录）
+						let targetRootDir = await findTargetRootDir(filePath);
+						if (!targetRootDir) {
+							// 如果找不到，使用文件所在目录的父目录作为后备
+							targetRootDir = path.dirname(path.dirname(filePath));
+						}
+						const moduleSpecFile = path.join(targetRootDir, 'AutoSnippet.boxspec.json');
+						await saveFromFile(moduleSpecFile, snippet);
 						return;
 					}
 
@@ -253,8 +303,14 @@ function readStream(specFile, filePathArr, snippet, isHaveHeader) {
 					const packageInfo = await findPath.parsePackageSwift(packagePath);
 					if (!packageInfo) {
 						snippet['{content}'] = codeList;
-						const moduleSpecFile = path.join(path.dirname(packagePath), 'AutoSnippet.boxspec.json');
-						saveFromFile(moduleSpecFile, snippet);
+						// ✅ 查找 target 根目录（Code 或 Sources 的父目录）
+						let targetRootDir = await findTargetRootDir(filePath);
+						if (!targetRootDir) {
+							// 如果找不到，使用 Package.swift 所在目录作为后备
+							targetRootDir = path.dirname(packagePath);
+						}
+						const moduleSpecFile = path.join(targetRootDir, 'AutoSnippet.boxspec.json');
+						await saveFromFile(moduleSpecFile, snippet);
 						return;
 					}
 
@@ -262,50 +318,54 @@ function readStream(specFile, filePathArr, snippet, isHaveHeader) {
 					const moduleName = determineModuleName(filePath, packageInfo);
 					const headerNameWithoutExt = fileName.substring(0, fileName.length - 2); // 移除 .h
 
-					// ✅ 模块根目录就是 Package.swift 所在目录（packageInfo.path）
-					// .boxspec.json 文件将创建在这个目录下（与 Package.swift 同级）
-					const moduleRoot = packageInfo.path;
+					// ✅ 查找 target 根目录（Code 或 Sources 的父目录）
+					let targetRootDir = await findTargetRootDir(filePath);
+					if (!targetRootDir) {
+						// 如果找不到 target 根目录，使用 Package.swift 所在目录作为后备
+						targetRootDir = packageInfo.path;
+					}
+					console.log(`[createCodeSnippets] target 根目录: ${targetRootDir}`);
+					const moduleRoot = targetRootDir;
 
 					// ✅ 查找头文件（适配 SPM 的 include/ModuleName/ 结构）
-					// 在 Package.swift 所在目录下查找（可能包含 Services/Services/... 这样的结构）
-					const headerPath = await findPath.findSubHeaderPath(moduleRoot, headerNameWithoutExt, moduleName);
+					// 在 target 根目录下查找（可能包含 Code/ 或 Sources/ 这样的结构）
+					const headerPath = await findPath.findSubHeaderPath(targetRootDir, headerNameWithoutExt, moduleName);
 
 					snippet['{content}'] = codeList;
 					snippet['{specName}'] = moduleName;  // ✅ specName 是 target 名称（如 BDNetworkAPI），不是包名（如 Business）
 
 					if (headerPath) {
-						// ✅ headName 存储相对于 Package.swift 所在目录的相对路径
-						// 例如：如果 Package.swift 在 Business/，头文件在 Business/Business/BDNetworkAPI/Code/xxx.h
-						// 则 headName = "Business/BDNetworkAPI/Code/xxx.h"
-						const headerRelativePath = path.relative(moduleRoot, headerPath);
+						// ✅ headName 存储相对于 target 根目录的相对路径
+						// 例如：target 根目录在 BDNetworkAPI/，头文件在 BDNetworkAPI/Code/xxx.h
+						// 则 headName = "Code/xxx.h"
+						const headerRelativePath = path.relative(targetRootDir, headerPath);
 						snippet['{headName}'] = headerRelativePath;
 					} else {
 						// 如果找不到头文件，使用文件名
 						snippet['{headName}'] = fileName;
 					}
 
-					// 查找 README.md
+					// 查找 README.md（在 target 根目录）
 					try {
-						const readmePath = path.join(packageInfo.path, README_NAME);
+						const readmePath = path.join(targetRootDir, README_NAME);
 						await fs.promises.access(readmePath);
-						const moduleRoot = packageInfo.path;
-						const readmeRelativePath = path.relative(moduleRoot, readmePath);
+						const readmeRelativePath = path.relative(targetRootDir, readmePath);
 						snippet['{readme}'] = encodeURI(readmeRelativePath);
 					} catch {
 						// README.md 不存在，跳过
 					}
 
-					// ✅ SPM 模块：.boxspec 文件位置在模块根目录（与 Package.swift 同级）
-					const moduleSpecFile = path.join(packageInfo.path, 'AutoSnippet.boxspec.json');
-					saveFromFile(moduleSpecFile, snippet);
-				}).catch(function (err) {
+					// ✅ SPM 模块：.boxspec 文件位置在 target 根目录（Code 或 Sources 的父目录）
+					const moduleSpecFile = path.join(targetRootDir, 'AutoSnippet.boxspec.json');
+					await saveFromFile(moduleSpecFile, snippet);
+				}).catch(async function (err) {
 					console.error('Error finding Package.swift:', err);
 					snippet['{content}'] = codeList;
-					saveFromFile(specFile, snippet);
+					await saveFromFile(specFile, snippet);
 				});
 			} else {
 				snippet['{content}'] = codeList;
-				saveFromFile(specFile, snippet);
+				await saveFromFile(specFile, snippet);
 			}
 			// 移除ACode标识
 			removeAcodeMark(filePath, positionList);
@@ -315,7 +375,8 @@ function readStream(specFile, filePathArr, snippet, isHaveHeader) {
 	});
 }
 
-function saveFromFile(specFile, snippet) {
+async function saveFromFile(specFile, snippet) {
+	const findPath = require('./findPath.js');
 	let placeholder = null;
 
 	try {
@@ -370,7 +431,58 @@ function saveFromFile(specFile, snippet) {
 				console.log(err);
 			}
 			cache.updateCache(specFile, content);
-			// ✅ 只写入刚创建的代码片段，而不是所有代码片段
+			
+			// ✅ 同步到根目录的 AutoSnippetRoot.boxspec.json
+			try {
+				const rootSpecFile = await findPath.getRootSpecFilePath(specFile);
+				if (rootSpecFile) {
+					// 读取根配置文件
+					let rootPlaceholder = null;
+					try {
+						const rootData = fs.readFileSync(rootSpecFile, 'utf8');
+						if (rootData) {
+							rootPlaceholder = JSON.parse(rootData);
+						}
+					} catch (err) {
+						if (err.code === 'ENOENT') {
+							rootPlaceholder = { list: [] };
+						} else {
+							console.error(`[saveFromFile] 读取根配置文件失败: ${err.message}`);
+						}
+					}
+					
+					if (rootPlaceholder != null) {
+						// 检查是否已存在相同的 identifier
+						let exists = false;
+						if (rootPlaceholder.list) {
+							for (let i = 0; i < rootPlaceholder.list.length; i++) {
+								if (rootPlaceholder.list[i]['{identifier}'] === snippet['{identifier}']) {
+									// 已存在，更新它
+									rootPlaceholder.list[i] = snippet;
+									exists = true;
+									break;
+								}
+							}
+						} else {
+							rootPlaceholder.list = [];
+						}
+						
+						// 如果不存在，添加到列表
+						if (!exists) {
+							rootPlaceholder.list.push(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}`);
+			}
+			
+			// ✅ 只写入刚创建的单个代码片段
 			install.addCodeSnippets(specFile, snippet);
 		}
 	}

package/bin/findPath.js

@@ -4,6 +4,7 @@ const fs = require('fs');
 const path = require('path');
 // 全局常量
 const HOLDER_NAME = 'AutoSnippet.boxspec.json';
+const ROOT_MARKER_NAME = 'AutoSnippetRoot.boxspec.json'; // 项目根目录标记文件
 const PACKAGE_SWIFT = 'Package.swift';
 const README_NAME = 'readme.md';
 
@@ -16,6 +17,23 @@ const CACHE_TTL = 60000; // 缓存 60 秒
  */
 async function getDirectoryEntries(dirPath) {
 	const cacheKey = path.resolve(dirPath);
+	
+	// ✅ 首先检查路径是否是文件，如果是文件，立即返回 null（避免 ENOTDIR 错误）
+	// 注意：这个检查要在缓存检查之前，因为缓存可能包含错误的条目
+	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);
 	
 	if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
@@ -23,6 +41,7 @@ async function getDirectoryEntries(dirPath) {
 	}
 	
 	try {
+		console.log(`[getDirectoryEntries] 尝试读取目录: ${dirPath}`);
 		const entries = await fs.promises.readdir(dirPath, {
 			withFileTypes: true  // 返回 Dirent 对象，减少 stat 调用
 		});
@@ -44,8 +63,10 @@ async function getDirectoryEntries(dirPath) {
 		
 		return entries;
 	} catch (err) {
-		if (err.code === 'ENOENT' || err.code === 'EACCES') {
-			return null;  // 路径不存在或权限不足
+		// ✅ 处理各种文件系统错误
+		console.log(`[getDirectoryEntries] readdir 失败: ${dirPath}, 错误: ${err.code || err.message}`);
+		if (err.code === 'ENOENT' || err.code === 'EACCES' || err.code === 'ENOTDIR') {
+			return null;  // 路径不存在、权限不足或不是目录
 		}
 		throw err;
 	}
@@ -208,7 +229,7 @@ function findASSpecPath(filePath, callback, configPath, configDir) {
 			}
 			return;
 		}
-		
+
 		fs.readdir(currentPath, function (err, files) {
 			if (err) {
 				// 错误处理：权限错误继续查找
@@ -220,7 +241,7 @@ function findASSpecPath(filePath, callback, configPath, configDir) {
 					if (parentResolvedPath === path.resolve(currentPath)) {
 						if (foundConfigPath) {
 							callback(foundConfigPath);
-						} else {
+		} else {
 							console.log('未找到 AutoSnippet.boxspec.json 文件，请检查路径。');
 						}
 						return;
@@ -228,34 +249,34 @@ function findASSpecPath(filePath, callback, configPath, configDir) {
 					
 					search(parentPath, foundConfigPath, foundConfigDir, level + 1);
 				} else {
-					console.log(err);
+			console.log(err);
 				}
-				return;
-			}
+			return;
+		}
 
 			let isFound = false;
 			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;
+		}
 			}
 
 			// 继续向上查找
@@ -270,8 +291,8 @@ function findASSpecPath(filePath, callback, configPath, configDir) {
 				} else {
 					console.log('未找到 AutoSnippet.boxspec.json 文件，请检查路径。');
 				}
-				return;
-			}
+			return;
+		}
 
 			search(parentPath, currentConfigPath, currentConfigDir, level + 1);
 		});
@@ -412,49 +433,121 @@ async function findSubHeaderPath(filePath, headerName, moduleName) {
 
 // 向下查找AutoSnippet配置文件（优化：异步 I/O）
 async function findSubASSpecPath(filePath) {
+	console.log(`[findSubASSpecPath] 开始查找，传入路径: ${filePath}`);
 	let resultArray = [];
 
 	try {
-		const entries = await getDirectoryEntries(filePath);
+		// ✅ 确保 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;
 		}
 
 		for (const entry of entries) {
 			if (entry.isFile() && entry.name === HOLDER_NAME) {
-				resultArray.push(path.join(filePath, entry.name));
+				resultArray.push(path.join(dirPath, entry.name));
 			} else if (entry.isDirectory()) {
 				// 跳过 node_modules、.git 等目录
 				if (entry.name.startsWith('.') || entry.name === 'node_modules') {
 					continue;
 				}
 				
-				const array = await findSubASSpecPath(path.join(filePath, entry.name));
+				const array = await findSubASSpecPath(path.join(dirPath, entry.name));
 				resultArray = resultArray.concat(array);
 			}
 		}
 	} catch (err) {
-		console.log(err);
+		// ✅ 忽略 ENOTDIR 错误（传入的是文件路径）和其他文件系统错误
+		if (err.code !== 'ENOTDIR') {
+			console.log(err);
+		}
 	}
 	
 	return resultArray;
 }
 
 /**
- * 向上查找项目根目录（包含 .git、Package.swift 等的目录）
- * @param {string} filePath - 起始文件路径
- * @returns {Promise<string|null>} 项目根目录路径，如果找不到返回 null
+ * 向上查找项目根目录（查找 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);
+	
+	// 检查路径是文件还是目录
+	try {
+		const stats = await fs.promises.stat(currentPath);
+		if (stats.isFile()) {
+			// 如果是文件，使用其所在目录
+			currentPath = path.dirname(currentPath);
+			console.log(`[findProjectRoot] 检测到文件路径，转换为目录: ${filePath} -> ${currentPath}`);
+		}
+	} 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 {
-			const entries = await getDirectoryEntries(currentPath);
-			if (entries && isProjectRoot(currentPath, entries)) {
-				return currentPath;
+			// ✅ 查找 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);
@@ -464,7 +557,8 @@ async function findProjectRoot(filePath) {
 			currentPath = parentPath;
 			levelsChecked++;
 		} catch (err) {
-			if (err.code === 'ENOENT' || err.code === 'EACCES') {
+			// ✅ 处理各种文件系统错误
+			if (err.code === 'ENOENT' || err.code === 'EACCES' || err.code === 'ENOTDIR') {
 				const parentPath = path.dirname(currentPath);
 				if (parentPath === currentPath) {
 					break;
@@ -477,6 +571,7 @@ async function findProjectRoot(filePath) {
 		}
 	}
 	
+	console.log(`[findProjectRoot] 未找到根目录标记文件 ${ROOT_MARKER_NAME}`);
 	return null;
 }
 
@@ -575,6 +670,35 @@ async function findModuleDirectory(dirPath, moduleName, headerFileName) {
 	return 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) {
+		return null;
+	}
+	const rootSpecFile = path.join(projectRoot, ROOT_MARKER_NAME);
+	
+	// 检查文件是否存在，如果不存在则创建
+	try {
+		await fs.promises.access(rootSpecFile);
+	} catch (err) {
+		if (err.code === 'ENOENT') {
+			// 文件不存在，创建它
+			const specObj = {
+				list: []
+			};
+			const content = JSON.stringify(specObj, null, 4);
+			fs.writeFileSync(rootSpecFile, content, 'utf8');
+		}
+	}
+	
+	return rootSpecFile;
+}
+
 exports.findASSpecPath = findASSpecPath;
 exports.findASSpecPathAsync = findASSpecPathAsync;
 exports.findPackageSwiftPath = findPackageSwiftPath;
@@ -582,4 +706,6 @@ exports.parsePackageSwift = parsePackageSwift;
 exports.findSubHeaderPath = findSubHeaderPath;
 exports.findSubASSpecPath = findSubASSpecPath;
 exports.findProjectRoot = findProjectRoot;
-exports.findModuleHeaderFromRoot = findModuleHeaderFromRoot;
+exports.findModuleHeaderFromRoot = findModuleHeaderFromRoot;
+exports.getRootSpecFilePath = getRootSpecFilePath;
+exports.ROOT_MARKER_NAME = ROOT_MARKER_NAME;

package/bin/init.js

@@ -16,24 +16,36 @@ async function mergeSubSpecs(mainSpecFile) {
 		list: []
 	};
 
-	// ✅ 从项目根目录开始查找，而不是从主配置文件所在目录
-	// 找到项目根目录（包含 .git、Package.swift 等的目录）
-	const projectRoot = await findPath.findProjectRoot(mainSpecFile);
-	const searchRoot = projectRoot || path.dirname(mainSpecFile);
+	// ✅ 找到项目根目录的 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 = mainSpecFile.lastIndexOf('/');
-	const specFilePath = mainSpecFile.substring(0, specSlashIndex + 1);
+	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];
 
 		const slashIndex = filename.lastIndexOf('/');
 		let thePath = filename.substring(0, slashIndex + 1);
-		if (filename === mainSpecFile) {
-			thePath = '';
+		if (filename === rootSpecFile) {
+			// 跳过根目录的 AutoSnippetRoot.boxspec.json，避免循环引用
+			continue;
 		} else {
 			thePath = thePath.replace(specFilePath, '');
 		}
@@ -64,33 +76,92 @@ async function mergeSubSpecs(mainSpecFile) {
 	try {
 		const content = JSON.stringify(specObj, null, 4);
 		if (content) {
-			fs.writeFileSync(mainSpecFile, content, 'utf8');
+			// ✅ 写入根目录的 AutoSnippetRoot.boxspec.json
+			fs.writeFileSync(rootSpecFile, content, 'utf8');
+			console.log(`[mergeSubSpecs] 已聚合 ${specObj.list.length} 个 snippet 到根目录配置文件`);
 		}
 	} catch (err) {
 		console.error(err);
 	}
 }
 
+/**
+ * 从目录路径确定 target 的根目录（包含 Code 或 Sources 的目录）
+ * @param {string} dirPath - 目录路径
+ * @returns {Promise<string|null>} target 根目录路径，如果找不到返回 null
+ */
+async function findTargetRootDirFromPath(dirPath) {
+	let currentPath = path.resolve(dirPath);
+	const maxLevels = 10;
+	let levelsChecked = 0;
+	
+	// ✅ 向上查找包含 Code 或 Sources 目录的目录（target 根目录）
+	while (currentPath && levelsChecked < maxLevels) {
+		try {
+			const entries = await fs.promises.readdir(currentPath, { withFileTypes: true });
+			
+			// 检查当前目录是否包含 Code 或 Sources 目录
+			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;
+				}
+			}
+			
+			// 继续向上查找
+			const parentPath = path.dirname(currentPath);
+			if (parentPath === currentPath) {
+				break;
+			}
+			currentPath = parentPath;
+			levelsChecked++;
+		} catch (err) {
+			if (err.code === 'ENOENT' || err.code === 'EACCES') {
+				break;
+			}
+			throw err;
+		}
+	}
+	
+	console.log(`[findTargetRootDirFromPath] 未找到 target 根目录（Code 或 Sources）`);
+	return null;
+}
+
 async function initSpec() {
-	// ✅ 查找 Package.swift，在其同级目录创建 AutoSnippet.boxspec.json
-	let packagePath = await findPath.findPackageSwiftPath(CMD_PATH);
+	// ✅ 查找 target 根目录（包含 Code 或 Sources 的目录），在该目录创建 AutoSnippet.boxspec.json
+	let targetRootDir = await findTargetRootDirFromPath(CMD_PATH);
+	
+	// 如果找不到 target 根目录，尝试查找 Package.swift 作为后备
+	if (!targetRootDir) {
+		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}`);
+		}
+	}
 	
-	// 如果找不到 Package.swift，使用当前目录
-	const configDir = packagePath ? path.dirname(packagePath) : CMD_PATH;
-	const filePath = path.join(configDir, 'AutoSnippet.boxspec.json');
+	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.18",
+    "version": "1.1.20",
     "description": "A iOS module management tool.",
     "main": "index.js",
     "scripts": {