claude-code 0.1.2

A Rust library for executing Claude Code CLI
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

use std::io;

/// Error types for claude-code.
#[derive(Debug, thiserror::Error)]
#[non_exhaustive]
pub enum ClaudeError {
    /// `claude` command not found in PATH.
    #[error(
        "claude CLI not found in PATH. Install it from https://docs.anthropic.com/en/docs/claude-code"
    )]
    CliNotFound,

    /// CLI exited with a non-zero status code.
    #[error("claude exited with code {code}: {stderr}")]
    NonZeroExit {
        /// Exit code.
        code: i32,
        /// Captured stderr content.
        stderr: String,
    },

    /// Failed to deserialize JSON / stream-json response.
    #[error("failed to parse response")]
    ParseError(#[from] serde_json::Error),

    /// Request timed out.
    #[error("request timed out")]
    Timeout,

    /// I/O error from process spawn, stdout/stderr reads, etc.
    #[error(transparent)]
    Io(#[from] io::Error),

    /// CLI succeeded but the `result` field could not be deserialized
    /// into the target type.
    #[error("failed to deserialize structured output: {source}")]
    StructuredOutputError {
        /// Raw result string from CLI.
        raw_result: String,
        /// Deserialization error.
        source: serde_json::Error,
    },
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn cli_not_found_message() {
        let err = ClaudeError::CliNotFound;
        assert_eq!(
            err.to_string(),
            "claude CLI not found in PATH. Install it from https://docs.anthropic.com/en/docs/claude-code"
        );
    }

    #[test]
    fn non_zero_exit_message() {
        let err = ClaudeError::NonZeroExit {
            code: 1,
            stderr: "something went wrong".into(),
        };
        assert_eq!(
            err.to_string(),
            "claude exited with code 1: something went wrong"
        );
    }

    #[test]
    fn timeout_message() {
        let err = ClaudeError::Timeout;
        assert_eq!(err.to_string(), "request timed out");
    }

    #[test]
    fn from_io_error() {
        let io_err = io::Error::new(io::ErrorKind::Other, "disk full");
        let err = ClaudeError::from(io_err);
        assert!(matches!(err, ClaudeError::Io(_)));
        assert_eq!(err.to_string(), "disk full");
    }

    #[test]
    fn from_serde_error() {
        let serde_err = serde_json::from_str::<serde_json::Value>("invalid").unwrap_err();
        let err = ClaudeError::from(serde_err);
        assert!(matches!(err, ClaudeError::ParseError(_)));
    }

    #[test]
    fn structured_output_error_message() {
        let serde_err = serde_json::from_str::<serde_json::Value>("not json").unwrap_err();
        let err = ClaudeError::StructuredOutputError {
            raw_result: "raw text here".into(),
            source: serde_err,
        };
        assert!(
            err.to_string()
                .starts_with("failed to deserialize structured output:")
        );
    }

    #[test]
    fn structured_output_error_preserves_raw_result() {
        let serde_err = serde_json::from_str::<serde_json::Value>("not json").unwrap_err();
        let err = ClaudeError::StructuredOutputError {
            raw_result: "the raw output".into(),
            source: serde_err,
        };
        match err {
            ClaudeError::StructuredOutputError { raw_result, .. } => {
                assert_eq!(raw_result, "the raw output");
            }
            _ => panic!("expected StructuredOutputError"),
        }
    }
}