|
|
| """
|
| build_quantum.py — Generate all BOB quantum civilization binding files via Nemotron (free)
|
| and push directly to sov-kernel-monster.
|
| """
|
| import requests, base64, os, json, re
|
| from concurrent.futures import ThreadPoolExecutor, as_completed
|
|
|
| PAT = os.environ.get("PAT_TOKEN", "GH_PAT_REDACTED")
|
| OR_KEY = os.environ.get("OPENROUTER_API_KEY", "OPENROUTER_KEY_REDACTED")
|
| ORG = "SNAPKITTYWEST"
|
| REPO = "sov-kernel-monster"
|
| HDR = {"Authorization": f"token {PAT}"}
|
| MODEL = "nvidia/nemotron-3-ultra-550b-a55b:free"
|
|
|
| def ask(prompt):
|
| for model in [MODEL, "qwen/qwen-2.5-coder-32b-instruct"]:
|
| try:
|
| r = requests.post("https://openrouter.ai/api/v1/chat/completions",
|
| headers={"Authorization": f"Bearer {OR_KEY}", "HTTP-Referer": "https://snapkittywest.io"},
|
| json={"model": model, "messages": [{"role":"user","content":prompt}],
|
| "temperature": 0.1, "max_tokens": 8192}, timeout=300)
|
| data = r.json()
|
| if "error" not in data:
|
| return data["choices"][0]["message"]["content"]
|
| except: pass
|
| return ""
|
|
|
| def push(path, content, msg="feat(quantum): add binding file"):
|
| if isinstance(content, str): content = content.encode("utf-8")
|
| r = requests.get(f"https://api.github.com/repos/{ORG}/{REPO}/contents/{path}", headers=HDR)
|
| sha = r.json().get("sha","") if r.status_code == 200 else ""
|
| body = {"message": msg, "content": base64.b64encode(content).decode()}
|
| if sha: body["sha"] = sha
|
| r = requests.put(f"https://api.github.com/repos/{ORG}/{REPO}/contents/{path}", headers=HDR, json=body)
|
| return r.status_code
|
|
|
| def clean(result):
|
| m = re.search(r'```[\w]*\n(.*?)```', result, re.DOTALL)
|
| if m: return m.group(1).strip()
|
| m2 = re.search(r'^(import |from |module |defmodule |package |use |#include|<svg|\[package\]|cmake_minimum)', result, re.MULTILINE)
|
| if m2: return result[m2.start():].strip()
|
| return result.strip()
|
|
|
| TASKS = [
|
| ("julia/bob_quantum.jl", """Write complete Julia bindings for BOB Quantum Civilization Engine (600+ lines).
|
| File: julia/bob_quantum.jl
|
| Zero-copy C ABI interop via ccall to libbob_quantum.so.
|
| module BobQuantum. Structs: BobRNG, BobLattice, BobState, BobHamiltonian (all with Ptr{Cvoid}).
|
| All ccall wrappers loading from const LIBBOB path.
|
| Base.finalize for RAII cleanup.
|
| Functions: RNG(seed), Lattice(nx,ny,nz,coupling,seed;periodic), State(num_qubits), Hamiltonian(num_qubits),
|
| evolve!(lat,dt) -> (energy,entropy), energy(lat), entropy(lat),
|
| measure(state,rng;collapse) -> Int64, measure_shots(state,num_shots,rng) -> (counts,probs),
|
| normalize!(state), add_term!(H,matrix,coeff,qubits), expectation(H,state),
|
| evolve_exact!(state,H,dt), evolve_trotter!(state,H,dt,order=2), evolve_krylov!(state,H,dt,k=20).
|
| export all. Output ONLY Julia code."""),
|
|
|
| ("elixir/lib/bob_quantum.ex", """Write complete Elixir OTP bridge for BOB Quantum Civilization Engine (500+ lines).
|
| File: elixir/lib/bob_quantum.ex
|
| Use Rustler NIF declarations for all C ABI functions.
|
| GenServer wrappers: BobQuantum.RNG, BobQuantum.Lattice, BobQuantum.State — each with start_link, init, handle_call.
|
| RNG: uniform/1, normal/2, integer/3.
|
| Lattice: evolve/2 -> {energy, entropy}, energy/1, entropy/1.
|
| State: measure/2, amplitudes/1, normalize/1.
|
| Module BobQuantum with @spec declarations and defdelegate.
|
| Output ONLY Elixir code."""),
|
|
|
| ("nats/bob_subjects.go", """Write complete NATS message bus schema for BOB Quantum Civilization Engine (400+ lines).
|
| File: nats/bob_subjects.go
|
| Package bob. All subject constants: bob.lattice.create/evolve/energy/entropy, bob.state.create/measure/measure_shots, bob.hamiltonian.create/add_term/expectation, bob.evolve.exact/trotter/krylov, bob.rng.create/uniform/normal, bob.circuit.qft/grover/qpe, bob.proof.check/compile, bob.plasma.enforce/verify, bob.swarm.task.claim/complete, bob.bifrost.log/verify.
|
| All JSON payload structs for request/response pairs.
|
| Client struct with NewClient(urls) and Request(subject, req, resp, timeout) methods.
|
| Output ONLY Go code."""),
|
|
|
| ("rust/bob-quantum-sys/src/lib.rs", """Write complete Rust FFI crate for BOB Quantum Civilization Engine (800+ lines).
|
| File: rust/bob-quantum-sys/src/lib.rs
|
| #![allow non_upper_case_globals, non_camel_case_types, non_snake_case]
|
| Opaque types: bob_rng_t, bob_lattice_t, bob_state_t, bob_hamiltonian_t as *mut c_void.
|
| Error constants BOB_SUCCESS through BOB_ERROR_INVALID_GATE.
|
| #[link(name="bob_quantum")] extern "C" block with ALL function signatures.
|
| Safe wrappers: RNG, Lattice, State, Hamiltonian structs with Drop impls.
|
| BobError enum with From<c_int> and Display.
|
| Complex64 = num_complex::Complex<f64>.
|
| All methods return Result<T, BobError>.
|
| Output ONLY Rust code."""),
|
|
|
| ("rust/bob-quantum-sys/Cargo.toml", """Write Cargo.toml for bob-quantum-sys crate.
|
| [package] name="bob-quantum-sys" version="0.1.0" edition="2021"
|
| [lib] link-lib="bob_quantum"
|
| [dependencies] num-complex="0.4" libc="0.2"
|
| [build-dependencies] cc="1.0"
|
| Output ONLY TOML."""),
|
|
|
| ("smalltalk/BobQuantum.st", """Write complete Smalltalk bindings for BOB Quantum Civilization Engine (800+ lines).
|
| Pharo-compatible. Classes: BobQuantumLibrary (singleton, loads libbob_quantum.so via FFI),
|
| BobRNG, BobLattice, BobState, BobHamiltonian, BobQuantumWorld.
|
| Use Pharo ExternalFunction and ExternalAddress for C ABI calls.
|
| BobQuantumWorld: createLattice:ny:nz:coupling:, runSimulation:steps:dt:, visualize.
|
| Output ONLY Smalltalk code."""),
|
|
|
| ("r/bob_quantum.R", """Write complete R bindings for BOB Quantum Civilization Engine (600+ lines).
|
| Use .Call() to C ABI. Functions: bob.rng.create(seed), bob.rng.uniform(rng), bob.rng.normal(rng,mean,sd),
|
| bob.lattice.create(nx,ny,nz,coupling,seed,periodic), bob.lattice.evolve(lattice,dt),
|
| bob.lattice.energy(lattice), bob.lattice.entropy(lattice),
|
| bob.state.create(num_qubits), bob.state.measure(state,rng,collapse),
|
| bob.state.measure_shots(state,num_shots,rng), bob.hamiltonian.create(num_qubits),
|
| bob.hamiltonian.add_term(h,matrix,coeff,qubits), bob.hamiltonian.expectation(h,state).
|
| ggplot2 visualization: plot_entropy_evolution(), plot_state_probabilities(), plot_lattice_energy().
|
| Output ONLY R code."""),
|
|
|
| ("include/bob_quantum.h", """Write complete C header for BOB Quantum Civilization Engine.
|
| File: include/bob_quantum.h
|
| #pragma once, #include <stdint.h>, #include <stdbool.h>
|
| Opaque handle typedefs. Error code enum BOB_ERROR_*.
|
| ALL function declarations matching Fortran bind(C) exports:
|
| bob_rng_create/destroy/seed/uniform/normal/integer,
|
| bob_lattice_create/destroy/evolve/get_energy/entanglement_entropy,
|
| bob_state_create/destroy/normalize/get_amplitude/set_amplitude/measure/measure_qubit/measure_shots,
|
| bob_hamiltonian_create/destroy/add_term/expectation,
|
| bob_evolve_exact/trotter/krylov, bob_error_string/get_last_error.
|
| extern "C" guards. Output ONLY C header."""),
|
|
|
| ("CMakeLists.txt", """Write complete CMakeLists.txt for BOB Quantum Civilization Engine.
|
| cmake_minimum_required(VERSION 3.20). project(sov-kernel-monster Fortran C).
|
| Find gfortran. Build libbob_quantum.so from all src/*.f90 with -std=f2018 -O3 -fPIC -march=native.
|
| add_library(bob_quantum SHARED src/*.f90).
|
| set_target_properties with VERSION 1.0.0.
|
| install targets. enable_testing(). add_subdirectory(tests) if exists.
|
| Output ONLY CMake."""),
|
|
|
| ("fpm.toml", """Write fpm.toml for BOB Quantum Civilization Engine.
|
| name = "sov-kernel-monster"
|
| version = "1.0.0"
|
| license = "Apache-2.0"
|
| [build] auto-executables=false auto-tests=true
|
| [fortran] implicit-typing=false implicit-external=false source-form="free"
|
| [library] source-dir="src"
|
| Extra flags: -O3 -march=native -fPIC -std=f2018
|
| Output ONLY TOML."""),
|
|
|
| ("build.py", """Write build.py — master build orchestrator for BOB Quantum Civilization Engine.
|
| Builds: 1) libbob_quantum.so via cmake, 2) Rust crate via cargo, 3) Fortran tests via fpm,
|
| 4) Julia package test, 5) Elixir mix compile, 6) R CMD build, 7) Lean4 lake build, 8) Go NATS build.
|
| argparse: --release, --test, --lang LANG (build single language), --all.
|
| Uses subprocess, pathlib, shutil. Colored output via print with ANSI codes.
|
| Output ONLY Python code."""),
|
|
|
| (".github/workflows/build.yml", """Write .github/workflows/build.yml for BOB Quantum Civilization Engine.
|
| name: Build All Languages. on: push, pull_request.
|
| jobs: build on ubuntu-latest.
|
| Steps: checkout, setup gfortran (sudo apt-get install gfortran),
|
| setup rust (rustup), setup julia (julia-actions/setup-julia@v1),
|
| setup elixir (erlef/setup-beam@v1), setup R (r-lib/actions/setup-r@v2),
|
| install lake via elan, setup go, cmake build, cargo build, fpm test,
|
| julia test, mix test, R CMD check, lake build.
|
| Cache: cargo, julia depot, R packages.
|
| Output ONLY YAML."""),
|
|
|
| ("docs/quantum_world.svg", """Create an interactive animated SVG for BOB Quantum Civilization Engine.
|
| viewBox="0 0 1200 800". Self-contained. Use SMIL animations.
|
| Show:
|
| 1. Central Fortran quantum kernel (gold hexagon, pulsing glow animation)
|
| 2. 7 language bindings in orbit: Julia (purple), Elixir (violet), Rust (orange), Lean4 (green), Smalltalk (blue), R (teal), NATS/Go (cyan) — each as labeled circle orbiting the center
|
| 3. Animated data flow arrows between them (animateMotion along orbit paths)
|
| 4. 4x4 quantum lattice grid in bottom-left with vortex nodes (circles changing color based on quantum state)
|
| 5. Born rule probability bars animating in bottom-right
|
| 6. PLASMA GATE hexagon barrier in top-right with particle flow animation
|
| 7. Title: BOB Quantum Civilization Engine
|
| Colors: quantum blue #0A84FF, gold #FFD60A, green #30D158, red #FF453A, background #000000
|
| Output ONLY SVG starting with <svg."""),
|
| ]
|
|
|
| def process(task):
|
| path, prompt = task
|
| print(f" -> {path}")
|
| result = ask(prompt)
|
| if not result or len(result) < 50:
|
| print(f" ✗ {path}: empty response")
|
| return path, False
|
| code = clean(result)
|
| status = push(path, code, f"feat(quantum): {path} — BOB civilization engine")
|
| ok = status in (200, 201)
|
| print(f" {'OK' if ok else 'FAIL'} {path}: HTTP {status} ({len(code)} chars)")
|
| return path, ok
|
|
|
| print(f"BOB Quantum Civilization Engine — {len(TASKS)} files")
|
| print(f"Target: https://github.com/{ORG}/{REPO}")
|
| print()
|
|
|
| results = {}
|
| with ThreadPoolExecutor(max_workers=4) as pool:
|
| futures = {pool.submit(process, t): t[0] for t in TASKS}
|
| for f in as_completed(futures):
|
| path, ok = f.result()
|
| results[path] = ok
|
|
|
| pushed = sum(1 for v in results.values() if v)
|
| print(f"\nDone: {pushed}/{len(TASKS)} files pushed to {ORG}/{REPO}")
|
|
|
