skillnet 0.4.0

Reconcile and manage local AI skill mirrors; calibration data for the multi-phase-plan skill.
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

use std::time::{SystemTime, UNIX_EPOCH};

use anyhow::{bail, Context};

use super::{catalog::ThresholdStore, db::DbParam as P, Db};

pub enum Decision {
    Accept,
    Reject,
}

impl Decision {
    fn as_stored(&self) -> &'static str {
        match self {
            Self::Accept => "accepted",
            Self::Reject => "rejected",
        }
    }
}

pub fn run(
    db: &mut Db,
    proposal_id: i64,
    decision: Decision,
    rationale: String,
) -> anyhow::Result<()> {
    let existing = db
        .query_optional(
            "SELECT decision, trigger_name, proposed_threshold
             FROM calibration_proposals WHERE id = $1",
            &[P::from(proposal_id)],
            |row| Ok((row.get_string(0)?, row.get_string(1)?, row.get_f64(2)?)),
        )
        .context("failed to read proposal decision")?;

    let Some(existing) = existing else {
        bail!("proposal {proposal_id} not found");
    };
    let (existing_decision, trigger_name, proposed_threshold) = existing;
    if existing_decision == "accepted" && matches!(decision, Decision::Accept) {
        println!("proposal {proposal_id} already accepted");
        return Ok(());
    }
    if existing_decision != "pending" {
        bail!("proposal {proposal_id} is already {existing_decision}");
    }

    let stored = decision.as_stored();
    db.execute(
        "UPDATE calibration_proposals
        SET decision = $1, decided_at = $2, rationale = $3
        WHERE id = $4 AND decision = 'pending'",
        &[
            P::from(stored),
            P::from(unix_timestamp()?),
            P::from(rationale.as_str()),
            P::from(proposal_id),
        ],
    )?;
    if matches!(decision, Decision::Accept) {
        let source = format!("proposal:{proposal_id}");
        ThresholdStore::load(db)?.set(&trigger_name, proposed_threshold, &source)?;
    }

    println!("proposal {proposal_id} {stored}");
    Ok(())
}

fn unix_timestamp() -> anyhow::Result<i64> {
    let duration = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .context("system clock is before unix epoch")?;
    i64::try_from(duration.as_secs()).context("unix timestamp does not fit in i64")
}