1mod cloud;
2mod ide;
3mod nx;
4mod setup;
5
6use clap::{Parser, Subcommand, error::ErrorKind};
7use serde_json::{Value, json};
8use std::{path::PathBuf, process::ExitCode};
9
10#[derive(Parser, Debug)]
11#[command(
12 name = "magi-nx-axi",
13 version,
14 about = "Agent-native Nx workspace CLI",
15 disable_help_subcommand = true,
16 after_help = "Examples:\n magi-nx-axi workspace --format json\n magi-nx-axi project app --select targets.build\n magi-nx-axi graph project --project app"
17)]
18pub struct Cli {
19 #[arg(long, env = "NX_WORKSPACE_PATH", global = true)]
20 pub workspace: Option<PathBuf>,
21 #[arg(long, env="NX_FORMAT", global=true, default_value="toon", value_parser=["toon","json"])]
22 pub format: String,
23 #[arg(long, global = true)]
24 pub full: bool,
25 #[arg(long, env = "NX_AXI_CLOUD_URL", global = true)]
26 pub cloud_url: Option<String>,
27 #[command(subcommand)]
28 pub command: Option<CommandKind>,
29}
30#[derive(Subcommand, Debug)]
31pub enum CommandKind {
32 #[command(
33 about = "Search current Nx documentation",
34 after_help = "Examples:\n magi-nx-axi docs \"How do affected tasks work?\"\n magi-nx-axi --format json docs \"configure named inputs\""
35 )]
36 Docs { query: String },
37 #[command(
38 about = "List official, community, installed, and local Nx plugins",
39 after_help = "Examples:\n magi-nx-axi plugins\n magi-nx-axi --format json plugins"
40 )]
41 Plugins,
42 #[command(
43 about = "Inspect project graph, dependencies, and nx.json",
44 after_help = "Examples:\n magi-nx-axi workspace\n magi-nx-axi workspace --filter 'tag:type:app,!*-e2e' --select targets.build"
45 )]
46 Workspace {
47 #[arg(long)]
48 filter: Option<String>,
49 #[arg(long)]
50 select: Option<String>,
51 #[arg(long, default_value_t = 0)]
52 page: usize,
53 #[arg(long)]
54 limit: Option<usize>,
55 },
56 #[command(
57 about = "Resolve current Nx workspace root",
58 after_help = "Examples:\n magi-nx-axi workspace-path\n magi-nx-axi --workspace ../repo workspace-path"
59 )]
60 WorkspacePath,
61 #[command(
62 about = "Inspect one Nx project",
63 after_help = "Examples:\n magi-nx-axi project app\n magi-nx-axi project app --select targets.build"
64 )]
65 Project {
66 name: String,
67 #[arg(long)]
68 select: Option<String>,
69 #[arg(long, default_value_t = 0)]
70 page: usize,
71 },
72 #[command(
73 about = "List installed and local generators",
74 after_help = "Examples:\n magi-nx-axi generators\n magi-nx-axi --format json generators"
75 )]
76 Generators,
77 #[command(
78 about = "Read complete generator JSON schema",
79 after_help = "Examples:\n magi-nx-axi generator-schema @nx/react:component\n magi-nx-axi generator-schema workspace:widget --full"
80 )]
81 GeneratorSchema { name: String },
82 #[command(
83 about = "Read generator examples.md",
84 after_help = "Examples:\n magi-nx-axi generator-examples @nx/react:component\n magi-nx-axi generator-examples workspace:widget --full"
85 )]
86 GeneratorExamples { name: String },
87 #[command(
88 about = "Open Nx graph in connected Nx Console IDE",
89 after_help = "Examples:\n magi-nx-axi graph full-project-graph\n magi-nx-axi graph project-task --project app --task build"
90 )]
91 Graph {
92 #[arg(value_parser=["project","project-task","full-project-graph"])]
93 kind: String,
94 #[arg(long)]
95 project: Option<String>,
96 #[arg(long)]
97 task: Option<String>,
98 },
99 #[command(
100 about = "List IDE-known running and recent Nx tasks",
101 after_help = "Examples:\n magi-nx-axi tasks\n magi-nx-axi --format json tasks"
102 )]
103 Tasks,
104 #[command(
105 about = "Read newest IDE task output page",
106 after_help = "Examples:\n magi-nx-axi task-output app:build\n magi-nx-axi task-output build --page 1"
107 )]
108 TaskOutput {
109 task: String,
110 #[arg(long, default_value_t = 0)]
111 page: usize,
112 },
113 #[command(
114 about = "Inspect Nx Cloud CI pipeline information",
115 after_help = "Examples:\n magi-nx-axi ci --branch main\n magi-nx-axi ci --url https://cloud.nx.app/runs/<id> --select tasks"
116 )]
117 Ci {
118 #[arg(long)]
119 url: Option<String>,
120 #[arg(long)]
121 branch: Option<String>,
122 #[arg(long)]
123 select: Option<String>,
124 #[arg(long, default_value_t = 0)]
125 page: usize,
126 },
127 #[command(
128 about = "Read newest Nx Cloud task output page",
129 after_help = "Examples:\n magi-nx-axi ci-task-output app:build --run <run-id>\n magi-nx-axi ci-task-output app:test --branch main --page 1"
130 )]
131 CiTaskOutput {
132 task: String,
133 #[arg(long)]
134 run: Option<String>,
135 #[arg(long)]
136 url: Option<String>,
137 #[arg(long)]
138 branch: Option<String>,
139 #[arg(long, default_value_t = 0)]
140 page: usize,
141 },
142 #[command(
143 about = "Apply, reject, or rerun a self-healing fix",
144 after_help = "Examples:\n magi-nx-axi self-healing --id <id> APPLY\n magi-nx-axi self-healing --short-link <fix-suggestion> REJECT"
145 )]
146 SelfHealing {
147 #[arg(long, conflicts_with_all=["short_link","branch"])]
148 id: Option<String>,
149 #[arg(long, conflicts_with_all=["id","branch"])]
150 short_link: Option<String>,
151 #[arg(long, conflicts_with_all=["id","short_link"])]
152 branch: Option<String>,
153 #[arg(value_parser=["APPLY","REJECT","RERUN_ENVIRONMENT_STATE"])]
154 action: String,
155 },
156 #[command(
157 about = "List recent Nx Cloud pipeline executions",
158 after_help = "Examples:\n magi-nx-axi cipes --branch main\n magi-nx-axi --format json cipes"
159 )]
160 Cipes {
161 #[arg(long)]
162 branch: Option<String>,
163 },
164 #[command(
165 about = "Install or repair opt-in agent session integrations",
166 after_help = "Examples:\n magi-nx-axi setup\n magi-nx-axi setup --claude --opencode"
167 )]
168 Setup {
169 #[arg(long)]
170 claude: bool,
171 #[arg(long)]
172 codex: bool,
173 #[arg(long)]
174 opencode: bool,
175 },
176}
177
178fn root(cli: &Cli) -> Result<PathBuf, String> {
179 nx::find_workspace(
180 &cli.workspace
181 .clone()
182 .unwrap_or(std::env::current_dir().map_err(|e| e.to_string())?),
183 )
184}
185fn reverse_page(s: &str, p: usize, max_chars: usize, max_lines: usize) -> Value {
186 let lines: Vec<&str> = s.split_inclusive('\n').collect();
187 let mut pages = Vec::<String>::new();
188 let mut end = lines.len();
189 while end > 0 {
190 let mut start = end;
191 let mut chars = 0usize;
192 while start > 0 && end - start < max_lines {
193 let next = lines[start - 1].chars().count();
194 if chars > 0 && chars.saturating_add(next) > max_chars {
195 break;
196 }
197 chars = chars.saturating_add(next);
198 start -= 1;
199 }
200 if start == end {
201 start = end - 1;
202 }
203 pages.push(lines[start..end].concat());
204 end = start;
205 }
206 let total = pages.len();
207 let content = pages.get(p).cloned().unwrap_or_default();
208 json!({"content":content,"page":p,"totalPages":total,"hasMore":p+1<total,"nextPage":(p+1<total).then_some(p+1)})
209}
210fn select(v: &Value, path: &str) -> Option<Value> {
211 path.replace('[', ".")
212 .replace(']', "")
213 .split('.')
214 .filter(|x| !x.is_empty())
215 .try_fold(v, |x, k| x.get(k))
216 .cloned()
217}
218fn docs(query: &str, full: bool) -> Result<Value, String> {
219 let base = std::env::var("NX_AXI_DOCS_URL").unwrap_or_else(|_| "https://nx.dev".into());
220 let url = url::Url::parse(&base).map_err(|e| format!("invalid docs endpoint: {e}"))?;
221 let loopback = matches!(
222 url.host_str(),
223 Some("localhost") | Some("127.0.0.1") | Some("::1")
224 );
225 if url.scheme() != "https" && !(url.scheme() == "http" && loopback) {
226 return Err("docs endpoint must use HTTPS; HTTP is allowed only for loopback tests".into());
227 }
228 let response = ureq::post(&format!(
229 "{}/api/query-ai-embeddings",
230 base.trim_end_matches('/')
231 ))
232 .header("Content-Type", "application/json")
233 .send_json(json!({"messages":[{"role":"user","content":query}]}))
234 .map_err(|e| format!("Nx docs request failed: {e}"))?;
235 let value: Value = response
236 .into_body()
237 .read_json()
238 .map_err(|e| format!("Nx docs returned invalid JSON: {e}"))?;
239 let all = value
240 .pointer("/context/pageSections")
241 .and_then(Value::as_array)
242 .cloned()
243 .unwrap_or_default();
244 let total = all.len();
245 let sections: Vec<_> = if full {
246 all
247 } else {
248 all.into_iter().take(4).collect()
249 };
250 let help = (sections.len() < total).then(|| vec!["magi-nx-axi docs \"<same query>\" --full"]);
251 Ok(json!({"query":query,"count":sections.len(),"total":total,"sections":sections,"help":help}))
252}
253
254fn filter_match(value: &str, pattern: &str) -> bool {
255 if pattern.contains('*') {
256 let mut parts = pattern.split('*');
257 value.starts_with(parts.next().unwrap_or(""))
258 && value.ends_with(parts.next_back().unwrap_or(""))
259 } else {
260 value.contains(pattern)
261 }
262}
263fn project_matches(project: &Value, expression: &str) -> bool {
264 let name = project
265 .get("name")
266 .and_then(Value::as_str)
267 .unwrap_or_default();
268 let root = project
269 .get("root")
270 .and_then(Value::as_str)
271 .unwrap_or_default();
272 let tags = project
273 .get("tags")
274 .and_then(Value::as_array)
275 .cloned()
276 .unwrap_or_default();
277 expression
278 .split(',')
279 .map(str::trim)
280 .filter(|x| !x.is_empty())
281 .all(|pattern| {
282 let negative = pattern.starts_with('!');
283 let pattern = pattern.strip_prefix('!').unwrap_or(pattern);
284 let matched = if let Some(tag) = pattern.strip_prefix("tag:") {
285 tags.iter()
286 .filter_map(Value::as_str)
287 .any(|value| filter_match(value, tag))
288 } else {
289 filter_match(name, pattern) || filter_match(root, pattern)
290 };
291 if negative { !matched } else { matched }
292 })
293}
294
295fn current_branch(root: &std::path::Path) -> Result<String, String> {
296 let output = std::process::Command::new("git")
297 .args(["rev-parse", "--abbrev-ref", "HEAD"])
298 .current_dir(root)
299 .output()
300 .map_err(|e| format!("cannot determine git branch: {e}"))?;
301 if !output.status.success() {
302 return Err("cannot determine git branch; pass --branch or --url".into());
303 }
304 let branch = String::from_utf8(output.stdout)
305 .map_err(|_| "git branch is not UTF-8")?
306 .trim()
307 .to_owned();
308 if branch.is_empty() {
309 Err("cannot determine git branch; pass --branch or --url".into())
310 } else {
311 Ok(branch)
312 }
313}
314
315fn cloud_url_parts(raw: &str) -> Result<(&'static str, String, Option<String>), String> {
316 let url = url::Url::parse(raw).map_err(|_| "invalid Nx Cloud URL")?;
317 let parts: Vec<_> = url.path_segments().map(|x| x.collect()).unwrap_or_default();
318 if let Some(id) = parts
319 .iter()
320 .position(|part| *part == "cipes")
321 .and_then(|index| parts.get(index + 1))
322 {
323 return Ok(("cipe", (*id).into(), None));
324 }
325 if let Some(id) = parts
326 .iter()
327 .position(|part| *part == "runs")
328 .and_then(|index| parts.get(index + 1))
329 {
330 let task = parts
331 .iter()
332 .position(|part| *part == "task")
333 .and_then(|i| parts.get(i + 1))
334 .map(|x| (*x).into());
335 return Ok(("run", (*id).into(), task));
336 }
337 Err(
338 "unsupported Nx Cloud URL; expected /cipes/<id>, /runs/<id>, or /runs/<id>/task/<task>"
339 .into(),
340 )
341}
342
343fn find_string(value: &Value, key: &str) -> Option<String> {
344 match value {
345 Value::Object(object) => object
346 .get(key)
347 .and_then(Value::as_str)
348 .map(str::to_owned)
349 .or_else(|| object.values().find_map(|value| find_string(value, key))),
350 Value::Array(items) => items.iter().find_map(|value| find_string(value, key)),
351 _ => None,
352 }
353}
354
355fn list(v: Value, page: usize, limit: Option<usize>) -> Value {
356 let a = v.as_array().cloned().unwrap_or_default();
357 let total = a.len();
358 let n = limit.unwrap_or(1000);
359 let start = page.saturating_mul(n);
360 let items = a.into_iter().skip(start).take(n).collect::<Vec<_>>();
361 json!({"items":items,"count":items.len(),"total":total,"page":page,"limit":n,"hasMore":start.saturating_add(n)<total})
362}
363fn execute(c: &Cli) -> Result<Value, String> {
364 let workspace = match c.command {
365 Some(CommandKind::Docs { .. })
366 | Some(CommandKind::Plugins)
367 | Some(CommandKind::WorkspacePath)
368 | None => nx::find_workspace(
369 &c.workspace
370 .clone()
371 .unwrap_or(std::env::current_dir().map_err(|e| e.to_string())?),
372 )
373 .ok(),
374 _ => Some(root(c)?),
375 };
376 match (&c.command, workspace) {
377 (None, None) => Ok(json!({
378 "bin": display_executable(),
379 "description":"Inspect Nx workspaces, generators, IDE tasks, and Nx Cloud CI",
380 "workspace":{"found":false,"cwd":std::env::current_dir().map_err(|e|e.to_string())?},
381 "help":["magi-nx-axi --workspace <path> workspace","magi-nx-axi docs \"<nx question>\""]
382 })),
383 (None, Some(root)) => match nx::projects(&root) {
384 Ok(projects) => Ok(json!({
385 "bin":display_executable(),
386 "description":"Inspect Nx workspaces, generators, IDE tasks, and Nx Cloud CI",
387 "workspace":{"found":true,"path":root,"projects":projects.len(),"analysis":"ready"},
388 "projects":projects.iter().take(8).filter_map(|p|p["name"].as_str()).collect::<Vec<_>>(),
389 "help":["magi-nx-axi workspace","magi-nx-axi project <name>","magi-nx-axi ci"]
390 })),
391 Err(message) => Ok(json!({
392 "bin":display_executable(),
393 "description":"Inspect Nx workspaces, generators, IDE tasks, and Nx Cloud CI",
394 "workspace":{"found":true,"path":root,"analysis":"unavailable","message":message},
395 "help":["Install workspace dependencies, then run `magi-nx-axi workspace`.","magi-nx-axi docs \"install Nx workspace dependencies\""]
396 })),
397 },
398 (Some(CommandKind::Docs { query }), _) => docs(query, c.full),
399 (Some(CommandKind::WorkspacePath), root) => Ok(match root {
400 Some(root) => json!({"found":true,"workspace":root}),
401 None => json!({"found":false,"workspace":Value::Null}),
402 }),
403 (Some(CommandKind::Plugins), root) => {
404 let plugins = nx::plugins(root.as_deref())?;
405 Ok(json!({
406 "scope":root,
407 "count":plugins.len(),
408 "plugins":plugins,
409 "help":["magi-nx-axi generators"]
410 }))
411 }
412 (
413 Some(CommandKind::Workspace {
414 filter,
415 select: s,
416 page,
417 limit,
418 }),
419 Some(root),
420 ) => {
421 let mut projects = nx::projects(&root)?;
422 if let Some(expression) = filter {
423 projects.retain(|project| project_matches(project, expression));
424 }
425 if let Some(path) = s {
426 let selected = projects
427 .iter()
428 .map(|project| {
429 let name = project["name"].clone();
430 select(project, path)
431 .map(|value| json!({"project":name,"value":value}))
432 .ok_or_else(|| {
433 format!(
434 "selection `{path}` not found in project {}",
435 name.as_str().unwrap_or("<unknown>")
436 )
437 })
438 })
439 .collect::<Result<Vec<_>, _>>()?;
440 let paged = list(json!(selected), *page, *limit);
441 Ok(json!({"workspace":root,"selection":path,"projects":paged}))
442 } else {
443 let dependencies = nx::graph(&root)?
444 .get("dependencies")
445 .cloned()
446 .unwrap_or_else(|| json!({}));
447 let nx_json = nx::nx_json(&root)?;
448 Ok(
449 json!({"workspace":root,"projects":list(json!(projects),*page,*limit),"dependencies":dependencies,"nxJson":nx_json,"help":["magi-nx-axi project <name>"]}),
450 )
451 }
452 }
453 (
454 Some(CommandKind::Project {
455 name,
456 select: selection,
457 page,
458 }),
459 Some(root),
460 ) => {
461 let projects = nx::projects(&root)?;
462 let project = projects
463 .into_iter()
464 .find(|value| value.get("name").and_then(Value::as_str) == Some(name))
465 .ok_or_else(|| format!("project not found: {name}"))?;
466 let value = if let Some(path) = selection {
467 select(&project, path)
468 .ok_or_else(|| format!("selection `{path}` not found in project {name}"))?
469 } else {
470 project
471 };
472 if *page > 0 {
473 let serialized = serde_json::to_string(&value).map_err(|e| e.to_string())?;
474 Ok(json!({"project":name,"page":reverse_page(&serialized,*page,10_000,usize::MAX)}))
475 } else {
476 Ok(json!({"project":value}))
477 }
478 }
479 (Some(CommandKind::Generators), Some(root)) => {
480 let generators = nx::generators(&root)?;
481 Ok(
482 json!({"workspace":root,"count":generators.len(),"generators":generators,"help":["magi-nx-axi generator-schema <name>"]}),
483 )
484 }
485 (Some(CommandKind::GeneratorSchema { name }), Some(root)) => Ok(
486 json!({"workspace":root,"generator":name,"schema":nx::generator_schema(&root,name)?}),
487 ),
488 (Some(CommandKind::GeneratorExamples { name }), Some(root)) => Ok(
489 json!({"workspace":root,"generator":name,"examples":nx::generator_examples(&root,name)?}),
490 ),
491 (
492 Some(CommandKind::Graph {
493 kind,
494 project,
495 task,
496 }),
497 Some(root),
498 ) => {
499 let projects = nx::projects(&root)?;
500 if let Some(name) = project {
501 let project = projects
502 .iter()
503 .find(|value| value["name"].as_str() == Some(name.as_str()))
504 .ok_or_else(|| format!("project not found: {name}"))?;
505 if let Some(task) = task {
506 if project.pointer(&format!("/targets/{task}")).is_none() {
507 return Err(format!("target not found: {name}:{task}"));
508 }
509 }
510 }
511 ide::notify_graph(&root, kind, project.as_deref(), task.as_deref())?;
512 Ok(
513 json!({"visualization":{"type":kind,"project":project,"task":task,"ide":"connected","opened":true}}),
514 )
515 }
516 (Some(CommandKind::Tasks), Some(root)) => {
517 let response = ide::call(&root, "ide/getRunningTasks", None, true)?;
518 let tasks = response
519 .pointer("/result/runningTasks")
520 .and_then(Value::as_object)
521 .ok_or("IDE returned no running-task map")?;
522 let rows: Vec<_> = tasks
523 .values()
524 .map(|task| {
525 json!({
526 "taskId":task.get("name"),
527 "status":task.get("status"),
528 "continuous":task.get("continuous"),
529 "runStatus":task.get("overallRunStatus")
530 })
531 })
532 .collect();
533 Ok(
534 json!({"workspace":root,"count":rows.len(),"tasks":rows,"help":["magi-nx-axi task-output <task-id>"]}),
535 )
536 }
537 (Some(CommandKind::TaskOutput { task, page: p }), Some(root)) => {
538 let response = ide::call(&root, "ide/getRunningTasks", None, true)?;
539 let (id, task) = ide::task_output(&response, task)?;
540 let output = task
541 .get("output")
542 .and_then(Value::as_str)
543 .unwrap_or_default();
544 Ok(
545 json!({"task":id,"status":task.get("status"),"continuous":task.get("continuous"),"output":reverse_page(output,*p,10_000,usize::MAX)}),
546 )
547 }
548 (
549 Some(CommandKind::Ci {
550 url,
551 branch,
552 select: selection,
553 page,
554 }),
555 Some(root),
556 ) => {
557 let value = if let Some(url) = url {
558 let (kind, id, _) = cloud_url_parts(url)?;
559 if kind == "cipe" {
560 cloud::pipeline(&root, c.cloud_url.as_deref(), &id)?
561 } else {
562 cloud::run(&root, c.cloud_url.as_deref(), &id)?
563 }
564 } else {
565 let branch = branch
566 .clone()
567 .map(Ok)
568 .unwrap_or_else(|| current_branch(&root))?;
569 cloud::recent(&root, c.cloud_url.as_deref(), Some(&branch))?
570 };
571 if let Some(path) = selection {
572 let selected = select(&value, path)
573 .ok_or_else(|| format!("selection `{path}` not found in CI information"))?;
574 if let Some(text) = selected.as_str() {
575 Ok(json!({"selection":path,"value":reverse_page(text,*page,10_000,usize::MAX)}))
576 } else {
577 Ok(json!({"selection":path,"value":selected}))
578 }
579 } else {
580 Ok(json!({"ci":value,"help":["magi-nx-axi ci-task-output <task> --run <run-id>"]}))
581 }
582 }
583 (Some(CommandKind::Cipes { branch }), Some(root)) => {
584 let branch = branch
585 .clone()
586 .map(Ok)
587 .unwrap_or_else(|| current_branch(&root))?;
588 let value = cloud::recent(&root, c.cloud_url.as_deref(), Some(&branch))?;
589 let items = value
590 .get("ciPipelineExecutions")
591 .and_then(Value::as_array)
592 .cloned()
593 .unwrap_or_default();
594 Ok(json!({"scope":"recent","branch":branch,"count":items.len(),"executions":items}))
595 }
596 (
597 Some(CommandKind::CiTaskOutput {
598 task,
599 run,
600 url,
601 branch,
602 page,
603 }),
604 Some(root),
605 ) => {
606 let run = if let Some(run) = run {
607 run.clone()
608 } else if let Some(url) = url {
609 let (_, id, task_from_url) = cloud_url_parts(url)?;
610 if let Some(url_task) = task_from_url {
611 if url_task != *task {
612 return Err(format!("task URL identifies `{url_task}`, not `{task}`"));
613 }
614 }
615 id
616 } else {
617 let branch = branch
618 .clone()
619 .map(Ok)
620 .unwrap_or_else(|| current_branch(&root))?;
621 let recent = cloud::recent(&root, c.cloud_url.as_deref(), Some(&branch))?;
622 find_string(&recent, "linkId")
623 .or_else(|| find_string(&recent, "executionId"))
624 .ok_or("no run found for branch")?
625 };
626 let output = cloud::terminal(&root, c.cloud_url.as_deref(), task, &run)?;
627 Ok(json!({"task":task,"run":run,"output":reverse_page(&output,*page,10_000,120)}))
628 }
629 (
630 Some(CommandKind::SelfHealing {
631 id,
632 short_link,
633 branch,
634 action,
635 }),
636 Some(root),
637 ) => {
638 let id = if let Some(id) = id {
639 id.clone()
640 } else if let Some(short) = short_link {
641 let fix = cloud::retrieve_fix(&root, c.cloud_url.as_deref(), short)?;
642 find_string(&fix, "aiFixId").ok_or("Nx Cloud fix response contained no aiFixId")?
643 } else {
644 let branch = branch
645 .clone()
646 .map(Ok)
647 .unwrap_or_else(|| current_branch(&root))?;
648 let recent = cloud::recent(&root, c.cloud_url.as_deref(), Some(&branch))?;
649 find_string(&recent, "aiFixId").ok_or("no self-healing fix found for branch")?
650 };
651 let result = cloud::update(&root, c.cloud_url.as_deref(), &id, action)?;
652 if result.get("success").and_then(Value::as_bool) != Some(true) {
653 let message = result
654 .pointer("/error/message")
655 .and_then(Value::as_str)
656 .unwrap_or("Nx Cloud did not confirm self-healing mutation");
657 return Err(message.into());
658 }
659 Ok(json!({"success":true,"changed":true,"aiFixId":id,"action":action,"result":result}))
660 }
661 (
662 Some(CommandKind::Setup {
663 claude,
664 codex,
665 opencode,
666 }),
667 Some(root),
668 ) => setup::install(&root, *claude, *codex, *opencode),
669 _ => Err("invalid command context".into()),
670 }
671}
672fn display_executable() -> String {
673 let path = std::env::current_exe().unwrap_or_else(|_| PathBuf::from("magi-nx-axi"));
674 let text = path.to_string_lossy().into_owned();
675 if let Some(home) = std::env::var_os("HOME") {
676 let home = home.to_string_lossy();
677 if let Some(rest) = text.strip_prefix(home.as_ref()) {
678 return format!("~{rest}");
679 }
680 }
681 text
682}
683
684fn truncate(value: &mut Value) -> bool {
685 match value {
686 Value::String(text) if text.chars().count() > 1000 => {
687 let length = text.chars().count();
688 *text = text.chars().take(1000).collect::<String>()
689 + &format!("… [truncated, {length} chars; use --full]");
690 true
691 }
692 Value::Array(items) => {
693 let mut changed = false;
694 for item in items {
695 changed |= truncate(item);
696 }
697 changed
698 }
699 Value::Object(items) => {
700 let mut changed = false;
701 for item in items.values_mut() {
702 changed |= truncate(item);
703 }
704 changed
705 }
706 _ => false,
707 }
708}
709fn output(c: &Cli, mut value: Value) -> Result<(), String> {
710 if !c.full {
711 truncate(&mut value);
712 }
713 let rendered = if c.format == "json" {
714 serde_json::to_string(&value).map_err(|e| e.to_string())?
715 } else {
716 toon_format::encode(&value, &toon_format::EncodeOptions::default())
717 .map_err(|e| e.to_string())?
718 };
719 println!("{rendered}");
720 Ok(())
721}
722pub fn main_exit() -> ExitCode {
723 match Cli::try_parse() {
724 Ok(c) => match execute(&c) {
725 Ok(value) => match output(&c, value) {
726 Ok(()) => ExitCode::SUCCESS,
727 Err(message) => {
728 println!(
729 "{}",
730 serde_json::to_string(
731 &json!({"error":{"type":"output","code":1,"message":message}})
732 )
733 .unwrap()
734 );
735 ExitCode::from(1)
736 }
737 },
738 Err(message) => {
739 let value = json!({"error":{"type":"operational","code":1,"message":message}});
740 let rendered = if c.format == "json" {
741 serde_json::to_string(&value).unwrap()
742 } else {
743 toon_format::encode(&value, &toon_format::EncodeOptions::default()).unwrap()
744 };
745 println!("{rendered}");
746 ExitCode::from(1)
747 }
748 },
749 Err(e) => {
750 let kind = e.kind();
751 if matches!(kind, ErrorKind::DisplayHelp | ErrorKind::DisplayVersion) {
752 print!("{e}");
753 ExitCode::SUCCESS
754 } else {
755 let format = if std::env::args().any(|arg| arg == "json") {
756 "json"
757 } else {
758 "toon"
759 };
760 let value = json!({"error":{"type":"usage","code":2,"message":e.to_string(),"help":"Run `magi-nx-axi --help` or `<command> --help`."}});
761 if format == "json" {
762 println!("{}", serde_json::to_string(&value).unwrap());
763 } else {
764 println!(
765 "{}",
766 toon_format::encode(&value, &toon_format::EncodeOptions::default())
767 .unwrap()
768 );
769 }
770 ExitCode::from(2)
771 }
772 }
773 }
774}
775#[cfg(test)]
776mod tests {
777 use super::*;
778 use clap::CommandFactory;
779 #[test]
780 fn cli_valid() {
781 Cli::command().debug_assert();
782 }
783 #[test]
784 fn truncates() {
785 let mut v = json!({"x":"a".repeat(1001)});
786 assert!(truncate(&mut v));
787 }
788 #[test]
789 fn unicode_page() {
790 assert_eq!(reverse_page("éé", 0, 10_000, usize::MAX)["content"], "éé");
791 }
792}