feat: publish Dever core with project scaffolding and versioned AI skills

test/dever-cli-tests/support/native_elf.rs

@@ -0,0 +1,90 @@
+//! Small ELF metadata fixtures; execution acceptance uses real author inputs.
+pub fn compiler(needed: &[&str]) -> Vec<u8> {
+    elf(None, needed, Some("$ORIGIN/lib"))
+}
+
+pub fn library(name: &str, needed: &[&str]) -> Vec<u8> {
+    elf(Some(name), needed, None)
+}
+
+pub fn static_executable() -> Vec<u8> {
+    let mut bytes = elf(None, &[], None);
+    // Change the synthetic PT_INTERP entry to PT_NULL. Execution tests use the
+    // real static author input; this fixture tests only ELF admission rules.
+    bytes[64 + 2 * 56..68 + 2 * 56].copy_from_slice(&0u32.to_le_bytes());
+    bytes
+}
+
+pub fn elf(soname: Option<&str>, needed: &[&str], rpath: Option<&str>) -> Vec<u8> {
+    let mut strings = vec![0u8];
+    let mut string = |text: &str| {
+        let offset = strings.len() as u64;
+        strings.extend_from_slice(text.as_bytes());
+        strings.push(0);
+        offset
+    };
+    let mut dynamic = needed
+        .iter()
+        .map(|name| (1u64, string(name)))
+        .collect::<Vec<_>>();
+    if let Some(name) = soname {
+        dynamic.push((14, string(name)));
+    }
+    if let Some(path) = rpath {
+        dynamic.push((15, string(path)));
+    }
+    let interpreter = if cfg!(target_arch = "aarch64") {
+        b"/lib/ld-linux-aarch64.so.1\0".as_slice()
+    } else {
+        b"/lib64/ld-linux-x86-64.so.2\0".as_slice()
+    };
+    let header_count: u16 = if soname.is_some() { 2 } else { 3 };
+    let string_offset = 64 + usize::from(header_count) * 56;
+    let interpreter_offset = string_offset + strings.len();
+    let dynamic_offset = (interpreter_offset + interpreter.len() + 7) & !7;
+    dynamic.extend([
+        (5, string_offset as u64),
+        (10, strings.len() as u64),
+        (0, 0),
+    ]);
+    let length = dynamic_offset + dynamic.len() * 16;
+    let mut bytes = vec![0; length];
+    bytes[..7].copy_from_slice(b"\x7fELF\x02\x01\x01");
+    bytes[16..18].copy_from_slice(&3u16.to_le_bytes());
+    let machine = if cfg!(target_arch = "aarch64") {
+        183u16
+    } else {
+        62u16
+    };
+    bytes[18..20].copy_from_slice(&machine.to_le_bytes());
+    bytes[20..24].copy_from_slice(&1u32.to_le_bytes());
+    bytes[32..40].copy_from_slice(&64u64.to_le_bytes());
+    bytes[52..54].copy_from_slice(&64u16.to_le_bytes());
+    bytes[54..56].copy_from_slice(&56u16.to_le_bytes());
+    bytes[56..58].copy_from_slice(&header_count.to_le_bytes());
+    let mut segment = |index: usize, kind: u32, offset: usize, size: usize| {
+        let start = 64 + index * 56;
+        bytes[start..start + 4].copy_from_slice(&kind.to_le_bytes());
+        bytes[start + 4..start + 8].copy_from_slice(&4u32.to_le_bytes());
+        for at in [8, 16, 24] {
+            bytes[start + at..start + at + 8].copy_from_slice(&(offset as u64).to_le_bytes());
+        }
+        for at in [32, 40] {
+            bytes[start + at..start + at + 8].copy_from_slice(&(size as u64).to_le_bytes());
+        }
+        bytes[start + 48..start + 56].copy_from_slice(&1u64.to_le_bytes());
+    };
+    segment(0, 1, 0, length);
+    segment(1, 2, dynamic_offset, dynamic.len() * 16);
+    if soname.is_none() {
+        segment(2, 3, interpreter_offset, interpreter.len());
+    }
+    bytes[string_offset..interpreter_offset].copy_from_slice(&strings);
+    bytes[interpreter_offset..interpreter_offset + interpreter.len()].copy_from_slice(interpreter);
+    for (index, (tag, value)) in dynamic.into_iter().enumerate() {
+        let start = dynamic_offset + index * 16;
+        bytes[start..start + 8].copy_from_slice(&tag.to_le_bytes());
+        bytes[start + 8..start + 16].copy_from_slice(&value.to_le_bytes());
+    }
+    bytes
+}