@lucas-bur/pix 0.10.0 → 0.12.0

package/README.md

@@ -19,13 +19,13 @@ pix query "authentication middleware"
 
 ## Commands
 
-| Command              | Description                                 | JSON flag |
-| -------------------- | ------------------------------------------- | --------- |
-| `pix init`           | Create `.pix/config.json` with defaults     | `--json`  |
-| `pix index`          | Scan, chunk, embed, and store project files | `--json`  |
-| `pix query "<text>"` | Semantic search via cosine similarity       | `--json`  |
-| `pix status`         | Show index statistics                       | `--json`  |
-| `pix reset`          | Delete index files (chunks + vectors)       | `--json`  |
+| Command                      | Description                                                                                                                            | JSON flag |
+| ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- | --------- |
+| `pix init`                   | Create `.pix/config.json` with defaults                                                                                                | `--json`  |
+| `pix index`                  | Scan, chunk, embed, and store project files                                                                                            | `--json`  |
+| `pix query "<text>" [flags]` | Semantic search via cosine similarity (`--top`, `--context-lines`, `--ignore-path`, `--only-path`, `--max-characters`, `--no-content`) | `--json`  |
+| `pix status`                 | Show index statistics                                                                                                                  | `--json`  |
+| `pix reset`                  | Delete index files (chunks + vectors)                                                                                                  | `--json`  |
 
 All commands support `--json` for structured output on stdout — ideal for piping to AI agents.
 

package/dist/index.mjs

@@ -2,7 +2,8 @@
 import { createRequire } from "node:module";
 import { Args, CliConfig, Command, Options } from "@effect/cli";
 import { NodeContext, NodeRuntime } from "@effect/platform-node";
-import { Clock, Context, Data, Effect, Layer, Option, Ref } from "effect";
+import { Clock, Context, Data, Effect, Exit, Layer, Option, Ref, Stream } from "effect";
+import * as Chunk from "effect/Chunk";
 import { styleText } from "node:util";
 import * as clack from "@clack/prompts";
 import { FileSystem } from "@effect/platform";
@@ -74,6 +75,7 @@ const withInteractive = (activeRef, acquire, setActive, release, effect) => Ref.
 /** Display implementation using @clack/prompts for interactive terminal output */
 const ClackDisplay = { layer: Layer.effect(Display, Effect.gen(function* () {
 	const activeRef = yield* Ref.make(null);
+	const lastSpinnerMsg = yield* Ref.make("");
 	return {
 		intro: (title) => Effect.sync(() => clack.intro(styleText("inverse", ` ${title} `))),
 		outro: (message) => Effect.sync(() => clack.outro(message)),
@@ -84,11 +86,17 @@ const ClackDisplay = { layer: Layer.effect(Display, Effect.gen(function* () {
 			const s = clack.spinner();
 			s.start(message);
 			return s;
-		}), (s) => ({
+		}).pipe(Effect.tap(() => Ref.set(lastSpinnerMsg, message))), (s) => ({
 			type: "spinner",
 			handle: s
-		}), (s, exit) => Effect.sync(() => s.stop(exit._tag === "Success" ? message : `${message} (failed)`)), effect),
-		progress: (opts, effect) => withInteractive(activeRef, Effect.sync(() => {
+		}), (s, exit) => lastSpinnerMsg.pipe(Effect.flatMap((lastMsg) => Effect.sync(() => s.stop(exit._tag === "Success" && lastMsg ? lastMsg : `${message} (failed)`)))), effect),
+		progress: (opts, effect) => Effect.gen(function* () {
+			const current = yield* Ref.get(activeRef);
+			if (current && current.type === "spinner") {
+				const msg = yield* Ref.get(lastSpinnerMsg);
+				current.handle.stop(msg || opts.message);
+				yield* Ref.set(activeRef, null);
+			}
 			const bar = clack.progress({
 				max: opts.max,
 				style: opts.style ?? "heavy",
@@ -96,16 +104,27 @@ const ClackDisplay = { layer: Layer.effect(Display, Effect.gen(function* () {
 				indicator: opts.indicator ?? "dots"
 			});
 			bar.start(opts.message);
-			return bar;
-		}), (bar) => ({
-			type: "progress",
-			handle: bar,
-			value: 0,
-			max: opts.max
-		}), (bar, exit) => Effect.sync(() => exit._tag === "Success" ? bar.stop(opts.message) : bar.error(opts.message)), effect),
+			yield* Ref.set(activeRef, {
+				type: "progress",
+				handle: bar,
+				value: 0,
+				max: opts.max
+			});
+			const exit = yield* Effect.exit(effect);
+			yield* Ref.set(activeRef, null);
+			if (Exit.isSuccess(exit)) {
+				bar.stop(opts.message);
+				return exit.value;
+			}
+			bar.error(opts.message);
+			return yield* Effect.failCause(exit.cause);
+		}),
 		updateInteractive: (payload) => Ref.get(activeRef).pipe(Effect.flatMap((active) => {
 			if (!active) return Effect.void;
-			if (active.type === "spinner") return Effect.sync(() => active.handle.message(payloadText(payload)));
+			if (active.type === "spinner") {
+				const msg = payloadText(payload);
+				return Effect.sync(() => active.handle.message(msg)).pipe(Effect.andThen(Ref.set(lastSpinnerMsg, msg)));
+			}
 			const delta = computeDelta(payload, {
 				value: active.value,
 				max: active.max
@@ -149,22 +168,48 @@ const DEFAULT_CONFIG = {
 		"dist",
 		"build",
 		".next",
-		".agents",
-		".claude",
 		".vscode",
-		".github",
 		"coverage",
 		"*-lock.yaml",
 		"*-lock.json",
-		"*.lock"
+		"*.lock",
+		".vite-hooks",
+		".fallow"
 	],
 	embedder: {
 		model: "Xenova/all-MiniLM-L6-v2",
 		device: "auto",
-		dtype: "fp32"
+		dtype: "fp32",
+		batchSize: 16
 	}
 };
 //#endregion
+//#region src/lib/extension.ts
+/** Extract the last path segment (filename) from a file path. Handles both `/` and `\\` separators. */
+const getFilename = (path) => {
+	const sepIndex = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+	return sepIndex >= 0 ? path.slice(sepIndex + 1) : path;
+};
+/**
+* Extract the lowercase extension (including dot) from a file path. Used for processor dispatch.
+* Strips the directory, then returns the part after the last dot. If no dot, returns the full
+* filename lowercased.
+*/
+const getExtension = (file) => {
+	const name = getFilename(file);
+	const dotIndex = name.lastIndexOf(".");
+	if (dotIndex === -1) return name.toLowerCase();
+	return name.slice(dotIndex).toLowerCase();
+};
+/**
+* Extract the extension from a filename (not full path). Returns `"(no extension)"` if no dot
+* exists. Used for display grouping of skipped files.
+*/
+const getFileExtension = (filename) => {
+	const dotIndex = filename.lastIndexOf(".");
+	return dotIndex >= 0 ? filename.slice(dotIndex) : "(no extension)";
+};
+//#endregion
 //#region src/domain/errors.ts
 /** Config file or directory does not exist. Run pix init first. */
 var ConfigNotFoundError = class extends Data.TaggedError("ConfigNotFoundError") {};
@@ -289,13 +334,13 @@ function buildProcessorMap(skipExtensions) {
 }
 //#endregion
 //#region src/application/index-project.ts
-function getExtension(file) {
-	const lastSlash = file.lastIndexOf("/");
-	const name = lastSlash >= 0 ? file.slice(lastSlash + 1) : file;
-	const dotIndex = name.lastIndexOf(".");
-	if (dotIndex === -1) return name.toLowerCase();
-	return name.slice(dotIndex).toLowerCase();
-}
+const deriveEffectiveConfig = (opts, config) => ({
+	batchSize: opts.batchSize ?? config.embedder.batchSize ?? 16,
+	concurrency: Math.max(1, opts.chunkConcurrency ?? config.chunkConcurrency ?? 8),
+	skipExtensions: opts.skipExtensions ? [...config.skipExtensions, ...opts.skipExtensions] : config.skipExtensions,
+	ignoredPaths: opts.ignorePaths ? [...config.ignoredPaths ?? DEFAULT_CONFIG.ignoredPaths, ...opts.ignorePaths] : config.ignoredPaths ?? DEFAULT_CONFIG.ignoredPaths,
+	ignoreGitignore: opts.ignoreGitignore ?? config.ignoreGitignore ?? false
+});
 const classifyFiles = (files, processorMap) => {
 	const knownFiles = [];
 	const skippedFiles = [];
@@ -313,11 +358,19 @@ const classifyFiles = (files, processorMap) => {
 		unknownExtensions
 	};
 };
-/**
-* Use case: index project files. Pipeline: scan → ContentExtractor → chunk → embed → store. Depends
-* on ConfigStore, Scanner, Chunker, Embedder, VectorStore, Display, ContentExtractor via Effect
-* tags.
-*/
+const classifyAndCollectChunks = (knownFiles, extractor, chunker, concurrency, skipped) => Stream.fromIterable(knownFiles).pipe(Stream.mapEffect((file) => extractor.extract(file).pipe(Effect.flatMap((text) => Effect.succeed(Option.some({
+	file,
+	text
+}))), Effect.catchAll((err) => Ref.update(skipped, (prev) => [...prev, {
+	path: file,
+	reason: err.message
+}]).pipe(Effect.flatMap(() => Effect.succeed(Option.none()))))), { concurrency }), Stream.filterMap((opt) => opt), Stream.mapEffect(({ file, text }) => chunker.chunkText(text, file), { concurrency }), Stream.flatMap((chunks) => Stream.fromIterable(chunks)), Stream.runCollect, Effect.map((allChunks) => {
+	const chunks = Chunk.toArray(allChunks);
+	return {
+		chunks,
+		totalChunks: chunks.length
+	};
+}));
 var IndexProject = class extends Effect.Service()("IndexProject", {
 	accessors: true,
 	effect: Effect.gen(function* () {
@@ -328,65 +381,118 @@ var IndexProject = class extends Effect.Service()("IndexProject", {
 		const vectorStore = yield* VectorStore;
 		const d = yield* Display;
 		const extractor = yield* ContentExtractor;
-		const index = () => Effect.gen(function* () {
+		const index = (opts = {}) => Effect.gen(function* () {
+			const start = Date.now();
 			if (!(yield* configStore.configExists())) yield* configStore.writeConfig(DEFAULT_CONFIG);
-			const config = yield* configStore.readConfig();
-			const processorMap = buildProcessorMap(config.skipExtensions);
+			const eff = deriveEffectiveConfig(opts, yield* configStore.readConfig());
+			const processorMap = buildProcessorMap(eff.skipExtensions);
 			yield* d.updateInteractive("Scanning source files...");
-			const ignoredPaths = config.ignoredPaths ?? DEFAULT_CONFIG.ignoredPaths;
-			const { knownFiles, skippedFiles, unknownExtensions } = classifyFiles((yield* scanner.scanFiles(ignoredPaths)).files, processorMap);
-			if (unknownExtensions.size > 0) yield* d.log(`Skipped ${skippedFiles.length} files with unknown extensions: ${[...unknownExtensions].join(", ")}`, "warn");
-			if (knownFiles.length === 0) return {
-				success: true,
-				status: {
-					chunks: 0,
-					files: 0,
-					totalLines: 0,
-					byteSize: 0
-				}
-			};
+			const scanResult = yield* scanner.scanFiles(eff.ignoredPaths, eff.ignoreGitignore);
+			const { knownFiles, skippedFiles, unknownExtensions } = classifyFiles(scanResult.files, processorMap);
+			const skipped = yield* Ref.make(scanResult.skipped.filter((s) => !s.reason.startsWith("Ignored by config pattern")).map((s) => ({
+				path: s.path,
+				reason: s.reason
+			})));
+			if (unknownExtensions.size > 0) yield* Ref.update(skipped, (prev) => [...prev, ...skippedFiles.map((f) => ({
+				path: f,
+				reason: "unknown extension"
+			}))]);
+			if (knownFiles.length === 0) {
+				yield* displaySkippedNote(d, yield* Ref.get(skipped));
+				return {
+					success: true,
+					status: {
+						chunks: 0,
+						files: 0,
+						totalLines: 0,
+						byteSize: 0
+					},
+					durationMs: Date.now() - start
+				};
+			}
 			yield* d.updateInteractive(`Processing ${knownFiles.length} files...`);
-			const allChunks = (yield* Effect.forEach(knownFiles, (file) => Effect.gen(function* () {
-				const result = yield* Effect.either(extractor.extract(file));
-				if (result._tag === "Left") {
-					if (result.left._tag === "UnsupportedFormat") {
-						yield* d.log(`Skipping ${file}: ${result.left.message}`, "warn");
-						return [];
-					}
-					return yield* Effect.fail(result.left);
-				}
-				return yield* chunker.chunkText(result.right, file);
-			}), { concurrency: Math.max(1, config.chunkConcurrency ?? 8) })).flat();
-			const totalChunks = allChunks.length;
-			const totalFiles = new Set(allChunks.map((c) => c.file)).size;
-			const totalLines = allChunks.reduce((sum, c) => sum + (c.endLine - c.startLine + 1), 0);
-			if (totalChunks === 0) return {
-				success: true,
-				status: {
-					chunks: 0,
-					files: 0,
-					totalLines: 0,
-					byteSize: 0
-				}
-			};
-			yield* d.updateInteractive(`Embedding ${totalChunks} chunks...`);
-			const texts = allChunks.map((c) => c.text);
-			const embeddings = yield* embedder.batch(texts);
-			yield* vectorStore.store(allChunks, embeddings);
-			const dims = embeddings[0]?.dims ?? 384;
+			const { chunks, totalChunks } = yield* classifyAndCollectChunks(knownFiles, extractor, chunker, eff.concurrency, skipped);
+			if (totalChunks === 0) {
+				yield* displaySkippedNote(d, yield* Ref.get(skipped));
+				return {
+					success: true,
+					status: {
+						chunks: 0,
+						files: 0,
+						totalLines: 0,
+						byteSize: 0
+					},
+					durationMs: Date.now() - start
+				};
+			}
+			yield* vectorStore.storeBegin();
+			const embeddedRef = yield* Ref.make(0);
+			const stats = yield* d.progress({
+				message: `Embedding ${totalChunks} chunks...`,
+				max: totalChunks
+			}, Stream.fromIterable(chunks).pipe(Stream.grouped(eff.batchSize), Stream.mapEffect((batchChunk) => Effect.gen(function* () {
+				const batch = Chunk.toArray(batchChunk);
+				const texts = batch.map((c) => c.text);
+				const embeddings = yield* embedder.batch(texts);
+				yield* vectorStore.storeBatch(batch, embeddings);
+				const count = yield* Ref.updateAndGet(embeddedRef, (n) => n + batch.length);
+				yield* d.updateInteractive({
+					message: `Embedding ${count} of ${totalChunks} chunks`,
+					setTo: count
+				});
+			})), Stream.runDrain, Effect.matchEffect({
+				onSuccess: () => vectorStore.storeCommit(),
+				onFailure: (err) => vectorStore.storeAbort().pipe(Effect.flatMap(() => Effect.fail(err)))
+			})));
+			yield* displaySkippedNote(d, yield* Ref.get(skipped));
+			const durationSec = ((Date.now() - start) / 1e3).toFixed(1);
+			yield* d.log(`Indexed ${stats.chunks} chunks from ${stats.files} files in ${durationSec}s`, "success");
+			const fallbackInfo = yield* embedder.getFallbackInfo();
 			return {
 				success: true,
 				status: {
-					chunks: totalChunks,
-					files: totalFiles,
-					totalLines,
-					byteSize: embeddings.length * dims * 4
-				}
+					chunks: stats.chunks,
+					files: stats.files,
+					totalLines: stats.totalLines,
+					byteSize: stats.byteSize
+				},
+				durationMs: Date.now() - start,
+				embedderFallback: fallbackInfo
 			};
 		});
 		return { index };
 	})
 }) {};
+const groupByExtension = (entries) => {
+	const byExt = /* @__PURE__ */ new Map();
+	for (const s of entries) {
+		const name = getFilename(s.path);
+		const ext = getFileExtension(name);
+		if (!byExt.has(ext)) byExt.set(ext, []);
+		byExt.get(ext).push(name);
+	}
+	return byExt;
+};
+const formatFileList = (files, maxDisplay = 5) => files.length > maxDisplay ? `${files.slice(0, maxDisplay).join(", ")} +${files.length - maxDisplay} more` : files.join(", ");
+const buildSkippedLines = (extFailures, extractErrors) => {
+	const lines = [];
+	if (extFailures.length > 0) {
+		lines.push(`Unknown extensions (${extFailures.length})`);
+		for (const [ext, files] of groupByExtension(extFailures)) lines.push(`  ${ext} (${files.length}): ${formatFileList(files)}`);
+	}
+	if (extractErrors.length > 0) {
+		if (lines.length > 0) lines.push("");
+		lines.push(`Extraction errors (${extractErrors.length})`);
+		for (const s of extractErrors) lines.push(`  ${getFilename(s.path)}: ${s.reason}`);
+	}
+	return lines;
+};
+const displaySkippedNote = (d, skipped) => {
+	if (skipped.length === 0) return Effect.void;
+	const extFailures = skipped.filter((s) => s.reason === "unknown extension");
+	const extractErrors = skipped.filter((s) => s.reason !== "unknown extension");
+	return d.note(buildSkippedLines(extFailures, extractErrors).join("\n"), `Skipped ${skipped.length} files`);
+};
 //#endregion
 //#region src/application/init-project.ts
 /**
@@ -412,7 +518,7 @@ var QueryProject = class extends Effect.Service()("QueryProject", {
 	effect: Effect.gen(function* () {
 		const embedder = yield* Embedder;
 		const store = yield* VectorStore;
-		const queryProject = (queryText, topK) => embedder.embed(queryText).pipe(Effect.flatMap((embedding) => store.search(embedding, topK)));
+		const queryProject = (queryText, options) => embedder.embed(queryText).pipe(Effect.flatMap((embedding) => store.search(embedding, options)));
 		return { queryProject };
 	})
 }) {};
@@ -475,22 +581,60 @@ const reportError = (error) => Effect.gen(function* () {
 });
 //#endregion
 //#region src/commands/index-cmd.ts
-/** CLI command: pix index [--force] [--verbose] [--json] */
+const batchSizeOption = Options.integer("batch-size").pipe(Options.withAlias("b"), Options.optional);
+const chunkConcurrencyOption = Options.integer("chunk-concurrency").pipe(Options.withAlias("c"), Options.optional);
+const skipExtensionsOption = Options.text("skip-extensions").pipe(Options.withAlias("s"), Options.repeated);
+const ignorePathOption = Options.text("ignore-path").pipe(Options.repeated);
+const ignorePathsOption = Options.text("ignore-paths").pipe(Options.repeated);
+const ignoreGitignoreOption = Options.boolean("ignore-gitignore").pipe(Options.withDefault(false));
+const splitCsv = (values) => values.flatMap((v) => v.split(",").map((s) => s.trim()).filter((s) => s.length > 0));
+const buildIndexOptions = (args) => {
+	if (Option.isSome(args.batchSize) && args.batchSize.value <= 0) throw new Error(`--batch-size must be positive, got ${args.batchSize.value}`);
+	if (Option.isSome(args.chunkConcurrency) && args.chunkConcurrency.value <= 0) throw new Error(`--chunk-concurrency must be positive, got ${args.chunkConcurrency.value}`);
+	const cliSkipExtensions = splitCsv(args.skipExtensions);
+	const cliIgnorePaths = [...args.ignorePath.map((s) => s.trim()).filter((s) => s.length > 0), ...splitCsv(args.ignorePaths)];
+	return {
+		batchSize: Option.getOrUndefined(args.batchSize),
+		chunkConcurrency: Option.getOrUndefined(args.chunkConcurrency),
+		skipExtensions: cliSkipExtensions.length > 0 ? cliSkipExtensions : void 0,
+		ignorePaths: cliIgnorePaths.length > 0 ? cliIgnorePaths : void 0,
+		ignoreGitignore: args.ignoreGitignore || void 0
+	};
+};
+const emitIndexResult = (d, result) => Effect.gen(function* () {
+	yield* d.json({
+		chunks: result.status.chunks,
+		files: result.status.files,
+		totalLines: result.status.totalLines,
+		byteSize: result.status.byteSize,
+		durationMs: result.durationMs,
+		...result.embedderFallback && { embedderFallback: result.embedderFallback }
+	});
+	if (result.status.chunks === 0) yield* d.log("No chunks to index.", "warn");
+});
 const indexCommand = Command.make("index", {
 	force: Options.boolean("force").pipe(Options.withDefault(false)),
 	verbose: Options.boolean("verbose").pipe(Options.withDefault(false)),
-	json: Options.boolean("json").pipe(Options.withDefault(false))
-}, ({ force, verbose }) => Effect.gen(function* () {
+	json: Options.boolean("json").pipe(Options.withDefault(false)),
+	batchSize: batchSizeOption,
+	chunkConcurrency: chunkConcurrencyOption,
+	skipExtensions: skipExtensionsOption,
+	ignorePath: ignorePathOption,
+	ignorePaths: ignorePathsOption,
+	ignoreGitignore: ignoreGitignoreOption
+}, ({ force, verbose, batchSize, chunkConcurrency, skipExtensions, ignorePath, ignorePaths, ignoreGitignore }) => Effect.gen(function* () {
 	const d = yield* Display;
 	if (force) yield* d.log("--force is currently not implemented and only a placeholder.", "warn");
 	if (verbose) yield* d.log("--verbose is currently not implemented and only a placeholder.", "warn");
-	const result = yield* d.spinner("Indexing project...", IndexProject.index());
-	yield* d.json({
-		chunks: result.status.chunks,
-		files: result.status.files
+	const options = buildIndexOptions({
+		batchSize,
+		chunkConcurrency,
+		skipExtensions,
+		ignorePath,
+		ignorePaths,
+		ignoreGitignore
 	});
-	if (result.status.chunks === 0) yield* d.log("No chunks to index.", "warn");
-	else yield* d.log(`Indexed ${result.status.chunks} chunks from ${result.status.files} files.`, "success");
+	yield* emitIndexResult(d, yield* d.spinner("Indexing project...", IndexProject.index(options)));
 }).pipe(Effect.catchAll(reportError)));
 //#endregion
 //#region src/commands/init.ts
@@ -506,6 +650,51 @@ const initCommand = Command.make("init", { json: Options.boolean("json").pipe(Op
 	DiskFullError: reportError
 })));
 //#endregion
+//#region src/lib/format.ts
+/** Format byte count as human-readable string (e.g. "1.5 MB") */
+const formatBytes = (bytes) => {
+	if (bytes === 0) return "0 B";
+	const units = [
+		"B",
+		"KB",
+		"MB",
+		"GB"
+	];
+	const i = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1);
+	return `${(bytes / 1024 ** i).toFixed(1)} ${units[i]}`;
+};
+/**
+* Apply a character budget to search results. Returns results in score order capped by the budget.
+* The last result may be truncated to fit the remaining budget. Character count includes file path,
+* line numbers, chunk text, and context lines.
+*/
+const applyCharBudget = (results, maxChars) => {
+	if (!maxChars || maxChars <= 0) return { results };
+	const budgeted = [];
+	let remaining = maxChars;
+	for (const result of results) {
+		const indicator = " [...]";
+		const metadata = `${result.file}:${result.startLine}-${result.endLine}\n`;
+		const chars = `${metadata}${result.text}${result.contextBefore ? `\n${result.contextBefore}` : ""}${result.contextAfter ? `\n${result.contextAfter}` : ""}`.length;
+		if (chars <= remaining) {
+			budgeted.push(result);
+			remaining -= chars;
+		} else {
+			const textBudget = remaining - metadata.length - 6;
+			if (textBudget <= 0) break;
+			const truncated = result.text.slice(0, textBudget);
+			budgeted.push({
+				...result,
+				text: `${truncated}${indicator}`,
+				contextBefore: null,
+				contextAfter: null
+			});
+			break;
+		}
+	}
+	return { results: budgeted };
+};
+//#endregion
 //#region src/commands/query.ts
 const DEFAULT_TOP_K = 5;
 const DEFAULT_CONTEXT_LINES = 0;
@@ -532,31 +721,64 @@ const formatResult = (result) => {
 	const contextAfter = result.contextAfter ? `\n${result.contextAfter}` : "";
 	return `${result.file}:${result.startLine}-${result.endLine} (score: ${result.score.toFixed(3)})${contextBefore}\n${result.text}${contextAfter}`;
 };
-const toJsonOutput = (results, ctxLines) => results.map((r) => ({
+/** Format a result as a lightweight location reference (no text content). */
+const formatLocation = (result) => `${result.file}:${result.startLine}-${result.endLine} (score: ${result.score.toFixed(3)})`;
+/** Build optional content fields for a single JSON output entry. */
+const buildContentFields = (r, ctxLines, noContent) => {
+	if (noContent) return {};
+	return {
+		text: r.text,
+		...ctxLines > 0 && r.contextBefore && { contextBefore: r.contextBefore },
+		...ctxLines > 0 && r.contextAfter && { contextAfter: r.contextAfter }
+	};
+};
+const toJsonOutput = (results, ctxLines, noContent = false) => results.map((r) => ({
 	score: r.score,
 	file: r.file,
 	startLine: r.startLine,
 	endLine: r.endLine,
-	text: r.text,
-	...ctxLines > 0 && r.contextBefore && { contextBefore: r.contextBefore },
-	...ctxLines > 0 && r.contextAfter && { contextAfter: r.contextAfter }
+	...buildContentFields(r, ctxLines, noContent)
 }));
-/** CLI command: pix query "<text>" [--top N] [--json] [--context-lines N] */
+/** Build SearchOptions from parsed CLI args, clamping topK. */
+const buildSearchOptions = (top, ignorePath, onlyPath) => {
+	const rawValue = Option.getOrElse(top, () => DEFAULT_TOP_K);
+	const clamped = clampTopK(rawValue);
+	return {
+		options: {
+			topK: clamped.value,
+			...ignorePath.length > 0 && { ignorePaths: [...ignorePath] },
+			...onlyPath.length > 0 && { onlyPaths: [...onlyPath] }
+		},
+		clamped: clamped.clamped,
+		rawValue
+	};
+};
+/** Render search results via Display — JSON + human-readable text. */
+const renderResults = (d, results, ctxLines, noContent) => Effect.gen(function* () {
+	yield* d.json(toJsonOutput(results, ctxLines, noContent));
+	if (results.length === 0) yield* d.log("No results found", "warn");
+	else for (const result of results) yield* d.text(noContent ? formatLocation(result) : formatResult(result));
+});
+/**
+* CLI command: pix query "<text>" [--top N] [--json] [--context-lines N] [--ignore-path P]
+* [--only-path P] [--max-characters N] [--no-content]
+*/
 const queryCommand = Command.make("query", {
 	queryText: Args.text({ name: "query" }),
 	top: Options.integer("top").pipe(Options.withDefault(DEFAULT_TOP_K), Options.optional),
 	json: Options.boolean("json").pipe(Options.withDefault(false)),
-	contextLines: Options.integer("context-lines").pipe(Options.withDefault(DEFAULT_CONTEXT_LINES), Options.optional)
-}, ({ queryText, top, contextLines }) => Effect.gen(function* () {
+	contextLines: Options.integer("context-lines").pipe(Options.withDefault(DEFAULT_CONTEXT_LINES), Options.optional),
+	ignorePath: Options.text("ignore-path").pipe(Options.repeated),
+	onlyPath: Options.text("only-path").pipe(Options.repeated),
+	maxCharacters: Options.integer("max-characters").pipe(Options.optional),
+	noContent: Options.boolean("no-content").pipe(Options.withDefault(false))
+}, ({ queryText, top, contextLines, ignorePath, onlyPath, maxCharacters, noContent }) => Effect.gen(function* () {
 	const d = yield* Display;
-	const topK = Option.getOrElse(top, () => DEFAULT_TOP_K);
 	const ctxLines = Option.getOrElse(contextLines, () => DEFAULT_CONTEXT_LINES);
-	const clamped = clampTopK(topK);
-	if (clamped.clamped) yield* d.log(`topK clamped from ${topK} to ${clamped.value}`, "warn");
-	const results = yield* d.spinner("Searching...", QueryProject.queryProject(queryText, clamped.value));
-	yield* d.json(toJsonOutput(results, ctxLines));
-	if (results.length === 0) yield* d.log("No results found", "warn");
-	else for (const result of results) yield* d.text(formatResult(result));
+	const { options: searchOptions, clamped, rawValue } = buildSearchOptions(top, ignorePath, onlyPath);
+	if (clamped) yield* d.log(`topK clamped from ${rawValue} to ${searchOptions.topK}`, "warn");
+	const results = yield* d.spinner("Searching...", QueryProject.queryProject(queryText, searchOptions));
+	yield* renderResults(d, noContent ? results : applyCharBudget(results, Option.getOrUndefined(maxCharacters)).results, ctxLines, noContent);
 }).pipe(Effect.catchTags({
 	ModelLoadError: reportError,
 	InferenceError: reportError,
@@ -565,20 +787,6 @@ const queryCommand = Command.make("query", {
 	NoIndexError: reportError
 })));
 //#endregion
-//#region src/lib/format.ts
-/** Format byte count as human-readable string (e.g. "1.5 MB") */
-const formatBytes = (bytes) => {
-	if (bytes === 0) return "0 B";
-	const units = [
-		"B",
-		"KB",
-		"MB",
-		"GB"
-	];
-	const i = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1);
-	return `${(bytes / 1024 ** i).toFixed(1)} ${units[i]}`;
-};
-//#endregion
 //#region src/commands/reset.ts
 /** CLI command: pix reset [--json] */
 const resetCommand = Command.make("reset", { json: Options.boolean("json").pipe(Options.withDefault(false)) }, () => Effect.gen(function* () {
@@ -692,13 +900,19 @@ const buildChunks = (file, content, config) => {
 		const text = lines.slice(startLine - 1, endLine).join("\n");
 		if (text.length >= MIN_CHUNK_CHARS) {
 			const id = crypto.createHash("sha1").update(`${file}:${startLine}`).digest("hex").slice(0, 12);
+			const contextBeforeStart = Math.max(0, startLine - 1 - config.overlapLines);
+			const contextBefore = lines.slice(contextBeforeStart, startLine - 1).join("\n");
+			const contextAfterEnd = Math.min(lines.length, endLine + config.overlapLines);
+			const contextAfter = lines.slice(endLine, contextAfterEnd).join("\n");
 			chunks.push({
 				id,
 				idx,
 				file,
 				startLine,
 				endLine,
-				text
+				text,
+				contextBefore: contextBefore || null,
+				contextAfter: contextAfter || null
 			});
 			idx++;
 		}
@@ -725,12 +939,19 @@ const make$5 = Effect.gen(function* () {
 });
 const ChunkerLive = Layer.effect(Chunker, make$5);
 //#endregion
+//#region src/lib/platform-error.ts
+/**
+* Check if a platform error has a specific `reason` string (e.g. "BadResource" for disk full,
+* "NotFound" for missing files). Platform errors from @effect/platform include a `reason` property
+* that categorizes the failure.
+*/
+const isPlatformReason = (cause, reason) => typeof cause === "object" && cause !== null && "reason" in cause && String(cause.reason) === reason;
+//#endregion
 //#region src/services/config-store.ts
 const CONFIG_DIR = ".pix";
 const CONFIG_PATH = `${CONFIG_DIR}/config.json`;
-const isPlatformReason$1 = (cause, reason) => typeof cause === "object" && cause !== null && "reason" in cause && String(cause.reason) === reason;
 const mapConfigWriteError = (cause, path, action) => {
-	if (isPlatformReason$1(cause, "BadResource")) return new DiskFullError({
+	if (isPlatformReason(cause, "BadResource")) return new DiskFullError({
 		message: `Disk full: could not ${action}`,
 		path,
 		cause
@@ -749,7 +970,7 @@ const make$4 = Effect.gen(function* () {
 	});
 	const readConfig = () => Effect.gen(function* () {
 		const content = yield* fs.readFileString(CONFIG_PATH).pipe(Effect.mapError((cause) => {
-			if (isPlatformReason$1(cause, "NotFound")) return new ConfigNotFoundError({
+			if (isPlatformReason(cause, "NotFound")) return new ConfigNotFoundError({
 				message: "Config file not found. Run pix init first.",
 				path: CONFIG_PATH,
 				cause
@@ -784,10 +1005,7 @@ const make$3 = Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
 	const processorMap = buildProcessorMap([]);
 	const extract = (file) => {
-		const lastSlash = file.lastIndexOf("/");
-		const name = lastSlash >= 0 ? file.slice(lastSlash + 1) : file;
-		const dotIndex = name.lastIndexOf(".");
-		const ext = dotIndex === -1 ? name.toLowerCase() : name.slice(dotIndex).toLowerCase();
+		const ext = getExtension(file);
 		const processor = processorMap[ext];
 		if (!processor) return Effect.fail({
 			_tag: "UnsupportedFormat",
@@ -828,9 +1046,7 @@ const MODEL_REGISTRY = {
 };
 //#endregion
 //#region src/services/embedder.ts
-const CACHE_DIR = ".pix/cache";
-const BATCH_SIZE = 16;
-env.cacheDir = CACHE_DIR;
+env.cacheDir = ".pix/cache";
 const normalize = (arr) => {
 	let norm = 0;
 	for (let i = 0; i < arr.length; i++) norm += arr[i] * arr[i];
@@ -872,16 +1088,14 @@ const createExtractor = (opts) => Effect.tryPromise(async () => {
 	model: opts.model,
 	cause
 })));
-const createExtractorWithFallback = (opts) => {
+const createExtractorWithFallback = (opts, fallbackRef) => {
 	if (opts.device === "cpu") return createExtractor(opts);
 	return createExtractor(opts).pipe(Effect.catchAll((originalError) => Effect.gen(function* () {
-		const d = yield* Display;
-		yield* d.log(`GPU (${opts.device}) failed, falling back to CPU...`, "warn");
-		yield* d.json({
-			event: "embedder_fallback",
+		yield* (yield* Display).log(`GPU (${opts.device}) failed, falling back to CPU...`, "warn");
+		yield* Ref.set(fallbackRef, Option.some({
 			originalDevice: opts.device,
 			reason: originalError.message
-		});
+		}));
 		return yield* createExtractor({
 			...opts,
 			device: "cpu"
@@ -892,7 +1106,8 @@ const make$2 = Effect.gen(function* () {
 	const configStore = yield* ConfigStore;
 	const d = yield* Display;
 	const cfg = yield* resolveEmbedderConfig(configStore);
-	const getExtractor = yield* Effect.cached(createExtractorWithFallback(cfg));
+	const fallbackRef = yield* Ref.make(Option.none());
+	const getExtractor = yield* Effect.cached(createExtractorWithFallback(cfg, fallbackRef));
 	const embed = (text) => Effect.gen(function* () {
 		const extractor = yield* getExtractor;
 		const data = (yield* Effect.tryPromise(() => extractor(text, {
@@ -909,31 +1124,30 @@ const make$2 = Effect.gen(function* () {
 	}).pipe(Effect.provideService(Display, d));
 	const batch = (texts) => Effect.gen(function* () {
 		const extractor = yield* getExtractor;
+		const tensor = yield* Effect.tryPromise(() => extractor([...texts], {
+			pooling: "mean",
+			normalize: false
+		})).pipe(Effect.mapError((cause) => new InferenceError({
+			message: "Batch embedding inference failed",
+			cause
+		})));
+		const data = tensor.data;
+		const n = tensor.dims[0];
 		const results = [];
-		for (let i = 0; i < texts.length; i += BATCH_SIZE) {
-			const slice = texts.slice(i, i + BATCH_SIZE);
-			const tensor = yield* Effect.tryPromise(() => extractor(slice, {
-				pooling: "mean",
-				normalize: false
-			})).pipe(Effect.mapError((cause) => new InferenceError({
-				message: "Batch embedding inference failed",
-				cause
-			})));
-			const data = tensor.data;
-			const n = tensor.dims[0];
-			for (let j = 0; j < n; j++) {
-				const offset = j * cfg.dims;
-				results.push(normalize(data.slice(offset, offset + cfg.dims)));
-			}
+		for (let j = 0; j < n; j++) {
+			const offset = j * cfg.dims;
+			results.push({
+				vector: normalize(data.slice(offset, offset + cfg.dims)),
+				dims: cfg.dims
+			});
 		}
-		return results.map((vector) => ({
-			vector,
-			dims: cfg.dims
-		}));
+		return results;
 	}).pipe(Effect.provideService(Display, d));
+	const getFallbackInfo = () => Ref.get(fallbackRef).pipe(Effect.map(Option.getOrElse(() => void 0)));
 	return {
 		embed,
-		batch
+		batch,
+		getFallbackInfo
 	};
 });
 const OnnxEmbedderLive = Layer.provideMerge(Layer.effect(Embedder, make$2), ConfigStoreLive);
@@ -977,7 +1191,16 @@ const make$1 = Effect.gen(function* () {
 		if (result.skipped) skipped.push(result.skipped);
 		if (result.content.trim()) ig.add(result.content.split("\n"));
 	});
-	const loadGitignoreRules = (ignoredPaths, cwd) => Effect.gen(function* () {
+	const loadGitignoreRules = (ignoredPaths) => {
+		const ig = ignore();
+		const skipped = [];
+		if (ignoredPaths.length > 0) ig.add(ignoredPaths);
+		return Effect.succeed({
+			ig,
+			skipped
+		});
+	};
+	const loadGitignoreRulesWithFiles = (ignoredPaths, cwd) => Effect.gen(function* () {
 		const ig = ignore();
 		const skipped = [];
 		if (ignoredPaths.length > 0) ig.add(ignoredPaths);
@@ -1056,10 +1279,10 @@ const make$1 = Effect.gen(function* () {
 			skipped
 		};
 	});
-	const scanFiles = (ignoredPaths) => Effect.gen(function* () {
+	const scanFiles = (ignoredPaths, ignoreGitignore) => Effect.gen(function* () {
 		const cwd = process.cwd();
-		const { ig, skipped: ignoreSkipped } = yield* loadGitignoreRules(ignoredPaths, cwd).pipe(Effect.mapError((cause) => new ScanFailed({
-			message: `Failed to load gitignore rules: ${String(cause)}`,
+		const { ig, skipped: ignoreSkipped } = yield* (ignoreGitignore ? loadGitignoreRules(ignoredPaths) : loadGitignoreRulesWithFiles(ignoredPaths, cwd)).pipe(Effect.mapError((cause) => new ScanFailed({
+			message: `Failed to load ignore rules: ${String(cause)}`,
 			cause
 		})));
 		const { files, skipped: walkSkipped } = yield* walk(cwd, ig, cwd);
@@ -1073,16 +1296,66 @@ const make$1 = Effect.gen(function* () {
 const ScannerLive = Layer.effect(Scanner, make$1);
 //#endregion
 //#region src/services/vector-store.ts
+/**
+* Parse a single JSON line from chunks.jsonl and normalize context fields (old indexes may lack
+* them).
+*/
+const parseChunkLine = (line) => {
+	const raw = JSON.parse(line);
+	return {
+		file: typeof raw.file === "string" ? raw.file : "",
+		startLine: typeof raw.startLine === "number" ? raw.startLine : 0,
+		endLine: typeof raw.endLine === "number" ? raw.endLine : 0,
+		text: typeof raw.text === "string" ? raw.text : "",
+		contextBefore: typeof raw.contextBefore === "string" ? raw.contextBefore : null,
+		contextAfter: typeof raw.contextAfter === "string" ? raw.contextAfter : null
+	};
+};
+/** Compute dot-product similarity between a chunk vector and the query embedding. */
+const computeDotProduct = (chunkVector, query) => {
+	let dot = 0;
+	for (let j = 0; j < query.dims; j++) dot += chunkVector[j] * query.vector[j];
+	return dot;
+};
 const STORE_DIR = ".pix";
 const CHUNKS_FILE = `${STORE_DIR}/chunks.jsonl`;
 const VECTORS_FILE = `${STORE_DIR}/vectors.bin`;
-const isPlatformReason = (cause, reason) => typeof cause === "object" && cause !== null && "reason" in cause && String(cause.reason) === reason;
+/**
+* Serialize a Chunk to a JSON object for storage in chunks.jsonl. Always includes context fields
+* for schema consistency.
+*/
+const serializeChunk = (c) => ({
+	id: c.id,
+	idx: c.idx,
+	file: c.file,
+	startLine: c.startLine,
+	endLine: c.endLine,
+	text: c.text,
+	contextBefore: c.contextBefore,
+	contextAfter: c.contextAfter
+});
 /**
 * FileSystem adapter for VectorStore port. Reads from chunks.jsonl and vectors.bin to provide index
 * statistics.
 */
 const make = Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
+	const chunksTemp = `${CHUNKS_FILE}.tmp`;
+	const vectorsTemp = `${VECTORS_FILE}.tmp`;
+	const seenFiles = yield* Ref.make(/* @__PURE__ */ new Set());
+	const statsAccumulator = yield* Ref.make({
+		chunks: 0,
+		files: 0,
+		totalLines: 0,
+		byteSize: 0
+	});
+	const serializeVectors = (embeddings) => {
+		const dims = embeddings[0]?.dims ?? 384;
+		const totalFloats = embeddings.length * dims;
+		const vectorsArray = new Float32Array(totalFloats);
+		for (let i = 0; i < embeddings.length; i++) vectorsArray.set(embeddings[i].vector, i * dims);
+		return Buffer.from(vectorsArray.buffer);
+	};
 	/**
 	* Count total lines across all chunks in chunks.jsonl. Each line is a JSON object; the 'text'
 	* field contains the source code.
@@ -1145,44 +1418,82 @@ const make = Effect.gen(function* () {
 			deleted: true
 		};
 	});
+	const storeBegin = () => Effect.gen(function* () {
+		yield* ensureDirExists(STORE_DIR, ".pix directory");
+		yield* Ref.set(seenFiles, /* @__PURE__ */ new Set());
+		yield* Ref.set(statsAccumulator, {
+			chunks: 0,
+			files: 0,
+			totalLines: 0,
+			byteSize: 0
+		});
+		if (yield* withStoreError(fs.exists(chunksTemp), "check chunks temp")) yield* withStoreError(fs.remove(chunksTemp), "clean stale chunks temp", chunksTemp);
+		if (yield* withStoreError(fs.exists(vectorsTemp), "check vectors temp")) yield* withStoreError(fs.remove(vectorsTemp), "clean stale vectors temp", vectorsTemp);
+	});
+	const storeBatch = (chunks, embeddings) => Effect.gen(function* () {
+		const content = chunks.map((c) => JSON.stringify(serializeChunk(c))).join("\n") + "\n";
+		yield* withStoreError(fs.writeFile(chunksTemp, Buffer.from(content), { flag: "a" }), "append chunks", chunksTemp);
+		const buffer = serializeVectors(embeddings);
+		yield* withStoreError(fs.writeFile(vectorsTemp, buffer, { flag: "a" }), "append vectors", vectorsTemp);
+		const dims = embeddings[0]?.dims ?? 384;
+		const batchLines = chunks.reduce((sum, c) => sum + (c.endLine - c.startLine + 1), 0);
+		const batchBytes = embeddings.length * dims * 4;
+		yield* Ref.update(seenFiles, (prev) => {
+			for (const c of chunks) prev.add(c.file);
+			return prev;
+		});
+		yield* Ref.update(statsAccumulator, (prev) => ({
+			chunks: prev.chunks + chunks.length,
+			files: 0,
+			totalLines: prev.totalLines + batchLines,
+			byteSize: prev.byteSize + batchBytes
+		}));
+	});
+	const storeCommit = () => Effect.gen(function* () {
+		yield* withStoreError(fs.rename(chunksTemp, CHUNKS_FILE), "commit chunks", CHUNKS_FILE);
+		yield* withStoreError(fs.rename(vectorsTemp, VECTORS_FILE), "commit vectors", VECTORS_FILE);
+		const stats = yield* Ref.get(statsAccumulator);
+		const files = yield* Ref.get(seenFiles);
+		yield* Ref.set(seenFiles, /* @__PURE__ */ new Set());
+		return {
+			...stats,
+			files: files.size
+		};
+	});
+	const storeAbort = () => Effect.gen(function* () {
+		yield* Ref.set(seenFiles, /* @__PURE__ */ new Set());
+		if (yield* withReadError(fs.exists(chunksTemp), "check chunks temp")) yield* withReadError(fs.remove(chunksTemp), "abort chunks temp", chunksTemp);
+		if (yield* withReadError(fs.exists(vectorsTemp), "check vectors temp")) yield* withReadError(fs.remove(vectorsTemp), "abort vectors temp", vectorsTemp);
+	});
 	const store = (chunks, embeddings) => Effect.gen(function* () {
 		yield* ensureDirExists(STORE_DIR, ".pix directory");
 		const chunksTemp = `${CHUNKS_FILE}.tmp`;
-		const chunksLines = chunks.map((c) => JSON.stringify({
-			id: c.id,
-			idx: c.idx,
-			file: c.file,
-			startLine: c.startLine,
-			endLine: c.endLine,
-			text: c.text
-		}));
-		yield* withStoreError(fs.writeFileString(chunksTemp, chunksLines.join("\n")), "write chunks", chunksTemp);
+		const chunksJson = chunks.map((c) => JSON.stringify(serializeChunk(c))).join("\n");
+		yield* withStoreError(fs.writeFileString(chunksTemp, chunksJson), "write chunks", chunksTemp);
 		yield* withStoreError(fs.rename(chunksTemp, CHUNKS_FILE), "commit chunks", CHUNKS_FILE);
 		const vectorsTemp = `${VECTORS_FILE}.tmp`;
-		const dims = embeddings[0]?.dims ?? 384;
-		const totalFloats = embeddings.length * dims;
-		const vectorsArray = new Float32Array(totalFloats);
-		for (let i = 0; i < embeddings.length; i++) vectorsArray.set(embeddings[i].vector, i * dims);
-		const buffer = Buffer.from(vectorsArray.buffer);
+		const buffer = serializeVectors(embeddings);
 		yield* withStoreError(fs.writeFile(vectorsTemp, buffer), "write vectors", vectorsTemp);
 		yield* withStoreError(fs.rename(vectorsTemp, VECTORS_FILE), "commit vectors", VECTORS_FILE);
 	});
-	const search = (query, topK) => Effect.gen(function* () {
+	const search = (query, options) => Effect.gen(function* () {
 		const chunksExists = yield* withReadError(fs.exists(CHUNKS_FILE), "check chunks file");
 		const vectorsExists = yield* withReadError(fs.exists(VECTORS_FILE), "check vectors file");
 		if (!chunksExists || !vectorsExists) return yield* new NoIndexError({ message: "No index found. Run pix index first." });
 		const chunkLines = (yield* withReadError(fs.readFileString(CHUNKS_FILE), "read chunks", CHUNKS_FILE)).split("\n").filter((l) => l.trim().length > 0);
 		const vectorsBuffer = yield* withReadError(fs.readFile(VECTORS_FILE), "read vectors", VECTORS_FILE);
-		const vectors = new Float32Array(vectorsBuffer.buffer);
+		const vectors = new Float32Array(vectorsBuffer.buffer, vectorsBuffer.byteOffset, vectorsBuffer.byteLength / Float32Array.BYTES_PER_ELEMENT);
+		const ignoreIg = options?.ignorePaths?.length ? ignore().add([...options.ignorePaths]) : null;
+		const onlyIg = options?.onlyPaths?.length ? ignore().add([...options.onlyPaths]) : null;
 		const results = [];
 		for (let i = 0; i < chunkLines.length; i++) try {
-			const chunk = JSON.parse(chunkLines[i]);
+			const chunk = parseChunkLine(chunkLines[i]);
+			if (ignoreIg && ignoreIg.ignores(chunk.file)) continue;
+			if (onlyIg && !onlyIg.ignores(chunk.file)) continue;
 			const startIdx = i * query.dims;
-			const chunkVector = vectors.slice(startIdx, startIdx + query.dims);
-			let dotProduct = 0;
-			for (let j = 0; j < query.dims; j++) dotProduct += chunkVector[j] * query.vector[j];
+			const score = computeDotProduct(vectors.slice(startIdx, startIdx + query.dims), query);
 			results.push({
-				score: dotProduct,
+				score,
 				file: chunk.file,
 				startLine: chunk.startLine,
 				endLine: chunk.endLine,
@@ -1192,7 +1503,10 @@ const make = Effect.gen(function* () {
 			});
 		} catch {}
 		results.sort((a, b) => b.score - a.score);
-		return results.slice(0, topK);
+		const topK = options?.topK;
+		if (topK == null) return results;
+		const clamped = Math.max(0, Math.min(Math.floor(topK), results.length));
+		return results.slice(0, clamped);
 	});
 	const getStatus = () => Effect.gen(function* () {
 		const chunksExists = yield* withReadError(fs.exists(CHUNKS_FILE), "check chunks file");
@@ -1232,6 +1546,10 @@ const make = Effect.gen(function* () {
 	});
 	return {
 		store,
+		storeBegin,
+		storeBatch,
+		storeCommit,
+		storeAbort,
 		search,
 		getStatus,
 		reset

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucas-bur/pix",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "Lightweight local semantic project indexer",
   "keywords": [
     "cli",