looprs 0.4.0

Concise coding assistant REPL — core library
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

use crate::{jj, kan};
use serde::{Deserialize, Serialize};

/// Context available at session start
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SessionContext {
    pub jj_status: Option<jj::JjStatus>,
    pub jj_recent_commits: Option<Vec<String>>,
    pub kan_status: Option<kan::KanStatus>,
}

impl SessionContext {
    /// Collect context from jj and kan if available
    pub fn collect() -> Self {
        SessionContext {
            jj_status: jj::get_status(),
            jj_recent_commits: jj::get_recent_commits(5),
            kan_status: kan::get_status(),
        }
    }

    /// Format context as a human-readable string for prompt injection
    pub fn format_for_prompt(&self) -> Option<String> {
        let mut parts = Vec::new();

        // Format jj status if available
        if let Some(ref status) = self.jj_status {
            parts.push(format!(
                "## Repository Status\n- Branch: {}\n- Commit: {}\n- Description: {}",
                status.branch, status.commit, status.description
            ));
        }

        // Format recent commits if available
        if let Some(ref commits) = self.jj_recent_commits {
            let commits_str = commits
                .iter()
                .map(|c| format!("  - {c}"))
                .collect::<Vec<_>>()
                .join("\n");
            parts.push(format!("## Recent Commits\n{commits_str}"));
        }

        // Format kan status if available
        if let Some(ref kan) = self.kan_status {
            let columns_str = kan
                .by_column
                .iter()
                .map(|col| format!("  - {}: {}", col.name, col.count))
                .collect::<Vec<_>>()
                .join("\n");
            parts.push(format!(
                "## Kanban Board\n  Total tasks: {}\n{columns_str}",
                kan.total_tasks
            ));
        }

        if parts.is_empty() {
            None
        } else {
            Some(parts.join("\n\n"))
        }
    }

    /// Check if there is any context available
    pub fn is_empty(&self) -> bool {
        self.jj_status.is_none() && self.jj_recent_commits.is_none() && self.kan_status.is_none()
    }
}

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

    #[test]
    fn test_session_context_collect() {
        // Should work even with no jj repo
        let ctx = SessionContext::collect();
        assert!(ctx.is_empty()); // No jj in current env
    }

    #[test]
    fn test_session_context_format_empty() {
        let ctx = SessionContext {
            jj_status: None,
            jj_recent_commits: None,
            kan_status: None,
        };
        assert!(ctx.format_for_prompt().is_none());
    }

    #[test]
    fn test_session_context_format_with_jj() {
        let ctx = SessionContext {
            jj_status: Some(jj::JjStatus {
                branch: "main".to_string(),
                commit: "abc123".to_string(),
                description: "Initial commit".to_string(),
            }),
            jj_recent_commits: None,
            kan_status: None,
        };

        let text = ctx.format_for_prompt().expect("expected formatted prompt");
        assert!(text.contains("main"));
        assert!(text.contains("abc123"));
    }
}