cmt 0.5.16

CLI tool that generates commit messages using AI
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

//! Integration tests for AI providers via rstructor
//!
//! These tests verify that the AI providers work correctly with rstructor.
//! They require valid API keys to run:
//!   - GEMINI_API_KEY for Gemini tests
//!   - ANTHROPIC_API_KEY for Claude tests
//!   - OPENAI_API_KEY for OpenAI tests
//!
//! Run these tests with:
//!   cargo test --test integration_models
//!
//! Or run a specific provider:
//!   cargo test --test integration_models test_gemini
//!   cargo test --test integration_models test_claude
//!   cargo test --test integration_models test_openai

use std::env;

use cmt::ai_mod::{ThinkingLevel, PROVIDERS};
use cmt::defaults::{DEFAULT_CLAUDE_MODEL, DEFAULT_GEMINI_MODEL, DEFAULT_OPENAI_MODEL};
use rstructor::{AnthropicClient, GeminiClient, Instructor, LLMClient, OpenAIClient};
use serde::{Deserialize, Serialize};

/// Simple test struct for validation
#[derive(Debug, Serialize, Deserialize, Instructor)]
#[llm(description = "A simple test response")]
struct TestResponse {
    #[llm(description = "A greeting message")]
    message: String,
}

/// Helper to require an API key - panics if not set
fn require_api_key(key: &str) {
    if env::var(key).is_err() {
        panic!("{} environment variable not set", key);
    }
}

/// Test that Claude works with rstructor
#[tokio::test]
async fn test_claude_with_rstructor() {
    require_api_key("ANTHROPIC_API_KEY");

    let client = AnthropicClient::from_env()
        .expect("Failed to build Claude client")
        .model(DEFAULT_CLAUDE_MODEL)
        .temperature(0.3);

    let result = client
        .materialize::<TestResponse>("Say hello in a friendly way")
        .await;

    match result {
        Ok(response) => {
            println!("✓ Claude works with rstructor!");
            println!("  Message: {}", response.message);
            assert!(!response.message.is_empty(), "Message should not be empty");
        }
        Err(e) => {
            panic!(
                "Claude with rstructor failed (model: {}): {}",
                DEFAULT_CLAUDE_MODEL, e
            );
        }
    }
}

/// Test that OpenAI works with rstructor
#[tokio::test]
async fn test_openai_with_rstructor() {
    require_api_key("OPENAI_API_KEY");

    let client = OpenAIClient::from_env()
        .expect("Failed to build OpenAI client")
        .model(DEFAULT_OPENAI_MODEL)
        .temperature(0.3);

    let result = client
        .materialize::<TestResponse>("Say hello in a friendly way")
        .await;

    match result {
        Ok(response) => {
            println!("✓ OpenAI works with rstructor!");
            println!("  Message: {}", response.message);
            assert!(!response.message.is_empty(), "Message should not be empty");
        }
        Err(e) => {
            panic!(
                "OpenAI with rstructor failed (model: {}): {}",
                DEFAULT_OPENAI_MODEL, e
            );
        }
    }
}

/// Test that Gemini works with rstructor
#[tokio::test]
async fn test_gemini_with_rstructor() {
    require_api_key("GEMINI_API_KEY");

    let client = GeminiClient::from_env()
        .expect("Failed to build Gemini client")
        .model(DEFAULT_GEMINI_MODEL)
        .temperature(0.3)
        .thinking_level(rstructor::ThinkingLevel::Low);

    let result = client
        .materialize::<TestResponse>("Say hello in a friendly way")
        .await;

    match result {
        Ok(response) => {
            println!("✓ Gemini works with rstructor!");
            println!("  Message: {}", response.message);
            assert!(!response.message.is_empty(), "Message should not be empty");
        }
        Err(e) => {
            panic!(
                "Gemini with rstructor failed (model: {}): {}",
                DEFAULT_GEMINI_MODEL, e
            );
        }
    }
}

/// Test that the provider list is correct
#[test]
fn test_provider_list() {
    assert!(PROVIDERS.contains(&"claude"));
    assert!(PROVIDERS.contains(&"openai"));
    assert!(PROVIDERS.contains(&"gemini"));
}

/// Test thinking level parsing
#[test]
fn test_thinking_level() {
    assert_eq!(ThinkingLevel::parse("none"), ThinkingLevel::Off);
    assert_eq!(ThinkingLevel::parse("off"), ThinkingLevel::Off);
    assert_eq!(ThinkingLevel::parse("minimal"), ThinkingLevel::Minimal);
    assert_eq!(ThinkingLevel::parse("low"), ThinkingLevel::Low);
    assert_eq!(ThinkingLevel::parse("high"), ThinkingLevel::High);
    // Default for unknown values
    assert_eq!(ThinkingLevel::parse("unknown"), ThinkingLevel::Low);
}