Unix Goto Development

#!/bin/bash# unix-goto - [Module purpose]# https://github.com/manutej/unix-goto
# Storage locationGOTO_MODULE_FILE="${GOTO_MODULE_FILE:-$HOME/.goto_module}"
# Main functiongoto_module() {    local subcommand="$1"    shift
    case "$subcommand" in        list)            # Implementation            ;;        add)            # Implementation            ;;        --help|-h|help|"")            echo "goto module - [Description]"            echo ""            echo "Usage:"            echo "  goto module list     [Description]"            echo "  goto module add      [Description]"            ;;        *)            echo "Unknown command: $subcommand"            return 1            ;;    esac}

# Add to load sequence (respect dependencies)source "$GOTO_LIB_DIR/history-tracking.sh"source "$GOTO_LIB_DIR/module.sh"  # NEW - add after dependenciessource "$GOTO_LIB_DIR/back-command.sh"

goto() {    case "$1" in        module)  # NEW            if command -v goto_module &> /dev/null; then                shift                goto_module "$@"            else                echo "⚠️  Module command not loaded"            fi            return            ;;    esac}

#!/bin/bash# Test suite for [feature] functionality
set -e
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"source "$SCRIPT_DIR/lib/module.sh"
# Test countersTESTS_PASSED=0TESTS_FAILED=0
# Test helperpass() {    echo "✓ PASS: $1"    ((TESTS_PASSED++))}
fail() {    echo "✗ FAIL: $1"    ((TESTS_FAILED++))}
# Test 1: [Description]test_feature() {    # Arrange    local input="test"
    # Act    local result=$(function_under_test "$input")
    # Assert    if [[ "$result" == "expected" ]]; then        pass "Feature works"    else        fail "Feature failed: got '$result'"    fi}
# Run teststest_feature
# Summaryecho ""echo "Tests passed: $TESTS_PASSED"echo "Tests failed: $TESTS_FAILED"
[ $TESTS_FAILED -eq 0 ] && exit 0 || exit 1

# Unit testtest_get_recent_dirs() {    result=$(__goto_recent_dirs 5)    [ $? -eq 0 ] && pass "Get recent dirs" || fail "Get recent dirs failed"}
# Integration testtest_goto_recent_navigation() {    goto recent 1    [ $? -eq 0 ] && pass "Navigate to recent dir" || fail "Navigation failed"}
# Edge casetest_empty_history() {    rm -f ~/.goto_history    result=$(goto recent)    [[ "$result" == *"No history"* ]] && pass "Empty history" || fail "Empty history check"}
# Performance testtest_recent_speed() {    start=$(date +%s%N)    __goto_recent_dirs 10    end=$(date +%s%N)    duration=$(((end - start) / 1000000))    [ $duration -lt 10 ] && pass "Recent dirs <10ms" || fail "Too slow: ${duration}ms"}

goto module listgoto module add value

goto recent        # Show all recent directoriesgoto recent 5      # Show 5 most recent

git commit -m "feat: implement module feature (CET-XX)
[Detailed explanation]
Features:- Feature 1- Feature 2
Performance:- Metric: value
Tests:- X/X tests passing- 100% coverage
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude <[email protected]>"

__goto_cache_lookup "folder"# Returns:#   0 - Single match found (path to stdout)#   1 - Not found in cache#   2 - Multiple matches found (all paths to stdout)

bookmark add work /path/to/workbookmark remove workgoto @work

goto recent        # Show all recent directoriesgoto recent 5      # Show 5 most recentback              # Go back to previous directory

#!/bin/bash# unix-goto - Recent directories command# https://github.com/manutej/unix-goto
# Get recent directories__goto_recent_dirs() {    local limit="${1:-}"
    if [ ! -f "$GOTO_HISTORY_FILE" ]; then        return 1    fi
    # Extract paths, reverse order, unique, limit    local dirs=$(awk -F'|' '{print $2}' "$GOTO_HISTORY_FILE" | \                 tac | \                 awk '!seen[$0]++' | \                 ${limit:+head -n "$limit"})
    echo "$dirs"    return 0}
# Recent command implementationgoto_recent() {    local limit="${1:-}"
    local dirs=$(__goto_recent_dirs "$limit")
    if [ -z "$dirs" ]; then        echo "No recent directories"        return 1    fi
    echo "$dirs"    return 0}

source "$GOTO_LIB_DIR/history-tracking.sh"source "$GOTO_LIB_DIR/recent-command.sh"  # NEW

goto() {    case "$1" in        recent)            shift            goto_recent "$@"            return            ;;    esac}

#!/bin/bashset -e
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"source "$SCRIPT_DIR/lib/recent-command.sh"
TESTS_PASSED=0TESTS_FAILED=0
pass() { echo "✓ PASS: $1"; ((TESTS_PASSED++)); }fail() { echo "✗ FAIL: $1"; ((TESTS_FAILED++)); }
# Test 1: Get recent directoriestest_get_recent() {    result=$(__goto_recent_dirs)    [ $? -eq 0 ] && pass "Get recent dirs" || fail "Failed"}
# Test 2: Empty historytest_empty_history() {    rm -f ~/.goto_history    result=$(goto_recent)    [[ "$result" == *"No recent"* ]] && pass "Empty history" || fail "Empty check"}
# Test 3: Limit resultstest_limit_results() {    result=$(__goto_recent_dirs 5)    count=$(echo "$result" | wc -l)    [ $count -le 5 ] && pass "Limit to 5" || fail "Limit failed"}
# Run teststest_get_recenttest_empty_historytest_limit_results
echo ""echo "Passed: $TESTS_PASSED, Failed: $TESTS_FAILED"[ $TESTS_FAILED -eq 0 ] && exit 0 || exit 1

git commit -m "feat: implement recent directories command (CET-77)
Add goto recent command to display recently navigated directories.
Features:- List all recent directories- Limit to N most recent- Unique directories only- Reverse chronological order
Performance:- History retrieval: <10ms ✓
Tests:- 3/3 tests passing- 100% coverage
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude <[email protected]>"

#!/bin/bash# Benchmark: Cached vs Uncached Navigation Performance
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"REPO_DIR="$SCRIPT_DIR/.."
source "$SCRIPT_DIR/bench-helpers.sh"source "$REPO_DIR/lib/cache-index.sh"
main() {    bench_header "Cached vs Uncached Navigation Performance"
    echo "Configuration:"    echo "  Iterations: 10"    echo "  Warmup: 3 runs"    echo ""
    benchmark_cached_vs_uncached
    generate_summary}
benchmark_cached_vs_uncached() {    bench_section "Benchmark: Cached vs Uncached Lookup"
    # Setup workspace    local workspace=$(bench_create_workspace "medium")
    # Phase 1: Uncached lookup    echo "Phase 1: Uncached lookup (no cache)"    echo "─────────────────────────────────"
    # Warmup    bench_warmup "__goto_cache_lookup unix-goto" 3
    # Run benchmark    local uncached_stats=$(bench_run "uncached" \        "__goto_cache_lookup unix-goto" 10)
    IFS=',' read -r uc_min uc_max uc_mean uc_median uc_stddev <<< "$uncached_stats"
    bench_print_stats "$uncached_stats" "Uncached Results"
    # Phase 2: Cached lookup    echo ""    echo "Phase 2: Cached lookup (with cache)"    echo "─────────────────────────────────"
    # Build cache    __goto_cache_build
    # Warmup    bench_warmup "__goto_cache_lookup unix-goto" 3
    # Run benchmark    local cached_stats=$(bench_run "cached" \        "__goto_cache_lookup unix-goto" 10)
    IFS=',' read -r c_min c_max c_mean c_median c_stddev <<< "$cached_stats"
    bench_print_stats "$cached_stats" "Cached Results"
    # Calculate speedup    local speedup=$(bench_compare "$uc_mean" "$c_mean")
    echo ""    echo "Speedup Analysis:"    echo "  Speedup ratio:                               ${speedup}x"
    # Assert targets    bench_assert_target "$c_mean" 100 "Cached navigation time"
    # Save results    bench_save_result "cached_vs_uncached" "$uncached_stats" "uncached"    bench_save_result "cached_vs_uncached" "$cached_stats" "cached"
    # Cleanup    bench_cleanup_workspace "$workspace"}
mainexit 0

#!/bin/bash# Benchmark helper functions
BENCH_RESULTS_DIR="${BENCH_RESULTS_DIR:-$HOME/.goto_benchmarks}"
# High-precision timingbench_time_ms() {    local cmd="$*"    local start=$(date +%s%N)    eval "$cmd" > /dev/null 2>&1    local end=$(date +%s%N)    echo $(((end - start) / 1000000))}
# Calculate statisticsbench_calculate_stats() {    local values=("$@")    local count=${#values[@]}
    # Sort values    IFS=$'\n' sorted=($(sort -n <<<"${values[*]}"))
    # Min/Max    local min=${sorted[0]}    local max=${sorted[$((count-1))]}
    # Mean    local sum=0    for val in "${values[@]}"; do        sum=$((sum + val))    done    local mean=$((sum / count))
    # Median    local mid=$((count / 2))    local median=${sorted[$mid]}
    # Standard deviation    local variance=0    for val in "${values[@]}"; do        local diff=$((val - mean))        variance=$((variance + diff * diff))    done    variance=$((variance / count))    local stddev=$(echo "sqrt($variance)" | bc)
    echo "$min,$max,$mean,$median,$stddev"}
# Print headerbench_header() {    local title="$1"    echo "╔══════════════════════════════════════════════════════════════════╗"    printf "║  %-62s  ║\n" "$title"    echo "╚══════════════════════════════════════════════════════════════════╝"    echo ""}
# Print sectionbench_section() {    local title="$1"    echo "$title"    echo "─────────────────────────────────────────────────────────────────"}
# Print statistics blockbench_print_stats() {    local stats="$1"    local label="$2"
    IFS=',' read -r min max mean median stddev <<< "$stats"
    echo ""    echo "$label:"    printf "  Min:                                             %dms\n" "$min"    printf "  Max:                                             %dms\n" "$max"    printf "  Mean:                                            %dms\n" "$mean"    printf "  Median:                                          %dms\n" "$median"    printf "  Std Dev:                                       %.2fms\n" "$stddev"}
# Assert performance targetbench_assert_target() {    local actual="$1"    local target="$2"    local label="$3"
    if [ "$actual" -lt "$target" ]; then        echo "✓ $label meets target: ${actual}ms (target: <${target}ms)"    else        echo "✗ $label exceeds target: ${actual}ms (target: <${target}ms)"    fi}
# Initialize results directorybench_init() {    mkdir -p "$BENCH_RESULTS_DIR"}
# Save benchmark resultbench_save_result() {    bench_init
    local name="$1"    local stats="$2"    local metadata="${3:-}"
    local timestamp=$(date +%s)    local results_file="$BENCH_RESULTS_DIR/results.csv"
    # Create header if file doesn't exist    if [ ! -f "$results_file" ]; then        echo "timestamp,benchmark_name,operation,min_ms,max_ms,mean_ms,median_ms,stddev,metadata" > "$results_file"    fi
    # Append result    echo "$timestamp,$name,$metadata,$stats" >> "$results_file"}
# Create test workspacebench_create_workspace() {    local size="${1:-medium}"    local workspace=$(mktemp -d)
    case "$size" in        small)            # 10 folders            for i in {1..10}; do                mkdir -p "$workspace/folder-$i"            done            ;;        medium)            # 50 folders            for i in {1..50}; do                mkdir -p "$workspace/folder-$i"            done            ;;        large)            # 500 folders            for i in {1..500}; do                mkdir -p "$workspace/folder-$i"            done            ;;    esac
    echo "$workspace"}
# Cleanup workspacebench_cleanup_workspace() {    local workspace="$1"    rm -rf "$workspace"}
# Run benchmark iterationsbench_run() {    local name="$1"    local cmd="$2"    local iterations="${3:-10}"
    local times=()
    for i in $(seq 1 $iterations); do        local time=$(bench_time_ms "$cmd")        times+=("$time")        printf "  Run %2d: %dms\n" "$i" "$time"    done
    bench_calculate_stats "${times[@]}"}
# Warmup iterationsbench_warmup() {    local cmd="$1"    local iterations="${2:-3}"
    for i in $(seq 1 $iterations); do        eval "$cmd" > /dev/null 2>&1    done}
# Compare performancebench_compare() {    local baseline="$1"    local optimized="$2"
    local speedup=$(echo "scale=2; $baseline / $optimized" | bc)    echo "$speedup"}

function_name() {    local param1="$1"    local param2="${2:-default}"
    # Validate inputs    if [ -z "$param1" ]; then        echo "Error: param1 required"        return 1    fi
    # Main logic    local result=$(process "$param1")
    # Return value    echo "$result"    return 0}

# Always check command successif ! goto index rebuild; then    echo "Failed to rebuild cache"    return 1fi
# Use meaningful error messagesif [ ! -d "$target_dir" ]; then    echo "❌ Directory not found: $target_dir"    return 1fi

# Good: Explain why, not what# Cache lookup is O(1) because we use grep on indexed file
# Bad: Explain what (obvious from code)# Set folder_name to first parameterfolder_name="$1"

# Module data file# Version: 1.0# Built: [timestamp]# Format: field1|field2|field3#---value1|value2|value3value1|value2|value3

set -xsource goto.shgoto testset +x

if declare -f __goto_cache_lookup > /dev/null; then    echo "Function loaded"fi

# View cache filecat ~/.goto_index
# Check cache agestat -f %m ~/.goto_index
# Rebuild and observegoto index rebuild

# Developmentsource goto.sh                 # Load all modulesgoto index rebuild             # Rebuild cachebash test-cache.sh             # Run cache testsbash test-benchmark.sh         # Run benchmark testsgoto benchmark all             # Run all benchmarks
# Debuggingset -x; goto project; set +x   # Trace executiondeclare -F | grep goto         # List functionscat ~/.goto_index              # View cache
# Git workflowgit checkout -b feature/CET-XX # Create branchgit commit -m "feat: ..."      # Commit with proper formatgit push origin feature/CET-XX # Push to remote
# Performancetime goto project              # Measure navigationgoto benchmark navigation      # Benchmark navigationgoto index status              # Check cache health