1. 1//! CLI handlers for `vak agents` (managing specialist agents & domain templates).
2. 2
3. 3use std::path::PathBuf;
4. 4
5. 5use vak_server::agents;
6. 6
7. 7use crate::cli::AgentsAction;
8. 8
9. 9pub fn run_agents(cwd: PathBuf, action: Option<AgentsAction>) -> i32 {
10. 10 let shared = vak_config::paths::default_workspace();
11. 11
12. 12 match action.unwrap_or(AgentsAction::List { global: false }) {
13. 13 AgentsAction::List { global } => {
14. 14 let root = if global {
15. 15 shared.as_path()
16. 16 } else {
17. 17 cwd.as_path()
18. 18 };
19. 19 let list = match agents::load(root) {
20. 20 Ok(l) => l,
21. 21 Err(e) => {
22. 22 eprintln!("error reading agents: {e}");
23. 23 return 1;
24. 24 }
25. 25 };
26. 26 if list.is_empty() {
27. 27 println!(
28. 28 "No agents configured in {} scope.",
29. 29 if global { "global" } else { "workspace" }
30. 30 );
31. 31 println!(
32. 32 "Hint: run 'vak agents templates' or 'vak agents init --template <name> --id <id>' to create one."
33. 33 );
34. 34 return 0;
35. 35 }
36. 36 println!(
37. 37 "Configured Agents in {} scope ({} total):\n",
38. 38 if global { "global" } else { "workspace" },
39. 39 list.len()
40. 40 );
41. 41 for a in list {
42. 42 println!("- `{}` ({}): {}", a.id, a.name, a.behaviour);
43. 43 if !a.personality.is_empty() {
44. 44 println!(" personality: {}", a.personality);
45. 45 }
46. 46 if !a.responsibilities.is_empty() {
47. 47 println!(" focus: {}", a.responsibilities);
48. 48 }
49. 49 }
50. 50 0
51. 51 }
52. 52 AgentsAction::Templates => {
53. 53 let templates = agents::builtin_templates();
54. 54 println!(
55. 55 "Available Universal Domain Specialist Templates ({} total):\n",
56. 56 templates.len()
57. 57 );
58. 58 for t in templates {
59. 59 println!("- `{}` — {} [Domain: {}]", t.template_id, t.name, t.domain);
60. 60 println!(" {}", t.description);
61. 61 println!(
62. 62 " Character: {} | Voice: {} | Animation: {}",
63. 63 t.character, t.voice, t.animation
64. 64 );
65. 65 println!(" Focus: {}", t.responsibilities);
66. 66 println!();
67. 67 }
68. 68 println!("To instantiate an agent from a template:");
69. 69 println!(
70. 70 " vak agents init --template <template_id> --id <unique_agent_id> [--name <display_name>] [--global]"
71. 71 );
72. 72 0
73. 73 }
74. 74 AgentsAction::Init {
75. 75 template,
76. 76 id,
77. 77 name,
78. 78 global,
79. 79 } => {
80. 80 let Some(tmpl) = agents::find_template(&template) else {
81. 81 eprintln!("error: unknown template '{template}'");
82. 82 eprintln!("Run 'vak agents templates' to view available archetypes.");
83. 83 return 1;
84. 84 };
85. 85
86. 86 let root = if global {
87. 87 shared.as_path()
88. 88 } else {
89. 89 cwd.as_path()
90. 90 };
91. 91 let mut existing = match agents::load(root) {
92. 92 Ok(l) => l,
93. 93 Err(e) => {
94. 94 eprintln!("error reading agents: {e}");
95. 95 return 1;
96. 96 }
97. 97 };
98. 98
99. 99 if existing.iter().any(|a| a.id == id) {
100. 100 eprintln!(
101. 101 "error: agent with id '{id}' already exists in {} scope",
102. 102 if global { "global" } else { "workspace" }
103. 103 );
104. 104 return 1;
105. 105 }
106. 106
107. 107 let new_agent = tmpl.to_agent_definition(&id, name.as_deref());
108. 108 existing.push(new_agent.clone());
109. 109
110. 110 match agents::save(root, &existing, vak_core::trust::is_trusted(root)) {
111. 111 Ok(_) => {
112. 112 println!(
113. 113 "Created agent '{}' ({}) in {} scope.",
114. 114 new_agent.id,
115. 115 new_agent.name,
116. 116 if global { "global" } else { "workspace" }
117. 117 );
118. 118 0
119. 119 }
120. 120 Err(e) => {
121. 121 eprintln!("error saving agent: {e}");
122. 122 1
123. 123 }
124. 124 }
125. 125 }
126. 126 }
127. 127}
128. 128