nornir 0.4.5

Companion to cargo: dependency tracking, release gating, deploy, benchmarks, and documentation assembly. Project-agnostic.
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

//! Launcher for the Urðr Threads visualizer.
//!
//! Usage (embedded — opens the warehouse directly):
//!     cargo run --release --features viz --bin urdr-threads \
//!         -- --warehouse /path/to/.nornir/warehouse --workspace my-ws
//!
//! Usage (thin client — reads from a running nornir-server over gRPC):
//!     NORNIR_SERVER=http://127.0.0.1:7878 NORNIR_SERVER_TOKEN=… \
//!     cargo run --release --features viz --bin urdr-threads -- --workspace my-ws
//! `NORNIR_WORKSPACE`, if set, selects the served workspace via the gRPC header.

use std::path::PathBuf;

use anyhow::Result;
use clap::Parser;

use nornir::viz::UrdrThreadsApp;

#[derive(Parser)]
#[command(name = "urdr-threads")]
#[command(about = "Time-travel visualizer for the Urðr warehouse", long_about = None)]
struct Cli {
    /// Path to the Iceberg warehouse root directory.
    #[arg(long, default_value = "/tmp/nornir-demo-warehouse")]
    warehouse: PathBuf,

    /// Workspace name (matches the `[workspace] name =` from the descriptor).
    /// Empty (the default) = remote mode auto-selects the server's first
    /// registered workspace; local mode browses the warehouse's default.
    #[arg(long, default_value = "")]
    workspace: String,

    /// Optional path to `nornir.toml`. If omitted we try to discover one
    /// from the current directory; if that also fails the Knowledge tab
    /// just renders with no repos.
    #[arg(long)]
    config: Option<PathBuf>,
}

fn main() -> Result<()> {
    let cli = Cli::parse();

    let (workspace_root, repos) = match cli.config.as_deref() {
        Some(p) => match nornir::config::load_explicit(p) {
            Ok(loaded) => (
                loaded.workspace_root,
                loaded.nornir.repo.keys().cloned().collect(),
            ),
            Err(_) => (PathBuf::new(), Vec::new()),
        },
        None => match std::env::current_dir()
            .ok()
            .and_then(|cwd| nornir::config::discover(&cwd).ok())
        {
            Some(loaded) => (
                loaded.workspace_root,
                loaded.nornir.repo.keys().cloned().collect(),
            ),
            None => (PathBuf::new(), Vec::new()),
        },
    };

    let native_options = eframe::NativeOptions {
        viewport: eframe::egui::ViewportBuilder::default()
            .with_inner_size([1200.0, 700.0])
            .with_title("Urðr Threads — nornir time machine"),
        ..Default::default()
    };
    // Thin-client mode: `NORNIR_SERVER` set → read the timeline from a running
    // nornir-server over gRPC; otherwise open the local warehouse directly.
    let server = std::env::var("NORNIR_SERVER").ok().filter(|s| !s.is_empty());
    // `NORNIR_WORKSPACE` (the same selector the CLI/MCP use) overrides --workspace
    // so the viz targets a chosen served workspace (e.g. a monitored one). It is
    // also sent as the `nornir-workspace` gRPC header (see viz::remote).
    let workspace = std::env::var("NORNIR_WORKSPACE")
        .ok()
        .filter(|s| !s.is_empty())
        .unwrap_or(cli.workspace);

    eframe::run_native(
        "Urðr Threads",
        native_options,
        Box::new(move |_cc| {
            let app = match server {
                Some(endpoint) => {
                    let token = std::env::var("NORNIR_SERVER_TOKEN").unwrap_or_default();
                    UrdrThreadsApp::with_remote(endpoint, token, workspace, workspace_root, repos)
                }
                None => UrdrThreadsApp::with_repos(cli.warehouse, workspace, workspace_root, repos),
            };
            Ok(Box::new(app))
        }),
    )
    .map_err(|e| anyhow::anyhow!("eframe error: {e}"))?;
    Ok(())
}