nighthawk 0.1.1

AI terminal autocomplete — zero config, zero login, zero telemetry
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

pub mod history;
#[cfg(feature = "local-llm")]
pub mod llm;
pub mod specs;
pub mod tier;

use crate::proto::{CompletionRequest, CompletionResponse};
use tier::PredictionTier;
use tracing::{debug, warn};

/// Orchestrates the tiered prediction cascade.
///
/// Tiers run in order (fast first). The engine returns the first
/// tier's results that produce suggestions. Future: fire slower
/// tiers in background for potential upgrades.
pub struct PredictionEngine {
    tiers: Vec<Box<dyn PredictionTier>>,
}

impl PredictionEngine {
    pub fn new(tiers: Vec<Box<dyn PredictionTier>>) -> Self {
        Self { tiers }
    }

    /// Run the prediction cascade and return the best suggestions.
    pub async fn complete(&self, req: &CompletionRequest) -> CompletionResponse {
        for tier in &self.tiers {
            match tokio::time::timeout(
                std::time::Duration::from_millis(tier.budget_ms() as u64 + 50),
                tier.predict(req),
            )
            .await
            {
                Ok(suggestions) if !suggestions.is_empty() => {
                    debug!(
                        tier = tier.name(),
                        count = suggestions.len(),
                        "Tier produced suggestions"
                    );
                    return CompletionResponse { suggestions };
                }
                Ok(_) => {
                    debug!(tier = tier.name(), "Tier returned no suggestions");
                }
                Err(_) => {
                    warn!(
                        tier = tier.name(),
                        budget_ms = tier.budget_ms(),
                        "Tier exceeded budget"
                    );
                }
            }
        }

        CompletionResponse {
            suggestions: vec![],
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::proto::{Shell, Suggestion, SuggestionSource};
    use async_trait::async_trait;
    use std::path::PathBuf;

    struct MockTier {
        suggestions: Vec<Suggestion>,
    }

    #[async_trait]
    impl PredictionTier for MockTier {
        fn name(&self) -> &str {
            "mock"
        }
        fn budget_ms(&self) -> u32 {
            10
        }
        async fn predict(&self, _req: &CompletionRequest) -> Vec<Suggestion> {
            self.suggestions.clone()
        }
    }

    fn test_request() -> CompletionRequest {
        CompletionRequest {
            input: "git ch".into(),
            cursor: 6,
            cwd: PathBuf::from("/tmp"),
            shell: Shell::Zsh,
        }
    }

    #[tokio::test]
    async fn empty_tiers_return_empty() {
        let engine = PredictionEngine::new(vec![]);
        let resp = engine.complete(&test_request()).await;
        assert!(resp.suggestions.is_empty());
    }

    #[tokio::test]
    async fn first_tier_with_results_wins() {
        let tier1 = MockTier {
            suggestions: vec![Suggestion {
                text: "checkout".into(),
                replace_start: 4,
                replace_end: 6,
                confidence: 0.9,
                source: SuggestionSource::Spec,
                description: None,
                diff_ops: None,
            }],
        };
        let tier2 = MockTier {
            suggestions: vec![Suggestion {
                text: "from-tier2".into(),
                replace_start: 0,
                replace_end: 6,
                confidence: 0.5,
                source: SuggestionSource::History,
                description: None,
                diff_ops: None,
            }],
        };

        let engine = PredictionEngine::new(vec![Box::new(tier1), Box::new(tier2)]);
        let resp = engine.complete(&test_request()).await;
        assert_eq!(resp.suggestions.len(), 1);
        assert_eq!(resp.suggestions[0].text, "checkout");
    }

    #[tokio::test]
    async fn skips_empty_tier() {
        let empty_tier = MockTier {
            suggestions: vec![],
        };
        let real_tier = MockTier {
            suggestions: vec![Suggestion {
                text: "cherry-pick".into(),
                replace_start: 4,
                replace_end: 6,
                confidence: 0.7,
                source: SuggestionSource::History,
                description: None,
                diff_ops: None,
            }],
        };

        let engine = PredictionEngine::new(vec![Box::new(empty_tier), Box::new(real_tier)]);
        let resp = engine.complete(&test_request()).await;
        assert_eq!(resp.suggestions[0].text, "cherry-pick");
    }
}