@lucas-bur/pix 0.9.0 → 0.10.0

package/dist/index.mjs

@@ -1,15 +1,18 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
-import { NodeContext, NodeRuntime } from "@effect/platform-node";
-import { Clock, Console, Context, Data, Effect, Layer, Option } from "effect";
 import { Args, CliConfig, Command, Options } from "@effect/cli";
-import crypto from "node:crypto";
+import { NodeContext, NodeRuntime } from "@effect/platform-node";
+import { Clock, Context, Data, Effect, Layer, Option, Ref } from "effect";
+import { styleText } from "node:util";
+import * as clack from "@clack/prompts";
 import { FileSystem } from "@effect/platform";
+import crypto from "node:crypto";
 import { env } from "@huggingface/transformers";
 import ignore from "ignore";
 //#region src/domain/ports.ts
 var ConfigStore = class extends Context.Tag("ConfigStore")() {};
 var Scanner = class extends Context.Tag("Scanner")() {};
+var ContentExtractor = class extends Context.Tag("ContentExtractor")() {};
 var Chunker = class extends Context.Tag("Chunker")() {};
 var Embedder = class extends Context.Tag("Embedder")() {};
 var VectorStore = class extends Context.Tag("VectorStore")() {};
@@ -32,6 +35,104 @@ var GetStatus = class extends Effect.Service()("GetStatus", {
 		return { getStatus };
 	})
 }) {};
+Data.taggedEnum();
+/** Display context tag — commands use `yield* Display` to produce output */
+var Display = class extends Context.Tag("Display")() {};
+/** Maps severity to the corresponding @clack/prompts log function */
+const severityToClack = {
+	info: clack.log.info,
+	success: clack.log.success,
+	warn: clack.log.warning,
+	error: clack.log.error
+};
+/** Styling helpers using node:util styleText (zero-deps, Node 21+) */
+const terminalStyle = {
+	status: (message) => styleText("bold", message),
+	dim: (message) => styleText("dim", message)
+};
+/** Extract the message text from an UpdateInteractivePayload */
+const payloadText = (p) => typeof p === "string" ? p : p.message;
+/**
+* Compute the delta for a progress bar from the payload + current state. Returns 0 if there is no
+* numeric payload or if the active element is a spinner.
+*/
+const computeDelta = (p, state) => {
+	if (typeof p === "string") return 0;
+	if ("advanceBy" in p && p.advanceBy !== void 0) return Math.max(-state.value, p.advanceBy);
+	if ("setTo" in p && p.setTo !== void 0) return Math.max(0, Math.min(state.max, p.setTo)) - state.value;
+	if ("setToPercent" in p && p.setToPercent !== void 0) {
+		const target = Math.floor(state.max * p.setToPercent / 100);
+		return Math.max(-state.value, Math.min(state.max - state.value, target - state.value));
+	}
+	return 0;
+};
+/**
+* Extracts the "guarded interactive" pattern: skip if already active, otherwise
+* acquire-use-release.
+*/
+const withInteractive = (activeRef, acquire, setActive, release, effect) => Ref.get(activeRef).pipe(Effect.flatMap((current) => current !== null ? effect : Effect.acquireUseRelease(acquire.pipe(Effect.tap((h) => Ref.set(activeRef, setActive(h)))), () => effect, (h, exit) => Ref.set(activeRef, null).pipe(Effect.andThen(release(h, exit))))));
+/** Display implementation using @clack/prompts for interactive terminal output */
+const ClackDisplay = { layer: Layer.effect(Display, Effect.gen(function* () {
+	const activeRef = yield* Ref.make(null);
+	return {
+		intro: (title) => Effect.sync(() => clack.intro(styleText("inverse", ` ${title} `))),
+		outro: (message) => Effect.sync(() => clack.outro(message)),
+		log: (message, severity) => Effect.sync(() => severityToClack[severity](terminalStyle.status(message))),
+		note: (content, title) => Effect.sync(() => clack.note(content, title)),
+		text: (message) => Effect.sync(() => clack.log.message(message)),
+		spinner: (message, effect) => withInteractive(activeRef, Effect.sync(() => {
+			const s = clack.spinner();
+			s.start(message);
+			return s;
+		}), (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(() => {
+			const bar = clack.progress({
+				max: opts.max,
+				style: opts.style ?? "heavy",
+				size: opts.size ?? 40,
+				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),
+		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)));
+			const delta = computeDelta(payload, {
+				value: active.value,
+				max: active.max
+			});
+			const newValue = Math.max(0, Math.min(active.max, active.value + delta));
+			return Effect.sync(() => {
+				active.handle.advance(delta, payloadText(payload));
+			}).pipe(Effect.andThen(Ref.update(activeRef, (current) => current && current.type === "progress" ? {
+				...current,
+				value: newValue
+			} : current)));
+		})),
+		json: () => Effect.void
+	};
+})) };
+/** Display implementation for --json mode — no-ops interactive methods, writes JSON to stdout */
+const JsonDisplay = { layer: Layer.succeed(Display, {
+	intro: () => Effect.void,
+	outro: () => Effect.void,
+	log: () => Effect.void,
+	note: () => Effect.void,
+	text: () => Effect.void,
+	spinner: (_message, effect) => effect,
+	progress: (_opts, effect) => effect,
+	updateInteractive: () => Effect.void,
+	json: (data) => Effect.sync(() => process.stdout.write(`${JSON.stringify(data)}\n`))
+}) };
 //#endregion
 //#region src/domain/config.ts
 var ConfigError = class extends Data.TaggedError("ConfigError") {};
@@ -40,7 +141,23 @@ const DEFAULT_CONFIG = {
 	chunkLines: 60,
 	overlapLines: 10,
 	chunkConcurrency: 8,
-	files: {},
+	skipExtensions: [],
+	ignoredPaths: [
+		".pix",
+		"node_modules",
+		".git",
+		"dist",
+		"build",
+		".next",
+		".agents",
+		".claude",
+		".vscode",
+		".github",
+		"coverage",
+		"*-lock.yaml",
+		"*-lock.json",
+		"*.lock"
+	],
 	embedder: {
 		model: "Xenova/all-MiniLM-L6-v2",
 		device: "auto",
@@ -48,10 +165,158 @@ const DEFAULT_CONFIG = {
 	}
 };
 //#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") {};
+/** File type is unsupported for text extraction. */
+var UnsupportedFormat = class extends Data.TaggedError("UnsupportedFormat") {};
+/** Text extraction failed for a supported file type. */
+var ExtractionFailed = class extends Data.TaggedError("ExtractionFailed") {};
+//#endregion
+//#region src/services/processors/identity.ts
+const identityProcessor = (file) => FileSystem.FileSystem.pipe(Effect.flatMap((fs) => fs.readFileString(file)), Effect.mapError((cause) => new ExtractionFailed({
+	message: `Failed to read file for extraction: ${file}`,
+	file,
+	cause
+})));
+//#endregion
+//#region src/services/processors/skip.ts
+const skipProcessor = (extension) => {
+	const error = new UnsupportedFormat({
+		message: `Unsupported file type: ${extension}`,
+		extension
+	});
+	return (_file) => Effect.fail(error);
+};
+//#endregion
+//#region src/services/processors/index.ts
+const DEFAULT_PROCESSOR_MAP = {
+	".ts": identityProcessor,
+	".tsx": identityProcessor,
+	".js": identityProcessor,
+	".jsx": identityProcessor,
+	".py": identityProcessor,
+	".rs": identityProcessor,
+	".go": identityProcessor,
+	".java": identityProcessor,
+	".c": identityProcessor,
+	".cpp": identityProcessor,
+	".h": identityProcessor,
+	".hpp": identityProcessor,
+	".json": identityProcessor,
+	".yaml": identityProcessor,
+	".yml": identityProcessor,
+	".toml": identityProcessor,
+	".xml": identityProcessor,
+	".csv": identityProcessor,
+	".md": identityProcessor,
+	".mdx": identityProcessor,
+	".txt": identityProcessor,
+	".rst": identityProcessor,
+	".html": identityProcessor,
+	".css": identityProcessor,
+	".scss": identityProcessor,
+	".less": identityProcessor,
+	".sql": identityProcessor,
+	".graphql": identityProcessor,
+	".sh": identityProcessor,
+	".bash": identityProcessor,
+	".ps1": identityProcessor,
+	".bat": identityProcessor,
+	".cmake": identityProcessor,
+	".dockerfile": identityProcessor,
+	dockerfile: identityProcessor,
+	makefile: identityProcessor,
+	gemfile: identityProcessor,
+	".pdf": skipProcessor(".pdf"),
+	".png": skipProcessor(".png"),
+	".jpg": skipProcessor(".jpg"),
+	".jpeg": skipProcessor(".jpeg"),
+	".gif": skipProcessor(".gif"),
+	".svg": identityProcessor,
+	".ico": skipProcessor(".ico"),
+	".webp": skipProcessor(".webp"),
+	".mp3": skipProcessor(".mp3"),
+	".mp4": skipProcessor(".mp4"),
+	".wav": skipProcessor(".wav"),
+	".avi": skipProcessor(".avi"),
+	".mov": skipProcessor(".mov"),
+	".mkv": skipProcessor(".mkv"),
+	".exe": skipProcessor(".exe"),
+	".dll": skipProcessor(".dll"),
+	".so": skipProcessor(".so"),
+	".zip": skipProcessor(".zip"),
+	".tar": skipProcessor(".tar"),
+	".gz": skipProcessor(".gz"),
+	".7z": skipProcessor(".7z"),
+	".rar": skipProcessor(".rar"),
+	".ttf": skipProcessor(".ttf"),
+	".woff": skipProcessor(".woff"),
+	".woff2": skipProcessor(".woff2"),
+	".eot": skipProcessor(".eot"),
+	".otf": skipProcessor(".otf"),
+	".lock": identityProcessor,
+	lock: identityProcessor
+};
+/**
+* Builds the processor map by merging domain defaults with user-specified skip extensions. Skip
+* extensions override any existing mapping with a skip processor. Unknown extensions remain absent
+* from the map — callers decide how to handle them.
+*/
+function buildProcessorMap(skipExtensions) {
+	const mapped = { ...DEFAULT_PROCESSOR_MAP };
+	for (const ext of skipExtensions) mapped[ext] = skipProcessor(ext);
+	return mapped;
+}
+//#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 classifyFiles = (files, processorMap) => {
+	const knownFiles = [];
+	const skippedFiles = [];
+	const unknownExtensions = /* @__PURE__ */ new Set();
+	for (const file of files) {
+		const ext = getExtension(file);
+		if (!processorMap[ext]) {
+			unknownExtensions.add(ext);
+			skippedFiles.push(file);
+		} else knownFiles.push(file);
+	}
+	return {
+		knownFiles,
+		skippedFiles,
+		unknownExtensions
+	};
+};
 /**
-* Use case: index project files. Pipeline: scan → chunk → embed → store. Depends on ConfigStore,
-* Scanner, Chunker, Embedder, VectorStore via Effect tags.
+* Use case: index project files. Pipeline: scan → ContentExtractor → chunk → embed → store. Depends
+* on ConfigStore, Scanner, Chunker, Embedder, VectorStore, Display, ContentExtractor via Effect
+* tags.
 */
 var IndexProject = class extends Effect.Service()("IndexProject", {
 	accessors: true,
@@ -61,32 +326,50 @@ var IndexProject = class extends Effect.Service()("IndexProject", {
 		const chunker = yield* Chunker;
 		const embedder = yield* Embedder;
 		const vectorStore = yield* VectorStore;
+		const d = yield* Display;
+		const extractor = yield* ContentExtractor;
 		const index = () => Effect.gen(function* () {
 			if (!(yield* configStore.configExists())) yield* configStore.writeConfig(DEFAULT_CONFIG);
 			const config = yield* configStore.readConfig();
-			const extensions = Object.keys(config.files).length > 0 ? Object.keys(config.files) : [
-				".ts",
-				".tsx",
-				".js",
-				".jsx"
-			];
-			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 processorMap = buildProcessorMap(config.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
+				}
+			};
+			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) {
-				yield* Effect.logInfo("No chunks to index.");
-				return {
-					success: true,
-					status: {
-						chunks: 0,
-						files: 0,
-						totalLines: 0,
-						byteSize: 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);
@@ -183,41 +466,41 @@ const formatError = (error) => JSON.stringify({
 	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)));
+/** Log the error to Display in human + agent format, then re-fail to preserve non-zero exit code. */
+const reportError = (error) => Effect.gen(function* () {
+	const d = yield* Display;
+	yield* d.log(`${codeFromError(error)}: ${messageFromError(error)}`, "error");
+	yield* d.json(JSON.parse(formatError(error)));
+	return yield* 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* () {
-	yield* logFlagWarnings(force, verbose, json);
-	const startTime = Date.now();
-	const result = yield* IndexProject.index();
-	const duration = `${((Date.now() - startTime) / 1e3).toFixed(1)}s`;
-	if (json) return yield* Console.log(JSON.stringify({
+}, ({ force, verbose }) => 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,
-		duration
-	}));
-	yield* logHumanOutput(result.status.chunks, result.status.files, duration);
+		files: result.status.files
+	});
+	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");
 }).pipe(Effect.catchAll(reportError)));
 //#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* 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.");
+const initCommand = Command.make("init", { json: Options.boolean("json").pipe(Options.withDefault(false)) }, () => Effect.gen(function* () {
+	const d = yield* Display;
+	const result = yield* d.spinner("Initializing...", InitProject.init());
+	yield* d.json(result);
+	yield* d.log("Created .pix/config.json with default settings.", "success");
+	yield* d.note("Add `.pix` to your `.gitignore` file to avoid committing the index.", "Reminder");
 }).pipe(Effect.catchTags({
 	ConfigError: reportError,
 	DiskFullError: reportError
@@ -258,30 +541,22 @@ const toJsonOutput = (results, ctxLines) => results.map((r) => ({
 	...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" }),
 	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* () {
+}, ({ queryText, top, contextLines }) => 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 && !json) yield* Effect.logDebug(`topK clamped from ${topK} to ${clamped.value}`);
-	const results = yield* QueryProject.queryProject(queryText, clamped.value);
-	if (json) return yield* Console.log(JSON.stringify(toJsonOutput(results, ctxLines), null, 2));
-	yield* renderResults(results);
+	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));
 }).pipe(Effect.catchTags({
 	ModelLoadError: reportError,
 	InferenceError: reportError,
@@ -305,30 +580,26 @@ const formatBytes = (bytes) => {
 };
 //#endregion
 //#region src/commands/reset.ts
-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;
-	}
-	yield* Effect.logInfo(`Deleted: ${deletedParts.join(", ")}`);
-	yield* Effect.logInfo(`Freed: ${formatBytes(result.freedBytes)}`);
-	yield* Effect.logInfo(`Time: ${elapsedMs}ms`);
-});
 /** CLI command: pix reset [--json] */
-const resetCommand = Command.make("reset", { json: Options.boolean("json").pipe(Options.withDefault(false)) }, ({ json }) => Effect.gen(function* () {
+const resetCommand = Command.make("reset", { json: Options.boolean("json").pipe(Options.withDefault(false)) }, () => Effect.gen(function* () {
+	const d = yield* Display;
 	const start = yield* Clock.currentTimeMillis;
-	const result = yield* ResetIndex.reset();
+	const result = yield* d.spinner("Resetting index...", ResetIndex.reset());
 	const elapsedMs = (yield* Clock.currentTimeMillis) - start;
-	if (json) return yield* logJsonResult(result, elapsedMs);
-	yield* logHumanResult(result, elapsedMs);
+	yield* d.json({
+		status: "ok",
+		deletedChunks: result.deletedChunks,
+		deletedVectors: result.deletedVectors,
+		freedBytes: result.freedBytes,
+		elapsedMs
+	});
+	const deletedParts = [result.deletedChunks ? "chunks.jsonl" : null, result.deletedVectors ? "vectors.bin" : null].filter((part) => part !== null);
+	if (deletedParts.length === 0) yield* d.log("Nothing to reset.", "info");
+	else {
+		yield* d.log(`Deleted: ${deletedParts.join(", ")}`, "success");
+		yield* d.log(`Freed: ${formatBytes(result.freedBytes)}`, "info");
+		yield* d.log(`Time: ${elapsedMs}ms`, "info");
+	}
 }).pipe(Effect.catchTags({
 	DiskFullError: reportError,
 	StoreError: reportError
@@ -336,22 +607,22 @@ const resetCommand = Command.make("reset", { json: Options.boolean("json").pipe(
 //#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 statusCommand = Command.make("status", { json: Options.boolean("json").pipe(Options.withDefault(false)) }, () => Effect.gen(function* () {
+	const d = yield* Display;
 	const result = yield* GetStatus.getStatus();
-	if (json) return yield* 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}`);
+	yield* d.json(result);
+	const lastIndexStr = result.lastIndex > 0 ? new Date(result.lastIndex).toLocaleString() : "never";
+	yield* d.log(`Indexed: ${result.chunks} chunks across ${result.files} files`, "info");
+	yield* d.log(`Model: ${result.model || "none"}`, "info");
+	yield* d.log(`Total lines: ${result.totalLines.toLocaleString()}`, "info");
+	yield* d.log(`Index size: ${result.byteSize.toLocaleString()} bytes`, "info");
+	yield* d.log(`Last indexed: ${lastIndexStr}`, "info");
 }).pipe(Effect.catchTags({ StoreError: reportError })));
 //#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.");
+	yield* (yield* Display).log(`pix v${VERSION} - Lightweight local semantic project indexer`, "info");
 })).pipe(Command.withSubcommands([
 	initCommand,
 	statusCommand,
@@ -359,33 +630,50 @@ const pix = Command.make("pix", {}, () => Effect.gen(function* () {
 	queryCommand,
 	resetCommand
 ]));
-const cli = (args) => Command.run(pix, {
-	name: "pix",
-	version: VERSION
-})(args).pipe(Effect.provide(CliConfig.layer({ showTypes: false })));
+const cli = (args) => {
+	const displayLayer = args.some((a) => a === "--json") ? JsonDisplay.layer : ClackDisplay.layer;
+	return {
+		effect: Command.run(pix, {
+			name: "pix",
+			version: VERSION
+		})(args),
+		displayLayer
+	};
+};
 //#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") {};
+//#region src/display/terminalCleanup.ts
 /**
-* Fatal scan failure — gitignore loading failed entirely. Non-fatal per-entry skips are reported
-* via ScanResult.skipped.
+* Terminal cleanup for abrupt exits.
+*
+* @clack/prompts' spinner and taskLog call stdin.setRawMode(true) and hide
+* the cursor via escape sequences. When the process is killed by a signal
+* handler that calls process.exit() directly, clack's own cleanup is
+* bypassed and the terminal is left in raw mode with the cursor hidden.
+*
+* Registering a process 'exit' listener that restores these guarantees the
+* terminal is always left in a usable state.
 */
-var ScanFailed = class extends Data.TaggedError("ScanFailed") {};
+/** Escape sequence to show the cursor (DECTCEM). */
+const SHOW_CURSOR = "\x1B[?25h";
+/**
+* Creates a synchronous exit handler that restores terminal state. Extracted as a pure function so
+* it can be unit-tested without side effects.
+*/
+const makeTerminalCleanupHandler = (stdin, stdout) => () => {
+	if (stdin.isTTY && stdin.setRawMode) try {
+		stdin.setRawMode(false);
+	} catch {}
+	if (stdout.isTTY) try {
+		stdout.write(SHOW_CURSOR);
+	} catch {}
+};
+/**
+* Registers the terminal cleanup handler on process 'exit'. Call once at program startup
+* (index.ts).
+*/
+const setupTerminalCleanup = () => {
+	process.on("exit", makeTerminalCleanupHandler(process.stdin, process.stdout));
+};
 //#endregion
 //#region src/services/chunker.ts
 const MIN_CHUNK_CHARS = 20;
@@ -418,17 +706,24 @@ const buildChunks = (file, content, config) => {
 	}
 	return chunks;
 };
-const make$4 = Effect.gen(function* () {
+const make$5 = Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
 	const config = yield* (yield* ConfigStore).readConfig().pipe(Effect.catchAll(() => Effect.succeed(DEFAULT_CONFIG)));
+	const chunkText = (text, file) => Effect.sync(() => {
+		if (text === "") return [];
+		return buildChunks(file, text, config);
+	});
 	const chunkFile = (file) => Effect.gen(function* () {
 		const content = yield* readFileContent(fs, file);
 		if (content === "") return [];
 		return buildChunks(file, content, config);
 	});
-	return { chunkFile };
+	return {
+		chunkFile,
+		chunkText
+	};
 });
-const ChunkerLive = Layer.effect(Chunker, make$4);
+const ChunkerLive = Layer.effect(Chunker, make$5);
 //#endregion
 //#region src/services/config-store.ts
 const CONFIG_DIR = ".pix";
@@ -445,7 +740,7 @@ const mapConfigWriteError = (cause, path, action) => {
 		cause
 	});
 };
-const make$3 = Effect.gen(function* () {
+const make$4 = Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
 	const writeConfig = (config) => Effect.gen(function* () {
 		const configJson = JSON.stringify(config, null, 2);
@@ -482,7 +777,28 @@ const make$3 = Effect.gen(function* () {
 		configExists
 	};
 });
-const ConfigStoreLive = Layer.effect(ConfigStore, make$3);
+const ConfigStoreLive = Layer.effect(ConfigStore, make$4);
+//#endregion
+//#region src/services/content-extractor.ts
+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 processor = processorMap[ext];
+		if (!processor) return Effect.fail({
+			_tag: "UnsupportedFormat",
+			message: `No processor for extension: ${ext}`,
+			extension: ext
+		});
+		return processor(file).pipe(Effect.provideService(FileSystem.FileSystem, fs));
+	};
+	return { extract };
+});
+const ContentExtractorLive = Layer.effect(ContentExtractor, make$3);
 //#endregion
 //#region src/domain/models.ts
 /** Registry of supported embedding models. */
@@ -559,7 +875,13 @@ const createExtractor = (opts) => Effect.tryPromise(async () => {
 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}`);
+		const d = yield* Display;
+		yield* d.log(`GPU (${opts.device}) failed, falling back to CPU...`, "warn");
+		yield* d.json({
+			event: "embedder_fallback",
+			originalDevice: opts.device,
+			reason: originalError.message
+		});
 		return yield* createExtractor({
 			...opts,
 			device: "cpu"
@@ -567,7 +889,9 @@ const createExtractorWithFallback = (opts) => {
 	})));
 };
 const make$2 = Effect.gen(function* () {
-	const cfg = yield* resolveEmbedderConfig(yield* ConfigStore);
+	const configStore = yield* ConfigStore;
+	const d = yield* Display;
+	const cfg = yield* resolveEmbedderConfig(configStore);
 	const getExtractor = yield* Effect.cached(createExtractorWithFallback(cfg));
 	const embed = (text) => Effect.gen(function* () {
 		const extractor = yield* getExtractor;
@@ -582,7 +906,7 @@ const make$2 = Effect.gen(function* () {
 			vector: normalize(data),
 			dims: cfg.dims
 		};
-	});
+	}).pipe(Effect.provideService(Display, d));
 	const batch = (texts) => Effect.gen(function* () {
 		const extractor = yield* getExtractor;
 		const results = [];
@@ -606,7 +930,7 @@ const make$2 = Effect.gen(function* () {
 			vector,
 			dims: cfg.dims
 		}));
-	});
+	}).pipe(Effect.provideService(Display, d));
 	return {
 		embed,
 		batch
@@ -615,14 +939,6 @@ const make$2 = Effect.gen(function* () {
 const OnnxEmbedderLive = Layer.provideMerge(Layer.effect(Embedder, make$2), ConfigStoreLive);
 //#endregion
 //#region src/services/scanner.ts
-const ALWAYS_IGNORE = new Set([
-	".pix",
-	"node_modules",
-	".git",
-	"dist",
-	"build",
-	".next"
-]);
 const make$1 = Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
 	const readFileWithSkip = (path, mkReason) => fs.readFileString(path).pipe(Effect.map((content) => ({
@@ -655,47 +971,84 @@ const make$1 = Effect.gen(function* () {
 			reason: `Could not stat: ${String(error)}`
 		}
 	})));
-	const loadGitignoreRules = Effect.gen(function* () {
+	const computeRelative = (fullPath, cwd) => fullPath.startsWith(cwd) ? fullPath.slice(cwd.length + 1) : fullPath;
+	const loadIgnoreFile = (filePath, ig, skipped) => Effect.gen(function* () {
+		const result = yield* readFileWithSkip(filePath, (error) => `Could not read ignore file: ${String(error)}`);
+		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 ig = ignore();
-		const cwd = process.cwd();
 		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"));
+		if (ignoredPaths.length > 0) ig.add(ignoredPaths);
+		const gitignorePath = `${cwd}/.gitignore`;
+		if (yield* fs.exists(gitignorePath).pipe(Effect.catchAll(() => Effect.succeed(false)))) yield* loadIgnoreFile(gitignorePath, ig, skipped);
 		const excludePath = `${cwd}/.git/info/exclude`;
-		if (yield* fs.exists(excludePath)) {
-			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"));
-		}
+		if (yield* fs.exists(excludePath).pipe(Effect.catchAll(() => Effect.succeed(false)))) yield* loadIgnoreFile(excludePath, ig, skipped);
 		return {
 			ig,
 			skipped
 		};
 	});
-	const walk = (dir, extensions) => Effect.gen(function* () {
+	const processEntry = (entry, dir, ig, cwd) => Effect.gen(function* () {
+		const fullPath = `${dir}/${entry}`;
+		const statResult = yield* statWithSkip(fullPath);
+		if (statResult.skipped) return {
+			files: [],
+			skipped: [statResult.skipped]
+		};
+		if (!statResult.info) return {
+			files: [],
+			skipped: []
+		};
+		const info = statResult.info;
+		if (info.type === "Directory") {
+			const relativeDir = computeRelative(fullPath, cwd);
+			if (ig.ignores(relativeDir)) return {
+				files: [],
+				skipped: [{
+					path: fullPath,
+					reason: `Ignored by config pattern: ${relativeDir}`
+				}]
+			};
+			return {
+				files: [],
+				skipped: [],
+				recurse: true
+			};
+		}
+		if (info.type === "File") {
+			const relativePath = computeRelative(fullPath, cwd);
+			if (ig.ignores(relativePath)) return {
+				files: [],
+				skipped: [{
+					path: fullPath,
+					reason: `Ignored by config pattern: ${relativePath}`
+				}]
+			};
+			return {
+				files: [fullPath],
+				skipped: []
+			};
+		}
+		return {
+			files: [],
+			skipped: []
+		};
+	});
+	const walk = (dir, ig, cwd) => Effect.gen(function* () {
 		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* 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);
+			const entryResult = yield* processEntry(entry, dir, ig, cwd);
+			files.push(...entryResult.files);
+			skipped.push(...entryResult.skipped);
+			if ("recurse" in entryResult) {
+				const sub = yield* walk(`${dir}/${entry}`, ig, cwd);
 				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)) files.push(fullPath);
 			}
 		}
 		return {
@@ -703,16 +1056,15 @@ const make$1 = Effect.gen(function* () {
 			skipped
 		};
 	});
-	const scanFiles = (extensions) => Effect.gen(function* () {
-		const { ig, skipped: ignoreSkipped } = yield* loadGitignoreRules.pipe(Effect.mapError((cause) => new ScanFailed({
+	const scanFiles = (ignoredPaths) => 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)}`,
 			cause
 		})));
-		const cwd = process.cwd();
-		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);
+		const { files, skipped: walkSkipped } = yield* walk(cwd, ig, cwd);
 		return {
-			files: ig.filter(relativePaths).map((p) => `${cwd}/${p}`),
+			files,
 			skipped: [...ignoreSkipped, ...walkSkipped]
 		};
 	});
@@ -888,11 +1240,14 @@ const make = Effect.gen(function* () {
 const VectorStoreLive = Layer.effect(VectorStore, make);
 //#endregion
 //#region src/index.ts
-const ServicesLayer = Layer.mergeAll(ConfigStoreLive, ScannerLive, OnnxEmbedderLive, VectorStoreLive);
+const ServicesLayer = Layer.mergeAll(ConfigStoreLive, ScannerLive, OnnxEmbedderLive, VectorStoreLive, ContentExtractorLive);
 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, ResetIndex.Default);
 const AppLayer = Layer.merge(UseCaseLayer.pipe(Layer.provide(InfraLayer)), NodeContext.layer);
-cli(process.argv).pipe(Effect.provide(AppLayer), NodeRuntime.runMain({ disableErrorReporting: true }));
+const { effect, displayLayer } = cli(process.argv);
+const cliLayer = Layer.mergeAll(displayLayer, CliConfig.layer({ showTypes: false }));
+setupTerminalCleanup();
+effect.pipe(Effect.provide(AppLayer.pipe(Layer.provideMerge(cliLayer))), NodeRuntime.runMain({ disableErrorReporting: true }));
 //#endregion
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucas-bur/pix",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Lightweight local semantic project indexer",
   "keywords": [
     "cli",
@@ -52,6 +52,7 @@
     "pix": ""
   },
   "dependencies": {
+    "@clack/prompts": "^1.4.0",
     "@effect/cli": "^0.75.1",
     "@effect/platform": "^0.96.1",
     "@effect/platform-node": "^0.106.0",