phago-cli 1.0.0

Command-line interface for Phago biological computing framework
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
109
110
111
112
113
114

//! Session management commands.

use anyhow::{bail, Context, Result};
use colored::Colorize;
use phago::prelude::*;

use crate::config::{current_session_path, sessions_dir};

pub fn save(name: &str) -> Result<()> {
    let current_path = current_session_path()?;

    if !current_path.exists() {
        bail!(
            "No active session. Run {} first.",
            "phago ingest".cyan()
        );
    }

    // Ensure sessions directory exists
    let sessions = sessions_dir()?;
    std::fs::create_dir_all(&sessions)?;

    // Copy current session to named session
    let session_path = sessions.join(format!("{}.json", name));
    std::fs::copy(&current_path, &session_path)
        .with_context(|| format!("Failed to save session: {}", name))?;

    println!(
        "{} Session saved: {}",
        "✓".green().bold(),
        name.cyan()
    );

    Ok(())
}

pub fn load(name: &str) -> Result<()> {
    let sessions = sessions_dir()?;
    let session_path = sessions.join(format!("{}.json", name));

    if !session_path.exists() {
        bail!("Session not found: {}", name);
    }

    // Load the named session to verify it's valid
    let state = load_session(&session_path)?;

    // Copy to current session
    let current_path = current_session_path()?;
    std::fs::copy(&session_path, &current_path)
        .with_context(|| format!("Failed to load session: {}", name))?;

    // Restore to get stats
    let mut colony = Colony::new();
    restore_into_colony(&mut colony, &state);
    let stats = colony.stats();

    println!(
        "{} Session loaded: {}",
        "✓".green().bold(),
        name.cyan()
    );
    println!("  Nodes: {}", stats.graph_nodes.to_string().cyan());
    println!("  Edges: {}", stats.graph_edges.to_string().cyan());

    Ok(())
}

pub fn list() -> Result<()> {
    let sessions = sessions_dir()?;

    if !sessions.exists() {
        println!("{} No saved sessions.", "•".yellow());
        return Ok(());
    }

    let mut found = false;
    println!("{} Saved sessions:", "→".blue());
    println!();

    for entry in std::fs::read_dir(&sessions)? {
        let entry = entry?;
        let path = entry.path();

        if path.extension().map(|e| e == "json").unwrap_or(false) {
            let name = path
                .file_stem()
                .map(|s| s.to_string_lossy().to_string())
                .unwrap_or_default();

            // Try to load and get stats
            if let Ok(state) = load_session(&path) {
                let mut colony = Colony::new();
                restore_into_colony(&mut colony, &state);
                let stats = colony.stats();

                println!(
                    "  {} {} ({} nodes, {} edges)",
                    "•".blue(),
                    name.white().bold(),
                    stats.graph_nodes,
                    stats.graph_edges
                );
                found = true;
            }
        }
    }

    if !found {
        println!("  {} No saved sessions.", "•".yellow());
    }

    Ok(())
}