@buaa_smat/hometrans 0.1.0

package/dist/context/index.js

@@ -0,0 +1,688 @@
+import { createRequire as _htCreateRequire } from 'module'; const require = _htCreateRequire(import.meta.url);
+
+// src/context/index.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  CallGraph as CallGraph2,
+  CallGraphBuilder,
+  Scene as Scene2,
+  SceneConfig
+} from "arkanalyzer";
+
+// src/context/analysis/ArkTsGitInfoAnalysis.ts
+import {
+  AbstractInvokeExpr,
+  ArkAssignStmt,
+  CallGraphNode,
+  ArkInvokeStmt,
+  fetchDependenciesFromFile,
+  FunctionType,
+  parseJsonText
+} from "arkanalyzer";
+import path2 from "path";
+import fs2 from "fs";
+
+// src/context/utils/util.ts
+import LoggerMod, { LOG_MODULE_TYPE } from "arkanalyzer/lib/utils/logger.js";
+import path from "path";
+import fs from "fs";
+var Logger = LoggerMod.default ?? LoggerMod;
+var logger = Logger.getLogger(LOG_MODULE_TYPE.DEFAULT, "util");
+function safePush(target, source, maxBatchSize = 1e4) {
+  for (let i = 0; i < source.length; i += maxBatchSize) {
+    const batch = source.slice(i, i + maxBatchSize);
+    target.push(...batch);
+  }
+}
+function getAllFiles(dirPath, exts, filenameArr = [], visited = /* @__PURE__ */ new Set()) {
+  if (!fs.existsSync(dirPath)) {
+    logger.error(`'${dirPath}' is not exist, please check!`);
+    return filenameArr;
+  }
+  const realSrc = fs.realpathSync(dirPath);
+  if (visited.has(realSrc)) {
+    return filenameArr;
+  }
+  visited.add(realSrc);
+  fs.readdirSync(realSrc).forEach((fileName) => {
+    if (shouldSkipFile(fileName)) {
+      return;
+    }
+    const realFile = path.resolve(realSrc, fileName);
+    if (fs.statSync(realFile).isDirectory()) {
+      getAllFiles(realFile, exts, filenameArr, visited);
+    } else {
+      if (exts.length === 0) {
+        filenameArr.push(realFile);
+      } else if (shouldAddFile(realFile, exts)) {
+        filenameArr.push(realFile);
+      }
+    }
+  });
+  return filenameArr;
+}
+function shouldSkipFile(fileName) {
+  return ["oh_modules", "node_modules", "hvigorfile.ts", "ohosTest"].includes(fileName);
+}
+function shouldAddFile(filePath, exts) {
+  if (exts.length === 0) {
+    return true;
+  }
+  const ext = path.extname(filePath).toLowerCase();
+  return exts.includes(ext);
+}
+function getFilePath(parts) {
+  return path.join(...parts);
+}
+
+// src/context/analysis/ArkTsGitInfoAnalysis.ts
+var ModuleDependency = class {
+  moduleName;
+  modulePath;
+  pluralJsons;
+  stringJsons;
+  strArrayJsons;
+};
+var Resource = class {
+  resource = /* @__PURE__ */ new Map();
+};
+var GitItem = class {
+  mode;
+  path;
+  lineInterval;
+  contentAfter;
+  contentBefore;
+};
+var ArkTsGitInfoAnalysis = class {
+  scene;
+  mode;
+  callGraph;
+  originLines;
+  copiedLines;
+  dependencyFileDict = /* @__PURE__ */ new Map();
+  dependencyResourceMap = /* @__PURE__ */ new Map();
+  gitItem;
+  moduleDependencies;
+  modulePathDependenciesMap = /* @__PURE__ */ new Map();
+  maxCallDepth = 4;
+  analysis = (arkFile, gitItem, callGraph, mode) => {
+    this.callGraph = callGraph;
+    this.mode = mode;
+    this.originLines = arkFile.getCode().split("\n");
+    let copiedLinesInDict = this.dependencyFileDict.get(arkFile);
+    if (!copiedLinesInDict) {
+      this.copiedLines = new Array(this.originLines.length);
+      this.dependencyFileDict.set(arkFile, this.copiedLines);
+    } else {
+      this.copiedLines = copiedLinesInDict;
+    }
+    this.gitItem = gitItem;
+    this.scene = arkFile.getScene();
+    const modulePath = arkFile.getModuleScene().getModulePath();
+    if (this.modulePathDependenciesMap.has(modulePath)) {
+      this.moduleDependencies = this.modulePathDependenciesMap.get(modulePath);
+    } else {
+      this.moduleDependencies = /* @__PURE__ */ new Map();
+      this.getModuleDependency(arkFile.getModuleScene().getModulePath());
+      this.modulePathDependenciesMap.set(modulePath, this.moduleDependencies);
+    }
+    this.analysisFileStructureTree(arkFile);
+    for (let i = gitItem.lineInterval[0]; i <= gitItem.lineInterval[1]; i++) {
+      if (this.copiedLines[i - 1] === void 0) {
+        this.copiedLines[i - 1] = this.originLines[i - 1];
+      }
+    }
+    return this.dependencyFileDict;
+  };
+  getModuleDependency(modulePath) {
+    let OhPkgFilePath = path2.join(modulePath, "oh-package.json5");
+    console.log(`modulePath ${modulePath} OhPkgFilePath ${OhPkgFilePath}`);
+    let libOhPkgContent = fetchDependenciesFromFile(OhPkgFilePath);
+    let dependencies = libOhPkgContent.dependencies;
+    console.dir(dependencies, { depth: null });
+    if (!dependencies) {
+      return;
+    }
+    Object.entries(dependencies).forEach(([key, value]) => {
+      if (key.startsWith("@ohos") && value.startsWith("file:")) {
+        const targetModulePath = path2.resolve(modulePath, value.replace("file:", ""));
+        if (!this.moduleDependencies.has(targetModulePath)) {
+          const targetModuleResourcePath = path2.join(targetModulePath, "src", "main", "resources");
+          const moduleDependency = new ModuleDependency();
+          moduleDependency.moduleName = key.replace("@ohos/", "");
+          moduleDependency.modulePath = targetModulePath;
+          moduleDependency.pluralJsons = this.loadJsonResources(targetModuleResourcePath, "plural.json");
+          moduleDependency.strArrayJsons = this.loadJsonResources(targetModuleResourcePath, "strarray.json");
+          moduleDependency.stringJsons = this.loadJsonResources(targetModuleResourcePath, "string.json");
+          this.moduleDependencies.set(moduleDependency.modulePath, moduleDependency);
+          this.getModuleDependency(targetModulePath);
+        }
+      }
+    });
+  }
+  resolveAnonymousMethod(arkMethod, arkClass) {
+    let callStmtStartLine = arkMethod.getLine();
+    let callStmtEndLine = this.getEndLine(callStmtStartLine, arkMethod.getCode());
+    let outerArkMethod = arkMethod.getOuterMethod();
+    while (outerArkMethod && outerArkMethod.getName().startsWith("%AM")) {
+      arkMethod = outerArkMethod;
+      outerArkMethod = arkMethod.getOuterMethod();
+    }
+    if (outerArkMethod) {
+      if (outerArkMethod.getName() === "%instInit") {
+        let targetArkField;
+        for (let arkField of arkClass.getFields()) {
+          const stmts = arkField.getInitializer() ?? [];
+          for (let stmt of stmts) {
+            if (stmt instanceof ArkAssignStmt) {
+              const rightOp = stmt.getRightOp();
+              let type = rightOp.getType();
+              if (type instanceof FunctionType && type.getMethodSignature() === arkMethod.getSignature()) {
+                arkMethod = this.scene.getMethod(type.getMethodSignature());
+                targetArkField = arkField;
+                callStmtStartLine = targetArkField.getOriginPosition().getLineNo();
+                callStmtEndLine = this.getEndLine(callStmtStartLine, targetArkField.getCode());
+                break;
+              }
+            }
+          }
+          if (targetArkField) {
+            break;
+          }
+        }
+      } else if (outerArkMethod.getName() === "%dflt") {
+        let locals = outerArkMethod.getBody().getLocals();
+        locals.forEach((local, str) => {
+          let stmt = local.getDeclaringStmt();
+          if (stmt instanceof ArkAssignStmt) {
+            const rightOp = stmt.getRightOp();
+            let type = rightOp.getType();
+            if (type instanceof FunctionType && type.getMethodSignature() === arkMethod.getSignature()) {
+              arkMethod = this.scene.getMethod(type.getMethodSignature());
+              callStmtStartLine = stmt.getOriginPositionInfo().getLineNo();
+              callStmtEndLine = this.getEndLine(callStmtStartLine, stmt.getOriginalText());
+            }
+          }
+        });
+      } else {
+        callStmtStartLine = outerArkMethod.getLine();
+        callStmtEndLine = this.getEndLine(callStmtStartLine, outerArkMethod.getCode());
+      }
+    }
+    return { arkMethod, startLine: callStmtStartLine, endLine: callStmtEndLine };
+  }
+  copyClassHeader(arkClass, copiedLines, originLines, includeMinLine) {
+    let classStartLine = arkClass.getLine();
+    let classEndLine = this.getEndLine(classStartLine, arkClass.getCode());
+    let minLineNumber = classEndLine;
+    if (arkClass.getFields().length !== 0) {
+      let fields = arkClass.getFields();
+      fields.sort((a, b) => a.getOriginPosition().getLineNo() - b.getOriginPosition().getLineNo());
+      let firstFieldLine = fields[0].getOriginPosition().getLineNo();
+      minLineNumber = Math.min(firstFieldLine, minLineNumber);
+    }
+    if (arkClass.getMethods().length !== 0) {
+      let methods = arkClass.getMethods();
+      methods = methods.filter((method) => this.isMethodValid(method)).sort((a, b) => a.getLine() - b.getLine());
+      if (methods.length !== 0) {
+        let firstMethodLine = methods[0].getLine();
+        if (firstMethodLine !== void 0 && firstMethodLine !== null) {
+          minLineNumber = Math.min(firstMethodLine, minLineNumber);
+        }
+      }
+    }
+    const end = includeMinLine ? minLineNumber : minLineNumber - 1;
+    for (let i = classStartLine; i <= end; i++) {
+      copiedLines[i - 1] = originLines[i - 1];
+    }
+    copiedLines[classEndLine - 1] = originLines[classEndLine - 1];
+  }
+  loadJsonResources(resourcePath, fileName) {
+    const jsonItems = [];
+    const results = getAllFiles(resourcePath, [fileName]);
+    for (const result of results) {
+      const configText = fs2.readFileSync(result, "utf8");
+      const json = parseJsonText(configText);
+      jsonItems.push({ path: result, content: json });
+    }
+    return jsonItems;
+  }
+  getEndLine(startLine, code) {
+    return startLine + (code ? code.split("\n").length - 1 : 0);
+  }
+  isMethodValid(method) {
+    return !(method.getName() === "constructor" && method.getCode() === "") && method.getLine() !== -1 && method.getCode() !== void 0;
+  }
+  analysisFileStructureTree(arkFile) {
+    arkFile.getModuleScene().getModulePath();
+    let arkClasses = arkFile.getClasses().filter((cls) => cls.getName() === "%dflt" || !cls.getName().startsWith("%"));
+    let classNames = arkClasses.map((cls) => cls.getName());
+    for (const arkClass of arkClasses) {
+      if (arkClass.getName() === "%dflt") {
+        this.analysisClassStructureTree(arkClass);
+      } else {
+        let classStartLine = arkClass.getLine();
+        if (classStartLine === -1) {
+          this.analysisClassStructureTree(arkClass);
+        } else {
+          let classEndLine = this.getEndLine(classStartLine, arkClass.getCode());
+          let classLineInterval = [classStartLine, classEndLine];
+          if (!(classLineInterval[0] > this.gitItem.lineInterval[1] || classLineInterval[1] < this.gitItem.lineInterval[0])) {
+            this.copyClassHeader(arkClass, this.copiedLines, this.originLines, false);
+            this.analysisClassStructureTree(arkClass);
+          }
+        }
+      }
+    }
+  }
+  getInvokeExprFromStmt(stmt) {
+    if (stmt instanceof ArkInvokeStmt) {
+      return stmt.getInvokeExpr();
+    } else if (stmt instanceof ArkAssignStmt) {
+      const rightOp = stmt.getRightOp();
+      if (rightOp instanceof AbstractInvokeExpr) {
+        return rightOp;
+      }
+    }
+  }
+  analysisMethodResource(method) {
+    const stmts = method.getBody()?.getCfg().getStmts();
+    if (!stmts) {
+      return;
+    }
+    for (let stmt of stmts) {
+      const invokeExpr = this.getInvokeExprFromStmt(stmt);
+      if (!invokeExpr) {
+        continue;
+      }
+      const invokeSignature = invokeExpr.getMethodSignature();
+      let clazz = method.getDeclaringArkClass();
+      let methodName = invokeSignature.getMethodSubSignature().getMethodName();
+      let moduleName = clazz.getDeclaringArkFile().getModuleName();
+      if (moduleName === void 0) {
+        continue;
+      }
+      if (methodName === "$r") {
+        const resourceLabel = invokeExpr.getArgs()[0].toString().slice(1, -1);
+        const array = resourceLabel.split(".");
+        if (array.length === 3) {
+          const scope = array[0];
+          if (scope !== "app") {
+            continue;
+          }
+          const category = array[1];
+          const name = array[2];
+          for (const moduleDependency of this.moduleDependencies.values()) {
+            if (category === "string" && moduleDependency.stringJsons.length !== 0) {
+              for (const jsonItem of moduleDependency.stringJsons) {
+                this.extracted(jsonItem, name);
+              }
+            } else if (category === "strarray" && moduleDependency.strArrayJsons.length !== 0) {
+              for (const jsonItem of moduleDependency.strArrayJsons) {
+                this.extracted(jsonItem, name);
+              }
+            } else if (category === "plural" && moduleDependency.pluralJsons.length !== 0) {
+              for (const jsonItem of moduleDependency.pluralJsons) {
+                this.extracted(jsonItem, name);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  extracted(jsonItem, name) {
+    for (const descriptor of jsonItem.content["string"]) {
+      if (descriptor["name"] === name) {
+        let stringResourceItem = this.dependencyResourceMap.get(jsonItem.path);
+        if (!stringResourceItem) {
+          stringResourceItem = new Resource();
+        }
+        if (!stringResourceItem.resource.has(name)) {
+          stringResourceItem.resource.set(name, descriptor);
+          this.dependencyResourceMap.set(jsonItem.path, stringResourceItem);
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+  analysisClassStructureTree(arkClass) {
+    let callgraph = this.callGraph;
+    let arkMethods = arkClass.getMethods();
+    for (let arkMethod of arkMethods) {
+      let methodStartLine = arkMethod.getLine();
+      let methodEndLine = this.getEndLine(methodStartLine, arkMethod.getCode());
+      let methodLineInterval = [];
+      methodLineInterval = [methodStartLine, methodEndLine];
+      if (!(methodLineInterval[0] > this.gitItem.lineInterval[1] || methodLineInterval[1] < this.gitItem.lineInterval[0])) {
+        let callStmtStartLine = arkMethod.getLine();
+        let callStmtEndLine = this.getEndLine(callStmtStartLine, arkMethod.getCode());
+        if (arkMethod.getName().startsWith("%AM")) {
+          const resolved = this.resolveAnonymousMethod(arkMethod, arkClass);
+          arkMethod = resolved.arkMethod;
+          callStmtStartLine = resolved.startLine;
+          callStmtEndLine = resolved.endLine;
+        }
+        if (this.isMethodValid(arkMethod)) {
+          for (let i = callStmtStartLine; i <= callStmtEndLine; i++) {
+            this.copiedLines[i - 1] = this.originLines[i - 1];
+          }
+        }
+        this.analysisMethodResource(arkMethod);
+        if (this.mode === "default") {
+          let invokeStmts = callgraph.getInvokeStmtByMethod(arkMethod.getSignature());
+          if (invokeStmts) {
+            for (let invokeStmt of invokeStmts) {
+              let dstMethod = invokeStmt.getCfg().getDeclaringMethod();
+              console.log(`[caller] ${arkMethod.getSignature()} is called by ${dstMethod.getSignature()} in ${dstMethod.getDeclaringArkClass().getDeclaringArkFile().getName()}`);
+              this.analysisCallArkFile(dstMethod, 1);
+            }
+          }
+          let setEdges = callgraph.getCallGraphNodeByMethod(arkMethod.getSignature()).getOutgoingEdges();
+          setEdges.forEach((edge) => {
+            let dst = edge.getDstNode();
+            if (dst instanceof CallGraphNode && !dst.isSdkMethod()) {
+              let dstMethodSignature = dst.getMethod();
+              let dstMethod = this.scene.getMethod(dstMethodSignature);
+              console.log(`[callee] ${arkMethod.getSignature()} calls ${dstMethodSignature} in ${dstMethod.getDeclaringArkClass().getDeclaringArkFile().getName()}`);
+              this.analysisCallArkFile(dstMethod, 1);
+            }
+          });
+        }
+      }
+    }
+  }
+  analysisCallArkFile = (arkMethod, currentDepth = 1) => {
+    let arkClass = arkMethod.getDeclaringArkClass();
+    let callArkFile = arkClass.getDeclaringArkFile();
+    let originLines = callArkFile.getCode().split("\n");
+    let copiedLines = this.dependencyFileDict.get(callArkFile);
+    if (!copiedLines) {
+      copiedLines = new Array(originLines.length);
+      this.dependencyFileDict.set(callArkFile, copiedLines);
+    }
+    if (arkClass.getName() != "%dlft") {
+      this.copyClassHeader(arkClass, copiedLines, originLines, true);
+    }
+    let callStmtStartLine = arkMethod.getLine();
+    let callStmtEndLine = this.getEndLine(callStmtStartLine, arkMethod.getCode());
+    if (arkMethod.getName().startsWith("%AM")) {
+      const resolved = this.resolveAnonymousMethod(arkMethod, arkClass);
+      arkMethod = resolved.arkMethod;
+      callStmtStartLine = resolved.startLine;
+      callStmtEndLine = resolved.endLine;
+    }
+    if (this.isMethodValid(arkMethod)) {
+      for (let i = callStmtStartLine; i <= callStmtEndLine; ++i) {
+        copiedLines[i - 1] = originLines[i - 1];
+      }
+    }
+    if (this.mode === "default" && currentDepth < this.maxCallDepth) {
+      let invokeStmts = this.callGraph.getInvokeStmtByMethod(arkMethod.getSignature());
+      if (invokeStmts) {
+        for (let invokeStmt of invokeStmts) {
+          let dstMethod = invokeStmt.getCfg().getDeclaringMethod();
+          console.log(`[caller][depth=${currentDepth}] ${arkMethod.getSignature()} is called by ${dstMethod.getSignature()} in ${dstMethod.getDeclaringArkClass().getDeclaringArkFile().getName()}`);
+          this.analysisCallArkFile(dstMethod, currentDepth + 1);
+        }
+      }
+      let setEdges = this.callGraph.getCallGraphNodeByMethod(arkMethod.getSignature()).getOutgoingEdges();
+      if (setEdges) {
+        setEdges.forEach((edge) => {
+          let dst = edge.getDstNode();
+          if (dst instanceof CallGraphNode && !dst.isSdkMethod()) {
+            let dstMethodSignature = dst.getMethod();
+            let dstMethod = this.scene.getMethod(dstMethodSignature);
+            console.log(`[callee][depth=${currentDepth}] ${arkMethod.getSignature()} calls ${dstMethodSignature} in ${dstMethod.getDeclaringArkClass().getDeclaringArkFile().getName()}`);
+            this.analysisCallArkFile(dstMethod, currentDepth + 1);
+          }
+        });
+      }
+    }
+    return copiedLines;
+  };
+};
+
+// src/context/git/GitDiffExtractor.ts
+import simpleGit from "simple-git";
+var ALLOWED_EXTS = [".ets", ".ts", ".c", ".cpp", ".h", ".hpp"];
+function hasAllowedExt(filePath) {
+  if (!filePath) return false;
+  const lower = filePath.toLowerCase();
+  return ALLOWED_EXTS.some((ext) => lower.endsWith(ext));
+}
+function normalize(content) {
+  return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/-\n        textPara/g, "-\n      textPara");
+}
+function parseNameStatus(raw) {
+  const out = [];
+  if (!raw) return out;
+  for (const rawLine of raw.split("\n")) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    const parts = line.split("	");
+    const status = parts[0];
+    if (!status) continue;
+    if (status.startsWith("R") || status.startsWith("C")) {
+      out.push({ status, oldPath: parts[1] ?? "", newPath: parts[2] ?? "" });
+    } else if (status === "A") {
+      out.push({ status, oldPath: "", newPath: parts[1] ?? "" });
+    } else if (status === "D") {
+      out.push({ status, oldPath: parts[1] ?? "", newPath: "" });
+    } else {
+      out.push({ status, oldPath: parts[1] ?? "", newPath: parts[1] ?? "" });
+    }
+  }
+  return out;
+}
+function resolveFileMode(change) {
+  if (change.status.startsWith("R")) return "rename";
+  if (change.status === "A") return "add";
+  if (change.status === "D") return "delete";
+  return "modify";
+}
+function parseHunks(patch, newFilePath) {
+  const items = [];
+  if (!patch) return items;
+  const lines = patch.split("\n");
+  let current = new GitItem();
+  let oldLines = [];
+  let newLines = [];
+  for (const line of lines) {
+    if (line.startsWith("---") || line.startsWith("+++")) {
+      continue;
+    }
+    if (line.startsWith("@@")) {
+      current.contentBefore = normalize(oldLines.join("\n"));
+      current.contentAfter = normalize(newLines.join("\n"));
+      items.push(current);
+      current = new GitItem();
+      oldLines = [];
+      newLines = [];
+      const parts = line.split(" ");
+      const oldInfo = parts[1].substring(1).split(",");
+      const oldRow = parseInt(oldInfo[0], 10);
+      const oldAffected = oldInfo.length === 2 ? parseInt(oldInfo[1], 10) : 1;
+      const newInfo = parts[2].substring(1).split(",");
+      const newRow = parseInt(newInfo[0], 10);
+      const newAffected = newInfo.length === 2 ? parseInt(newInfo[1], 10) : 1;
+      current.path = newFilePath;
+      current.lineInterval = [newRow, newRow + newAffected - 1];
+      if (oldAffected === 0) current.mode = "add";
+      if (newAffected === 0) {
+        current.mode = "delete";
+      } else {
+        current.mode = "modify";
+      }
+    } else if (line.startsWith("-")) {
+      oldLines.push(line.substring(1));
+    } else if (line.startsWith("+")) {
+      newLines.push(line.substring(1));
+    }
+  }
+  current.contentBefore = normalize(oldLines.join("\n"));
+  current.contentAfter = normalize(newLines.join("\n"));
+  items.push(current);
+  items.shift();
+  return items;
+}
+async function extractCommitDiff(repoPath, commitId) {
+  const git = simpleGit(repoPath);
+  const parentId = (await git.raw(["rev-parse", `${commitId}^`])).trim();
+  console.log(`commit: ${commitId} parent: ${parentId}`);
+  const nameStatus = await git.raw(["diff", "--name-status", "-M", parentId, commitId]);
+  const changes = parseNameStatus(nameStatus);
+  const results = [];
+  for (const change of changes) {
+    if (change.oldPath && !hasAllowedExt(change.oldPath)) continue;
+    if (change.newPath && !hasAllowedExt(change.newPath)) continue;
+    const reportPath = change.newPath || change.oldPath;
+    const filePaths = [change.oldPath, change.newPath].filter((p) => p);
+    const patchArgs = ["diff", "-U0", "-M", parentId, commitId, "--", ...new Set(filePaths)];
+    const patch = await git.raw(patchArgs);
+    const hunkItems = parseHunks(patch, reportPath);
+    const fileMode = resolveFileMode(change);
+    for (const item of hunkItems) {
+      item.file_mode = fileMode;
+    }
+    results.push(...hunkItems);
+  }
+  return results;
+}
+
+// src/context/index.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path3.dirname(__filename);
+function linesToRanges(lines) {
+  const ranges = [];
+  let start = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const defined = lines[i] !== void 0;
+    if (defined && start === -1) {
+      start = i + 1;
+    } else if (!defined && start !== -1) {
+      ranges.push([start, i]);
+      start = -1;
+    }
+  }
+  if (start !== -1) {
+    ranges.push([start, lines.length]);
+  }
+  return ranges;
+}
+function resolveSdkConfigPath() {
+  return path3.resolve(__dirname, "resources", "sdkConfig.json");
+}
+function resolveResourcesRoot() {
+  return path3.resolve(__dirname, "resources");
+}
+function loadSdks(ohosSdkPath, hmsSdkPath) {
+  const sdkConfigPath = resolveSdkConfigPath();
+  if (!fs3.existsSync(sdkConfigPath)) {
+    throw new Error(`HomeTrans context: sdkConfig.json not found at ${sdkConfigPath}`);
+  }
+  const configurations = JSON.parse(fs3.readFileSync(sdkConfigPath, "utf-8"));
+  const sdks = configurations.sdks ?? [];
+  const resourcesRoot = resolveResourcesRoot();
+  sdks.forEach((sdk) => {
+    if (sdk.name === "ohosSdk") {
+      sdk.path = ohosSdkPath;
+    } else if (sdk.name === "hmsSdk") {
+      sdk.path = hmsSdkPath;
+    } else {
+      const stripped = sdk.path.replace(/^\.\/?resources[\\/]?/, "");
+      sdk.path = path3.join(resourcesRoot, stripped);
+    }
+  });
+  return sdks;
+}
+async function extractCommitContext(input) {
+  const { projectPath, commitId } = input;
+  const mode = input.mode ?? "default";
+  const ohosSdkPath = input.ohosSdkPath ?? process.env.HOMETRANS_OHOS_SDK_PATH ?? "";
+  const hmsSdkPath = input.hmsSdkPath ?? process.env.HOMETRANS_HMS_SDK_PATH ?? "";
+  if (!projectPath) {
+    throw new Error("extractCommitContext: projectPath is required");
+  }
+  if (!commitId) {
+    throw new Error("extractCommitContext: commitId is required");
+  }
+  if (!ohosSdkPath && !hmsSdkPath) {
+    throw new Error(
+      "extractCommitContext: ohosSdkPath/hmsSdkPath not provided. Pass them as tool input or set HOMETRANS_OHOS_SDK_PATH / HOMETRANS_HMS_SDK_PATH env vars (e.g. D:\\DevEco Studio\\sdk\\default\\openharmony\\ets)."
+    );
+  }
+  console.error(
+    `[hometrans/context] analyzing commit=${commitId} project=${projectPath} mode=${mode}`
+  );
+  const gitItems = await extractCommitDiff(projectPath, commitId);
+  console.error(`[hometrans/context] extracted ${gitItems.length} diff items`);
+  const scene = new Scene2();
+  const analysisResult = [];
+  const sceneConfig = new SceneConfig({ enableAST: false });
+  const sdkList = loadSdks(ohosSdkPath, hmsSdkPath);
+  const fileList = getAllFiles(projectPath, [".ts", ".ets", ".js", ".json5"]);
+  sceneConfig.buildFromProjectFiles("hometrans_target", projectPath, fileList, sdkList);
+  scene.buildSceneFromFiles(sceneConfig);
+  scene.inferTypes();
+  const callGraph = new CallGraph2(scene);
+  if (mode === "default") {
+    const callGraphBuilder = new CallGraphBuilder(callGraph, scene);
+    const entryPoints = [];
+    const totalMethodSignatures = scene.getFiles().filter(
+      (arkFile) => arkFile.getFilePath().endsWith(".ets") || arkFile.getFilePath().endsWith(".ts")
+    ).flatMap((arkFile) => arkFile.getClasses()).flatMap((arkClass) => arkClass.getMethods()).map((arkMethod) => arkMethod.getSignature());
+    safePush(entryPoints, totalMethodSignatures);
+    callGraphBuilder.buildClassHierarchyCallGraph(entryPoints, false);
+  }
+  const arkFiles = scene.getFiles();
+  const gitAnalysis = new ArkTsGitInfoAnalysis();
+  for (const gitItem of gitItems) {
+    for (const arkFile of arkFiles) {
+      let paths = gitItem.path.split("/");
+      if (gitItem.path.startsWith("NewPhotos")) {
+        paths = paths.slice(1);
+        paths.unshift(arkFile.getProjectDir());
+      } else {
+        paths.unshift(arkFile.getProjectDir());
+      }
+      const gitFilePath = getFilePath(paths);
+      if (arkFile.getFilePath() === gitFilePath) {
+        gitAnalysis.analysis(arkFile, gitItem, callGraph, mode);
+      }
+    }
+  }
+  const dependencyResourceMap = gitAnalysis.dependencyResourceMap;
+  dependencyResourceMap.forEach((resource, filePath) => {
+    const base = path3.basename(filePath);
+    if (base === "string.json" || base === "plural.json" || base === "strarray.json") {
+      analysisResult.push({
+        path: filePath,
+        kind: "resource",
+        resourceNames: Array.from(resource.resource.keys())
+      });
+    }
+  });
+  const dependencyFileDict = gitAnalysis.dependencyFileDict;
+  dependencyFileDict.forEach((lines, arkFile) => {
+    const ranges = linesToRanges(lines);
+    if (ranges.length === 0) {
+      return;
+    }
+    analysisResult.push({
+      path: arkFile.getFilePath(),
+      kind: "source",
+      ranges
+    });
+  });
+  console.error(
+    `[hometrans/context] produced ${analysisResult.length} context entries`
+  );
+  return analysisResult;
+}
+export {
+  extractCommitContext
+};