autosnippet 1.1.19 → 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';
 
@@ -503,13 +504,13 @@ async function findSubASSpecPath(filePath) {
 }
 
 /**
- * 向上查找项目根目录（包含 .git、Package.swift 等的目录）
+ * 向上查找项目根目录（查找 AutoSnippetRoot.boxspec.json 文件）
  * @param {string} filePath - 起始文件路径或目录路径
- * @returns {Promise<string|null>} 项目根目录路径，如果找不到返回 null
+ * @returns {Promise<string|null>} 项目根目录路径（AutoSnippetRoot.boxspec.json 所在目录），如果找不到返回 null
  */
 async function findProjectRoot(filePath) {
 	console.log(`[findProjectRoot] 开始查找，传入路径: ${filePath}`);
-	// ✅ 确保从目录路径开始查找，如果是文件路径，先转换为目录路径
+	// ✅ 简化逻辑：向上查找 AutoSnippetRoot.boxspec.json 文件
 	let currentPath = path.resolve(filePath);
 	
 	// 检查路径是文件还是目录
@@ -537,9 +538,16 @@ async function findProjectRoot(filePath) {
 	
 	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);
@@ -549,7 +557,7 @@ async function findProjectRoot(filePath) {
 			currentPath = parentPath;
 			levelsChecked++;
 		} catch (err) {
-			// ✅ 处理各种文件系统错误，包括 ENOTDIR
+			// ✅ 处理各种文件系统错误
 			if (err.code === 'ENOENT' || err.code === 'EACCES' || err.code === 'ENOTDIR') {
 				const parentPath = path.dirname(currentPath);
 				if (parentPath === currentPath) {
@@ -563,6 +571,7 @@ async function findProjectRoot(filePath) {
 		}
 	}
 	
+	console.log(`[findProjectRoot] 未找到根目录标记文件 ${ROOT_MARKER_NAME}`);
 	return null;
 }
 
@@ -661,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;
@@ -668,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,16 +16,22 @@ async function mergeSubSpecs(mainSpecFile) {
 		list: []
 	};
 
-	// ✅ 从项目根目录开始查找，而不是从主配置文件所在目录
-	// 找到项目根目录（包含 .git、Package.swift 等的目录）
+	// ✅ 找到项目根目录的 AutoSnippetRoot.boxspec.json 文件
 	console.log(`[mergeSubSpecs] 主配置文件路径: ${mainSpecFile}`);
-	const projectRoot = await findPath.findProjectRoot(mainSpecFile);
-	const searchRoot = projectRoot || path.dirname(mainSpecFile);
-	console.log(`[mergeSubSpecs] 项目根目录: ${projectRoot || 'null'}`);
+	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}`);
@@ -37,8 +43,9 @@ async function mergeSubSpecs(mainSpecFile) {
 
 		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, '');
 		}
@@ -69,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.19",
+    "version": "1.1.20",
     "description": "A iOS module management tool.",
     "main": "index.js",
     "scripts": {