sandbox-agent/server/packages/extracted-agent-schemas/build.rs

use std::fs;
use std::io::{self, Write};
use std::path::Path;

fn main() {
    let out_dir = std::env::var("OUT_DIR").unwrap();
    let schema_dir = Path::new("../../../resources/agent-schemas/artifacts/json-schema");

    let schemas = [
        ("opencode", "opencode.json"),
        ("claude", "claude.json"),
        ("codex", "codex.json"),
        ("amp", "amp.json"),
    ];

    for (name, file) in schemas {
        let schema_path = schema_dir.join(file);

        // Tell cargo to rerun if schema changes
        emit_stdout(&format!("cargo:rerun-if-changed={}", schema_path.display()));

        if !schema_path.exists() {
            emit_stdout(&format!(
                "cargo:warning=Schema file not found: {}",
                schema_path.display()
            ));
            // Write empty module
            let out_path = Path::new(&out_dir).join(format!("{}.rs", name));
            fs::write(&out_path, "// Schema not found\n").unwrap();
            continue;
        }

        let schema_content = fs::read_to_string(&schema_path)
            .unwrap_or_else(|e| panic!("Failed to read {}: {}", schema_path.display(), e));

        let schema: schemars::schema::RootSchema = serde_json::from_str(&schema_content)
            .unwrap_or_else(|e| panic!("Failed to parse {}: {}", schema_path.display(), e));

        let mut type_space = typify::TypeSpace::default();

        type_space
            .add_root_schema(schema)
            .unwrap_or_else(|e| panic!("Failed to process {}: {}", schema_path.display(), e));

        let contents = type_space.to_stream();

        // Format the generated code
        let formatted = prettyplease::unparse(
            &syn::parse2(contents.clone())
                .unwrap_or_else(|e| panic!("Failed to parse generated code for {}: {}", name, e)),
        );

        let out_path = Path::new(&out_dir).join(format!("{}.rs", name));
        fs::write(&out_path, formatted)
            .unwrap_or_else(|e| panic!("Failed to write {}: {}", out_path.display(), e));

        // emit_stdout(&format!(
        //     "cargo:warning=Generated {} types from {}",
        //     name, file
        // ));
    }
}

fn emit_stdout(message: &str) {
    let mut out = io::stdout();
    let _ = out.write_all(message.as_bytes());
    let _ = out.write_all(b"\n");
    let _ = out.flush();
}