ccat 0.1.1

CLAUDE.md Context Analyzer - A comprehensive tool for analyzing and managing Claude Code memory files
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
141
142
143
144
145
146
147
148
149

use super::Formatter;
use crate::core::{MemoryFile, MemoryType};
use anyhow::Result;
use colored::Colorize;
use std::io::{self, Write};

pub struct TextFormatter {
    content_only: bool,
    show_metadata: bool,
    expand_imports: bool,
}

impl Default for TextFormatter {
    fn default() -> Self {
        Self::new()
    }
}

impl TextFormatter {
    pub fn new() -> Self {
        Self {
            content_only: false,
            show_metadata: false,
            expand_imports: true,
        }
    }

    pub fn with_content_only(mut self, value: bool) -> Self {
        self.content_only = value;
        self
    }

    pub fn with_show_metadata(mut self, value: bool) -> Self {
        self.show_metadata = value;
        self
    }

    pub fn with_expand_imports(mut self, value: bool) -> Self {
        self.expand_imports = value;
        self
    }

    fn format_header(&self, file: &MemoryFile) -> String {
        let type_badge = match file.file_type {
            MemoryType::ProjectMemory => "[PROJECT]".green(),
            MemoryType::UserMemory => "[USER]".blue(),
            MemoryType::LocalMemory => "[LOCAL]".yellow(),
            MemoryType::SubdirMemory => "[SUBDIR]".cyan(),
        };

        format!("{} {}", type_badge, file.path.display().to_string().bold())
    }

    fn format_metadata(&self, file: &MemoryFile) -> String {
        let meta = &file.metadata;
        format!(
            "  Size: {} | Lines: {} | Modified: {} | Hash: {}",
            format_size(meta.size).dimmed(),
            meta.line_count.to_string().dimmed(),
            meta.modified
                .format("%Y-%m-%d %H:%M:%S")
                .to_string()
                .dimmed(),
            &meta.hash[..8].dimmed()
        )
    }

    fn format_imports(&self, file: &MemoryFile) -> String {
        if file.imports.is_empty() {
            return String::new();
        }

        let mut output = String::from("  Imports:\n");
        for import in &file.imports {
            let status = if import.resolved_path.is_some() {
                "✓".green()
            } else {
                "✗".red()
            };
            output.push_str(&format!(
                "    {} {} (line {})\n",
                status, import.path, import.line_number
            ));
        }
        output
    }
}

impl Formatter for TextFormatter {
    fn format(&self, files: &[MemoryFile]) -> Result<()> {
        let stdout = io::stdout();
        let mut handle = stdout.lock();

        for (i, file) in files.iter().enumerate() {
            if i > 0 {
                writeln!(handle, "\n{}", "─".repeat(80).dimmed())?;
            }

            // Header
            if !self.content_only {
                writeln!(handle, "{}", self.format_header(file))?;

                if self.show_metadata {
                    writeln!(handle, "{}", self.format_metadata(file))?;
                }

                if !file.imports.is_empty() {
                    write!(handle, "{}", self.format_imports(file))?;
                }

                writeln!(handle)?;
            }

            // Content
            if self.content_only {
                write!(handle, "{}", file.content)?;
            } else {
                // Add line numbers
                for (line_no, line) in file.content.lines().enumerate() {
                    writeln!(
                        handle,
                        "{:4} │ {}",
                        (line_no + 1).to_string().dimmed(),
                        line
                    )?;
                }
            }
        }

        Ok(())
    }
}

fn format_size(bytes: u64) -> String {
    const UNITS: &[&str] = &["B", "KB", "MB", "GB"];
    let mut size = bytes as f64;
    let mut unit_index = 0;

    while size >= 1024.0 && unit_index < UNITS.len() - 1 {
        size /= 1024.0;
        unit_index += 1;
    }

    if unit_index == 0 {
        format!("{} {}", size as u64, UNITS[unit_index])
    } else {
        format!("{:.2} {}", size, UNITS[unit_index])
    }
}