autosnippet 1.7.3 → 1.7.4

package/lib/injection/injectionService.js

@@ -16,6 +16,17 @@ const ImportDecisionEngine = require('./ImportDecisionEngine');
 
 const importDecisionEngine = new ImportDecisionEngine();
 
+/**
+ * 依赖被阻止异常（循环依赖、反向依赖、用户取消）
+ */
+class DependencyBlockedError extends Error {
+  constructor(message, reason) {
+    super(message);
+    this.name = 'DependencyBlockedError';
+    this.reason = reason;
+  }
+}
+
 function buildDependencySuggestionNote(ensureResult) {
   try {
   const suggestion = ensureResult && ensureResult.suggestion ? String(ensureResult.suggestion) : '';
@@ -81,25 +92,46 @@ const shownPolicyAlerts = new Set();
 function maybeAlertPolicyBlocked(fromModule, toModule, ensureResult) {
   try {
   const reason = ensureResult && ensureResult.reason ? String(ensureResult.reason) : '';
-  if (reason !== 'cycleBlocked') return;
+  
+  // 只对 cycleBlocked 和 downwardDependency 弹窗（阻止策略）
+  if (reason !== 'cycleBlocked' && reason !== 'downwardDependency') return;
+  
   const key = `${fromModule}=>${toModule}`;
   if (shownPolicyAlerts.has(key)) return;
   shownPolicyAlerts.add(key);
 
   const extra = ensureResult && ensureResult.suggestion ? `\n\n${String(ensureResult.suggestion)}` : '';
+  const moduleLine = `${fromModule} -> ${toModule}`;
+  let detail = ensureResult && ensureResult.message ? `\n${String(ensureResult.message)}` : '';
+  if (reason === 'cycleBlocked' && detail.includes('Package.swift')) {
+  detail = '\n跨包循环依赖';
+  }
+  
+  let title = 'AutoSnippet SPM 依赖策略';
+  if (reason === 'cycleBlocked') {
+    title = 'AutoSnippet SPM - 循环依赖';
+  } else if (reason === 'downwardDependency') {
+    title = 'AutoSnippet SPM - 反向依赖';
+  }
+  
   notifier.alert(
-    `已阻止依赖注入（形成反向引入/循环）\n\n${fromModule} -> ${toModule}${extra}`,
-    { title: 'AutoSnippet SPM 依赖策略', givingUpAfterSeconds: 12 }
+    `已阻止依赖注入\n\n${moduleLine}${detail}${extra}`,
+    { title, givingUpAfterSeconds: 12 }
   );
   } catch {
   // ignore
   }
 }
 
-async function handleHeaderLine(specFile, updateFile, headerLine, importArray, isSwift) {
+async function handleHeaderLine(specFile, updateFile, headerLine, importArray, isSwift, options = {}) {
+  const result = { suggestionNote: null, decisionAction: null };
+
   if (isSwift) {
-  await handleHeaderLineSwift(specFile, updateFile, headerLine, importArray);
-  return;
+  const swiftResult = await handleHeaderLineSwift(specFile, updateFile, headerLine, importArray, options);
+  if (swiftResult && swiftResult.suggestionNote) {
+    result.suggestionNote = swiftResult.suggestionNote;
+  }
+  return result;
   }
 
   const projectRoot = getProjectRoot(specFile);
@@ -109,7 +141,7 @@ async function handleHeaderLine(specFile, updateFile, headerLine, importArray, i
   const importWriter = getImportWriter(projectRoot);
   
   const header = directiveParser.createHeader(headerLine);
-  if (!header) return;
+  if (!header) return result;
   
   // 判断引号格式：moduleName 为空字符串表示引号格式 "Header.h"
   // 尖括号格式：moduleName 有值，例如 <Module/Header.h>
@@ -118,22 +150,28 @@ async function handleHeaderLine(specFile, updateFile, headerLine, importArray, i
   if (isQuotedHeader) {
   // 引号格式：设置 relativePathToCurrentFile 以便 _buildImportLine 构建正确的 import 语句
   header.relativePathToCurrentFile = header.headerName;
-  await importWriter.addHeaderToFile(updateFile, header, false);
-  return;
+  if (!options.preflight) {
+    await importWriter.addHeaderToFile(updateFile, header, false);
+  }
+  return result;
   }
 
   const updateFileDir = path.dirname(updateFile);
   const currentPackagePath = await packageParser.findPackageSwiftPath(updateFileDir);
 
   if (!currentPackagePath) {
-  await importWriter.handleModuleHeader(specFile, updateFile, header, importArray, true);
-  return;
+  if (!options.preflight) {
+    await importWriter.handleModuleHeader(specFile, updateFile, header, importArray, true);
+  }
+  return result;
   }
 
   const currentPackageInfo = await packageParser.parsePackageSwift(currentPackagePath);
   if (!currentPackageInfo) {
-  await importWriter.handleModuleHeader(specFile, updateFile, header, importArray, true);
-  return;
+  if (!options.preflight) {
+    await importWriter.handleModuleHeader(specFile, updateFile, header, importArray, true);
+  }
+  return result;
   }
 
   const currentModuleName = moduleResolver.determineCurrentModule(updateFile, currentPackageInfo);
@@ -248,11 +286,37 @@ async function handleHeaderLine(specFile, updateFile, headerLine, importArray, i
     // policy=block：提前拦截，禁止写入头文件/import
     if (decision.action === 'block') {
     maybeAlertPolicyBlocked(currentModuleName, headerInfo.moduleName, ensureResult);
-    return;
+    throw new DependencyBlockedError(
+      `依赖被阻止：${currentModuleName} -> ${headerInfo.moduleName} (${ensureResult.reason})`,
+      ensureResult.reason
+    );
     }
 
     // allowActions 弹窗决策
     if (decision.action === 'review' && ensureResult.allowActions && ensureResult.allowActions.length > 1) {
+    if (options.skipPrompt) {
+      const selectedAction = options.decisionAction || 'insertAnyway';
+      result.decisionAction = selectedAction;
+      if (selectedAction === 'cancel') {
+      throw new DependencyBlockedError(
+        `用户取消操作：${currentModuleName} -> ${headerInfo.moduleName}`,
+        'userCanceled'
+      );
+      }
+      if (selectedAction === 'suggestPatch') {
+      const note = options.suggestionNote || buildDependencySuggestionNote(ensureResult);
+      if (note) result.suggestionNote = note;
+      }
+      if (selectedAction === 'autoFix') {
+      const deps2 = getSpmDepsService(projectRoot);
+      const fixResult = await deps2.ensureDependency(specFile, currentPackagePath, currentModuleName, headerInfo.moduleName, { forceFix: true });
+      if (fixResult && fixResult.changed) {
+        console.log(`✅ [AutoSnippet][SPM] 已自动补齐依赖：${currentModuleName} -> ${headerInfo.moduleName}`);
+        notifier.notify(`已补齐依赖：${currentModuleName} -> ${headerInfo.moduleName}`, { title: 'AutoSnippet SPM' });
+        header.dependencyNote = buildDependencyFixedNote(fixResult);
+      }
+      }
+    } else {
     const buttonMap = {
       'insertAnyway': '直接插入（信任架构）',
       'suggestPatch': '显示建议补丁',
@@ -276,13 +340,19 @@ async function handleHeaderLine(specFile, updateFile, headerLine, importArray, i
       '取消操作': 'cancel'
     };
     const selectedAction = actionMap[userChoice] || 'cancel';
+    result.decisionAction = selectedAction;
 
-    if (selectedAction === 'cancel') return;
+    if (selectedAction === 'cancel') {
+      throw new DependencyBlockedError(
+        `用户取消操作：${currentModuleName} -> ${headerInfo.moduleName}`,
+        'userCanceled'
+      );
+    }
     if (selectedAction === 'suggestPatch') {
       if (ensureResult.suggestion) console.log(ensureResult.suggestion);
       notifier.notify(`建议补丁已在控制台输出`, { title: 'AutoSnippet' });
       const note = buildDependencySuggestionNote(ensureResult);
-      if (note) header.dependencyNote = note;
+      if (note) result.suggestionNote = note;
     }
     if (selectedAction === 'autoFix') {
       // 再次调用 ensureDependency 触发修复（此次使用 fix 模式）
@@ -296,6 +366,7 @@ async function handleHeaderLine(specFile, updateFile, headerLine, importArray, i
     }
     // 其他情况（insertAnyway/suggestPatch/autoFix后）继续插入
     }
+    }
   } else if (ensureResult.changed) {
     console.log(`✅ [AutoSnippet][SPM] 已自动补齐依赖：${currentModuleName} -> ${headerInfo.moduleName}`);
     header.dependencyNote = buildDependencyFixedNote(ensureResult);
@@ -318,10 +389,15 @@ async function handleHeaderLine(specFile, updateFile, headerLine, importArray, i
   }
 
   const shouldUseRelativePath = isSameDirectory || isSameModule || (headFullPath && fs.existsSync(headFullPath));
+  if (!options.preflight) {
   await importWriter.handleModuleHeader(specFile, updateFile, header, importArray, !shouldUseRelativePath);
+  }
+  return result;
 }
 
-async function handleHeaderLineSwift(specFile, updateFile, headerLine, importArray) {
+async function handleHeaderLineSwift(specFile, updateFile, headerLine, importArray, options = {}) {
+  const result = { suggestionNote: null, decisionAction: null };
+
   const projectRoot = getProjectRoot(specFile);
   const packageParser = getPackageParser(projectRoot);
   const deps = getSpmDepsService(projectRoot);
@@ -331,7 +407,7 @@ async function handleHeaderLineSwift(specFile, updateFile, headerLine, importArr
   
   const parsed = directiveParser.parse(headerLine);
   const moduleName = (parsed && parsed.content) ? parsed.content : '';
-  if (!moduleName) return;
+  if (!moduleName) return result;
 
   // Swift import 同样需要 target 依赖；尽量与 ObjC 路径一致：跨 module 时补齐 SPM 依赖
   try {
@@ -354,11 +430,36 @@ async function handleHeaderLineSwift(specFile, updateFile, headerLine, importArr
       // policy=block：提前拦截，禁止写入 import
       if (ensureResult.reason === 'cycleBlocked' || ensureResult.reason === 'downwardDependency') {
         maybeAlertPolicyBlocked(currentModuleName, moduleName, ensureResult);
-        return;
+        throw new DependencyBlockedError(
+        `依赖被阻止：${currentModuleName} -> ${moduleName} (${ensureResult.reason})`,
+        ensureResult.reason
+        );
       }
 
       // allowActions 弹窗决策
       if (ensureResult.allowActions && ensureResult.allowActions.length > 1) {
+        if (options.skipPrompt) {
+        const selectedAction = options.decisionAction || 'insertAnyway';
+        result.decisionAction = selectedAction;
+        if (selectedAction === 'cancel') {
+          throw new DependencyBlockedError(
+          `用户取消操作：${currentModuleName} -> ${moduleName}`,
+          'userCanceled'
+          );
+        }
+        if (selectedAction === 'suggestPatch') {
+          const note = options.suggestionNote || buildDependencySuggestionNote(ensureResult);
+          if (note) result.suggestionNote = note;
+        }
+        if (selectedAction === 'autoFix') {
+          const deps2 = getSpmDepsService(projectRoot);
+          const fixResult = await deps2.ensureDependency(specFile, currentPackagePath, currentModuleName, moduleName, { forceFix: true });
+          if (fixResult && fixResult.changed) {
+          console.log(`✅ [AutoSnippet][SPM] 已自动补齐依赖：${currentModuleName} -> ${moduleName}`);
+          notifier.notify(`已补齐依赖：${currentModuleName} -> ${moduleName}`, { title: 'AutoSnippet SPM' });
+          }
+        }
+        } else {
         const buttonMap = {
         'insertAnyway': '直接插入（信任架构）',
         'suggestPatch': '显示建议补丁',
@@ -381,11 +482,19 @@ async function handleHeaderLineSwift(specFile, updateFile, headerLine, importArr
         '取消操作': 'cancel'
         };
         const selectedAction = actionMap[userChoice] || 'cancel';
+        result.decisionAction = selectedAction;
 
-        if (selectedAction === 'cancel') return;
+        if (selectedAction === 'cancel') {
+        throw new DependencyBlockedError(
+          `用户取消操作：${currentModuleName} -> ${moduleName}`,
+          'userCanceled'
+        );
+        }
         if (selectedAction === 'suggestPatch') {
         if (ensureResult.suggestion) console.log(ensureResult.suggestion);
         notifier.notify(`建议补丁已在控制台输出`, { title: 'AutoSnippet' });
+        const note = buildDependencySuggestionNote(ensureResult);
+        if (note) result.suggestionNote = note;
         }
         if (selectedAction === 'autoFix') {
         const deps2 = getSpmDepsService(projectRoot);
@@ -395,6 +504,7 @@ async function handleHeaderLineSwift(specFile, updateFile, headerLine, importArr
           notifier.notify(`已补齐依赖：${currentModuleName} -> ${moduleName}`, { title: 'AutoSnippet SPM' });
         }
         }
+        }
       }
       } else if (ensureResult.changed) {
       console.log(`✅ [AutoSnippet][SPM] 已自动补齐依赖：${currentModuleName} -> ${moduleName}`);
@@ -417,7 +527,10 @@ async function handleHeaderLineSwift(specFile, updateFile, headerLine, importArr
     }
     }
   }
-  } catch {
+  } catch (err) {
+  if (err && err.name === 'DependencyBlockedError') {
+    throw err;
+  }
   // ignore - 依赖补齐失败不应阻断 import 注入
   }
 
@@ -431,9 +544,11 @@ async function handleHeaderLineSwift(specFile, updateFile, headerLine, importArr
   }
   }
 
-  if (!isAddedHeader) {
+  if (!isAddedHeader && !options.preflight) {
   await importWriter.addImportToFileSwift(updateFile, moduleName, '自动注入 import 完成。');
   }
+
+  return result;
 }
 
 module.exports = {

package/lib/watch/handlers/HeaderHandler.js

@@ -4,8 +4,13 @@
 
 const fs = require('fs');
 const path = require('path');
+const { promisify } = require('util');
 const injection = require('../../injection/injectionService.js');
 const AutomationOrchestrator = require('../../automation/AutomationOrchestrator');
+const notifier = require('../../infrastructure/notification/Notifier');
+
+const accessAsync = promisify(fs.access);
+const readFileAsync = promisify(fs.readFile);
 
 const automationOrchestrator = new AutomationOrchestrator();
 
@@ -24,38 +29,241 @@ class HeaderHandler {
   );
   }
 
-  async _handleHeader(context) {
-  const { specFile, updateFile, headerLine, importArray, isSwift } = context;
-  if (isSwift || updateFile.endsWith('.h')) {
-    await injection.handleHeaderLine(specFile, updateFile, headerLine, importArray, isSwift);
-    return;
+  async handleHeadersBatch(specFile, updateFile, headersToInsert, options = {}) {
+  const safeHeaders = Array.isArray(headersToInsert) ? headersToInsert : [];
+  const isSwift = options.isSwift === true || updateFile.endsWith('.swift');
+  const debug = options.debug === true;
+  const suggestionNotes = [];
+  const decisions = options.decisions || {};
+  const preflight = options.preflight === true;
+
+  if (debug) {
+    console.log(`\n[HeaderDebug] 头文件处理:`);
+    console.log(`   总共定义头文件: ${safeHeaders.length} 个`);
+    if (safeHeaders.length > 0) {
+    safeHeaders.forEach((h, idx) => {
+      console.log(`      [${idx + 1}] ${h}`);
+    });
+    }
+  }
+
+  let headerInsertCount = 0;
+  if (safeHeaders.length === 0) return { blocked: false, headerInsertCount, suggestionNotes, decisions };
+
+  const importArray = this._collectImportsFromFile(updateFile, isSwift);
+  if (!isSwift && !updateFile.endsWith('.h')) {
+    await this._collectImportsFromHeaderFile(updateFile, importArray);
+  }
+
+  for (const header of safeHeaders) {
+    try {
+    if (debug) {
+      console.log(`   处理头文件: ${header}`);
+    }
+    let directiveLine = header;
+    if (isSwift) {
+      directiveLine = header.replace(/^import\s+/, '// as:import ');
+    } else {
+      directiveLine = header.replace(/^#import\s+/, '// as:include ');
+    }
+    const decision = decisions[header];
+    const handleResult = await injection.handleHeaderLine(
+      specFile,
+      updateFile,
+      directiveLine,
+      importArray,
+      isSwift,
+      {
+      preflight,
+      skipPrompt: !!decision,
+      decisionAction: decision ? decision.action : null,
+      suggestionNote: decision ? decision.suggestionNote : null
+      }
+    );
+    if (handleResult && handleResult.suggestionNote) {
+      suggestionNotes.push(handleResult.suggestionNote);
+      if (preflight) {
+      decisions[header] = {
+        action: handleResult.decisionAction || 'suggestPatch',
+        suggestionNote: handleResult.suggestionNote
+      };
+      }
+    } else if (preflight) {
+      decisions[header] = {
+      action: handleResult && handleResult.decisionAction ? handleResult.decisionAction : 'insertAnyway',
+      suggestionNote: null
+      };
+    }
+    if (!importArray.includes(header)) {
+      importArray.push(header);
+      headerInsertCount++;
+    }
+    } catch (err) {
+    console.error(`   ❌ 处理头文件失败: ${header}`, err.message);
+    if (err.name === 'DependencyBlockedError') {
+      notifier.notify(`操作已取消: ${err.message}`, { title: 'AutoSnippet - 头文件注入' });
+      return { blocked: true, headerInsertCount, suggestionNotes };
+    }
+    if (process.env.ASD_SPM_CHECK_STRICT === '1') {
+      notifier.notify(`依赖缺失: ${header}${err.message ? `\n\n${err.message}` : ''}`, { title: 'AutoSnippet' });
+      return { blocked: true, headerInsertCount, suggestionNotes };
+    }
+    }
+  }
+
+  if (debug) {
+    console.log(`   ✅ 已处理 ${headerInsertCount} 个头文件`);
   }
 
+  return { blocked: false, headerInsertCount, suggestionNotes, decisions };
+  }
+
+  formatSuggestionNotes(suggestionNotes, indent = '') {
+  if (!Array.isArray(suggestionNotes) || suggestionNotes.length === 0) return [];
+  const lines = [];
+  const seen = new Set();
+  for (const note of suggestionNotes) {
+    if (!note) continue;
+    String(note)
+    .split(/\r?\n/)
+    .forEach((line) => {
+      if (!line || !line.trim()) return;
+      const key = line.trim();
+      if (seen.has(key)) return;
+      seen.add(key);
+      lines.push(indent + line);
+    });
+  }
+  return lines;
+  }
+
+  _collectImportsFromFile(filePath, isSwift) {
+  try {
+    if (!fs.existsSync(filePath)) return [];
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split(/\r?\n/);
+    const imports = [];
+    for (const line of lines) {
+    const trimmed = line.trim();
+    if (isSwift) {
+      if (trimmed.startsWith('import ')) {
+      imports.push(trimmed);
+      }
+    } else {
+      if (trimmed.startsWith('#import ') || trimmed.startsWith('@import ') || trimmed.startsWith('#include ')) {
+      imports.push(trimmed);
+      }
+    }
+    }
+    return imports;
+  } catch (err) {
+    console.warn('读取文件 imports 失败:', err.message);
+    return [];
+  }
+  }
+
+  async _collectImportsFromHeaderFile(updateFile, importArray) {
   const dotIndex = updateFile.lastIndexOf('.');
+  if (dotIndex <= 0) return;
   const mainPathFile = updateFile.substring(0, dotIndex) + '.h';
+  try {
+    await accessAsync(mainPathFile, fs.constants.F_OK);
+    const data = await readFileAsync(mainPathFile, 'utf8');
+    const lineArray = data.split('\n');
+    lineArray.forEach(element => {
+    const lineVal = element.trim();
+    if (this.importReg.test(lineVal)) {
+      importArray.push(lineVal);
+    }
+    });
+  } catch (err) {
+    console.log(`   ℹ️  无法读取 ${path.basename(mainPathFile)}，使用现有 importArray`);
+  }
+  }
 
-  fs.access(mainPathFile, fs.constants.F_OK, async (err) => {
-    if (err) {
+  computePasteLineNumber(triggerLineNumber, headerInsertCount, filePath, options = {}) {
+  const expectedCount = Number.isFinite(options.expectedHeaderCount)
+    ? options.expectedHeaderCount
+    : headerInsertCount;
+  if (expectedCount > 0) {
+    if (options.forceOffset) {
+    return triggerLineNumber + expectedCount;
+    }
+    const headerInsertPosition = this._getLastImportLine(filePath);
+    if (headerInsertPosition > 0 && headerInsertPosition < triggerLineNumber) {
+    return triggerLineNumber + expectedCount;
+    }
+  }
+  return triggerLineNumber;
+  }
+
+  _getLastImportLine(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return 0;
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split(/\r?\n/);
+    let lastImportIdx = -1;
+    for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (trimmed.startsWith('#import ') || trimmed.startsWith('@import ') || trimmed.startsWith('#include ') || trimmed.startsWith('import ')) {
+      lastImportIdx = i;
+    }
+    }
+    return lastImportIdx >= 0 ? lastImportIdx + 1 : 0;
+  } catch (err) {
+    return 0;
+  }
+  }
+
+  async _handleHeader(context) {
+  const { specFile, updateFile, headerLine, importArray, isSwift } = context;
+  
+  try {
+    if (isSwift || updateFile.endsWith('.h')) {
     await injection.handleHeaderLine(specFile, updateFile, headerLine, importArray, isSwift);
     return;
     }
-    fs.readFile(mainPathFile, 'utf8', async (readErr, data) => {
-    if (readErr) {
-      await injection.handleHeaderLine(specFile, updateFile, headerLine, importArray, isSwift);
-      return;
-    }
 
+    const dotIndex = updateFile.lastIndexOf('.');
+    const mainPathFile = updateFile.substring(0, dotIndex) + '.h';
+
+    // 尝试读取 .h 文件中已有的 imports
+    try {
+    await accessAsync(mainPathFile, fs.constants.F_OK);
+    const data = await readFileAsync(mainPathFile, 'utf8');
     const lineArray = data.split('\n');
+    
     lineArray.forEach(element => {
       const lineVal = element.trim();
       if (this.importReg.test(lineVal)) {
       importArray.push(lineVal);
       }
     });
+    } catch (err) {
+    // .h 文件不存在或读取失败，继续处理
+    console.log(`   ℹ️  无法读取 ${path.basename(mainPathFile)}，使用现有 importArray`);
+    }
 
+    // 调用 injection 服务处理头文件
     await injection.handleHeaderLine(specFile, updateFile, headerLine, importArray, isSwift);
+    
+  } catch (err) {
+    // DependencyBlockedError: 依赖被阻止（循环/反向/用户取消）
+    if (err.name === 'DependencyBlockedError') {
+    console.error(`   ❌ 头文件注入被阻止: ${err.message}`);
+    notifier.notify(`操作已取消: ${err.message}`, { 
+      title: 'AutoSnippet - 头文件注入' 
     });
-  });
+    // 不抛出异常，避免中断 watch 流程
+    return;
+    }
+    
+    // 其他错误：记录并通知
+    console.error(`   ❌ 头文件注入失败:`, err.message);
+    notifier.notify(`头文件注入失败: ${err.message}`, { 
+    title: 'AutoSnippet' 
+    });
+  }
   }
 }