moeix 0.4.2

High-performance trigram code search for humans and AI agents.
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

//! ix — trigram code search library
//!
//! Build order: `format` → `varint` → `trigram` → `bloom` → `posting` →
//!              `string_pool` → `builder` → `reader` → `planner` → `executor` → `scanner`

// Lint configuration — Tier 1 security hardened, pedantic with pragmatic allow
#![warn(clippy::pedantic)]
#![allow(clippy::cast_possible_truncation)] // 64-bit target; try_from guards runtime
#![allow(clippy::cast_possible_wrap)] // controlled internal values
#![allow(clippy::cast_sign_loss)] // controlled internal values
#![allow(clippy::module_name_repetitions)] // module::Type is idiomatic
#![allow(clippy::too_many_lines)] // scanner/executor are well-structured
#![warn(missing_docs)] // enterprise: every public item documented
#![cfg_attr(test, allow(missing_docs))] // tests: no doc needed for test fns
#![warn(clippy::semicolon_if_nothing_returned)]
#![warn(clippy::non_ascii_literal)]
#![warn(clippy::unimplemented)]
#![warn(clippy::use_self)]
#![warn(clippy::string_slice)]
#![warn(clippy::clone_on_ref_ptr)]

extern crate llmosafe;

pub mod archive;
pub mod bloom;
pub mod builder;
pub mod config;
pub mod decompress;
/// Error types for the ix crate.
pub mod error;
pub mod executor;
pub mod format;
#[cfg(feature = "notify")]
pub mod idle;
pub mod planner;
pub mod posting;
pub mod reader;
pub mod scanner;
pub mod string_pool;
pub mod trigram;
pub mod varint;
#[cfg(feature = "notify")]
pub mod watcher;

#[cfg(feature = "notify")]
pub use crate::builder::Builder;
#[cfg(feature = "notify")]
pub use crate::format::Beacon;
#[cfg(feature = "notify")]
pub use crate::idle::IdleTracker;
#[cfg(feature = "notify")]
pub use crate::watcher::Watcher;

/// Run the daemon watching the given directory for changes and rebuilding the index.
///
/// # Errors
///
/// Returns an error if the root cannot be canonicalized, the index cannot be built,
/// or the file watcher fails.
///
/// # Panics
///
/// Panics if the Ctrl-C handler cannot be set (which is extremely rare).
#[cfg(feature = "notify")]
pub fn run_daemon(path: &std::path::Path) -> crate::error::Result<()> {
    use std::fs;
    use std::sync::Arc;
    use std::sync::atomic::{AtomicBool, Ordering};
    use std::time::Duration;

    let root = path.canonicalize().map_err(crate::error::Error::Io)?;

    println!("ixd: watching {}...", root.display());

    let mut builder = Builder::new(&root)?;

    // Lazy startup: if index exists, just update. Otherwise build.
    let ix_dir = root.join(".ix");
    let index_file = ix_dir.join("shard.ix");
    if index_file.exists() {
        println!("ixd: existing index found, performing startup update...");
        // In a real implementation we would load the 'files' table from the shard
        // to know which files to check for changes. For now we just build to satisfy
        // the current Builder API, but we've already optimized Builder's memory.
        builder.build()?;
    } else {
        builder.build()?;
    }

    println!(
        "ixd: initial index ready ({} files, {} trigrams)",
        builder.files_len(),
        builder.trigrams_len()
    );

    let mut watcher = Watcher::new(&root);
    let rx = watcher.start()?;

    let ix_dir = root.join(".ix");
    if !ix_dir.exists() {
        fs::create_dir_all(&ix_dir)?;
    }
    let mut beacon = Beacon::new(&root);
    beacon.write_to(&ix_dir)?;

    let mut idle = IdleTracker::new();

    let running = Arc::new(AtomicBool::new(true));
    let r = std::sync::Arc::clone(&running);
    ctrlc::set_handler(move || {
        r.store(false, Ordering::SeqCst);
    })
    .expect("Error setting Ctrl-C handler");

    while running.load(Ordering::SeqCst) {
        match rx.recv_timeout(Duration::from_secs(5)) {
            Ok(changed_files) => {
                println!(
                    "ixd: {} files changed, updating index...",
                    changed_files.len()
                );

                beacon.status = "indexing".to_string();
                beacon.last_event_at = std::time::SystemTime::now()
                    .duration_since(std::time::UNIX_EPOCH)
                    .unwrap_or_default()
                    .as_secs();
                let _ = beacon.write_to(&ix_dir);

                idle.record_change();
                builder.update(&changed_files)?;

                beacon.status = "idle".to_string();
                let _ = beacon.write_to(&ix_dir);
            }
            Err(crossbeam_channel::RecvTimeoutError::Timeout) => {}
            Err(crossbeam_channel::RecvTimeoutError::Disconnected) => break,
        }
    }

    println!("ixd: shutting down");
    let _ = fs::remove_file(ix_dir.join("beacon.json"));
    watcher.stop();
    Ok(())
}