Make spikes into maven projects

Author: edburns

1917-java-embed-rust-cli-runtime-remove-before-merge/20260723-prompts.md

@@ -38,8 +38,6 @@ It must be a standalone Java program that produces an executable jar I can invok
 
 ### 18:22 Prompt
 
-
-
 In this session, we are reducing the ignorance in the `copilot-sdk/1917-java-embed-rust-cli-runtime-remove-before-merge/1917-embed-cli-runtime-ignorance-reduction-plan.md` by working through the items in Section 3 for which we do not yet have a **Resolution:**. For starters, read and understand that whole document.
 
 Today we start with ### 3.6 — Platform detection implementation
@@ -153,3 +151,94 @@ Running it with:
 `java -jar spike-3-6-platform-detection-darwin-arm64.jar`
 
 prints detected platform details by default; on this machine it logs `arch=arm64` and `classifier=darwin-arm64`.
+
+### 18:37 Prompt
+
+In this session, we are reducing the ignorance in the `copilot-sdk/1917-java-embed-rust-cli-runtime-remove-before-merge/1917-embed-cli-runtime-ignorance-reduction-plan.md` by working through the items in Section 3 for which we do not yet have a **Resolution:**. For starters, read and understand that whole document.
+
+Today we start with ### 3.6 — Platform detection implementation
+
+> **Question:** What is the exact implementation of platform detection, particularly the ELF PT_INTERP parsing for musl vs. glibc on Linux?
+> 
+> ADR-007 specifies reading the first 2 KB of `/proc/self/exe` and parsing the ELF PT_INTERP segment. This is the same approach as the `detect-libc` npm package.
+> 
+> **Open questions:**
+> 
+> 1. Can we read `/proc/self/exe` from Java? (`/proc/self/exe` is a symlink to the JVM binary — on glibc Linux it will contain the glibc dynamic linker path, on Alpine/musl it will contain the musl path.)
+> 2. Should the detector be in a standalone utility class (reusable) or inline in the loader?
+> 3. Edge case: What about container environments where `/proc` is mounted but the JVM binary is from a different libc than the container's userspace? (This shouldn't happen in practice — the JVM must match the libc.)
+> 
+> **Spike needed:** Write a Java snippet that parses ELF PT_INTERP from `/proc/self/exe` on a glibc Linux system and on Alpine. Verify the dynamic linker paths match expectations (`/lib64/ld-linux-x86-64.so.2` vs. `/lib/ld-musl-x86_64.so.1`).
+> 
+> **Recommendation:** Standalone `PlatformDetector` class in `com.github.copilot.ffi` with methods `detectOs()`, `detectArch()`, `detectLinuxLibc()`, `detectClassifier()`. Pure Java, no dependencies. Unit-testable with mocked system properties and test ELF binaries.
+
+Platform detection needs to work on all supported tuples specified in the Platform dimensions section of `copilot-sdk/java/docs/adr/adr-007-native-bundling-strategy.md`.
+
+Now, we happening to be running now on. 
+
+
+| Platform label    | Rust triple                  | Constraint                                                       |
+| ----------------- | ---------------------------- | ---------------------------------------------------------------- |
+| `linux-x64`       | `x86_64-unknown-linux-gnu`   | [glibc](#references) ≥ 2.28 (Debian 10+, Ubuntu 20.04+, RHEL 8+) |
+
+Let's start spiking with this one. Create the spike in `copilot-sdk/1917-java-embed-rust-cli-runtime-remove-before-merge/spike-3-6-platform-detection-linux-x64`.
+
+It must be a standalone Java program that produces an executable jar I can invoke with `java -jar spike-3-6-platform-detection-linux-x64.jar` and when it runs it shows the detected arch. We need to detect enough information so that we can select the corresponding binary content contained in the classifier jar as shown in section 3.1 of `copilot-sdk/1917-java-embed-rust-cli-runtime-remove-before-merge/1917-embed-cli-runtime-ignorance-reduction-plan.md`. The spike program must use java.util.logging such that the output is printed by default.
+
+Note that `copilot-sdk/1917-java-embed-rust-cli-runtime-remove-before-merge/spike-3-6-platform-detection-darwin-arm64` already exists and is the spike for `darwin-arm64`. That was built when running on that hardware. 
+
+You are now running on linux-x64 hardware.
+
+Now, here is where all that ELF and `/proc/self/exe` stuff comes into play. Consider that for inclusion in your spike. 
+
+### 18:45 Response
+
+Good, I have a clear picture of the darwin-arm64 spike. Now I'll create the linux-x64 version. The code is identical (it's the same `PlatformDetector` logic), just packaged for running on linux-x64. I'll create the directory structure, copy the source, build it, and run it.
+
+Shell Create spike directory structure 1 line…
+mkdir -p /home/edburns/workareas/copilot-sdk/1917-java-embed-rust-cli-runtime-remove-before-merge/spike-3-6-platfo…
+
+Create PlatformDetector.java +242
+Create PlatformDetectionSpikeMain.java +55
+Create README.md +43
+
+Now let me build and run the spike:
+
+Shell Check Java availability 4 lines…
+export JAVA_HOME="/Library/Java/JavaVirtualMachines/microsoft-25.jdk/Contents/Home" && export PATH="${JAVA_HOME}/b…
+Shell Build the spike jar 2 lines…
+export JAVA_HOME="/Library/Java/JavaVirtualMachines/microsoft-25.jdk/Contents/Home" && export PATH="${JAVA_HOME}/b…
+Shell Run the spike jar 19 lines…
+export JAVA_HOME="/Library/Java/JavaVirtualMachines/microsoft-25.jdk/Contents/Home" && export PATH="${JAVA_HOME}/b…
+
+The spike is working perfectly. All key findings confirmed:
+
+Spike 3.6 results on linux-x64:
+
+┌───────────────┬─────────────────────────────┐
+│ Detection     │ Result                      │
+├───────────────┼─────────────────────────────┤
+│ os            │ linux                       │
+├───────────────┼─────────────────────────────┤
+│ arch          │ x64                         │
+├───────────────┼─────────────────────────────┤
+│ linuxLibc     │ GLIBC                       │
+├───────────────┼─────────────────────────────┤
+│ classifier    │ linux-x64                   │
+├───────────────┼─────────────────────────────┤
+│ ELF PT_INTERP │ /lib64/ld-linux-x86-64.so.2 │
+└───────────────┴─────────────────────────────┘
+
+Key answers to the open questions from section 3.6:
+
+1. Can we read `/proc/self/exe` from Java? — ✅ Yes. `Files.newInputStream(Path.of("/proc/self/exe"))` works fine. The JVM binary is an ELF64 executable linked against glibc, and `PT_INTERP` is at offset within the first 2 KB.
+2. Does the ELF parsing correctly identify glibc? — ✅ Yes. The dynamic linker path `/lib64/ld-linux-x86-64.so.2` is correctly extracted and matched as glibc.
+3. Classifier maps to correct resource path — `native/linux-x64/runtime.node` matches the expected layout from section 3.1.
+
+The spike is at:
+
+1917-java-embed-rust-cli-runtime-remove-before-merge/spike-3-6-platform-detection-linux-x64/
+
+Run it with:
+
+java -jar spike-3-6-platform-detection-linux-x64.jar

1917-java-embed-rust-cli-runtime-remove-before-merge/spike-3-6-platform-detection-darwin-arm64/README.md

@@ -12,16 +12,11 @@ It includes ELF `PT_INTERP` parsing from `/proc/self/exe` for Linux musl/glibc d
 ## Build
 
 ```sh
-mkdir -p out/classes
-javac -d out/classes $(find src/main/java -name '*.java')
-jar --create \
-  --file spike-3-6-platform-detection-darwin-arm64.jar \
-  --main-class com.github.copilot.spike.platform.PlatformDetectionSpikeMain \
-  -C out/classes .
+mvn clean package
 ```
 
 ## Run
 
 ```sh
-java -jar spike-3-6-platform-detection-darwin-arm64.jar
+java -jar target/spike-3-6-platform-detection-darwin-arm64.jar
 ```

1917-java-embed-rust-cli-runtime-remove-before-merge/spike-3-6-platform-detection-darwin-arm64/out/classes/com/github/copilot/spike/platform/PlatformDetectionSpikeMain.class

@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.github.copilot.spike</groupId>
+    <artifactId>spike-3-6-platform-detection-darwin-arm64</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+
+    <properties>
+        <maven.compiler.source>17</maven.compiler.source>
+        <maven.compiler.target>17</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <version>3.3.0</version>
+                <configuration>
+                    <archive>
+                        <manifest>
+                            <mainClass>com.github.copilot.spike.platform.PlatformDetectionSpikeMain</mainClass>
+                        </manifest>
+                    </archive>
+                    <finalName>spike-3-6-platform-detection-darwin-arm64</finalName>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>

1917-java-embed-rust-cli-runtime-remove-before-merge/spike-3-6-platform-detection-darwin-arm64/out/classes/com/github/copilot/spike/platform/PlatformDetector$LinuxLibc.class

@@ -0,0 +1,38 @@
+# Spike 3.6 — Platform detection (linux-x64)
+
+This spike is a standalone Java program that detects:
+
+- OS (`darwin`, `linux`, `win32`)
+- arch (`x64`, `arm64`)
+- Linux libc (`GLIBC`, `MUSL`, `UNKNOWN`) via ELF `PT_INTERP` parsing of `/proc/self/exe`
+- final runtime classifier (for `native/<classifier>/runtime.node`)
+
+On this platform (linux-x64 glibc), it exercises the ELF parsing path and verifies
+that `/proc/self/exe` resolves to the JVM binary, whose `PT_INTERP` segment contains
+the glibc dynamic linker path `/lib64/ld-linux-x86-64.so.2`.
+
+## Build
+
+```sh
+mvn clean package
+```
+
+## Run
+
+```sh
+java -jar target/spike-3-6-platform-detection-linux-x64.jar
+```
+
+## Expected output (glibc linux-x64)
+
+```
+INFO: Detected os=linux
+INFO: Detected arch=x64
+INFO: Detected linuxLibc=GLIBC
+INFO: Detected classifier=linux-x64
+INFO: ELF PT_INTERP=/lib64/ld-linux-x86-64.so.2
+INFO: PASS: PT_INTERP matches expected glibc x86_64 dynamic linker
+INFO: --- Spike result ---
+INFO: Classifier for native binary selection: linux-x64
+INFO: Resource path would be: native/linux-x64/runtime.node
+```

1917-java-embed-rust-cli-runtime-remove-before-merge/spike-3-6-platform-detection-darwin-arm64/out/classes/com/github/copilot/spike/platform/PlatformDetector.class

@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.github.copilot.spike</groupId>
+    <artifactId>spike-3-6-platform-detection-linux-x64</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+
+    <properties>
+        <maven.compiler.source>17</maven.compiler.source>
+        <maven.compiler.target>17</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <version>3.3.0</version>
+                <configuration>
+                    <archive>
+                        <manifest>
+                            <mainClass>com.github.copilot.spike.platform.PlatformDetectionSpikeMain</mainClass>
+                        </manifest>
+                    </archive>
+                    <finalName>spike-3-6-platform-detection-linux-x64</finalName>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>

1917-java-embed-rust-cli-runtime-remove-before-merge/spike-3-6-platform-detection-darwin-arm64/pom.xml

@@ -0,0 +1,55 @@
+package com.github.copilot.spike.platform;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Entry point for platform detection spike on linux-x64.
+ *
+ * Demonstrates that we can read /proc/self/exe, parse the ELF PT_INTERP
+ * segment, and determine whether the JVM is linked against glibc or musl.
+ */
+public final class PlatformDetectionSpikeMain {
+    private static final Logger LOGGER = Logger.getLogger(PlatformDetectionSpikeMain.class.getName());
+
+    private PlatformDetectionSpikeMain() {
+    }
+
+    public static void main(String[] args) {
+        String os = PlatformDetector.detectOs();
+        String arch = PlatformDetector.detectArch();
+        PlatformDetector.LinuxLibc libc = PlatformDetector.detectLinuxLibc();
+        String classifier = PlatformDetector.detectClassifier();
+
+        LOGGER.log(Level.INFO, "Detected os={0}", os);
+        LOGGER.log(Level.INFO, "Detected arch={0}", arch);
+        LOGGER.log(Level.INFO, "Detected linuxLibc={0}", libc);
+        LOGGER.log(Level.INFO, "Detected classifier={0}", classifier);
+
+        if ("linux".equals(os)) {
+            try {
+                String interp = PlatformDetector.readElfPtInterp(Path.of("/proc/self/exe"));
+                LOGGER.log(Level.INFO, "ELF PT_INTERP={0}", interp);
+
+                // Verify expectations for linux-x64 glibc
+                if (interp.contains("/ld-linux-x86-64.so.2")) {
+                    LOGGER.log(Level.INFO, "PASS: PT_INTERP matches expected glibc x86_64 dynamic linker");
+                } else if (interp.contains("/ld-musl-x86_64.so.1")) {
+                    LOGGER.log(Level.INFO, "PASS: PT_INTERP matches expected musl x86_64 dynamic linker");
+                } else {
+                    LOGGER.log(Level.WARNING, "UNEXPECTED: PT_INTERP does not match known linker paths: {0}", interp);
+                }
+            } catch (IOException ex) {
+                LOGGER.log(Level.WARNING, "Unable to parse PT_INTERP from /proc/self/exe: " + ex.getMessage(), ex);
+            }
+        } else {
+            LOGGER.log(Level.INFO, "Not on Linux — skipping ELF PT_INTERP parsing");
+        }
+
+        LOGGER.log(Level.INFO, "--- Spike result ---");
+        LOGGER.log(Level.INFO, "Classifier for native binary selection: {0}", classifier);
+        LOGGER.log(Level.INFO, "Resource path would be: native/{0}/runtime.node", classifier);
+    }
+}