autosnippet 1.1.18 → 1.1.19

package/bin/findPath.js

@@ -16,6 +16,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 +40,7 @@ async function getDirectoryEntries(dirPath) {
 	}
 	
 	try {
+		console.log(`[getDirectoryEntries] 尝试读取目录: ${dirPath}`);
 		const entries = await fs.promises.readdir(dirPath, {
 			withFileTypes: true  // 返回 Dirent 对象，减少 stat 调用
 		});
@@ -44,8 +62,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 +228,7 @@ function findASSpecPath(filePath, callback, configPath, configDir) {
 			}
 			return;
 		}
-		
+
 		fs.readdir(currentPath, function (err, files) {
 			if (err) {
 				// 错误处理：权限错误继续查找
@@ -220,7 +240,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 +248,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 +290,8 @@ function findASSpecPath(filePath, callback, configPath, configDir) {
 				} else {
 					console.log('未找到 AutoSnippet.boxspec.json 文件，请检查路径。');
 				}
-				return;
-			}
+			return;
+		}
 
 			search(parentPath, currentConfigPath, currentConfigDir, level + 1);
 		});
@@ -412,29 +432,71 @@ 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;
@@ -442,11 +504,34 @@ async function findSubASSpecPath(filePath) {
 
 /**
  * 向上查找项目根目录（包含 .git、Package.swift 等的目录）
- * @param {string} filePath - 起始文件路径
+ * @param {string} filePath - 起始文件路径或目录路径
  * @returns {Promise<string|null>} 项目根目录路径，如果找不到返回 null
  */
 async function findProjectRoot(filePath) {
+	console.log(`[findProjectRoot] 开始查找，传入路径: ${filePath}`);
+	// ✅ 确保从目录路径开始查找，如果是文件路径，先转换为目录路径
 	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;
 	
@@ -464,7 +549,8 @@ async function findProjectRoot(filePath) {
 			currentPath = parentPath;
 			levelsChecked++;
 		} catch (err) {
-			if (err.code === 'ENOENT' || err.code === 'EACCES') {
+			// ✅ 处理各种文件系统错误，包括 ENOTDIR
+			if (err.code === 'ENOENT' || err.code === 'EACCES' || err.code === 'ENOTDIR') {
 				const parentPath = path.dirname(currentPath);
 				if (parentPath === currentPath) {
 					break;

package/bin/init.js

@@ -18,14 +18,19 @@ async function mergeSubSpecs(mainSpecFile) {
 
 	// ✅ 从项目根目录开始查找，而不是从主配置文件所在目录
 	// 找到项目根目录（包含 .git、Package.swift 等的目录）
+	console.log(`[mergeSubSpecs] 主配置文件路径: ${mainSpecFile}`);
 	const projectRoot = await findPath.findProjectRoot(mainSpecFile);
 	const searchRoot = projectRoot || path.dirname(mainSpecFile);
+	console.log(`[mergeSubSpecs] 项目根目录: ${projectRoot || 'null'}`);
+	console.log(`[mergeSubSpecs] 搜索根目录: ${searchRoot}`);
 
 	const specSlashIndex = mainSpecFile.lastIndexOf('/');
 	const specFilePath = mainSpecFile.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];

package/package.json

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