opi-coding-agent 0.4.0

Interactive coding agent CLI with file editing and shell execution
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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177

//! Tests for system prompt construction (task 1.11).
//!
//! DoD: "prompt includes tool defs and system layer"

use opi_ai::message::ToolDef;
use opi_coding_agent::prompt::SystemPromptBuilder;
use serde_json::json;

fn tool_def(name: &str, description: &str) -> ToolDef {
    ToolDef {
        name: name.into(),
        description: description.into(),
        input_schema: json!({
            "type": "object",
            "properties": {
                "arg": { "type": "string" }
            },
            "required": ["arg"]
        }),
    }
}

// ---------------------------------------------------------------------------
// Base prompt layer
// ---------------------------------------------------------------------------

#[test]
fn builder_always_includes_base_instructions() {
    let prompt = SystemPromptBuilder::new().build();
    assert!(!prompt.is_empty(), "system prompt should never be empty");
    assert!(
        prompt.contains("coding"),
        "base prompt should mention coding role"
    );
}

// ---------------------------------------------------------------------------
// Tool description layer
// ---------------------------------------------------------------------------

#[test]
fn tool_names_appear_in_prompt() {
    let tools = vec![
        tool_def("read", "Read a file"),
        tool_def("bash", "Run a command"),
    ];
    let prompt = SystemPromptBuilder::new().tools(tools.clone()).build();

    assert!(prompt.contains("read"), "prompt should mention tool 'read'");
    assert!(prompt.contains("bash"), "prompt should mention tool 'bash'");
}

#[test]
fn tool_descriptions_appear_in_prompt() {
    let tools = vec![tool_def("read", "Read file content from disk")];
    let prompt = SystemPromptBuilder::new().tools(tools.clone()).build();

    assert!(
        prompt.contains("Read file content from disk"),
        "prompt should contain tool description text"
    );
}

#[test]
fn no_tools_means_no_tool_section() {
    let prompt = SystemPromptBuilder::new().build();
    assert!(
        !prompt.contains("Available tools"),
        "no tool section header when no tools provided"
    );
}

// ---------------------------------------------------------------------------
// User system prompt layer
// ---------------------------------------------------------------------------

#[test]
fn user_system_prompt_appended() {
    let prompt = SystemPromptBuilder::new()
        .user_system("Always use British spelling.")
        .build();

    assert!(
        prompt.contains("Always use British spelling."),
        "user system prompt should appear in output"
    );
}

#[test]
fn no_user_system_means_no_user_section() {
    let prompt = SystemPromptBuilder::new().build();
    assert!(
        !prompt.contains("User instructions"),
        "no user section when no user system prompt provided"
    );
}

// ---------------------------------------------------------------------------
// Layer ordering
// ---------------------------------------------------------------------------

#[test]
fn layers_in_correct_order() {
    let tools = vec![tool_def("read", "Read a file")];
    let prompt = SystemPromptBuilder::new()
        .tools(tools)
        .user_system("Custom instructions")
        .build();

    let base_pos = prompt.find("coding").expect("base instructions present");
    let tool_pos = prompt.find("read").expect("tool description present");
    let user_pos = prompt
        .find("Custom instructions")
        .expect("user system present");

    assert!(
        base_pos < tool_pos,
        "base instructions should come before tool descriptions"
    );
    assert!(
        tool_pos < user_pos,
        "tool descriptions should come before user system prompt"
    );
}

// ---------------------------------------------------------------------------
// Tool definitions collected for Request.tools
// ---------------------------------------------------------------------------

#[test]
fn tool_defs_collected_for_request() {
    let tools = vec![
        tool_def("read", "Read a file"),
        tool_def("bash", "Run a command"),
    ];
    let builder = SystemPromptBuilder::new().tools(tools.clone());

    let collected = builder.tool_definitions();
    assert_eq!(collected.len(), 2);
    assert_eq!(collected[0].name, "read");
    assert_eq!(collected[1].name, "bash");
}

// ---------------------------------------------------------------------------
// Edge cases
// ---------------------------------------------------------------------------

#[test]
fn empty_user_system_is_ignored() {
    let prompt = SystemPromptBuilder::new().user_system("").build();

    assert!(
        !prompt.contains("User instructions"),
        "empty user system should not create section"
    );
}

#[test]
fn multiple_tools_all_appear() {
    let tools = vec![
        tool_def("read", "Read a file"),
        tool_def("write", "Write a file"),
        tool_def("edit", "Edit a file"),
        tool_def("bash", "Run a command"),
        tool_def("glob", "Find files"),
        tool_def("grep", "Search content"),
    ];
    let prompt = SystemPromptBuilder::new().tools(tools.clone()).build();

    for tool in &tools {
        assert!(
            prompt.contains(&tool.name),
            "prompt should mention tool '{}'",
            tool.name
        );
    }
}