aicx 0.9.2

Operator CLI + MCP server: canonical corpus first, optional semantic index second (Claude Code, Codex, Gemini)
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use anyhow::Result;
use std::collections::BTreeMap;
use std::fs;
use std::path::Path;

use crate::corpus::inference::{
    infer_agent, infer_frame_kind, infer_path_date, system_date, system_timestamp,
};
use crate::corpus::io::{markdown_files, validate_optional_root};
use crate::corpus::noise::detect_noise_classes;
use crate::corpus::roots::default_roots;
use crate::corpus::types::{
    CorpusAuditOptions, CorpusAuditReport, CorpusAuditTotals, CorpusFileFinding, RootAuditReport,
};
use crate::sanitize;

pub fn audit(options: &CorpusAuditOptions) -> Result<CorpusAuditReport> {
    let roots = if options.roots.is_empty() {
        default_roots()?
    } else {
        options.roots.clone()
    }
    .into_iter()
    .map(validate_optional_root)
    .collect::<Result<Vec<_>>>()?;

    let mut reports = Vec::new();
    let mut totals = CorpusAuditTotals::default();

    for root in roots {
        let report = audit_root(&root)?;
        if report.present {
            totals.roots_present += 1;
        } else {
            totals.roots_missing += 1;
        }
        totals.markdown_files += report.markdown_files;
        totals.files_with_noise += report.files_with_noise;
        merge_counts(&mut totals.noise_classes, &report.noise_classes);
        merge_counts(&mut totals.agents, &report.agents);
        merge_counts(&mut totals.frame_kinds, &report.frame_kinds);
        merge_counts(&mut totals.path_dates, &report.path_dates);
        reports.push(report);
    }

    Ok(CorpusAuditReport {
        roots: reports,
        totals,
    })
}

fn audit_root(root: &Path) -> Result<RootAuditReport> {
    if !root.is_dir() {
        return Ok(RootAuditReport {
            root: root.to_path_buf(),
            present: false,
            markdown_files: 0,
            files_with_noise: 0,
            noise_classes: BTreeMap::new(),
            agents: BTreeMap::new(),
            frame_kinds: BTreeMap::new(),
            path_dates: BTreeMap::new(),
            artifact_birthtime_dates: BTreeMap::new(),
            artifact_mtime_dates: BTreeMap::new(),
            examples: Vec::new(),
        });
    }

    let mut report = RootAuditReport {
        root: root.to_path_buf(),
        present: true,
        markdown_files: 0,
        files_with_noise: 0,
        noise_classes: BTreeMap::new(),
        agents: BTreeMap::new(),
        frame_kinds: BTreeMap::new(),
        path_dates: BTreeMap::new(),
        artifact_birthtime_dates: BTreeMap::new(),
        artifact_mtime_dates: BTreeMap::new(),
        examples: Vec::new(),
    };

    for path in markdown_files(root)? {
        report.markdown_files += 1;
        let content = sanitize::read_to_string_validated(&path).unwrap_or_default();
        let classes = detect_noise_classes(&content);
        let agent = infer_agent(&path, &content);
        inc(&mut report.agents, agent.clone());
        if let Some(frame_kind) = infer_frame_kind(&path, &content) {
            inc(&mut report.frame_kinds, frame_kind);
        }
        if let Some(path_date) = infer_path_date(&path) {
            inc(&mut report.path_dates, path_date);
        }
        if let Ok(meta) = fs::metadata(&path) {
            if let Ok(created) = meta.created() {
                inc(&mut report.artifact_birthtime_dates, system_date(created));
            }
            if let Ok(modified) = meta.modified() {
                inc(&mut report.artifact_mtime_dates, system_date(modified));
            }
        }

        if !classes.is_empty() {
            report.files_with_noise += 1;
            for class in &classes {
                inc(&mut report.noise_classes, class.as_str().to_string());
            }
            if report.examples.len() < 20 {
                report.examples.push(CorpusFileFinding {
                    path: path.clone(),
                    agent,
                    frame_kind: infer_frame_kind(&path, &content),
                    path_date: infer_path_date(&path),
                    artifact_birthtime: fs::metadata(&path)
                        .ok()
                        .and_then(|m| m.created().ok())
                        .map(system_timestamp),
                    artifact_mtime: fs::metadata(&path)
                        .ok()
                        .and_then(|m| m.modified().ok())
                        .map(system_timestamp),
                    noise_classes: classes.iter().map(|c| c.as_str().to_string()).collect(),
                });
            }
        }
    }

    Ok(report)
}

fn merge_counts(target: &mut BTreeMap<String, usize>, source: &BTreeMap<String, usize>) {
    for (key, value) in source {
        *target.entry(key.clone()).or_default() += value;
    }
}

fn inc(map: &mut BTreeMap<String, usize>, key: String) {
    *map.entry(key).or_default() += 1;
}