wtp-mcp-rs 0.1.0

MCP server for WTP - Git Worktree Plus
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

//! Shared data types used across tools, resources, and parsers.

use schemars::JsonSchema;
use serde::Serialize;

use crate::config::SecurityPolicy;

/// Worktree entry as reported by `wtp list`.
#[derive(Debug, Clone, Serialize, JsonSchema)]
#[schemars(
    description = "Worktree entry as reported by `wtp list`. Each worktree represents an isolated folder tied to a branch."
)]
pub struct Worktree {
    /// Worktree selector accepted by `wtp` commands (typically a branch name).
    #[schemars(
        description = "Worktree selector accepted by wtp commands (typically a branch name)."
    )]
    pub name: String,
    /// Path as printed by `wtp` (may be relative or abbreviated).
    #[schemars(description = "Path as printed by wtp (may be relative or abbreviated).")]
    pub path: String,
    /// Git branch checked out in this worktree.
    #[schemars(description = "Git branch checked out in this worktree.")]
    pub branch: String,
    /// HEAD commit hash for this worktree.
    #[schemars(description = "HEAD commit hash for this worktree.")]
    pub head: String,
    /// True if this is the main worktree.
    #[schemars(description = "True if this is the main worktree.")]
    pub is_main: bool,
}

/// Worktree entry with a resolved absolute path.
#[derive(Debug, Clone, Serialize, JsonSchema)]
#[schemars(description = "Worktree entry with resolved absolute path for direct navigation.")]
pub struct ResolvedWorktree {
    /// Worktree selector accepted by `wtp` commands (typically a branch name).
    #[schemars(
        description = "Worktree selector accepted by wtp commands (typically a branch name)."
    )]
    pub name: String,
    /// Path as printed by `wtp` (may be relative or abbreviated).
    #[schemars(description = "Path as printed by wtp (may be relative or abbreviated).")]
    pub path: String,
    /// Git branch checked out in this worktree.
    #[schemars(description = "Git branch checked out in this worktree.")]
    pub branch: String,
    /// HEAD commit hash for this worktree.
    #[schemars(description = "HEAD commit hash for this worktree.")]
    pub head: String,
    /// True if this is the main worktree.
    #[schemars(description = "True if this is the main worktree.")]
    pub is_main: bool,
    /// Absolute filesystem path for this worktree.
    #[schemars(description = "Absolute filesystem path for this worktree.")]
    pub absolute_path: String,
}

/// Summary of security policy flags exposed via resources.
#[derive(Debug, Clone, Serialize, JsonSchema)]
pub struct SecuritySummary {
    /// True when hooks are allowed by policy.
    pub allow_hooks: bool,
    /// True when branch deletion is allowed by policy.
    pub allow_branch_delete: bool,
}

/// Repository overview resource.
#[derive(Debug, Clone, Serialize, JsonSchema)]
pub struct Overview {
    /// Absolute path of the main worktree, if available.
    pub repo_root: String,
    /// `wtp` version string if resolved.
    pub wtp_version: Option<String>,
    /// Resolved worktree inventory.
    pub worktrees: Vec<ResolvedWorktree>,
    /// Security policy summary for this repo.
    pub security: SecuritySummary,
}

impl From<&SecurityPolicy> for SecuritySummary {
    fn from(policy: &SecurityPolicy) -> Self {
        Self {
            allow_hooks: policy.allow_hooks,
            allow_branch_delete: policy.allow_branch_delete,
        }
    }
}

impl From<Worktree> for ResolvedWorktree {
    fn from(wt: Worktree) -> Self {
        Self {
            name: wt.name,
            absolute_path: wt.path.clone(),
            path: wt.path,
            branch: wt.branch,
            head: wt.head,
            is_main: wt.is_main,
        }
    }
}

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

    #[test]
    fn security_summary_from_policy() {
        let policy = SecurityPolicy {
            allow_hooks: true,
            allow_branch_delete: false,
        };
        let summary = SecuritySummary::from(&policy);
        assert!(summary.allow_hooks);
        assert!(!summary.allow_branch_delete);
    }

    #[test]
    fn resolved_worktree_from_worktree() {
        let worktree = Worktree {
            name: "wt".to_string(),
            path: "path".to_string(),
            branch: "main".to_string(),
            head: "abc123".to_string(),
            is_main: true,
        };

        let resolved = ResolvedWorktree::from(worktree);
        assert_eq!(resolved.name, "wt");
        assert_eq!(resolved.path, "path");
        assert_eq!(resolved.absolute_path, "path");
        assert!(resolved.is_main);
    }
}