autosnippet 3.2.6 → 3.2.8

package/lib/core/analysis/ImportPathResolver.js

@@ -0,0 +1,189 @@
+/**
+ * @module ImportPathResolver
+ * @description Phase 5: 将 import 路径解析为项目内文件路径
+ *
+ * 负责:
+ *   - 相对路径 (./ ../) 解析
+ *   - 文件扩展名补全 (.ts, .js, .py, ...)
+ *   - index 文件约定 (./dir → ./dir/index.ts)
+ *   - 外部依赖识别与过滤
+ *   - tsconfig paths alias 支持 (@/xxx → src/xxx)
+ *
+ * 不负责:
+ *   - webpack resolve alias (需额外配置)
+ *   - Node.js exports map (需解析 package.json)
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+export class ImportPathResolver {
+  /**
+   * @param {string} projectRoot — 项目根目录
+   * @param {string[]} allFiles — 项目内所有文件的相对路径
+   */
+  constructor(projectRoot, allFiles) {
+    this.projectRoot = projectRoot;
+    /** @type {Map<string, string>} normalizedPath → actualFilePath */
+    this.fileIndex = new Map();
+    /** @type {Array<{prefix: string, targets: string[]}>} tsconfig paths 映射 */
+    this.pathAliases = [];
+
+    // 构建文件索引
+    for (const f of allFiles) {
+      // 完整路径
+      this.fileIndex.set(f, f);
+
+      // 去扩展名 → 完整路径
+      const base = f.replace(/\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|kt|swift|m|dart)$/, '');
+      if (!this.fileIndex.has(base)) {
+        this.fileIndex.set(base, f);
+      }
+
+      // index 文件约定: src/utils/ → src/utils/index.ts
+      if (/\/index\.(ts|tsx|js|jsx|mjs|cjs)$/.test(f)) {
+        const dir = f.replace(/\/index\.(ts|tsx|js|jsx|mjs|cjs)$/, '');
+        if (!this.fileIndex.has(dir)) {
+          this.fileIndex.set(dir, f);
+        }
+      }
+
+      // Python __init__.py 约定: pkg/ → pkg/__init__.py
+      if (f.endsWith('/__init__.py')) {
+        const dir = f.replace(/\/__init__\.py$/, '');
+        if (!this.fileIndex.has(dir)) {
+          this.fileIndex.set(dir, f);
+        }
+      }
+    }
+
+    // 自动加载 tsconfig paths
+    this._loadTsconfigPaths(projectRoot);
+  }
+
+  /**
+   * 从 tsconfig.json 加载 paths alias 配置
+   * @param {string} projectRoot
+   * @private
+   */
+  _loadTsconfigPaths(projectRoot) {
+    const candidates = ['tsconfig.json', 'tsconfig.app.json', 'jsconfig.json'];
+    for (const name of candidates) {
+      try {
+        const configPath = path.join(projectRoot, name);
+        if (!fs.existsSync(configPath)) continue;
+        const raw = fs.readFileSync(configPath, 'utf-8');
+        // 简单的 JSON 解析 (去除注释)
+        const cleaned = raw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+        const config = JSON.parse(cleaned);
+        const compilerOptions = config.compilerOptions || {};
+        const baseUrl = compilerOptions.baseUrl || '.';
+        const paths = compilerOptions.paths;
+        if (!paths) continue;
+
+        for (const [aliasPattern, targetPatterns] of Object.entries(paths)) {
+          // "@/*" → ["src/*"]
+          // "~/*" → ["src/*"]
+          // "@components/*" → ["src/components/*"]
+          const prefix = aliasPattern.replace(/\/?\*$/, '');
+          const targets = (Array.isArray(targetPatterns) ? targetPatterns : [targetPatterns])
+            .map((t) => {
+              const target = String(t).replace(/\/?\*$/, '');
+              // 相对于 baseUrl 解析
+              return path.normalize(path.join(baseUrl, target));
+            });
+          if (prefix) {
+            this.pathAliases.push({ prefix, targets });
+          }
+        }
+
+        // 只加载第一个找到的配置文件
+        break;
+      } catch (_e) {
+        // 配置解析失败，静默跳过
+      }
+    }
+  }
+
+  /**
+   * 解析 import 路径到项目文件
+   *
+   * @param {string} importPath — 如 "./UserRepo" 或 "../shared/utils"
+   * @param {string} importerFile — 当前文件路径 (相对路径)
+   * @returns {string|null} — 解析后的文件路径 (相对) 或 null (外部依赖)
+   */
+  resolve(importPath, importerFile) {
+    const pathStr = String(importPath);
+
+    // 1. 跳过外部依赖 (先检查 alias，再判断外部)
+    // 相对路径始终尝试解析
+    if (pathStr.startsWith('.')) {
+      const importerDir = path.dirname(importerFile);
+      const resolved = path.normalize(path.join(importerDir, pathStr));
+      if (this.fileIndex.has(resolved)) return this.fileIndex.get(resolved);
+      return this.fileIndex.get(resolved) || null;
+    }
+
+    // 2. tsconfig paths alias 解析
+    const aliasResolved = this._resolveAlias(pathStr);
+    if (aliasResolved) return aliasResolved;
+
+    // 3. 如果不是 alias 且是外部依赖 → null
+    if (this._isExternal(pathStr)) return null;
+
+    // 4. Python 模块路径 (点分隔 → 斜线)
+    if (pathStr.includes('.') && !pathStr.includes('/')) {
+      const slashed = pathStr.replace(/\./g, '/');
+      if (this.fileIndex.has(slashed)) return this.fileIndex.get(slashed);
+    }
+
+    // 5. 直接匹配（Go 包路径、Rust crate path 等）
+    return this.fileIndex.get(pathStr) || null;
+  }
+
+  /**
+   * 尝试通过 tsconfig paths alias 解析
+   * @param {string} importPath
+   * @returns {string|null}
+   * @private
+   */
+  _resolveAlias(importPath) {
+    for (const { prefix, targets } of this.pathAliases) {
+      if (importPath === prefix || importPath.startsWith(prefix + '/')) {
+        const remainder = importPath === prefix ? '' : importPath.slice(prefix.length + 1);
+        for (const target of targets) {
+          const resolved = remainder ? path.normalize(path.join(target, remainder)) : target;
+          if (this.fileIndex.has(resolved)) return this.fileIndex.get(resolved);
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * 判断是否为外部依赖
+   * @param {string} importPath
+   * @returns {boolean}
+   */
+  _isExternal(importPath) {
+    // 相对路径不是外部
+    if (importPath.startsWith('.') || importPath.startsWith('/')) {
+      return false;
+    }
+
+    // scoped npm packages: @scope/pkg
+    // bare specifier: lodash, express 等
+    // 如果在文件索引中有匹配，说明是项目内的
+    if (this.fileIndex.has(importPath)) return false;
+
+    // Python 点分路径的特殊处理
+    if (importPath.includes('.') && !importPath.includes('/')) {
+      const slashed = importPath.replace(/\./g, '/');
+      if (this.fileIndex.has(slashed)) return false;
+    }
+
+    return true;
+  }
+}
+
+export default ImportPathResolver;

package/lib/core/analysis/ImportRecord.js

@@ -0,0 +1,105 @@
+/**
+ * @module ImportRecord
+ * @description 增强的 Import 记录 — 对外表现类似 string，内部携带结构化元信息。
+ *
+ * Phase 5: 跨文件调用链分析的基础数据结构。
+ *
+ * 兼容性保证:
+ *   - imp.includes('express')     ✅  (includes 方法代理到 path)
+ *   - `${imp}`                     ✅  (toString 返回 path)
+ *   - imp.startsWith('./')         ✅  (同上代理)
+ *   - JSON.stringify(imp)          ✅  (toJSON 返回 path)
+ *   - typeof imp === 'object'      ⚠️  不再是 'string'
+ *
+ * @example
+ *   const rec = new ImportRecord('./UserRepo', { symbols: ['UserRepo'], kind: 'named' });
+ *   rec.includes('User');   // true
+ *   `${rec}`;               // './UserRepo'
+ *   rec.symbols;            // ['UserRepo']
+ */
+
+export class ImportRecord {
+  /**
+   * @param {string} path — 导入路径原始字符串
+   * @param {object} [meta]
+   * @param {string[]} [meta.symbols] — 导入的符号名 e.g. ['UserRepo', 'findById'] 或 ['*']
+   * @param {string|null} [meta.alias] — 导入别名 e.g. import { UserRepo as Repo }
+   * @param {'named'|'default'|'namespace'|'side-effect'} [meta.kind] — 导入方式
+   * @param {boolean} [meta.isTypeOnly] — 是否为类型导入 (TypeScript)
+   */
+  constructor(path, meta = {}) {
+    this.path = String(path);
+    this.symbols = meta.symbols || [];
+    this.alias = meta.alias || null;
+    this.kind = meta.kind || 'side-effect';
+    this.isTypeOnly = meta.isTypeOnly || false;
+  }
+
+  // ── String 兼容性方法 ──
+
+  toString() {
+    return this.path;
+  }
+
+  includes(s) {
+    return this.path.includes(s);
+  }
+
+  startsWith(s) {
+    return this.path.startsWith(s);
+  }
+
+  endsWith(s) {
+    return this.path.endsWith(s);
+  }
+
+  indexOf(s) {
+    return this.path.indexOf(s);
+  }
+
+  replace(a, b) {
+    return this.path.replace(a, b);
+  }
+
+  match(re) {
+    return this.path.match(re);
+  }
+
+  split(sep) {
+    return this.path.split(sep);
+  }
+
+  trim() {
+    return this.path.trim();
+  }
+
+  toJSON() {
+    return this.path;
+  }
+
+  get length() {
+    return this.path.length;
+  }
+
+  valueOf() {
+    return this.path;
+  }
+
+  // ── Phase 5 结构化访问 ──
+
+  /** 是否具有结构化符号信息 */
+  get isStructured() {
+    return this.symbols.length > 0;
+  }
+
+  /**
+   * 检查是否导入了指定符号名
+   * @param {string} symbolName
+   * @returns {boolean}
+   */
+  hasSymbol(symbolName) {
+    return this.symbols.includes(symbolName) || this.symbols.includes('*');
+  }
+}
+
+export default ImportRecord;

package/lib/core/analysis/SymbolTableBuilder.js

@@ -0,0 +1,211 @@
+/**
+ * @module SymbolTableBuilder
+ * @description Phase 5: 从 analyzeProject 结果构建全局符号表
+ *
+ * 符号表是调用图解析的核心数据结构，将 AST 提取的声明信息组织为可查询的全局表。
+ *
+ * 数据流:
+ *   ProjectAstSummary → SymbolTableBuilder.build() → SymbolTable {
+ *     declarations: Map<FQN, SymbolDeclaration>
+ *     fileExports: Map<FilePath, string[]>
+ *     fileImports: Map<FilePath, ImportRecord[]>
+ *   }
+ */
+
+import { ImportRecord } from './ImportRecord.js';
+
+/**
+ * @typedef {object} SymbolDeclaration
+ * @property {string} fqn — Fully Qualified Name e.g. "src/service/UserService.ts::UserService.getUser"
+ * @property {string} name — 短名 e.g. "getUser"
+ * @property {string|null} className — 所属类
+ * @property {string} file — 声明文件 (相对路径)
+ * @property {number} line — 行号
+ * @property {'class'|'function'|'method'|'variable'|'interface'|'type'} kind
+ * @property {boolean} isExported — 是否导出
+ */
+
+/**
+ * @typedef {object} SymbolTable
+ * @property {Map<string, SymbolDeclaration>} declarations — 符号 FQN → 声明
+ * @property {Map<string, string[]>} fileExports — 文件 → 导出符号名列表
+ * @property {Map<string, ImportRecord[]>} fileImports — 文件 → ImportRecord 列表
+ * @property {Set<string>} instantiatedClasses — Phase 5.3 RTA: 程序中实际实例化的类名集合
+ * @property {Map<string, Map<string, string>>} propertyTypes — Phase 5.3 DI: className → (fieldName → typeName)
+ */
+
+export class SymbolTableBuilder {
+  /**
+   * 从 analyzeProject 结果构建全局符号表
+   *
+   * @param {object} projectSummary — analyzeProject() 返回的 ProjectAstSummary
+   * @returns {SymbolTable}
+   */
+  static build(projectSummary) {
+    /** @type {SymbolTable} */
+    const table = {
+      declarations: new Map(),
+      fileExports: new Map(),
+      fileImports: new Map(),
+      // Phase 5.3: RTA — track classes that are actually instantiated in the program
+      instantiatedClasses: new Set(),
+      // Phase 5.3: DI — property type annotations: className → (fieldName → typeName)
+      propertyTypes: new Map(),
+    };
+
+    if (!projectSummary?.fileSummaries) return table;
+
+    for (const fileSummary of projectSummary.fileSummaries) {
+      const filePath = fileSummary.file;
+
+      // 1. 提取导出名列表 (用于后续 import resolution)
+      const exportNames = _extractExportNames(fileSummary.exports || []);
+
+      // 2. 注册类声明
+      for (const cls of fileSummary.classes || []) {
+        if (!cls.name || cls.name === 'Unknown') continue;
+        const fqn = `${filePath}::${cls.name}`;
+        table.declarations.set(fqn, {
+          fqn,
+          name: cls.name,
+          className: null,
+          file: filePath,
+          line: cls.line || 0,
+          kind: cls.kind === 'enum' ? 'type' : cls.kind === 'type' ? 'type' : 'class',
+          isExported: _isExported(cls.name, exportNames),
+        });
+      }
+
+      // 3. 注册接口/协议声明
+      for (const proto of fileSummary.protocols || []) {
+        if (!proto.name || proto.name === 'Unknown') continue;
+        const fqn = `${filePath}::${proto.name}`;
+        table.declarations.set(fqn, {
+          fqn,
+          name: proto.name,
+          className: null,
+          file: filePath,
+          line: proto.line || 0,
+          kind: 'interface',
+          isExported: _isExported(proto.name, exportNames),
+        });
+      }
+
+      // 4. 注册方法/函数声明
+      for (const method of fileSummary.methods || []) {
+        if (!method.name || method.name === 'unknown') continue;
+        const scope = method.className || '';
+        const fqn = `${filePath}::${scope ? `${scope}.` : ''}${method.name}`;
+        table.declarations.set(fqn, {
+          fqn,
+          name: method.name,
+          className: method.className || null,
+          file: filePath,
+          line: method.line || 0,
+          kind: method.className ? 'method' : 'function',
+          isExported: !method.className && _isExported(method.name, exportNames),
+        });
+      }
+
+      // 5. 注册导出
+      table.fileExports.set(filePath, exportNames);
+
+      // 6. 注册导入 (兼容 string 和 ImportRecord)
+      const imports = (fileSummary.imports || []).map((imp) =>
+        imp instanceof ImportRecord ? imp : new ImportRecord(String(imp))
+      );
+      table.fileImports.set(filePath, imports);
+
+      // 7. Phase 5.3 RTA: Collect instantiated classes from callSites
+      //    new ClassName() → callType='constructor', receiverType=ClassName
+      //    <Component /> → callType='constructor', receiverType=Component (JSX)
+      for (const cs of fileSummary.callSites || []) {
+        if (cs.callType === 'constructor' && cs.receiverType) {
+          table.instantiatedClasses.add(cs.receiverType);
+        }
+      }
+
+      // 8. Phase 5.3 DI: Collect property type annotations
+      //    property { name, className, typeAnnotation } → propertyTypes[className][name] = type
+      for (const prop of fileSummary.properties || []) {
+        if (prop.typeAnnotation && prop.className) {
+          if (!table.propertyTypes.has(prop.className)) {
+            table.propertyTypes.set(prop.className, new Map());
+          }
+          table.propertyTypes.get(prop.className).set(prop.name, prop.typeAnnotation);
+        }
+      }
+    }
+
+    return table;
+  }
+}
+
+// ── 内部工具函数 ───────────────────────────────────────────
+
+/**
+ * 从 exports 数组中提取导出名
+ * exports 格式可能是:
+ *   - string[]
+ *   - { line, text }[] (TypeScript walker 的格式)
+ *   - { name, ... }[]
+ *
+ * @param {Array} exports
+ * @returns {string[]}
+ */
+function _extractExportNames(exports) {
+  const names = [];
+
+  for (const exp of exports) {
+    if (typeof exp === 'string') {
+      names.push(exp);
+      continue;
+    }
+
+    if (exp?.name) {
+      names.push(exp.name);
+      continue;
+    }
+
+    if (exp?.text) {
+      // 从 export 文本中尝试提取名称
+      // e.g. "export class UserService" → "UserService"
+      // e.g. "export function getUser" → "getUser"
+      // e.g. "export const config" → "config"
+      // e.g. "export default class" → "default"
+      const text = exp.text;
+      const match = text.match(
+        /export\s+(?:default\s+)?(?:class|function|const|let|var|interface|type|enum|abstract\s+class)\s+(\w+)/
+      );
+      if (match) {
+        names.push(match[1]);
+      } else if (text.includes('export default')) {
+        names.push('default');
+      }
+      // export { A, B, C }
+      const namedMatch = text.match(/export\s*\{([^}]+)\}/);
+      if (namedMatch) {
+        const items = namedMatch[1].split(',').map((s) => {
+          // 处理 "A as B" 的情况
+          const parts = s.trim().split(/\s+as\s+/);
+          return parts[parts.length - 1].trim();
+        });
+        names.push(...items.filter(Boolean));
+      }
+    }
+  }
+
+  return names;
+}
+
+/**
+ * 检查符号是否被导出
+ * @param {string} name
+ * @param {string[]} exportNames
+ * @returns {boolean}
+ */
+function _isExported(name, exportNames) {
+  return exportNames.includes(name) || exportNames.includes('default');
+}
+
+export default SymbolTableBuilder;

package/lib/core/ast/ProjectGraph.js

@@ -292,6 +292,14 @@ export default class ProjectGraph {
     return this.#files.get(relativePath) || null;
   }
 
+  /**
+   * 获取所有已解析的文件路径
+   * @returns {string[]} 相对路径列表
+   */
+  getAllFilePaths() {
+    return [...this.#files.keys()];
+  }
+
   /**
    * 搜索类名 (模糊匹配)
    * @param {string} query