@lucas-bur/pix 0.2.0

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Lucas Burmeister
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,46 @@
+# @lucas-bur/pix
+
+[![CI](https://github.com/lucas-bur/pix/actions/workflows/ci.yml/badge.svg)](https://github.com/lucas-bur/pix/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/lucas-bur/pix/branch/main/graph/badge.svg)](https://codecov.io/gh/lucas-bur/pix)
+[![npm version](https://img.shields.io/npm/v/@lucas-bur/pix)](https://www.npmjs.com/package/@lucas-bur/pix)
+[![npm downloads](https://img.shields.io/npm/dm/@lucas-bur/pix)](https://www.npmjs.com/package/@lucas-bur/pix)
+[![Code Quality](https://img.shields.io/badge/code%20quality-fallow-blue)](https://github.com/fallow-rs/fallow)
+
+Lightweight local semantic project indexer (short pix)
+
+Zero external services, 100% local + offline. Installs as a devDependency and provides agent-ready structured JSON output.
+
+## Status
+
+MVP in development. See [CONTEXT.md](./CONTEXT.md) for architecture decisions and [.scratch/pix-mvp/PRD.md](./.scratch/pix-mvp/PRD.md) for the product requirements.
+
+## Quick Start
+
+```bash
+npm install --save-dev @lucas-bur/pix
+pix init
+pix index
+pix query "authentication middleware"
+```
+
+## Quality Gates
+
+This project uses [fallow](https://github.com/fallow-rs/fallow) for static analysis (dead code, duplication, complexity).
+
+### Commands
+
+- `vp run lint:fallow` — Run fallow with JSON output (used in CI)
+- `fallow audit --summary` — Check only changed files (used in pre-commit hook)
+
+### Pre-commit Hook
+
+The pre-commit hook is managed by vite-plus and runs:
+
+1. `vp staged` — Formats, lints, and type-checks staged files
+2. `fallow audit --summary` — Audits changed files for quality issues
+
+To set up hooks after cloning: `vp config`
+
+## License
+
+[MIT](./LICENSE)

package/dist/index.mjs

@@ -0,0 +1,565 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { NodeContext, NodeRuntime } from "@effect/platform-node";
+import { Context, Data, Effect, Layer, Option } from "effect";
+import { Args, Command, Options } from "@effect/cli";
+import crypto from "node:crypto";
+import { FileSystem } from "@effect/platform";
+import { env } from "@huggingface/transformers";
+import fg from "fast-glob";
+import ignore from "ignore";
+//#region src/domain/ports.ts
+var ConfigStore = class extends Context.Tag("ConfigStore")() {};
+var Scanner = class extends Context.Tag("Scanner")() {};
+var Chunker = class extends Context.Tag("Chunker")() {};
+var Embedder = class extends Context.Tag("Embedder")() {};
+var VectorStore = class extends Context.Tag("VectorStore")() {};
+//#endregion
+//#region src/application/get-status.ts
+/** Use case: get index statistics. Depends on VectorStore via Effect tag. */
+var GetStatus = class extends Effect.Service()("GetStatus", {
+	accessors: true,
+	effect: Effect.gen(function* () {
+		const store = yield* VectorStore;
+		const getStatus = () => store.getStats();
+		return { getStatus };
+	})
+}) {};
+//#endregion
+//#region src/application/index-project.ts
+/**
+* Use case: index project files. Pipeline: scan → chunk → embed → store. Depends on ConfigStore,
+* Scanner, Chunker, Embedder, VectorStore via Effect tags.
+*/
+var IndexProject = class extends Effect.Service()("IndexProject", {
+	accessors: true,
+	effect: Effect.gen(function* () {
+		const configStore = yield* ConfigStore;
+		const scanner = yield* Scanner;
+		const chunker = yield* Chunker;
+		const embedder = yield* Embedder;
+		const vectorStore = yield* VectorStore;
+		const index = () => Effect.gen(function* () {
+			const config = yield* configStore.readConfig();
+			const extensions = Object.keys(config.files).length > 0 ? Object.keys(config.files) : [
+				".ts",
+				".tsx",
+				".js",
+				".jsx"
+			];
+			const files = yield* scanner.scanFiles(extensions);
+			const allChunks = (yield* Effect.forEach(files, (file) => chunker.chunkFile(file), { concurrency: "unbounded" })).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) {
+				yield* Effect.logInfo("No chunks to index.");
+				return {
+					success: true,
+					stats: {
+						chunks: 0,
+						files: 0,
+						totalLines: 0,
+						byteSize: 0
+					}
+				};
+			}
+			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 byteSize = embeddings.length * dims * 4;
+			yield* Effect.logInfo(`Indexed ${totalChunks} chunks from ${totalFiles} files.`);
+			return {
+				success: true,
+				stats: {
+					chunks: totalChunks,
+					files: totalFiles,
+					totalLines,
+					byteSize
+				}
+			};
+		});
+		return { index };
+	})
+}) {};
+//#endregion
+//#region src/domain/config.ts
+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: {}
+};
+//#endregion
+//#region src/application/init-project.ts
+/**
+* Use case: initialize a pix project by writing default config. Depends on ConfigStore via Effect
+* tag.
+*/
+var InitProject = class extends Effect.Service()("InitProject", {
+	accessors: true,
+	effect: Effect.gen(function* () {
+		const store = yield* ConfigStore;
+		const init = () => store.writeConfig(DEFAULT_CONFIG).pipe(Effect.as({
+			success: true,
+			config: DEFAULT_CONFIG
+		}));
+		return { init };
+	})
+}) {};
+//#endregion
+//#region src/application/query-project.ts
+/** Use case: semantic search over indexed code. Depends on Embedder + VectorStore via Effect tags. */
+var QueryProject = class extends Effect.Service()("QueryProject", {
+	accessors: true,
+	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)));
+		return { queryProject };
+	})
+}) {};
+//#endregion
+//#region src/commands/index-cmd.ts
+/** 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) yield* Effect.logInfo(`--force is currently not implemented and only a placeholder.`);
+	if (verbose) yield* Effect.logInfo(`--verbose is currently not implemented and only a placeholder.`);
+	const startTime = Date.now();
+	const result = yield* IndexProject.index().pipe(Effect.either);
+	if (result._tag === "Left") {
+		const error = result.left;
+		const message = error.message ?? String(error);
+		yield* Effect.sync(() => {
+			console.log(JSON.stringify({ error: message }));
+		});
+		return yield* Effect.fail(error);
+	}
+	const duration = `${((Date.now() - startTime) / 1e3).toFixed(1)}s`;
+	if (json) return yield* Effect.sync(() => {
+		console.log(JSON.stringify({
+			chunks: result.right.stats.chunks,
+			files: result.right.stats.files,
+			duration
+		}));
+	});
+	yield* Effect.logInfo(`Indexed ${result.right.stats.chunks} chunks from ${result.right.stats.files} files in ${duration}.`);
+}));
+//#endregion
+//#region src/commands/init.ts
+/** CLI command: pix init [--json] */
+const initCommand = Command.make("init", { json: Options.boolean("json").pipe(Options.withDefault(false)) }, ({ json }) => Effect.gen(function* () {
+	const result = yield* InitProject.init();
+	if (json) return yield* Effect.sync(() => {
+		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.");
+}));
+//#endregion
+//#region src/commands/query.ts
+const DEFAULT_TOP_K = 5;
+const DEFAULT_CONTEXT_LINES = 0;
+const MIN_TOP_K = 1;
+const MAX_TOP_K = 100;
+/** Clamp topK to [MIN_TOP_K, MAX_TOP_K]. Returns the clamped value and whether clamping was applied. */
+const clampTopK = (value) => {
+	if (value < MIN_TOP_K) return {
+		value: MIN_TOP_K,
+		clamped: true
+	};
+	if (value > MAX_TOP_K) return {
+		value: MAX_TOP_K,
+		clamped: true
+	};
+	return {
+		value,
+		clamped: false
+	};
+};
+/** Format a single result for human-readable output */
+const formatResult = (result) => {
+	const contextBefore = result.contextBefore ? `\n${result.contextBefore}` : "";
+	const contextAfter = result.contextAfter ? `\n${result.contextAfter}` : "";
+	return `${result.file}:${result.startLine}-${result.endLine} (score: ${result.score.toFixed(3)})${contextBefore}\n${result.text}${contextAfter}`;
+};
+/** CLI command: pix query "<text>" [--top N] [--json] [--context-lines N] */
+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, json, contextLines }) => Effect.gen(function* () {
+	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}`);
+	const results = yield* QueryProject.queryProject(queryText, clamped.value);
+	if (json) return yield* Effect.sync(() => {
+		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 }
+		}));
+		console.log(JSON.stringify(output, null, 2));
+	});
+	if (results.length === 0) {
+		yield* Effect.logInfo("No results found");
+		return;
+	}
+	for (const result of results) yield* Effect.sync(() => {
+		console.log(formatResult(result));
+		console.log("---");
+	});
+}));
+//#endregion
+//#region src/commands/status.ts
+/** CLI command: pix status [--json] */
+const statusCommand = Command.make("status", { json: Options.boolean("json").pipe(Options.withDefault(false)) }, ({ json }) => Effect.gen(function* () {
+	const result = yield* GetStatus.getStatus();
+	if (json) return yield* Effect.sync(() => {
+		console.log(JSON.stringify(result, null, 2));
+	});
+	const lastIndexStr = result.lastIndex > 0 ? new Date(result.lastIndex).toISOString() : "never";
+	yield* Effect.logInfo(`Indexed: ${result.chunks} chunks across ${result.files} files`);
+	yield* Effect.logInfo(`Model: ${result.model || "none"}`);
+	yield* Effect.logInfo(`Total lines: ${result.totalLines.toLocaleString()}`);
+	yield* Effect.logInfo(`Index size: ${formatBytes(result.byteSize)}`);
+	yield* Effect.logInfo(`Last indexed: ${lastIndexStr}`);
+}));
+/** 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.floor(Math.log(bytes) / Math.log(1024));
+	return `${(bytes / Math.pow(1024, i)).toFixed(1)} ${units[i]}`;
+};
+//#endregion
+//#region src/cli.ts
+const VERSION = createRequire(import.meta.url)("../package.json").version;
+const pix = Command.make("pix", {}, () => Effect.gen(function* () {
+	yield* Effect.logInfo("pix - Lightweight local semantic project indexer");
+	yield* Effect.logInfo("Use `pix --help` to see available commands.");
+})).pipe(Command.withSubcommands([
+	initCommand,
+	statusCommand,
+	indexCommand,
+	queryCommand
+]));
+const cli = Command.run(pix, {
+	name: "pix",
+	version: VERSION
+});
+//#endregion
+//#region src/services/chunker.ts
+const MIN_CHUNK_CHARS = 20;
+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("")));
+		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 { chunkFile };
+});
+const ChunkerLive = Layer.effect(Chunker, make$4);
+//#endregion
+//#region src/services/config-store.ts
+const CONFIG_DIR = ".pix";
+const CONFIG_PATH = `${CONFIG_DIR}/config.json`;
+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
+	})));
+	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 configExists = () => Effect.gen(function* () {
+		return yield* fs.exists(CONFIG_PATH);
+	}).pipe(Effect.catchAll(() => Effect.succeed(false)));
+	return {
+		writeConfig,
+		readConfig,
+		configExists
+	};
+});
+const ConfigStoreLive = Layer.effect(ConfigStore, make$3);
+//#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;
+const normalize = (arr) => {
+	let norm = 0;
+	for (let i = 0; i < arr.length; i++) norm += arr[i] * arr[i];
+	norm = Math.sqrt(norm);
+	if (norm === 0) return arr;
+	const result = new Float32Array(arr.length);
+	for (let i = 0; i < arr.length; i++) result[i] = arr[i] / norm;
+	return result;
+};
+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 embed = (text) => Effect.gen(function* () {
+		const extractor = yield* getExtractor;
+		const data = (yield* Effect.tryPromise(() => extractor(text, {
+			pooling: "mean",
+			normalize: false
+		}))).data;
+		return {
+			vector: normalize(data),
+			dims: DIMS
+		};
+	}).pipe(Effect.catchAll(() => Effect.succeed({
+		vector: new Float32Array(DIMS),
+		dims: DIMS
+	})));
+	const batch = (texts) => Effect.gen(function* () {
+		const extractor = yield* getExtractor;
+		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
+			}));
+			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)));
+			}
+		}
+		return results.map((vector) => ({
+			vector,
+			dims: DIMS
+		}));
+	}).pipe(Effect.catchAll(() => Effect.succeed([])));
+	return {
+		embed,
+		batch
+	};
+});
+const OnnxEmbedderLive = Layer.effect(Embedder, make$2);
+//#endregion
+//#region src/services/scanner.ts
+const make$1 = Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	/** Loads all gitignore patterns from .gitignore files in the repo. */
+	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 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"));
+		}
+		return ig;
+	}).pipe(Effect.catchAll(() => Effect.succeed(ignore())));
+	const scanFiles = (extensions) => Effect.gen(function* () {
+		const ig = yield* loadGitignoreRules;
+		const cwd = process.cwd();
+		const pattern = extensions.map((ext) => `**/*${ext}`);
+		const relativePaths = (yield* Effect.tryPromise(() => fg(pattern, { dot: false })).pipe(Effect.catchAll(() => Effect.succeed([])))).map((p) => {
+			return p.startsWith(cwd) ? p.slice(cwd.length + 1) : p;
+		});
+		return ig.filter(relativePaths).map((p) => `${cwd}/${p}`);
+	});
+	return { scanFiles };
+});
+const ScannerLive = Layer.effect(Scanner, make$1);
+//#endregion
+//#region src/services/vector-store.ts
+const STORE_DIR = ".pix";
+const CHUNKS_FILE = `${STORE_DIR}/chunks.jsonl`;
+const VECTORS_FILE = `${STORE_DIR}/vectors.bin`;
+/**
+* Reads the first line of chunks.jsonl to get the model name. Returns empty string if the file
+* doesn't exist or is empty.
+*/
+const readModelFromChunks = (lines) => {
+	if (lines.length === 0) return "";
+	try {
+		return JSON.parse(lines[0]).model ?? "";
+	} catch {
+		return "";
+	}
+};
+/**
+* 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;
+	/**
+	* Count total lines across all chunks in chunks.jsonl. Each line is a JSON object; the 'text'
+	* field contains the source code.
+	*/
+	const countTotalLines = (lines) => lines.reduce((sum, line) => {
+		try {
+			return sum + JSON.parse(line).text.split("\n").length;
+		} catch {
+			return sum;
+		}
+	}, 0);
+	/** Count unique files across all chunks in chunks.jsonl. */
+	const countUniqueFiles = (lines) => {
+		const files = /* @__PURE__ */ new Set();
+		for (const line of lines) try {
+			const chunk = JSON.parse(line);
+			files.add(chunk.file);
+		} catch {}
+		return files;
+	};
+	const store = (chunks, embeddings) => Effect.gen(function* () {
+		if (!(yield* fs.exists(STORE_DIR))) yield* fs.makeDirectory(STORE_DIR, { recursive: true });
+		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* fs.writeFileString(chunksTemp, chunksLines.join("\n"));
+		yield* fs.rename(chunksTemp, 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);
+	});
+	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 vectors = new Float32Array(vectorsBuffer.buffer);
+		const results = [];
+		for (let i = 0; i < chunkLines.length; i++) try {
+			const chunk = JSON.parse(chunkLines[i]);
+			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];
+			results.push({
+				score: dotProduct,
+				file: chunk.file,
+				startLine: chunk.startLine,
+				endLine: chunk.endLine,
+				text: chunk.text,
+				contextBefore: chunk.contextBefore,
+				contextAfter: chunk.contextAfter
+			});
+		} catch {}
+		results.sort((a, b) => b.score - a.score);
+		return results.slice(0, topK);
+	});
+	const getStats = () => Effect.gen(function* () {
+		const chunksExists = yield* fs.exists(CHUNKS_FILE);
+		const vectorsExists = yield* fs.exists(VECTORS_FILE);
+		if (!chunksExists || !vectorsExists) return {
+			chunks: 0,
+			files: 0,
+			model: "",
+			lastIndex: 0,
+			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 chunks = lines.length;
+		const files = countUniqueFiles(lines).size;
+		const model = readModelFromChunks(lines);
+		const totalLines = countTotalLines(lines);
+		const vectorsStat = yield* fs.stat(VECTORS_FILE).pipe(Effect.catchAll(() => Effect.succeed(null)));
+		const byteSize = vectorsStat && "size" in vectorsStat ? vectorsStat.size : 0;
+		return {
+			chunks,
+			files,
+			model,
+			lastIndex: Option.map(vectorsStat?.mtime ?? Option.none(), (d) => d instanceof Date ? d.getTime() : 0).pipe(Option.getOrElse(() => 0)),
+			totalLines,
+			byteSize
+		};
+	});
+	return {
+		store,
+		search,
+		getStats
+	};
+});
+const VectorStoreLive = Layer.effect(VectorStore, make);
+//#endregion
+//#region src/index.ts
+const ServicesLayer = Layer.mergeAll(ConfigStoreLive, ScannerLive, OnnxEmbedderLive, VectorStoreLive);
+const ChunkerLayer = ChunkerLive.pipe(Layer.provide(ServicesLayer));
+const InfraLayer = Layer.mergeAll(ServicesLayer, ChunkerLayer).pipe(Layer.provide(NodeContext.layer));
+const UseCaseLayer = Layer.mergeAll(InitProject.Default, GetStatus.Default, QueryProject.Default, IndexProject.Default);
+const AppLayer = Layer.merge(UseCaseLayer.pipe(Layer.provide(InfraLayer)), NodeContext.layer);
+cli(process.argv).pipe(Effect.provide(AppLayer), NodeRuntime.runMain);
+//#endregion
+export {};

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@lucas-bur/pix",
+  "version": "0.2.0",
+  "description": "Lightweight local semantic project indexer",
+  "keywords": [
+    "cli",
+    "embeddings",
+    "local",
+    "rag",
+    "semantic-search"
+  ],
+  "homepage": "https://github.com/lucas-bur/pix",
+  "bugs": {
+    "url": "https://github.com/lucas-bur/pix/issues"
+  },
+  "license": "MIT",
+  "author": "Lucas Burmeister <lucas.burmeister@gmx.de>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lucas-bur/pix.git"
+  },
+  "bin": {
+    "pix": "./dist/index.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "test:coverage": "vp test --coverage",
+    "check": "vp check",
+    "ci": "vp check && vp test --coverage && vp run build && fallow audit",
+    "lint:fallow": "fallow --format json",
+    "fallow": "fallow",
+    "prepublishOnly": "vp run build",
+    "pix": ""
+  },
+  "dependencies": {
+    "@effect/cli": "^0.75.1",
+    "@effect/platform": "^0.96.1",
+    "@effect/platform-node": "^0.106.0",
+    "@huggingface/transformers": "^4.2.0",
+    "effect": "^3.21.2",
+    "fast-glob": "^3.3.3",
+    "ignore": "^7.0.5"
+  },
+  "devDependencies": {
+    "@effect/language-service": "^0.85.1",
+    "@types/node": "^25.5.0",
+    "@typescript/native-preview": "7.0.0-dev.20260328.1",
+    "@vitest/coverage-v8": "^4.1.6",
+    "fallow": "^2.65.0",
+    "typescript": "^6.0.2",
+    "vite-plus": "^0.1.14"
+  },
+  "packageManager": "pnpm@10.33.3",
+  "pnpm": {
+    "overrides": {
+      "vite": "npm:@voidzero-dev/vite-plus-core@latest",
+      "vitest": "npm:@voidzero-dev/vite-plus-test@latest"
+    },
+    "onlyBuiltDependencies": [
+      "@parcel/watcher",
+      "fallow",
+      "msgpackr-extract",
+      "onnxruntime-node",
+      "protobufjs",
+      "sharp"
+    ]
+  }
+}