1#![forbid(unsafe_code)]
7
8mod aliases;
9mod cli;
10mod detector;
11mod discover;
12mod error;
13mod mcp;
14mod model;
15mod normalize;
16mod render;
17mod resolve;
18mod source;
19mod tokens;
20mod write;
21
22pub use cli::{Command, OutputMode, parse, usage};
23pub use discover::{RepoRef, Scope, folder_scope, target_scope};
24pub use error::{Error, Result};
25pub use model::{
26 ApiDirection, ApiObservation, ApiProtocol, ApiRelation, DatabaseEngine, DatabaseObservation,
27 DatabaseRelation, KafkaObservation, KafkaRelation, KafkaRole, RepoId, RepoInventory,
28 RepositoryMap,
29};
30pub use mcp::serve as serve_mcp;
31pub use render::render;
32pub use write::FILENAME;
33
34use std::io::{self, Write};
35
36pub const VERSION: &str = env!("CARGO_PKG_VERSION");
38
39#[derive(Debug, Clone, PartialEq, Eq)]
41pub struct CliOutput {
42 pub code: i32,
44 pub stdout: String,
46 pub stderr: String,
48}
49
50#[must_use]
52pub fn run(args: &[String]) -> CliOutput {
53 match parse(args) {
54 Ok(Command::Help) => CliOutput {
55 code: 0,
56 stdout: format!("{}\n", usage()),
57 stderr: String::new(),
58 },
59 Ok(Command::Version) => CliOutput {
60 code: 0,
61 stdout: format!("weavatrix-md {VERSION}\n"),
62 stderr: String::new(),
63 },
64 Ok(command) => match execute(&command) {
65 Ok(output) => output,
66 Err(error) => CliOutput {
67 code: 2,
68 stdout: String::new(),
69 stderr: format!("weavatrix-md: {error}\n"),
70 },
71 },
72 Err(error) => CliOutput {
73 code: 2,
74 stdout: String::new(),
75 stderr: format!("weavatrix-md: {error}\n{}", usage()),
76 },
77 }
78}
79
80fn execute(command: &Command) -> Result<CliOutput> {
81 let (scope, output) = match command {
82 Command::Help | Command::Version => unreachable!(),
83 Command::Target { path, output } => (discover::target_scope(path.as_deref())?, *output),
84 Command::Folder { folder, output } => (discover::folder_scope(folder)?, *output),
85 };
86 generate(&scope, output)
87}
88
89pub fn generate(scope: &Scope, output: OutputMode) -> Result<CliOutput> {
95 let mut inventories = Vec::new();
96 for peer in &scope.peers {
97 inventories.push(source::inventory(peer)?);
98 }
99 let names: Vec<String> = scope.targets.iter().map(|repo| repo.name.clone()).collect();
100 let maps = resolve::resolve(&inventories, &names);
101 let mut connections = 0_usize;
102 let mut stale = false;
103 let mut stdout = String::new();
104 for (target, map) in scope.targets.iter().zip(maps.iter()) {
105 let markdown = render(map);
106 connections += map.connection_count();
107 match output {
108 OutputMode::Stdout => stdout.push_str(&markdown),
109 OutputMode::Write => write::atomic_write(&target.root, &markdown)?,
110 OutputMode::Check => {
111 let existing = write::read_existing(&target.root)?;
112 if existing.as_deref() != Some(markdown.as_str()) {
113 stale = true;
114 }
115 }
116 }
117 }
118 let scanned = scope.peers.len();
119 let summary = match output {
120 OutputMode::Write => format!(
121 "{scanned} repositories scanned, {connections} connections proven, {FILENAME} updated\n"
122 ),
123 OutputMode::Check if stale => {
124 format!("{FILENAME} is stale; run weavatrix-md to regenerate\n")
125 }
126 OutputMode::Check => format!("{FILENAME} is up to date\n"),
127 OutputMode::Stdout => String::new(),
128 };
129 let (code, stderr) = match output {
130 OutputMode::Check if stale => (1, summary),
131 OutputMode::Stdout => (0, String::new()),
132 _ => (0, summary),
133 };
134 Ok(CliOutput {
135 code,
136 stdout,
137 stderr,
138 })
139}
140
141pub fn emit(output: &CliOutput) -> io::Result<()> {
147 let mut stdout = io::stdout().lock();
148 let mut stderr = io::stderr().lock();
149 stdout.write_all(output.stdout.as_bytes())?;
150 stderr.write_all(output.stderr.as_bytes())?;
151 Ok(())
152}