minni 0.1.0

Local memory, task, and codebase indexing tool for AI agents
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

use crate::db::Database;
use crate::journal::JournalManager;
use anyhow::Result;
use colored::Colorize;
use std::env;
use std::path::Path;

pub fn run() -> Result<()> {
    let cwd = env::current_dir()?;

    if Database::minni_dir_exists(&cwd) {
        println!(
            "{} Minni is already initialized in this directory",
            "!".yellow()
        );
        return Ok(());
    }

    let _db = Database::initialize(&cwd)?;

    println!("{} Initialized minni in {}", "✓".green(), cwd.display());
    println!();
    println!("Next steps:");
    println!("  {} Index your codebase", "minni index".cyan());
    println!("  {} Search for code", "minni search \"your query\"".cyan());
    println!("  {} Save session context", "minni context save".cyan());

    Ok(())
}

/// Auto-initialize minni if not already done. Returns true if initialization was performed.
/// Optionally installs git hooks and runs initial index.
pub fn ensure_initialized(project_root: &Path, full_setup: bool) -> Result<bool> {
    if Database::minni_dir_exists(project_root) {
        return Ok(false);
    }

    println!("{} Auto-initializing minni...", "→".blue());
    let _db = Database::initialize(project_root)?;
    println!(
        "{} Initialized minni in {}",
        "✓".green(),
        project_root.display()
    );

    // Add .minni to .gitignore if not already present
    add_to_gitignore(project_root)?;

    if full_setup {
        // Install git hooks if this is a git repo
        let git_dir = project_root.join(".git");
        if git_dir.exists() {
            let journal = JournalManager::new(project_root);
            if journal.install_hooks().is_ok() {
                println!("{} Git hooks installed for auto-journaling", "✓".green());
            }
        }

        // Run initial index
        println!("{} Running initial index...", "→".blue());
        crate::cli::index::run(Some(project_root.to_path_buf()), false)?;
    }

    Ok(true)
}

/// Add .minni/ to .gitignore if not already present
fn add_to_gitignore(project_root: &Path) -> Result<()> {
    let gitignore_path = project_root.join(".gitignore");

    let content = if gitignore_path.exists() {
        std::fs::read_to_string(&gitignore_path)?
    } else {
        String::new()
    };

    // Check if .minni is already ignored
    if content.lines().any(|line| {
        let trimmed = line.trim();
        trimmed == ".minni" || trimmed == ".minni/" || trimmed == "/.minni" || trimmed == "/.minni/"
    }) {
        return Ok(());
    }

    // Append .minni/ to .gitignore
    let mut new_content = content;
    if !new_content.is_empty() && !new_content.ends_with('\n') {
        new_content.push('\n');
    }
    if !new_content.is_empty() {
        new_content.push('\n');
    }
    new_content.push_str("# Minni - local codebase index (https://github.com/youruser/minni)\n");
    new_content.push_str(".minni/\n");

    std::fs::write(&gitignore_path, new_content)?;
    println!("{} Added .minni/ to .gitignore", "✓".green());

    Ok(())
}