shellwise 0.1.0

package/src/tui/components/result-list.ts

@@ -0,0 +1,106 @@
+import { color, icon } from "../theme";
+import { truncate } from "../renderer";
+import type { ScoredResult } from "../../search";
+
+export interface ResultListState {
+  results: ScoredResult[];
+  selectedIndex: number;
+  scrollOffset: number;
+  visibleCount: number;
+}
+
+export function renderResultList(state: ResultListState, width: number): string[] {
+  const lines: string[] = [];
+  const { results, selectedIndex, scrollOffset, visibleCount } = state;
+
+  if (results.length === 0) {
+    lines.push(`${color.dim}  No matches found${color.reset}`);
+    return lines;
+  }
+
+  const end = Math.min(scrollOffset + visibleCount, results.length);
+
+  for (let i = scrollOffset; i < end; i++) {
+    const result = results[i];
+    const isSelected = i === selectedIndex;
+    const prefix = isSelected
+      ? `${color.cyan}${color.bold}${icon.selected} ${color.reset}`
+      : "  ";
+
+    const timeStr = formatTimeAgo(result.lastUsedAt);
+    const freqStr = result.frequency > 1 ? `${color.dim}(${result.frequency}x)${color.reset} ` : "";
+
+    const metaLen = timeStr.length + (result.frequency > 1 ? `(${result.frequency}x) `.length : 0) + 4;
+    const maxCmdWidth = width - metaLen - 2;
+
+    let cmdDisplay: string;
+    if (isSelected) {
+      cmdDisplay = highlightMatches(
+        truncate(result.command, maxCmdWidth),
+        result.matchPositions,
+        `${color.white}${color.bold}`,
+        `${color.yellow}${color.bold}${color.underline}`
+      );
+    } else {
+      cmdDisplay = highlightMatches(
+        truncate(result.command, maxCmdWidth),
+        result.matchPositions,
+        color.white,
+        `${color.cyan}`
+      );
+    }
+
+    const rightSide = `${freqStr}${color.dim}${timeStr}${color.reset}`;
+    const padding = Math.max(0, width - truncate(result.command, maxCmdWidth).length - metaLen - 2);
+
+    lines.push(`${prefix}${cmdDisplay}${" ".repeat(padding)}${rightSide}`);
+  }
+
+  return lines;
+}
+
+function highlightMatches(
+  text: string,
+  positions: number[],
+  normalStyle: string,
+  matchStyle: string
+): string {
+  if (positions.length === 0) return `${normalStyle}${text}${color.reset}`;
+
+  const posSet = new Set(positions);
+  let result = "";
+  let inMatch = false;
+
+  for (let i = 0; i < text.length; i++) {
+    if (posSet.has(i)) {
+      if (!inMatch) {
+        result += matchStyle;
+        inMatch = true;
+      }
+    } else {
+      if (inMatch) {
+        result += color.reset + normalStyle;
+        inMatch = false;
+      }
+    }
+    result += text[i];
+  }
+
+  return `${normalStyle}${result}${color.reset}`;
+}
+
+function formatTimeAgo(timestamp: number): string {
+  const diff = Date.now() - timestamp;
+  const seconds = Math.floor(diff / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  const weeks = Math.floor(days / 7);
+
+  if (seconds < 60) return "just now";
+  if (minutes < 60) return `${minutes}m ago`;
+  if (hours < 24) return `${hours}h ago`;
+  if (days < 7) return `${days}d ago`;
+  if (weeks < 52) return `${weeks}w ago`;
+  return `${Math.floor(days / 365)}y ago`;
+}

package/src/tui/components/search-box.ts

@@ -0,0 +1,20 @@
+import { color, icon } from "../theme";
+import { truncate } from "../renderer";
+
+export interface SearchBoxState {
+  query: string;
+  cursorPos: number;
+}
+
+export function renderSearchBox(state: SearchBoxState, width: number): string {
+  const prefix = `${color.cyan}${color.bold}${icon.prompt} ${color.reset}`;
+  const prefixLen = 2; // "> "
+  const maxQueryWidth = width - prefixLen - 1;
+  const displayQuery = truncate(state.query, maxQueryWidth);
+
+  return `${prefix}${displayQuery}`;
+}
+
+export function getSearchBoxCursorCol(state: SearchBoxState): number {
+  return state.cursorPos + 3; // "> " + 1-based column
+}

package/src/tui/components/status-bar.ts

@@ -0,0 +1,10 @@
+import { color } from "../theme";
+
+export function renderStatusBar(resultCount: number, width: number): string {
+  const left = `${color.dim} ${resultCount} result${resultCount !== 1 ? "s" : ""}`;
+  const right = `Tab/S-Tab:navigate  Enter:select  Esc:cancel ${color.reset}`;
+  const rightClean = `Tab/S-Tab:navigate  Enter:select  Esc:cancel `;
+  const padding = Math.max(0, width - ` ${resultCount} results`.length - rightClean.length);
+
+  return `${left}${" ".repeat(padding)}${right}`;
+}

package/src/tui/input.ts

@@ -0,0 +1,71 @@
+export type KeyEvent =
+  | { type: "char"; char: string }
+  | { type: "special"; key: SpecialKey }
+  | { type: "ctrl"; char: string };
+
+export type SpecialKey =
+  | "up"
+  | "down"
+  | "left"
+  | "right"
+  | "tab"
+  | "shift-tab"
+  | "enter"
+  | "escape"
+  | "backspace"
+  | "delete"
+  | "home"
+  | "end";
+
+export function parseKeypress(data: Buffer): KeyEvent {
+  const str = data.toString("utf-8");
+
+  // Ctrl combinations
+  if (data.length === 1 && data[0] < 32) {
+    const char = data[0];
+    if (char === 13) return { type: "special", key: "enter" };
+    if (char === 9) return { type: "special", key: "tab" };
+    if (char === 27) return { type: "special", key: "escape" };
+    if (char === 127) return { type: "special", key: "backspace" };
+    // Ctrl+A = 1, Ctrl+B = 2, etc.
+    return { type: "ctrl", char: String.fromCharCode(char + 96) };
+  }
+
+  // Escape sequences
+  if (str.startsWith("\x1b[")) {
+    const seq = str.slice(2);
+    if (seq === "A") return { type: "special", key: "up" };
+    if (seq === "B") return { type: "special", key: "down" };
+    if (seq === "C") return { type: "special", key: "right" };
+    if (seq === "D") return { type: "special", key: "left" };
+    if (seq === "H") return { type: "special", key: "home" };
+    if (seq === "F") return { type: "special", key: "end" };
+    if (seq === "Z") return { type: "special", key: "shift-tab" };
+    if (seq === "3~") return { type: "special", key: "delete" };
+  }
+
+  // Escape only
+  if (data.length === 1 && data[0] === 27) {
+    return { type: "special", key: "escape" };
+  }
+
+  // Regular character
+  return { type: "char", char: str };
+}
+
+let originalRawMode: boolean | undefined;
+
+export function enableRawMode(): void {
+  if (process.stdin.isTTY) {
+    originalRawMode = process.stdin.isRaw;
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+  }
+}
+
+export function disableRawMode(): void {
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(originalRawMode ?? false);
+    process.stdin.pause();
+  }
+}

package/src/tui/renderer.ts

@@ -0,0 +1,45 @@
+const ESC = "\x1b[";
+
+export function moveCursorUp(n: number): string {
+  return n > 0 ? `${ESC}${n}A` : "";
+}
+
+export function moveCursorDown(n: number): string {
+  return n > 0 ? `${ESC}${n}B` : "";
+}
+
+export function moveCursorToColumn(col: number): string {
+  return `${ESC}${col}G`;
+}
+
+export function clearLine(): string {
+  return `${ESC}2K`;
+}
+
+export function clearDown(): string {
+  return `${ESC}J`;
+}
+
+export function hideCursor(): string {
+  return `${ESC}?25l`;
+}
+
+export function showCursor(): string {
+  return `${ESC}?25h`;
+}
+
+export function getTerminalSize(): { rows: number; cols: number } {
+  return {
+    rows: process.stdout.rows || 24,
+    cols: process.stdout.columns || 80,
+  };
+}
+
+export function write(text: string): void {
+  process.stderr.write(text);
+}
+
+export function truncate(text: string, maxWidth: number): string {
+  if (text.length <= maxWidth) return text;
+  return text.slice(0, maxWidth - 1) + "…";
+}

package/src/tui/theme.ts

@@ -0,0 +1,34 @@
+const ESC = "\x1b[";
+
+export const color = {
+  reset: `${ESC}0m`,
+  bold: `${ESC}1m`,
+  dim: `${ESC}2m`,
+  italic: `${ESC}3m`,
+  underline: `${ESC}4m`,
+  inverse: `${ESC}7m`,
+
+  // Foreground
+  black: `${ESC}30m`,
+  red: `${ESC}31m`,
+  green: `${ESC}32m`,
+  yellow: `${ESC}33m`,
+  blue: `${ESC}34m`,
+  magenta: `${ESC}35m`,
+  cyan: `${ESC}36m`,
+  white: `${ESC}37m`,
+  gray: `${ESC}90m`,
+
+  // Background
+  bgBlack: `${ESC}40m`,
+  bgBlue: `${ESC}44m`,
+  bgCyan: `${ESC}46m`,
+  bgWhite: `${ESC}47m`,
+  bgGray: `${ESC}100m`,
+} as const;
+
+export const icon = {
+  prompt: ">",
+  selected: ">",
+  dot: "·",
+} as const;

package/src/utils/paths.ts

@@ -0,0 +1,27 @@
+import { homedir } from "os";
+import { join } from "path";
+import { mkdirSync, existsSync } from "fs";
+
+const home = homedir();
+
+export function getDataDir(): string {
+  const xdg = process.env.XDG_DATA_HOME;
+  const dir = xdg ? join(xdg, "shellwise") : join(home, ".local", "share", "shellwise");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 0o700 });
+  return dir;
+}
+
+export function getConfigDir(): string {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  const dir = xdg ? join(xdg, "shellwise") : join(home, ".config", "shellwise");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 0o700 });
+  return dir;
+}
+
+export function getDbPath(): string {
+  return join(getDataDir(), "history.db");
+}
+
+export function getLogPath(): string {
+  return join(getDataDir(), "debug.log");
+}

package/src/utils/platform.ts

@@ -0,0 +1,13 @@
+import { basename } from "path";
+
+export function detectShell(): "zsh" | "bash" | "unknown" {
+  const shell = process.env.SHELL || "";
+  const name = basename(shell);
+  if (name === "zsh") return "zsh";
+  if (name === "bash") return "bash";
+  return "unknown";
+}
+
+export function getHostname(): string {
+  return process.env.HOSTNAME || require("os").hostname();
+}