@groma/scanner-java 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groma/scanner-java",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Java compiler and project evidence; framework runtime use is not verified.",
   "private": false,
   "type": "module",
@@ -44,10 +44,7 @@
           }
         ],
         "compatibility": {
-          "groma": "^0.3.0",
-          "technologyVersions": {
-            "java": "25.0.0"
-          }
+          "groma": "^0.3.0"
         }
       }
     }

package/src/index.js

@@ -1,8 +1,40 @@
 // @bun
-// plugins/scanners/java/src/adapter.ts
-import { fileURLToPath } from "url";
+// plugins/scanners/java/src/index.ts
+import path7 from "path";
+
+// plugins/scanners/projects.ts
+import { execFile } from "child_process";
+import { existsSync } from "fs";
+import path from "path";
+import { promisify } from "util";
+var execute = promisify(execFile);
+var excluded = new Set([
+  ".git",
+  "node_modules",
+  "vendor",
+  "target",
+  "dist",
+  "build",
+  "bin",
+  "obj",
+  ".gradle",
+  ".angular",
+  "coverage",
+  "generated",
+  "groma",
+  ".groma"
+]);
+async function projectFiles(root, matches) {
+  const { stdout } = await execute("git", ["-C", root, "ls-files", "-z", "--cached", "--others", "--exclude-standard"], { maxBuffer: 64 * 1024 * 1024 });
+  return [...new Set(stdout.split("\x00").filter((file) => file && matches(file) && !file.split("/").some((part) => excluded.has(part)) && existsSync(path.join(root, file))))].sort();
+}
+
+// plugins/scanners/project-scanner.ts
 import path3 from "path";
 
+// plugins/scanners/observations.ts
+import path2 from "path";
+
 // packages/scanner/src/index.ts
 function compare(...values) {
   return values.join("\x00");
@@ -257,27 +289,101 @@ function sourcePosition(position) {
   return { position: Number(position) };
 }
 
+// plugins/scanners/observations.ts
+function relocateObservation(observation, directory) {
+  const file = (value) => path2.posix.normalize(path2.posix.join(directory, value));
+  return {
+    ...observation,
+    roots: observation.roots.map((root) => ({ ...root, ...root.file ? { file: file(root.file) } : {} })),
+    files: observation.files.map((source) => ({ ...source, file: file(source.file) })),
+    operations: observation.operations?.map((operation) => ({ ...operation, file: file(operation.file) })),
+    invocations: observation.invocations?.map((call) => ({
+      ...call,
+      ...call.binding ? { binding: { ...call.binding, file: file(call.binding.file) } } : {}
+    })),
+    diagnostics: observation.diagnostics.map((item) => ({ ...item, ...item.file ? { file: file(item.file) } : {} }))
+  };
+}
+function combineObservations(parts) {
+  if (!parts.length)
+    return;
+  const roots = [];
+  const files = new Map;
+  const operations = [];
+  const invocations = [];
+  const diagnostics = [];
+  for (const { key, observation } of parts) {
+    const id = (value) => JSON.stringify([key, value]);
+    roots.push(...observation.roots.map((root) => ({ ...root, id: id(root.id), ...root.parent ? { parent: id(root.parent) } : {} })));
+    for (const source of observation.files) {
+      const combined = files.get(source.file) ?? { file: source.file, roots: [], symbols: [] };
+      combined.roots.push(...source.roots.map(id));
+      combined.symbols.push(...source.symbols.map((symbol) => ({ ...symbol, id: id(symbol.id) })));
+      files.set(source.file, combined);
+    }
+    operations.push(...(observation.operations ?? []).map((operation) => ({ ...operation, id: id(operation.id) })));
+    invocations.push(...(observation.invocations ?? []).map((call) => ({ ...call, source: id(call.source), targets: call.targets.map(id) })));
+    diagnostics.push(...observation.diagnostics);
+  }
+  return createScanObservation({
+    scanner: parts[0].observation.scanner,
+    roots,
+    files: [...files.values()],
+    operations,
+    invocations,
+    diagnostics
+  });
+}
+
+// plugins/scanners/project-scanner.ts
+function projectScanner(scanner, select) {
+  return {
+    ...scanner,
+    checkReadiness: async (root, settings = {}) => {
+      const projects = await select(root, settings);
+      if (!projects.length)
+        throw new Error(`${scanner.id}: No supported project declaration was found.`);
+      for (const project of projects)
+        await scanner.checkReadiness?.(project, settings);
+    },
+    scan: async (root, settings = {}) => {
+      const parts = [];
+      for (const project of await select(root, settings)) {
+        const observation = await scanner.scan(project, settings);
+        const key = path3.relative(root, project).split(path3.sep).join("/");
+        if (observation)
+          parts.push({ key, observation: relocateObservation(observation, key) });
+      }
+      return combineObservations(parts);
+    }
+  };
+}
+
+// plugins/scanners/java/src/adapter.ts
+import { fileURLToPath } from "url";
+import path6 from "path";
+
 // plugins/scanners/java/src/maven.ts
 import { access, mkdtemp, readFile, readdir, realpath, rm } from "fs/promises";
 import os from "os";
-import path2 from "path";
+import path5 from "path";
 
 // plugins/scanners/java/src/process.ts
-import { execFile } from "child_process";
-import path from "path";
+import { execFile as execFile2 } from "child_process";
+import path4 from "path";
 function javaCommand() {
   const executable = process.platform === "win32" ? "java.exe" : "java";
-  return process.env.JAVA_HOME ? path.join(process.env.JAVA_HOME, "bin", executable) : executable;
+  return process.env.JAVA_HOME ? path4.join(process.env.JAVA_HOME, "bin", executable) : executable;
 }
 function run(command, args, root, input = "", timeout = 120000) {
   return new Promise((resolve, reject) => {
-    const child = execFile(command, args, {
+    const child = execFile2(command, args, {
       cwd: root,
       encoding: "utf8",
       timeout,
       killSignal: "SIGKILL",
       maxBuffer: 64 * 1024 * 1024,
-      windowsVerbatimArguments: process.platform === "win32" && path.basename(command).toLowerCase() === "cmd.exe"
+      windowsVerbatimArguments: process.platform === "win32" && path4.basename(command).toLowerCase() === "cmd.exe"
     }, (error, stdout, stderr) => {
       if (error)
         reject(new Error(stderr.trim() || stdout.trim() || error.message));
@@ -308,16 +414,16 @@ async function exists(file) {
 async function collect(root, directory) {
   const files = [];
   for (const entry of await readdir(directory, { withFileTypes: true })) {
-    const file = path2.join(directory, entry.name);
+    const file = path5.join(directory, entry.name);
     if (entry.isDirectory())
       files.push(...await collect(root, file));
     else if (entry.isFile() && file.endsWith(".java"))
-      files.push(path2.relative(root, file).split(path2.sep).join("/"));
+      files.push(path5.relative(root, file).split(path5.sep).join("/"));
   }
   return files.sort();
 }
 async function mavenCommand(root) {
-  const wrapper = path2.join(root, process.platform === "win32" ? "mvnw.cmd" : "mvnw");
+  const wrapper = path5.join(root, process.platform === "win32" ? "mvnw.cmd" : "mvnw");
   return await exists(wrapper) ? wrapper : process.platform === "win32" ? "mvn.cmd" : "mvn";
 }
 var mavenGoals = [
@@ -326,13 +432,13 @@ var mavenGoals = [
 ];
 async function readJavaInput(repositoryRoot, java, worker, maven) {
   const root = await realpath(repositoryRoot);
-  if (!await exists(path2.join(root, "pom.xml"))) {
-    throw new Error("JAVA_UNSUPPORTED_BUILD: The Java scanner supports a root single-module Maven pom.xml. Gradle and other build arrangements are not supported.");
+  if (!await exists(path5.join(root, "pom.xml"))) {
+    throw new Error("JAVA_UNSUPPORTED_BUILD: The Java scanner supports Maven pom.xml projects. Gradle and other build arrangements are not supported.");
   }
-  const temporary = await mkdtemp(path2.join(os.tmpdir(), "groma-java-model-"));
+  const temporary = await mkdtemp(path5.join(os.tmpdir(), "groma-java-model-"));
   try {
-    const model = path2.join(temporary, "pom.xml");
-    const classpath = path2.join(temporary, "classpath.txt");
+    const model = path5.join(temporary, "pom.xml");
+    const classpath = path5.join(temporary, "classpath.txt");
     const command = maven ?? await mavenCommand(root);
     const args = [
       "--offline",
@@ -350,12 +456,14 @@ async function readJavaInput(repositoryRoot, java, worker, maven) {
       throw new Error(`JAVA_MAVEN_PREPARATION: Install the project JDK and Maven (or use its wrapper), then run ${command} ${mavenGoals.join(" ")} -DincludeScope=compile once with dependency access. Scans use Maven offline. ${error instanceof Error ? error.message : error}`);
     }
     const exported = JSON.parse(await run(java, ["-jar", worker, "model", model], root));
+    if (exported.aggregator)
+      return;
     const files = await collect(root, exported.sourceRoot);
     if (!files.length)
       throw new Error("JAVA_EMPTY_SOURCE_SET: Maven main source directory contains no Java sources.");
     if (files.some((file) => file.endsWith("module-info.java")))
       throw new Error("JAVA_UNSUPPORTED_BUILD: JPMS module paths are not supported.");
-    const dependencies = (await readFile(classpath, "utf8")).trim().split(path2.delimiter).filter(Boolean);
+    const dependencies = (await readFile(classpath, "utf8")).trim().split(path5.delimiter).filter(Boolean);
     if (await exists(exported.output))
       dependencies.push(exported.output);
     return {
@@ -391,6 +499,8 @@ async function checkJavaReadiness(repositoryRoot, options = {}) {
 }
 async function scanJavaSource(repositoryRoot, options = {}) {
   const { input, command, jar } = await checkJavaReadiness(repositoryRoot, options);
+  if (!input)
+    return;
   let stdout;
   try {
     stdout = await run(command, [
@@ -401,7 +511,7 @@ async function scanJavaSource(repositoryRoot, options = {}) {
       input.release,
       input.encoding,
       input.generatedRoot
-    ], input.root, `${input.classpath.join(path3.delimiter)}
+    ], input.root, `${input.classpath.join(path6.delimiter)}
 ${input.files.join(`
 `)}
 `, options.timeout);
@@ -416,13 +526,13 @@ ${input.files.join(`
 // plugins/scanners/java/src/index.ts
 var scanner = {
   id: "java",
-  watch: { include: ["**/*.java", "pom.xml", ".mvn/**"], exclude: [] },
+  watch: { include: ["**/*.java", "**/pom.xml", "**/.mvn/**"], exclude: [] },
   checkReadiness: async (root) => {
     await checkJavaReadiness(root);
   },
   scan: scanJavaSource
 };
-var src_default = scanner;
+var src_default = projectScanner(scanner, async (root) => (await projectFiles(root, (file) => path7.posix.basename(file) === "pom.xml")).map((file) => path7.dirname(path7.join(root, file))));
 export {
   src_default as default
 };