venus 0.1.1

Reactive notebook environment for Rust
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

//! Sync command implementation for Venus CLI.
//!
//! Converts .rs notebooks to .ipynb format.

use std::path::Path;
use std::time::Instant;

use venus_sync::{OutputCache, default_ipynb_path, sync_to_ipynb};

use crate::colors;

/// Execute the sync command.
pub fn execute(notebook_path: &str, watch: bool) -> anyhow::Result<()> {
    let path = Path::new(notebook_path);
    if !path.exists() {
        anyhow::bail!("Notebook not found: {}", notebook_path);
    }

    let abs_path = path.canonicalize()?;
    let ipynb_path = default_ipynb_path(&abs_path);

    println!(
        "\n{}Venus Sync{} - Converting to Jupyter format",
        colors::BOLD,
        colors::RESET
    );
    println!("{}", "─".repeat(50));

    // Set up output cache
    let notebook_dir = abs_path.parent().unwrap_or(Path::new("."));
    let cache_dir = notebook_dir.join(".venus").join("outputs");
    let cache = OutputCache::new(&cache_dir).ok();

    if watch {
        println!(
            "{}Watching{} {} for changes...",
            colors::CYAN,
            colors::RESET,
            path.display()
        );
        println!("Press Ctrl+C to stop.\n");

        // Initial sync
        sync_file(&abs_path, &ipynb_path, cache.as_ref())?;

        // Watch for changes using simple polling
        // TODO: Use notify crate for proper file watching
        watch_and_sync(&abs_path, &ipynb_path, cache.as_ref())?;
    } else {
        sync_file(&abs_path, &ipynb_path, cache.as_ref())?;
    }

    Ok(())
}

/// Sync a single file.
fn sync_file(rs_path: &Path, ipynb_path: &Path, cache: Option<&OutputCache>) -> anyhow::Result<()> {
    let start = Instant::now();

    print!(
        "  {} → {} ... ",
        rs_path.file_name().unwrap_or_default().to_string_lossy(),
        ipynb_path.file_name().unwrap_or_default().to_string_lossy()
    );
    std::io::Write::flush(&mut std::io::stdout()).ok();

    sync_to_ipynb(rs_path, ipynb_path, cache)?;

    let elapsed = start.elapsed();
    println!(
        "{}✓{} ({:.2}ms)",
        colors::GREEN,
        colors::RESET,
        elapsed.as_secs_f64() * 1000.0
    );

    Ok(())
}

/// Watch a file and sync on changes.
fn watch_and_sync(
    rs_path: &Path,
    ipynb_path: &Path,
    cache: Option<&OutputCache>,
) -> anyhow::Result<()> {
    use std::fs;
    use std::thread;
    use std::time::Duration;

    let mut last_modified = fs::metadata(rs_path)?.modified()?;

    loop {
        thread::sleep(Duration::from_millis(500));

        let current_modified = fs::metadata(rs_path)?.modified()?;

        if current_modified != last_modified {
            last_modified = current_modified;
            println!("\nFile changed, syncing...");

            if let Err(e) = sync_file(rs_path, ipynb_path, cache) {
                eprintln!("  Error: {}", e);
            }
        }
    }
}