duvis 0.1.8

Disk usage visualizer for both AI and humans
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

//! Wire DTOs for `--largest N`. Both the JSON form
//! (`{meta, largest: [...]}`) and the NDJSON form (meta line +
//! one entry per line) live here.
//!
//! The meta block is a superset of [`super::tree::WireMeta`] —
//! `largest_requested` and `total_entries` are added so an agent can
//! tell "we saw 10 of 1234" without separate context.

use serde::Serialize;

use crate::classify::Category;
use crate::render::{is_zero_u64, RenderConfig};
use crate::wire::tree::WireMeta;

/// Top-level `--largest --json` envelope: `{meta, largest: [...]}`.
/// No `tree` field — `--largest` is intentionally a flat query, not a
/// hierarchical view.
#[derive(Debug, Serialize)]
pub(crate) struct WireLargestRoot<'a> {
    pub(crate) meta: WireLargestMeta<'a>,
    pub(crate) largest: Vec<WireLargestEntry>,
}

/// Meta block for `--largest`: the shared `WireMeta` flattened in,
/// plus the two largest-specific counters. Flattening keeps the
/// JSON shape identical to the pre-refactor hand-built struct while
/// guaranteeing the base fields can't drift from `--json` / `--ndjson`.
#[derive(Debug, Serialize)]
pub(crate) struct WireLargestMeta<'a> {
    #[serde(flatten)]
    pub(crate) base: WireMeta<'a>,
    /// Surfaced so an agent can tell whether the list it sees was
    /// truncated by `--largest N` or genuinely smaller than N. Pair
    /// with `total_entries` to compute "we saw 10 of 1234".
    pub(crate) largest_requested: usize,
    pub(crate) total_entries: u64,
}

impl<'a> WireLargestMeta<'a> {
    pub(crate) fn from_config(
        config: &'a RenderConfig<'a>,
        largest_requested: usize,
        total_entries: u64,
    ) -> Self {
        Self {
            base: WireMeta::from_config(config),
            largest_requested,
            total_entries,
        }
    }
}

#[derive(Debug, Serialize)]
pub(crate) struct WireLargestEntry {
    pub(crate) name: String,
    pub(crate) relative_path: String,
    pub(crate) depth: u32,
    pub(crate) size: u64,
    pub(crate) size_human: String,
    pub(crate) is_dir: bool,
    pub(crate) category: Category,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub(crate) modified_days_ago: Option<u64>,
    pub(crate) file_count: u64,
    pub(crate) dir_count: u64,
}

/// NDJSON record for `--largest --ndjson`: meta line followed by one
/// entry per line. Schema-compatible with the tree-form NDJSON stream
/// (same `type` discriminator, same per-entry fields including the
/// `truncated_*` pair) so downstream parsers can share code — even
/// though `truncated_*` is always 0 in flat-list mode.
#[derive(Debug, Serialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub(crate) enum WireLargestNdjsonRecord<'a> {
    Meta(WireLargestMeta<'a>),
    Entry(WireLargestNdjsonEntry<'a>),
}

#[derive(Debug, Serialize)]
pub(crate) struct WireLargestNdjsonEntry<'a> {
    pub(crate) name: &'a str,
    pub(crate) relative_path: &'a str,
    pub(crate) depth: u32,
    pub(crate) size: u64,
    pub(crate) size_human: String,
    pub(crate) is_dir: bool,
    pub(crate) category: Category,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub(crate) modified_days_ago: Option<u64>,
    pub(crate) file_count: u64,
    pub(crate) dir_count: u64,
    #[serde(skip_serializing_if = "is_zero_u64")]
    pub(crate) truncated_count: u64,
    #[serde(skip_serializing_if = "is_zero_u64")]
    pub(crate) truncated_size: u64,
}