1use crate::core::session::SessionState;
2use crate::core::workflow::{self, WorkflowRun, WorkflowSpec};
3use chrono::Utc;
4use serde_json::Value;
5
6pub fn handle_with_session(
7 args: Option<&serde_json::Map<String, Value>>,
8 session: &mut SessionState,
9) -> String {
10 let action = get_str(args, "action").unwrap_or_else(|| "status".to_string());
11
12 match action.as_str() {
13 "start" => handle_start(args),
14 "status" => handle_status(session),
15 "stop" => handle_stop(),
16 "transition" => handle_transition(args, session),
17 "complete" => handle_complete(args, session),
18 "evidence_add" => handle_evidence_add(args, session),
19 "evidence_list" => handle_evidence_list(session),
20 _ => "Unknown action. Use: start, status, transition, complete, evidence_add, evidence_list, stop".to_string(),
21 }
22}
23
24fn handle_start(args: Option<&serde_json::Map<String, Value>>) -> String {
25 let spec_json = get_str(args, "spec");
26 let name_override = get_str(args, "name");
27
28 let mut spec: WorkflowSpec = match spec_json.as_deref() {
29 Some(s) if !s.trim().is_empty() => match serde_json::from_str::<WorkflowSpec>(s) {
30 Ok(v) => v,
31 Err(e) => return format!("Invalid spec JSON: {e}"),
32 },
33 _ => WorkflowSpec::builtin_plan_code_test(),
34 };
35
36 if let Some(name) = name_override {
37 if !name.trim().is_empty() {
38 spec.name = name;
39 }
40 }
41
42 if let Err(e) = workflow::validate_spec(&spec) {
43 return format!("Invalid WorkflowSpec: {e}");
44 }
45
46 let run = WorkflowRun::new(spec);
47 if let Err(e) = workflow::save_active(&run) {
48 return format!("Failed to save workflow: {e}");
49 }
50
51 format!(
52 "Workflow started: {}\n State: {}\n Started: {}",
53 run.spec.name, run.current, run.started_at
54 )
55}
56
57fn handle_status(session: &SessionState) -> String {
58 let Ok(active) = workflow::load_active() else {
59 return "Error: failed to load active workflow.".to_string();
60 };
61 let Some(run) = active else {
62 return "No active workflow. Use action=start to begin.".to_string();
63 };
64
65 let mut lines = vec![
66 format!("Workflow: {}", run.spec.name),
67 format!(" State: {}", run.current),
68 format!(" Updated: {}", run.updated_at),
69 ];
70
71 if let Some(state) = run.spec.state(&run.current) {
72 if let Some(ref tools) = state.allowed_tools {
73 let mut tools = tools.clone();
74 tools.sort();
75 let tools = tools.into_iter().take(30).collect::<Vec<_>>();
76 lines.push(format!(
77 " Allowed tools ({} shown): {}",
78 tools.len(),
79 tools.join(", ")
80 ));
81 }
82 }
83
84 let transitions = workflow::allowed_transitions(&run.spec, &run.current);
85 if transitions.is_empty() {
86 lines.push(" Transitions: (none)".to_string());
87 } else {
88 lines.push(" Transitions:".to_string());
89 for t in transitions.iter().take(10) {
90 let missing = workflow::missing_evidence_for_state(&run.spec, &t.to, |k| {
91 run.evidence.iter().any(|e| e.key == k) || session.has_evidence_key(k)
92 });
93 if missing.is_empty() {
94 lines.push(format!(" → {} (ok)", t.to));
95 } else {
96 lines.push(format!(" → {} (missing: {})", t.to, missing.join(", ")));
97 }
98 }
99 }
100
101 lines.join("\n")
102}
103
104fn handle_stop() -> String {
105 match workflow::clear_active() {
106 Ok(()) => "Workflow stopped (active cleared).".to_string(),
107 Err(e) => format!("Error clearing workflow: {e}"),
108 }
109}
110
111fn handle_transition(
112 args: Option<&serde_json::Map<String, Value>>,
113 session: &SessionState,
114) -> String {
115 let Some(to) = get_str(args, "to") else {
116 return "Error: 'to' is required for transition".to_string();
117 };
118 let note = get_str(args, "value");
119
120 let Ok(active) = workflow::load_active() else {
121 return "Error: failed to load active workflow.".to_string();
122 };
123 let Some(mut run) = active else {
124 return "No active workflow. Use action=start to begin.".to_string();
125 };
126
127 if let Err(e) = workflow::can_transition(&run.spec, &run.current, &to, |k| {
128 run.evidence.iter().any(|e| e.key == k) || session.has_evidence_key(k)
129 }) {
130 return format!("Transition blocked: {e}");
131 }
132
133 let from = run.current.clone();
134 run.current.clone_from(&to);
135 run.updated_at = Utc::now();
136 run.transitions
137 .push(crate::core::workflow::TransitionRecord {
138 from: from.clone(),
139 to: to.clone(),
140 note: note.clone(),
141 timestamp: Utc::now(),
142 });
143
144 if let Err(e) = workflow::save_active(&run) {
145 return format!("Failed to save workflow: {e}");
146 }
147
148 format!("Transition: {from} → {to}")
149}
150
151fn handle_complete(
152 args: Option<&serde_json::Map<String, Value>>,
153 session: &SessionState,
154) -> String {
155 let Ok(active) = workflow::load_active() else {
156 return "Error: failed to load active workflow.".to_string();
157 };
158 let Some(mut run) = active else {
159 return "No active workflow. Use action=start to begin.".to_string();
160 };
161 let note = get_str(args, "value");
162
163 let done = "done".to_string();
164 if workflow::find_transition(&run.spec, &run.current, &done).is_none() {
165 return format!("No transition to 'done' from '{}'", run.current);
166 }
167
168 if let Err(e) = workflow::can_transition(&run.spec, &run.current, &done, |k| {
169 run.evidence.iter().any(|e| e.key == k) || session.has_evidence_key(k)
170 }) {
171 return format!("Complete blocked: {e}");
172 }
173
174 let from = run.current.clone();
175 run.current.clone_from(&done);
176 run.updated_at = Utc::now();
177 run.transitions
178 .push(crate::core::workflow::TransitionRecord {
179 from: from.clone(),
180 to: done.clone(),
181 note,
182 timestamp: Utc::now(),
183 });
184
185 if let Err(e) = workflow::save_active(&run) {
186 return format!("Failed to save workflow: {e}");
187 }
188
189 format!("Workflow completed: {from} → {done}")
190}
191
192fn handle_evidence_add(
193 args: Option<&serde_json::Map<String, Value>>,
194 session: &mut SessionState,
195) -> String {
196 let Some(key) = get_str(args, "key") else {
197 return "Error: key is required".to_string();
198 };
199 let value = get_str(args, "value");
200
201 let Ok(active) = workflow::load_active() else {
202 return "Error: failed to load active workflow.".to_string();
203 };
204 let Some(mut run) = active else {
205 return "No active workflow. Use action=start to begin.".to_string();
206 };
207
208 run.add_manual_evidence(&key, value.as_deref());
209 session.record_manual_evidence(&key, value.as_deref());
210
211 if let Err(e) = workflow::save_active(&run) {
212 return format!("Failed to save workflow: {e}");
213 }
214
215 format!("Evidence added: {key}")
216}
217
218fn handle_evidence_list(session: &SessionState) -> String {
219 let Ok(active) = workflow::load_active() else {
220 return "Error: failed to load active workflow.".to_string();
221 };
222 let Some(run) = active else {
223 return "No active workflow.".to_string();
224 };
225
226 let mut lines = vec![format!("Evidence (workflow: {}):", run.spec.name)];
227 if run.evidence.is_empty() && session.evidence.is_empty() {
228 lines.push(" (none)".to_string());
229 return lines.join("\n");
230 }
231
232 if !run.evidence.is_empty() {
233 lines.push(" Manual (workflow):".to_string());
234 for e in run.evidence.iter().rev().take(20) {
235 let v = e.value.as_deref().unwrap_or("-");
236 lines.push(format!(" {} = {} ({})", e.key, v, e.timestamp));
237 }
238 }
239
240 if !session.evidence.is_empty() {
241 lines.push(" Session receipts (latest):".to_string());
242 for e in session.evidence.iter().rev().take(20) {
243 lines.push(format!(" {} ({:?})", e.key, e.kind));
244 }
245 }
246
247 lines.join("\n")
248}
249
250fn get_str(args: Option<&serde_json::Map<String, Value>>, key: &str) -> Option<String> {
251 args?
252 .get(key)?
253 .as_str()
254 .map(std::string::ToString::to_string)
255}