yog 0.0.57

yog: the standalone server for litany loops — the world, the balls and the conversations, behind one wire
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

//! The §8.5 search derivation, end to end: the corpus it spans, the order it
//! ranks in, the bytes it re-reads, and the gaps it names.

mod corpus;
mod rank;
mod render;

use super::*;
use crate::app::{Cadence, Snapshot};
use crate::binding::{Workspace, WorkspaceKind};
use crate::git_tree::{Agent, AgentState, GitTree};
use crate::projects::balls::Ball;
use crate::projects::join::{JoinRow, JoinState};
use std::collections::HashMap;
use std::path::{Path, PathBuf};
use tempfile::tempdir;

const AGENT: &str = "20260427T120000Z-aaaa";

fn ball(id: &str, title: &str, body: &str) -> Ball {
    Ball {
        id: id.to_owned(),
        title: title.to_owned(),
        body: body.to_owned(),
        claimant: None,
        blockers: vec![],
        parent: None,
        priority: 3,
        tags: vec![],
        created: None,
        updated: None,
        root_commit: None,
    }
}

fn agent(id: &str, name: Option<&str>) -> Agent {
    Agent {
        branch_name: format!("agents/{id}"),
        agent_id: id.to_owned(),
        tip_oid: "a".repeat(40),
        tip_short_oid: "aaaaaaaa".to_owned(),
        tip_timestamp_unix: 100,
        last_action_unix: 100,
        messages: 0,
        call_start_unix: None,
        steps: vec![],
        preview: None,
        stream: crate::git_tree::Stream::default(),
        tool_calls: vec![],
        state: AgentState::Quiescent,
        state_uncertain: false,
        truncated: false,
        failure: None,
        flagged: None,
        pending: vec![],
        conflicted_oid: None,
        budget_oid: None,
        abandoned_oid: None,
        notify_oid: None,
        held: None,
        goal_ball: None,
        name: name.map(str::to_owned),
        goal_name: None,
    }
}

/// A world: one named workspace with `agents` derived, and one project with
/// `live`/`closed` ball sets.
fn world(ws: &Path, agents: Vec<Agent>, live: Vec<Ball>, closed: Vec<Ball>) -> Snapshot {
    let project = PathBuf::from("/proj");
    let mut trees = HashMap::new();
    trees.insert(
        ws.to_path_buf(),
        GitTree {
            commits: vec![],
            agents,
        },
    );
    Snapshot {
        workspaces: vec![Workspace {
            path: ws.to_path_buf(),
            kind: WorkspaceKind::Named {
                name: crate::naming::leaf(ws),
            },
        }],
        projects: vec![project.clone()],
        trees,
        bills: HashMap::new(),
        balls_by_project: HashMap::from([(project.clone(), live)]),
        closed_by_project: HashMap::from([(project, closed)]),
        join_rows: vec![],
        ops: vec![],
        growth: vec![],
        ui_bytes: None,
        derived_at_unix: 0,
        cadence: Cadence::default(),
        fleet: std::collections::BTreeMap::new(),
    }
}

fn always() -> impl Fn() -> bool {
    || true
}

fn write(path: &Path, bytes: &[u8]) {
    std::fs::create_dir_all(path.parent().unwrap()).unwrap();
    std::fs::write(path, bytes).unwrap();
}