chore(ffi): modernize zig abi layer and project hygiene

Author: hyperpolymath

.gitignore

@@ -13,6 +13,9 @@ Thumbs.db
 # Build
 /target/
 /_build/
+/compiler/_build/
+/ffi/zig/.zig-cache/
+/ffi/zig/zig-out/
 /build/
 /dist/
 /out/
@@ -25,6 +28,7 @@ Thumbs.db
 
 # Rust
 # Cargo.lock  # Keep for binaries
+/compiler/tangle-lsp/Cargo.lock
 
 # Elixir
 /cover/

ABI-FFI-README.md

@@ -1,6 +1,4 @@
-{{~ Aditionally delete this line and fill out the template below ~}}
-
-# {{PROJECT}} ABI/FFI Documentation
+# TANGLE ABI/FFI Documentation
 
 ## Overview
 
@@ -26,7 +24,7 @@ This library follows the **Hyperpolymath RSR Standard** for ABI and FFI design:
                   ▼
 ┌─────────────────────────────────────────────┐
 │  C Headers (auto-generated)                 │
-│  generated/abi/{{project}}.h                │
+│  generated/abi/tangle.h                │
 └─────────────────┬───────────────────────────┘
                   │
                   │ imported by
@@ -39,7 +37,7 @@ This library follows the **Hyperpolymath RSR Standard** for ABI and FFI design:
 │  - Memory-safe by default                   │
 └─────────────────┬───────────────────────────┘
                   │
-                  │ compiled to lib{{project}}.so/.a
+                  │ compiled to libtangle.so/.a
                   ▼
 ┌─────────────────────────────────────────────┐
 │  Any Language via C ABI                     │
@@ -50,7 +48,7 @@ This library follows the **Hyperpolymath RSR Standard** for ABI and FFI design:
 ## Directory Structure
 
 ```
-{{project}}/
+tangle/
 ├── src/
 │   ├── abi/                    # ABI definitions (Idris2)
 │   │   ├── Types.idr           # Core type definitions with proofs
@@ -67,11 +65,11 @@ This library follows the **Hyperpolymath RSR Standard** for ABI and FFI design:
 │       ├── test/
 │       │   └── integration_test.zig
 │       └── include/
-│           └── {{project}}.h   # C header (optional, can be generated)
+│           └── tangle.h   # C header (optional, can be generated)
 │
 ├── generated/                  # Auto-generated files
 │   └── abi/
-│       └── {{project}}.h       # Generated from Idris2 ABI
+│       └── tangle.h       # Generated from Idris2 ABI
 │
 └── bindings/                   # Language-specific wrappers (optional)
     ├── rust/
@@ -199,7 +197,7 @@ zig build test                    # Run tests
 
 ```bash
 cd src/abi
-idris2 --cg c-header Types.idr -o ../../generated/abi/{{project}}.h
+idris2 --cg c-header Types.idr -o ../../generated/abi/tangle.h
 ```
 
 ### Cross-Compile
@@ -222,32 +220,32 @@ zig build -Dtarget=x86_64-windows
 ### From C
 
 ```c
-#include "{{project}}.h"
+#include "tangle.h"
 
 int main() {
-    void* handle = {{project}}_init();
+    void* handle = tangle_init();
     if (!handle) return 1;
 
-    int result = {{project}}_process(handle, 42);
+    int result = tangle_process(handle, 42);
     if (result != 0) {
-        const char* err = {{project}}_last_error();
+        const char* err = tangle_last_error();
         fprintf(stderr, "Error: %s\n", err);
     }
 
-    {{project}}_free(handle);
+    tangle_free(handle);
     return 0;
 }
 ```
 
 Compile with:
 ```bash
-gcc -o example example.c -l{{project}} -L./zig-out/lib
+gcc -o example example.c -ltangle -L./zig-out/lib
 ```
 
 ### From Idris2
 
 ```idris
-import {{PROJECT}}.ABI.Foreign
+import TANGLE.ABI.Foreign
 
 main : IO ()
 main = do
@@ -264,44 +262,44 @@ main = do
 ### From Rust
 
 ```rust
-#[link(name = "{{project}}")]
+#[link(name = "tangle")]
 extern "C" {
-    fn {{project}}_init() -> *mut std::ffi::c_void;
-    fn {{project}}_free(handle: *mut std::ffi::c_void);
-    fn {{project}}_process(handle: *mut std::ffi::c_void, input: u32) -> i32;
+    fn tangle_init() -> *mut std::ffi::c_void;
+    fn tangle_free(handle: *mut std::ffi::c_void);
+    fn tangle_process(handle: *mut std::ffi::c_void, input: u32) -> i32;
 }
 
 fn main() {
     unsafe {
-        let handle = {{project}}_init();
+        let handle = tangle_init();
         assert!(!handle.is_null());
 
-        let result = {{project}}_process(handle, 42);
+        let result = tangle_process(handle, 42);
         assert_eq!(result, 0);
 
-        {{project}}_free(handle);
+        tangle_free(handle);
     }
 }
 ```
 
 ### From Julia
 
 ```julia
-const lib{{project}} = "lib{{project}}"
+const libtangle = "libtangle"
 
 function init()
-    handle = ccall((:{{project}}_init, lib{{project}}), Ptr{Cvoid}, ())
+    handle = ccall((:tangle_init, libtangle), Ptr{Cvoid}, ())
     handle == C_NULL && error("Failed to initialize")
     handle
 end
 
 function process(handle, input)
-    result = ccall((:{{project}}_process, lib{{project}}), Cint, (Ptr{Cvoid}, UInt32), handle, input)
+    result = ccall((:tangle_process, libtangle), Cint, (Ptr{Cvoid}, UInt32), handle, input)
     result
 end
 
 function cleanup(handle)
-    ccall((:{{project}}_free, lib{{project}}), Cvoid, (Ptr{Cvoid},), handle)
+    ccall((:tangle_free, libtangle), Cvoid, (Ptr{Cvoid},), handle)
 end
 
 # Usage
@@ -355,7 +353,7 @@ When modifying the ABI/FFI:
 
 2. **Generate C header**
    ```bash
-   idris2 --cg c-header src/abi/Types.idr -o generated/abi/{{project}}.h
+   idris2 --cg c-header src/abi/Types.idr -o generated/abi/tangle.h
    ```
 
 3. **Update FFI implementation** (`ffi/zig/src/main.zig`)

ffi/zig/build.zig

@@ -1,4 +1,4 @@
-// {{PROJECT}} FFI Build Configuration
+// TANGLE FFI Build Configuration
 // SPDX-License-Identifier: PMPL-1.0-or-later
 
 const std = @import("std");
@@ -7,88 +7,60 @@ pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
-    // Shared library (.so, .dylib, .dll)
-    const lib = b.addSharedLibrary(.{
-        .name = "{{project}}",
+    const root_module = b.createModule(.{
         .root_source_file = b.path("src/main.zig"),
         .target = target,
         .optimize = optimize,
+        .link_libc = true,
     });
 
-    // Set version
-    lib.version = .{ .major = 0, .minor = 1, .patch = 0 };
-
-    // Static library (.a)
-    const lib_static = b.addStaticLibrary(.{
-        .name = "{{project}}",
-        .root_source_file = b.path("src/main.zig"),
-        .target = target,
-        .optimize = optimize,
+    const lib = b.addLibrary(.{
+        .name = "tangle",
+        .root_module = root_module,
+        .linkage = .dynamic,
+        .version = .{ .major = 0, .minor = 1, .patch = 0 },
     });
-
-    // Install artifacts
     b.installArtifact(lib);
-    b.installArtifact(lib_static);
 
-    // Generate header file for C compatibility
-    const header = b.addInstallHeader(
-        b.path("include/{{project}}.h"),
-        "{{project}}.h",
-    );
-    b.getInstallStep().dependOn(&header.step);
+    const lib_static = b.addLibrary(.{
+        .name = "tangle",
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("src/main.zig"),
+            .target = target,
+            .optimize = optimize,
+            .link_libc = true,
+        }),
+        .linkage = .static,
+    });
+    b.installArtifact(lib_static);
 
-    // Unit tests
-    const lib_tests = b.addTest(.{
+    const unit_mod = b.createModule(.{
         .root_source_file = b.path("src/main.zig"),
         .target = target,
         .optimize = optimize,
+        .link_libc = true,
     });
+    const unit_tests = b.addTest(.{ .root_module = unit_mod });
+    const run_unit_tests = b.addRunArtifact(unit_tests);
 
-    const run_lib_tests = b.addRunArtifact(lib_tests);
-
-    const test_step = b.step("test", "Run library tests");
-    test_step.dependOn(&run_lib_tests.step);
-
-    // Integration tests
-    const integration_tests = b.addTest(.{
+    const integration_mod = b.createModule(.{
         .root_source_file = b.path("test/integration_test.zig"),
         .target = target,
         .optimize = optimize,
+        .link_libc = true,
     });
+    integration_mod.addImport("tangle", root_module);
 
-    integration_tests.linkLibrary(lib);
-
+    const integration_tests = b.addTest(.{ .root_module = integration_mod });
     const run_integration_tests = b.addRunArtifact(integration_tests);
 
-    const integration_test_step = b.step("test-integration", "Run integration tests");
-    integration_test_step.dependOn(&run_integration_tests.step);
-
-    // Documentation
-    const docs = b.addTest(.{
-        .root_source_file = b.path("src/main.zig"),
-        .target = target,
-        .optimize = .Debug,
-    });
-
-    const docs_step = b.step("docs", "Generate documentation");
-    docs_step.dependOn(&b.addInstallDirectory(.{
-        .source_dir = docs.getEmittedDocs(),
-        .install_dir = .prefix,
-        .install_subdir = "docs",
-    }).step);
-
-    // Benchmark (if needed)
-    const bench = b.addExecutable(.{
-        .name = "{{project}}-bench",
-        .root_source_file = b.path("bench/bench.zig"),
-        .target = target,
-        .optimize = .ReleaseFast,
-    });
-
-    bench.linkLibrary(lib);
+    const unit_step = b.step("test", "Run Zig unit tests");
+    unit_step.dependOn(&run_unit_tests.step);
 
-    const run_bench = b.addRunArtifact(bench);
+    const integration_step = b.step("test-integration", "Run Zig integration tests");
+    integration_step.dependOn(&run_integration_tests.step);
 
-    const bench_step = b.step("bench", "Run benchmarks");
-    bench_step.dependOn(&run_bench.step);
+    const all_step = b.step("test-all", "Run all Zig tests");
+    all_step.dependOn(&run_unit_tests.step);
+    all_step.dependOn(&run_integration_tests.step);
 }