Method run

atomic-cli/src/commands/memory/list.rs:269–347

(&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 items: Vec<(String, 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), e.updated_at.clone()))
            .collect();
        // Most-recent first (`updated_at` is RFC 3339, so lexical == chronological);
        // id as a stable tiebreaker.
        items.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));
        if let Some(limit) = self.limit {
            items.truncate(limit);
        }

        let rows: Vec<Row> = items
            .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");