try-cli 1.7.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a6b118821db0d2fc53ac1fdb38f5574d13bee02e25b39d7362f51ab7aa128976
+  data.tar.gz: a3eb513bf97a2a9fe0e082d1b3166049c320739261158768a40880aa9d04ca54
+SHA512:
+  metadata.gz: bbcc44f8afa56ae146d95a03dadec98bea06b0726fafed760926d9662c30321f19632c171b766956878c88b0b5e318f201c31894a73be571509d0ec0eda91ebf
+  data.tar.gz: 6759723862c35789b434bb0339397334b25cb046d06bba86632b8639eeaf2bb593cc65ff82aef891e122bc966d38d1c98c48357807a4a63e643f985944514442

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Tobi Lutke
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,259 @@
+# try - fresh directories for every vibe
+
+*Your experiments deserve a home.* 🏠
+
+> For everyone who constantly creates new projects for little experiments, a one-file Ruby script to quickly manage and navigate to keep them somewhat organized
+
+Ever find yourself with 50 directories named `test`, `test2`, `new-test`, `actually-working-test`, scattered across your filesystem? Or worse, just coding in `/tmp` and losing everything?
+
+**try** is here for your beautifully chaotic mind.
+
+# What it does 
+
+![Fuzzy Search Demo](assets/try-fuzzy-search-demo.gif)
+
+*[View interactive version on asciinema](https://asciinema.org/a/ve8AXBaPhkKz40YbqPTlVjqgs)*
+
+Instantly navigate through all your experiment directories with:
+- **Fuzzy search** that just works
+- **Smart sorting** - recently used stuff bubbles to the top
+- **Auto-dating** - creates directories like `2025-08-17-redis-experiment`
+- **Zero config** - just one Ruby file, no dependencies
+
+## Quick Start
+
+```bash
+curl -sL https://raw.githubusercontent.com/tobi/try/refs/heads/main/try.rb > ~/.local/try.rb
+
+# Make "try" executable so it can be run directly
+chmod +x ~/.local/try.rb
+
+# Add to your shell (bash/zsh)
+echo 'eval "$(ruby ~/.local/try.rb init ~/src/tries)"' >> ~/.zshrc
+
+# for fish shell users
+echo 'eval (~/.local/try.rb init ~/src/tries | string collect)' >> ~/.config/fish/config.fish
+```
+
+## The Problem
+
+You're learning Redis. You create `/tmp/redis-test`. Then `~/Desktop/redis-actually`. Then `~/projects/testing-redis-again`. Three weeks later you can't find that brilliant connection pooling solution you wrote at 2am.
+
+## The Solution
+
+All your experiments in one place, with instant fuzzy search:
+
+```bash
+$ try pool
+→ 2025-08-14-redis-connection-pool    2h, 18.5
+  2025-08-03-thread-pool              3d, 12.1
+  2025-07-22-db-pooling               2w, 8.3
+  + Create new: pool
+```
+
+Type, arrow down, enter. You're there.
+
+## Features
+
+### 🎯 Smart Fuzzy Search
+Not just substring matching - it's smart:
+- `rds` matches `redis-server`
+- `connpool` matches `connection-pool`
+- Recent stuff scores higher
+- Shorter names win on equal matches
+
+### ⏰ Time-Aware
+- Shows how long ago you touched each project
+- Recently accessed directories float to the top
+- Perfect for "what was I working on yesterday?"
+
+### 🎨 Pretty TUI
+- Clean, minimal interface
+- Highlights matches as you type
+- Shows scores so you know why things are ranked
+- Dark mode by default (because obviously)
+
+### 📁 Organized Chaos
+- Everything lives in `~/src/tries` (configurable via `TRY_PATH`)
+- Auto-prefixes with dates: `2025-08-17-your-idea`
+- Skip the date prompt if you already typed a name
+
+### Shell Integration
+
+- Bash/Zsh:
+
+  ```bash
+  # default is ~/src/tries
+  eval "$(~/.local/try.rb init)"
+  # or pick a path
+  eval "$(~/.local/try.rb init ~/src/tries)"
+  ```
+
+- Fish:
+
+  ```fish
+  eval (~/.local/try.rb init | string collect)
+  # or pick a path
+  eval (~/.local/try.rb init ~/src/tries | string collect)
+  ```
+
+Notes:
+- The runtime commands printed by `try` are shell-neutral (absolute paths, quoted). Only the small wrapper function differs per shell.
+
+## Usage
+
+```bash
+try                                          # Browse all experiments
+try redis                                    # Jump to redis experiment or create new
+try new api                                  # Start with "2025-08-17-new-api"
+try . [name]                                   # Create a dated worktree dir for current repo
+try ./path/to/repo [name]                      # Use another repo as the worktree source
+try worktree dir [name]                        # Same as above, explicit CLI form
+try clone https://github.com/user/repo.git  # Clone repo into date-prefixed directory
+try https://github.com/user/repo.git        # Shorthand for clone (same as above)
+try --help                                   # See all options
+```
+
+Notes on worktrees (`try .` / `try worktree dir`):
+- With a custom [name], uses that; otherwise uses cwd’s basename. Both are prefixed with today’s date.
+- Inside a Git repo: adds a detached HEAD git worktree to the created directory.
+- Outside a repo: simply creates the directory and changes into it.
+
+### Git Repository Cloning
+
+**try** can automatically clone git repositories into properly named experiment directories:
+
+```bash
+# Clone with auto-generated directory name
+try clone https://github.com/tobi/try.git
+# Creates: 2025-08-27-tobi-try
+
+# Clone with custom name
+try clone https://github.com/tobi/try.git my-fork
+# Creates: my-fork
+
+# Shorthand syntax (no need to type 'clone')
+try https://github.com/tobi/try.git
+# Creates: 2025-08-27-tobi-try
+```
+
+Supported git URI formats:
+- `https://github.com/user/repo.git` (HTTPS GitHub)
+- `git@github.com:user/repo.git` (SSH GitHub)
+- `https://gitlab.com/user/repo.git` (GitLab)
+- `git@host.com:user/repo.git` (SSH other hosts)
+
+The `.git` suffix is automatically removed from URLs when generating directory names.
+
+### Keyboard Shortcuts
+
+- `↑/↓` or `Ctrl-P/N/J/K` - Navigate
+- `Enter` - Select or create
+- `Backspace` - Delete character
+- `Ctrl-D` - Delete directory (with confirmation)
+- `ESC` - Cancel
+- Just type to filter
+
+## Configuration
+
+Set `TRY_PATH` to change where experiments are stored:
+
+```bash
+export TRY_PATH=~/code/sketches
+```
+
+Default: `~/src/tries`
+
+## Nix
+
+### Quick start
+
+```bash
+nix run github:tobi/try
+nix run github:tobi/try -- --help
+nix run github:tobi/try init ~/my-tries
+```
+
+### Home Manager
+
+```nix
+{
+  inputs.try.url = "github:tobi/try";
+  
+  imports = [ inputs.try.homeManagerModules.default ];
+  
+  programs.try = {
+    enable = true;
+    path = "~/experiments";  # optional, defaults to ~/src/tries
+  };
+}
+```
+
+## Homebrew
+
+### Quick start
+
+```bash
+brew tap tobi/try https://github.com/tobi/try
+brew install try
+```
+
+After installation, add to your shell:
+
+- Bash/Zsh:
+
+  ```bash
+  # default is ~/src/tries
+  eval "$(try init)"
+  # or pick a path
+  eval "$(try init ~/src/tries)"
+  ```
+
+- Fish:
+
+  ```fish
+  eval "(try init | string collect)"
+  # or pick a path
+  eval "(try init ~/src/tries | string collect)"
+  ```
+
+## Why Ruby?
+
+- One file, no dependencies
+- Works on any system with Ruby (macOS has it built-in)
+- Fast enough for thousands of directories
+- Easy to hack on
+
+## The Philosophy
+
+Your brain doesn't work in neat folders. You have ideas, you try things, you context-switch like a caffeinated squirrel. This tool embraces that.
+
+Every experiment gets a home. Every home is instantly findable. Your 2am coding sessions are no longer lost to the void.
+
+## FAQ
+
+**Q: Why not just use `cd` and `ls`?**
+A: Because you have 200 directories and can't remember if you called it `test-redis`, `redis-test`, or `new-redis-thing`.
+
+**Q: Why not use `fzf`?**
+A: fzf is great for files. This is specifically for project directories, with time-awareness and auto-creation built in.
+
+**Q: Can I use this for real projects?**
+A: You can, but it's designed for experiments. Real projects deserve real names in real locations.
+
+**Q: What if I have thousands of experiments?**
+A: First, welcome to the club. Second, it handles it fine - the scoring algorithm ensures relevant stuff stays on top.
+
+## Contributing
+
+It's one file. If you want to change something, just edit it. Send a PR if you think others would like it too.
+
+## License
+
+MIT - Do whatever you want with it.
+
+---
+
+*Built for developers with ADHD by developers with ADHD.*
+
+*Your experiments deserve a home.* 🏠

data/VERSION

@@ -0,0 +1 @@
+1.7.1

data/bin/try

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../try'

data/lib/fuzzy.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+# Fuzzy string matching with scoring and highlight positions
+#
+# Usage:
+#   entries = [
+#     { text: "2024-01-15-project", base_score: 3.2 },
+#     { text: "2024-02-20-another", base_score: 1.5 },
+#   ]
+#   fuzzy = Fuzzy.new(entries)
+#
+#   # Get all matches
+#   fuzzy.match("proj").each do |entry, positions, score|
+#     puts "#{entry[:text]} score=#{score} highlight=#{positions.inspect}"
+#   end
+#
+#   # Limit results
+#   fuzzy.match("proj").limit(10).each { |entry, positions, score| ... }
+#
+class Fuzzy
+  Entry = Data.define(:data, :text, :text_lower, :base_score)
+
+  def initialize(entries)
+    @entries = entries.map do |e|
+      text = e[:text] || e["text"]
+      Entry.new(
+        data: e,
+        text: text,
+        text_lower: text.downcase,
+        base_score: e[:base_score] || e["base_score"] || 0.0
+      )
+    end
+  end
+
+  # Returns a MatchResult enumerator for the query
+  def match(query)
+    MatchResult.new(@entries, query.to_s)
+  end
+
+  # Enumerator wrapper that supports .limit() and .each
+  class MatchResult
+    include Enumerable
+
+    def initialize(entries, query)
+      @entries = entries
+      @query = query
+      @query_lower = query.downcase
+      @query_chars = @query_lower.chars
+      @limit = nil
+    end
+
+    # Set maximum number of results
+    def limit(n)
+      @limit = n
+      self
+    end
+
+    # Iterate over matches: yields (entry_data, highlight_positions, score)
+    def each(&block)
+      return enum_for(:each) unless block_given?
+
+      results = []
+
+      @entries.each do |entry|
+        score, positions = calculate_match(entry)
+        next if score.nil?  # No match
+
+        results << [entry.data, positions, score]
+      end
+
+      # Sort by score descending
+      results.sort_by! { |_, _, score| -score }
+
+      # Apply limit
+      results = results.first(@limit) if @limit
+
+      results.each(&block)
+    end
+
+    private
+
+    # Pre-computed sqrt values for proximity bonus (gap 0-15)
+    SQRT_TABLE = (0..16).map { |n| 2.0 / Math.sqrt(n + 1) }.freeze
+
+    def calculate_match(entry)
+      positions = []
+      score = entry.base_score
+
+      # Empty query = match all with base score only
+      return [score, positions] if @query.empty?
+
+      text = entry.text_lower
+      query_chars = @query_chars
+      query_len = query_chars.length
+
+      last_pos = -1
+      pos = 0
+
+      query_chars.each do |qc|
+        # Find next occurrence of query char starting from pos
+        found = text.index(qc, pos)
+        return nil unless found  # No match
+
+        positions << found
+
+        # Base match point
+        score += 1.0
+
+        # Word boundary bonus (start of string or after non-alphanumeric)
+        if found == 0 || text[found - 1].match?(/[^a-z0-9]/)
+          score += 1.0
+        end
+
+        # Proximity bonus (consecutive chars score higher)
+        if last_pos >= 0
+          gap = found - last_pos - 1
+          score += gap < 16 ? SQRT_TABLE[gap] : (2.0 / Math.sqrt(gap + 1))
+        end
+
+        last_pos = found
+        pos = found + 1
+      end
+
+      # Density bonus: prefer shorter spans
+      score *= (query_len.to_f / (last_pos + 1)) if last_pos >= 0
+
+      # Length penalty: shorter strings score higher
+      score *= (10.0 / (entry.text.length + 10.0))
+
+      [score, positions]
+    end
+  end
+end