gx-code-agent 0.0.0-stage → 0.1.1

package/src/application/scanWorkflow.js

@@ -0,0 +1,689 @@
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { scanJavaAst } from "../domain/javaAst.js";
+import { resolveJdkTools } from "../domain/jdk.js";
+
+const DEFAULT_SOURCE_DIRS = ["src/main/java"];
+const IGNORED_DIRS = new Set(["node_modules", ".git", "target", "build", "dist", "out", ".gx"]);
+const EXTENSION_CLASS_SUFFIX = /(Hook|Ext|Extension|Listener|Handler|ServiceImpl|Service)$/u;
+const IGNORED_METHODS = new Set(["main", "equals", "hashCode", "toString", "canEqual"]);
+
+/**
+ * 递归收集 Java 文件。
+ *
+ * @param {string} dir
+ * @param {string[]} output
+ */
+function collectJavaFiles(dir, output) {
+  if (!fs.existsSync(dir)) {
+    return;
+  }
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (IGNORED_DIRS.has(entry.name)) {
+      continue;
+    }
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      collectJavaFiles(full, output);
+    } else if (entry.isFile() && entry.name.endsWith(".java")) {
+      output.push(full);
+    }
+  }
+}
+
+/**
+ * 按文件路径生成稳定的相对路径。
+ *
+ * @param {string} dir
+ * @param {string} file
+ * @returns {string}
+ */
+function relativePath(dir, file) {
+  return path.relative(dir, file).split(path.sep).join("/");
+}
+
+/**
+ * 计算行号（1 开始）。
+ *
+ * @param {string} content
+ * @param {number} index
+ * @returns {number}
+ */
+function lineAt(content, index) {
+  return content.slice(0, index).split("\n").length;
+}
+
+/**
+ * 从 openIndex 开始查找配对的右括号，跳过字符串与注释。
+ *
+ * @param {string} content
+ * @param {number} openIndex
+ * @param {string} open
+ * @param {string} close
+ * @returns {number}
+ */
+function findMatching(content, openIndex, open = "(", close = ")") {
+  let depth = 0;
+  let quote = null;
+  let escaped = false;
+  let lineComment = false;
+  let blockComment = false;
+  for (let i = openIndex; i < content.length; i += 1) {
+    const char = content[i];
+    const next = content[i + 1];
+    if (lineComment) {
+      if (char === "\n") {
+        lineComment = false;
+      }
+      continue;
+    }
+    if (blockComment) {
+      if (char === "*" && next === "/") {
+        blockComment = false;
+        i += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      lineComment = true;
+      i += 1;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      blockComment = true;
+      i += 1;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char === open) {
+      depth += 1;
+    } else if (char === close) {
+      depth -= 1;
+      if (depth === 0) {
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+
+/**
+ * 拆分注解参数中的顶层逗号。
+ *
+ * @param {string} text
+ * @returns {string[]}
+ */
+function splitTopLevel(text) {
+  const parts = [];
+  let start = 0;
+  let depth = 0;
+  let quote = null;
+  let escaped = false;
+  for (let i = 0; i < text.length; i += 1) {
+    const char = text[i];
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char === "{" || char === "(" || char === "[") {
+      depth += 1;
+    } else if (char === "}" || char === ")" || char === "]") {
+      depth -= 1;
+    } else if (char === "," && depth === 0) {
+      parts.push(text.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(text.slice(start));
+  return parts.map((part) => part.trim()).filter(Boolean);
+}
+
+/**
+ * 解析字符串字面量。
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+function parseString(text) {
+  const trimmed = text.trim();
+  if (trimmed.startsWith('"')) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return trimmed.slice(1, -1);
+    }
+  }
+  if (trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1).replace(/\\'/gu, "'").replace(/\\\\/gu, "\\");
+  }
+  return trimmed;
+}
+
+/**
+ * 解析数组字面量中的字符串。
+ *
+ * @param {string} text
+ * @returns {string[]}
+ */
+function parseStringArray(text) {
+  const matches = [...text.matchAll(/"((?:\\.|[^"\\])*)"|'((?:\\.|[^'\\])*)'/gu)];
+  return matches.map((match) => {
+    if (match[1] !== undefined) {
+      try {
+        return JSON.parse(`"${match[1]}"`);
+      } catch {
+        return match[1];
+      }
+    }
+    return match[2].replace(/\\'/gu, "'").replace(/\\\\/gu, "\\");
+  });
+}
+
+/**
+ * 解析 @ExtMethod 参数。
+ *
+ * @param {string} text
+ * @returns {{ entity?: string, intent?: string, triggers: string[] }}
+ */
+function parseExtMethodArgs(text) {
+  const parsed = { triggers: [], fields: [] };
+  for (const part of splitTopLevel(text)) {
+    const equals = part.indexOf("=");
+    if (equals < 0) {
+      continue;
+    }
+    const key = part.slice(0, equals).trim();
+    const value = part.slice(equals + 1).trim();
+    if (key === "entity" || key === "intent") {
+      parsed[key] = parseString(value);
+    } else if (key === "triggers") {
+      parsed.triggers = parseStringArray(value);
+    } else if (key === "fields") {
+      parsed.fields = parseStringArray(value);
+    }
+  }
+  return parsed;
+}
+
+/**
+ * 找到注解所在类名。
+ *
+ * @param {string} content
+ * @param {number} index
+ * @returns {string}
+ */
+function classNameAt(content, index) {
+  const regex = /\b(?:class|interface|enum|record)\s+([A-Za-z_$][\w$]*)/gu;
+  let name = "";
+  for (const match of content.matchAll(regex)) {
+    if (match.index > index) {
+      break;
+    }
+    name = match[1];
+  }
+  return name;
+}
+
+/**
+ * 跳过空白、注释与注解。
+ *
+ * @param {string} content
+ * @param {number} start
+ * @returns {number}
+ */
+function skipTrivia(content, start) {
+  let i = start;
+  while (i < content.length) {
+    if (/\s/u.test(content[i])) {
+      i += 1;
+      continue;
+    }
+    if (content[i] === "/" && content[i + 1] === "/") {
+      const end = content.indexOf("\n", i + 2);
+      i = end < 0 ? content.length : end + 1;
+      continue;
+    }
+    if (content[i] === "/" && content[i + 1] === "*") {
+      const end = content.indexOf("*/", i + 2);
+      i = end < 0 ? content.length : end + 2;
+      continue;
+    }
+    if (content[i] === "@") {
+      let j = i + 1;
+      while (j < content.length && /[\w$.]/u.test(content[j])) {
+        j += 1;
+      }
+      j = skipTrivia(content, j);
+      if (content[j] === "(") {
+        const close = findMatching(content, j);
+        j = close < 0 ? content.length : close + 1;
+      }
+      i = j;
+      continue;
+    }
+    break;
+  }
+  return i;
+}
+
+/**
+ * 从注解后定位方法。
+ *
+ * @param {string} content
+ * @param {number} start
+ * @returns {{ methodName: string, start: number, end: number } | null}
+ */
+function findMethodAfter(content, start) {
+  let i = skipTrivia(content, start);
+  const modifiers = /^(?:public|protected|private|static|final|abstract|synchronized|native|default|strictfp|transient|volatile)\b/u;
+  for (;;) {
+    const rest = content.slice(i);
+    const match = rest.match(modifiers);
+    if (!match) {
+      break;
+    }
+    i = skipTrivia(content, i + match[0].length);
+  }
+  const paren = content.indexOf("(", i);
+  if (paren < 0) {
+    return null;
+  }
+  const segment = content.slice(i, paren);
+  const nameMatch = segment.match(/([A-Za-z_$][\w$]*)\s*$/u);
+  if (!nameMatch) {
+    return null;
+  }
+  const methodName = nameMatch[1];
+  const methodStart = i;
+  const afterParen = findMatching(content, paren);
+  if (afterParen < 0) {
+    return null;
+  }
+  let cursor = afterParen + 1;
+  let bodyStart = -1;
+  while (cursor < content.length) {
+    const char = content[cursor];
+    if (char === ";") {
+      return { methodName, start: methodStart, end: cursor + 1 };
+    }
+    if (char === "{") {
+      bodyStart = cursor;
+      break;
+    }
+    cursor += 1;
+  }
+  if (bodyStart < 0) {
+    return { methodName, start: methodStart, end: afterParen + 1 };
+  }
+  const bodyEnd = findMatching(content, bodyStart, "{", "}");
+  return { methodName, start: methodStart, end: bodyEnd < 0 ? content.length : bodyEnd + 1 };
+}
+
+/**
+ * 提取源码中的 @ExtMethod 声明。
+ *
+ * @param {string} content
+ * @param {string} file
+ * @param {string} dir
+ * @param {string[]} warnings
+ * @returns {object[]}
+ */
+function extractExtPoints(content, file, dir, warnings) {
+  const points = [];
+  const regex = /@(?:[A-Za-z_$][\w$]*\.)*ExtMethod\s*\(/gu;
+  for (const match of content.matchAll(regex)) {
+    const open = match.index + match[0].lastIndexOf("(");
+    const close = findMatching(content, open);
+    if (close < 0) {
+      warnings.push(`${relativePath(dir, file)}: @ExtMethod 参数括号未闭合`);
+      continue;
+    }
+    const args = parseExtMethodArgs(content.slice(open + 1, close));
+    const method = findMethodAfter(content, close + 1);
+    if (!method) {
+      warnings.push(`${relativePath(dir, file)}: @ExtMethod 后未找到方法`);
+      continue;
+    }
+    const className = classNameAt(content, match.index);
+    if (!className || !args.entity || !args.intent) {
+      warnings.push(`${relativePath(dir, file)}: @ExtMethod 缺少 entity/intent 或类名`);
+      continue;
+    }
+    const code = content.slice(method.start, method.end).trim();
+    points.push({
+      entity: args.entity,
+      intent: args.intent,
+      triggers: args.triggers,
+      fields: args.fields,
+      class: className,
+      method: method.methodName,
+      codeHash: createHash("sha256").update(code).digest("hex"),
+      file: relativePath(dir, file)
+    });
+  }
+  return points;
+}
+
+/**
+ * 判断文件是否属于扩展层候选。
+ *
+ * @param {string} content
+ * @param {string} className
+ * @returns {boolean}
+ */
+function isExtensionCandidate(content, className) {
+  const pkg = content.match(/^\s*package\s+([\w.]+)\s*;/mu)?.[1] ?? "";
+  return /(?:^|\.)(?:ext|extension)(?:\.|$)/iu.test(pkg)
+    || EXTENSION_CLASS_SUFFIX.test(className)
+    || content.includes("@ExtMethod");
+}
+
+/**
+ * 提取扩展层中缺少 @ExtMethod 的公开方法。
+ *
+ * @param {string} content
+ * @param {string} file
+ * @param {string} dir
+ * @param {string} className
+ * @param {Set<string>} annotated
+ * @returns {object[]}
+ */
+function extractUnannotated(content, file, dir, className, annotated) {
+  if (!className || !isExtensionCandidate(content, className) || content.includes("@generated GX-CODE")) {
+    return [];
+  }
+  const result = [];
+  const regex = /\bpublic\s+(?:static\s+)?(?:final\s+)?(?:synchronized\s+)?(?:abstract\s+)?(?:default\s+)?[\w$<>\[\],.?\s]+\s+([A-Za-z_$][\w$]*)\s*\(/gu;
+  for (const match of content.matchAll(regex)) {
+    const methodName = match[1];
+    if (IGNORED_METHODS.has(methodName) || methodName === className || annotated.has(methodName)) {
+      continue;
+    }
+    result.push({
+      className,
+      methodName,
+      file: relativePath(dir, file),
+      line: lineAt(content, match.index),
+      reason: "扩展层公开方法未声明 @ExtMethod"
+    });
+  }
+  return result;
+}
+
+/**
+ * 构建编译 classpath。
+ *
+ * @param {string} dir
+ * @param {string | undefined} extra
+ * @returns {string[]}
+ */
+function buildClasspath(dir, extra) {
+  const entries = [];
+  if (extra) {
+    entries.push(...extra.split(path.delimiter).map((item) => item.trim()).filter(Boolean));
+  }
+  for (const candidate of ["target/classes", "build/classes/java/main", "out/production/classes", "bin/main"]) {
+    const full = path.join(dir, candidate);
+    if (fs.existsSync(full)) {
+      entries.push(full);
+    }
+  }
+  for (const candidate of ["target/dependency", "build/libs", "lib"]) {
+    const full = path.join(dir, candidate);
+    if (!fs.existsSync(full)) {
+      continue;
+    }
+    for (const entry of fs.readdirSync(full, { withFileTypes: true })) {
+      if (entry.isFile() && entry.name.endsWith(".jar")) {
+        entries.push(path.join(full, entry.name));
+      }
+    }
+  }
+  return entries;
+}
+
+/**
+ * 使用 javac 编译扩展层源码。
+ *
+ * @param {{ dir: string, files: string[], classpath?: string }} input
+ * @returns {object}
+ */
+function compileSources({ dir, files, classpath, sourceDirs }) {
+  const tools = resolveJdkTools();
+  if (!tools.ok) {
+    return { attempted: false, available: false, reason: tools.reason };
+  }
+  const javac = tools.javac;
+  if (files.length === 0) {
+    return { attempted: true, available: true, success: true, fileCount: 0, errors: [] };
+  }
+  const output = fs.mkdtempSync(path.join(os.tmpdir(), "gx-compile-"));
+  const cp = buildClasspath(dir, classpath);
+  const args = ["-proc:none", "-encoding", "UTF-8", "-d", output];
+  if (sourceDirs.length > 0) {
+    args.push("-sourcepath", sourceDirs.join(path.delimiter));
+  }
+  if (cp.length > 0) {
+    args.push("-cp", cp.join(path.delimiter));
+  }
+  args.push(...files);
+  const result = spawnSync(javac, args, { encoding: "utf8", maxBuffer: 10 * 1024 * 1024 });
+  fs.rmSync(output, { recursive: true, force: true });
+  if (result.error) {
+    return { attempted: false, available: false, reason: `javac 执行失败：${result.error.message}` };
+  }
+  const text = `${result.stdout ?? ""}\n${result.stderr ?? ""}`;
+  const errors = [];
+  let contextLines = 0;
+  for (const line of text.split(/\r?\n/u).map((item) => item.trim()).filter(Boolean)) {
+    if (line.includes(".java:") || line.startsWith("error:") || line.startsWith("错误:")) {
+      errors.push(line);
+      contextLines = 3;
+      continue;
+    }
+    if (contextLines > 0) {
+      errors.push(line);
+      contextLines -= 1;
+    }
+    if (errors.length >= 50) {
+      break;
+    }
+  }
+  return {
+    attempted: true,
+    available: true,
+    success: result.status === 0,
+    exitCode: result.status,
+    fileCount: files.length,
+    errors
+  };
+}
+
+/**
+ * 扫描扩展点。
+ *
+ * @param {{ dir: string, sourceDirs?: string[], compile?: boolean, classpath?: string }} input
+ * @returns {{ extPoints: object[], unannotatedMethods: object[], warnings: string[], coverage: object, filesScanned: number, compilation: object | null }}
+ */
+export function scanWorkflow({ dir, sourceDirs = DEFAULT_SOURCE_DIRS, compile = false, classpath }) {
+  const existingDirs = sourceDirs
+    .map((sourceDir) => (path.isAbsolute(sourceDir) ? sourceDir : path.join(dir, sourceDir)))
+    .filter((sourceDir) => fs.existsSync(sourceDir));
+
+  const files = [];
+  for (const sourceDir of existingDirs) {
+    collectJavaFiles(sourceDir, files);
+  }
+
+  const points = [];
+  const unannotated = [];
+  const warnings = [];
+  const extensionFiles = [];
+  const ast = scanJavaAst({ files });
+  const astByFile = new Map();
+  for (const method of ast.methods) {
+    const list = astByFile.get(path.resolve(method.file)) ?? [];
+    list.push(method);
+    astByFile.set(path.resolve(method.file), list);
+  }
+  if (!ast.available) {
+    warnings.push(`AST 扫描不可用，回退正则检测：${ast.reason}`);
+  }
+  else {
+    warnings.push(...ast.warnings);
+  }
+  for (const file of files) {
+    const content = fs.readFileSync(file, "utf8");
+    const pointsInFile = extractExtPoints(content, file, dir, warnings);
+    const annotatedByClass = new Map();
+    for (const point of pointsInFile) {
+      const list = annotatedByClass.get(point.class) ?? new Set();
+      list.add(point.method);
+      annotatedByClass.set(point.class, list);
+    }
+    points.push(...pointsInFile);
+    const classes = new Set([...content.matchAll(/\b(?:class|interface|enum|record)\s+([A-Za-z_$][\w$]*)/gu)]
+      .map((match) => match[1]));
+    const astMethods = astByFile.get(path.resolve(file)) ?? [];
+    const astAnnotatedByClass = new Map();
+    for (const method of astMethods) {
+      if (!method.annotations.some((annotation) => annotation.endsWith("ExtMethod"))) {
+        continue;
+      }
+      const list = astAnnotatedByClass.get(method.className) ?? new Set();
+      list.add(method.methodName);
+      astAnnotatedByClass.set(method.className, list);
+    }
+    if (ast.available) {
+      for (const method of astMethods) {
+        const className = method.className;
+        const simpleClass = className.split(".").pop();
+        if (!className || className.endsWith(".") || !simpleClass || content.includes("@generated GX-CODE")) {
+          continue;
+        }
+        if (!isExtensionCandidate(content, className)
+            || IGNORED_METHODS.has(method.methodName) || method.methodName === simpleClass) {
+          continue;
+        }
+        if (method.annotations.some((annotation) => annotation.endsWith("ExtMethod"))) {
+          continue;
+        }
+        if ((astAnnotatedByClass.get(className) ?? new Set()).has(method.methodName)) {
+          continue;
+        }
+        unannotated.push({
+          className,
+          methodName: method.methodName,
+          file: relativePath(dir, file),
+          line: method.line,
+          reason: "扩展层公开方法未声明 @ExtMethod（AST）"
+        });
+      }
+      for (const className of new Set(astMethods.map((method) => method.className))) {
+        if (className && !className.endsWith(".") && isExtensionCandidate(content, className)) {
+          extensionFiles.push(file);
+        }
+      }
+    }
+    else {
+      for (const className of classes) {
+        unannotated.push(...extractUnannotated(content, file, dir, className,
+          annotatedByClass.get(className) ?? new Set()));
+        if (isExtensionCandidate(content, className)) {
+          extensionFiles.push(file);
+        }
+      }
+    }
+  }
+
+  points.sort((left, right) => `${left.class}#${left.method}`.localeCompare(`${right.class}#${right.method}`));
+  unannotated.sort((left, right) => `${left.className}#${left.methodName}`
+    .localeCompare(`${right.className}#${right.methodName}`));
+
+  const sourceAvailable = existingDirs.length > 0;
+  const facets = {
+    source_files: sourceAvailable
+      ? { available: true }
+      : { available: false, reason: "源码目录不存在" },
+    ext_method_scan: sourceAvailable
+      ? { available: true, reason: null }
+      : { available: false, reason: "源码目录不存在，无法扫描 @ExtMethod" },
+    ast_scan: sourceAvailable
+      ? (ast.available ? { available: true, reason: null }
+        : { available: false, reason: ast.reason })
+      : { available: false, reason: "源码目录不存在，无法执行 AST 扫描" },
+    compilation: compile
+      ? { available: false, reason: "未执行编译" }
+      : { available: false, reason: "未执行编译；如需编译请使用 --compile" }
+  };
+
+  let compilation = null;
+  if (compile) {
+    const compileFiles = extensionFiles.length > 0 ? [...new Set(extensionFiles)] : files;
+    compilation = compileSources({ dir, files: compileFiles, classpath, sourceDirs: existingDirs });
+    facets.compilation = compilation.available
+      ? { available: true, success: compilation.success, reason: compilation.success ? null
+        : `javac 失败，退出码 ${compilation.exitCode}` }
+      : { available: false, reason: compilation.reason };
+    if (compilation.available && !compilation.success) {
+      warnings.push(`扩展层编译失败，共 ${compilation.errors.length} 条错误`);
+    }
+  }
+
+  return {
+    extPoints: points,
+    unannotatedMethods: dedupeMethods(unannotated),
+    warnings,
+    filesScanned: files.length,
+    compilation,
+    coverage: {
+      status: sourceAvailable ? "partial" : "unknown",
+      facets
+    }
+  };
+}
+
+/**
+ * 去重未声明方法。
+ *
+ * @param {object[]} methods
+ * @returns {object[]}
+ */
+function dedupeMethods(methods) {
+  const seen = new Set();
+  return methods.filter((item) => {
+    const key = `${item.className}#${item.methodName}@${item.file}:${item.line}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}