agent-playground 0.1.0

CLI for running agent in a temporary playground.
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

//! JSON Schema site generation utilities.
//!
//! This module materializes schema files for the public configuration models
//! and writes a tiny static index page that can be hosted as documentation.

use std::{
    fs,
    path::{Path, PathBuf},
};

use anyhow::{Context, Result};
use serde::Serialize;

use crate::config::{PlaygroundConfigFile, RootConfigFile};

const ROOT_SCHEMA_FILE_NAME: &str = "root-config.schema.json";
const PLAYGROUND_SCHEMA_FILE_NAME: &str = "playground-config.schema.json";

/// Generates JSON Schema artifacts and an index page into `output_dir`.
///
/// The command writes:
///
/// - `schemas/root-config.schema.json`
/// - `schemas/playground-config.schema.json`
/// - `index.html`
///
/// Existing files at those paths are overwritten.
///
/// # Errors
///
/// Returns an error when output directories cannot be created, schema values
/// cannot be serialized, or files cannot be written.
pub fn write_schema_site(output_dir: &Path) -> Result<()> {
    let schemas_dir = output_dir.join("schemas");
    fs::create_dir_all(&schemas_dir)
        .with_context(|| format!("failed to create {}", schemas_dir.display()))?;

    write_json_file(
        &schemas_dir.join(ROOT_SCHEMA_FILE_NAME),
        &RootConfigFile::json_schema(),
    )?;
    write_json_file(
        &schemas_dir.join(PLAYGROUND_SCHEMA_FILE_NAME),
        &PlaygroundConfigFile::json_schema(),
    )?;
    fs::write(output_dir.join("index.html"), render_schema_index()).with_context(|| {
        format!(
            "failed to write {}",
            output_dir.join("index.html").display()
        )
    })?;

    Ok(())
}

/// Returns the default output location used for generated schema artifacts.
///
/// The returned path is relative to the current working directory:
/// `target/schema-site`.
pub fn default_schema_site_dir() -> PathBuf {
    PathBuf::from("target").join("schema-site")
}

fn write_json_file<T>(path: &Path, value: &T) -> Result<()>
where
    T: Serialize,
{
    let content =
        serde_json::to_string_pretty(value).context("failed to serialize schema to JSON")?;
    fs::write(path, content).with_context(|| format!("failed to write {}", path.display()))
}

fn render_schema_index() -> &'static str {
    r#"<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>agent-playground JSON Schemas</title>
    <style>
      :root {
        color-scheme: light dark;
        font-family: ui-sans-serif, system-ui, sans-serif;
      }
      body {
        margin: 0 auto;
        max-width: 48rem;
        padding: 3rem 1.25rem;
        line-height: 1.6;
      }
      code {
        font-family: ui-monospace, SFMono-Regular, monospace;
      }
    </style>
  </head>
  <body>
    <h1>agent-playground JSON Schemas</h1>
    <p>Generated from the Rust config file models in this repository.</p>
    <ul>
      <li><a href="./schemas/root-config.schema.json"><code>root-config.schema.json</code></a></li>
      <li><a href="./schemas/playground-config.schema.json"><code>playground-config.schema.json</code></a></li>
    </ul>
  </body>
</html>
"#
}

#[cfg(test)]
mod tests {
    use anyhow::Result;
    use serde_json::Value;
    use tempfile::tempdir;

    use super::{PLAYGROUND_SCHEMA_FILE_NAME, ROOT_SCHEMA_FILE_NAME, write_schema_site};

    #[test]
    fn writes_schema_site_artifacts() -> Result<()> {
        let output_dir = tempdir()?;

        write_schema_site(output_dir.path())?;

        let root_schema_path = output_dir
            .path()
            .join("schemas")
            .join(ROOT_SCHEMA_FILE_NAME);
        let playground_schema_path = output_dir
            .path()
            .join("schemas")
            .join(PLAYGROUND_SCHEMA_FILE_NAME);
        let index_path = output_dir.path().join("index.html");

        assert!(root_schema_path.is_file());
        assert!(playground_schema_path.is_file());
        assert!(index_path.is_file());

        let root_schema: Value = serde_json::from_str(&std::fs::read_to_string(root_schema_path)?)?;
        let playground_schema: Value =
            serde_json::from_str(&std::fs::read_to_string(playground_schema_path)?)?;
        let index_html = std::fs::read_to_string(index_path)?;

        assert_eq!(root_schema["type"], Value::String("object".to_string()));
        assert_eq!(
            playground_schema["type"],
            Value::String("object".to_string())
        );
        assert!(index_html.contains("root-config.schema.json"));
        assert!(index_html.contains("playground-config.schema.json"));

        Ok(())
    }
}