Method run

atomic-cli/src/commands/memory/list.rs:265–339

(&self)

impl Command for MemoryList {
    fn run(&self) -> CliResult<()> {
        let root = find_repository_root()?;
        let repo = Repository::open(&root).map_err(CliError::Repository)?;

        let verifier = resolve_verifier(&self.identity)?;

        // Enumerate via the SAME call `atomic vault memory list` makes; the
        // `memory/` prefix already excludes attestation entries, and the filter
        // is a belt-and-suspenders guard (mirrors memory/mod.rs' invariant test).
        let entries = repo
            .vault_list("memory/", None)
            .map_err(CliError::Repository)?;
        let mut ids: Vec<String> = entries
            .iter()
            .filter(|e| !e.path.starts_with("attestations/"))
            // The default `memory/MEMORY.md` index scaffold is NOT a canonical
            // memory (no `uid`/`memoryKind`; its frontmatter is `type:index`).
            // Skip it so the attestation-aware list only shows real memories.
            .filter(|e| !is_index_scaffold(&repo, &e.path))
            .map(|e| bridge::memory_id(&e.path))
            .collect();
        // vault_list is prefix-scan order, not sorted: sort by id for stability.
        ids.sort();

        let rows: Vec<Row> = ids
            .iter()
            .map(|id| compute_row(&repo, id, verifier.as_ref()))
            .collect();

        if self.json {
            let json: Vec<serde_json::Value> = rows
                .iter()
                .map(|r| {
                    serde_json::json!({
                        "id": r.id,
                        "kind": r.kind,
                        "status": r.status,
                        "about": r.about,
                        "attested": r.attested.json(),
                        "verifies": r.verifies.json(),
                    })
                })
                .collect();
            println!("{}", serde_json::to_string_pretty(&json).unwrap());
            return Ok(());
        }

        if rows.is_empty() {
            println!("No memories found.");
            return Ok(());
        }

        // Fixed-width, left-aligned columns with a header row.
        let id_w = col_width(rows.iter().map(|r| r.id.chars().count()), "id");
        let kind_w = col_width(rows.iter().map(|r| r.kind.chars().count()), "kind");
        let status_w = col_width(rows.iter().map(|r| r.status.chars().count()), "status");

        println!(