historion 0.1.1

Record and search shell history stored in plain text logs
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

use crate::entry::HistoryEntry;

pub fn help_text() -> &'static str {
    r#"Usage:
  hy <query> [--folder PATH] [--today] [--since DAYS] [--limit N] [--json] [-i|--ignore-case]
  hy record --cwd PATH --command COMMAND [--history-id ID] [--shell bash|zsh]
  hy init <bash|zsh>
  hy install <bash|zsh>

Commands:
  <query>   Search command history for a substring
  record    Append a shell command to the daily history log
  init      Print shell integration for bash or zsh
  install   Install shell integration into the rc file
"#
}

pub fn render_entries(entries: &[HistoryEntry]) -> String {
    let mut output = String::new();

    for entry in entries {
        output.push_str(&entry.format_escaped_tsv());
        output.push('\n');
    }

    output
}

pub fn render_entries_as_json(entries: &[HistoryEntry]) -> String {
    let mut output = String::from("[");

    for (index, entry) in entries.iter().enumerate() {
        if index > 0 {
            output.push(',');
        }

        output.push_str("{\"timestamp\":\"");
        output.push_str(&escape_json(&entry.timestamp));
        output.push_str("\",\"cwd\":\"");
        output.push_str(&escape_json(&entry.cwd.to_string_lossy()));
        output.push_str("\",\"command\":\"");
        output.push_str(&escape_json(&entry.command));
        output.push_str("\",\"file\":\"");
        output.push_str(&escape_json(&entry.source.file.to_string_lossy()));
        output.push_str("\",\"line\":");
        output.push_str(&entry.source.line_number.to_string());
        output.push('}');
    }

    output.push_str("]\n");
    output
}

fn escape_json(value: &str) -> String {
    let mut escaped = String::with_capacity(value.len());

    for ch in value.chars() {
        match ch {
            '"' => escaped.push_str("\\\""),
            '\\' => escaped.push_str("\\\\"),
            '\n' => escaped.push_str("\\n"),
            '\r' => escaped.push_str("\\r"),
            '\t' => escaped.push_str("\\t"),
            other => escaped.push(other),
        }
    }

    escaped
}

#[cfg(test)]
mod tests {
    use super::{render_entries, render_entries_as_json};
    use crate::entry::{EntrySource, HistoryEntry};
    use std::path::PathBuf;

    #[test]
    fn render_entries_uses_one_line_per_entry() {
        let entries = vec![HistoryEntry {
            timestamp: String::from("2026-04-19T10:23:45+0100"),
            cwd: PathBuf::from("/tmp/demo"),
            command: String::from("cargo test"),
            source: EntrySource {
                file: PathBuf::from("/tmp/log.log"),
                line_number: 1,
            },
        }];

        assert_eq!(
            render_entries(&entries),
            "2026-04-19T10:23:45+0100\t/tmp/demo\tcargo test\n"
        );
    }

    #[test]
    fn render_entries_as_json_returns_machine_readable_output() {
        let entries = vec![HistoryEntry {
            timestamp: String::from("2026-04-19T10:23:45+0100"),
            cwd: PathBuf::from("/tmp/demo"),
            command: String::from("printf \"hi\"\n"),
            source: EntrySource {
                file: PathBuf::from("/tmp/log.log"),
                line_number: 3,
            },
        }];

        assert_eq!(
            render_entries_as_json(&entries),
            "[{\"timestamp\":\"2026-04-19T10:23:45+0100\",\"cwd\":\"/tmp/demo\",\"command\":\"printf \\\"hi\\\"\\n\",\"file\":\"/tmp/log.log\",\"line\":3}]\n"
        );
    }
}