gx-code-agent 0.0.0-stage → 0.1.0

package/src/domain/java/JavaAstChunker.java

@@ -0,0 +1,139 @@
+package gx.tools;
+
+import com.sun.source.tree.AnnotationTree;
+import com.sun.source.tree.ClassTree;
+import com.sun.source.tree.CompilationUnitTree;
+import com.sun.source.tree.MethodTree;
+import com.sun.source.tree.Tree;
+import com.sun.source.util.JavacTask;
+import com.sun.source.util.SourcePositions;
+import com.sun.source.util.TreePathScanner;
+import com.sun.source.util.Trees;
+
+import javax.lang.model.element.Modifier;
+import javax.tools.Diagnostic;
+import javax.tools.DiagnosticCollector;
+import javax.tools.JavaCompiler;
+import javax.tools.JavaFileObject;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.ToolProvider;
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+
+public final class JavaAstChunker {
+
+	private JavaAstChunker() {
+	}
+
+	public static void main(String[] args) throws Exception {
+		List<File> files = new ArrayList<>();
+		try (BufferedReader reader = new BufferedReader(
+				new InputStreamReader(System.in, StandardCharsets.UTF_8))) {
+			String line;
+			while ((line = reader.readLine()) != null) {
+				if (!line.isBlank()) {
+					files.add(new File(line.trim()));
+				}
+			}
+		}
+		if (files.isEmpty()) {
+			return;
+		}
+		JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+		if (compiler == null) {
+			System.err.println("NO_JAVAC");
+			System.exit(2);
+		}
+		DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
+		StandardJavaFileManager fileManager = compiler.getStandardFileManager(diagnostics, null,
+				StandardCharsets.UTF_8);
+		JavacTask task = (JavacTask) compiler.getTask(null, fileManager, diagnostics, List.of("-proc:none"),
+				null, fileManager.getJavaFileObjectsFromFiles(files));
+		Iterable<? extends CompilationUnitTree> units = task.parse();
+		Trees trees = Trees.instance(task);
+		SourcePositions positions = trees.getSourcePositions();
+		PrintWriter out = new PrintWriter(new BufferedWriter(
+				new OutputStreamWriter(System.out, StandardCharsets.UTF_8)));
+		for (CompilationUnitTree unit : units) {
+			new TreePathScanner<Void, Void>() {
+				private final List<String> classes = new ArrayList<>();
+
+				@Override
+				public Void visitClass(ClassTree node, Void unused) {
+					String className = String.join(".", classes);
+					classes.add(node.getSimpleName().toString());
+					String fullName = String.join(".", classes);
+					long start = line(unit, positions.getStartPosition(unit, node));
+					long end = line(unit, positions.getEndPosition(unit, node));
+					if (start > 0 && end >= start) {
+						out.println("class\t" + sanitize(unit.getSourceFile().getName()) + "\t"
+								+ sanitize(fullName) + "\t\t" + start + "\t" + end + "\tfalse\t"
+								+ sanitize(annotations(node)));
+					}
+					super.visitClass(node, unused);
+					classes.remove(classes.size() - 1);
+					return null;
+				}
+
+				@Override
+				public Void visitMethod(MethodTree node, Void unused) {
+					String className = String.join(".", classes);
+					Tree returnType = node.getReturnType();
+					long start = returnType == null ? positions.getStartPosition(unit, node)
+							: positions.getStartPosition(unit, returnType);
+					long end = positions.getEndPosition(unit, node);
+					long startLine = line(unit, start);
+					long endLine = line(unit, end);
+					if (startLine > 0 && endLine >= startLine) {
+						boolean isPublic = node.getModifiers().getFlags().contains(Modifier.PUBLIC);
+						out.println("method\t" + sanitize(unit.getSourceFile().getName()) + "\t"
+								+ sanitize(className) + "\t" + sanitize(node.getName().toString()) + "\t"
+								+ startLine + "\t" + endLine + "\t" + isPublic + "\t"
+								+ sanitize(annotations(node)));
+					}
+					return super.visitMethod(node, unused);
+				}
+			}.scan(unit, null);
+		}
+		out.flush();
+		for (Diagnostic<? extends JavaFileObject> diagnostic : diagnostics.getDiagnostics()) {
+			if (diagnostic.getKind() == Diagnostic.Kind.ERROR) {
+				String source = diagnostic.getSource() == null ? "" : diagnostic.getSource().getName();
+				System.err.println(source + ":" + diagnostic.getLineNumber() + ": "
+						+ diagnostic.getMessage(Locale.ROOT));
+			}
+		}
+	}
+
+	private static long line(CompilationUnitTree unit, long position) {
+		return position < 0 ? -1 : unit.getLineMap().getLineNumber(position);
+	}
+
+	private static String annotations(MethodTree node) {
+		List<String> values = new ArrayList<>();
+		for (AnnotationTree annotation : node.getModifiers().getAnnotations()) {
+			values.add(annotation.getAnnotationType().toString());
+		}
+		return String.join(",", values);
+	}
+
+	private static String annotations(ClassTree node) {
+		List<String> values = new ArrayList<>();
+		for (AnnotationTree annotation : node.getModifiers().getAnnotations()) {
+			values.add(annotation.getAnnotationType().toString());
+		}
+		return String.join(",", values);
+	}
+
+	private static String sanitize(String value) {
+		return value.replace('\t', ' ').replace('\n', ' ').replace('\r', ' ');
+	}
+}

package/src/domain/java/JavaAstScanner.java

@@ -0,0 +1,107 @@
+package gx.tools;
+
+import com.sun.source.tree.AnnotationTree;
+import com.sun.source.tree.ClassTree;
+import com.sun.source.tree.CompilationUnitTree;
+import com.sun.source.tree.MethodTree;
+import com.sun.source.util.JavacTask;
+import com.sun.source.util.SourcePositions;
+import com.sun.source.util.TreePathScanner;
+import com.sun.source.util.Trees;
+
+import javax.lang.model.element.Modifier;
+import javax.tools.Diagnostic;
+import javax.tools.DiagnosticCollector;
+import javax.tools.JavaCompiler;
+import javax.tools.JavaFileObject;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.ToolProvider;
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+
+public final class JavaAstScanner {
+
+	private JavaAstScanner() {
+	}
+
+	public static void main(String[] args) throws Exception {
+		List<File> files = new ArrayList<>();
+		try (BufferedReader reader = new BufferedReader(
+				new InputStreamReader(System.in, StandardCharsets.UTF_8))) {
+			String line;
+			while ((line = reader.readLine()) != null) {
+				if (!line.isBlank()) {
+					files.add(new File(line.trim()));
+				}
+			}
+		}
+		if (files.isEmpty()) {
+			return;
+		}
+		JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+		if (compiler == null) {
+			System.err.println("NO_JAVAC");
+			System.exit(2);
+		}
+		DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
+		StandardJavaFileManager fileManager = compiler.getStandardFileManager(diagnostics, null,
+				StandardCharsets.UTF_8);
+		JavacTask task = (JavacTask) compiler.getTask(null, fileManager, diagnostics, List.of("-proc:none"),
+				null, fileManager.getJavaFileObjectsFromFiles(files));
+		Iterable<? extends CompilationUnitTree> units = task.parse();
+		Trees trees = Trees.instance(task);
+		SourcePositions positions = trees.getSourcePositions();
+		PrintWriter out = new PrintWriter(new BufferedWriter(
+				new OutputStreamWriter(System.out, StandardCharsets.UTF_8)));
+		for (CompilationUnitTree unit : units) {
+			new TreePathScanner<Void, Void>() {
+				private final List<String> classes = new ArrayList<>();
+
+				@Override
+				public Void visitClass(ClassTree node, Void unused) {
+					classes.add(node.getSimpleName().toString());
+					super.visitClass(node, unused);
+					classes.remove(classes.size() - 1);
+					return null;
+				}
+
+				@Override
+				public Void visitMethod(MethodTree node, Void unused) {
+					if (node.getModifiers().getFlags().contains(Modifier.PUBLIC)) {
+						long position = positions.getStartPosition(unit, node);
+						long line = position < 0 ? 0 : unit.getLineMap().getLineNumber(position);
+						List<String> annotations = new ArrayList<>();
+						for (AnnotationTree annotation : node.getModifiers().getAnnotations()) {
+							annotations.add(annotation.getAnnotationType().toString());
+						}
+						out.println(sanitize(unit.getSourceFile().getName()) + "\t"
+								+ sanitize(String.join(".", classes)) + "\t"
+								+ sanitize(node.getName().toString()) + "\t" + line + "\t"
+								+ sanitize(String.join(",", annotations)));
+					}
+					return super.visitMethod(node, unused);
+				}
+			}.scan(unit, null);
+		}
+		out.flush();
+		for (Diagnostic<? extends JavaFileObject> diagnostic : diagnostics.getDiagnostics()) {
+			if (diagnostic.getKind() == Diagnostic.Kind.ERROR) {
+				String source = diagnostic.getSource() == null ? "" : diagnostic.getSource().getName();
+				System.err.println(source + ":" + diagnostic.getLineNumber() + ": "
+						+ diagnostic.getMessage(Locale.ROOT));
+			}
+		}
+	}
+
+	private static String sanitize(String value) {
+		return value.replace('\t', ' ').replace('\n', ' ').replace('\r', ' ');
+	}
+}

package/src/domain/javaAst.js

@@ -0,0 +1,186 @@
+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 { fileURLToPath } from "node:url";
+
+import { resolveJdkTools } from "./jdk.js";
+
+const JAVA_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), "java");
+const SCANNER_SOURCE = path.join(JAVA_DIR, "JavaAstScanner.java");
+const CHUNKER_SOURCE = path.join(JAVA_DIR, "JavaAstChunker.java");
+
+/**
+ * 编译并缓存一个 Java AST 工具。
+ *
+ * @param {string} sourcePath
+ * @param {{ javac: string, major: number }} tools
+ * @param {string} className
+ * @returns {{ ok: boolean, cacheDir?: string, reason?: string }}
+ */
+function ensureTool(sourcePath, tools, className) {
+  if (!fs.existsSync(sourcePath)) {
+    return { ok: false, reason: `AST 工具源码不存在：${sourcePath}` };
+  }
+  const source = fs.readFileSync(sourcePath, "utf8");
+  const cacheDir = path.join(os.tmpdir(), "gx-java-ast",
+    `${createHash("sha256").update(source).digest("hex").slice(0, 16)}-${tools.major}-${className}`);
+  const classFile = path.join(cacheDir, ...className.split(".")) + ".class";
+  if (fs.existsSync(classFile)) {
+    return { ok: true, cacheDir };
+  }
+  fs.mkdirSync(cacheDir, { recursive: true });
+  const compiled = spawnSync(tools.javac, ["-encoding", "UTF-8", "-d", cacheDir, sourcePath], {
+    encoding: "utf8",
+    maxBuffer: 10 * 1024 * 1024
+  });
+  if (compiled.error) {
+    return { ok: false, reason: `AST 工具编译失败：${compiled.error.message}` };
+  }
+  if (compiled.status !== 0) {
+    const detail = `${compiled.stdout ?? ""}\n${compiled.stderr ?? ""}`.trim().split(/\r?\n/u)[0];
+    return { ok: false, reason: `AST 工具编译失败：${detail}` };
+  }
+  return { ok: true, cacheDir };
+}
+
+/**
+ * 执行 Java AST 工具。
+ *
+ * @param {{ java: string }} tools
+ * @param {string} className
+ * @param {string} cacheDir
+ * @param {string[]} files
+ * @returns {object}
+ */
+function runTool(tools, className, cacheDir, files) {
+  return spawnSync(tools.java, ["-cp", cacheDir, className], {
+    input: files.join("\n"),
+    encoding: "utf8",
+    maxBuffer: 20 * 1024 * 1024
+  });
+}
+
+/**
+ * 用 JDK Compiler Tree API 解析 Java 方法、注解与行号。
+ *
+ * @param {{ files: string[] }} input
+ * @returns {{ available: boolean, methods: object[], warnings: string[], reason: string | null }}
+ */
+export function scanJavaAst({ files }) {
+  if (!files || files.length === 0) {
+    return { available: true, methods: [], warnings: [], reason: null };
+  }
+  const tools = resolveJdkTools();
+  if (!tools.ok) {
+    return { available: false, methods: [], warnings: [], reason: tools.reason };
+  }
+  const scanner = ensureTool(SCANNER_SOURCE, tools, "gx.tools.JavaAstScanner");
+  if (!scanner.ok) {
+    return { available: false, methods: [], warnings: [], reason: scanner.reason };
+  }
+  const result = runTool(tools, "gx.tools.JavaAstScanner", scanner.cacheDir, files);
+  if (result.error) {
+    return { available: false, methods: [], warnings: [], reason: `AST 扫描执行失败：${result.error.message}` };
+  }
+  if (result.status !== 0) {
+    const detail = `${result.stdout ?? ""}\n${result.stderr ?? ""}`.trim().split(/\r?\n/u)[0];
+    return { available: false, methods: [], warnings: [], reason: `AST 扫描执行失败：${detail}` };
+  }
+  const methods = [];
+  for (const line of (result.stdout ?? "").split(/\r?\n/u)) {
+    if (!line) {
+      continue;
+    }
+    const [file, className, methodName, lineText, annotationText] = line.split("\t");
+    if (!file || !className || !methodName) {
+      continue;
+    }
+    methods.push({
+      file: path.resolve(file),
+      className,
+      methodName,
+      line: Number.parseInt(lineText, 10) || 0,
+      annotations: annotationText ? annotationText.split(",").filter(Boolean) : []
+    });
+  }
+  return {
+    available: true,
+    methods,
+    warnings: warnings(result.stderr),
+    reason: null
+  };
+}
+
+/**
+ * 用 JDK Compiler Tree API 生成 Java 类/方法切片边界。
+ *
+ * @param {{ files: string[] }} input
+ * @returns {{ available: boolean, chunks: object[], warnings: string[], reason: string | null }}
+ */
+export function scanJavaChunks({ files }) {
+  if (!files || files.length === 0) {
+    return { available: true, chunks: [], warnings: [], reason: null };
+  }
+  const tools = resolveJdkTools();
+  if (!tools.ok) {
+    return { available: false, chunks: [], warnings: [], reason: tools.reason };
+  }
+  const chunker = ensureTool(CHUNKER_SOURCE, tools, "gx.tools.JavaAstChunker");
+  if (!chunker.ok) {
+    return { available: false, chunks: [], warnings: [], reason: chunker.reason };
+  }
+  const result = runTool(tools, "gx.tools.JavaAstChunker", chunker.cacheDir, files);
+  if (result.error) {
+    return { available: false, chunks: [], warnings: [], reason: `AST 切片执行失败：${result.error.message}` };
+  }
+  if (result.status !== 0) {
+    const detail = `${result.stdout ?? ""}\n${result.stderr ?? ""}`.trim().split(/\r?\n/u)[0];
+    return { available: false, chunks: [], warnings: [], reason: `AST 切片执行失败：${detail}` };
+  }
+  const chunks = [];
+  for (const line of (result.stdout ?? "").split(/\r?\n/u)) {
+    if (!line) {
+      continue;
+    }
+    const [kind, file, className, methodName, startText, endText, publicText, annotationText] = line.split("\t");
+    if (!kind || !file || !className) {
+      continue;
+    }
+    const startLine = Number.parseInt(startText, 10) || 0;
+    const endLine = Number.parseInt(endText, 10) || 0;
+    if (startLine < 1 || endLine < startLine) {
+      continue;
+    }
+    chunks.push({
+      kind,
+      file: path.resolve(file),
+      className,
+      methodName: methodName || null,
+      startLine,
+      endLine,
+      isPublic: publicText === "true",
+      annotations: annotationText ? annotationText.split(",").filter(Boolean) : []
+    });
+  }
+  return {
+    available: true,
+    chunks,
+    warnings: warnings(result.stderr),
+    reason: null
+  };
+}
+
+/**
+ * 提取工具 stderr 中的诊断信息。
+ *
+ * @param {string | null} text
+ * @returns {string[]}
+ */
+function warnings(text) {
+  return (text ?? "").split(/\r?\n/u)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .slice(0, 20);
+}

package/src/domain/jdk.js

@@ -0,0 +1,66 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+
+let cached;
+
+/**
+ * 解析 javac 主版本。
+ *
+ * @param {string} javac
+ * @returns {number}
+ */
+function javacMajor(javac) {
+  const result = spawnSync(javac, ["-version"], { encoding: "utf8" });
+  const text = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
+  const match = text.match(/javac\s+(?:1\.)?(\d+)/u);
+  return match ? Number.parseInt(match[1], 10) : 0;
+}
+
+/**
+ * 选择可用的 JDK 9+（AST Tree API 与 JDK 17 class 文件需要）。
+ *
+ * @returns {{ ok: boolean, javac?: string, java?: string, reason?: string }}
+ */
+export function resolveJdkTools() {
+  if (cached) {
+    return cached;
+  }
+  const candidates = [];
+  if (process.env.JAVAC) {
+    candidates.push({
+      javac: process.env.JAVAC,
+      java: process.env.JAVA || (process.env.JAVA_HOME
+        ? path.join(process.env.JAVA_HOME, "bin", "java") : "java")
+    });
+  }
+  if (process.env.JAVA_HOME) {
+    candidates.push({
+      javac: path.join(process.env.JAVA_HOME, "bin", "javac"),
+      java: path.join(process.env.JAVA_HOME, "bin", "java")
+    });
+  }
+  candidates.push({ javac: "javac", java: "java" });
+  if (process.platform === "darwin") {
+    for (const version of ["17", "21", "23"]) {
+      const home = spawnSync("/usr/libexec/java_home", ["-v", version], { encoding: "utf8" });
+      if (home.status === 0 && home.stdout.trim()) {
+        candidates.push({
+          javac: path.join(home.stdout.trim(), "bin", "javac"),
+          java: path.join(home.stdout.trim(), "bin", "java")
+        });
+      }
+    }
+  }
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate.javac) || candidate.javac === "javac") {
+      const major = javacMajor(candidate.javac);
+      if (major >= 9) {
+        cached = { ok: true, ...candidate, major };
+        return cached;
+      }
+    }
+  }
+  cached = { ok: false, reason: "需要 JDK 9+；请设置 JAVA_HOME 或 JAVAC" };
+  return cached;
+}

package/src/domain/keepBlocks.js

@@ -0,0 +1,122 @@
+/**
+ * GX 生成文件的保留块合并。
+ *
+ * 生成文件中的 `[CN01-xxx] start ... end-xxx` 块归用户/AI 所有；
+ * 重新生成时必须保留目标文件里的块内容。
+ *
+ * @param {string} existing 现有文件内容
+ * @param {string} generated 新生成文件内容
+ * @returns {string}
+ */
+export function mergeKeepBlocks(existing, generated) {
+  if (!existing) {
+    return generated;
+  }
+  const generatedLines = generated.split("\n");
+  const existingBlocks = collectBlocks(existing);
+
+  const output = [];
+  for (let i = 0; i < generatedLines.length; i += 1) {
+    const line = generatedLines[i];
+    const name = startBlockName(line);
+    if (name === null) {
+      output.push(line);
+      continue;
+    }
+    const endIndex = findEnd(generatedLines, i + 1, name);
+    if (endIndex < 0) {
+      output.push(line);
+      continue;
+    }
+    output.push(line);
+    const oldBlock = existingBlocks.get(name);
+    if (oldBlock && oldBlock.length > 0) {
+      output.push(...oldBlock);
+    } else {
+      output.push(...generatedLines.slice(i + 1, endIndex));
+    }
+    output.push(generatedLines[endIndex]);
+    i = endIndex;
+  }
+  return output.join("\n");
+}
+
+/**
+ * 提取 start 行中的块名。
+ *
+ * @param {string} line
+ * @returns {string | null}
+ */
+export function startBlockName(line) {
+  const match = line.match(/\[CN01-([^\]]+)\]\s*start/u);
+  return match ? match[1] : null;
+}
+
+/**
+ * 查找结束行。
+ *
+ * @param {string[]} lines
+ * @param {number} from
+ * @param {string} name
+ * @returns {number}
+ */
+function findEnd(lines, from, name) {
+  for (let i = from; i < lines.length; i += 1) {
+    if (lines[i].includes(`end-${name}`)) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+/**
+ * 收集现有文件的块内容（不含 start/end 行）。
+ *
+ * @param {string} content
+ * @returns {Map<string, string[]>}
+ */
+export function collectBlocks(content) {
+  const lines = content.split("\n");
+  const blocks = new Map();
+  for (let i = 0; i < lines.length; i += 1) {
+    const name = startBlockName(lines[i]);
+    if (name === null) {
+      continue;
+    }
+    const endIndex = findEnd(lines, i + 1, name);
+    if (endIndex < 0) {
+      continue;
+    }
+    blocks.set(name, lines.slice(i + 1, endIndex));
+    i = endIndex;
+  }
+  return blocks;
+}
+/**
+ * 去掉保留块内部内容，只保留 start/end 行，用于漂移校验。
+ *
+ * 生成层指纹只覆盖骨架，自定义块内容归用户所有，不参与漂移判断。
+ *
+ * @param {string} content
+ * @returns {string}
+ */
+export function stripKeepBlockContents(content) {
+  const lines = content.split("\n");
+  const output = [];
+  for (let i = 0; i < lines.length; i += 1) {
+    const name = startBlockName(lines[i]);
+    if (name === null) {
+      output.push(lines[i]);
+      continue;
+    }
+    const endIndex = findEnd(lines, i + 1, name);
+    if (endIndex < 0) {
+      output.push(lines[i]);
+      continue;
+    }
+    output.push(lines[i]);
+    output.push(lines[endIndex]);
+    i = endIndex;
+  }
+  return output.join("\n");
+}