Function bodies 848 total

agent_id_copy_semantics function · rust · L83-L87 (5 LOC)

src/agent/mod.rs

    fn agent_id_copy_semantics() {
        let a = AgentId::new();
        let b = a;
        assert_eq!(a, b);
    }

agent_id_from_uuid function · rust · L90-L94 (5 LOC)

src/agent/mod.rs

    fn agent_id_from_uuid() {
        let uuid = Uuid::new_v4();
        let id = AgentId::from(uuid);
        assert_eq!(*id.as_uuid(), uuid);
    }

agent_id_default function · rust · L97-L101 (5 LOC)

src/agent/mod.rs

    fn agent_id_default() {
        let a = AgentId::default();
        let b = AgentId::default();
        assert_ne!(a, b);
    }

default function · rust · L30-L37 (8 LOC)

src/agent/restart.rs

    fn default() -> Self {
        Self {
            auto_restart: false,
            max_restarts: 3,
            restart_delay_secs: 5,
            restart_backoff_multiplier: 2.0,
        }
    }

new function · rust · L53-L59 (7 LOC)

src/agent/restart.rs

    pub fn new(policy: RestartPolicy) -> Self {
        Self {
            restart_count: 0,
            last_restart: None,
            policy,
        }
    }

should_restart function · rust · L65-L67 (3 LOC)

src/agent/restart.rs

    pub fn should_restart(&self) -> bool {
        self.policy.auto_restart && self.restart_count < self.policy.max_restarts
    }

next_delay function · rust · L73-L81 (9 LOC)

src/agent/restart.rs

    pub fn next_delay(&self) -> Duration {
        let base = self.policy.restart_delay_secs as f64;
        let multiplied = base
            * self
                .policy
                .restart_backoff_multiplier
                .powi(self.restart_count as i32);
        Duration::from_secs_f64(multiplied.min(300.0))
    }

Repobility — the code-quality scanner for AI-generated software · https://repobility.com

record_restart function · rust · L84-L87 (4 LOC)

src/agent/restart.rs

    pub fn record_restart(&mut self) {
        self.restart_count += 1;
        self.last_restart = Some(Instant::now());
    }

restart_count function · rust · L90-L92 (3 LOC)

src/agent/restart.rs

    pub fn restart_count(&self) -> u32 {
        self.restart_count
    }

max_restarts function · rust · L95-L97 (3 LOC)

src/agent/restart.rs

    pub fn max_restarts(&self) -> u32 {
        self.policy.max_restarts
    }

last_restart function · rust · L100-L102 (3 LOC)

src/agent/restart.rs

    pub fn last_restart(&self) -> Option<Instant> {
        self.last_restart
    }

is_enabled function · rust · L105-L107 (3 LOC)

src/agent/restart.rs

    pub fn is_enabled(&self) -> bool {
        self.policy.auto_restart
    }

reset function · rust · L110-L113 (4 LOC)

src/agent/restart.rs

    pub fn reset(&mut self) {
        self.restart_count = 0;
        self.last_restart = None;
    }

status_display function · rust · L118-L132 (15 LOC)

src/agent/restart.rs

    pub fn status_display(&self) -> String {
        if !self.policy.auto_restart {
            "No auto-restart".to_string()
        } else if self.restart_count >= self.policy.max_restarts {
            format!(
                "Restart limit reached ({}/{})",
                self.restart_count, self.policy.max_restarts
            )
        } else {
            format!(
                "Restarts: {}/{}",
                self.restart_count, self.policy.max_restarts
            )
        }
    }

default function · rust · L136-L138 (3 LOC)

src/agent/restart.rs

    fn default() -> Self {
        Self::new(RestartPolicy::default())
    }

test_restart_policy_defaults function · rust · L148-L154 (7 LOC)

src/agent/restart.rs

    fn test_restart_policy_defaults() {
        let policy = RestartPolicy::default();
        assert!(!policy.auto_restart);
        assert_eq!(policy.max_restarts, 3);
        assert_eq!(policy.restart_delay_secs, 5);
        assert_eq!(policy.restart_backoff_multiplier, 2.0);
    }

test_restart_policy_deserialize function · rust · L157-L169 (13 LOC)

src/agent/restart.rs

    fn test_restart_policy_deserialize() {
        let toml_str = r#"
            auto_restart = true
            max_restarts = 5
            restart_delay_secs = 10
            restart_backoff_multiplier = 1.5
        "#;
        let policy: RestartPolicy = toml::from_str(toml_str).unwrap();
        assert!(policy.auto_restart);
        assert_eq!(policy.max_restarts, 5);
        assert_eq!(policy.restart_delay_secs, 10);
        assert_eq!(policy.restart_backoff_multiplier, 1.5);
    }

test_restart_policy_partial_deserialize function · rust · L172-L182 (11 LOC)

src/agent/restart.rs

    fn test_restart_policy_partial_deserialize() {
        let toml_str = r#"
            auto_restart = true
        "#;
        let policy: RestartPolicy = toml::from_str(toml_str).unwrap();
        assert!(policy.auto_restart);
        // Defaults for the rest
        assert_eq!(policy.max_restarts, 3);
        assert_eq!(policy.restart_delay_secs, 5);
        assert_eq!(policy.restart_backoff_multiplier, 2.0);
    }

test_should_restart_when_enabled function · rust · L187-L194 (8 LOC)

src/agent/restart.rs

    fn test_should_restart_when_enabled() {
        let tracker = RestartTracker::new(RestartPolicy {
            auto_restart: true,
            max_restarts: 3,
            ..Default::default()
        });
        assert!(tracker.should_restart());
    }

test_should_not_restart_when_disabled function · rust · L197-L204 (8 LOC)

src/agent/restart.rs

    fn test_should_not_restart_when_disabled() {
        let tracker = RestartTracker::new(RestartPolicy {
            auto_restart: false,
            max_restarts: 3,
            ..Default::default()
        });
        assert!(!tracker.should_restart());
    }

test_should_not_restart_at_limit function · rust · L207-L218 (12 LOC)

src/agent/restart.rs

    fn test_should_not_restart_at_limit() {
        let mut tracker = RestartTracker::new(RestartPolicy {
            auto_restart: true,
            max_restarts: 3,
            ..Default::default()
        });
        tracker.record_restart();
        tracker.record_restart();
        tracker.record_restart();
        assert!(!tracker.should_restart());
        assert_eq!(tracker.restart_count(), 3);
    }

test_backoff_delay_initial function · rust · L221-L229 (9 LOC)

src/agent/restart.rs

    fn test_backoff_delay_initial() {
        let tracker = RestartTracker::new(RestartPolicy {
            restart_delay_secs: 5,
            restart_backoff_multiplier: 2.0,
            ..Default::default()
        });
        // 5 * 2^0 = 5
        assert_eq!(tracker.next_delay(), Duration::from_secs(5));
    }

test_backoff_delay_after_one_restart function · rust · L232-L241 (10 LOC)

src/agent/restart.rs

    fn test_backoff_delay_after_one_restart() {
        let mut tracker = RestartTracker::new(RestartPolicy {
            restart_delay_secs: 5,
            restart_backoff_multiplier: 2.0,
            ..Default::default()
        });
        tracker.record_restart();
        // 5 * 2^1 = 10
        assert_eq!(tracker.next_delay(), Duration::from_secs(10));
    }

Repobility · open methodology · https://repobility.com/research/

test_backoff_delay_after_two_restarts function · rust · L244-L254 (11 LOC)

src/agent/restart.rs

    fn test_backoff_delay_after_two_restarts() {
        let mut tracker = RestartTracker::new(RestartPolicy {
            restart_delay_secs: 5,
            restart_backoff_multiplier: 2.0,
            ..Default::default()
        });
        tracker.record_restart();
        tracker.record_restart();
        // 5 * 2^2 = 20
        assert_eq!(tracker.next_delay(), Duration::from_secs(20));
    }

test_backoff_delay_capped_at_five_minutes function · rust · L257-L269 (13 LOC)

src/agent/restart.rs

    fn test_backoff_delay_capped_at_five_minutes() {
        let mut tracker = RestartTracker::new(RestartPolicy {
            restart_delay_secs: 100,
            restart_backoff_multiplier: 10.0,
            max_restarts: 100,
            ..Default::default()
        });
        tracker.record_restart();
        tracker.record_restart();
        tracker.record_restart();
        // Would be 100 * 10^3 = 100_000, but capped at 300
        assert_eq!(tracker.next_delay(), Duration::from_secs(300));
    }

test_record_restart_updates_count function · rust · L272-L283 (12 LOC)

src/agent/restart.rs

    fn test_record_restart_updates_count() {
        let mut tracker = RestartTracker::new(RestartPolicy::default());
        assert_eq!(tracker.restart_count(), 0);
        assert!(tracker.last_restart().is_none());

        tracker.record_restart();
        assert_eq!(tracker.restart_count(), 1);
        assert!(tracker.last_restart().is_some());

        tracker.record_restart();
        assert_eq!(tracker.restart_count(), 2);
    }

test_reset_tracker function · rust · L286-L301 (16 LOC)

src/agent/restart.rs

    fn test_reset_tracker() {
        let mut tracker = RestartTracker::new(RestartPolicy {
            auto_restart: true,
            max_restarts: 3,
            ..Default::default()
        });
        tracker.record_restart();
        tracker.record_restart();
        tracker.record_restart();
        assert!(!tracker.should_restart());

        tracker.reset();
        assert_eq!(tracker.restart_count(), 0);
        assert!(tracker.last_restart().is_none());
        assert!(tracker.should_restart());
    }

test_status_display_disabled function · rust · L304-L307 (4 LOC)

src/agent/restart.rs

    fn test_status_display_disabled() {
        let tracker = RestartTracker::default();
        assert_eq!(tracker.status_display(), "No auto-restart");
    }

test_status_display_enabled function · rust · L310-L317 (8 LOC)

src/agent/restart.rs

    fn test_status_display_enabled() {
        let tracker = RestartTracker::new(RestartPolicy {
            auto_restart: true,
            max_restarts: 5,
            ..Default::default()
        });
        assert_eq!(tracker.status_display(), "Restarts: 0/5");
    }

test_status_display_limit_reached function · rust · L320-L329 (10 LOC)

src/agent/restart.rs

    fn test_status_display_limit_reached() {
        let mut tracker = RestartTracker::new(RestartPolicy {
            auto_restart: true,
            max_restarts: 2,
            ..Default::default()
        });
        tracker.record_restart();
        tracker.record_restart();
        assert_eq!(tracker.status_display(), "Restart limit reached (2/2)");
    }

test_is_enabled function · rust · L332-L341 (10 LOC)

src/agent/restart.rs

    fn test_is_enabled() {
        let tracker_off = RestartTracker::new(RestartPolicy::default());
        assert!(!tracker_off.is_enabled());

        let tracker_on = RestartTracker::new(RestartPolicy {
            auto_restart: true,
            ..Default::default()
        });
        assert!(tracker_on.is_enabled());
    }

Repobility · severity-and-effort ranking · https://repobility.com

test_max_restarts_accessor function · rust · L344-L350 (7 LOC)

src/agent/restart.rs

    fn test_max_restarts_accessor() {
        let tracker = RestartTracker::new(RestartPolicy {
            max_restarts: 7,
            ..Default::default()
        });
        assert_eq!(tracker.max_restarts(), 7);
    }

test_default_tracker function · rust · L353-L358 (6 LOC)

src/agent/restart.rs

    fn test_default_tracker() {
        let tracker = RestartTracker::default();
        assert_eq!(tracker.restart_count(), 0);
        assert!(!tracker.is_enabled());
        assert!(!tracker.should_restart());
    }

test_backoff_with_fractional_multiplier function · rust · L361-L369 (9 LOC)

src/agent/restart.rs

    fn test_backoff_with_fractional_multiplier() {
        let tracker = RestartTracker::new(RestartPolicy {
            restart_delay_secs: 10,
            restart_backoff_multiplier: 1.5,
            ..Default::default()
        });
        // 10 * 1.5^0 = 10
        assert_eq!(tracker.next_delay(), Duration::from_secs(10));
    }

new function · rust · L25-L32 (8 LOC)

src/agent/scrollback.rs

    pub fn new(max_bytes: usize) -> Self {
        Self {
            raw_bytes: Vec::with_capacity(max_bytes / 4),
            max_bytes,
            scroll_offset: 0,
            search: None,
        }
    }

append function · rust · L35-L43 (9 LOC)

src/agent/scrollback.rs

    pub fn append(&mut self, data: &[u8]) {
        self.raw_bytes.extend_from_slice(data);

        // Trim from the front if we exceed max size
        if self.raw_bytes.len() > self.max_bytes {
            let trim = self.raw_bytes.len() - self.max_bytes;
            self.raw_bytes.drain(..trim);
        }
    }

scroll_up function · rust · L46-L48 (3 LOC)

src/agent/scrollback.rs

    pub fn scroll_up(&mut self, page_height: usize) {
        self.scroll_offset += page_height / 2;
    }

scroll_down function · rust · L51-L53 (3 LOC)

src/agent/scrollback.rs

    pub fn scroll_down(&mut self, page_height: usize) {
        self.scroll_offset = self.scroll_offset.saturating_sub(page_height / 2);
    }

mouse_scroll_up function · rust · L56-L58 (3 LOC)

src/agent/scrollback.rs

    pub fn mouse_scroll_up(&mut self, lines: usize) {
        self.scroll_offset += lines;
    }

Repobility — the code-quality scanner for AI-generated software · https://repobility.com

mouse_scroll_down function · rust · L61-L63 (3 LOC)

src/agent/scrollback.rs

    pub fn mouse_scroll_down(&mut self, lines: usize) {
        self.scroll_offset = self.scroll_offset.saturating_sub(lines);
    }

is_scrolled function · rust · L66-L68 (3 LOC)

src/agent/scrollback.rs

    pub fn is_scrolled(&self) -> bool {
        self.scroll_offset > 0
    }

scroll_to_bottom function · rust · L71-L73 (3 LOC)

src/agent/scrollback.rs

    pub fn scroll_to_bottom(&mut self) {
        self.scroll_offset = 0;
    }

scroll_offset function · rust · L76-L78 (3 LOC)

src/agent/scrollback.rs

    pub fn scroll_offset(&self) -> usize {
        self.scroll_offset
    }

clamp_scroll function · rust · L81-L85 (5 LOC)

src/agent/scrollback.rs

    pub fn clamp_scroll(&mut self, max_scrollback: usize) {
        if self.scroll_offset > max_scrollback {
            self.scroll_offset = max_scrollback;
        }
    }

search function · rust · L88-L90 (3 LOC)

src/agent/scrollback.rs

    pub fn search(&self) -> Option<&SearchState> {
        self.search.as_ref()
    }

search_mut function · rust · L93-L95 (3 LOC)

src/agent/scrollback.rs

    pub fn search_mut(&mut self) -> Option<&mut SearchState> {
        self.search.as_mut()
    }

start_search function · rust · L98-L104 (7 LOC)

src/agent/scrollback.rs

    pub fn start_search(&mut self, query: &str) {
        if query.is_empty() {
            self.search = None;
        } else {
            self.search = Some(SearchState::new(query));
        }
    }

clear_search function · rust · L107-L109 (3 LOC)

src/agent/scrollback.rs

    pub fn clear_search(&mut self) {
        self.search = None;
    }

raw_len function · rust · L112-L114 (3 LOC)

src/agent/scrollback.rs

    pub fn raw_len(&self) -> usize {
        self.raw_bytes.len()
    }

raw_bytes function · rust · L117-L119 (3 LOC)

src/agent/scrollback.rs

    pub fn raw_bytes(&self) -> &[u8] {
        &self.raw_bytes
    }

‹ prevpage 4 / 17next ›