devist 0.1.1

Project bootstrap CLI for AI-assisted development. Spin up new projects from templates, manage backends, and keep your codebase comprehensible.
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

use anyhow::{anyhow, Result};
use console::style;
use notify::RecursiveMode;
use notify_debouncer_mini::new_debouncer;
use std::path::Path;
use std::sync::mpsc::channel;
use std::time::Duration;

use crate::registry::Registry;

pub fn run(name: String, debounce_ms: u64) -> Result<()> {
    let reg = Registry::load()?;
    let project = reg
        .find(&name)
        .ok_or_else(|| anyhow!("Project not found: {}", name))?
        .clone();

    if !project.path.exists() {
        return Err(anyhow!(
            "Project directory missing: {}",
            project.path.display()
        ));
    }

    println!("{}", style("devist watch").bold());
    println!(
        "  watching {} (debounce {}ms)",
        style(project.path.display()).cyan(),
        debounce_ms
    );
    println!("  press Ctrl+C to stop");
    println!();

    let (tx, rx) = channel();
    let mut debouncer = new_debouncer(Duration::from_millis(debounce_ms), tx)?;

    debouncer
        .watcher()
        .watch(&project.path, RecursiveMode::Recursive)?;

    for res in rx {
        match res {
            Ok(events) => {
                let interesting: Vec<&notify_debouncer_mini::DebouncedEvent> =
                    events.iter().filter(|e| !is_ignored(&e.path)).collect();
                if interesting.is_empty() {
                    continue;
                }
                print_change_block(&interesting, &project.path);
            }
            Err(error) => {
                eprintln!("  {} {:?}", style("[WATCH-ERR]").red(), error);
            }
        }
    }

    Ok(())
}

fn print_change_block(events: &[&notify_debouncer_mini::DebouncedEvent], project_root: &Path) {
    let now = chrono::Local::now().format("%H:%M:%S");
    println!(
        "{} {} {}",
        style(format!("[{}]", now)).dim(),
        style("CHANGE").yellow(),
        style(format!("{} file(s)", events.len())).bold()
    );
    for e in events {
        let rel = e
            .path
            .strip_prefix(project_root)
            .map(|p| p.to_path_buf())
            .unwrap_or_else(|_| e.path.clone());
        println!("  {} {}", style("ยท").dim(), rel.display());
    }
    println!();
}

const IGNORED_DIRS: &[&str] = &[
    "node_modules",
    "target",
    "dist",
    "build",
    ".next",
    ".turbo",
    ".cache",
    ".venv",
    "venv",
    "__pycache__",
    ".pytest_cache",
    ".git",
    ".idea",
    ".vscode",
    ".expo",
    ".dart_tool",
];

const IGNORED_FILES: &[&str] = &[".DS_Store"];

fn is_ignored(path: &Path) -> bool {
    let s = path.to_string_lossy();
    for d in IGNORED_DIRS {
        if s.contains(&format!("/{}/", d))
            || s.contains(&format!("\\{}\\", d))
            || s.ends_with(&format!("/{}", d))
        {
            return true;
        }
    }
    if let Some(name) = path.file_name().and_then(|n| n.to_str()) {
        if IGNORED_FILES.contains(&name) {
            return true;
        }
    }
    false
}