grepmax 0.2.5 → 0.3.1

package/README.md

@@ -23,7 +23,7 @@ Natural-language search that works like `grep`. Fast, local, and built for codin
 - **Call Graph Tracing:** Map dependencies with `trace` to see who calls what.
 - **Role Detection:** Distinguishes `ORCHESTRATION` (high-level logic) from `DEFINITION` (types/classes).
 - **Local & Private:** 100% local embeddings via ONNX (CPU) or MLX (Apple Silicon GPU).
-- **Auto-Isolated:** Each repository gets its own index automatically.
+- **Centralized Index:** One database at `~/.gmax/` — index once, search from anywhere.
 - **Agent-Ready:** Native output with symbols, roles, and call graphs.
 
 ## Quick Start
@@ -41,25 +41,30 @@ Natural-language search that works like `grep`. Fast, local, and built for codin
 
     Downloads embedding models (~150MB) upfront and lets you choose between CPU (ONNX) and GPU (MLX) embedding modes. If you skip this, models download automatically on first use.
 
-3.  **Search**
+3.  **Index**
 
     ```bash
     cd my-repo
-    gmax "where do we handle authentication?"
+    gmax index
     ```
 
-    **Your first search will automatically index the repository.** Each repository is automatically isolated with its own index. Switching between repos "just works" — no manual configuration needed. If the background server is running (`gmax serve`), search goes through the hot daemon; otherwise it falls back to on-demand indexing.
+    Indexes into a centralized store at `~/.gmax/lancedb/`. You can index any directory — a single repo, a monorepo, or an entire workspace.
+
+4.  **Search**
+
+    ```bash
+    gmax "where do we handle authentication?"
+    ```
 
-4.  **Trace** (Call Graph)
+5.  **Trace** (Call Graph)
 
     ```bash
     gmax trace "function_name"
     ```
-See who calls a function (upstream dependencies) and what it calls (downstream dependencies). Perfect for impact analysis and understanding code flow.
+    See who calls a function (upstream dependencies) and what it calls (downstream dependencies).
 
-To find the symbols in your code base:
     ```bash
-    gmax symbols
+    gmax symbols                  # List all indexed symbols
     ```
 
 In our public benchmarks, `grepmax` can save about 20% of your LLM tokens and deliver a 30% speedup.
@@ -68,53 +73,44 @@ In our public benchmarks, `grepmax` can save about 20% of your LLM tokens and de
   <img src="public/bench.png" alt="gmax benchmark" width="100%" style="border-radius: 8px; margin: 20px 0;" />
 </div>
 
+## Agent Plugins
 
-
-### Claude Code Plugin
+### Claude Code
 
 1. Run `gmax install-claude-code`
-2. Open Claude Code (`claude`) and ask it questions about your codebase.
-3. Highly recommend indexing your code base before using the plugin.
-4. The plugin's hooks auto-start `gmax serve` in the background and shut it down on session end. Claude will use `gmax` for semantic searches automatically but can be encouraged to do so.
+2. Open Claude Code — the plugin auto-starts the MLX GPU server and a background file watcher.
+3. Claude uses `gmax` for semantic searches automatically via MCP tools.
 
-### Opencode Plugin
+### Opencode
 1. Run `gmax install-opencode`
-2. Open OC (`opencode`) and ask it questions about your codebase.
-3. Highly recommend indexing your code base before using the plugin.
-4. The plugin's hooks auto-start `gmax serve` in the background and shut it down on session end. OC will use `gmax` for semantic searches automatically but can be encouraged to do so.
+2. OC uses `gmax` for semantic searches via MCP.
 
-### Codex Plugin
+### Codex
 1. Run `gmax install-codex`
-2. Codex will use `gmax` for semantic searches.
+2. Codex uses `gmax` for semantic searches.
 
-### Factory Droid Plugin
+### Factory Droid
 1. Run `gmax install-droid`
 2. To remove: `gmax uninstall-droid`
 
 ### MCP Server
 
-gmax exposes tools via the [Model Context Protocol](https://modelcontextprotocol.io/) for any MCP-compatible AI agent or editor.
-
-```bash
-gmax mcp
-```
-
-This starts a stdio-based MCP server that auto-launches the `gmax serve` daemon. Available tools:
+`gmax mcp` starts a stdio-based MCP server that searches the centralized index directly — no HTTP daemon needed.
 
 | Tool | Description |
 | --- | --- |
-| `semantic_search` | Natural language code search with score filtering and per-file caps |
+| `semantic_search` | Natural language code search. Use `root` to search a parent or sibling directory. |
+| `search_all` | Search ALL indexed code across every directory. |
 | `code_skeleton` | Collapsed file structure (~4x fewer tokens than reading the full file) |
-| `trace_calls` | Call graph — who calls a symbol and what it calls |
+| `trace_calls` | Call graph — who calls a symbol and what it calls (unscoped, crosses project boundaries) |
 | `list_symbols` | List indexed functions, classes, and types with definition locations |
-| `index_status` | Check daemon status, file count, embed mode, and index age |
-
+| `index_status` | Check index health: chunk counts, indexed directories, model info |
 
 ## Commands
 
 ### `gmax search`
 
-The default command. Searches the current directory using semantic meaning.
+The default command. Searches indexed code using semantic meaning.
 
 ```bash
 gmax "how is the database connection pooled?"
@@ -133,147 +129,68 @@ gmax "how is the database connection pooled?"
 | `--skeleton` | Show code skeleton for matching files instead of snippets. | `false` |
 | `--plain` | Disable ANSI colors and use simpler formatting. | `false` |
 | `-s`, `--sync` | Force re-index changed files before searching. | `false` |
-| `-d`, `--dry-run` | Show what would be indexed without actually indexing. | `false` |
 
 **Examples:**
 
 ```bash
-# General concept search
 gmax "API rate limiting logic"
-
-# Deep dive (show more matches per file)
 gmax "error handling" --per-file 5
-
-# Just give me the files
 gmax "user validation" --compact
-
-# Show relevance scores and filter low-confidence matches
 gmax "authentication" --scores --min-score 0.5
-
-# Show skeletons of matching files
 gmax "database connection" --skeleton
 ```
 
 ### `gmax index`
 
-Manually indexes the repository. Useful if you want to pre-warm the cache or if you've made massive changes outside of the editor.
-
-- Respects `.gitignore` and `.gmaxignore` (see [Configuration](#ignoring-files) section).
-- **Smart Indexing:** Only embeds code and config files. Skips binaries, lockfiles, and minified assets.
-- **Bounded Concurrency:** Uses a fixed thread pool to keep your system responsive.
-- **Semantic Chunking:** Uses TreeSitter grammars for supported languages (TypeScript, JavaScript, Python, Go, Rust, C/C++, Java, C#, Ruby, PHP, Swift, Kotlin, JSON).
-
-**Options:**
-
-| Flag | Description | Default |
-| --- | --- | --- |
-| `-d`, `--dry-run` | See what would be indexed without making changes. | `false` |
-| `-p`, `--path <dir>` | Path to index (defaults to current directory). | `.` |
-| `-r`, `--reset` | Remove existing index and re-index from scratch. | `false` |
-| `-v`, `--verbose` | Show detailed progress with file names. | `false` |
-
-**Examples:**
-
-```bash
-gmax index                    # Index current dir
-gmax index --dry-run          # See what would be indexed
-gmax index --verbose          # Watch detailed progress (useful for debugging)
-gmax index --reset            # Full re-index from scratch
-```
-
-### `gmax serve`
-
-Runs a lightweight HTTP server with live file watching so searches stay hot in RAM.
-
-- Keeps LanceDB and the embedding worker resident for <50ms responses.
-- **Live reindexing:** Watches the repo (via chokidar) and incrementally re-indexes on file change.
-- **Idle timeout:** Automatically shuts down after 30 minutes of inactivity (disable with `--no-idle-timeout`).
-- Endpoints:
-  - `GET /health` — liveness check
-  - `GET /stats` — file count, chunk count, embed mode, index age, watcher status
-  - `POST /search` — `{ query, limit, path }`
+Index a directory into the centralized store.
 
-**Options:**
-
-| Flag | Description |
-| --- | --- |
-| `-p, --port <port>` | Port to listen on (default `4444`, retries up to 10 ports if taken) |
-| `-b, --background` | Run server in background and exit immediately |
-| `--cpu` | Use CPU-only embeddings (skip MLX GPU server) |
-| `--no-idle-timeout` | Disable the 30-minute idle shutdown |
-
-**Port Selection (priority order):**
-1. Explicit `-p <port>` flag
-2. `GMAX_PORT` environment variable
-3. Default `4444` (auto-increments if in use)
-
-**Usage:**
+- Respects `.gitignore` and `.gmaxignore`.
+- Only embeds code and config files. Skips binaries, lockfiles, and minified assets.
+- Uses TreeSitter for semantic chunking (TypeScript, JavaScript, Python, Go, Rust, C/C++, Java, C#, Ruby, PHP, Swift, Kotlin, JSON).
+- Files already indexed with matching content are skipped automatically.
 
 ```bash
-gmax serve                    # Foreground, port 4444 (or next available)
-gmax serve --background       # Background mode, auto port
-gmax serve -b -p 5000         # Background on specific port
+gmax index                        # Index current dir
+gmax index --path ~/workspace     # Index a specific directory
+gmax index --dry-run              # See what would be indexed
+gmax index --verbose              # Watch detailed progress
+gmax index --reset                # Full re-index from scratch
 ```
 
-**Subcommands:**
-
-```bash
-gmax serve status             # Show server status for current directory
-gmax serve stop               # Stop server in current directory
-gmax serve stop --all         # Stop all running gmax servers
-```
+### `gmax watch`
 
-**Example workflow:**
+Background file watcher for live reindexing. Watches for file changes and incrementally updates the centralized index.
 
 ```bash
-# Start servers in multiple projects
-cd ~/project-a && gmax serve -b    # Starts on port 4444
-cd ~/project-b && gmax serve -b    # Starts on port 4445 (auto-increment)
-
-# Check status
-gmax serve status
-
-# Stop all when done
-gmax serve stop --all
+gmax watch -b                     # Background mode (auto-stops after 30min idle)
+gmax watch --path ~/workspace     # Watch a specific directory
+gmax watch status                 # Show running watchers
+gmax watch stop --all             # Stop all watchers
 ```
 
-Claude Code hooks start/stop this automatically; you rarely need to run it manually.
+The MCP server auto-starts a watcher on session start. You rarely need to run this manually.
 
-### `gmax list`
+### `gmax serve`
 
-Lists all indexed repositories (stores) and their metadata.
+HTTP server with live file watching. Useful for non-MCP integrations.
 
 ```bash
-gmax list
+gmax serve                        # Foreground, port 4444
+gmax serve --background           # Background mode
+gmax serve --cpu                  # Force CPU-only embeddings
 ```
 
-Shows store names, sizes, and last modified times. Useful for seeing what's indexed and cleaning up old stores.
-
 ### `gmax skeleton`
 
-Generates a compressed "skeleton" of a file, showing only signatures, types, and class structures while eliding function bodies.
+Compressed view of a file — signatures with bodies collapsed.
 
 ```bash
 gmax skeleton src/lib/auth.ts
+gmax skeleton AuthService         # Find symbol, skeletonize its file
+gmax skeleton "auth logic"        # Search, skeletonize top matches
 ```
 
-**Output:**
-```typescript
-class AuthService {
-  validate(token: string): boolean {
-    // → jwt.verify, checkScope, .. | C:5 | ORCH
-  }
-}
-```
-
-**Modes:**
-- `gmax skeleton <file>`: Skeletonize specific file.
-- `gmax skeleton <Symbol>`: Find symbol in index and skeletonize its file.
-- `gmax skeleton "query"`: Search for query and skeletonize top matches.
-
-**Supported Languages:**
-TypeScript, JavaScript, Python, Go, Rust, Java, C#, C++, C, Ruby, PHP, Swift, Kotlin.
-
+**Supported Languages:** TypeScript, JavaScript, Python, Go, Rust, Java, C#, C++, C, Ruby, PHP, Swift, Kotlin.
 
 ### `gmax doctor`
 
@@ -283,88 +200,68 @@ Checks installation health, model paths, and database integrity.
 gmax doctor
 ```
 
-## Performance & Architecture
+## Architecture
 
-gmax is designed to be a "good citizen" on your machine:
+### Centralized Index
 
-1.  **Bounded Concurrency:** Chunking/embedding stay within small thread pools (1–4) and capped batch sizes to keep laptops responsive.
-2.  **Smart Chunking:** Uses `tree-sitter` to split code by function/class boundaries, ensuring embeddings capture complete logical blocks.
-3.  **Deduplication:** Identical code blocks (boilerplate, license headers) are embedded once and cached, saving space and time.
-4.  **Semantic Split Search:** Queries both "Code" and "Docs" separately to ensure documentation doesn't drown out implementation details, then reranks with ColBERT.
-5.  **Global Batching:** A producer/consumer pipeline decouples chunking from embedding. Files are chunked concurrently, queued, embedded in fat batches, and written to LanceDB in bulk.
-6.  **Anchor-Only Scans & Batch Deletes:** File discovery and stale cleanup hit only anchor rows, and stale/changed paths are removed with a single `IN` delete to minimize I/O.
-7.  **Structural Boosting:** Function/class chunks get a small score boost; test/spec paths are slightly downweighted to bubble up primary definitions first.
-8.  **Role Classification:** Detects `ORCHESTRATION` functions (high complexity, many calls) vs `DEFINITION` (types/classes) to help agents prioritize where to read.
+All data lives in `~/.gmax/`:
+- `~/.gmax/lancedb/` — LanceDB vector store (one database for all indexed directories)
+- `~/.gmax/cache/meta.lmdb` — file metadata cache (content hashes, mtimes)
+- `~/.gmax/config.json` — global config (model tier, embed mode)
+- `~/.gmax/models/` — embedding models
+- `~/.gmax/grammars/` — Tree-sitter grammars
+- `~/.gmax/projects.json` — registry of indexed directories
 
-## Configuration
+All chunks store **absolute file paths**. Search scoping is done via path prefix filtering. There are no per-project index directories.
 
-### Automatic Repository Isolation
+### Performance
 
-gmax automatically creates a unique index for each repository based on:
+- **Bounded Concurrency:** Worker threads scale to 50% of CPU cores (min 4). Override with `GMAX_WORKER_THREADS`.
+- **Smart Chunking:** `tree-sitter` splits code by function/class boundaries for complete logical blocks.
+- **Deduplication:** Identical code blocks are embedded once and cached.
+- **Multi-stage Search:** Vector search + FTS + RRF fusion + ColBERT reranking + structural boosting.
+- **Role Classification:** Detects `ORCHESTRATION` (high complexity, many calls) vs `DEFINITION` (types/classes).
 
-1. **Git Remote URL** (e.g., `github.com/facebook/react` → `facebook-react`)
-2. **Git Repo without Remote** → directory name + hash (e.g., `utils-7f8a2b3c`)
-3. **Non-Git Directory** → directory name + hash for collision safety
+### GPU Embeddings (Apple Silicon)
 
-**Examples:**
-```bash
-cd ~/work/myproject        # Auto-detected: owner-myproject
-gmax "API handlers"
+On Macs with Apple Silicon, gmax defaults to MLX for GPU-accelerated embeddings. The MLX embed server runs on port `8100` and is managed automatically by the Claude Code plugin hook.
 
-cd ~/personal/utils        # Auto-detected: utils-abc12345
-gmax "helper functions"
-```
+To force CPU mode: `GMAX_EMBED_MODE=cpu gmax index`
 
-Stores are isolated automatically — no manual `--store` flags needed!
+## Configuration
 
 ### Ignoring Files
 
-gmax respects both `.gitignore` and `.gmaxignore` files when indexing. Create a `.gmaxignore` file in your repository root to exclude additional files or patterns from indexing.
-
-**`.gmaxignore` syntax:**
-- Uses the same pattern syntax as `.gitignore`
-- Patterns are relative to the repository root
-- Supports glob patterns, negation (`!`), and directory patterns (`/`)
-
+gmax respects `.gitignore` and `.gmaxignore` files. Create a `.gmaxignore` in your directory root to exclude additional patterns.
 
 ### Index Management
 
-- **View indexed projects:** `gmax list`
-- **Index location:** `.gmax/` in each project root
-- **Clean up a project index:** `rm -rf .gmax/` in the project directory
-- **Global data (models, grammars):** `~/.gmax/`
-
-### GPU Embeddings (Apple Silicon)
-
-On Macs with Apple Silicon, gmax can use MLX for GPU-accelerated embeddings instead of ONNX on CPU.
-
-1. Run `gmax setup` and select **GPU (MLX)** when prompted.
-2. Start the server: `gmax serve` (automatically starts the MLX embed server).
-3. To force CPU mode on a GPU-configured project: `gmax serve --cpu`.
-
-The MLX embed server runs on port `8100` by default (configurable via `MLX_EMBED_PORT`). It is managed automatically by `gmax serve` — you don't need to start it manually.
+- **View indexed directories:** `gmax list --all`
+- **Index location:** `~/.gmax/lancedb/` (centralized)
+- **Clean up:** `gmax index --reset` re-indexes the current directory from scratch
+- **Full reset:** `rm -rf ~/.gmax/lancedb ~/.gmax/cache` to start completely fresh
 
 ## Development
 
 ```bash
 pnpm install
-pnpm build        # or pnpm dev
+pnpm build
 pnpm test         # vitest
 pnpm format       # biome check
+just deploy       # publish latest tag to npm
 ```
 
 ## Troubleshooting
 
-- **Index feels stale?** Run `gmax index` to refresh, or use `gmax serve` for live reindexing.
+- **Index feels stale?** Run `gmax index` to refresh, or use `gmax watch -b` for live reindexing.
 - **Weird results?** Run `gmax doctor` to verify models.
 - **Index getting stuck?** Run `gmax index --verbose` to see which file is being processed.
-- **Need a fresh start?** Delete `.gmax/` in your project root and run `gmax index`.
-- **MLX server won't start?** Check `/tmp/mlx-embed-server.log` for errors. Use `gmax serve --cpu` to fall back to CPU.
+- **Need a fresh start?** `rm -rf ~/.gmax/lancedb ~/.gmax/cache` then `gmax index`.
+- **MLX server won't start?** Check `/tmp/mlx-embed-server.log` for errors. Use `GMAX_EMBED_MODE=cpu` to fall back to CPU.
 
 ## Attribution
 
-gmax is built upon the foundation of [mgrep](https://github.com/mixedbread-ai/mgrep) by MixedBread. We acknowledge and appreciate the original architectural concepts and design decisions that informed this work.
-
+grepmax is built upon the foundation of [mgrep](https://github.com/mixedbread-ai/mgrep) by MixedBread. We acknowledge and appreciate the original architectural concepts and design decisions that informed this work.
 
 See the [NOTICE](NOTICE) file for detailed attribution information.
 
@@ -372,4 +269,3 @@ See the [NOTICE](NOTICE) file for detailed attribution information.
 
 Licensed under the Apache License, Version 2.0.
 See [LICENSE](LICENSE) and [Apache-2.0](https://opensource.org/licenses/Apache-2.0) for details.
-

package/dist/commands/mcp.js

@@ -46,6 +46,7 @@ exports.mcp = void 0;
 exports.toStringArray = toStringArray;
 exports.ok = ok;
 exports.err = err;
+const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
@@ -63,6 +64,7 @@ const vector_db_1 = require("../lib/store/vector-db");
 const filter_builder_1 = require("../lib/utils/filter-builder");
 const project_registry_1 = require("../lib/utils/project-registry");
 const project_root_1 = require("../lib/utils/project-root");
+const watcher_registry_1 = require("../lib/utils/watcher-registry");
 // ---------------------------------------------------------------------------
 // Tool definitions
 // ---------------------------------------------------------------------------
@@ -291,33 +293,63 @@ exports.mcp = new commander_1.Command("mcp")
                     console.log("[MCP] Index exists, ready.");
                 }
                 _indexReady = true;
+                ensureWatcher();
             }
             catch (e) {
                 console.error("[MCP] Index sync failed:", e);
             }
         });
     }
+    // --- Background watcher ---
+    function findIndexedParent(dir) {
+        const resolved = path.resolve(dir);
+        const projects = (0, project_registry_1.listProjects)();
+        // Find indexed directories that are parents of `dir`, pick broadest
+        let broadest;
+        for (const p of projects) {
+            if (resolved.startsWith(p.root) && p.root !== resolved) {
+                if (!broadest || p.root.length < broadest.length) {
+                    broadest = p.root;
+                }
+            }
+        }
+        return broadest;
+    }
+    function ensureWatcher() {
+        var _a;
+        if ((0, watcher_registry_1.getWatcherCoveringPath)(projectRoot))
+            return;
+        const watchRoot = (_a = findIndexedParent(projectRoot)) !== null && _a !== void 0 ? _a : projectRoot;
+        if ((0, watcher_registry_1.getWatcherCoveringPath)(watchRoot))
+            return;
+        const child = (0, node_child_process_1.spawn)("gmax", ["watch", "-b", "--path", watchRoot], {
+            detached: true,
+            stdio: "ignore",
+        });
+        child.unref();
+        console.log(`[MCP] Started background watcher for ${watchRoot}`);
+    }
     // --- Tool handlers ---
     function handleSemanticSearch(args_1) {
         return __awaiter(this, arguments, void 0, function* (args, searchAll = false) {
             const query = String(args.query || "");
             if (!query)
                 return err("Missing required parameter: query");
-            const limit = Math.min(Math.max(Number(args.limit) || 10, 1), 50);
+            const limit = Math.min(Math.max(Number(args.limit) || 3, 1), 50);
             yield ensureIndexReady();
             try {
                 const searcher = getSearcher();
-                // Determine path prefix for scoping
+                // Determine path prefix and display root for relative paths
                 let pathPrefix;
+                let displayRoot = projectRoot;
                 if (!searchAll) {
-                    // Resolve search root — default to project root
                     const searchRoot = typeof args.root === "string"
                         ? path.resolve(args.root)
                         : path.resolve(projectRoot);
+                    displayRoot = searchRoot;
                     pathPrefix = searchRoot.endsWith("/")
                         ? searchRoot
                         : `${searchRoot}/`;
-                    // If a sub-path is specified, append it
                     if (typeof args.path === "string") {
                         pathPrefix = path.join(searchRoot, args.path);
                         if (!pathPrefix.endsWith("/"))
@@ -330,47 +362,47 @@ exports.mcp = new commander_1.Command("mcp")
                 }
                 const minScore = typeof args.min_score === "number" ? args.min_score : 0;
                 const maxPerFile = typeof args.max_per_file === "number" ? args.max_per_file : 0;
-                const MAX_SNIPPET_LINES = 8;
-                let compact = result.data.map((r) => {
-                    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
-                    const startLine = (_c = (_a = r.startLine) !== null && _a !== void 0 ? _a : (_b = r.generated_metadata) === null || _b === void 0 ? void 0 : _b.start_line) !== null && _c !== void 0 ? _c : 0;
+                const MAX_SNIPPET_LINES = 4;
+                let results = result.data.map((r) => {
+                    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+                    const absPath = (_c = (_a = r.path) !== null && _a !== void 0 ? _a : (_b = r.metadata) === null || _b === void 0 ? void 0 : _b.path) !== null && _c !== void 0 ? _c : "";
+                    const relPath = absPath.startsWith(displayRoot)
+                        ? absPath.slice(displayRoot.length + 1)
+                        : absPath;
+                    const startLine = (_f = (_d = r.startLine) !== null && _d !== void 0 ? _d : (_e = r.generated_metadata) === null || _e === void 0 ? void 0 : _e.start_line) !== null && _f !== void 0 ? _f : 0;
+                    const endLine = (_j = (_g = r.endLine) !== null && _g !== void 0 ? _g : (_h = r.generated_metadata) === null || _h === void 0 ? void 0 : _h.end_line) !== null && _j !== void 0 ? _j : 0;
+                    const score = typeof r.score === "number" ? r.score.toFixed(2) : "0";
+                    const role = ((_k = r.role) !== null && _k !== void 0 ? _k : "IMPL").slice(0, 4).toUpperCase();
+                    const defs = toStringArray((_l = r.definedSymbols) !== null && _l !== void 0 ? _l : r.defined_symbols).slice(0, 3);
                     const raw = typeof r.content === "string"
                         ? r.content
                         : typeof r.text === "string"
                             ? r.text
                             : "";
-                    // Add line numbers and cap at MAX_SNIPPET_LINES
                     const lines = raw.split("\n");
                     const capped = lines.slice(0, MAX_SNIPPET_LINES);
                     const numbered = capped.map((line, i) => `${startLine + i + 1}│${line}`);
-                    const snippet = lines.length > MAX_SNIPPET_LINES
-                        ? `${numbered.join("\n")}\n… (+${lines.length - MAX_SNIPPET_LINES} more lines)`
-                        : numbered.join("\n");
-                    return {
-                        path: (_f = (_d = r.path) !== null && _d !== void 0 ? _d : (_e = r.metadata) === null || _e === void 0 ? void 0 : _e.path) !== null && _f !== void 0 ? _f : "",
-                        startLine,
-                        endLine: (_j = (_g = r.endLine) !== null && _g !== void 0 ? _g : (_h = r.generated_metadata) === null || _h === void 0 ? void 0 : _h.end_line) !== null && _j !== void 0 ? _j : 0,
-                        score: typeof r.score === "number" ? +r.score.toFixed(3) : 0,
-                        role: (_k = r.role) !== null && _k !== void 0 ? _k : "IMPLEMENTATION",
-                        confidence: (_l = r.confidence) !== null && _l !== void 0 ? _l : "Unknown",
-                        definedSymbols: toStringArray((_m = r.definedSymbols) !== null && _m !== void 0 ? _m : r.defined_symbols).slice(0, 5),
-                        snippet,
-                    };
+                    const header = `${relPath}:${startLine + 1}-${endLine + 1} [${role}] score:${score}${defs.length ? ` defines:${defs.join(",")}` : ""}`;
+                    const snippet = numbered.join("\n");
+                    return { absPath, header, snippet, score: +score };
                 });
                 if (minScore > 0) {
-                    compact = compact.filter((r) => r.score >= minScore);
+                    results = results.filter((r) => r.score >= minScore);
                 }
                 if (maxPerFile > 0) {
                     const counts = new Map();
-                    compact = compact.filter((r) => {
-                        const count = counts.get(r.path) || 0;
+                    results = results.filter((r) => {
+                        const count = counts.get(r.absPath) || 0;
                         if (count >= maxPerFile)
                             return false;
-                        counts.set(r.path, count + 1);
+                        counts.set(r.absPath, count + 1);
                         return true;
                     });
                 }
-                return ok(JSON.stringify(compact));
+                const output = results
+                    .map((r) => `${r.header}\n${r.snippet}`)
+                    .join("\n\n");
+                return ok(output);
             }
             catch (e) {
                 const msg = e instanceof Error ? e.message : String(e);

package/dist/commands/watch.js

@@ -60,10 +60,13 @@ const IDLE_CHECK_INTERVAL_MS = 60 * 1000; // check every minute
 exports.watch = new commander_1.Command("watch")
     .description("Start background file watcher for live reindexing")
     .option("-b, --background", "Run watcher in background and exit")
+    .option("-p, --path <dir>", "Directory to watch (defaults to project root)")
     .option("--no-idle-timeout", "Disable the 30-minute idle shutdown")
     .action((options) => __awaiter(void 0, void 0, void 0, function* () {
     var _a;
-    const projectRoot = (_a = (0, project_root_1.findProjectRoot)(process.cwd())) !== null && _a !== void 0 ? _a : process.cwd();
+    const projectRoot = options.path
+        ? path.resolve(options.path)
+        : (_a = (0, project_root_1.findProjectRoot)(process.cwd())) !== null && _a !== void 0 ? _a : process.cwd();
     const projectName = path.basename(projectRoot);
     // Check if watcher already running
     const existing = (0, watcher_registry_1.getWatcherForProject)(projectRoot);

package/dist/config.js

@@ -65,7 +65,7 @@ const DEFAULT_WORKER_THREADS = (() => {
     if (Number.isFinite(fromEnv) && fromEnv > 0)
         return fromEnv;
     const cores = os.cpus().length || 1;
-    const HARD_CAP = 4;
+    const HARD_CAP = Math.max(4, Math.floor(cores * 0.5));
     return Math.max(1, Math.min(HARD_CAP, cores));
 })();
 exports.CONFIG = {

package/dist/lib/index/index-config.js

@@ -60,7 +60,7 @@ function readGlobalConfig() {
         return {
             modelTier: config_1.DEFAULT_MODEL_TIER,
             vectorDim: tier.vectorDim,
-            embedMode: "cpu",
+            embedMode: process.arch === "arm64" && process.platform === "darwin" ? "gpu" : "cpu",
         };
     }
 }

package/dist/lib/utils/watcher-registry.js

@@ -43,6 +43,7 @@ exports.isProcessRunning = isProcessRunning;
 exports.registerWatcher = registerWatcher;
 exports.unregisterWatcher = unregisterWatcher;
 exports.getWatcherForProject = getWatcherForProject;
+exports.getWatcherCoveringPath = getWatcherCoveringPath;
 exports.listWatchers = listWatchers;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
@@ -90,6 +91,15 @@ function getWatcherForProject(projectRoot) {
     }
     return undefined;
 }
+function getWatcherCoveringPath(dir) {
+    const resolved = path.resolve(dir);
+    const entries = loadRegistry();
+    for (const e of entries) {
+        if (resolved.startsWith(e.projectRoot) && isProcessRunning(e.pid))
+            return e;
+    }
+    return undefined;
+}
 function listWatchers() {
     const entries = loadRegistry();
     const active = entries.filter((e) => isProcessRunning(e.pid));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.2.5",
+  "version": "0.3.1",
   "author": "Robert Owens <robowens@me.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {

package/plugins/grepmax/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.2.5",
+  "version": "0.3.1",
   "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
   "author": {
     "name": "Robert Owens",