malvin 0.2.7

Non-interactive research and coding agent
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use std::env;
use std::path::{Path, PathBuf};
use std::process::Command;

struct PiPatchSpec {
    patch_rel: &'static str,
    marker_rel: &'static str,
    marker: &'static str,
    cfg_name: &'static str,
    label: &'static str,
}

pub fn apply_pi_openrouter_cost_patch(manifest_dir: &Path) {
    const SPECS: &[PiPatchSpec] = &[PiPatchSpec {
        patch_rel: "admin/patches/pi_agent_rust-0.1.23-openrouter-cost.patch",
        marker_rel: "src/providers/openai.rs",
        marker: "take_openrouter_generation_ids",
        cfg_name: "malvin_pi_openrouter_patch",
        label: "OpenRouter billed cost",
    }];
    for spec in SPECS {
        apply_pi_patch(manifest_dir, spec);
    }
}

fn apply_pi_patch(manifest_dir: &Path, spec: &PiPatchSpec) {
    let patch = manifest_dir.join(spec.patch_rel);
    println!("cargo:rerun-if-changed={}", patch.display());

    if env::var_os("DOCS_RS").is_some() || env::var_os("MALVIN_SKIP_PI_PATCH").is_some() {
        return;
    }

    if !patch.is_file() {
        println!(
            "cargo:warning=pi {} patch file missing: {}",
            spec.label,
            patch.display()
        );
        return;
    }

    let Some(pi_src) = find_pi_agent_rust_0_1_23_src() else {
        println!(
            "cargo:warning=pi_agent_rust-0.1.23 source not found; {} patch skipped",
            spec.label
        );
        return;
    };

    let marker_path = pi_src.join(spec.marker_rel);
    if file_contains_marker(&marker_path, spec.marker) {
        println!("cargo:rustc-cfg={}", spec.cfg_name);
        return;
    }

    let status = Command::new("patch")
        .arg("-p1")
        .arg("-N")
        .arg("-i")
        .arg(&patch)
        .current_dir(&pi_src)
        .status();

    match status {
        Ok(s) if s.success() => {
            println!("cargo:rustc-cfg={}", spec.cfg_name);
        }
        Ok(s) => {
            if file_contains_marker(&marker_path, spec.marker) {
                println!("cargo:rustc-cfg={}", spec.cfg_name);
            } else {
                println!(
                    "cargo:warning=pi {} patch exited with status {s}",
                    spec.label
                );
            }
        }
        Err(e) => {
            println!(
                "cargo:warning=failed to run patch for pi_agent_rust ({}): {e}",
                spec.label
            );
        }
    }
}

fn find_pi_agent_rust_0_1_23_src() -> Option<PathBuf> {
    let home = env::var_os("HOME")?;
    let registry = PathBuf::from(home).join(".cargo/registry/src");
    let entries = std::fs::read_dir(&registry).ok()?;
    for entry in entries.flatten() {
        let candidate = entry.path().join("pi_agent_rust-0.1.23");
        if candidate.join("Cargo.toml").is_file() {
            return Some(candidate);
        }
    }
    None
}

fn file_contains_marker(path: &Path, marker: &str) -> bool {
    std::fs::read_to_string(path)
        .ok()
        .is_some_and(|body| body.contains(marker))
}