@carlesandres/house 0.4.13 → 0.5.0

package/src/config/load.ts

@@ -1,381 +0,0 @@
-/**
- * Layered configuration loader.
- *
- * Precedence (high to low): CLI args → env vars → user TOML file → built-in defaults.
- * Each source is wrapped as a `ConfigProvider` and composed via `orElse`,
- * which falls through per-key when the upstream source returns `undefined`.
- *
- * The schema (`Config.schema` + `Schema.Literals`) validates `theme` against
- * the registered theme ids and `tone` against `"dark" | "light"`. Validation
- * failures and TOML parse errors both surface as `ConfigError` from `loadConfig`.
- */
-
-import { homedir } from "node:os"
-import { join } from "node:path"
-import { Config, ConfigProvider, Effect, Schema } from "effect"
-import { parseShowList, SHOW_CATEGORIES, type ShowCategory } from "../discovery/show.ts"
-import { themeDefinitions } from "../theme/registry.ts"
-
-export interface HouseConfig {
-	readonly theme: string
-	readonly tone: "dark" | "light"
-	readonly extensions: readonly string[]
-	/** Reader wrap width used when wrapping is enabled. */
-	readonly width: number
-	/** Whether the reader starts with fixed-width wrapping enabled. */
-	readonly wrap: boolean
-	/** Default discovery-root strategy when no explicit `--root` flag is passed. */
-	readonly defaultRoot: "cwd" | "git"
-	/** Categories of normally-skipped entries to opt into. See
-	 *  `src/discovery/show.ts` for the vocabulary. Empty array (the
-	 *  default) yields the conservative discovery set. */
-	readonly show: readonly ShowCategory[]
-	/** Startup pane/input target. `filter` opens the sidebar filter prompt and
-	 *  focuses it immediately. */
-	readonly focus: "sidebar" | "reader" | "filter"
-}
-
-export interface CliOverrides {
-	readonly theme: string | null
-	readonly tone: string | null
-	readonly extensions: readonly string[] | null
-	/** When non-null, the parsed `--show` list completely replaces env/file
-	 *  (no per-category merging — sets compose by replacement, like every
-	 *  other CLI override here). `--show ""` sets the empty set. */
-	readonly show: readonly ShowCategory[] | null
-	readonly focus: "sidebar" | "reader" | "filter" | null
-	readonly width: number | null
-	readonly wrap: boolean | null
-}
-
-const DEFAULT_THEME = "opencode"
-const DEFAULT_TONE: "dark" | "light" = "dark"
-const DEFAULT_EXTENSIONS: readonly string[] = []
-const DEFAULT_ROOT: "cwd" | "git" = "cwd"
-const DEFAULT_SHOW = ""
-const DEFAULT_FOCUS: "sidebar" | "reader" | "filter" = "sidebar"
-const DEFAULT_WIDTH = 80
-const DEFAULT_WRAP = false
-
-const themeIds = themeDefinitions.map((t) => t.id)
-
-/**
- * Top-level keys the config file is allowed to set. Kept in sync by hand
- * with `schema` below — when adding a key, add it both places.
- * Used by `fileProvider` to warn about unrecognized keys (with a
- * did-you-mean hint when one is close) while still loading the rest.
- */
-const KNOWN_FILE_KEYS: ReadonlySet<string> = new Set([
-	"theme",
-	"tone",
-	"extensions",
-	"show",
-	"focus",
-	"width",
-	"wrap",
-	"defaultRoot",
-])
-
-const schema = Config.all({
-	theme: Config.schema(Schema.Literals(themeIds), "theme"),
-	tone: Config.schema(Schema.Literals(["dark", "light"] as const), "tone"),
-	defaultRoot: Config.schema(Schema.String, "defaultRoot"),
-	// Comma-separated extension list. Empty string means no extra extensions.
-	extensions: Config.schema(Schema.String, "extensions"),
-	// `show` arrives as a comma-separated string from every provider
-	// (`fileProvider` coerces TOML arrays via `String()`, which produces
-	// `"hidden,gitignored"`). Token-level validation happens in `loadConfig`
-	// so the error message can list valid categories at the field's path.
-	show: Config.schema(Schema.String, "show"),
-	focus: Config.schema(Schema.Literals(["sidebar", "reader", "filter"] as const), "focus"),
-	width: Config.schema(Schema.String, "width"),
-	wrap: Config.schema(Schema.String, "wrap"),
-})
-
-const defaultsProvider = (): ConfigProvider.ConfigProvider =>
-	ConfigProvider.fromUnknown({
-		theme: DEFAULT_THEME,
-		tone: DEFAULT_TONE,
-		defaultRoot: DEFAULT_ROOT,
-		extensions: DEFAULT_EXTENSIONS.join(","),
-		show: DEFAULT_SHOW,
-		focus: DEFAULT_FOCUS,
-		width: String(DEFAULT_WIDTH),
-		wrap: String(DEFAULT_WRAP),
-	})
-
-const sourceError = (message: string, cause?: unknown): ConfigProvider.SourceError =>
-	new ConfigProvider.SourceError({ message, cause })
-
-const validateFileValue = (path: string, key: string, value: unknown): void => {
-	if (key === "width") {
-		if (!Number.isSafeInteger(value) || (value as number) <= 0) {
-			throw sourceError(`invalid value for width in ${path}: expected a positive integer`)
-		}
-	}
-	if (key === "wrap") {
-		if (typeof value !== "boolean") {
-			throw sourceError(`invalid value for wrap in ${path}: expected true or false`)
-		}
-	}
-}
-
-/**
- * Levenshtein edit distance, capped at `cap` for early exit.
- * Used only to suggest "did you mean X?" when a config key looks like a
- * typo of a known one. Tiny inputs (≤ ~20 chars), so the naive O(n·m)
- * fill is fine.
- */
-const editDistance = (a: string, b: string, cap: number): number => {
-	if (Math.abs(a.length - b.length) > cap) return cap + 1
-	const prev: number[] = Array.from({ length: b.length + 1 })
-	const curr: number[] = Array.from({ length: b.length + 1 })
-	for (let j = 0; j <= b.length; j++) prev[j] = j
-	for (let i = 1; i <= a.length; i++) {
-		curr[0] = i
-		let rowMin = curr[0]!
-		for (let j = 1; j <= b.length; j++) {
-			const cost = a[i - 1] === b[j - 1] ? 0 : 1
-			curr[j] = Math.min(prev[j]! + 1, curr[j - 1]! + 1, prev[j - 1]! + cost)
-			if (curr[j]! < rowMin) rowMin = curr[j]!
-		}
-		if (rowMin > cap) return cap + 1
-		for (let j = 0; j <= b.length; j++) prev[j] = curr[j]!
-	}
-	return prev[b.length]!
-}
-
-const suggestKey = (unknown: string, known: readonly string[]): string | null => {
-	let best: { key: string; dist: number } | null = null
-	for (const k of known) {
-		const d = editDistance(unknown, k, 2)
-		if (d <= 2 && (best === null || d < best.dist)) best = { key: k, dist: d }
-	}
-	return best?.key ?? null
-}
-
-const formatUnknownKeyWarning = (path: string, key: string, known: readonly string[]): string => {
-	const suggestion = suggestKey(key, known)
-	const hint = suggestion ? ` — did you mean "${suggestion}"?` : ""
-	return `house: ignoring unknown key "${key}" in ${path}${hint}`
-}
-
-/**
- * Reads a TOML file at `path`. Missing file → `undefined` for every key
- * (per-key fallthrough). Malformed TOML → `SourceError` (hard fail
- * upstream). Unknown top-level keys are warned about via `onWarning` and
- * dropped — this preserves forward-compat with newer config schemas while
- * still flagging typos like `them = "..."`.
- */
-const fileProvider = (
-	path: string,
-	onWarning: (message: string) => void,
-): ConfigProvider.ConfigProvider => {
-	let cache: { data: Record<string, unknown> | null } | null = null
-	const load = Effect.gen(function* () {
-		if (cache !== null) return cache.data
-		const file = Bun.file(path)
-		const exists = yield* Effect.promise(() => file.exists())
-		if (!exists) {
-			cache = { data: null }
-			return null
-		}
-		const text = yield* Effect.promise(() => file.text())
-		const parsed = yield* Effect.try({
-			try: () => Bun.TOML.parse(text) as Record<string, unknown>,
-			catch: (cause) =>
-				sourceError(
-					`invalid TOML in ${path}: ${cause instanceof Error ? cause.message : String(cause)}`,
-					cause,
-				),
-		})
-		const known = [...KNOWN_FILE_KEYS]
-		const filtered: Record<string, unknown> = {}
-		for (const [k, v] of Object.entries(parsed)) {
-			if (KNOWN_FILE_KEYS.has(k)) {
-				yield* Effect.try({
-					try: () => validateFileValue(path, k, v),
-					catch: (cause) =>
-						cause instanceof ConfigProvider.SourceError
-							? cause
-							: sourceError(`invalid value for ${k} in ${path}`, cause),
-				})
-				filtered[k] = v
-			} else {
-				onWarning(formatUnknownKeyWarning(path, k, known))
-			}
-		}
-		cache = { data: filtered }
-		return filtered
-	})
-	return ConfigProvider.make((path) =>
-		Effect.gen(function* () {
-			const data = yield* load
-			if (data === null) return undefined
-			if (path.length === 0) {
-				return ConfigProvider.makeRecord(new Set(Object.keys(data)))
-			}
-			const head = path[0]
-			if (typeof head !== "string") return undefined
-			const value = data[head]
-			if (value === undefined) return undefined
-			if (typeof value === "string") return ConfigProvider.makeValue(value)
-			// Numbers/booleans coerced to their string form so Schema.Literals matches.
-			return ConfigProvider.makeValue(String(value))
-		}),
-	)
-}
-
-/**
- * Reads `HOUSE_THEME` / `HOUSE_TONE` directly into a `fromUnknown` provider.
- *
- * We don't use `fromEnv().pipe(nested("HOUSE"), constantCase)` here because
- * `ConfigProvider.orElse` composes providers via `.get(path)` (raw store
- * access), which bypasses `mapInput`/`prefix`. That means an env provider
- * built with `nested` + `constantCase` silently returns `undefined` once it
- * sits behind an `orElse`. Reading env vars eagerly sidesteps the issue.
- */
-const envProvider = (env: Record<string, string | undefined>): ConfigProvider.ConfigProvider => {
-	const entries: Array<[string, string]> = []
-	const theme = env["HOUSE_THEME"]
-	const tone = env["HOUSE_TONE"]
-	const defaultRoot = env["HOUSE_DEFAULT_ROOT"]
-	const extensions = env["HOUSE_EXTENSIONS"]
-	const show = env["HOUSE_SHOW"]
-	const focus = env["HOUSE_FOCUS"]
-	const width = env["HOUSE_WIDTH"]
-	const wrap = env["HOUSE_WRAP"]
-	if (theme !== undefined) entries.push(["theme", theme])
-	if (tone !== undefined) entries.push(["tone", tone])
-	if (defaultRoot !== undefined) entries.push(["defaultRoot", defaultRoot])
-	if (extensions !== undefined) entries.push(["extensions", extensions])
-	if (show !== undefined) entries.push(["show", show])
-	if (focus !== undefined) entries.push(["focus", focus])
-	if (width !== undefined) entries.push(["width", width])
-	if (wrap !== undefined) entries.push(["wrap", wrap])
-	return ConfigProvider.fromUnknown(Object.fromEntries(entries))
-}
-
-const cliProvider = (overrides: CliOverrides): ConfigProvider.ConfigProvider => {
-	const entries: Array<[string, string]> = []
-	if (overrides.theme !== null) entries.push(["theme", overrides.theme])
-	if (overrides.tone !== null) entries.push(["tone", overrides.tone])
-	if (overrides.extensions !== null) entries.push(["extensions", overrides.extensions.join(",")])
-	if (overrides.show !== null) entries.push(["show", overrides.show.join(",")])
-	if (overrides.focus !== null) entries.push(["focus", overrides.focus])
-	if (overrides.width !== null) entries.push(["width", String(overrides.width)])
-	if (overrides.wrap !== null) entries.push(["wrap", String(overrides.wrap)])
-	return ConfigProvider.fromUnknown(Object.fromEntries(entries))
-}
-
-const parsePositiveInteger = (key: string, raw: string): Effect.Effect<number, Error> => {
-	if (!/^\d+$/.test(raw)) {
-		return Effect.fail(new Error(`${key}: expected a positive integer, got ${JSON.stringify(raw)}`))
-	}
-	const value = Number.parseInt(raw, 10)
-	if (!Number.isSafeInteger(value) || value <= 0) {
-		return Effect.fail(new Error(`${key}: expected a positive integer, got ${JSON.stringify(raw)}`))
-	}
-	return Effect.succeed(value)
-}
-
-const parseBoolean = (key: string, raw: string): Effect.Effect<boolean, Error> => {
-	if (raw === "true") return Effect.succeed(true)
-	if (raw === "false") return Effect.succeed(false)
-	return Effect.fail(new Error(`${key}: expected true or false, got ${JSON.stringify(raw)}`))
-}
-
-export interface LoadOptions {
-	readonly cli?: CliOverrides
-	/** Override the TOML path (tests). Defaults to `$XDG_CONFIG_HOME/house/config.toml`. */
-	readonly filePath?: string
-	/** Override env (tests). Defaults to `process.env`. */
-	readonly env?: Record<string, string>
-	/** Sink for non-fatal warnings (unknown keys). Defaults to stderr. */
-	readonly onWarning?: (message: string) => void
-}
-
-export const defaultConfigPath = (): string =>
-	join(process.env["XDG_CONFIG_HOME"] ?? join(homedir(), ".config"), "house", "config.toml")
-
-/**
- * Renders a `ConfigError` (or any error) as a short single-line message
- * suitable for `console.error("house: " + ...)`. Strips Effect's
- * `ConfigError(SchemaError(...))` wrapping when present.
- */
-export const formatConfigError = (err: unknown): string => {
-	if (err instanceof Config.ConfigError) {
-		const cause = err.cause
-		const raw = "message" in cause ? cause.message : String(cause)
-		return raw
-			.replace(/\s+at \[[^\]]+\]\s*$/, "")
-			.replace(/\s+/g, " ")
-			.trim()
-	}
-	if (err instanceof Error) return err.message
-	return String(err)
-}
-
-export const loadConfig = (
-	options: LoadOptions = {},
-): Effect.Effect<HouseConfig, Config.ConfigError | Error> => {
-	const cli = options.cli ?? {
-		theme: null,
-		tone: null,
-		extensions: null,
-		show: null,
-		focus: null,
-		width: null,
-		wrap: null,
-	}
-	const onWarning = options.onWarning ?? ((msg) => process.stderr.write(`${msg}\n`))
-	const provider = cliProvider(cli).pipe(
-		ConfigProvider.orElse(envProvider(options.env ?? process.env)),
-		ConfigProvider.orElse(fileProvider(options.filePath ?? defaultConfigPath(), onWarning)),
-		ConfigProvider.orElse(defaultsProvider()),
-	)
-	return schema.parse(provider).pipe(
-		Effect.flatMap((raw) =>
-			Effect.gen(function* () {
-				const defaultRoot =
-					raw.defaultRoot === "cwd" || raw.defaultRoot === "git" ? raw.defaultRoot : DEFAULT_ROOT
-				if (raw.defaultRoot !== defaultRoot) {
-					onWarning(
-						`house: ignoring invalid value ${JSON.stringify(raw.defaultRoot)} for defaultRoot in config/env; using "${DEFAULT_ROOT}"`,
-					)
-				}
-				const parsed = parseShowList(raw.show)
-				if (!parsed.ok) {
-					// Effect's `Config.ConfigError` requires a `SchemaError` or
-					// `SourceError` cause that we don't have a clean constructor
-					// for here — surface as a plain Error and let the boot
-					// layer's existing `formatConfigError` (which already handles
-					// `instanceof Error`) render it.
-					return yield* Effect.fail(
-						new Error(
-							`show: unknown category "${parsed.invalid.join('", "')}" (valid: ${SHOW_CATEGORIES.join(", ")})`,
-						),
-					)
-				}
-				const width = yield* parsePositiveInteger("width", raw.width)
-				const wrap = yield* parseBoolean("wrap", raw.wrap)
-				return {
-					theme: raw.theme,
-					tone: raw.tone,
-					defaultRoot,
-					width,
-					wrap,
-					extensions:
-						raw.extensions === ""
-							? []
-							: raw.extensions
-									.split(",")
-									.map((s) => s.trim())
-									.filter(Boolean),
-					show: parsed.value,
-					focus: raw.focus,
-				}
-			}),
-		),
-	)
-}

package/src/config/save.ts

@@ -1,95 +0,0 @@
-import { dirname } from "node:path"
-import { lstat, mkdir, readFile, realpath, rename, unlink, writeFile } from "node:fs/promises"
-import { defaultConfigPath } from "./load.ts"
-
-export interface ThemePreference {
-	readonly theme: string
-	readonly tone: "dark" | "light"
-}
-
-let saveQueue: Promise<void> = Promise.resolve()
-
-const encodeTomlString = (value: string): string => JSON.stringify(value)
-
-const upsertTopLevelString = (raw: string, key: keyof ThemePreference, value: string): string => {
-	const encoded = encodeTomlString(value)
-	const lines = raw.split("\n")
-	const keyPattern = new RegExp(`^(\\s*)${key}\\s*=.*$`)
-	let inTopLevel = true
-	let insertAt = lines.length
-
-	for (let i = 0; i < lines.length; i++) {
-		const line = lines[i]!
-		if (/^\s*\[[^\]]+\]\s*(?:#.*)?$/.test(line)) {
-			inTopLevel = false
-			insertAt = Math.min(insertAt, i)
-		}
-		if (!inTopLevel) continue
-		const match = keyPattern.exec(line)
-		if (match) {
-			lines[i] = `${match[1]}${key} = ${encoded}`
-			return lines.join("\n")
-		}
-	}
-
-	const insertion = `${key} = ${encoded}`
-	if (insertAt === lines.length) {
-		if (lines.length === 0 || lines[lines.length - 1] !== "") return `${raw}\n${insertion}\n`
-		lines.splice(lines.length - 1, 0, insertion)
-		return lines.join("\n")
-	}
-
-	lines.splice(insertAt, 0, insertion)
-	return lines.join("\n")
-}
-
-const updateThemePreferenceToml = (raw: string, record: ThemePreference): string => {
-	// Validate the existing file before preserving and editing its text. If the
-	// user has malformed TOML, fail loudly rather than replacing it wholesale.
-	Bun.TOML.parse(raw)
-	return upsertTopLevelString(upsertTopLevelString(raw, "theme", record.theme), "tone", record.tone)
-}
-
-const resolveWritableConfigPath = async (path: string): Promise<string> => {
-	try {
-		const stat = await lstat(path)
-		if (stat.isSymbolicLink()) return await realpath(path)
-	} catch (err) {
-		if ((err as NodeJS.ErrnoException).code !== "ENOENT") throw err
-	}
-	return path
-}
-
-const writeThemePreference = async (record: ThemePreference, path: string): Promise<void> => {
-	const targetPath = await resolveWritableConfigPath(path)
-	path = targetPath
-	const tmp = `${path}.${process.pid}.${Date.now()}.tmp`
-	try {
-		await mkdir(dirname(path), { recursive: true })
-		let next = `theme = ${encodeTomlString(record.theme)}\ntone = ${encodeTomlString(record.tone)}\n`
-		try {
-			const raw = await readFile(path, "utf8")
-			next = updateThemePreferenceToml(raw, record)
-		} catch (err) {
-			if ((err as NodeJS.ErrnoException).code !== "ENOENT") throw err
-		}
-		await writeFile(tmp, next, "utf8")
-		await rename(tmp, path)
-	} catch (err) {
-		try {
-			await unlink(tmp)
-		} catch {
-			// best-effort cleanup
-		}
-		throw err
-	}
-}
-
-export const saveThemePreference = async (
-	record: ThemePreference,
-	path = defaultConfigPath(),
-): Promise<void> => {
-	const run = saveQueue.catch(() => {}).then(() => writeThemePreference(record, path))
-	saveQueue = run.catch(() => {})
-	return run
-}

package/src/discovery/filter.ts

@@ -1,148 +0,0 @@
-/**
- * Fuzzy filter for the sidebar.
- *
- * Matching stays intentionally small and pure: case-insensitive subsequence on
- * the filename and full relative path. Ranking prefers what users usually mean
- * in a sidebar (no configuration, no user knobs):
- *   - filename matches above folder-only matches (zf/fzf-inspired strong bias)
- *   - shallower / current-folder paths win over deep nested ones
- *   - incidental matches purely from deep directory names are heavily demoted
- *     so "nested folders bubbling up" does not happen for typical queries
- *
- * Empty query preserves discovery/tree order.
- *
- * The low-level fuzzyScore uses a "best alignment" scan (try every possible
- * start position for the first query char, complete greedily, take the highest
- * scoring match). This avoids the "early spurious char traps" a pure left-to-right
- * greedy can hit on paths (e.g. "src/r.../readme" for query "readme" must prefer
- * the boundary "r" in the filename, not the "r" in "src"). This draws from fzf's
- * v1 "find occurrence then look for better" idea and the general principle that
- * boundary+consecutive bonuses should win when they exist later in the string.
- * We deliberately do not depend on fuzzysort/fuse/fzf here: the ranking *policy*
- * (heavy filename bias, exact/stem bonuses, depth soft penalty) is application
- * specific to "what makes a sidebar nice" and must be owned so end users get the
- * good experience with zero configuration or thought. See DESIGN.md §7.4 and the
- * filter tests.
- */
-
-import type { FileEntry } from "./walk.ts"
-
-export const fuzzyScore = (query: string, target: string): number | null => {
-	if (query.length === 0) return 0
-	const q = query.toLowerCase()
-	const t = target.toLowerCase()
-	if (q.length > t.length) return null
-
-	let best: number | null = null
-
-	// Best-alignment: try every viable start for q[0], then complete the rest
-	// greedily from there. Take the alignment that accumulates the most bonus
-	// points (word-start after /, consecutives). This is what gives good OOB
-	// results on tree paths without the caller doing extra work.
-	for (let start = 0; start < t.length; start++) {
-		if (t[start] !== q[0]) continue
-
-		let qi = 1
-		let score = 0
-		let lastMatch = start
-
-		// score first char
-		const isWordStart0 = start === 0 || t[start - 1] === "/"
-		score += isWordStart0 ? 10 : 1
-
-		let i = start + 1
-		for (; i < t.length && qi < q.length; i++) {
-			if (t[i] !== q[qi]) continue
-			const isWordStart = i === 0 || t[i - 1] === "/"
-			score += isWordStart ? 10 : 1
-			if (lastMatch === i - 1) score += 5
-			lastMatch = i
-			qi++
-		}
-
-		if (qi === q.length) {
-			if (best === null || score > best) best = score
-		}
-	}
-
-	return best
-}
-
-const splitPath = (relativePath: string): { fileName: string; depth: number } => {
-	const slash = relativePath.lastIndexOf("/")
-	return {
-		fileName: slash >= 0 ? relativePath.slice(slash + 1) : relativePath,
-		depth: slash >= 0 ? relativePath.split("/").length - 1 : 0,
-	}
-}
-
-const fileStem = (fileName: string): string => {
-	const dot = fileName.lastIndexOf(".")
-	return dot > 0 ? fileName.slice(0, dot) : fileName
-}
-
-const rankFile = (query: string, file: FileEntry): number | null => {
-	const pathScore = fuzzyScore(query, file.relativePath)
-	if (pathScore === null) return null
-
-	const { fileName, depth } = splitPath(file.relativePath)
-	const q = query.toLowerCase()
-	const name = fileName.toLowerCase()
-	const stem = fileStem(fileName).toLowerCase()
-	const nameScore = fuzzyScore(query, fileName) ?? 0
-
-	let score = pathScore * 4
-	score += nameScore * 150
-
-	// Filename (and stem) priority — the heart of good sidebar UX.
-	// Users almost always mean "the file whose name contains this", not
-	// "some directory component that happens to have these letters".
-	if (name === q || stem === q) score += 5_000
-	else if (name.startsWith(q) || stem.startsWith(q)) score += 2_000
-	else if (name.includes(q)) score += 1_000
-
-	// Strong depth bias so less-nested files appear near the top.
-	// We want shallow files to win over deep "nested folders" even when
-	// the deep file has a decent path match (common with short queries or
-	// dir names). The penalty is now large enough to matter vs. the
-	// match bonuses. Root gets a big kick. This is the main lever for
-	// "position in the tree structure" without any user config.
-	if (depth === 0) score += 800
-	score -= depth * 120
-
-	// Extra penalty when the match is weak or absent in the *basename*.
-	// This aggressively demotes results where the hit is only because the
-	// file lives under a matching deep directory ("nested folders bubbling up").
-	if (nameScore == null || nameScore < 8) {
-		score -= depth * 80
-	}
-
-	return score
-}
-
-/**
- * Filter and re-rank a file list by a query. Empty query returns the input
- * unchanged (preserves the discovery sort order). Non-empty query keeps
- * matches only, sorted by score desc; ties fall back to the input order so
- * the discovery sort still leaks through.
- *
- * All the "make this feel right for users exploring a tree" logic lives here
- * (and in rankFile) so callers (Browser) and end users never have to think
- * about or configure ranking.
- */
-export const filterFiles = (files: readonly FileEntry[], query: string): readonly FileEntry[] => {
-	if (query.length === 0) return files
-	const scored: { file: FileEntry; score: number; depth: number; index: number }[] = []
-	for (let i = 0; i < files.length; i++) {
-		const file = files[i]!
-		const score = rankFile(query, file)
-		if (score === null) continue
-		const depth = (file.relativePath.match(/\//g) || []).length
-		scored.push({ file, score, depth, index: i })
-	}
-	// Primary: match quality (fuzzy + name bonuses - depth penalties already in score)
-	// Secondary: shallower depth wins (less nested near top)
-	// Tertiary: stable original discovery order
-	scored.sort((a, b) => b.score - a.score || a.depth - b.depth || a.index - b.index)
-	return scored.map((s) => s.file)
-}

package/src/discovery/show.ts

@@ -1,48 +0,0 @@
-/**
- * Discovery visibility categories.
- *
- * Each name identifies a class of entries that the walker normally skips and
- * that the user can opt into showing. The set is intentionally an open vocab:
- * adding a future category (e.g. `"build-artifacts"`) means one entry here,
- * one branch in `walk`, and no churn in the CLI/config surface — `--show`,
- * `HOUSE_SHOW`, and TOML `show = [...]` all carry whatever names live in this
- * tuple.
- */
-export const SHOW_CATEGORIES = ["hidden", "gitignored"] as const
-
-export type ShowCategory = (typeof SHOW_CATEGORIES)[number]
-
-export const isShowCategory = (value: string): value is ShowCategory =>
-	(SHOW_CATEGORIES as readonly string[]).includes(value)
-
-/**
- * Parse a comma-separated list of category names. Whitespace around tokens
- * is trimmed; empty tokens (trailing comma, double comma) are dropped.
- * Returns `{ ok, value }` on success or `{ ok: false, invalid }` listing
- * tokens that aren't known categories — callers shape the error message
- * for their surface (CLI vs config).
- */
-export type ParseShowResult =
-	| { readonly ok: true; readonly value: readonly ShowCategory[] }
-	| { readonly ok: false; readonly invalid: readonly string[] }
-
-export const parseShowList = (raw: string): ParseShowResult => {
-	const tokens = raw
-		.split(",")
-		.map((t) => t.trim())
-		.filter((t) => t.length > 0)
-	const invalid = tokens.filter((t) => !isShowCategory(t))
-	if (invalid.length > 0) return { ok: false, invalid }
-	// De-dupe while preserving the configured order — callers that care
-	// about presence use Set membership; emitting a unique sequence keeps
-	// the round-trip (encode/decode) stable.
-	const seen = new Set<ShowCategory>()
-	const out: ShowCategory[] = []
-	for (const t of tokens as ShowCategory[]) {
-		if (!seen.has(t)) {
-			seen.add(t)
-			out.push(t)
-		}
-	}
-	return { ok: true, value: out }
-}