@ez-corp/ez-search 1.0.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026 ez-search contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,207 @@
+# ez-search
+
+Semantic codebase search with zero cloud dependencies.
+
+`ez-search` is a local, privacy-first CLI tool that provides semantic search over codebases, documents, and image libraries. It uses ML inference (WebGPU with CPU fallback) to generate embeddings and stores them in a local vector database. No cloud services, no API keys, no data leaves your machine.
+
+Built as a contextual retrieval engine for AI coding assistants like Claude Code.
+
+## Features
+
+- **Three search pipelines** -- code, text/documents, and images, each with a specialized embedding model
+- **Incremental indexing** -- only re-embeds files that have changed (mtime + content hash)
+- **WebGPU acceleration** with automatic CPU fallback
+- **Respects .gitignore and .cursorignore** -- skips `node_modules`, `dist`, lockfiles, etc. by default
+- **Machine-readable JSON output** -- designed for AI assistant consumption
+- **Project-scoped storage** -- all index data lives in `.ez-search/` within your project
+
+## Requirements
+
+- **Node.js v20+** (v22+ recommended for WebGPU support)
+- Models are downloaded automatically on first run (~500MB total for all three)
+
+## Installation
+
+```bash
+npm install -g ez-search
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/ezcorp-org/ez-search.git
+cd ez-search
+npm install
+npm run build
+```
+
+## Quick Start
+
+```bash
+# Index the current directory
+ez-search index .
+
+# Search your code
+ez-search query "error handling in the auth module"
+
+# Check index status
+ez-search status
+```
+
+## CLI Reference
+
+### `ez-search index <path>`
+
+Scan a directory, chunk files, generate embeddings, and store them in the local vector database.
+
+```bash
+ez-search index .
+ez-search index ./src --type code
+ez-search index . --clear --format text
+```
+
+| Flag | Description |
+|------|-------------|
+| `--type <code\|text\|image>` | Index only files of a specific type. If omitted, all types are auto-detected by file extension. |
+| `--clear` | Delete the existing `.ez-search/` index before indexing. |
+| `--no-ignore` | Disable `.gitignore` and `.cursorignore` filtering. |
+| `-q, --quiet` | Suppress status output. |
+| `--format <json\|text>` | Output format. Default: `json`. |
+
+### `ez-search query <text>`
+
+Search the index with a natural language query. Run from inside an indexed directory.
+
+```bash
+ez-search query "database connection pooling"
+ez-search query "how are users authenticated" --format text
+ez-search query "parse config" -k 5 --dir src/config
+ez-search query "validation logic" --threshold 0.7
+```
+
+| Flag | Description |
+|------|-------------|
+| `-k, --top-k <n>` | Number of results to return. Default: `10`. |
+| `--type <code\|text>` | Search a specific pipeline only. |
+| `--dir <path>` | Scope results to a subdirectory. |
+| `--threshold <score>` | Minimum relevance score (0-1) to include in results. |
+| `--format <json\|text>` | Output format. Default: `json`. |
+
+JSON output returns a grouped envelope:
+
+```json
+{
+  "query": "database connection",
+  "totalIndexed": 142,
+  "searchScope": ".",
+  "code": [
+    {
+      "file": "src/db/pool.ts",
+      "lines": { "start": 12, "end": 45 },
+      "score": 0.87,
+      "text": "..."
+    }
+  ],
+  "text": [
+    {
+      "file": "docs/architecture.md",
+      "score": 0.72,
+      "text": "..."
+    }
+  ]
+}
+```
+
+Text output uses a human-readable format:
+
+```
+## Code
+
+File: src/db/pool.ts | Lines: 12-45 | Relevance: 0.87
+    <chunk text>
+
+## Text
+
+File: docs/architecture.md | Relevance: 0.72
+    <chunk text>
+```
+
+### `ez-search status`
+
+Show indexing status for the current directory.
+
+```bash
+ez-search status
+ez-search status --format text
+```
+
+| Flag | Description |
+|------|-------------|
+| `--format <json\|text>` | Output format. Default: `json`. |
+| `--no-ignore` | Disable `.gitignore` and `.cursorignore` filtering when computing stale file count. |
+
+Reports file count, chunk count, per-type breakdown, index size, last indexed time, and number of stale (unindexed) files.
+
+## Supported File Types
+
+| Type | Extensions |
+|------|------------|
+| Code | `.ts` `.tsx` `.js` `.jsx` `.py` `.go` `.rs` `.java` `.c` `.cpp` `.h` `.hpp` `.rb` `.php` `.swift` `.kt` `.scala` `.sh` `.bash` `.zsh` `.css` `.scss` `.html` `.json` `.yaml` `.yml` `.toml` |
+| Text | `.md` `.mdx` `.txt` `.rst` `.csv` `.pdf` |
+| Image | `.jpg` `.jpeg` `.png` `.gif` `.webp` `.svg` |
+
+## How It Works
+
+ez-search uses three specialized embedding models, each optimized for a different data type:
+
+| Pipeline | Model | Dimensions | Chunking |
+|----------|-------|------------|----------|
+| Code | `jinaai/jina-embeddings-v2-base-code` | 768 | 500-token sliding window, 50-token overlap |
+| Text | `nomic-ai/nomic-embed-text-v1.5` | 768 | Paragraph-boundary splitting, ~1600 chars per chunk |
+| Image | `Xenova/clip-vit-base-patch32` | 512 | One vector per image (no chunking) |
+
+Models are lazy-loaded -- only the model needed for the current operation is loaded. On first run, model weights are downloaded and cached in `~/.ez-search/models/`.
+
+**Incremental indexing:** A manifest at `.ez-search/manifest.json` tracks file size, mtime, and content hash (SHA-256). On subsequent runs, only changed files are re-embedded. Chunk-level deduplication further reduces work when only part of a file changes.
+
+**Vector storage:** Embeddings are stored in Zvec (`@zvec/zvec`), an in-process C++ vector database. Code and text share a 768-dimension collection; images use a separate 512-dimension collection. Both use cosine similarity for search.
+
+## Configuration
+
+ez-search uses convention over configuration. There are no config files.
+
+- **Project index:** stored in `<project>/.ez-search/` (add to `.gitignore`)
+- **Model cache:** stored in `~/.ez-search/models/` (shared across projects)
+- **File filtering:** respects `.gitignore` and `.cursorignore` by default; disable with `--no-ignore`
+- **Built-in exclusions:** `node_modules`, `.git`, `dist`, `build`, lockfiles, `.min.js`, `.map`, and other common noise are always excluded
+
+## Troubleshooting
+
+**WebGPU not available / falling back to CPU**
+
+WebGPU requires Node.js v22+ and a Vulkan-capable GPU. On systems without GPU support (or on NixOS where `vulkan-loader` may not be in the default environment), ez-search falls back to CPU with q8 quantization automatically. CPU mode is slower but functionally identical.
+
+On NixOS, you can enable Vulkan with:
+```bash
+nix-shell -p vulkan-loader
+```
+
+**Model download is slow or fails**
+
+Models are downloaded from Hugging Face on first use. If downloads fail, check your internet connection. Models are cached in `~/.ez-search/models/` -- you can delete this directory to force re-download.
+
+**"No index found" error**
+
+You need to index before querying. Run `ez-search index .` in your project directory first.
+
+**"No supported files found" error**
+
+The target directory contains no files with recognized extensions. Check the supported file types table above.
+
+**Large index size**
+
+Use `ez-search index --clear .` to rebuild the index from scratch. This removes stale entries from deleted files.
+
+## License
+
+[ISC](LICENSE)

package/dist/cli/commands/index-cmd.js

@@ -0,0 +1,450 @@
+/**
+ * Index command — end-to-end pipeline: scan -> manifest check -> chunk -> embed -> store.
+ *
+ * Pipeline flow (per type):
+ *   1. Resolve path and open vector collections
+ *   2. Handle --clear (wipe storage + manifest)
+ *   3. Load manifest (incremental cache)
+ *   4. For each type in [code, text, image]:
+ *      a. Scan files of that type
+ *      b. Detect changed/new/deleted files against manifest
+ *      c. Remove deleted files' chunks from the appropriate collection
+ *      d. Chunk changed/new files
+ *      e. Batch embed with the correct model
+ *      f. Insert embeddings into the appropriate collection
+ *   5. Optimize collections THEN save manifest (order matters)
+ *   6. Dispose pipelines and output results
+ *
+ * Model routing:
+ *   code  -> jinaai/jina-embeddings-v2-base-code, col-768
+ *   text  -> nomic-ai/nomic-embed-text-v1.5, col-768  (prefix: "search_document: ")
+ *   image -> Xenova/clip-vit-base-patch32, col-512     (one vector per file)
+ */
+import * as path from 'path';
+import * as fsp from 'fs/promises';
+import { rmSync } from 'fs';
+const BATCH_SIZE = 32;
+// ── Shared pipeline helper ─────────────────────────────────────────────────────
+/**
+ * Shared embedding pipeline: diff files against manifest, chunk, embed, insert into col768.
+ * Used by both code and text pipelines (they differ only in chunker, model, prefix, tokenizer).
+ */
+async function runTextEmbeddingPipeline(opts) {
+    const { type, files, col768, manifest, hashContent, hashText, makeChunkId } = opts;
+    let filesIndexed = 0;
+    let filesSkipped = 0;
+    let chunksCreated = 0;
+    let chunksReused = 0;
+    let chunksRemoved = 0;
+    // Determine which files need processing (mtime+size fast path, hash confirmation)
+    const filesToProcess = [];
+    for (const file of files) {
+        const existing = manifest.files[file.relativePath];
+        if (existing && existing.mtime === file.mtimeMs && existing.size === file.sizeBytes) {
+            filesSkipped++;
+            chunksReused += existing.chunks.length;
+            continue;
+        }
+        if (existing) {
+            const buf = await fsp.readFile(file.absolutePath);
+            const newHash = hashContent(buf);
+            if (newHash === existing.hash) {
+                manifest.files[file.relativePath] = { ...existing, mtime: file.mtimeMs, size: file.sizeBytes };
+                filesSkipped++;
+                chunksReused += existing.chunks.length;
+                continue;
+            }
+        }
+        filesToProcess.push(file);
+    }
+    if (filesToProcess.length === 0) {
+        return { filesIndexed, filesSkipped, chunksCreated, chunksReused, chunksRemoved };
+    }
+    // Load chunker and model (lazy, once per pipeline run)
+    let tokenizer = null;
+    let pipe = null;
+    const allPendingChunks = [];
+    const newFileEntries = [];
+    for (const file of filesToProcess) {
+        const ext = path.extname(file.absolutePath).toLowerCase();
+        let content;
+        if (ext === '.pdf') {
+            // PDF: read as buffer, extract text via pdf-parse
+            const buf = await fsp.readFile(file.absolutePath);
+            const fileHash = hashContent(buf);
+            const { extractPdfText, chunkTextFile } = await import('../../services/text-chunker.js');
+            const rawText = await extractPdfText(buf);
+            const chunks = chunkTextFile(rawText);
+            const existingEntry = manifest.files[file.relativePath];
+            const existingChunks = existingEntry?.chunks ?? [];
+            for (let i = chunks.length; i < existingChunks.length; i++) {
+                col768.remove(existingChunks[i].id);
+                chunksRemoved++;
+            }
+            const chunkRecords = [];
+            for (const chunk of chunks) {
+                const chunkId = makeChunkId(file.relativePath, chunk.chunkIndex);
+                const chunkTextHash = hashText(chunk.text);
+                const oldChunk = existingChunks[chunk.chunkIndex];
+                chunkRecords.push({ id: chunkId, lineStart: 0, lineEnd: 0, tokenCount: 0, textHash: chunkTextHash });
+                if (oldChunk && oldChunk.textHash === chunkTextHash) {
+                    chunksReused++;
+                }
+                else {
+                    allPendingChunks.push({
+                        relPath: file.relativePath,
+                        chunkId,
+                        text: chunk.text,
+                        lineStart: 0,
+                        lineEnd: 0,
+                        chunkIndex: chunk.chunkIndex,
+                        tokenCount: 0,
+                        textHash: chunkTextHash,
+                    });
+                }
+            }
+            newFileEntries.push({ relPath: file.relativePath, mtime: file.mtimeMs, size: file.sizeBytes, hash: fileHash, chunks: chunkRecords });
+            filesIndexed++;
+            continue;
+        }
+        // Non-PDF: read as UTF-8
+        content = await fsp.readFile(file.absolutePath, 'utf8');
+        const fileHash = hashContent(Buffer.from(content));
+        const existingEntry = manifest.files[file.relativePath];
+        const existingChunks = existingEntry?.chunks ?? [];
+        if (type === 'code') {
+            // Code: use Jina tokenizer + sliding-window chunker
+            if (!tokenizer) {
+                const { loadTokenizer } = await import('../../services/chunker.js');
+                tokenizer = await loadTokenizer();
+            }
+            const { chunkFile } = await import('../../services/chunker.js');
+            const chunks = chunkFile(content, tokenizer);
+            for (let i = chunks.length; i < existingChunks.length; i++) {
+                col768.remove(existingChunks[i].id);
+                chunksRemoved++;
+            }
+            const chunkRecords = [];
+            for (const chunk of chunks) {
+                const chunkId = makeChunkId(file.relativePath, chunk.chunkIndex);
+                const chunkTextHash = hashText(chunk.text);
+                const oldChunk = existingChunks[chunk.chunkIndex];
+                chunkRecords.push({
+                    id: chunkId,
+                    lineStart: chunk.lineStart,
+                    lineEnd: chunk.lineEnd,
+                    tokenCount: chunk.tokenCount,
+                    textHash: chunkTextHash,
+                });
+                if (oldChunk && oldChunk.textHash === chunkTextHash) {
+                    chunksReused++;
+                }
+                else {
+                    allPendingChunks.push({
+                        relPath: file.relativePath,
+                        chunkId,
+                        text: chunk.text,
+                        lineStart: chunk.lineStart,
+                        lineEnd: chunk.lineEnd,
+                        chunkIndex: chunk.chunkIndex,
+                        tokenCount: chunk.tokenCount,
+                        textHash: chunkTextHash,
+                    });
+                }
+            }
+            newFileEntries.push({ relPath: file.relativePath, mtime: file.mtimeMs, size: file.sizeBytes, hash: fileHash, chunks: chunkRecords });
+        }
+        else {
+            // Text (non-PDF): paragraph-boundary chunking for Nomic
+            const { chunkTextFile } = await import('../../services/text-chunker.js');
+            const chunks = chunkTextFile(content);
+            for (let i = chunks.length; i < existingChunks.length; i++) {
+                col768.remove(existingChunks[i].id);
+                chunksRemoved++;
+            }
+            const chunkRecords = [];
+            for (const chunk of chunks) {
+                const chunkId = makeChunkId(file.relativePath, chunk.chunkIndex);
+                const chunkTextHash = hashText(chunk.text);
+                const oldChunk = existingChunks[chunk.chunkIndex];
+                chunkRecords.push({ id: chunkId, lineStart: 0, lineEnd: 0, tokenCount: 0, textHash: chunkTextHash });
+                if (oldChunk && oldChunk.textHash === chunkTextHash) {
+                    chunksReused++;
+                }
+                else {
+                    allPendingChunks.push({
+                        relPath: file.relativePath,
+                        chunkId,
+                        text: chunk.text,
+                        lineStart: 0,
+                        lineEnd: 0,
+                        chunkIndex: chunk.chunkIndex,
+                        tokenCount: 0,
+                        textHash: chunkTextHash,
+                    });
+                }
+            }
+            newFileEntries.push({ relPath: file.relativePath, mtime: file.mtimeMs, size: file.sizeBytes, hash: fileHash, chunks: chunkRecords });
+        }
+        filesIndexed++;
+    }
+    // Embed all pending chunks
+    if (allPendingChunks.length > 0) {
+        const { createEmbeddingPipeline } = await import('../../services/model-router.js');
+        pipe = await createEmbeddingPipeline(type);
+        // Nomic requires "search_document: " prefix on indexed documents
+        const prefix = type === 'text' ? 'search_document: ' : '';
+        for (let batchStart = 0; batchStart < allPendingChunks.length; batchStart += BATCH_SIZE) {
+            const batch = allPendingChunks.slice(batchStart, batchStart + BATCH_SIZE);
+            const texts = batch.map((c) => prefix + c.text);
+            const embeddings = await pipe.embed(texts);
+            for (let i = 0; i < batch.length; i++) {
+                const chunk = batch[i];
+                col768.insert(chunk.chunkId, embeddings[i], {
+                    filePath: chunk.relPath,
+                    chunkIndex: chunk.chunkIndex,
+                    modelId: pipe.modelId,
+                    lineStart: chunk.lineStart,
+                    lineEnd: chunk.lineEnd,
+                    chunkText: chunk.text, // store without prefix
+                });
+                chunksCreated++;
+            }
+        }
+        await pipe.dispose();
+    }
+    // Commit new file entries to manifest
+    for (const entry of newFileEntries) {
+        manifest.files[entry.relPath] = {
+            mtime: entry.mtime,
+            size: entry.size,
+            hash: entry.hash,
+            chunks: entry.chunks,
+        };
+    }
+    return { filesIndexed, filesSkipped, chunksCreated, chunksReused, chunksRemoved };
+}
+export async function runIndex(targetPath, options) {
+    const startTime = Date.now();
+    try {
+        // 1. Resolve path
+        const absPath = path.resolve(targetPath);
+        // 2. Open vector collections
+        const { openProjectCollections } = await import('../../services/vector-db.js');
+        let { col768, col512, storagePath } = openProjectCollections(absPath);
+        // 3. Handle --clear
+        // rmSync removes .ez-search/ entirely (including manifest.json inside it)
+        if (options.clear) {
+            rmSync(storagePath, { recursive: true, force: true });
+            const reopened = openProjectCollections(absPath);
+            col768 = reopened.col768;
+            col512 = reopened.col512;
+            storagePath = reopened.storagePath;
+        }
+        // 4. Load manifest and helpers
+        const { loadManifest, saveManifest, hashContent, hashText, makeChunkId } = await import('../../services/manifest-cache.js');
+        const manifest = loadManifest(absPath);
+        // 5. Determine which types to index
+        const typesToIndex = options.type
+            ? [options.type]
+            : ['code', 'text', 'image'];
+        const { scanFiles } = await import('../../services/file-scanner.js');
+        // Aggregate stats
+        let totalFilesScanned = 0;
+        let totalFilesIndexed = 0;
+        let totalFilesSkipped = 0;
+        let totalChunksCreated = 0;
+        let totalChunksReused = 0;
+        let totalChunksRemoved = 0;
+        const allDeletedPaths = [];
+        // Per-type file counts for text output
+        const typeFileCounts = {};
+        let imageFilesProcessed = false;
+        for (const fileType of typesToIndex) {
+            // Scan files of this type
+            const scannedFiles = [];
+            for await (const file of scanFiles(absPath, { useIgnoreFiles: options.ignore, typeFilter: fileType })) {
+                scannedFiles.push(file);
+            }
+            totalFilesScanned += scannedFiles.length;
+            if (scannedFiles.length === 0) {
+                continue;
+            }
+            // Deletion detection: manifest entries with this file's extension
+            const scannedSet = new Set(scannedFiles.map((f) => f.relativePath));
+            if (fileType === 'code' || fileType === 'text') {
+                // Find manifest entries whose last extension matches this type's extensions
+                // Simpler: find entries NOT in current scan that belong to this type
+                // We only delete entries whose path is in the scanned set for OTHER types?
+                // Actually: we track all types in the same manifest. We need to scope deletions
+                // to files that WERE of this type (by extension). Use EXTENSION_MAP.
+                const { EXTENSION_MAP } = await import('../../types.js');
+                const deletedPaths = Object.keys(manifest.files).filter((relPath) => {
+                    if (scannedSet.has(relPath))
+                        return false;
+                    const ext = path.extname(relPath).toLowerCase();
+                    return EXTENSION_MAP[ext] === fileType;
+                });
+                for (const deletedPath of deletedPaths) {
+                    const entry = manifest.files[deletedPath];
+                    for (const chunk of entry.chunks) {
+                        col768.remove(chunk.id);
+                        totalChunksRemoved++;
+                    }
+                    delete manifest.files[deletedPath];
+                    allDeletedPaths.push(deletedPath);
+                }
+                // Run code/text embedding pipeline
+                const result = await runTextEmbeddingPipeline({
+                    type: fileType,
+                    files: scannedFiles,
+                    col768,
+                    manifest,
+                    hashContent,
+                    hashText,
+                    makeChunkId,
+                });
+                totalFilesIndexed += result.filesIndexed;
+                totalFilesSkipped += result.filesSkipped;
+                totalChunksCreated += result.chunksCreated;
+                totalChunksReused += result.chunksReused;
+                totalChunksRemoved += result.chunksRemoved;
+                if (result.filesIndexed > 0) {
+                    typeFileCounts[fileType] = (typeFileCounts[fileType] ?? 0) + result.filesIndexed;
+                }
+            }
+            else if (fileType === 'image') {
+                // Image pipeline: one vector per file, goes into col-512
+                const { EXTENSION_MAP } = await import('../../types.js');
+                const deletedPaths = Object.keys(manifest.files).filter((relPath) => {
+                    if (scannedSet.has(relPath))
+                        return false;
+                    const ext = path.extname(relPath).toLowerCase();
+                    return EXTENSION_MAP[ext] === 'image';
+                });
+                for (const deletedPath of deletedPaths) {
+                    const entry = manifest.files[deletedPath];
+                    for (const chunk of entry.chunks) {
+                        col512.remove(chunk.id);
+                        totalChunksRemoved++;
+                    }
+                    delete manifest.files[deletedPath];
+                    allDeletedPaths.push(deletedPath);
+                }
+                // Determine which image files need (re-)embedding
+                const filesToProcess = [];
+                for (const file of scannedFiles) {
+                    const existing = manifest.files[file.relativePath];
+                    if (existing && existing.mtime === file.mtimeMs && existing.size === file.sizeBytes) {
+                        totalFilesSkipped++;
+                        totalChunksReused += existing.chunks.length;
+                        continue;
+                    }
+                    if (existing) {
+                        const buf = await fsp.readFile(file.absolutePath);
+                        const newHash = hashContent(buf);
+                        if (newHash === existing.hash) {
+                            manifest.files[file.relativePath] = { ...existing, mtime: file.mtimeMs, size: file.sizeBytes };
+                            totalFilesSkipped++;
+                            totalChunksReused += existing.chunks.length;
+                            continue;
+                        }
+                    }
+                    filesToProcess.push(file);
+                }
+                if (filesToProcess.length > 0) {
+                    // Load CLIP pipeline once for the batch
+                    const { createImageEmbeddingPipeline } = await import('../../services/image-embedder.js');
+                    const imagePipeline = await createImageEmbeddingPipeline();
+                    for (const file of filesToProcess) {
+                        const buf = await fsp.readFile(file.absolutePath);
+                        const fileHash = hashContent(buf);
+                        const embedding = await imagePipeline.embedImage(file.absolutePath);
+                        const chunkId = makeChunkId(file.relativePath, 0);
+                        col512.insert(chunkId, embedding, {
+                            filePath: file.relativePath,
+                            chunkIndex: 0,
+                            modelId: imagePipeline.modelId,
+                            lineStart: 0,
+                            lineEnd: 0,
+                            chunkText: '',
+                        });
+                        totalChunksCreated++;
+                        manifest.files[file.relativePath] = {
+                            mtime: file.mtimeMs,
+                            size: file.sizeBytes,
+                            hash: fileHash,
+                            chunks: [{ id: chunkId, lineStart: 0, lineEnd: 0, tokenCount: 0, textHash: '' }],
+                        };
+                        totalFilesIndexed++;
+                    }
+                    await imagePipeline.dispose();
+                    imageFilesProcessed = true;
+                    typeFileCounts['image'] = (typeFileCounts['image'] ?? 0) + filesToProcess.length;
+                }
+            }
+        }
+        // 5b. Check for empty directory (no supported files found)
+        if (totalFilesScanned === 0) {
+            const { emitError } = await import('../errors.js');
+            const format = options.format === 'text' ? 'text' : 'json';
+            emitError({ code: 'EMPTY_DIR', message: 'No supported files found in directory', suggestion: 'Ensure the directory contains supported file types (.ts, .js, .py, .go, .rs, .c, .cpp, .md, .txt, .jpg, .png, .webp)' }, format);
+        }
+        // 6. Optimize THEN save manifest
+        col768.optimize();
+        if (imageFilesProcessed) {
+            col512.optimize();
+        }
+        saveManifest(absPath, manifest);
+        // 7. Output results
+        const durationMs = Date.now() - startTime;
+        const hasChanges = totalFilesIndexed > 0 || allDeletedPaths.length > 0;
+        const output = {
+            status: hasChanges ? 'ok' : 'no_changes',
+            path: absPath,
+            filesScanned: totalFilesScanned,
+            filesIndexed: totalFilesIndexed,
+            filesSkipped: totalFilesSkipped,
+            chunksCreated: totalChunksCreated,
+            chunksReused: totalChunksReused,
+            chunksRemoved: totalChunksRemoved,
+            durationMs,
+            storageDir: storagePath,
+        };
+        if (!options.quiet) {
+            if (options.format === 'text') {
+                const secs = (durationMs / 1000).toFixed(1);
+                if (!hasChanges) {
+                    console.log(`No changes detected. ${totalFilesScanned} files scanned in ${secs}s.`);
+                }
+                else {
+                    const parts = [];
+                    // Show per-type breakdown if multiple types indexed
+                    if (Object.keys(typeFileCounts).length > 1) {
+                        const typeParts = Object.entries(typeFileCounts).map(([t, count]) => `${count} ${t} file${count !== 1 ? 's' : ''}`);
+                        parts.push(`indexed ${typeParts.join(', ')}`);
+                    }
+                    else if (totalFilesIndexed > 0) {
+                        parts.push(`indexed ${totalFilesIndexed} file${totalFilesIndexed !== 1 ? 's' : ''}`);
+                    }
+                    if (allDeletedPaths.length > 0) {
+                        parts.push(`removed ${allDeletedPaths.length} deleted file${allDeletedPaths.length !== 1 ? 's' : ''}`);
+                    }
+                    if (totalChunksCreated > 0) {
+                        parts.push(`${totalChunksCreated} new chunk${totalChunksCreated !== 1 ? 's' : ''}`);
+                    }
+                    console.log(`${parts.join(', ')} in ${secs}s (${totalChunksReused} chunks reused, ${storagePath})`);
+                }
+            }
+            else {
+                console.log(JSON.stringify(output));
+            }
+        }
+        return output;
+    }
+    catch (err) {
+        const { emitError } = await import('../errors.js');
+        const message = err instanceof Error ? err.message : String(err);
+        return emitError({ code: 'GENERAL_ERROR', message, suggestion: 'Check the error above and retry' }, options.format === 'text' ? 'text' : 'json');
+    }
+}