navi-core 0.3.7

Local agentic engine and terminal-first coding agent.
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use crate::goal::types::{GoalStatus, SessionGoal};
use crate::session::SessionStore;
use std::collections::HashMap;
use std::path::Path;
use std::sync::{Arc, RwLock};

use super::runtime::GoalRuntimeHandle;

/// Public API for managing goals across sessions.
///
/// Maintains a registry of all active goal runtimes keyed by session id.
/// Goal persistence is handled via `SessionSnapshot.goal`.
pub struct GoalService {
    /// Active goal runtimes, keyed by session id.
    runtimes: RwLock<HashMap<String, Arc<GoalRuntimeHandle>>>,
}

impl GoalService {
    /// Creates a new goal service.
    pub fn new() -> Self {
        Self {
            runtimes: RwLock::new(HashMap::new()),
        }
    }

    /// Sets or updates the goal for a session.
    pub fn set_goal(
        &self,
        session_id: String,
        objective: String,
        token_budget: Option<i64>,
    ) -> SessionGoal {
        let runtimes = self.runtimes.read().unwrap_or_else(|e| e.into_inner());
        if let Some(runtime) = runtimes.get(&session_id) {
            runtime.set_objective(objective, token_budget)
        } else {
            drop(runtimes);
            SessionGoal::new(session_id, objective, token_budget)
        }
    }

    /// Updates the status of an existing goal.
    pub fn update_goal_status(&self, session_id: &str, status: GoalStatus) -> Option<SessionGoal> {
        let runtimes = self.runtimes.read().unwrap_or_else(|e| e.into_inner());
        if let Some(runtime) = runtimes.get(session_id) {
            let goal = runtime.get_goal();
            if let Some(mut goal) = goal {
                goal.transition_to(status);
                runtime.update_goal(goal.clone());
                return Some(goal);
            }
        }
        None
    }

    /// Gets the current goal for a session.
    pub fn get_goal(&self, session_id: &str) -> Option<SessionGoal> {
        let runtimes = self.runtimes.read().unwrap_or_else(|e| e.into_inner());
        if let Some(runtime) = runtimes.get(session_id) {
            runtime.get_goal()
        } else {
            None
        }
    }

    /// Clears the goal for a session. Also clears the runtime handle's state.
    pub fn clear_goal(&self, session_id: &str) -> bool {
        let mut runtimes = self.runtimes.write().unwrap_or_else(|e| e.into_inner());
        if let Some(runtime) = runtimes.get(session_id) {
            runtime.clear_goal();
        }
        runtimes.remove(session_id);
        true
    }

    /// Registers a runtime handle for a session.
    pub fn register_runtime(&self, session_id: String, runtime: Arc<GoalRuntimeHandle>) {
        let mut runtimes = self.runtimes.write().unwrap_or_else(|e| e.into_inner());
        runtimes.insert(session_id, runtime);
    }

    /// Unregisters a runtime handle for a session.
    pub fn unregister_runtime(&self, session_id: &str) {
        let mut runtimes = self.runtimes.write().unwrap_or_else(|e| e.into_inner());
        runtimes.remove(session_id);
    }

    /// Persists the goal for a session.
    ///
    /// The main runtime persists goals in `SessionSnapshot.goal`; this legacy
    /// helper keeps the standalone `goal.json` path available for callers that
    /// still use `GoalService` directly.
    pub fn persist_goal(
        &self,
        session_id: &str,
        _project_dir: &Path,
        session_store: &SessionStore,
    ) -> anyhow::Result<()> {
        if let Some(goal) = self.get_goal(session_id) {
            let json = serde_json::to_string_pretty(&goal)?;
            let dir = session_store.root().join(session_id);
            std::fs::create_dir_all(&dir)?;
            let path = dir.join("goal.json");
            std::fs::write(&path, json)?;
        }
        Ok(())
    }

    /// Loads a persisted goal for a session.
    ///
    /// Prefer the current session snapshot field, then fall back to the older
    /// `<sessions>/<session_id>/goal.json` layout.
    pub fn load_goal(&self, session_id: &str, session_store: &SessionStore) -> Option<SessionGoal> {
        if let Ok(snapshot) = session_store.load(session_id)
            && snapshot.goal.is_some()
        {
            return snapshot.goal;
        }

        let path = session_store.root().join(session_id).join("goal.json");
        if path.exists() {
            let json = std::fs::read_to_string(&path).ok()?;
            serde_json::from_str(&json).ok()
        } else {
            None
        }
    }
}

impl Default for GoalService {
    fn default() -> Self {
        Self::new()
    }
}