claude_assets_core 1.4.1

Layer 1 domain logic: symlink-based Claude Code artifact installer
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

//! Artifact kind and layout classification.
//!
//! Defines all supported Claude Code artifact types with their canonical
//! source and target directory mappings.

/// Layout of an artifact in the filesystem.
///
/// `File` artifacts are single files with a known extension.
/// `Directory` artifacts are entire subdirectory trees.
#[ derive( Debug, Clone, Copy, PartialEq, Eq ) ]
pub enum ArtifactLayout
{
  /// A single file (e.g., `.md`, `.yaml`).
  File,
  /// An entire directory tree.
  Directory,
}

/// A Claude Code artifact kind supported by the installer.
///
/// Each variant maps to a dedicated subdirectory in both the source
/// (`$PRO_CLAUDE/<subdir>/`) and target (`.claude/<subdir>/`) trees.
#[ derive( Debug, Clone, Copy, PartialEq, Eq ) ]
pub enum ArtifactKind
{
  /// Unconditional rules and coding guidelines (`rules/*.md`).
  Rule,
  /// User-invocable slash commands (`commands/*.md`).
  Command,
  /// Specialised subagent definitions (`agents/*.md`).
  Agent,
  /// Multi-step procedural skill packages (`skills/<name>/`).
  Skill,
  /// Plugin directory bundles (`plugins/<name>/`).
  Plugin,
  /// Event-triggered hook configurations (`hooks/*.yaml`).
  Hook,
}

impl ArtifactKind
{
  /// All supported artifact kinds in display order.
  #[ must_use ]
  #[ inline ]
  pub fn all() -> &'static [ Self ]
  {
    &[ Self::Rule, Self::Command, Self::Agent, Self::Skill, Self::Plugin, Self::Hook ]
  }

  /// Canonical lowercase name used in CLI arguments (`kind::rule`).
  #[ must_use ]
  #[ inline ]
  pub fn as_str( self ) -> &'static str
  {
    match self
    {
      Self::Rule    => "rule",
      Self::Command => "command",
      Self::Agent   => "agent",
      Self::Skill   => "skill",
      Self::Plugin  => "plugin",
      Self::Hook    => "hook",
    }
  }

  /// Parse a canonical kind name; returns `None` for unknown strings.
  ///
  /// Accepts the same names produced by [`as_str()`](Self::as_str).
  #[ must_use ]
  #[ inline ]
  pub fn from_name( s : &str ) -> Option< Self >
  {
    match s
    {
      "rule"    => Some( Self::Rule ),
      "command" => Some( Self::Command ),
      "agent"   => Some( Self::Agent ),
      "skill"   => Some( Self::Skill ),
      "plugin"  => Some( Self::Plugin ),
      "hook"    => Some( Self::Hook ),
      _         => None,
    }
  }

  /// Subdirectory name inside `$PRO_CLAUDE/` that holds this kind's sources.
  #[ must_use ]
  #[ inline ]
  pub fn source_subdir( self ) -> &'static str
  {
    match self
    {
      Self::Rule    => "rules",
      Self::Command => "commands",
      Self::Agent   => "agents",
      Self::Skill   => "skills",
      Self::Plugin  => "plugins",
      Self::Hook    => "hooks",
    }
  }

  /// Subdirectory name inside `.claude/` that receives installed symlinks.
  #[ must_use ]
  #[ inline ]
  pub fn target_subdir( self ) -> &'static str
  {
    match self
    {
      Self::Rule    => "rules",
      Self::Command => "commands",
      Self::Agent   => "agents",
      Self::Skill   => "skills",
      Self::Plugin  => "plugins",
      Self::Hook    => "hooks",
    }
  }

  /// How this artifact kind is stored in the filesystem.
  #[ must_use ]
  #[ inline ]
  pub fn layout( self ) -> ArtifactLayout
  {
    match self
    {
      Self::Rule | Self::Command | Self::Agent | Self::Hook => ArtifactLayout::File,
      Self::Skill | Self::Plugin                            => ArtifactLayout::Directory,
    }
  }

  /// File extension for `File`-layout kinds; `None` for `Directory`-layout kinds.
  #[ must_use ]
  #[ inline ]
  pub fn file_extension( self ) -> Option< &'static str >
  {
    match self
    {
      Self::Rule | Self::Command | Self::Agent => Some( "md" ),
      Self::Hook                               => Some( "yaml" ),
      Self::Skill | Self::Plugin               => None,
    }
  }
}