autosnippet 1.1.14 → 1.1.15

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/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

@@ -229,9 +229,6 @@ 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) {
@@ -261,14 +258,20 @@ function readStream(specFile, filePathArr, snippet, isHaveHeader) {
 					snippet['{headName}'] = fileName;
 
 					if (headerPath) {
-						snippet['{specHeadPath}'] = encodeURI(headerPath.replace(specFilePath, ''));
+						// ✅ 使用 path.relative() 计算相对于配置文件的相对路径
+						const specFileDir = path.dirname(specFile);
+						const relativePath = path.relative(specFileDir, headerPath);
+						snippet['{specHeadPath}'] = encodeURI(relativePath);
 					}
 
 					// 查找 README.md
 					try {
 						const readmePath = path.join(packageInfo.path, README_NAME);
 						await fs.promises.access(readmePath);
-						snippet['{readme}'] = encodeURI(readmePath.replace(specFilePath, ''));
+						// ✅ 使用 path.relative() 计算相对于配置文件的相对路径
+						const specFileDir = path.dirname(specFile);
+						const readmeRelativePath = path.relative(specFileDir, readmePath);
+						snippet['{readme}'] = encodeURI(readmeRelativePath);
 					} catch {
 						// README.md 不存在，跳过
 					}

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,10 +47,14 @@ async function initSpec() {
                             return false;
                         }
                     }
-                    idsArray.push(item['{identifier}']);
-					// 头文件相对路径需要补齐
+					idsArray.push(item['{identifier}']);
+					// ✅ 头文件相对路径需要补齐（将子配置的相对路径转换为相对于主配置的路径）
 					if (item['{specHeadPath}']) {
-						item['{specHeadPath}'] = thePath + item['{specHeadPath}'];
+						// 解码原始路径，拼接子配置路径，再编码
+						const decodedPath = decodeURI(item['{specHeadPath}']);
+						const combinedPath = thePath ? path.join(thePath, decodedPath) : decodedPath;
+						// 规范化路径（处理 .. 和 .）
+						item['{specHeadPath}'] = encodeURI(path.normalize(combinedPath));
 					}
                     return true;
                 });

package/bin/injection.js

@@ -129,9 +129,10 @@ function handelAddHeaderStatus(specFile, updateFile, header, isAddedHeader, isAd
 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];
+			// ✅ 使用 path.join() 正确拼接配置目录和相对路径
+			const specFileDir = path.dirname(specFile);
+			const relativePath = decodeURI(headCache[header.headerName]);
+			const headPath = path.join(specFileDir, relativePath);
 
 			try {
 				// 读取当前头文件所在工作空间里默认暴露的头文件

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.15",
     "description": "A iOS module management tool.",
     "main": "index.js",
     "scripts": {