🦘 gump

User types: "proj app"
         ↓
    Shell Integration Layer
    ├── Is "proj" a command/alias/builtin? → Execute normally
    ├── Is "proj" an exact local directory? → cd directly
    └── Query gump
         ↓
    Resolution Pipeline
    ├── 1. Fuzzy match against CWD contents
    │       (matches directory NAMES only, not full paths)
    └── 2. Fuzzy match against frecency database
         ↓
    Fuzzy Matcher (nucleo)
    ├── Score each path against all terms
    ├── Apply term ordering penalties
    ├── Apply last-component boosts
    └── Combine with frecency bonus
         ↓
    Return best match → cd to result

# CWD is /home/user/code
$ ls
myapp/  webapp/  utils/

# Query "app"
# CWD mode matches against: "myapp", "webapp", "utils"
# NOT against: "/home/user/code/myapp", etc.

# This prevents "code" from matching all three due to the parent path

# Tracking hook (pwd mode - only on directory change)
__gump_oldpwd="$PWD"
__gump_pwd_hook() {
    if [[ "$PWD" != "$__gump_oldpwd" ]]; then
        __gump_oldpwd="$PWD"
        command gump add -- "$PWD"
    fi
}
PROMPT_COMMAND="__gump_pwd_hook;$PROMPT_COMMAND"

# Jump function (g command)
g() {
    if [[ $# -eq 0 ]]; then
        builtin cd ~ && __gump_hook
    elif [[ $# -eq 1 && "$1" == "-" ]]; then
        builtin cd - && __gump_hook
    else
        local result
        result=$(command gump query --cwd -- "$@" 2>/dev/null)
        if [[ -z "$result" ]]; then
            result=$(command gump query -- "$@" 2>/dev/null)
        fi
        if [[ -n "$result" ]]; then
            builtin cd -- "$result" && __gump_hook
        else
            echo "gump: no match found" >&2
            return 1
        fi
    fi
}

# No-prefix jumping
command_not_found_handle() {
    # 1. Check local directory
    # 2. Query CWD
    # 3. Query database
    # 4. Fall through to error
}

# Tracking hook (pwd mode - chpwd hook)
__gump_hook() {
    command gump add -- "$PWD"
}
chpwd_functions+=(__gump_hook)

# ZLE widget - intercepts before execution
__gump_accept_line() {
    local first_word="${BUFFER%% *}"

    # Skip if empty or command exists
    if [[ -z "$BUFFER" ]] || whence "$first_word" >/dev/null 2>&1; then
        zle .accept-line
        return
    fi

    # Check local dir, then CWD, then database
    if [[ -d "$first_word" ]]; then
        BUFFER="cd ${(q)first_word}"
    else
        local result
        result=$(command gump query --cwd -- $=BUFFER 2>/dev/null)
        if [[ -z "$result" ]]; then
            result=$(command gump query -- $=BUFFER 2>/dev/null)
        fi
        if [[ -n "$result" ]]; then
            BUFFER="cd ${(q)result}"
        fi
    fi

    zle .accept-line
}

zle -N accept-line __gump_accept_line

# Tracking hook (pwd mode - PWD variable)
function __gump_hook --on-variable PWD
    command gump add -- $PWD
end

# Jump function
function g --description "Jump to a directory"
    if test (count $argv) -eq 0
        cd ~
    else if test (count $argv) -eq 1 -a "$argv[1]" = "-"
        cd -
    else
        set -l result (command gump query --cwd -- $argv 2>/dev/null)
        if test -z "$result"
            set result (command gump query -- $argv 2>/dev/null)
        end
        if test -n "$result"
            cd $result
        else
            echo "gump: no match found" >&2
            return 1
        end
    end
end

# No-prefix jumping via Enter key
function __gump_execute
    set -l cmd (commandline -b)
    set -l first_word (string split ' ' -- $cmd)[1]

    # Skip if empty or command exists
    if test -z "$first_word"; or type -q "$first_word"
        commandline -f execute
        return
    end

    # Check local, CWD, database
    # Rewrite commandline if match found
end

bind \r __gump_execute
bind \n __gump_execute

#!/bin/bash
# Switch to a git worktree using gump

worktree=$(gump query --all "$1" | while read dir; do
    if git -C "$dir" rev-parse --is-inside-work-tree &>/dev/null; then
        echo "$dir"
        break
    fi
done)

if [[ -n "$worktree" ]]; then
    cd "$worktree"
else
    echo "No git worktree found matching: $1"
fi

frecency = raw_score × time_multiplier

where:
  raw_score = number of accesses (increments by 1 each visit)
  time_multiplier = based on last_accessed timestamp

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DirEntry {
    /// Raw access score (increments by 1 on each access)
    pub score: f64,

    /// Last time this directory was accessed
    pub last_accessed: DateTime<Utc>,

    /// Total number of times accessed
    pub access_count: u64,
}

impl DirEntry {
    pub fn record_access(&mut self) {
        self.score += 1.0;
        self.last_accessed = Utc::now();
        self.access_count += 1;
    }
}

pub fn frecency(&self) -> f64 {
    let now = Utc::now();
    let duration = now.signed_duration_since(self.last_accessed);
    let hours = duration.num_hours();

    let multiplier = if hours < 1 {
        4.0    // Within 1 hour
    } else if hours < 24 {
        2.0    // Within 1 day
    } else if hours < 24 * 7 {
        0.5    // Within 1 week
    } else {
        0.25   // Older
    };

    self.score * multiplier
}

fn maybe_age(&mut self) {
    let total: f64 = self.data.entries.values().map(|e| e.score).sum();

    if total > self.max_age {
        // Calculate reduction factor (target 90% of max)
        let k = total / (self.max_age * 0.9);

        // Divide all scores, remove entries below 1.0
        self.data.entries.retain(|_, entry| {
            entry.score /= k;
            entry.score >= 1.0
        });
    }
}

use nucleo::{
    pattern::{CaseMatching, Normalization, Pattern},
    Matcher as NucleoMatcher, Utf32Str,
};

pub struct Matcher {
    nucleo: NucleoMatcher,
}

impl Matcher {
    pub fn new() -> Self {
        Self {
            nucleo: NucleoMatcher::new(nucleo::Config::DEFAULT),
        }
    }

    pub fn score(&mut self, path: &Path, terms: &[String]) -> Option<u32> {
        let path_str = path.to_string_lossy();
        let mut haystack_buf = Vec::new();
        let haystack = Utf32Str::new(&path_str, &mut haystack_buf);

        let mut total_score: u32 = 0;

        for term in terms {
            let pattern = Pattern::new(
                term,
                CaseMatching::Ignore,      // Case insensitive
                Normalization::Smart,       // Smart Unicode normalization
                nucleo::pattern::AtomKind::Fuzzy,
            );

            match pattern.score(haystack, &mut self.nucleo) {
                Some(score) => total_score = total_score.saturating_add(score),
                None => return None,  // All terms must match
            }
        }

        Some(total_score)
    }
}

// Boost score if last term matches last path component
if let Some(last_term) = terms.last() {
    if let Some(last_component) = path.file_name() {
        // Check fuzzy match on last component
        if pattern.score(comp_haystack, &mut self.nucleo).is_some() {
            total_score = total_score.saturating_add(100);

            // Extra boost for exact match
            if last_comp_lower == last_term_lower {
                total_score = total_score.saturating_add(50);
            }
        }
    }
}

// Frecency adds up to 25% bonus for tiebreaking
frecency_bonus = 1.0 + (frecency / 160.0).min(0.25)

// Fuzzy score is the base, frecency is secondary
combined_score = fuzzy_score × frecency_bonus

// On-disk format (bincode serialized)
struct DatabaseFile {
    version: u32,                    // Schema version (currently 1)
    entries: HashMap<PathBuf, DirEntry>,
    last_cleanup: DateTime<Utc>,
}

// Each directory entry
struct DirEntry {
    score: f64,                      // Raw access score
    last_accessed: DateTime<Utc>,    // UTC timestamp
    access_count: u64,               // Total accesses
}

pub fn save(&self) -> Result<(), DatabaseError> {
    // Ensure parent directory exists
    if let Some(parent) = self.path.parent() {
        fs::create_dir_all(parent)?;
    }

    // Serialize to bytes
    let bytes = bincode::serialize(&self.data)?;

    // Write to temp file first
    let temp_path = self.path.with_extension("bin.tmp");
    {
        let mut file = OpenOptions::new()
            .write(true)
            .create(true)
            .truncate(true)
            .open(&temp_path)?;
        file.write_all(&bytes)?;
        file.sync_all()?;  // Ensure data hits disk
    }

    // Atomic rename
    fs::rename(&temp_path, &self.path)?;

    Ok(())
}

fn canonicalize_path<P: AsRef<Path>>(&self, path: P) -> Result<PathBuf, DatabaseError> {
    let path = path.as_ref();

    // Handle "." specially
    let path = if path == Path::new(".") {
        std::env::current_dir()?
    } else {
        path.to_path_buf()
    };

    // Try to canonicalize (resolves symlinks)
    match fs::canonicalize(&path) {
        Ok(p) => Ok(p),
        Err(_) => {
            // If canonicalize fails, make it absolute
            if path.is_absolute() {
                Ok(path)
            } else {
                let cwd = std::env::current_dir()?;
                Ok(cwd.join(path))
            }
        }
    }
}