Skip to content
ahjdzxPublic

About

Find your local git repos by describing them. Semantic search with a built-in local embedding model — offline, no API key. macOS / Windows / Linux.

Topics

Resources

Stars

1 star

Watchers

0 watching

Forks

Latest commit

 

History

18 Commits

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

RepoFind icon

RepoFind

English | 简体中文

Search your local git repos in plain language. A client-only desktop app — no server, no Python, no Node.

Cloned hundreds of repos and forgot what they were called or where you put them? RepoFind builds a semantic index over them. Type "scripts for automating the browser" and puppeteer, your userscripts and playwright come out on top, even when not a single word matches the repo name or README. Works in English, Chinese, or a mix.

Search: "scripts for automating the browser"

Atlas: repos by topic, language and how long since you touched them

Screenshots use a set of demo repos. Top: searching "scripts for automating the browser" with the built-in local model. Bottom: the Atlas page.

Features

  • Client-only — built on nsh (Native Shell): scanning the file system, indexing and running the embedding model all happen inside the app
  • Hybrid ranking — 0.6 × semantic (cosine similarity) + 0.4 × lexical (TF-IDF): semantics finds what you meant, lexical keeps exact name matches on top
  • Mixed English/Chinese tokenizer — CJK bigrams, camelCase splitting, path segments weighted separately
  • Three ways to get vectors — a local model that runs inside the app (default: multilingual-e5-small, downloaded once, then fully offline), an embedding server already running on your machine (LM Studio, llama.cpp, Ollama), or any OpenAI-compatible API
  • Atlas (the first page) — repos grouped by topic, language, recency, local commits, source and owner; click any of them to filter, and search only within what you filtered
  • Open where you work — every result opens in Finder (File Explorer / the file manager) or a terminal; on macOS pick Terminal, iTerm, Ghostty, Warp… in Settings
  • Incremental re-indexing — rebuilding the index only re-embeds repos whose text changed
  • No git dependency — branch, remote and last commit are read straight from .git internals (HEAD / config / logs/HEAD); no git process is spawned
  • English and Chinese UI — one click in the top bar

Download

Pick your platform's file from Releases:

Platform File Needs
macOS, Apple silicon RepoFind-<version>-macos-arm64.zip macOS 14+
macOS, Intel RepoFind-<version>-macos-x86_64.zip macOS 14+
Linux RepoFind-<version>-linux-x86_64.tar.gz / -linux-arm64.tar.gz glibc 2.39+, GTK 4.14+ (Ubuntu 24.04 or later)
Windows RepoFind-<version>-windows-x86_64.zip Windows 10 1809+
  • macOS: unzip and move RepoFind.app to Applications. The build is ad hoc signed, not notarized, so macOS blocks the first launch; clear the quarantine flag once with xattr -dr com.apple.quarantine /Applications/RepoFind.app.
  • Linux: extract the archive and run the RepoFind executable inside it.
  • Windows: unzip and run RepoFind.exe. It is not code signed, so SmartScreen warns on first launch.

Local models are not available in the Intel Mac build (ONNX Runtime ships no prebuilt library for it); use a local service or an external API there.

Only the Apple silicon build has been run by hand so far; the others are built and tested headlessly in CI. Reports are welcome.

Run from source

Needs the nsh CLI and a Rust toolchain (the local embedding engine is Rust).

brew install longbridge/tap/nsh        # the nsh CLI
git clone https://github.com/ahjdzx/repofind.git
cd repofind/app
nsh run --target macos

Scanning local directories needs a desktop target (macOS / Windows / Linux). --target web shows the UI, but a browser cannot read your file system, so it cannot build an index.

Setup (Settings page)

Scan roots: space-separated, ~ is expanded, e.g. ~/work ~/code; must be inside your home directory (see Permissions).

Embedding: pick one of three sources.

Source What it is Setup
Local model (default) Inference inside the app with ONNX Runtime Nothing: the default model downloads on the first index. Others can be downloaded, switched or deleted in Settings
Local service An OpenAI-compatible server on your machine Base URL (LM Studio http://127.0.0.1:1234/v1, llama.cpp :8080/v1, Ollama :11434/v1) and the model name it lists
External API Any OpenAI-compatible embeddings API Base URL, model name, API key (stored in plain text in the app's on-device Storage, sent only to that URL)

Local models (int8-quantized ONNX, timings per repo measured on an Apple M1):

Model Download Speed Notes
multilingual-e5-small 135 MB ~40 ms Default; 100+ languages, Chinese and English both fine
bge-small-zh-v1.5 25 MB ~20 ms Smallest; strong on Chinese, weaker on English READMEs
multilingual-e5-base 296 MB ~160 ms Larger e5
bge-m3 587 MB ~500 ms Best results in our tests; about 1.5 GB of memory while loaded

Models download from huggingface.co or hf-mirror.com, whichever answers faster; if the download slows to a crawl or drops, it moves to the other one and carries on where it stopped (the source can also be fixed in Settings). Each model is checked against its published SHA-256 before it is used. A loaded model is unloaded after 3 idle minutes. Switching models means rebuilding the index. Without any working source the app still works, with lexical search only.

Press Build index now on the search page (or SCAN + INDEX in Settings), then describe what you are looking for:

  • The search box searches as you type (300 ms debounce)
  • The number on the left is the relevance score (amber = semantic hit, grey = lexical only)
  • Click a row to copy its path; Open in Finder / Open in Terminal under each result; GitHub repos link to their remote
  • SEM+ / LEX next to the search box switches between hybrid and lexical-only

The index and vectors are kept in the app's data directory and are there after a restart. Cloned something new? Rebuild the index; repos whose text did not change keep their vectors.

Permissions

The app declares only the capabilities it uses, in app/nsh.json:

Capability Scope Used for
Read files Home directory, app data directory Scanning repos, reading the index back
Write files App data directory only Saving the index, vectors and downloaded models
Network Any host Model downloads, and the embedding endpoint you choose
Clipboard / open URL https Copying paths, opening GitHub

To scan somewhere outside your home directory (an external drive, say), add that path to capabilities.fs.read and run from source.

What leaves your machine: with a local model, nothing (only the one-time model download). With a local service or an external API: when indexing, each repo's name, path (in ~ form), languages and the first 1500 characters of its README go to the embedding endpoint you configured; when searching, the query does. Lexical-only mode makes no requests.

Development

app/
  lib.ts         # scanning (.git parsing) · tokenizer · TF-IDF · OpenAI-compatible client · hybrid ranking · persistence
  embedder.ts    # the three embedding sources, settings migration
  tags.ts        # topic / language / recency tags for the Atlas
  App.tsx        # UI: search, Atlas, Settings, status bar
  Atlas.tsx      # tag statistics and the radar view
  src/           # Rust: local models (catalog, downloader, ONNX Runtime engine)
  App.test.tsx   # regression tests: fake file system, fake embedding endpoint, stand-in local models
  locales/       # zh-CN / en strings
cd app
nsh check                     # type check
nsh test                      # headless regression tests
cargo test --release -- --ignored   # downloads a real model, checks resume and inference
nsh package --target macos    # build RepoFind.app into .nsh/out

Roadmap

  • Lexical + semantic hybrid search
  • In-app model configuration, English/Chinese UI
  • Index and vectors persisted to disk
  • Packaged macOS app
  • Incremental scan (only rescan repos that changed)
  • Only re-embed repos whose text changed
  • Local embedding models inside the app
  • File-name level index
  • Packages for Intel Macs, Linux and Windows
  • Notarized / code-signed builds
  • TUI target

License

MIT

About

Find your local git repos by describing them. Semantic search with a built-in local embedding model — offline, no API key. macOS / Windows / Linux.

Topics

Resources

Stars

1 star

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages