1use crate::development::{
4 Actor, ExperimentManager, HarnessRequest, LinkProvenance, LocalHarness, PiHarness,
5 ProcessSnapshot, ProjectWorkspace, SemanticBreakpoint, SemanticSnapshot,
6};
7use glass_browser::cli::args::{
8 AgentCommand, AgentHarness, ExperimentCommand, NeovimCommand, ProjectCommand,
9 ProjectGraphCommand, ProjectProcessCommand,
10};
11use serde::Serialize;
12use std::time::Duration;
13
14type CliResult<T> = Result<T, Box<dyn std::error::Error>>;
15
16pub fn dispatch_agent(action: &AgentCommand, unrestricted: bool) -> CliResult<()> {
17 let (root, request, adapter) = match action {
18 AgentCommand::Tool { .. } | AgentCommand::ToolFile { .. } => {
19 return Err("agent tool calls use the resident broker path".into());
20 }
21 AgentCommand::Hello { root, harness } => (root, HarnessRequest::Hello, *harness),
22 AgentCommand::Prompt {
23 root,
24 text,
25 harness,
26 } => (
27 root,
28 HarnessRequest::Prompt { text: text.clone() },
29 *harness,
30 ),
31 AgentCommand::Steer {
32 root,
33 text,
34 harness,
35 } => (root, HarnessRequest::Steer { text: text.clone() }, *harness),
36 AgentCommand::FollowUp { root, text } => (
37 root,
38 HarnessRequest::FollowUp { text: text.clone() },
39 AgentHarness::Pi,
40 ),
41 AgentCommand::Models { root } => (root, HarnessRequest::Models, AgentHarness::Pi),
42 AgentCommand::SetModel {
43 root,
44 provider,
45 model_id,
46 } => (
47 root,
48 HarnessRequest::SetModel {
49 provider: provider.clone(),
50 model_id: model_id.clone(),
51 },
52 AgentHarness::Pi,
53 ),
54 AgentCommand::Thinking { root, level } => (
55 root,
56 HarnessRequest::SetThinking {
57 level: level.clone(),
58 },
59 AgentHarness::Pi,
60 ),
61 AgentCommand::Abort { root } => (root, HarnessRequest::Abort, AgentHarness::Pi),
62 AgentCommand::NewSession { root } => (root, HarnessRequest::NewSession, AgentHarness::Pi),
63 };
64 let mut workspace = ProjectWorkspace::open(root)?;
65 match adapter {
66 AgentHarness::Local => {
67 let mut harness = LocalHarness::default();
68 print_json(&harness.handle(&mut workspace, request)?)?;
69 }
70 AgentHarness::Pi => {
71 let mut harness = PiHarness::spawn_with_unrestricted(workspace.root(), unrestricted)?;
72 print_json(&harness.request(request)?)?;
73 }
74 }
75 Ok(())
76}
77
78pub fn dispatch_project(action: &ProjectCommand) -> CliResult<()> {
79 match action {
80 ProjectCommand::Inspect { root } => {
81 let workspace = ProjectWorkspace::open(root)?;
82 print_json(&serde_json::json!({
83 "schemaVersion": crate::development::DEVELOPMENT_SCHEMA_VERSION,
84 "root": workspace.root(),
85 "detection": workspace.detection(),
86 "config": workspace.config(),
87 "revision": workspace.revision(),
88 }))?;
89 }
90 ProjectCommand::Files { root } => {
91 let workspace = ProjectWorkspace::open(root)?;
92 print_json(&workspace.list_files_result()?)?;
93 }
94 ProjectCommand::Search { root, query, limit } => {
95 let mut workspace = ProjectWorkspace::open(root)?;
96 print_json(&workspace.search(query, *limit)?)?;
97 }
98 ProjectCommand::Read { root, path } => {
99 let mut workspace = ProjectWorkspace::open(root)?;
100 let content = workspace.read_file(path)?;
101 print_json(&serde_json::json!({"path": path, "content": content}))?;
102 }
103 ProjectCommand::Edit {
104 root,
105 path,
106 content,
107 input,
108 } => {
109 let content = match (content, input) {
110 (Some(content), None) => content.clone(),
111 (None, Some(input)) => std::fs::read_to_string(input)?,
112 (None, None) => {
113 return Err("project edit requires --content or --input".into());
114 }
115 (Some(_), Some(_)) => unreachable!("clap prevents conflicting edit inputs"),
116 };
117 let mut workspace = ProjectWorkspace::open(root)?;
118 workspace.edit_buffer(path, content, Actor::local())?;
119 print_json(&workspace.save_buffer(path)?)?;
120 }
121 ProjectCommand::Mkdir { root, path } => {
122 let mut workspace = ProjectWorkspace::open(root)?;
123 workspace.create_directory(path, Actor::local())?;
124 print_json(&serde_json::json!({"path": path, "created": true}))?;
125 }
126 ProjectCommand::Rename { root, from, to } => {
127 let mut workspace = ProjectWorkspace::open(root)?;
128 workspace.rename_path(from, to, Actor::local())?;
129 print_json(&serde_json::json!({"from": from, "to": to, "renamed": true}))?;
130 }
131 ProjectCommand::Delete { root, path, yes } => {
132 if !yes {
133 return Err("project delete requires --yes confirmation".into());
134 }
135 let mut workspace = ProjectWorkspace::open(root)?;
136 workspace.delete_path(path, Actor::local())?;
137 print_json(&serde_json::json!({"path": path, "deleted": true}))?;
138 }
139 ProjectCommand::Diagnostics { root, path } => {
140 let mut workspace = ProjectWorkspace::open(root)?;
141 print_json(&workspace.publish_rust_diagnostics(path)?)?;
142 }
143 ProjectCommand::Run {
144 root,
145 name,
146 command,
147 wait,
148 } => {
149 if !wait {
150 return Err("one-shot CLI process runs require --wait; use the TUI for persistent interactive processes".into());
151 }
152 let mut workspace = ProjectWorkspace::open(root)?;
153 let command = command
154 .clone()
155 .or_else(|| detected_command(workspace.detection(), name))
156 .ok_or_else(|| format!("no configured command for process {name}"))?;
157 #[cfg(windows)]
158 let snapshot = workspace.run_command_to_completion(
159 name,
160 &command,
161 std::time::Duration::from_secs(600),
162 )?;
163 #[cfg(not(windows))]
164 let snapshot = {
165 let snapshot = workspace.start_process(name, &command)?;
166 if *wait {
167 workspace.processes().close_input(name)?;
168 wait_for_project_process(&mut workspace, name)?
169 } else {
170 snapshot
171 }
172 };
173 print_json(&snapshot)?;
174 }
175 ProjectCommand::Test { root } => {
176 run_detected_command(root, "test", workspace_test_command)?;
177 }
178 ProjectCommand::Lint { root } => {
179 run_detected_command(root, "lint", workspace_lint_command)?;
180 }
181 ProjectCommand::Process { root, action } => {
182 let mut workspace = ProjectWorkspace::open(root)?;
183 match action {
184 ProjectProcessCommand::List => print_json(&workspace.processes().list_checked()?)?,
185 ProjectProcessCommand::Start {
186 name,
187 command,
188 wait,
189 } => {
190 if !wait {
191 return Err("one-shot CLI process starts require --wait; use the TUI for persistent interactive processes".into());
192 }
193 #[cfg(windows)]
194 let snapshot = workspace.run_command_to_completion(
195 name,
196 command,
197 std::time::Duration::from_secs(600),
198 )?;
199 #[cfg(not(windows))]
200 let snapshot = {
201 workspace.start_process(name, command)?;
202 if *wait {
203 workspace.processes().close_input(name)?;
204 wait_for_project_process(&mut workspace, name)?
205 } else {
206 workspace
207 .processes()
208 .list()
209 .into_iter()
210 .find(|process| process.name == *name)
211 .ok_or_else(|| format!("process {name} disappeared"))?
212 }
213 };
214 print_json(&snapshot)?;
215 }
216 ProjectProcessCommand::Stop { name } => {
217 print_json(&workspace.stop_process(name)?)?;
218 }
219 ProjectProcessCommand::Restart { name } => {
220 print_json(&workspace.processes().restart(name)?)?;
221 }
222 ProjectProcessCommand::Remove { name } => {
223 print_json(&workspace.processes().remove(name)?)?;
224 }
225 ProjectProcessCommand::Input { name, input } => {
226 workspace.processes().send_input(name, input)?;
227 print_json(&serde_json::json!({"name": name, "accepted": true}))?;
228 }
229 ProjectProcessCommand::Resize { name, cols, rows } => {
230 workspace.processes().resize(name, *cols, *rows)?;
231 print_json(&serde_json::json!({"name": name, "cols": cols, "rows": rows}))?;
232 }
233 ProjectProcessCommand::Output { name } => {
234 print_json(&serde_json::json!({
235 "name": name,
236 "output": workspace.processes().output(name)?,
237 }))?;
238 }
239 }
240 }
241 ProjectCommand::Diff { root } => {
242 let mut workspace = ProjectWorkspace::open(root)?;
243 print_json(&workspace.diff()?)?;
244 }
245 ProjectCommand::Link {
246 root,
247 entity,
248 path,
249 start_line,
250 end_line,
251 provenance,
252 confidence,
253 detail,
254 } => {
255 let mut workspace = ProjectWorkspace::open(root)?;
256 let provenance = parse_link_provenance(provenance)?;
257 let link = workspace.link_runtime_source(
258 entity,
259 path,
260 *start_line,
261 *end_line,
262 provenance,
263 detail,
264 *confidence,
265 Actor::local(),
266 )?;
267 print_json(&link)?;
268 }
269 ProjectCommand::Timeline { root } => {
270 let workspace = ProjectWorkspace::open(root)?;
271 print_json(&workspace.timeline().events().collect::<Vec<_>>())?;
272 }
273 ProjectCommand::Graph { root, action } => {
274 let mut workspace = ProjectWorkspace::open(root)?;
275 match action {
276 ProjectGraphCommand::Discover => print_json(&workspace.discover_runtime_links()?)?,
277 ProjectGraphCommand::Entity { entity } => {
278 print_json(&workspace.graph().links_for(entity))?
279 }
280 ProjectGraphCommand::Source { path, line } => {
281 print_json(&workspace.graph().entities_for_source(path, *line))?
282 }
283 }
284 }
285 ProjectCommand::Breakpoint {
286 root,
287 kind,
288 entity,
289 before,
290 after,
291 } => {
292 let mut workspace = ProjectWorkspace::open(root)?;
293 workspace.discover_runtime_links()?;
294 let before: SemanticSnapshot = serde_json::from_slice(&std::fs::read(before)?)?;
295 let after: SemanticSnapshot = serde_json::from_slice(&std::fs::read(after)?)?;
296 let breakpoint = match kind.as_str() {
297 "disappears" => SemanticBreakpoint::EntityDisappears { entity_id: entity.clone() },
298 "name-missing" => SemanticBreakpoint::AccessibleNameMissing { entity_id: Some(entity.clone()) },
299 "role-changes" => SemanticBreakpoint::RoleChanges { entity_id: entity.clone() },
300 "actionability-lost" => SemanticBreakpoint::ActionabilityLost { entity_id: entity.clone() },
301 _ => return Err("breakpoint kind must be disappears, name-missing, role-changes, or actionability-lost".into()),
302 };
303 print_json(&workspace.evaluate_semantic_breakpoints(
304 &[breakpoint],
305 &before,
306 &after,
307 )?)?;
308 }
309 ProjectCommand::Replay { root, start, limit } => {
310 let workspace = ProjectWorkspace::open(root)?;
311 print_json(&workspace.replay(*start, *limit)?)?;
312 }
313 ProjectCommand::Neovim { root, action } => {
314 let mut workspace = ProjectWorkspace::open(root)?;
315 match action {
316 NeovimCommand::Probe => print_json(&crate::development::probe_neovim()?)?,
317 NeovimCommand::Start { name, path } => {
318 print_json(&crate::development::start_neovim(
319 workspace.processes(),
320 name,
321 path.as_deref(),
322 )?)?
323 }
324 }
325 }
326 ProjectCommand::Experiment { root, action } => {
327 let manager = ExperimentManager::new(root)?;
328 match action {
329 ExperimentCommand::Create { name, port } => {
330 print_json(&manager.create(name, *port)?)?
331 }
332 }
333 }
334 ProjectCommand::Attach { root, actor } => {
335 let mut workspace = ProjectWorkspace::open(root)?;
336 let actor = Actor::external(actor);
337 workspace.attach_actor(actor.clone())?;
338 print_json(&actor)?;
339 }
340 }
341 Ok(())
342}
343
344fn detected_command(
345 detection: &crate::development::ProjectDetection,
346 name: &str,
347) -> Option<String> {
348 match name {
349 "dev" => detection.dev_command.clone(),
350 "test" => detection.test_command.clone(),
351 "lint" => detection.lint_command.clone(),
352 "build" => detection.build_command.clone(),
353 _ => None,
354 }
355}
356
357fn workspace_test_command(detection: &crate::development::ProjectDetection) -> Option<String> {
358 detection.test_command.clone()
359}
360
361fn workspace_lint_command(detection: &crate::development::ProjectDetection) -> Option<String> {
362 detection.lint_command.clone()
363}
364
365fn run_detected_command(
366 root: &std::path::Path,
367 name: &str,
368 command: fn(&crate::development::ProjectDetection) -> Option<String>,
369) -> CliResult<()> {
370 let mut workspace = ProjectWorkspace::open(root)?;
371 let command = command(workspace.detection())
372 .ok_or_else(|| format!("project has no detected {name} command"))?;
373 print_json(&workspace.run_verification(name, &command, Duration::from_secs(600))?)?;
374 Ok(())
375}
376
377fn wait_for_project_process(
378 workspace: &mut ProjectWorkspace,
379 name: &str,
380) -> CliResult<ProcessSnapshot> {
381 let deadline = std::time::Instant::now() + std::time::Duration::from_secs(600);
382 loop {
383 let snapshots = workspace.processes().poll()?;
384 let snapshot = snapshots
385 .into_iter()
386 .find(|process| process.name == name)
387 .ok_or_else(|| format!("process {name} disappeared"))?;
388 if !matches!(snapshot.state, crate::development::ProcessState::Running) {
389 return Ok(snapshot);
390 }
391 if std::time::Instant::now() >= deadline {
392 workspace.stop_process(name)?;
393 return Err(format!("process {name} exceeded 600 seconds").into());
394 }
395 std::thread::sleep(std::time::Duration::from_millis(20));
396 }
397}
398
399fn parse_link_provenance(value: &str) -> CliResult<LinkProvenance> {
400 match value {
401 "explicit-marker" => Ok(LinkProvenance::ExplicitMarker),
402 "runtime-observation" => Ok(LinkProvenance::RuntimeObservation),
403 "static-analysis" => Ok(LinkProvenance::StaticAnalysis),
404 "inferred" => Ok(LinkProvenance::Inferred),
405 _ => Err(
406 "provenance must be explicit-marker, runtime-observation, static-analysis, or inferred"
407 .into(),
408 ),
409 }
410}
411
412fn print_json<T: Serialize + ?Sized>(value: &T) -> CliResult<()> {
413 println!("{}", serde_json::to_string_pretty(value)?);
414 Ok(())
415}