Skip to main content

weavatrix_md/
lib.rs

1//! Tiny deterministic cross-repository integration map.
2//!
3//! Local mode depends only on `weavatrix-scan` and `weavatrix-parse`. It never
4//! opens a network connection or executes repository code.
5
6#![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
36/// Crate version compiled into the binary.
37pub const VERSION: &str = env!("CARGO_PKG_VERSION");
38
39/// Process output for the CLI and integration tests.
40#[derive(Debug, Clone, PartialEq, Eq)]
41pub struct CliOutput {
42    /// Exit code.
43    pub code: i32,
44    /// Stdout body.
45    pub stdout: String,
46    /// Stderr body.
47    pub stderr: String,
48}
49
50/// Runs the CLI against already-split argv (no binary name).
51#[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
89/// Analyzes every peer once, then writes or checks each target.
90///
91/// # Errors
92///
93/// Scan, resolution, or file IO fails.
94pub 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
141/// Writes CLI output to the real stdout/stderr.
142///
143/// # Errors
144///
145/// Stdout/stderr writes fail.
146pub 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}