@dexto/tui 1.6.2

package/dist/hooks/useGitBranch.d.ts

@@ -0,0 +1,13 @@
+/**
+ * useGitBranch Hook
+ *
+ * Detects the current git branch name for the working directory.
+ * Returns undefined if not in a git repository or if git command fails.
+ */
+/**
+ * Hook that returns the current git branch name
+ * @param cwd - Working directory to check (defaults to process.cwd())
+ * @returns Branch name string or undefined if not in git repo or command fails
+ */
+export declare function useGitBranch(cwd?: string): string | undefined;
+//# sourceMappingURL=useGitBranch.d.ts.map

package/dist/hooks/useGitBranch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGitBranch.d.ts","sourceRoot":"","sources":["../../src/hooks/useGitBranch.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAuB7D"}

package/dist/hooks/useGitBranch.js

@@ -0,0 +1,23 @@
+import { useState, useEffect } from "react";
+import { execSync } from "child_process";
+function useGitBranch(cwd) {
+  const [branchName, setBranchName] = useState(void 0);
+  useEffect(() => {
+    const workingDir = cwd || process.cwd();
+    try {
+      const result = execSync("git rev-parse --abbrev-ref HEAD", {
+        cwd: workingDir,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const branch = result.trim();
+      setBranchName(branch || void 0);
+    } catch {
+      setBranchName(void 0);
+    }
+  }, [cwd]);
+  return branchName;
+}
+export {
+  useGitBranch
+};

package/dist/hooks/useHistorySearch.cjs

@@ -0,0 +1,219 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useHistorySearch_exports = {};
+__export(useHistorySearch_exports, {
+  useHistorySearch: () => useHistorySearch
+});
+module.exports = __toCommonJS(useHistorySearch_exports);
+var import_react = require("react");
+function findMatches(history, query) {
+  if (!query) return [];
+  const lowerQuery = query.toLowerCase();
+  return history.filter((item) => item.toLowerCase().includes(lowerQuery)).reverse();
+}
+function useHistorySearch({
+  ui,
+  input,
+  buffer,
+  setUi,
+  setInput
+}) {
+  const { historySearch } = ui;
+  const { history } = input;
+  const matches = (0, import_react.useMemo)(
+    () => findMatches(history, historySearch.query),
+    [history, historySearch.query]
+  );
+  const hasMatch = matches.length > 0;
+  const currentMatch = hasMatch ? matches[Math.min(historySearch.matchIndex, matches.length - 1)] || null : historySearch.lastMatch || null;
+  const enter = (0, import_react.useCallback)(() => {
+    const currentText = buffer.text;
+    setUi((prev) => ({
+      ...prev,
+      historySearch: {
+        isActive: true,
+        query: "",
+        matchIndex: 0,
+        originalInput: currentText,
+        lastMatch: ""
+      }
+    }));
+  }, [buffer, setUi]);
+  const exit = (0, import_react.useCallback)(() => {
+    setUi((prev) => ({
+      ...prev,
+      historySearch: {
+        isActive: false,
+        query: "",
+        matchIndex: 0,
+        originalInput: "",
+        lastMatch: ""
+      }
+    }));
+  }, [setUi]);
+  const cancel = (0, import_react.useCallback)(() => {
+    const originalInput = historySearch.originalInput;
+    buffer.setText(originalInput);
+    setInput((prev) => ({ ...prev, value: originalInput }));
+    exit();
+  }, [historySearch.originalInput, buffer, setInput, exit]);
+  const applyMatch = (0, import_react.useCallback)(
+    (match) => {
+      if (match) {
+        buffer.setText(match);
+        setInput((prev) => ({ ...prev, value: match }));
+      }
+    },
+    [buffer, setInput]
+  );
+  const updateQuery = (0, import_react.useCallback)(
+    (newQuery) => {
+      const newMatches = findMatches(history, newQuery);
+      const newHasMatch = newMatches.length > 0;
+      const newMatch = newHasMatch ? newMatches[0] : null;
+      setUi((prev) => ({
+        ...prev,
+        historySearch: {
+          ...prev.historySearch,
+          query: newQuery,
+          matchIndex: 0,
+          // Update lastMatch only if we have a new match
+          lastMatch: newMatch || prev.historySearch.lastMatch
+        }
+      }));
+      if (newMatch) {
+        applyMatch(newMatch);
+      }
+    },
+    [history, setUi, applyMatch]
+  );
+  const appendToQuery = (0, import_react.useCallback)(
+    (char) => {
+      updateQuery(historySearch.query + char);
+    },
+    [historySearch.query, updateQuery]
+  );
+  const backspace = (0, import_react.useCallback)(() => {
+    if (historySearch.query.length > 0) {
+      updateQuery(historySearch.query.slice(0, -1));
+    }
+  }, [historySearch.query, updateQuery]);
+  const cycleNext = (0, import_react.useCallback)(() => {
+    if (matches.length === 0) return;
+    const newIndex = Math.min(historySearch.matchIndex + 1, matches.length - 1);
+    const newMatch = matches[newIndex];
+    setUi((prev) => ({
+      ...prev,
+      historySearch: {
+        ...prev.historySearch,
+        matchIndex: newIndex,
+        lastMatch: newMatch || prev.historySearch.lastMatch
+      }
+    }));
+    if (newMatch) {
+      applyMatch(newMatch);
+    }
+  }, [matches, historySearch.matchIndex, setUi, applyMatch]);
+  const cyclePrev = (0, import_react.useCallback)(() => {
+    if (matches.length === 0) return;
+    const newIndex = Math.max(0, historySearch.matchIndex - 1);
+    const newMatch = matches[newIndex];
+    setUi((prev) => ({
+      ...prev,
+      historySearch: {
+        ...prev.historySearch,
+        matchIndex: newIndex,
+        lastMatch: newMatch || prev.historySearch.lastMatch
+      }
+    }));
+    if (newMatch) {
+      applyMatch(newMatch);
+    }
+  }, [matches, historySearch.matchIndex, setUi, applyMatch]);
+  const accept = (0, import_react.useCallback)(() => {
+    exit();
+  }, [exit]);
+  const handleKey = (0, import_react.useCallback)(
+    (inputStr, key) => {
+      if (!historySearch.isActive) {
+        if (key.ctrl && inputStr === "r") {
+          enter();
+          return true;
+        }
+        return false;
+      }
+      if (key.ctrl && inputStr === "e") {
+        cyclePrev();
+        return true;
+      }
+      if (key.ctrl && inputStr === "r") {
+        cycleNext();
+        return true;
+      }
+      if (key.return) {
+        accept();
+        return true;
+      }
+      if (key.escape) {
+        cancel();
+        return true;
+      }
+      if (key.backspace || key.delete) {
+        backspace();
+        return true;
+      }
+      if (inputStr && !key.ctrl && !key.meta) {
+        appendToQuery(inputStr);
+        return true;
+      }
+      return true;
+    },
+    [
+      historySearch.isActive,
+      enter,
+      cycleNext,
+      cyclePrev,
+      accept,
+      cancel,
+      backspace,
+      appendToQuery
+    ]
+  );
+  return {
+    isActive: historySearch.isActive,
+    query: historySearch.query,
+    currentMatch,
+    hasMatch,
+    originalInput: historySearch.originalInput,
+    enter,
+    exit,
+    cancel,
+    updateQuery,
+    appendToQuery,
+    backspace,
+    cycleNext,
+    cyclePrev,
+    accept,
+    handleKey
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useHistorySearch
+});

package/dist/hooks/useHistorySearch.d.ts

@@ -0,0 +1,61 @@
+/**
+ * useHistorySearch - Hook for Ctrl+R reverse history search
+ *
+ * Manages search state and provides handlers for search operations.
+ */
+import { type Dispatch, type SetStateAction } from 'react';
+import type { InputState, UIState } from '../state/types.js';
+import type { TextBuffer } from '../components/shared/text-buffer.js';
+interface UseHistorySearchProps {
+    ui: UIState;
+    input: InputState;
+    buffer: TextBuffer;
+    setUi: Dispatch<SetStateAction<UIState>>;
+    setInput: Dispatch<SetStateAction<InputState>>;
+}
+interface UseHistorySearchReturn {
+    /** Whether search mode is active */
+    isActive: boolean;
+    /** Current search query */
+    query: string;
+    /** Current match (or last valid match if no current results) */
+    currentMatch: string | null;
+    /** Whether there's a match for the current query */
+    hasMatch: boolean;
+    /** Original input to potentially restore */
+    originalInput: string;
+    /** Enter search mode */
+    enter: () => void;
+    /** Exit search mode (keep current input) */
+    exit: (showRestoreHint?: boolean) => void;
+    /** Cancel search mode (restore original - used by Escape) */
+    cancel: () => void;
+    /** Update search query */
+    updateQuery: (query: string) => void;
+    /** Add character to query */
+    appendToQuery: (char: string) => void;
+    /** Remove last character from query */
+    backspace: () => void;
+    /** Cycle to next (older) match - Ctrl+R */
+    cycleNext: () => void;
+    /** Cycle to previous (newer) match - Ctrl+Shift+R */
+    cyclePrev: () => void;
+    /** Accept current match (for Enter - also exits search mode) */
+    accept: () => void;
+    /** Handle a keypress - returns true if consumed */
+    handleKey: (inputStr: string, key: {
+        ctrl: boolean;
+        shift: boolean;
+        return: boolean;
+        backspace: boolean;
+        delete: boolean;
+        escape: boolean;
+        meta: boolean;
+    }) => boolean;
+}
+/**
+ * Hook for managing reverse history search
+ */
+export declare function useHistorySearch({ ui, input, buffer, setUi, setInput, }: UseHistorySearchProps): UseHistorySearchReturn;
+export {};
+//# sourceMappingURL=useHistorySearch.d.ts.map

package/dist/hooks/useHistorySearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHistorySearch.d.ts","sourceRoot":"","sources":["../../src/hooks/useHistorySearch.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAwB,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAE,MAAM,OAAO,CAAC;AACjF,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAEtE,UAAU,qBAAqB;IAC3B,EAAE,EAAE,OAAO,CAAC;IACZ,KAAK,EAAE,UAAU,CAAC;IAClB,MAAM,EAAE,UAAU,CAAC;IACnB,KAAK,EAAE,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC;IACzC,QAAQ,EAAE,QAAQ,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC;CAClD;AAED,UAAU,sBAAsB;IAC5B,oCAAoC;IACpC,QAAQ,EAAE,OAAO,CAAC;IAClB,2BAA2B;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,gEAAgE;IAChE,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,oDAAoD;IACpD,QAAQ,EAAE,OAAO,CAAC;IAClB,4CAA4C;IAC5C,aAAa,EAAE,MAAM,CAAC;IACtB,wBAAwB;IACxB,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,4CAA4C;IAC5C,IAAI,EAAE,CAAC,eAAe,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IAC1C,6DAA6D;IAC7D,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,0BAA0B;IAC1B,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,6BAA6B;IAC7B,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACtC,uCAAuC;IACvC,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,2CAA2C;IAC3C,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,qDAAqD;IACrD,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,gEAAgE;IAChE,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,mDAAmD;IACnD,SAAS,EAAE,CACP,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE;QACD,IAAI,EAAE,OAAO,CAAC;QACd,KAAK,EAAE,OAAO,CAAC;QACf,MAAM,EAAE,OAAO,CAAC;QAChB,SAAS,EAAE,OAAO,CAAC;QACnB,MAAM,EAAE,OAAO,CAAC;QAChB,MAAM,EAAE,OAAO,CAAC;QAChB,IAAI,EAAE,OAAO,CAAC;KACjB,KACA,OAAO,CAAC;CAChB;AAWD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,EAC7B,EAAE,EACF,KAAK,EACL,MAAM,EACN,KAAK,EACL,QAAQ,GACX,EAAE,qBAAqB,GAAG,sBAAsB,CAqPhD"}

package/dist/hooks/useHistorySearch.js

@@ -0,0 +1,195 @@
+import { useCallback, useMemo } from "react";
+function findMatches(history, query) {
+  if (!query) return [];
+  const lowerQuery = query.toLowerCase();
+  return history.filter((item) => item.toLowerCase().includes(lowerQuery)).reverse();
+}
+function useHistorySearch({
+  ui,
+  input,
+  buffer,
+  setUi,
+  setInput
+}) {
+  const { historySearch } = ui;
+  const { history } = input;
+  const matches = useMemo(
+    () => findMatches(history, historySearch.query),
+    [history, historySearch.query]
+  );
+  const hasMatch = matches.length > 0;
+  const currentMatch = hasMatch ? matches[Math.min(historySearch.matchIndex, matches.length - 1)] || null : historySearch.lastMatch || null;
+  const enter = useCallback(() => {
+    const currentText = buffer.text;
+    setUi((prev) => ({
+      ...prev,
+      historySearch: {
+        isActive: true,
+        query: "",
+        matchIndex: 0,
+        originalInput: currentText,
+        lastMatch: ""
+      }
+    }));
+  }, [buffer, setUi]);
+  const exit = useCallback(() => {
+    setUi((prev) => ({
+      ...prev,
+      historySearch: {
+        isActive: false,
+        query: "",
+        matchIndex: 0,
+        originalInput: "",
+        lastMatch: ""
+      }
+    }));
+  }, [setUi]);
+  const cancel = useCallback(() => {
+    const originalInput = historySearch.originalInput;
+    buffer.setText(originalInput);
+    setInput((prev) => ({ ...prev, value: originalInput }));
+    exit();
+  }, [historySearch.originalInput, buffer, setInput, exit]);
+  const applyMatch = useCallback(
+    (match) => {
+      if (match) {
+        buffer.setText(match);
+        setInput((prev) => ({ ...prev, value: match }));
+      }
+    },
+    [buffer, setInput]
+  );
+  const updateQuery = useCallback(
+    (newQuery) => {
+      const newMatches = findMatches(history, newQuery);
+      const newHasMatch = newMatches.length > 0;
+      const newMatch = newHasMatch ? newMatches[0] : null;
+      setUi((prev) => ({
+        ...prev,
+        historySearch: {
+          ...prev.historySearch,
+          query: newQuery,
+          matchIndex: 0,
+          // Update lastMatch only if we have a new match
+          lastMatch: newMatch || prev.historySearch.lastMatch
+        }
+      }));
+      if (newMatch) {
+        applyMatch(newMatch);
+      }
+    },
+    [history, setUi, applyMatch]
+  );
+  const appendToQuery = useCallback(
+    (char) => {
+      updateQuery(historySearch.query + char);
+    },
+    [historySearch.query, updateQuery]
+  );
+  const backspace = useCallback(() => {
+    if (historySearch.query.length > 0) {
+      updateQuery(historySearch.query.slice(0, -1));
+    }
+  }, [historySearch.query, updateQuery]);
+  const cycleNext = useCallback(() => {
+    if (matches.length === 0) return;
+    const newIndex = Math.min(historySearch.matchIndex + 1, matches.length - 1);
+    const newMatch = matches[newIndex];
+    setUi((prev) => ({
+      ...prev,
+      historySearch: {
+        ...prev.historySearch,
+        matchIndex: newIndex,
+        lastMatch: newMatch || prev.historySearch.lastMatch
+      }
+    }));
+    if (newMatch) {
+      applyMatch(newMatch);
+    }
+  }, [matches, historySearch.matchIndex, setUi, applyMatch]);
+  const cyclePrev = useCallback(() => {
+    if (matches.length === 0) return;
+    const newIndex = Math.max(0, historySearch.matchIndex - 1);
+    const newMatch = matches[newIndex];
+    setUi((prev) => ({
+      ...prev,
+      historySearch: {
+        ...prev.historySearch,
+        matchIndex: newIndex,
+        lastMatch: newMatch || prev.historySearch.lastMatch
+      }
+    }));
+    if (newMatch) {
+      applyMatch(newMatch);
+    }
+  }, [matches, historySearch.matchIndex, setUi, applyMatch]);
+  const accept = useCallback(() => {
+    exit();
+  }, [exit]);
+  const handleKey = useCallback(
+    (inputStr, key) => {
+      if (!historySearch.isActive) {
+        if (key.ctrl && inputStr === "r") {
+          enter();
+          return true;
+        }
+        return false;
+      }
+      if (key.ctrl && inputStr === "e") {
+        cyclePrev();
+        return true;
+      }
+      if (key.ctrl && inputStr === "r") {
+        cycleNext();
+        return true;
+      }
+      if (key.return) {
+        accept();
+        return true;
+      }
+      if (key.escape) {
+        cancel();
+        return true;
+      }
+      if (key.backspace || key.delete) {
+        backspace();
+        return true;
+      }
+      if (inputStr && !key.ctrl && !key.meta) {
+        appendToQuery(inputStr);
+        return true;
+      }
+      return true;
+    },
+    [
+      historySearch.isActive,
+      enter,
+      cycleNext,
+      cyclePrev,
+      accept,
+      cancel,
+      backspace,
+      appendToQuery
+    ]
+  );
+  return {
+    isActive: historySearch.isActive,
+    query: historySearch.query,
+    currentMatch,
+    hasMatch,
+    originalInput: historySearch.originalInput,
+    enter,
+    exit,
+    cancel,
+    updateQuery,
+    appendToQuery,
+    backspace,
+    cycleNext,
+    cyclePrev,
+    accept,
+    handleKey
+  };
+}
+export {
+  useHistorySearch
+};

package/dist/hooks/useInputHistory.cjs

@@ -0,0 +1,47 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useInputHistory_exports = {};
+__export(useInputHistory_exports, {
+  useInputHistory: () => useInputHistory
+});
+module.exports = __toCommonJS(useInputHistory_exports);
+var import_ink = require("ink");
+function useInputHistory({ inputState, dispatch, isActive }) {
+  (0, import_ink.useInput)(
+    (inputChar, key) => {
+      if (!isActive || inputState.history.length === 0) return;
+      if (key.upArrow) {
+        dispatch({
+          type: "INPUT_HISTORY_NAVIGATE",
+          direction: "up"
+        });
+      } else if (key.downArrow) {
+        dispatch({
+          type: "INPUT_HISTORY_NAVIGATE",
+          direction: "down"
+        });
+      }
+    },
+    { isActive }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useInputHistory
+});

package/dist/hooks/useInputHistory.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Hook for managing input history navigation
+ * Handles keyboard shortcuts for history traversal
+ */
+import type React from 'react';
+import type { CLIAction } from '../state/actions.js';
+import type { InputState } from '../state/types.js';
+interface UseInputHistoryProps {
+    inputState: InputState;
+    dispatch: React.Dispatch<CLIAction>;
+    isActive: boolean;
+}
+/**
+ * Manages input history navigation with arrow keys
+ */
+export declare function useInputHistory({ inputState, dispatch, isActive }: UseInputHistoryProps): void;
+export {};
+//# sourceMappingURL=useInputHistory.d.ts.map

package/dist/hooks/useInputHistory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInputHistory.d.ts","sourceRoot":"","sources":["../../src/hooks/useInputHistory.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,UAAU,oBAAoB;IAC1B,UAAU,EAAE,UAAU,CAAC;IACvB,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;IACpC,QAAQ,EAAE,OAAO,CAAC;CACrB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,oBAAoB,GAAG,IAAI,CAmB9F"}

package/dist/hooks/useInputHistory.js

@@ -0,0 +1,23 @@
+import { useInput } from "ink";
+function useInputHistory({ inputState, dispatch, isActive }) {
+  useInput(
+    (inputChar, key) => {
+      if (!isActive || inputState.history.length === 0) return;
+      if (key.upArrow) {
+        dispatch({
+          type: "INPUT_HISTORY_NAVIGATE",
+          direction: "up"
+        });
+      } else if (key.downArrow) {
+        dispatch({
+          type: "INPUT_HISTORY_NAVIGATE",
+          direction: "down"
+        });
+      }
+    },
+    { isActive }
+  );
+}
+export {
+  useInputHistory
+};