Skip to main content

glass_dev/
cli.rs

1//! Glass Dev-owned project CLI dispatch.
2
3use 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}