hematite-cli 0.8.2

Senior SysAdmin, Network Admin, Data Analyst, and Software Engineer living in your terminal. A high-precision local AI agent harness for LM Studio, Ollama, and other local OpenAI-compatible runtimes that runs 100% on your own silicon. Reads repos, edits files, runs builds, inspects full network state and workstation telemetry, and runs real Python/JS for data analysis.
Documentation 
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

use hematite::tools::scientific::scientific_compute;
use serde_json::json;
use std::fs;

#[tokio::test]
async fn test_scientific_symbolic_solve() {
    let args = json!({
        "mode": "symbolic",
        "expr": "x**2 - 4 = 0",
        "target": "solve"
    });

    let result = scientific_compute(&args).await;
    if let Ok(res) = result {
        assert!(res.contains("RESULT") || res.contains("ERROR"));
    }
}

#[tokio::test]
async fn test_scientific_units() {
    let args = json!({
        "mode": "units",
        "calculation": "10m / 2s"
    });
    let result = scientific_compute(&args).await;
    if let Ok(res) = result {
        assert!(res.contains("RESULT") || res.contains("ERROR"));
    }
}

#[tokio::test]
async fn test_scientific_complexity() {
    let args = json!({
        "mode": "complexity",
        "snippet": "for i in range(n): pass"
    });
    let result = scientific_compute(&args).await;
    if let Ok(res) = result {
        assert!(res.contains("RESULT") || res.contains("ERROR"));
    }
}

#[tokio::test]
async fn test_scientific_ledger_append_read() {
    let test_content = "Integration by parts formula: Integral u dv = uv - Integral v du";

    let append_args = json!({
        "mode": "ledger",
        "action": "append",
        "content": test_content
    });
    let append_res = scientific_compute(&append_args).await;
    assert!(append_res.is_ok());
    assert!(append_res.unwrap().contains("successfully persisted"));

    let read_args = json!({
        "mode": "ledger",
        "action": "read"
    });
    let read_res = scientific_compute(&read_args).await;
    assert!(read_res.is_ok());
    assert!(read_res.unwrap().contains(test_content));

    let ledger_path = ".hematite/docs/scientific_ledger.md";
    if std::path::Path::new(ledger_path).exists() {
        fs::remove_file(ledger_path).ok();
    }
}

#[tokio::test]
async fn test_scientific_symbolic_latex() {
    let args = json!({
        "mode": "symbolic",
        "expr": "x**2 + 2*x + 1",
        "target": "simplify",
        "latex": true
    });

    let result = scientific_compute(&args).await;
    if let Ok(res) = result {
        assert!(res.contains("RESULT") || res.contains("ERROR"));
        if res.contains("RESULT") {
            assert!(res.contains("LATEX"));
        }
    }
}