@carlesandres/house 0.4.13 → 0.5.0

package/src/StatusPopover.tsx

@@ -1,166 +0,0 @@
-import { useTerminalDimensions } from "@opentui/react"
-import { useMemo, useState } from "react"
-import { StatusIndicator, statusIndicatorFg } from "./StatusIndicator.tsx"
-import { colors } from "./theme/colors.ts"
-
-export type StatusPopoverVariant = "info" | "warning" | "error" | "success"
-
-export interface StatusPopoverProps {
-	readonly icon: string
-	readonly content: string
-	readonly variant?: StatusPopoverVariant
-	readonly open?: boolean
-	readonly defaultOpen?: boolean
-	readonly onOpenChange?: (open: boolean) => void
-	readonly showPanel?: boolean
-	readonly minWidth?: number
-	readonly maxWidth?: number
-	readonly maxHeight?: number
-	readonly zIndex?: number
-}
-
-export interface StatusPopoverPanelProps {
-	readonly content: string
-	readonly variant?: StatusPopoverVariant
-	readonly minWidth?: number
-	readonly maxWidth?: number
-	readonly maxHeight?: number
-	readonly zIndex?: number
-}
-
-const clamp = (n: number, min: number, max: number) => Math.max(min, Math.min(max, n))
-
-const measureLine = (line: string): number => line.length
-
-const wrapLine = (line: string, width: number): string[] => {
-	if (width <= 0) return [line]
-	if (line.length <= width) return [line]
-	const out: string[] = []
-	let i = 0
-	while (i < line.length) {
-		out.push(line.slice(i, i + width))
-		i += width
-	}
-	return out
-}
-
-export const StatusPopover = ({
-	icon,
-	content,
-	variant = "warning",
-	open,
-	defaultOpen = false,
-	onOpenChange,
-	showPanel = true,
-	minWidth = 14,
-	maxWidth = 40,
-	maxHeight = 12,
-	zIndex = 30,
-}: StatusPopoverProps) => {
-	const { width: viewportWidth, height: viewportHeight } = useTerminalDimensions()
-	const [uncontrolledOpen, setUncontrolledOpen] = useState(defaultOpen)
-	const isOpen = open ?? uncontrolledOpen
-	const setOpen = (next: boolean) => {
-		if (open === undefined) setUncontrolledOpen(next)
-		onOpenChange?.(next)
-	}
-
-	const lines = useMemo(() => content.split(/\r?\n/), [content])
-	const textWidth = useMemo(() => {
-		const widest = Math.max(1, ...lines.map(measureLine))
-		return clamp(widest, minWidth, Math.min(maxWidth, Math.max(1, viewportWidth - 4)))
-	}, [content, lines, maxWidth, minWidth, viewportWidth])
-
-	const wrapped = useMemo(
-		() => lines.flatMap((line) => wrapLine(line, textWidth)),
-		[lines, textWidth],
-	)
-	const bodyHeight = Math.min(maxHeight, Math.max(1, wrapped.length))
-	const popoverWidth = Math.min(textWidth + 2, Math.max(1, viewportWidth - 2))
-	const popoverHeight = Math.min(bodyHeight + 2, Math.max(3, viewportHeight - 2))
-
-	const left = 1
-	const top = Math.max(0, viewportHeight - popoverHeight - 2)
-
-	const linesToRender = wrapped.slice(0, Math.max(0, popoverHeight - 2))
-	while (linesToRender.length < popoverHeight - 2) linesToRender.push("")
-	const borderColor = statusIndicatorFg(variant)
-
-	return (
-		<>
-			<StatusIndicator icon={icon} variant={variant} active onMouseUp={() => setOpen(!isOpen)} />
-			{showPanel && isOpen && (
-				<box
-					position="absolute"
-					left={left}
-					top={top}
-					width={popoverWidth}
-					height={popoverHeight}
-					zIndex={zIndex}
-					style={{
-						border: true,
-						borderColor,
-						backgroundColor: colors.backgroundPanel,
-						flexDirection: "column",
-					}}
-				>
-					<text content="" />
-					{linesToRender.map((line, i) => (
-						<text key={i} content={line} wrapMode="none" style={{ fg: colors.text }} />
-					))}
-					<text content="" />
-				</box>
-			)}
-		</>
-	)
-}
-
-export const StatusPopoverPanel = ({
-	content,
-	variant = "warning",
-	minWidth = 14,
-	maxWidth = 40,
-	maxHeight = 12,
-	zIndex = 30,
-}: StatusPopoverPanelProps) => {
-	const { width: viewportWidth, height: viewportHeight } = useTerminalDimensions()
-	const lines = useMemo(() => content.split(/\r?\n/), [content])
-	const textWidth = useMemo(() => {
-		const widest = Math.max(1, ...lines.map(measureLine))
-		return clamp(widest, minWidth, Math.min(maxWidth, Math.max(1, viewportWidth - 4)))
-	}, [lines, maxWidth, minWidth, viewportWidth])
-	const wrapped = useMemo(
-		() => lines.flatMap((line) => wrapLine(line, textWidth)),
-		[lines, textWidth],
-	)
-	const bodyHeight = Math.min(maxHeight, Math.max(1, wrapped.length))
-	const popoverWidth = Math.min(textWidth + 2, Math.max(1, viewportWidth - 2))
-	const popoverHeight = Math.min(bodyHeight + 2, Math.max(3, viewportHeight - 2))
-	const linesToRender = wrapped.slice(0, Math.max(0, popoverHeight - 2))
-	while (linesToRender.length < popoverHeight - 2) linesToRender.push("")
-
-	const borderColor = statusIndicatorFg(variant)
-
-	return (
-		<box
-			position="absolute"
-			left={1}
-			top={Math.max(0, viewportHeight - popoverHeight - 2)}
-			width={popoverWidth}
-			height={popoverHeight}
-			zIndex={zIndex}
-			style={{
-				border: true,
-				borderColor,
-				backgroundColor: colors.backgroundPanel,
-				flexDirection: "column",
-			}}
-		>
-			<text content="" />
-			{linesToRender.map((line, i) => (
-				<text key={i} content={line} wrapMode="none" style={{ fg: colors.text }} />
-			))}
-			<text content="" />
-		</box>
-	)
-}

package/src/brand.ts

@@ -1,7 +0,0 @@
-/**
- * Brand mark. U+2302 HOUSE is a single-cell glyph in every monospace font
- * we care about; falls back to a tofu box on rare fonts that lack it.
- * Single import point so future placements (#76) stay in sync.
- */
-export const BRAND = "⌂"
-export const BRAND_NAME = "house"

package/src/cli/argv.ts

@@ -1,179 +0,0 @@
-import { Command } from "commander"
-import { themeDefinitions } from "../theme/registry.ts"
-
-export interface ParsedArgs {
-	/** First positional argument, or null if none was given. */
-	readonly path: string | null
-	/** Value of `--root <dir>`, or null. */
-	readonly root: string | null
-	/** Value of `--theme <id>`, or null. Validated by the boot layer against the registry. */
-	readonly theme: string | null
-	/** Value of `--tone dark|light`, or null. Validated by the boot layer. */
-	readonly tone: string | null
-	/** Value of `--width <N>`, or null. Validated by the boot layer (must be a positive integer). */
-	readonly width: string | null
-	/** Startup reader wrap override. Null means config/env/default decides. */
-	readonly wrap: boolean | null
-	/** True when both `--wrap` and `--no-wrap` were passed. */
-	readonly wrapConflict: boolean
-	/** True when `--serve` was passed: serve the positional path as HTML, skip TUI. */
-	readonly serve: boolean
-	/** Value of `--port <N>`, or null. Validated by the boot layer. */
-	readonly port: string | null
-	/** True when `--help` was passed. */
-	readonly help: boolean
-	/** True when `--version` was passed. */
-	readonly version: boolean
-	/** True when `--config-path` was passed: print resolved config path and exit. */
-	readonly configPath: boolean
-	/** True when `--no-update-check` was passed: suppress the npm-registry
-	 *  probe and the "update available" notice. Mirrors the
-	 *  `NO_UPDATE_NOTIFIER` env var so opt-out is reachable without env state. */
-	readonly noUpdateCheck: boolean
-	/** Raw value of `--ext [list]`, or null if absent. Comma-separated list. */
-	readonly extensions: string | null
-	/** Value of `--focus <mode>` (`sidebar`, `reader`, `filter`), or null.
-	 *  Validated by the boot layer. */
-	readonly focus: string | null
-	/** Raw value of `--show <list>`, or null if the flag wasn't passed.
-	 *  Comma-separated list of category names; the boot layer validates
-	 *  tokens against the known vocabulary (see `discovery/show.ts`).
-	 *  `--show ""` is a meaningful value: clears the set. */
-	readonly show: string | null
-}
-
-const createProgram = () =>
-	new Command()
-		.allowUnknownOption(true)
-		.allowExcessArguments(true)
-		.exitOverride()
-		.helpOption(false)
-		.option("--theme [id]")
-		.option("--tone [mode]")
-		.option("--width [N]")
-		.option("--wrap")
-		.option("--no-wrap")
-		.option("--serve")
-		.option("--port [N]")
-		.option("--config-path")
-		.option("--no-update-check")
-		.option("--ext [list]")
-		.option("--focus [mode]")
-		.option("--show [list]")
-		.option("--root [dir]")
-		.option("-h, --help")
-		.option("-v, --version")
-		.argument("[path]")
-
-const VALUE_FLAGS: ReadonlySet<string> = new Set([
-	"--theme",
-	"--tone",
-	"--width",
-	"--port",
-	"--focus",
-	"--show",
-	"--root",
-	"--ext",
-])
-
-const REMOVED_VALUE_FLAGS: ReadonlySet<string> = new Set(["--sort", "--sidebar"])
-
-const BOOLEAN_FLAGS: ReadonlySet<string> = new Set([
-	"--serve",
-	"--config-path",
-	"--no-update-check",
-	"--wrap",
-	"--no-wrap",
-	"--help",
-	"-h",
-	"--version",
-	"-v",
-])
-
-const findPathArg = (argv: readonly string[]): string | null => {
-	for (let i = 0; i < argv.length; i++) {
-		const arg = argv[i]!
-		if (VALUE_FLAGS.has(arg) || REMOVED_VALUE_FLAGS.has(arg)) {
-			const next = argv[i + 1]
-			if (next !== undefined && !next.startsWith("-")) i++
-			continue
-		}
-		if (BOOLEAN_FLAGS.has(arg)) continue
-		if (arg.startsWith("-")) continue
-		return arg
-	}
-	return null
-}
-
-/**
- * Minimal argv parser.
- *
- * Does not validate flag values — boot layers do, so error messages can
- * reference domain knowledge (registered themes, valid integer ranges)
- * without coupling the parser to it.
- */
-export const parseArgv = (argv: readonly string[]): ParsedArgs => {
-	const program = createProgram()
-	program.parse([...argv], { from: "user" })
-	const opts = program.opts<Record<string, unknown>>()
-	const pathArg = findPathArg(argv)
-	const stringOrNull = (value: unknown): string | null => (typeof value === "string" ? value : null)
-	const hasWrap = argv.includes("--wrap")
-	const hasNoWrap = argv.includes("--no-wrap")
-
-	return {
-		path: typeof pathArg === "string" ? pathArg : null,
-		root: stringOrNull(opts["root"]),
-		theme: stringOrNull(opts["theme"]),
-		tone: stringOrNull(opts["tone"]),
-		width: stringOrNull(opts["width"]),
-		wrap: hasWrap ? true : hasNoWrap ? false : null,
-		wrapConflict: hasWrap && hasNoWrap,
-		serve: opts["serve"] === true,
-		port: stringOrNull(opts["port"]),
-		help: opts["help"] === true,
-		version: opts["version"] === true,
-		configPath: opts["configPath"] === true,
-		noUpdateCheck: opts["noUpdateCheck"] === true,
-		extensions: stringOrNull(opts["ext"]),
-		show: stringOrNull(opts["show"]),
-		focus: stringOrNull(opts["focus"]),
-	}
-}
-
-const themeList = themeDefinitions.map((t) => t.id).join(", ")
-
-export const usage = `usage:
-  house [query] [options]
-  house --serve <path> [--port N]
-
-  query          initial filter query; omit to browse the full discovery root
-
-options:
-  --theme <id>   color theme: ${themeList} (default: opencode)
-  --tone <mode>  dark or light (default: dark)
-  --width <N>    reader wrap width used when wrapping is enabled (default: 80)
-  --wrap         start with reader wrapping enabled
-  --no-wrap      start with reader wrapping disabled
-  --show <list>  reveal normally-skipped entries; comma-separated subset of:
-                   hidden, gitignored. Use --show "" to clear.
-  --root <dir>   discovery root to walk (overrides defaultRoot config/env)
-  --focus <m>    startup focus: sidebar, reader, or filter (default: sidebar)
-  --serve        serve the positional path as HTML in the browser (skips TUI)
-  --port <N>     port for --serve (default: OS-assigned)
-  -h, --help     show this help and exit
-  -v, --version  print version and exit
-  --config-path  print path to the config file and exit
-  --no-update-check  suppress the "newer version available" check (also via NO_UPDATE_NOTIFIER=1)
-	--ext <list>   include extra file extensions (comma-separated)
-
-examples:
-  house README.md
-  house --root docs
-  house --serve README.md
-
-configuration:
-  file: $XDG_CONFIG_HOME/house/config.toml  (default ~/.config/house/config.toml)
-	  keys: theme, tone, width, wrap, extensions, show, focus, defaultRoot
-	  env:  HOUSE_THEME, HOUSE_TONE, HOUSE_WIDTH, HOUSE_WRAP, HOUSE_EXTENSIONS, HOUSE_SHOW, HOUSE_FOCUS, HOUSE_DEFAULT_ROOT
-  precedence (high → low): flags → env → file → defaults`

package/src/commands/buildCommands.ts

@@ -1,98 +0,0 @@
-/**
- * Derive palette commands from `browserBindings` plus the annotation map.
- *
- * The annotation map is the *only* hand-written list keyed by binding id:
- * it carries title rewrites and metadata for bindings whose raw
- * `description` reads awkwardly as a palette command. Every enabled binding is exposed
- * verbatim — its `description` becomes the palette `title`, its first key
- * becomes the `shortcut`.
- *
- * Commands close over the per-render `BrowserCtx`, same shape the keymap
- * dispatcher uses, so the palette and the keymap fire the same action via
- * different surfaces. See #70 design log §list construction (option 3b)
- * for why this beat (a) a fully hand-written palette list and (b) deriving
- * everything via #92's atom-driven registry.
- */
-
-import { browserBindings, type BrowserCtx } from "../keymap/browser.ts"
-import { paletteOnlyCommands } from "./paletteOnlyCommands.ts"
-import type { AppCommand } from "./types.ts"
-
-interface Annotation {
-	/** Override the binding's `description` for palette display. */
-	readonly title?: string
-	/** Carried for #91's category headers; unused in v1's flat list. */
-	readonly category?: string
-	/** If true, the binding does not appear in the palette. */
-	readonly hidden?: boolean
-	readonly keywords?: readonly string[]
-}
-
-/**
- * Title rewrites convert keymap phrasing into imperative palette phrasing.
- * With the help overlay removed (#139), the palette is the only in-app full
- * action index, so all currently-enabled actions stay discoverable here.
- */
-const annotations: Record<string, Annotation> = {
-	// --- Keep, with title rewrites where the binding description reads awkwardly as a command ---
-	quit: { category: "App" },
-	"focus.toggle": { title: "Toggle focus", category: "View" },
-	"sidebar.toggle": { title: "Toggle sidebar", category: "View" },
-	"sidebar.down": { category: "Navigation" },
-	"sidebar.up": { category: "Navigation" },
-	"sidebar.jumpDown": { category: "Navigation" },
-	"sidebar.jumpUp": { category: "Navigation" },
-	"sidebar.pageDown": { category: "Navigation" },
-	"sidebar.pageUp": { category: "Navigation" },
-	"sidebar.top": { category: "Navigation" },
-	"sidebar.bottom": { category: "Navigation" },
-	"sidebar.open": { title: "Open file", category: "Navigation" },
-	"filter.open": { title: "Filter files…", category: "Navigation" },
-	"filter.clearOrOpen": { category: "Navigation" },
-	"discovery.toggleAll": {
-		title: "Toggle hidden / gitignored files",
-		category: "Navigation",
-		keywords: ["hidden", "gitignore", "dotfiles", "all"],
-	},
-	"reader.back": { title: "Back to sidebar", category: "Navigation" },
-	"reader.wrap.toggle": { title: "Toggle reader wrap", category: "View" },
-	"reader.prevFile": { title: "Previous file", category: "Navigation" },
-	"reader.nextFile": { title: "Next file", category: "Navigation" },
-	"serve.current": { title: "Open in browser", category: "File" },
-	"file.edit": { title: "Open in editor", category: "File", keywords: ["editor", "vim", "vscode"] },
-	"theme.next": { category: "Appearance" },
-	"theme.prev": { category: "Appearance" },
-	"theme.toneToggle": { title: "Toggle dark/light tone", category: "Appearance" },
-
-	// --- Hide: the palette opener itself shouldn't appear in the palette ---
-	"palette.open": { hidden: true },
-}
-
-/**
- * Build the AppCommand list for a given render. Iterates `browserBindings`
- * in array order (the empty-query palette renders in this order, by design
- * — see #70 design log §empty-state ordering), drops explicitly-hidden entries
- * and those whose `when` predicate currently returns false, and resolves
- * annotations to populate title / category / keywords.
- */
-export const buildCommands = (ctx: BrowserCtx): readonly AppCommand[] => {
-	const out: AppCommand[] = []
-	for (const binding of browserBindings) {
-		const ann = annotations[binding.id]
-		if (ann?.hidden) continue
-		// Same gating the keymap dispatcher uses. Disabled bindings stay out of
-		// the palette; #96 tracks a future show-with-reason mode.
-		if (binding.when && !binding.when(ctx)) continue
-		const cmd: AppCommand = {
-			id: binding.id,
-			title: ann?.title ?? binding.description,
-			...(ann?.category !== undefined && { category: ann.category }),
-			...(ann?.keywords !== undefined && { keywords: ann.keywords }),
-			...(binding.keys[0] !== undefined && { shortcut: binding.keys[0] }),
-			run: () => binding.run(ctx),
-		}
-		out.push(cmd)
-	}
-	for (const cmd of paletteOnlyCommands(ctx)) out.push(cmd)
-	return out
-}

package/src/commands/paletteOnlyCommands.ts

@@ -1,27 +0,0 @@
-/**
- * Commands that exist *only* in the palette — no `browserBindings` entry.
- *
- * Empty in v1 by design (#70 Q6c). This file exists as scaffolding so
- * future palette-only commands (#93 reveal-in-OS, #94 copy-path, …) have
- * an obvious home that's already wired into `buildCommands.ts`.
- *
- * Commands here follow the same shape as keymap-derived ones: they take
- * the per-render `BrowserCtx` so they can read selection state, mutate
- * focus, surface notices, etc.
- */
-
-import type { BrowserCtx } from "../keymap/browser.ts"
-import type { AppCommand } from "./types.ts"
-
-export const paletteOnlyCommands = (ctx: BrowserCtx): readonly AppCommand[] =>
-	ctx.hasSelected
-		? [
-				{
-					id: "file.copyContents",
-					title: "Copy file contents",
-					category: "File",
-					keywords: ["copy", "clipboard", "contents", "markdown"],
-					run: () => ctx.copyCurrentContents(),
-				},
-			]
-		: []

package/src/commands/score.ts

@@ -1,78 +0,0 @@
-/**
- * Command palette scorer — ported from ghui's pre-May `commands.ts`.
- *
- * Tiered ranking: title-prefix → text-prefix → title-includes →
- * text-includes → acronym → fuzzy-includes. Lower score wins. Ties broken
- * by `browserBindings` array order (the `index` field) so the empty-query
- * palette renders in the keymap's natural order. See #70 design log for
- * why we didn't reach for `fuzzysort`.
- */
-
-import type { AppCommand } from "./types.ts"
-
-const normalize = (text: string): string =>
-	text
-		.toLowerCase()
-		.replace(/[^a-z0-9#]+/g, " ")
-		.trim()
-
-const acronym = (text: string): string =>
-	normalize(text)
-		.split(" ")
-		.filter(Boolean)
-		.map((word) => word[0])
-		.join("")
-
-const fuzzyIncludes = (text: string, query: string): boolean => {
-	let index = 0
-	for (const char of text) {
-		if (char === query[index]) index++
-		if (index >= query.length) return true
-	}
-	return query.length === 0
-}
-
-const searchText = (command: AppCommand): string =>
-	normalize(
-		[command.title, command.category, ...(command.keywords ?? [])]
-			.filter((s): s is string => Boolean(s))
-			.join(" "),
-	)
-
-/** Returns the tier (lower = better) or `null` if the query doesn't match. */
-const score = (command: AppCommand, query: string): number | null => {
-	const q = normalize(query)
-	if (q.length === 0) return 0
-	const title = normalize(command.title)
-	const text = searchText(command)
-	if (title.startsWith(q)) return 0
-	if (text.startsWith(q)) return 1
-	if (title.includes(q)) return 2
-	if (text.includes(q)) return 3
-	if (acronym(command.title).startsWith(q)) return 4
-	if (fuzzyIncludes(text, q.replaceAll(" ", ""))) return 5
-	return null
-}
-
-/**
- * Filter and sort commands against a query. With an empty query, every
- * command tiers to 0 and the original index breaks ties — so the result is
- * the input list in its original order (which v1 uses as `browserBindings`
- * order). See #70 design log §empty-state ordering.
- */
-export const filterCommands = (
-	commands: readonly AppCommand[],
-	query: string,
-): readonly AppCommand[] =>
-	commands
-		.flatMap((command, index) => {
-			const tier = score(command, query)
-			return tier === null ? [] : [{ command, index, tier }]
-		})
-		.sort((a, b) => a.tier - b.tier || a.index - b.index)
-		.map(({ command }) => command)
-
-export const clampSelectedIndex = (index: number, commands: readonly AppCommand[]): number => {
-	if (commands.length === 0) return 0
-	return Math.max(0, Math.min(commands.length - 1, index))
-}

package/src/commands/types.ts

@@ -1,26 +0,0 @@
-/**
- * Palette command shape.
- *
- * Commands are derived at render time from `browserBindings` via the
- * annotation map (`buildCommands.ts`). The `run` field closes over the
- * per-render `BrowserCtx` so dispatching a command is equivalent to firing
- * the corresponding key binding — single source of truth for the action,
- * two surfaces (keymap + palette) that can invoke it.
- *
- * See issue #70 (and its design-log comments) for the rejected alternatives
- * — atom-driven registry (#92), fully hand-written list, fuzzysort dep, etc.
- */
-
-export interface AppCommand {
-	/** Stable id; matches the binding's id for keymap-derived commands. */
-	readonly id: string
-	/** Imperative-phrased label shown in the palette row. */
-	readonly title: string
-	/** Optional category for #91's grouped headers. Carried but unused in v1. */
-	readonly category?: string
-	/** Extra match terms (synonyms, alt phrasings). */
-	readonly keywords?: readonly string[]
-	/** Display-only shortcut hint (first key of the binding, if any). */
-	readonly shortcut?: string
-	readonly run: () => void
-}