github-copilot-sdk 1.0.17-preview.5

Rust SDK for programmatic control of the GitHub Copilot CLI via JSON-RPC.
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

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *--------------------------------------------------------------------------------------------*/

#![cfg(test)]

use super::*;

struct TestTransform;

#[async_trait]
impl SystemMessageTransform for TestTransform {
    fn section_ids(&self) -> Vec<String> {
        vec!["instructions".to_string(), "context".to_string()]
    }

    async fn transform_section(
        &self,
        section_id: &str,
        content: &str,
        _ctx: TransformContext,
    ) -> Option<String> {
        match section_id {
            "instructions" => Some(format!("[modified] {content}")),
            _ => None,
        }
    }
}

#[tokio::test]
async fn dispatch_applies_matching_transform() {
    let transform = TestTransform;
    let mut sections = HashMap::new();
    sections.insert(
        "instructions".to_string(),
        TransformSection {
            content: "be helpful".to_string(),
        },
    );

    let response = dispatch_transform(&transform, &SessionId::new("sess-1"), sections).await;
    assert_eq!(
        response.sections["instructions"].content,
        "[modified] be helpful"
    );
}

#[tokio::test]
async fn dispatch_passes_through_unhandled_section() {
    let transform = TestTransform;
    let mut sections = HashMap::new();
    sections.insert(
        "context".to_string(),
        TransformSection {
            content: "original context".to_string(),
        },
    );

    let response = dispatch_transform(&transform, &SessionId::new("sess-1"), sections).await;
    assert_eq!(response.sections["context"].content, "original context");
}

#[tokio::test]
async fn dispatch_unknown_section_passes_through() {
    let transform = TestTransform;
    let mut sections = HashMap::new();
    sections.insert(
        "unknown".to_string(),
        TransformSection {
            content: "mystery".to_string(),
        },
    );

    let response = dispatch_transform(&transform, &SessionId::new("sess-1"), sections).await;
    assert_eq!(response.sections["unknown"].content, "mystery");
}

#[tokio::test]
async fn dispatch_mixed_sections() {
    let transform = TestTransform;
    let mut sections = HashMap::new();
    sections.insert(
        "instructions".to_string(),
        TransformSection {
            content: "help me".to_string(),
        },
    );
    sections.insert(
        "context".to_string(),
        TransformSection {
            content: "some context".to_string(),
        },
    );
    sections.insert(
        "other".to_string(),
        TransformSection {
            content: "other stuff".to_string(),
        },
    );

    let response = dispatch_transform(&transform, &SessionId::new("sess-1"), sections).await;
    assert_eq!(
        response.sections["instructions"].content,
        "[modified] help me"
    );
    assert_eq!(response.sections["context"].content, "some context");
    assert_eq!(response.sections["other"].content, "other stuff");
}

#[tokio::test]
async fn section_ids_returns_registered_sections() {
    let transform = TestTransform;
    let ids = transform.section_ids();
    assert_eq!(ids, vec!["instructions", "context"]);
}