@lucas-bur/pix 0.6.0 → 0.8.0

package/dist/index.mjs

@@ -23,7 +23,7 @@ var GetStatus = class extends Effect.Service()("GetStatus", {
 		const configStore = yield* ConfigStore;
 		const getStatus = () => Effect.gen(function* () {
 			const status = yield* store.getStatus();
-			const configModel = yield* configStore.readConfig().pipe(Effect.map((c) => c.model), Effect.catchAll(() => Effect.succeed(status.model)));
+			const configModel = yield* configStore.readConfig().pipe(Effect.map((c) => c.embedder.model), Effect.catchAll(() => Effect.succeed(status.model)));
 			return {
 				...status,
 				model: configModel
@@ -54,8 +54,8 @@ var IndexProject = class extends Effect.Service()("IndexProject", {
 				".js",
 				".jsx"
 			];
-			const files = yield* scanner.scanFiles(extensions);
-			const allChunks = (yield* Effect.forEach(files, (file) => chunker.chunkFile(file), { concurrency: "unbounded" })).flat();
+			const scanResult = yield* scanner.scanFiles(extensions);
+			const allChunks = (yield* Effect.forEach(scanResult.files, (file) => chunker.chunkFile(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);
@@ -93,11 +93,15 @@ var IndexProject = class extends Effect.Service()("IndexProject", {
 var ConfigError = class extends Data.TaggedError("ConfigError") {};
 const DEFAULT_CONFIG = {
 	schema: "1",
-	model: "Xenova/all-MiniLM-L6-v2",
-	dims: 384,
 	chunkLines: 60,
 	overlapLines: 10,
-	files: {}
+	chunkConcurrency: 8,
+	files: {},
+	embedder: {
+		model: "Xenova/all-MiniLM-L6-v2",
+		device: "auto",
+		dtype: "fp32"
+	}
 };
 //#endregion
 //#region src/application/init-project.ts
@@ -141,9 +145,21 @@ var ResetIndex = class extends Effect.Service()("ResetIndex", {
 }) {};
 //#endregion
 //#region src/lib/error-format.ts
+/**
+* Maps Data.TaggedError _tag values to JSON error codes for structured output. Used by formatError
+* to produce the spec-mandated `{ error: true, code, message }` format.
+*/
 const errorCodes = {
-	ConfigError: "CONFIG_MISSING",
-	PlatformError: "PLATFORM_ERROR"
+	ConfigError: "CONFIG_ERROR",
+	ConfigNotFoundError: "CONFIG_NOT_FOUND",
+	ConfigMalformedError: "CONFIG_MALFORMED",
+	NoIndexError: "NO_INDEX",
+	DiskFullError: "DISK_FULL",
+	StoreError: "STORE_ERROR",
+	ChunkerError: "CHUNK_ERROR",
+	ModelLoadError: "MODEL_LOAD_ERROR",
+	InferenceError: "INFERENCE_ERROR",
+	ScanFailed: "SCAN_FAILED"
 };
 const messageFromError = (error) => {
 	if (typeof error === "string") return error;
@@ -154,32 +170,45 @@ const codeFromError = (error) => {
 	if (error && typeof error === "object" && "_tag" in error) return errorCodes[String(error._tag)] ?? "UNKNOWN";
 	return "UNKNOWN";
 };
+const causeFromError = (error) => {
+	if (typeof error === "string") return error;
+	if (error && typeof error === "object" && "cause" in error) return String(error.cause);
+	return "Unknown cause";
+};
+/** Format an error as spec-mandated JSON: `{ error: true, code: "...", message: "..." }`. */
 const formatError = (error) => JSON.stringify({
 	error: true,
 	code: codeFromError(error),
-	message: messageFromError(error)
+	message: messageFromError(error),
+	cause: causeFromError(error)
 });
+/** Log the error as JSON to stdout, then re-fail to preserve non-zero exit code. */
+const reportError = (error) => Console.log(formatError(error)).pipe(Effect.flatMap(() => Effect.fail(error)));
 //#endregion
 //#region src/commands/index-cmd.ts
+const logFlagWarnings = (force, verbose, json) => {
+	if (json) return Effect.void;
+	const warnings = [force ? "--force is currently not implemented and only a placeholder." : void 0, verbose ? "--verbose is currently not implemented and only a placeholder." : void 0].filter((msg) => msg !== void 0);
+	return Effect.forEach(warnings, (msg) => Effect.logInfo(msg), { discard: true });
+};
+const logHumanOutput = (chunks, files, duration) => Effect.logInfo(`Indexed ${chunks} chunks from ${files} files in ${duration}.`);
 /** CLI command: pix index [--force] [--verbose] [--json] */
 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, json }) => Effect.gen(function* () {
-	if (force && !json) yield* Effect.logInfo("--force is currently not implemented and only a placeholder.");
-	if (verbose && !json) yield* Effect.logInfo("--verbose is currently not implemented and only a placeholder.");
+	yield* logFlagWarnings(force, verbose, json);
 	const startTime = Date.now();
-	const result = yield* IndexProject.index().pipe(Effect.either);
-	if (result._tag === "Left") return yield* Effect.fail(result.left);
+	const result = yield* IndexProject.index();
 	const duration = `${((Date.now() - startTime) / 1e3).toFixed(1)}s`;
 	if (json) return yield* Console.log(JSON.stringify({
-		chunks: result.right.status.chunks,
-		files: result.right.status.files,
+		chunks: result.status.chunks,
+		files: result.status.files,
 		duration
 	}));
-	yield* Effect.logInfo(`Indexed ${result.right.status.chunks} chunks from ${result.right.status.files} files in ${duration}.`);
-}).pipe(Effect.tapError((error) => Console.log(formatError(error)))));
+	yield* logHumanOutput(result.status.chunks, result.status.files, duration);
+}).pipe(Effect.catchAll(reportError)));
 //#endregion
 //#region src/commands/init.ts
 /** CLI command: pix init [--json] */
@@ -188,7 +217,10 @@ const initCommand = Command.make("init", { json: Options.boolean("json").pipe(Op
 	if (json) return yield* Console.log(JSON.stringify(result, null, 2));
 	yield* Effect.logInfo("Created .pix/config.json with default settings.");
 	yield* Effect.logInfo("Reminder: Add `.pix` to your `.gitignore` file to avoid committing the index.");
-}).pipe(Effect.tapError((error) => Console.log(formatError(error)))));
+}).pipe(Effect.catchTags({
+	ConfigError: reportError,
+	DiskFullError: reportError
+})));
 //#endregion
 //#region src/commands/query.ts
 const DEFAULT_TOP_K = 5;
@@ -216,6 +248,25 @@ 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) => ({
+	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 }
+}));
+const renderResults = (results) => Effect.gen(function* () {
+	if (results.length === 0) {
+		yield* Effect.logInfo("No results found");
+		return;
+	}
+	for (const result of results) {
+		yield* Console.log(formatResult(result));
+		yield* Console.log("---");
+	}
+});
 /** CLI command: pix query "<text>" [--top N] [--json] [--context-lines N] */
 const queryCommand = Command.make("query", {
 	queryText: Args.text({ name: "query" }),
@@ -226,29 +277,17 @@ const queryCommand = Command.make("query", {
 	const topK = Option.getOrElse(top, () => DEFAULT_TOP_K);
 	const ctxLines = Option.getOrElse(contextLines, () => DEFAULT_CONTEXT_LINES);
 	const clamped = clampTopK(topK);
-	if (clamped.clamped) yield* Effect.logDebug(`topK clamped from ${topK} to ${clamped.value}`);
+	if (clamped.clamped && !json) yield* Effect.logDebug(`topK clamped from ${topK} to ${clamped.value}`);
 	const results = yield* QueryProject.queryProject(queryText, clamped.value);
-	if (json) {
-		const output = 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 }
-		}));
-		return yield* Console.log(JSON.stringify(output, null, 2));
-	}
-	if (results.length === 0) {
-		yield* Effect.logInfo("No results found");
-		return;
-	}
-	for (const result of results) {
-		yield* Console.log(formatResult(result));
-		yield* Console.log("---");
-	}
-}).pipe(Effect.tapError((error) => Console.log(formatError(error)))));
+	if (json) return yield* Console.log(JSON.stringify(toJsonOutput(results, ctxLines), null, 2));
+	yield* renderResults(results);
+}).pipe(Effect.catchTags({
+	ModelLoadError: reportError,
+	InferenceError: reportError,
+	DiskFullError: reportError,
+	StoreError: reportError,
+	NoIndexError: reportError
+})));
 //#endregion
 //#region src/lib/format.ts
 /** Format byte count as human-readable string (e.g. "1.5 MB") */
@@ -265,29 +304,34 @@ const formatBytes = (bytes) => {
 };
 //#endregion
 //#region src/commands/reset.ts
-/** CLI command: pix reset [--json] */
-const resetCommand = Command.make("reset", { json: Options.boolean("json").pipe(Options.withDefault(false)) }, ({ json }) => Effect.gen(function* () {
-	const start = yield* Clock.currentTimeMillis;
-	const result = yield* ResetIndex.reset();
-	const elapsedMs = (yield* Clock.currentTimeMillis) - start;
-	if (json) return yield* Console.log(JSON.stringify({
-		status: "ok",
-		deletedChunks: result.deletedChunks,
-		deletedVectors: result.deletedVectors,
-		freedBytes: result.freedBytes,
-		elapsedMs
-	}));
-	if (!result.deletedChunks && !result.deletedVectors) {
+const logJsonResult = (result, elapsedMs) => Console.log(JSON.stringify({
+	status: "ok",
+	deletedChunks: result.deletedChunks,
+	deletedVectors: result.deletedVectors,
+	freedBytes: result.freedBytes,
+	elapsedMs
+}));
+const logHumanResult = (result, elapsedMs) => Effect.gen(function* () {
+	const deletedParts = [result.deletedChunks ? "chunks.jsonl" : null, result.deletedVectors ? "vectors.bin" : null].filter((part) => part !== null);
+	if (deletedParts.length === 0) {
 		yield* Effect.logInfo("Nothing to reset.");
 		return;
 	}
-	const parts = [];
-	if (result.deletedChunks) parts.push("chunks.jsonl");
-	if (result.deletedVectors) parts.push("vectors.bin");
-	yield* Effect.logInfo(`Deleted: ${parts.join(", ")}`);
+	yield* Effect.logInfo(`Deleted: ${deletedParts.join(", ")}`);
 	yield* Effect.logInfo(`Freed: ${formatBytes(result.freedBytes)}`);
 	yield* Effect.logInfo(`Time: ${elapsedMs}ms`);
-}).pipe(Effect.tapError((error) => Console.log(formatError(error)))));
+});
+/** CLI command: pix reset [--json] */
+const resetCommand = Command.make("reset", { json: Options.boolean("json").pipe(Options.withDefault(false)) }, ({ json }) => Effect.gen(function* () {
+	const start = yield* Clock.currentTimeMillis;
+	const result = yield* ResetIndex.reset();
+	const elapsedMs = (yield* Clock.currentTimeMillis) - start;
+	if (json) return yield* logJsonResult(result, elapsedMs);
+	yield* logHumanResult(result, elapsedMs);
+}).pipe(Effect.catchTags({
+	DiskFullError: reportError,
+	StoreError: reportError
+})));
 //#endregion
 //#region src/commands/status.ts
 /** CLI command: pix status [--json] */
@@ -300,7 +344,7 @@ const statusCommand = Command.make("status", { json: Options.boolean("json").pip
 	yield* Effect.logInfo(`Total lines: ${result.totalLines.toLocaleString()}`);
 	yield* Effect.logInfo(`Index size: ${formatBytes(result.byteSize)}`);
 	yield* Effect.logInfo(`Last indexed: ${lastIndexStr}`);
-}).pipe(Effect.tapError((error) => Console.log(formatError(error)))));
+}).pipe(Effect.catchTags({ StoreError: reportError })));
 //#endregion
 //#region src/cli.ts
 const VERSION = createRequire(import.meta.url)("../package.json").version;
@@ -319,36 +363,67 @@ const cli = (args) => Command.run(pix, {
 	version: VERSION
 })(args).pipe(Effect.provide(CliConfig.layer({ showTypes: false })));
 //#endregion
+//#region src/domain/errors.ts
+/** Config file or directory does not exist. Run pix init first. */
+var ConfigNotFoundError = class extends Data.TaggedError("ConfigNotFoundError") {};
+/** Config file exists but contains invalid JSON. */
+var ConfigMalformedError = class extends Data.TaggedError("ConfigMalformedError") {};
+/** Index files (chunks.jsonl, vectors.bin) do not exist. Run pix index first. */
+var NoIndexError = class extends Data.TaggedError("NoIndexError") {};
+/** Disk is full — write operation could not complete. */
+var DiskFullError = class extends Data.TaggedError("DiskFullError") {};
+/** Generic index store I/O failure (read, write, delete). */
+var StoreError = class extends Data.TaggedError("StoreError") {};
+/** Source file could not be read during chunking (binary, permissions, encoding). */
+var ChunkerError = class extends Data.TaggedError("ChunkerError") {};
+/** Embedding model could not be downloaded or loaded. */
+var ModelLoadError = class extends Data.TaggedError("ModelLoadError") {};
+/** Embedding model failed during inference. */
+var InferenceError = class extends Data.TaggedError("InferenceError") {};
+/**
+* Fatal scan failure — gitignore loading failed entirely. Non-fatal per-entry skips are reported
+* via ScanResult.skipped.
+*/
+var ScanFailed = class extends Data.TaggedError("ScanFailed") {};
+//#endregion
 //#region src/services/chunker.ts
 const MIN_CHUNK_CHARS = 20;
+const readFileContent = (fs, file) => fs.readFileString(file).pipe(Effect.mapError((cause) => new ChunkerError({
+	message: "Could not read source file for chunking",
+	file,
+	cause
+})));
+const buildChunks = (file, content, config) => {
+	const lines = content.split("\n");
+	const chunks = [];
+	let idx = 0;
+	let startLine = 1;
+	while (startLine <= lines.length) {
+		const endLine = Math.min(startLine + config.chunkLines - 1, lines.length);
+		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);
+			chunks.push({
+				id,
+				idx,
+				file,
+				startLine,
+				endLine,
+				text
+			});
+			idx++;
+		}
+		startLine += config.chunkLines - config.overlapLines;
+	}
+	return chunks;
+};
 const make$4 = Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
 	const config = yield* (yield* ConfigStore).readConfig().pipe(Effect.catchAll(() => Effect.succeed(DEFAULT_CONFIG)));
 	const chunkFile = (file) => Effect.gen(function* () {
-		const content = yield* fs.readFileString(file).pipe(Effect.tapError((err) => Effect.logWarning(`[Chunker] Skipping unreadable file: ${file} — ${String(err)}`)), Effect.catchAll(() => Effect.succeed("")));
+		const content = yield* readFileContent(fs, file);
 		if (content === "") return [];
-		const lines = content.split("\n");
-		const chunks = [];
-		let idx = 0;
-		let startLine = 1;
-		while (startLine <= lines.length) {
-			const endLine = Math.min(startLine + config.chunkLines - 1, lines.length);
-			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);
-				chunks.push({
-					id,
-					idx,
-					file,
-					startLine,
-					endLine,
-					text
-				});
-				idx++;
-			}
-			startLine += config.chunkLines - config.overlapLines;
-		}
-		return chunks;
+		return buildChunks(file, content, config);
 	});
 	return { chunkFile };
 });
@@ -357,23 +432,46 @@ const ChunkerLive = Layer.effect(Chunker, make$4);
 //#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({
+		message: `Disk full: could not ${action}`,
+		path,
+		cause
+	});
+	return new ConfigError({
+		message: `Failed to ${action}`,
+		cause
+	});
+};
 const make$3 = Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
 	const writeConfig = (config) => Effect.gen(function* () {
 		const configJson = JSON.stringify(config, null, 2);
-		yield* fs.makeDirectory(CONFIG_DIR, { recursive: true });
-		yield* fs.writeFileString(CONFIG_PATH, configJson);
-	}).pipe(Effect.mapError((cause) => new ConfigError({
-		message: "Failed to write config.json",
-		cause
-	})));
+		yield* fs.makeDirectory(CONFIG_DIR, { recursive: true }).pipe(Effect.mapError((cause) => mapConfigWriteError(cause, CONFIG_DIR, "create .pix directory")));
+		yield* fs.writeFileString(CONFIG_PATH, configJson).pipe(Effect.mapError((cause) => mapConfigWriteError(cause, CONFIG_PATH, "write config.json")));
+	});
 	const readConfig = () => Effect.gen(function* () {
-		const content = yield* fs.readFileString(CONFIG_PATH);
-		return JSON.parse(content);
-	}).pipe(Effect.mapError((cause) => new ConfigError({
-		message: "Failed to read config.json",
-		cause
-	})));
+		const content = yield* fs.readFileString(CONFIG_PATH).pipe(Effect.mapError((cause) => {
+			if (isPlatformReason$1(cause, "NotFound")) return new ConfigNotFoundError({
+				message: "Config file not found. Run pix init first.",
+				path: CONFIG_PATH,
+				cause
+			});
+			return new ConfigError({
+				message: "Failed to read config.json",
+				cause
+			});
+		}));
+		return yield* Effect.try({
+			try: () => JSON.parse(content),
+			catch: (error) => new ConfigMalformedError({
+				message: "Invalid JSON in config.json",
+				path: CONFIG_PATH,
+				cause: error
+			})
+		});
+	});
 	const configExists = () => Effect.gen(function* () {
 		return yield* fs.exists(CONFIG_PATH);
 	}).pipe(Effect.catchAll(() => Effect.succeed(false)));
@@ -385,9 +483,34 @@ const make$3 = Effect.gen(function* () {
 });
 const ConfigStoreLive = Layer.effect(ConfigStore, make$3);
 //#endregion
+//#region src/domain/models.ts
+/** Registry of supported embedding models. */
+const MODEL_REGISTRY = {
+	"Xenova/all-MiniLM-L6-v2": {
+		id: "Xenova/all-MiniLM-L6-v2",
+		dims: 384,
+		dtypes: [
+			"fp32",
+			"fp16",
+			"q8",
+			"q4"
+		],
+		description: "General-purpose sentence embeddings, 23MB q8"
+	},
+	"Xenova/bge-small-en-v1.5": {
+		id: "Xenova/bge-small-en-v1.5",
+		dims: 384,
+		dtypes: [
+			"fp32",
+			"fp16",
+			"q8",
+			"q4"
+		],
+		description: "BGE retrieval-optimized embeddings, 34MB q8"
+	}
+};
+//#endregion
 //#region src/services/embedder.ts
-const MODEL_NAME = "Xenova/all-MiniLM-L6-v2";
-const DIMS = 384;
 const CACHE_DIR = ".pix/cache";
 const BATCH_SIZE = 16;
 env.cacheDir = CACHE_DIR;
@@ -400,28 +523,65 @@ const normalize = (arr) => {
 	for (let i = 0; i < arr.length; i++) result[i] = arr[i] / norm;
 	return result;
 };
+const resolveEmbedderConfig = (configStore) => Effect.gen(function* () {
+	const config = yield* configStore.readConfig().pipe(Effect.catchAll(() => Effect.succeed(void 0)));
+	const model = config?.embedder.model ?? "Xenova/all-MiniLM-L6-v2";
+	const device = config?.embedder.device ?? "auto";
+	const dtype = config?.embedder.dtype ?? "fp32";
+	const modelInfo = MODEL_REGISTRY[model];
+	if (!modelInfo) return yield* new ModelLoadError({
+		message: `Unknown embedding model "${model}". Available: ${Object.keys(MODEL_REGISTRY).join(", ")}`,
+		model
+	});
+	if (!modelInfo.dtypes.includes(dtype)) return yield* new ModelLoadError({
+		message: `Unsupported dtype "${dtype}" for model "${model}". Supported: ${modelInfo.dtypes.join(", ")}`,
+		model
+	});
+	return {
+		model,
+		device,
+		dtype,
+		dims: modelInfo.dims
+	};
+});
+const createExtractor = (opts) => Effect.tryPromise(async () => {
+	const { pipeline } = await import("@huggingface/transformers");
+	return pipeline("feature-extraction", opts.model, {
+		device: opts.device,
+		dtype: opts.dtype
+	});
+}).pipe(Effect.mapError((cause) => new ModelLoadError({
+	message: `Failed to load embedding model with device "${opts.device}"`,
+	model: opts.model,
+	cause
+})));
+const createExtractorWithFallback = (opts) => {
+	if (opts.device === "cpu") return createExtractor(opts);
+	return createExtractor(opts).pipe(Effect.catchAll((originalError) => Effect.gen(function* () {
+		yield* Effect.logWarning(`Embedding device "${opts.device}" failed, falling back to "cpu": ${originalError.message}`);
+		return yield* createExtractor({
+			...opts,
+			device: "cpu"
+		}).pipe(Effect.catchAll(() => Effect.fail(originalError)));
+	})));
+};
 const make$2 = Effect.gen(function* () {
-	const getExtractor = yield* Effect.cached(Effect.tryPromise(async () => {
-		const { pipeline } = await import("@huggingface/transformers");
-		return pipeline("feature-extraction", MODEL_NAME, {
-			device: "cpu",
-			dtype: "q8"
-		});
-	}));
+	const cfg = yield* resolveEmbedderConfig(yield* ConfigStore);
+	const getExtractor = yield* Effect.cached(createExtractorWithFallback(cfg));
 	const embed = (text) => Effect.gen(function* () {
 		const extractor = yield* getExtractor;
 		const data = (yield* Effect.tryPromise(() => extractor(text, {
 			pooling: "mean",
 			normalize: false
-		}))).data;
+		})).pipe(Effect.mapError((cause) => new InferenceError({
+			message: "Embedding inference failed",
+			cause
+		})))).data;
 		return {
 			vector: normalize(data),
-			dims: DIMS
+			dims: cfg.dims
 		};
-	}).pipe(Effect.catchAll(() => Effect.succeed({
-		vector: new Float32Array(DIMS),
-		dims: DIMS
-	})));
+	});
 	const batch = (texts) => Effect.gen(function* () {
 		const extractor = yield* getExtractor;
 		const results = [];
@@ -430,25 +590,28 @@ const make$2 = Effect.gen(function* () {
 			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 * DIMS;
-				results.push(normalize(data.slice(offset, offset + DIMS)));
+				const offset = j * cfg.dims;
+				results.push(normalize(data.slice(offset, offset + cfg.dims)));
 			}
 		}
 		return results.map((vector) => ({
 			vector,
-			dims: DIMS
+			dims: cfg.dims
 		}));
-	}).pipe(Effect.catchAll(() => Effect.succeed([])));
+	});
 	return {
 		embed,
 		batch
 	};
 });
-const OnnxEmbedderLive = Layer.effect(Embedder, make$2);
+const OnnxEmbedderLive = Layer.provideMerge(Layer.effect(Embedder, make$2), ConfigStoreLive);
 //#endregion
 //#region src/services/scanner.ts
 const ALWAYS_IGNORE = new Set([
@@ -461,43 +624,96 @@ const ALWAYS_IGNORE = new Set([
 ]);
 const make$1 = Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
+	const readFileWithSkip = (path, mkReason) => fs.readFileString(path).pipe(Effect.map((content) => ({
+		content,
+		skipped: null
+	})), Effect.catchAll((error) => Effect.succeed({
+		content: "",
+		skipped: {
+			path,
+			reason: mkReason(error)
+		}
+	})));
+	const readDirectoryWithSkip = (dir) => fs.readDirectory(dir).pipe(Effect.map((entries) => ({
+		entries,
+		skipped: null
+	})), Effect.catchAll((error) => Effect.succeed({
+		entries: [],
+		skipped: {
+			path: dir,
+			reason: `Could not read directory: ${String(error)}`
+		}
+	})));
+	const statWithSkip = (fullPath) => fs.stat(fullPath).pipe(Effect.map((info) => ({
+		info,
+		skipped: null
+	})), Effect.catchAll((error) => Effect.succeed({
+		info: null,
+		skipped: {
+			path: fullPath,
+			reason: `Could not stat: ${String(error)}`
+		}
+	})));
 	const loadGitignoreRules = Effect.gen(function* () {
 		const ig = ignore();
 		const cwd = process.cwd();
-		const rootContent = yield* fs.readFileString(`${cwd}/.gitignore`).pipe(Effect.catchAll(() => Effect.succeed("")));
-		if (rootContent.trim()) ig.add(rootContent.split("\n"));
+		const skipped = [];
+		const rootContent = yield* readFileWithSkip(`${cwd}/.gitignore`, (error) => `Could not read gitignore: ${String(error)}`);
+		if (rootContent.skipped) skipped.push(rootContent.skipped);
+		if (rootContent.content.trim()) ig.add(rootContent.content.split("\n"));
 		const excludePath = `${cwd}/.git/info/exclude`;
 		if (yield* fs.exists(excludePath)) {
-			const excludeContent = yield* fs.readFileString(excludePath).pipe(Effect.catchAll(() => Effect.succeed("")));
-			if (excludeContent.trim()) ig.add(excludeContent.split("\n"));
+			const excludeContent = yield* readFileWithSkip(excludePath, (error) => `Could not read exclude file: ${String(error)}`);
+			if (excludeContent.skipped) skipped.push(excludeContent.skipped);
+			if (excludeContent.content.trim()) ig.add(excludeContent.content.split("\n"));
 		}
-		return ig;
-	}).pipe(Effect.catchAll(() => Effect.succeed(ignore())));
+		return {
+			ig,
+			skipped
+		};
+	});
 	const walk = (dir, extensions) => Effect.gen(function* () {
-		const entries = yield* fs.readDirectory(dir).pipe(Effect.catchAll(() => Effect.succeed([])));
-		let results = [];
-		for (const entry of entries) {
+		const result = yield* readDirectoryWithSkip(dir);
+		let files = [];
+		const skipped = [];
+		if (result.skipped) skipped.push(result.skipped);
+		for (const entry of result.entries) {
 			if (ALWAYS_IGNORE.has(entry)) continue;
 			const fullPath = `${dir}/${entry}`;
-			const info = yield* fs.stat(fullPath).pipe(Effect.catchAll(() => Effect.succeed(null)));
-			if (!info) continue;
-			if (info.type === "Directory") {
-				const subResults = yield* walk(fullPath, extensions);
-				results.push(...subResults);
-			} else if (info.type === "File") {
+			const info = yield* statWithSkip(fullPath);
+			if (info.skipped) {
+				skipped.push(info.skipped);
+				continue;
+			}
+			if (!info.info) continue;
+			if (info.info.type === "Directory") {
+				const sub = yield* walk(fullPath, extensions);
+				files.push(...sub.files);
+				skipped.push(...sub.skipped);
+			} else if (info.info.type === "File") {
 				const dotIndex = entry.lastIndexOf(".");
 				if (dotIndex === -1) continue;
 				const ext = entry.slice(dotIndex);
-				if (extensions.has(ext)) results.push(fullPath);
+				if (extensions.has(ext)) files.push(fullPath);
 			}
 		}
-		return results;
+		return {
+			files,
+			skipped
+		};
 	});
 	const scanFiles = (extensions) => Effect.gen(function* () {
-		const ig = yield* loadGitignoreRules;
+		const { ig, skipped: ignoreSkipped } = yield* loadGitignoreRules.pipe(Effect.mapError((cause) => new ScanFailed({
+			message: `Failed to load gitignore rules: ${String(cause)}`,
+			cause
+		})));
 		const cwd = process.cwd();
-		const relativePaths = (yield* walk(cwd, new Set(extensions))).map((p) => p.startsWith(cwd) ? p.slice(cwd.length + 1) : p);
-		return ig.filter(relativePaths).map((p) => `${cwd}/${p}`);
+		const { files: paths, skipped: walkSkipped } = yield* walk(cwd, new Set(extensions));
+		const relativePaths = paths.map((p) => p.startsWith(cwd) ? p.slice(cwd.length + 1) : p);
+		return {
+			files: ig.filter(relativePaths).map((p) => `${cwd}/${p}`),
+			skipped: [...ignoreSkipped, ...walkSkipped]
+		};
 	});
 	return { scanFiles };
 });
@@ -507,6 +723,7 @@ const ScannerLive = Layer.effect(Scanner, make$1);
 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;
 /**
 * FileSystem adapter for VectorStore port. Reads from chunks.jsonl and vectors.bin to provide index
 * statistics.
@@ -533,8 +750,50 @@ const make = Effect.gen(function* () {
 		} catch {}
 		return files;
 	};
+	const toStoreError = (operation, path) => (cause) => {
+		if (isPlatformReason(cause, "BadResource")) return new DiskFullError({
+			message: `Disk full during ${operation}`,
+			path,
+			cause
+		});
+		return new StoreError({
+			message: `Failed to ${operation}`,
+			path,
+			cause
+		});
+	};
+	const toReadError = (operation, path) => (cause) => new StoreError({
+		message: `Failed to ${operation}`,
+		path,
+		cause
+	});
+	/** Wrap any fs Effect so failures become StoreError | DiskFullError. */
+	const withStoreError = (op, operation, path) => op.pipe(Effect.mapError(toStoreError(operation, path)));
+	/** Wrap any fs Effect so failures become StoreError (read-only). */
+	const withReadError = (op, operation, path) => op.pipe(Effect.mapError(toReadError(operation, path)));
+	/** Ensure a directory exists, creating it recursively if absent. */
+	const ensureDirExists = (dir, description = dir) => Effect.gen(function* () {
+		if (!(yield* withStoreError(fs.exists(dir), `check ${description}`))) yield* withStoreError(fs.makeDirectory(dir, { recursive: true }), `create ${description}`);
+	});
+	/**
+	* Remove a file if it exists, accumulating freed bytes. Returns the number of freed bytes (0 if
+	* the file was absent).
+	*/
+	const removeIfExists = (file, description) => Effect.gen(function* () {
+		if (!(yield* withStoreError(fs.exists(file), `check ${description}`))) return {
+			freed: 0,
+			deleted: false
+		};
+		const stat = yield* withStoreError(fs.stat(file), `stat ${description}`, file);
+		const freed = stat && "size" in stat ? Number(stat.size) : 0;
+		yield* withStoreError(fs.remove(file), `delete ${description}`, file);
+		return {
+			freed,
+			deleted: true
+		};
+	});
 	const store = (chunks, embeddings) => Effect.gen(function* () {
-		if (!(yield* fs.exists(STORE_DIR))) yield* fs.makeDirectory(STORE_DIR, { recursive: true });
+		yield* ensureDirExists(STORE_DIR, ".pix directory");
 		const chunksTemp = `${CHUNKS_FILE}.tmp`;
 		const chunksLines = chunks.map((c) => JSON.stringify({
 			id: c.id,
@@ -544,23 +803,23 @@ const make = Effect.gen(function* () {
 			endLine: c.endLine,
 			text: c.text
 		}));
-		yield* fs.writeFileString(chunksTemp, chunksLines.join("\n"));
-		yield* fs.rename(chunksTemp, CHUNKS_FILE);
+		yield* withStoreError(fs.writeFileString(chunksTemp, chunksLines.join("\n")), "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);
-		yield* fs.writeFile(vectorsTemp, buffer);
-		yield* fs.rename(vectorsTemp, VECTORS_FILE);
+		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 chunksExists = yield* fs.exists(CHUNKS_FILE);
-		const vectorsExists = yield* fs.exists(VECTORS_FILE);
-		if (!chunksExists || !vectorsExists) return [];
-		const chunkLines = (yield* fs.readFileString(CHUNKS_FILE)).split("\n").filter((l) => l.trim().length > 0);
-		const vectorsBuffer = yield* fs.readFile(VECTORS_FILE);
+		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 results = [];
 		for (let i = 0; i < chunkLines.length; i++) try {
@@ -583,8 +842,8 @@ const make = Effect.gen(function* () {
 		return results.slice(0, topK);
 	});
 	const getStatus = () => Effect.gen(function* () {
-		const chunksExists = yield* fs.exists(CHUNKS_FILE);
-		const vectorsExists = yield* fs.exists(VECTORS_FILE);
+		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 {
 			chunks: 0,
 			files: 0,
@@ -593,13 +852,13 @@ const make = Effect.gen(function* () {
 			totalLines: 0,
 			byteSize: 0
 		};
-		const lines = (yield* fs.readFileString(CHUNKS_FILE).pipe(Effect.catchAll(() => Effect.succeed("")))).split("\n").filter((l) => l.trim().length > 0);
+		const lines = (yield* withReadError(fs.readFileString(CHUNKS_FILE), "read chunks", CHUNKS_FILE)).split("\n").filter((l) => l.trim().length > 0);
 		const chunks = lines.length;
 		const files = countUniqueFiles(lines).size;
 		const model = "";
 		const totalLines = countTotalLines(lines);
-		const vectorsStat = yield* fs.stat(VECTORS_FILE).pipe(Effect.catchAll(() => Effect.succeed(null)));
-		const byteSize = vectorsStat && "size" in vectorsStat ? Number(vectorsStat.size) : 0;
+		const vectorsStat = yield* withReadError(fs.stat(VECTORS_FILE), "stat vectors", VECTORS_FILE);
+		const byteSize = "size" in vectorsStat ? Number(vectorsStat.size) : 0;
 		return {
 			chunks,
 			files,
@@ -610,25 +869,12 @@ const make = Effect.gen(function* () {
 		};
 	});
 	const reset = () => Effect.gen(function* () {
-		let deletedChunks = false;
-		let deletedVectors = false;
-		let freedBytes = 0;
-		if (yield* fs.exists(CHUNKS_FILE)) {
-			const stat = yield* fs.stat(CHUNKS_FILE);
-			freedBytes += stat && "size" in stat ? Number(stat.size) : 0;
-			yield* fs.remove(CHUNKS_FILE);
-			deletedChunks = true;
-		}
-		if (yield* fs.exists(VECTORS_FILE)) {
-			const stat = yield* fs.stat(VECTORS_FILE);
-			freedBytes += stat && "size" in stat ? Number(stat.size) : 0;
-			yield* fs.remove(VECTORS_FILE);
-			deletedVectors = true;
-		}
+		const chunks = yield* removeIfExists(CHUNKS_FILE, "chunks");
+		const vectors = yield* removeIfExists(VECTORS_FILE, "vectors");
 		return {
-			deletedChunks,
-			deletedVectors,
-			freedBytes
+			deletedChunks: chunks.deleted,
+			deletedVectors: vectors.deleted,
+			freedBytes: chunks.freed + vectors.freed
 		};
 	});
 	return {

package/package.json

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