Method run

atomic-cli/src/commands/memory/validate.rs:31–89

(&self)

impl Command for MemoryValidate {
    fn run(&self) -> CliResult<()> {
        // A path-shaped argument (ends in `.md` or contains a separator) is
        // loaded as a file; a missing file is reported as FileNotFound rather
        // than misreported as a bad id. Otherwise it is a memory id read
        // through the vault bridge; a FRESH attestation gates the attested node
        // (so a previously-attested memory reports conforms), a STALE one warns
        // and falls back to the raw node.
        let node = if is_path_shaped(&self.id_or_path) {
            let path = Path::new(&self.id_or_path);
            if !path.is_file() {
                return Err(CliError::FileNotFound {
                    path: path.to_path_buf(),
                });
            }
            let doc = std::fs::read_to_string(path).map_err(CliError::Io)?;
            let (fm, body) = parse_markdown(&doc).map_err(|e| CliError::InvalidArgument {
                message: format!("could not parse markdown frontmatter: {e}"),
            })?;
            lift_memory(&fm, &body).map_err(|e| CliError::InvalidArgument {
                message: format!("could not lift memory: {e}"),
            })?
        } else {
            let root = find_repository_root()?;
            let repo = Repository::open(&root).map_err(CliError::Repository)?;
            let inputs = bridge::read_memory(&repo, &self.id_or_path)?;
            match bridge::load_attestation(&repo, &self.id_or_path, &inputs)? {
                bridge::Attestation::Fresh(node) => *node,
                bridge::Attestation::Stale(_) => {
                    eprintln!(
                        "warning: the attestation for {} is stale (the memory changed since it \
                         was signed); re-run `atomic memory attest {}`.",
                        self.id_or_path, self.id_or_path
                    );
                    bridge::lift(&inputs)?
                }
                bridge::Attestation::None => bridge::lift(&inputs)?,
            }
        };

        let report = validate_memory(&node);

        if self.json {
            println!(
                "{}",
                serde_json::to_string_pretty(&report_json(&report)).unwrap()
            );
        } else {
            print!("{report}");
        }

        if report.conforms {
            Ok(())
        } else {
            Err(validation_failed(format!(
                "memory does not conform ({} violation(s))",
                report.results.len()
            )))
        }