Skip to main content

kiss_coding/
export.rs

1//! Session -> standalone HTML export.
2
3use crate::SessionManager;
4use anyhow::Result;
5use kiss_agent::AgentMessage;
6use std::path::Path;
7
8fn escape(text: &str) -> String {
9    text.replace('&', "&")
10        .replace('<', "&lt;")
11        .replace('>', "&gt;")
12}
13
14/// The system prompt and each tool's name and description, when a live
15/// session exports. Session files do not store them.
16pub type SystemContext = (String, Vec<(String, String)>);
17
18pub fn export_html(
19    manager: &SessionManager,
20    target: &Path,
21    system: Option<&SystemContext>,
22) -> Result<()> {
23    let mut body = String::new();
24    if let Some((prompt, tools)) = system {
25        let tools: String = tools
26            .iter()
27            .map(|(name, description)| format!("- {name}: {description}\n"))
28            .collect();
29        body.push_str(&format!(
30            "<details class=\"meta\"><summary>system prompt and tools</summary><pre>{}</pre><pre>{}</pre></details>\n",
31            escape(prompt),
32            escape(&tools)
33        ));
34    }
35    // The conversation as the model sees it, including compaction summaries
36    // and the messages a compaction kept.
37    for message in manager.context_messages() {
38        match message.as_ref() {
39            AgentMessage::User(u) => {
40                body.push_str(&format!(
41                    "<div class=\"msg user\"><h4>user</h4><pre>{}</pre></div>\n",
42                    escape(&u.content.as_text())
43                ));
44            }
45            AgentMessage::Assistant(a) => {
46                let mut inner = String::new();
47                for block in &a.content {
48                    match block {
49                        kiss_ai::ContentBlock::Text { text, .. } => {
50                            inner.push_str(&format!("<pre class=\"text\">{}</pre>", escape(text)));
51                        }
52                        kiss_ai::ContentBlock::Thinking { thinking, .. } => {
53                            inner.push_str(&format!(
54                                "<details><summary>thinking</summary><pre>{}</pre></details>",
55                                escape(thinking)
56                            ));
57                        }
58                        kiss_ai::ContentBlock::ToolCall(tc) => {
59                            inner.push_str(&format!(
60                                "<div class=\"toolcall\">→ {} <code>{}</code></div>",
61                                escape(&tc.name),
62                                escape(&tc.arguments.to_string())
63                            ));
64                        }
65                        kiss_ai::ContentBlock::Image { .. } => inner.push_str("<em>[image]</em>"),
66                    }
67                }
68                body.push_str(&format!(
69                    "<div class=\"msg assistant\"><h4>assistant ({})</h4>{inner}</div>\n",
70                    escape(&a.model)
71                ));
72            }
73            AgentMessage::ToolResult(t) => {
74                let text: String = t
75                    .content
76                    .iter()
77                    .filter_map(|c| match c {
78                        kiss_ai::ContentBlock::Text { text, .. } => Some(text.as_str()),
79                        _ => None,
80                    })
81                    .collect::<Vec<_>>()
82                    .join("\n");
83                let class = if t.is_error { "tool error" } else { "tool" };
84                body.push_str(&format!(
85                "<details class=\"{class}\"><summary>{} result</summary><pre>{}</pre></details>\n",
86                escape(&t.tool_name),
87                escape(&text)
88            ));
89            }
90            AgentMessage::CompactionSummary(c) => {
91                body.push_str(&format!("<details class=\"meta\"><summary>compaction summary</summary><pre>{}</pre></details>\n", escape(&c.summary)));
92            }
93            AgentMessage::BranchSummary(b) => {
94                body.push_str(&format!("<details class=\"meta\"><summary>branch summary</summary><pre>{}</pre></details>\n", escape(&b.summary)));
95            }
96            AgentMessage::BashExecution(b) => {
97                body.push_str(&format!(
98                    "<details class=\"tool\"><summary>! {}</summary><pre>{}</pre></details>\n",
99                    escape(&b.command),
100                    escape(&b.output)
101                ));
102            }
103            AgentMessage::Custom(c) => {
104                body.push_str(&format!(
105                    "<div class=\"msg meta\"><h4>{}</h4><pre>{}</pre></div>\n",
106                    escape(&c.custom_type),
107                    escape(&c.content.as_text())
108                ));
109            }
110        }
111    }
112
113    let title = manager
114        .session_name()
115        .unwrap_or_else(|| format!("kiss session {}", manager.session_id()));
116    let html = format!(
117        "<!doctype html><html><head><meta charset=\"utf-8\"><title>{title}</title><style>\n\
118        body{{font-family:ui-monospace,monospace;max-width:960px;margin:2rem auto;padding:0 1rem;background:#14141b;color:#d6d6e0}}\n\
119        .msg{{margin:1rem 0;padding:.6rem 1rem;border-radius:8px;background:#1d1d29}}\n\
120        .msg.user{{background:#232338;border-left:3px solid #7aa2f7}}\n\
121        h4{{margin:.1rem 0 .4rem;color:#7aa2f7;font-size:.8rem;text-transform:uppercase}}\n\
122        pre{{white-space:pre-wrap;word-break:break-word;margin:.2rem 0}}\n\
123        details{{margin:.5rem 0;padding:.4rem .8rem;background:#191924;border-radius:6px}}\n\
124        details.error{{border-left:3px solid #f7768e}}\n\
125        summary{{cursor:pointer;color:#8b8ba0}}\n\
126        .toolcall{{color:#9ece6a;margin:.2rem 0}}\n\
127        </style></head><body><h1>{title}</h1>\n{body}</body></html>",
128        title = escape(&title),
129    );
130    if let Some(parent) = target.parent() {
131        std::fs::create_dir_all(parent)?;
132    }
133    std::fs::write(target, html)?;
134    Ok(())
135}
136
137pub fn export_jsonl(manager: &SessionManager, target: &Path) -> Result<()> {
138    if let Some(parent) = target.parent() {
139        std::fs::create_dir_all(parent)?;
140    }
141    std::fs::write(target, manager.to_jsonl()?)?;
142    Ok(())
143}
144
145pub fn export_session(
146    manager: &SessionManager,
147    target: &Path,
148    system: Option<&SystemContext>,
149) -> Result<()> {
150    if target.extension().and_then(|extension| extension.to_str()) == Some("jsonl") {
151        export_jsonl(manager, target)
152    } else {
153        export_html(manager, target, system)
154    }
155}
156
157#[cfg(test)]
158mod tests {
159    use super::*;
160    use std::path::Path;
161
162    #[test]
163    fn jsonl_target_uses_portable_session_format() {
164        let dir = tempfile::tempdir().unwrap();
165        let target = dir.path().join("portable.jsonl");
166        let manager = SessionManager::in_memory(Path::new("/tmp/project"));
167        export_session(&manager, &target, None).unwrap();
168        let reopened = SessionManager::open(&target).unwrap();
169        assert_eq!(reopened.session_id(), manager.session_id());
170    }
171
172    #[test]
173    fn html_export_keeps_messages_a_compaction_retained() {
174        let dir = tempfile::tempdir().unwrap();
175        let target = dir.path().join("session.html");
176        let mut manager = SessionManager::in_memory(Path::new("/tmp/project"));
177        manager
178            .append_message(AgentMessage::user("summarized away"))
179            .unwrap();
180        manager
181            .append_compaction(
182                "the summary".into(),
183                100,
184                vec![AgentMessage::user("kept after compaction")],
185                None,
186                None,
187            )
188            .unwrap();
189        export_html(&manager, &target, None).unwrap();
190        let html = std::fs::read_to_string(&target).unwrap();
191        assert!(html.contains("the summary"));
192        assert!(html.contains("kept after compaction"));
193    }
194
195    #[test]
196    fn html_export_shows_the_system_prompt_and_tools() {
197        let dir = tempfile::tempdir().unwrap();
198        let target = dir.path().join("session.html");
199        let manager = SessionManager::in_memory(Path::new("/tmp/project"));
200        let system = (
201            "You are <kiss>".to_string(),
202            vec![("read".to_string(), "Read a file".to_string())],
203        );
204        export_session(&manager, &target, Some(&system)).unwrap();
205        let html = std::fs::read_to_string(&target).unwrap();
206        assert!(html.contains("system prompt and tools"));
207        assert!(html.contains("You are &lt;kiss&gt;"));
208        assert!(html.contains("- read: Read a file"));
209    }
210}