autosnippet 1.1.20 → 1.1.22

package/bin/asnip.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 const fs = require('fs');
+const path = require('path');
 // 读取输入命令
 const inquirer = require('inquirer');
 // 命令行工具
@@ -219,19 +220,32 @@ commander
 commander
 	.command('w')
 	.description('recognize that Snippet automatically injects dependency header files')
-	.action(() => {
-		getSpecFile(function (specFile) {
-			install.addCodeSnippets(specFile);
-			watch.watchFileChange(specFile);
-		});
+	.action(async () => {
+		// ✅ 从执行位置向上查找 AutoSnippetRoot.boxspec.json，找到根目录
+		const projectRoot = await findPath.findProjectRoot(CMD_PATH);
+		
+		if (!projectRoot) {
+			console.error('未找到项目根目录（AutoSnippetRoot.boxspec.json）。');
+			console.error('请先使用 asd root 命令在项目根目录创建根目录标记文件。');
+			return;
+		}
+		
+		console.log(`[asd w] 项目根目录: ${projectRoot}`);
+		
+		// ✅ 使用根目录的 AutoSnippetRoot.boxspec.json 作为配置文件
+		const rootSpecFile = path.join(projectRoot, findPath.ROOT_MARKER_NAME);
+		console.log(`[asd w] 使用配置文件: ${rootSpecFile}`);
+		
+		// 先安装 snippets
+		install.addCodeSnippets(rootSpecFile);
+		// 在根目录启动监听
+		watch.watchFileChange(rootSpecFile, projectRoot);
 	});
 
 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 {

package/bin/findPath.js

@@ -383,7 +383,24 @@ async function parsePackageSwift(packagePath) {
 
 // 向下查找模块头文件（优化：适配 SPM 结构，优先查找 include/ModuleName/ 目录）
 async function findSubHeaderPath(filePath, headerName, moduleName) {
-	// ✅ 优先查找 include/ModuleName/ 目录（SPM 结构）
+	// ✅ 优先查找 Code/ 目录（实际源代码位置）
+	// 按照用户期望的顺序：target根目录 → Code → 子文件夹/头文件
+	const codePath = path.join(filePath, 'Code');
+	try {
+		const stats = await fs.promises.stat(codePath);
+		if (stats.isDirectory()) {
+			// 在 Code 目录中递归查找头文件
+			const result = await findSubHeaderPath(codePath, headerName, null);
+			if (result) {
+				return result;
+			}
+		}
+	} catch {
+		// Code 目录不存在，继续查找
+	}
+	
+	// ✅ 降级：查找 include/ModuleName/ 目录（SPM 公共头文件结构）
+	// 注意：include/ 目录通常是符号链接，但作为后备方案保留
 	if (moduleName) {
 		const includePath = path.join(filePath, 'include', moduleName);
 		try {
@@ -402,7 +419,7 @@ async function findSubHeaderPath(filePath, headerName, moduleName) {
 		}
 	}
 	
-	// ✅ 降级：在整个模块目录中查找（深度限制）
+	// ✅ 最后：在整个模块目录中查找（深度限制）
 	try {
 		const entries = await getDirectoryEntries(filePath);
 		if (!entries) {

package/bin/injection.js

@@ -91,16 +91,40 @@ async function handleHeaderLine(specFile, updateFile, headerLine, importArray, i
 	// 获取当前文件所在的模块名（通过路径判断）
 	const currentModuleName = determineCurrentModuleName(updateFile, currentPackageInfo);
 
-	// ✅ 获取头文件缓存，然后确定头文件所在的模块名
-	const headCache = await cache.getHeadCache(specFile);
-	const headerModuleName = await determineHeaderModuleName(specFile, header, headCache);
+	// ✅ 优先从标记中获取相对路径，如果没有则从缓存获取
+	// 标记格式：// ahead <Module/Header.h> relative/path/to/Header.h
+	let headRelativePath = header.headRelativePathFromMark;
+	if (!headRelativePath) {
+		// 标记中没有相对路径，尝试从缓存获取
+		const headCache = await cache.getHeadCache(specFile);
+		if (headCache && headCache[header.headerName]) {
+			headRelativePath = headCache[header.headerName];
+		}
+	}
+	
+	const headerInfo = await determineHeaderInfo(specFile, header, headRelativePath, currentPackageInfo, currentModuleName);
 
-	// ✅ 更新 header 中的模块名和 specName，确保使用正确的模块名（最近的 target 模块名）
-	header.moduleName = headerModuleName;
-	header.specName = '<' + headerModuleName + '/' + header.headerName + '>';
+	// ✅ 更新 header 中的模块名、相对路径和 specName
+	header.moduleName = headerInfo.moduleName;
+	header.headRelativePath = headerInfo.headRelativePath;  // 相对于模块根目录的相对路径
+	header.specName = '<' + headerInfo.moduleName + '/' + header.headerName + '>';
 
 	// ✅ 判断是否为同一模块
-	const isSameModule = currentModuleName === headerModuleName;
+	const isSameModule = currentModuleName === headerInfo.moduleName;
+
+	// ✅ 如果是同一模块，计算相对于当前文件的相对路径
+	if (isSameModule && headerInfo.headRelativePath) {
+		// 当前文件相对于模块根目录的路径
+		const currentFileRelativeToModuleRoot = path.relative(currentPackageInfo.path, updateFile);
+		// 头文件相对于模块根目录的路径
+		const headRelativeToModuleRoot = headerInfo.headRelativePath;
+		
+		// 计算从当前文件到头文件的相对路径
+		const currentFileDir = path.dirname(currentFileRelativeToModuleRoot);
+		const relativePathToHeader = path.relative(currentFileDir, headRelativeToModuleRoot).replace(/\\/g, '/');
+		
+		header.relativePathToCurrentFile = relativePathToHeader;
+	}
 
 	// 如果是同一模块，使用相对路径；否则使用 <> 格式
 	handleModuleHeader(specFile, updateFile, header, importArray, !isSameModule);
@@ -125,57 +149,112 @@ function determineCurrentModuleName(filePath, packageInfo) {
 }
 
 /**
- * 确定头文件所在的模块名（SPM）
+ * 确定头文件信息（模块名、相对路径等）
  * 从头文件路径查找 Package.swift，确定最近的 target 模块名
+ * 同时计算相对于当前文件的相对路径
+ * @param {string} specFile - 配置文件路径
+ * @param {object} header - 头文件信息对象
+ * @param {string} headRelativePath - 头文件相对路径（相对于模块根目录），可能来自标记或缓存
+ * @param {object} currentPackageInfo - 当前文件的 Package.swift 信息
+ * @param {string} currentModuleName - 当前模块名
  */
-async function determineHeaderModuleName(specFile, header, headCache) {
-	if (!headCache) {
-		// 没有缓存，使用从 headerLine 解析的模块名（可能不准确）
-		return header.moduleName;
-	}
+async function determineHeaderInfo(specFile, header, headRelativePath, currentPackageInfo, currentModuleName) {
+	// 默认值
+	let moduleName = header.moduleName;
+	let relativePathToCurrentFile = null;
 
-	// 从头缓存中获取头文件的相对路径
-	const headRelativePath = headCache[header.headerName];
 	if (!headRelativePath) {
-		// 找不到头文件路径，使用从 headerLine 解析的模块名
-		return header.moduleName;
+		// 没有相对路径，使用从 headerLine 解析的模块名（可能不准确）
+		return {
+			moduleName: moduleName,
+			headRelativePath: null,
+			relativePathToCurrentFile: null
+		};
 	}
 
-	// ✅ specFile 位于模块根目录（如 ModuleRoot/AutoSnippet.boxspec.json）
-	const moduleRootDir = path.dirname(specFile);
-	const headPath = path.join(moduleRootDir, headRelativePath);
+	// ✅ specFile 可能是根目录的 AutoSnippetRoot.boxspec.json，需要找到头文件所在的模块配置
+	// 尝试从根目录的配置文件查找头文件所在的模块
+	const rootSpecDir = path.dirname(specFile);
+	let headPath = null;
+	
+	// 尝试多种可能的路径
+	// 1. 直接使用根目录的相对路径
+	headPath = path.join(rootSpecDir, headRelativePath);
+	
+	// 2. 如果文件不存在，尝试从子模块中查找
+	if (!fs.existsSync(headPath)) {
+		// 从头文件路径向上查找 Package.swift
+		const headerPackagePath = await findPath.findPackageSwiftPath(headPath);
+		if (headerPackagePath) {
+			const headerPackageInfo = await findPath.parsePackageSwift(headerPackagePath);
+			if (headerPackageInfo) {
+				// 找到 Package.swift，使用它的路径作为模块根目录
+				const headerModuleRootDir = path.dirname(headerPackagePath);
+				headPath = path.join(headerModuleRootDir, headRelativePath);
+			}
+		}
+	}
 
 	// 从头文件路径向上查找 Package.swift
 	const headerPackagePath = await findPath.findPackageSwiftPath(headPath);
 	if (!headerPackagePath) {
 		// 找不到 Package.swift，使用从 headerLine 解析的模块名
-		return header.moduleName;
+		return {
+			moduleName: moduleName,
+			headRelativePath: headRelativePath,
+			relativePathToCurrentFile: null
+		};
 	}
 
 	// 解析 Package.swift 获取模块信息
 	const headerPackageInfo = await findPath.parsePackageSwift(headerPackagePath);
 	if (!headerPackageInfo) {
-		return header.moduleName;
+		return {
+			moduleName: moduleName,
+			headRelativePath: headRelativePath,
+			relativePathToCurrentFile: null
+		};
 	}
 
 	// ✅ 根据头文件路径确定最近的 target 模块名
-	return determineCurrentModuleName(headPath, headerPackageInfo);
+	moduleName = determineCurrentModuleName(headPath, headerPackageInfo);
+
+	// ✅ 如果是同一模块，计算相对于当前文件的相对路径
+	// 注意：这里需要知道当前文件的路径，所以需要从外部传入
+	// 但当前函数中还没有 updateFile，所以这部分逻辑在 handleHeaderLine 中完成
+
+	return {
+		moduleName: moduleName,
+		headRelativePath: headRelativePath,
+		relativePathToCurrentFile: null  // 将在 handleHeaderLine 中计算
+	};
 }
 
 // isOuter区分模块内部引用""格式和模块外部引用<>格式
 // ✅ SPM 模块：
-//    - isOuter = false：同一模块内部，使用相对路径 #import "Header.h"
+//    - isOuter = false：同一模块内部，使用相对路径 #import "relative/path/Header.h" 或 #import "Header.h"
 //    - isOuter = true：不同模块之间，使用 #import <ModuleName/Header.h>
 function handleModuleHeader(specFile, updateFile, header, importArray, isOuter) {
-	// ✅ 根据 isOuter 选择不同的引入格式
-	const headName = isOuter ? header.name : header.headerStrName;  // isOuter: <ModuleName/Header.h>, 否则: "Header.h"
+	// ✅ 根据 isOuter 选择不同的引入格式，用于检查是否已存在
+	let headNameToCheck;
+	if (isOuter) {
+		// 外部模块，使用 <> 格式
+		headNameToCheck = header.name;  // <ModuleName/Header.h>
+	} else {
+		// 同一模块内部，使用相对路径
+		if (header.relativePathToCurrentFile) {
+			headNameToCheck = '"' + header.relativePathToCurrentFile + '"';  // "relative/path/Header.h"
+		} else {
+			headNameToCheck = header.headerStrName;  // "Header.h"
+		}
+	}
 	const moduleName = isOuter ? header.specName : header.moduleStrName;
 
 	// 检查是否已经引入头文件
 	for (let i = 0; i < importArray.length; i++) {
 		const importHeader = importArray[i].split(importMark)[1].trim();
 
-		if (importHeader === headName) {
+		if (importHeader === headNameToCheck) {
 			// 已经引入头文件
 			handelAddHeaderStatus(specFile, updateFile, header, true, false, isOuter);
 			return;
@@ -267,10 +346,21 @@ function removeMarkFromFile(updateFile, header, string) {
 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"
+	// isOuter = false: 使用相对路径（#import "relative/path/Header.h" 或 #import "Header.h"）
+	let importLine;
+	if (isOuter) {
+		// 外部模块，使用 <> 格式
+		importLine = importMark + ' ' + header.name;  // <ModuleName/Header.h>
+	} else {
+		// 同一模块内部，使用相对路径
+		if (header.relativePathToCurrentFile) {
+			// 使用计算出的相对路径（如 "SubDir/Header.h" 或 "../Header.h"）
+			importLine = importMark + ' "' + header.relativePathToCurrentFile + '"';
+		} else {
+			// 如果没有相对路径，使用文件名（如 "Header.h"）
+			importLine = importMark + ' ' + header.headerStrName;  // "Header.h"
+		}
+	}
 	
 	readStream(updateFile, importLine, importMark);
 	checkDependency(updateFile, header.moduleName, '自动注入头文件完成。').catch(err => {

package/bin/install.js

@@ -30,6 +30,11 @@ function writeSingleSnippet(snippet, template) {
 		// 例如：<BDVideoPlayer/BDVideoCacheManager.h> 而不是 <BDVideoPlayer/UI/BDVideoPlayer/Code/BDVideoCacheManager.h>
 		const headerFileName = path.basename(extPlace['{headName}']);
 		let header = '<' + extPlace['{specName}'] + '/' + headerFileName + '>';
+		
+		// ✅ 在标记中包含相对路径信息，格式：// ahead <Module/Header.h> relative/path/to/Header.h
+		// 这样即使没有缓存也能解析出完整信息
+		const headRelativePath = extPlace['{headName}'];  // 相对于模块根目录的相对路径
+		header = header + ' ' + headRelativePath;
 		header = escapeString(header);
 
 		// swift只需要考虑工作空间是否引入
@@ -42,7 +47,7 @@ function writeSingleSnippet(snippet, template) {
 		extPlace['{completion}'] = extPlace['{completion}'] + 'Z';
 		extPlace['{summary}'] = extPlace['{summary}'] + header;
 
-		// 添加替换header标识位
+		// 添加替换header标识位（格式：// ahead <Module/Header.h> relative/path/to/Header.h）
 		let array = ['// ahead ' + header];
 		extPlace['{content}'].forEach(element => {
 			array.push(element);
@@ -159,6 +164,11 @@ function addCodeSnippets(specFile, singleSnippet) {
 				// ✅ 从项目根目录找到模块，只使用模块名和头文件名
 				const headerFileName = path.basename(extPlace['{headName}']);
 				let header = '<' + extPlace['{specName}'] + '/' + headerFileName + '>';
+				
+				// ✅ 在标记中包含相对路径信息，格式：// ahead <Module/Header.h> relative/path/to/Header.h
+				// 这样即使没有缓存也能解析出完整信息
+				const headRelativePath = extPlace['{headName}'];  // 相对于模块根目录的相对路径
+				header = header + ' ' + headRelativePath;
 				header = escapeString(header);
 
 				// swift只需要考虑工作空间是否引入

package/bin/watch.js

@@ -14,7 +14,8 @@ const alinkMark = 'alink';
 const wellMark = '#';
 const atMark = '@';
 
-const headerReg = /^\/\/ ahead <\w+\/\w+.h>$/;
+// ✅ 更新正则以匹配包含相对路径的新格式：// ahead <Module/Header.h> relative/path/to/Header.h
+const headerReg = /^\/\/ ahead <\w+\/\w+.h>(\s+.+)?$/;
 const headerSwiftReg = /^\/\/ ahead \w+$/;
 const importReg = /^\#import\s*<\w+\/\w+.h>$/;
 const importSwiftReg = /^import\s*\w+$/;
@@ -22,10 +23,11 @@ const importSwiftReg = /^import\s*\w+$/;
 let timeoutLink = null;
 let timeoutHead = null;
 
-function watchFileChange(specFile) {
-
-	// 监听文件变化
-	const filePath = CMD_PATH;
+function watchFileChange(specFile, watchRootPath) {
+	// ✅ 如果指定了监听根目录，使用它；否则使用当前工作目录
+	const filePath = watchRootPath || CMD_PATH;
+	console.log(`[watchFileChange] 监听目录: ${filePath}`);
+	console.log(`[watchFileChange] 配置文件: ${specFile}`);
 	let isReading = false;
 
 	fs.watch(filePath, {recursive: true}, (event, filename) => {

package/package.json

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