@zakmandhro/bunti 0.1.0

package/src/components/Input.ts

@@ -0,0 +1,124 @@
+import type { BuntiContext } from '../dsl';
+import type { StyleOptions } from '../layout';
+
+export interface InputProps extends StyleOptions {
+  id: string;
+  label?: string;
+  placeholder?: string;
+  value?: string;
+  type?: 'text' | 'password';
+  onChange?: (value: string) => void;
+}
+
+/**
+ * Tactical Input Component
+ * Managed state HOC with cursor simulation, keyboard interception, and mouse focus.
+ */
+export function Input(ctx: BuntiContext, props: InputProps) {
+  const {
+    box,
+    color,
+    focusable,
+    state,
+    useState,
+    offsetX,
+    offsetY,
+    mouseX,
+    mouseY,
+    isMouseDown,
+  } = ctx;
+
+  // 1. Mouse Hit-Testing
+  const _finalLabelLen = props.label ? props.label.length + 1 : 0;
+  const w = props.width || 40;
+  const h = props.height || 3;
+
+  // Calculate absolute coordinates based on parent offsets and current flow cursor
+  // Assuming 100% width, x offset is just parent's offsetX.
+  const absX = offsetX;
+  const absY = offsetY + ctx.cursorY;
+
+  const isHovered =
+    mouseX >= absX &&
+    mouseX < absX + (w as number) &&
+    mouseY >= absY &&
+    mouseY < absY + (h as number);
+
+  // If clicked, force focus state
+  if (isHovered && isMouseDown && state.mouseButton === 0) {
+    state.focusedId = props.id;
+  }
+
+  // 2. Register in the global focus loop
+  const isSelected = focusable(props.id);
+
+  // 3. Manage internal state
+  const [value, setValue] = useState(props.id, props.value || '');
+
+  // 4. Handle Keyboard Interaction (only when focused)
+  if (isSelected && state.lastKey) {
+    const key = state.lastKey;
+
+    if (key === 'backspace') {
+      if (value.length > 0) {
+        const newValue = value.slice(0, -1);
+        setValue(newValue);
+        if (props.onChange) props.onChange(newValue);
+      }
+    } else if (
+      key === 'enter' ||
+      key === 'tab' ||
+      key === 'escape' ||
+      key === 'up' ||
+      key === 'down' ||
+      key === 'left' ||
+      key === 'right'
+    ) {
+      // System keys: ignore
+    } else if (key.length === 1) {
+      // Standard character input
+      const newValue = value + key;
+      setValue(newValue);
+      if (props.onChange) props.onChange(newValue);
+    }
+  }
+
+  // 5. Resolve Theme
+  const neutralGray = { r: 217, g: 216, b: 213 };
+  const borderCol = isSelected ? 'black' : isHovered ? 'ash' : neutralGray;
+  const _bgColor = { r: 255, g: 255, b: 255 };
+  const textColor = 'black';
+
+  // 6. Render
+  return box(
+    {
+      width: w,
+      height: h,
+      border: 'rounded',
+      borderColor: borderCol,
+      padding: [0, 1],
+      align: 'left',
+      valign: 'middle',
+    },
+    ({ text }) => {
+      // Label
+      if (props.label) {
+        text(color.dim(`${props.label} `));
+      }
+
+      // Value Display with simulated cursor
+      if (value.length === 0 && props.placeholder) {
+        text(color.dim(props.placeholder));
+      } else {
+        const displayValue =
+          props.type === 'password' ? '*'.repeat(value.length) : value;
+        text(color.fg(textColor, displayValue));
+      }
+
+      // Cursor (blinking)
+      if (isSelected && ctx.flicker(0.8)) {
+        text(color.black('█'));
+      }
+    },
+  );
+}

package/src/components/index.ts

@@ -0,0 +1,4 @@
+export * from './Button';
+export * from './Card';
+export * from './Header';
+export * from './Input';

package/src/data/glyphs.ts

@@ -0,0 +1,30 @@
+/**
+ * Bunti Curated Glyph Registry (Nerd Font v3)
+ */
+export const GLYPHS: Record<string, string> = {
+  // Languages & Tech
+  js: '\u{E781}', // nf-dev-javascript
+  ts: '\u{E628}', // nf-dev-typescript
+  python: '\u{E73C}', // nf-dev-python
+  rust: '\u{E7A8}', // nf-dev-rust
+  go: '\u{E627}', // nf-dev-go
+  node: '\u{E718}', // nf-dev-nodejs
+  bun: '\u{E22F}', // nf-seti-terminal (best proxy)
+
+  // Git & Source
+  git: '\u{F02A2}', // nf-md-git
+  branch: '\u{E725}', // nf-oct-git_branch
+  commit: '\u{E729}', // nf-oct-git_commit
+  pull: '\u{E728}', // nf-oct-git_pull_request
+  merge: '\u{E727}', // nf-oct-git_merge
+
+  // System & UI
+  folder: '\u{F07B}', // nf-fa-folder
+  file: '\u{F15B}', // nf-fa-file
+  lock: '\u{F023}', // nf-fa-lock
+  search: '\u{F002}', // nf-fa-search
+  settings: '\u{F013}', // nf-fa-cog
+  terminal: '\u{F489}', // nf-oct-terminal
+  heart: '\u{F004}', // nf-fa-heart
+  star: '\u{F005}', // nf-fa-star
+};

package/src/detect.ts

@@ -0,0 +1,60 @@
+/**
+ * Bunti Terminal Capability Detection
+ */
+
+export interface TerminalCapabilities {
+  nerdFont: boolean;
+  glyphProtocol: boolean;
+  unicode: boolean;
+  color: boolean;
+}
+
+/**
+ * Detects terminal capabilities using environment variables and
+ * modern protocol handshakes.
+ */
+export async function detectCapabilities(): Promise<TerminalCapabilities> {
+  const caps: TerminalCapabilities = {
+    nerdFont: false,
+    glyphProtocol: false,
+    unicode: true,
+    color: true,
+  };
+
+  // 1. Environment Variable Heuristics
+  const term = process.env.TERM_PROGRAM || '';
+  const termEmulator = process.env.TERMINAL_EMULATOR || '';
+  const nerdEnv =
+    process.env.NERD_FONTS || process.env.NERD_FONT || process.env.BUNTI_NF;
+
+  // Optimistic list of terminals known to support modern fonts
+  const modernTerms = [
+    'Ghostty',
+    'WezTerm',
+    'iTerm.app',
+    'WarpTerminal',
+    'Apple_Terminal',
+    'vscode',
+    'Hyper',
+    'Rio',
+    'Term7',
+  ];
+
+  if (nerdEnv === '1' || nerdEnv === 'true' || nerdEnv === 'yes') {
+    caps.nerdFont = true;
+  } else if (modernTerms.includes(term) || modernTerms.includes(termEmulator)) {
+    caps.nerdFont = true;
+  } else if (process.env.LC_TERMINAL === 'iTerm2') {
+    caps.nerdFont = true;
+  }
+
+  // 2. Glyph Protocol Handshake (Ghostty 1.3+, Rio, WezTerm)
+  // We send the Support Query and wait briefly for a response.
+  // Note: This is an optimistic check for now, can be expanded to
+  // a full async TTY listener if needed.
+  if (term === 'Ghostty') {
+    caps.glyphProtocol = true;
+  }
+
+  return caps;
+}