1. 1//! CLI handlers for `vak entities` (knowledge graph inspection & management).
2. 2
3. 3use std::path::PathBuf;
4. 4
5. 5use vak_core::Core;
6. 6use vak_core::entities;
7. 7
8. 8pub fn run_entities(cwd: PathBuf, action: Option<crate::cli::EntitiesAction>) -> i32 {
9. 9 let core = match Core::new(cwd) {
10. 10 Ok(c) => c,
11. 11 Err(e) => {
12. 12 eprintln!("error: {e}");
13. 13 return 2;
14. 14 }
15. 15 };
16. 16 let home = core.sessions_home();
17. 17 let workspace = core.cwd().clone();
18. 18
19. 19 match action.unwrap_or(crate::cli::EntitiesAction::List { global: false }) {
20. 20 crate::cli::EntitiesAction::List { global } => {
21. 21 let cwd_opt = if global {
22. 22 None
23. 23 } else {
24. 24 Some(workspace.as_path())
25. 25 };
26. 26 let list = entities::list_entities(&home, cwd_opt);
27. 27 if list.is_empty() {
28. 28 println!(
29. 29 "No entities recorded in {} knowledge graph.",
30. 30 if global { "global" } else { "workspace" }
31. 31 );
32. 32 return 0;
33. 33 }
34. 34 println!(
35. 35 "Entities in {} knowledge graph ({} total):\n",
36. 36 if global { "global" } else { "workspace" },
37. 37 list.len()
38. 38 );
39. 39 for e in list {
40. 40 println!(
41. 41 "- [{}] {} (`{}`): {}",
42. 42 e.entity_type, e.name, e.id, e.summary
43. 43 );
44. 44 if !e.attributes.is_empty() {
45. 45 let attrs: Vec<_> = e
46. 46 .attributes
47. 47 .iter()
48. 48 .map(|(k, v)| format!("{k}={v}"))
49. 49 .collect();
50. 50 println!(" attrs: {}", attrs.join(", "));
51. 51 }
52. 52 if !e.relations.is_empty() {
53. 53 let rels: Vec<_> = e
54. 54 .relations
55. 55 .iter()
56. 56 .map(|r| format!("{} -> {}", r.relation, r.target_entity_id))
57. 57 .collect();
58. 58 println!(" relations: {}", rels.join(", "));
59. 59 }
60. 60 }
61. 61 0
62. 62 }
63. 63 crate::cli::EntitiesAction::Search {
64. 64 query,
65. 65 entity_type,
66. 66 global,
67. 67 } => {
68. 68 let cwd_opt = if global {
69. 69 None
70. 70 } else {
71. 71 Some(workspace.as_path())
72. 72 };
73. 73 let mut results = entities::search_entities(&home, cwd_opt, &query);
74. 74 if let Some(filter) = entity_type {
75. 75 results.retain(|e| e.entity_type.eq_ignore_ascii_case(&filter));
76. 76 }
77. 77 if results.is_empty() {
78. 78 println!("No matching entities found.");
79. 79 return 0;
80. 80 }
81. 81 println!("Found {} matching entities:\n", results.len());
82. 82 for e in results {
83. 83 println!(
84. 84 "- [{}] {} (`{}`): {}",
85. 85 e.entity_type, e.name, e.id, e.summary
86. 86 );
87. 87 }
88. 88 0
89. 89 }
90. 90 crate::cli::EntitiesAction::Get { id, global } => {
91. 91 let cwd_opt = if global {
92. 92 None
93. 93 } else {
94. 94 Some(workspace.as_path())
95. 95 };
96. 96 match entities::get_entity(&home, cwd_opt, &id) {
97. 97 Some(e) => {
98. 98 println!("ID: {}", e.id);
99. 99 println!("Name: {}", e.name);
100. 100 println!("Type: {}", e.entity_type);
101. 101 println!("Summary: {}", e.summary);
102. 102 println!("Updated: {}", e.updated_at);
103. 103 if !e.attributes.is_empty() {
104. 104 println!("Attributes:");
105. 105 for (k, v) in e.attributes {
106. 106 println!(" {k}: {v}");
107. 107 }
108. 108 }
109. 109 if !e.relations.is_empty() {
110. 110 println!("Relations:");
111. 111 for r in e.relations {
112. 112 println!(" {} -> {}", r.relation, r.target_entity_id);
113. 113 }
114. 114 }
115. 115 0
116. 116 }
117. 117 None => {
118. 118 eprintln!("entity '{id}' not found");
119. 119 1
120. 120 }
121. 121 }
122. 122 }
123. 123 crate::cli::EntitiesAction::Delete { id, global } => {
124. 124 let cwd_opt = if global {
125. 125 None
126. 126 } else {
127. 127 Some(workspace.as_path())
128. 128 };
129. 129 match entities::delete_entity(&home, cwd_opt, &id) {
130. 130 Ok(true) => {
131. 131 println!("deleted entity '{id}'");
132. 132 0
133. 133 }
134. 134 Ok(false) => {
135. 135 eprintln!("entity '{id}' not found");
136. 136 1
137. 137 }
138. 138 Err(e) => {
139. 139 eprintln!("error: {e}");
140. 140 1
141. 141 }
142. 142 }
143. 143 }
144. 144 }
145. 145}
146. 146