Skip to main content

magi_nx_axi/
lib.rs

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}