@agents-inc/cli 0.32.1

package/dist/chunk-N6S7ZRIL.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import {
+  init_esm_shims
+} from "./chunk-DHET7RCE.js";
+
+// src/cli/components/common/confirm.tsx
+init_esm_shims();
+import { Box, Text } from "ink";
+import { ConfirmInput } from "@inkjs/ui";
+import { jsx, jsxs } from "react/jsx-runtime";
+var Confirm = ({
+  message,
+  onConfirm,
+  onCancel,
+  defaultValue = false
+}) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+  /* @__PURE__ */ jsx(Text, { children: message }),
+  /* @__PURE__ */ jsx(
+    ConfirmInput,
+    {
+      onConfirm,
+      onCancel,
+      defaultChoice: defaultValue ? "confirm" : "cancel"
+    }
+  )
+] });
+
+export {
+  Confirm
+};
+//# sourceMappingURL=chunk-N6S7ZRIL.js.map

package/dist/chunk-N6S7ZRIL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli/components/common/confirm.tsx"],"sourcesContent":["import React from \"react\";\nimport { Box, Text } from \"ink\";\nimport { ConfirmInput } from \"@inkjs/ui\";\n\ntype ConfirmProps = {\n  message: string;\n  onConfirm: () => void;\n  onCancel: () => void;\n  defaultValue?: boolean;\n};\n\nexport const Confirm: React.FC<ConfirmProps> = ({\n  message,\n  onConfirm,\n  onCancel,\n  defaultValue = false,\n}) => (\n  <Box flexDirection=\"column\">\n    <Text>{message}</Text>\n    <ConfirmInput\n      onConfirm={onConfirm}\n      onCancel={onCancel}\n      defaultChoice={defaultValue ? \"confirm\" : \"cancel\"}\n    />\n  </Box>\n);\n"],"mappings":";;;;;;AAAA;AACA,SAAS,KAAK,YAAY;AAC1B,SAAS,oBAAoB;AAe3B,SACE,KADF;AANK,IAAM,UAAkC,CAAC;AAAA,EAC9C;AAAA,EACA;AAAA,EACA;AAAA,EACA,eAAe;AACjB,MACE,qBAAC,OAAI,eAAc,UACjB;AAAA,sBAAC,QAAM,mBAAQ;AAAA,EACf;AAAA,IAAC;AAAA;AAAA,MACC;AAAA,MACA;AAAA,MACA,eAAe,eAAe,YAAY;AAAA;AAAA,EAC5C;AAAA,GACF;","names":[]}

package/dist/chunk-O4D67NN7.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import {
+  CLI_COLORS
+} from "./chunk-LAPCUV4D.js";
+import {
+  init_esm_shims
+} from "./chunk-DHET7RCE.js";
+
+// src/cli/components/wizard/view-title.tsx
+init_esm_shims();
+import { Text } from "ink";
+import { jsxs } from "react/jsx-runtime";
+var ViewTitle = ({ children }) => {
+  return /* @__PURE__ */ jsxs(Text, { backgroundColor: CLI_COLORS.WARNING, bold: true, color: "#000", children: [
+    " ",
+    children,
+    " "
+  ] });
+};
+
+export {
+  ViewTitle
+};
+//# sourceMappingURL=chunk-O4D67NN7.js.map

package/dist/chunk-O4D67NN7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli/components/wizard/view-title.tsx"],"sourcesContent":["import React from \"react\";\nimport { Text } from \"ink\";\nimport { CLI_COLORS } from \"../../consts.js\";\n\ntype ViewTitleProps = {\n  children: React.ReactNode;\n};\n\nexport const ViewTitle: React.FC<ViewTitleProps> = ({ children }) => {\n  return (\n    <Text backgroundColor={CLI_COLORS.WARNING} bold color=\"#000\">\n      {\" \"}\n      {children}{\" \"}\n    </Text>\n  );\n};\n"],"mappings":";;;;;;;;;AAAA;AACA,SAAS,YAAY;AASjB;AAFG,IAAM,YAAsC,CAAC,EAAE,SAAS,MAAM;AACnE,SACE,qBAAC,QAAK,iBAAiB,WAAW,SAAS,MAAI,MAAC,OAAM,QACnD;AAAA;AAAA,IACA;AAAA,IAAU;AAAA,KACb;AAEJ;","names":[]}

package/dist/chunk-ODUOU55D.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import {
+  getErrorMessage
+} from "./chunk-BZN2Z5P7.js";
+import {
+  init_esm_shims
+} from "./chunk-DHET7RCE.js";
+
+// src/cli/lib/exit-codes.ts
+init_esm_shims();
+var EXIT_CODES = {
+  SUCCESS: 0,
+  ERROR: 1,
+  INVALID_ARGS: 2,
+  NETWORK_ERROR: 3,
+  CANCELLED: 4
+};
+
+// src/cli/base-command.ts
+init_esm_shims();
+import { Command, Flags } from "@oclif/core";
+var BaseCommand = class extends Command {
+  static baseFlags = {
+    "dry-run": Flags.boolean({
+      description: "Preview operations without executing",
+      default: false
+    }),
+    source: Flags.string({
+      char: "s",
+      description: "Skills source path or URL",
+      required: false
+    })
+  };
+  get sourceConfig() {
+    return this.config.sourceConfig;
+  }
+  handleError(error) {
+    const message = getErrorMessage(error);
+    this.error(message, { exit: EXIT_CODES.ERROR });
+  }
+  logSuccess(message) {
+    this.log(`\u2713 ${message}`);
+  }
+  logWarning(message) {
+    this.warn(message);
+  }
+  logInfo(message) {
+    this.log(message);
+  }
+};
+
+export {
+  EXIT_CODES,
+  BaseCommand
+};
+//# sourceMappingURL=chunk-ODUOU55D.js.map

package/dist/chunk-ODUOU55D.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli/lib/exit-codes.ts","../src/cli/base-command.ts"],"sourcesContent":["export const EXIT_CODES = {\n  SUCCESS: 0,\n  ERROR: 1,\n  INVALID_ARGS: 2,\n  NETWORK_ERROR: 3,\n  CANCELLED: 4,\n} as const;\n","import { Command, Flags } from \"@oclif/core\";\nimport { getErrorMessage } from \"./utils/errors.js\";\nimport { EXIT_CODES } from \"./lib/exit-codes.js\";\nimport type { ResolvedConfig } from \"./lib/configuration/index.js\";\n\n/** Narrow interface for the sourceConfig we attach to oclif's Config in the init hook. */\ninterface ConfigWithSource {\n  sourceConfig?: ResolvedConfig;\n}\n\nexport abstract class BaseCommand extends Command {\n  static baseFlags = {\n    \"dry-run\": Flags.boolean({\n      description: \"Preview operations without executing\",\n      default: false,\n    }),\n    source: Flags.string({\n      char: \"s\",\n      description: \"Skills source path or URL\",\n      required: false,\n    }),\n  };\n\n  public get sourceConfig(): ResolvedConfig | undefined {\n    // Boundary cast: oclif Config doesn't declare sourceConfig; we attach it in the init hook\n    return (this.config as unknown as ConfigWithSource).sourceConfig;\n  }\n\n  protected handleError(error: unknown): never {\n    const message = getErrorMessage(error);\n    this.error(message, { exit: EXIT_CODES.ERROR });\n  }\n\n  protected logSuccess(message: string): void {\n    this.log(`✓ ${message}`);\n  }\n\n  protected logWarning(message: string): void {\n    this.warn(message);\n  }\n\n  protected logInfo(message: string): void {\n    this.log(message);\n  }\n}\n"],"mappings":";;;;;;;;;AAAA;AAAO,IAAM,aAAa;AAAA,EACxB,SAAS;AAAA,EACT,OAAO;AAAA,EACP,cAAc;AAAA,EACd,eAAe;AAAA,EACf,WAAW;AACb;;;ACNA;AAAA,SAAS,SAAS,aAAa;AAUxB,IAAe,cAAf,cAAmC,QAAQ;AAAA,EAChD,OAAO,YAAY;AAAA,IACjB,WAAW,MAAM,QAAQ;AAAA,MACvB,aAAa;AAAA,MACb,SAAS;AAAA,IACX,CAAC;AAAA,IACD,QAAQ,MAAM,OAAO;AAAA,MACnB,MAAM;AAAA,MACN,aAAa;AAAA,MACb,UAAU;AAAA,IACZ,CAAC;AAAA,EACH;AAAA,EAEA,IAAW,eAA2C;AAEpD,WAAQ,KAAK,OAAuC;AAAA,EACtD;AAAA,EAEU,YAAY,OAAuB;AAC3C,UAAM,UAAU,gBAAgB,KAAK;AACrC,SAAK,MAAM,SAAS,EAAE,MAAM,WAAW,MAAM,CAAC;AAAA,EAChD;AAAA,EAEU,WAAW,SAAuB;AAC1C,SAAK,IAAI,UAAK,OAAO,EAAE;AAAA,EACzB;AAAA,EAEU,WAAW,SAAuB;AAC1C,SAAK,KAAK,OAAO;AAAA,EACnB;AAAA,EAEU,QAAQ,SAAuB;AACvC,SAAK,IAAI,OAAO;AAAA,EAClB;AACF;","names":[]}

package/dist/chunk-OGJIZ6QH.js

@@ -0,0 +1,497 @@
+#!/usr/bin/env node
+import {
+  useFocusedListItem
+} from "./chunk-DC5AK3LW.js";
+import {
+  CLI_COLORS,
+  SCROLL_VIEWPORT,
+  UI_SYMBOLS
+} from "./chunk-LAPCUV4D.js";
+import {
+  init_esm_shims
+} from "./chunk-DHET7RCE.js";
+
+// src/cli/components/wizard/category-grid.tsx
+init_esm_shims();
+import { useCallback as useCallback2, useMemo as useMemo2 } from "react";
+import { Box, Text } from "ink";
+import { sortBy } from "remeda";
+
+// src/cli/components/hooks/use-virtual-scroll.ts
+init_esm_shims();
+import { useMemo } from "react";
+function computeVirtualScroll({
+  items,
+  availableHeight,
+  focusedIndex,
+  estimateItemHeight,
+  terminalWidth
+}) {
+  const totalItems = items.length;
+  if (totalItems === 0) {
+    return {
+      visibleItems: [],
+      startIndex: 0,
+      endIndex: 0,
+      hiddenAbove: 0,
+      hiddenBelow: 0,
+      isScrollable: false
+    };
+  }
+  const heights = items.map((item) => estimateItemHeight(item, terminalWidth));
+  const totalHeight = heights.reduce((sum, h) => sum + h, 0);
+  if (totalHeight <= availableHeight) {
+    return {
+      visibleItems: items,
+      startIndex: 0,
+      endIndex: totalItems,
+      hiddenAbove: 0,
+      hiddenBelow: 0,
+      isScrollable: false
+    };
+  }
+  const viewportHeight = Math.max(
+    SCROLL_VIEWPORT.MIN_VIEWPORT_ROWS,
+    availableHeight - SCROLL_VIEWPORT.SCROLL_INDICATOR_HEIGHT * 2
+  );
+  const safeFocused = Math.max(0, Math.min(focusedIndex, totalItems - 1));
+  let startIndex = safeFocused;
+  let endIndex = safeFocused + 1;
+  let usedHeight = heights[safeFocused] ?? 0;
+  while (endIndex < totalItems) {
+    const nextHeight = heights[endIndex] ?? 0;
+    if (usedHeight + nextHeight > viewportHeight) break;
+    usedHeight += nextHeight;
+    endIndex++;
+  }
+  while (startIndex > 0) {
+    const prevHeight = heights[startIndex - 1] ?? 0;
+    if (usedHeight + prevHeight > viewportHeight) break;
+    usedHeight += prevHeight;
+    startIndex--;
+  }
+  while (endIndex < totalItems) {
+    const nextHeight = heights[endIndex] ?? 0;
+    if (usedHeight + nextHeight > viewportHeight) break;
+    usedHeight += nextHeight;
+    endIndex++;
+  }
+  return {
+    visibleItems: items.slice(startIndex, endIndex),
+    startIndex,
+    endIndex,
+    hiddenAbove: startIndex,
+    hiddenBelow: totalItems - endIndex,
+    isScrollable: true
+  };
+}
+function useVirtualScroll(options) {
+  const { items, availableHeight, focusedIndex, estimateItemHeight, terminalWidth } = options;
+  return useMemo(
+    () => computeVirtualScroll(options),
+    [items, availableHeight, focusedIndex, estimateItemHeight, terminalWidth]
+  );
+}
+
+// src/cli/components/hooks/use-category-grid-input.ts
+init_esm_shims();
+import { useCallback, useEffect } from "react";
+import { useInput } from "ink";
+var FRAMEWORK_CATEGORY_ID = "framework";
+var isSectionLocked = (categoryId, categories) => {
+  if (categoryId === FRAMEWORK_CATEGORY_ID) {
+    return false;
+  }
+  const frameworkCategory = categories.find((cat) => cat.id === FRAMEWORK_CATEGORY_ID);
+  if (!frameworkCategory) return false;
+  return !frameworkCategory.options.some((opt) => opt.selected);
+};
+var findValidStartColumn = (options) => {
+  for (let i = 0; i < options.length; i++) {
+    if (options[i] && options[i].state !== "disabled") {
+      return i;
+    }
+  }
+  return 0;
+};
+var findNextUnlockedIndex = (processed, currentIndex, allCategories) => {
+  const length = processed.length;
+  if (length === 0) return currentIndex;
+  let index = currentIndex;
+  let attempts = 0;
+  while (attempts < length) {
+    index += 1;
+    if (index >= length) index = 0;
+    const category = processed[index];
+    if (category && !isSectionLocked(category.id, allCategories)) {
+      return index;
+    }
+    attempts++;
+  }
+  return currentIndex;
+};
+function useCategoryGridInput({
+  processedCategories,
+  categories,
+  focusedRow,
+  focusedCol,
+  setFocused,
+  moveFocus,
+  onToggle,
+  onToggleDescriptions
+}) {
+  const currentRow = processedCategories[focusedRow];
+  const currentOptions = currentRow?.sortedOptions || [];
+  const currentLocked = currentRow ? isSectionLocked(currentRow.id, categories) : false;
+  useEffect(() => {
+    if (!currentRow) return;
+    const maxCol = currentOptions.length - 1;
+    if (focusedCol > maxCol) {
+      const newCol = Math.max(0, maxCol);
+      setFocused(focusedRow, newCol);
+    } else if (currentOptions[focusedCol]?.state === "disabled") {
+      const validCol = findValidStartColumn(currentOptions);
+      if (validCol !== focusedCol) {
+        setFocused(focusedRow, validCol);
+      }
+    }
+  }, [focusedRow, currentOptions, focusedCol, setFocused, currentRow]);
+  useEffect(() => {
+    if (currentRow && currentLocked) {
+      const nextUnlocked = findNextUnlockedIndex(processedCategories, focusedRow, categories);
+      if (nextUnlocked !== focusedRow) {
+        const newRowOptions = processedCategories[nextUnlocked]?.sortedOptions || [];
+        const newCol = findValidStartColumn(newRowOptions);
+        setFocused(nextUnlocked, newCol);
+      }
+    }
+  }, [currentRow, currentLocked, focusedRow, processedCategories, categories, setFocused]);
+  useInput(
+    useCallback(
+      (input, key) => {
+        if (key.tab && key.shift) {
+          onToggleDescriptions();
+          return;
+        }
+        if (key.tab && !key.shift) {
+          const nextSection = findNextUnlockedIndex(processedCategories, focusedRow, categories);
+          if (nextSection !== focusedRow) {
+            const newRowOptions = processedCategories[nextSection]?.sortedOptions || [];
+            const newCol = findValidStartColumn(newRowOptions);
+            setFocused(nextSection, newCol);
+          }
+          return;
+        }
+        if (input === "d" || input === "D") {
+          onToggleDescriptions();
+          return;
+        }
+        if (input === " ") {
+          if (currentLocked) return;
+          const currentOption = currentOptions[focusedCol];
+          if (currentOption && currentOption.state !== "disabled") {
+            onToggle(currentRow.id, currentOption.id);
+          }
+          return;
+        }
+        const isLeft = key.leftArrow || input === "h";
+        const isRight = key.rightArrow || input === "l";
+        const isUp = key.upArrow || input === "k";
+        const isDown = key.downArrow || input === "j";
+        if (isLeft) {
+          if (currentLocked) return;
+          moveFocus("left");
+        } else if (isRight) {
+          if (currentLocked) return;
+          moveFocus("right");
+        } else if (isUp) {
+          moveFocus("up");
+        } else if (isDown) {
+          moveFocus("down");
+        }
+      },
+      [
+        focusedRow,
+        focusedCol,
+        currentOptions,
+        currentRow,
+        currentLocked,
+        processedCategories,
+        categories,
+        onToggle,
+        onToggleDescriptions,
+        setFocused,
+        moveFocus
+      ]
+    )
+  );
+}
+
+// src/cli/components/wizard/category-grid.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var SYMBOL_REQUIRED = "*";
+var sortOptions = (options, expertMode) => {
+  if (expertMode) {
+    return options;
+  }
+  const stateOrder = {
+    recommended: 0,
+    normal: 1,
+    discouraged: 2,
+    disabled: 3
+  };
+  return sortBy([...options], (o) => stateOrder[o.state]);
+};
+var findNextValidOption = (options, currentIndex, direction, wrap = true) => {
+  const length = options.length;
+  if (length === 0) return currentIndex;
+  let index = currentIndex;
+  let attempts = 0;
+  while (attempts < length) {
+    index += direction;
+    if (wrap) {
+      if (index < 0) index = length - 1;
+      if (index >= length) index = 0;
+    } else {
+      if (index < 0) index = 0;
+      if (index >= length) index = length - 1;
+    }
+    if (options[index] && options[index].state !== "disabled") {
+      return index;
+    }
+    attempts++;
+  }
+  return currentIndex;
+};
+var getStateSuffix = (state, isLocked) => {
+  if (isLocked || state === "disabled") return "(disabled)";
+  if (state === "recommended") return "(recommended)";
+  if (state === "discouraged") return "(discouraged)";
+  return null;
+};
+var getStateSymbol = (option, isLocked) => {
+  if (isLocked || option.state === "disabled") return UI_SYMBOLS.DISABLED;
+  if (option.selected) return UI_SYMBOLS.SELECTED;
+  if (option.state === "discouraged") return UI_SYMBOLS.DISCOURAGED;
+  return UI_SYMBOLS.UNSELECTED;
+};
+var SkillTag = ({ option, isFocused, isLocked }) => {
+  const getColor = () => {
+    if (isLocked || option.state === "disabled") {
+      return {
+        text: CLI_COLORS.NEUTRAL,
+        border: CLI_COLORS.NEUTRAL
+      };
+    }
+    if (option.selected) {
+      return {
+        text: CLI_COLORS.PRIMARY,
+        border: CLI_COLORS.PRIMARY
+      };
+    }
+    if (option.state === "recommended") {
+      return {
+        text: CLI_COLORS.UNFOCUSED,
+        border: CLI_COLORS.NEUTRAL
+      };
+    }
+    if (option.state === "discouraged") {
+      return {
+        text: CLI_COLORS.WARNING,
+        border: CLI_COLORS.WARNING
+      };
+    }
+    return {
+      text: CLI_COLORS.NEUTRAL,
+      border: CLI_COLORS.NEUTRAL
+    };
+  };
+  const isBold = isFocused || option.selected;
+  const isDimmed = isLocked || option.state === "disabled";
+  const isBorderDimmed = isDimmed || !option.selected && !isFocused;
+  const focusBorderColor = option.selected ? CLI_COLORS.PRIMARY : CLI_COLORS.UNFOCUSED;
+  const colors = getColor();
+  const stateSuffix = getStateSuffix(option.state, isLocked);
+  const stateSymbol = getStateSymbol(option, isLocked);
+  return /* @__PURE__ */ jsx(
+    Box,
+    {
+      marginRight: 1,
+      borderColor: isFocused ? focusBorderColor : colors.border,
+      borderStyle: "single",
+      borderDimColor: isBorderDimmed,
+      children: /* @__PURE__ */ jsxs(Text, { color: colors.text, bold: isBold, dimColor: false, children: [
+        " ",
+        option.local && /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(Text, { backgroundColor: CLI_COLORS.NEUTRAL, children: " L " }),
+          " "
+        ] }),
+        option.installed && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          UI_SYMBOLS.SELECTED,
+          " "
+        ] }),
+        !option.installed && /* @__PURE__ */ jsxs(Text, { dimColor: isDimmed, children: [
+          stateSymbol,
+          " "
+        ] }),
+        option.label,
+        stateSuffix && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          " ",
+          stateSuffix
+        ] }),
+        " "
+      ] })
+    }
+  );
+};
+var CategorySection = ({
+  category,
+  options,
+  isLocked,
+  isFocused,
+  focusedOptionIndex,
+  showDescriptions
+}) => {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: isLocked, children: category.displayName }),
+      category.required && /* @__PURE__ */ jsxs(Text, { color: isLocked ? CLI_COLORS.NEUTRAL : CLI_COLORS.ERROR, dimColor: isLocked, children: [
+        " ",
+        SYMBOL_REQUIRED
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { flexDirection: "row", flexWrap: "wrap", marginTop: 0, children: options.map((option, index) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(
+        SkillTag,
+        {
+          option,
+          isFocused: isFocused && index === focusedOptionIndex && !isLocked,
+          isLocked
+        }
+      ),
+      showDescriptions && option.stateReason && !isLocked && /* @__PURE__ */ jsx(Box, { marginLeft: 1, marginBottom: 0, children: /* @__PURE__ */ jsx(Text, { dimColor: true, wrap: "truncate-end", children: option.stateReason }) })
+    ] }, option.id)) })
+  ] });
+};
+var estimateCategoryHeight = (category, terminalWidth) => {
+  const { CATEGORY_NAME_LINES, AVG_TAG_WIDTH, CATEGORY_MARGIN_LINES } = SCROLL_VIEWPORT;
+  const optionCount = category.sortedOptions.length;
+  const tagsPerRow = Math.max(1, Math.floor(terminalWidth / AVG_TAG_WIDTH));
+  const tagRows = Math.ceil(optionCount / tagsPerRow);
+  return CATEGORY_NAME_LINES + tagRows + CATEGORY_MARGIN_LINES;
+};
+var ScrollIndicator = ({ count, direction }) => {
+  if (count === 0) return null;
+  const arrow = direction === "above" ? UI_SYMBOLS.SCROLL_UP : UI_SYMBOLS.SCROLL_DOWN;
+  const label = `${arrow} ${count} more ${count === 1 ? "category" : "categories"} ${direction}`;
+  return /* @__PURE__ */ jsx(Box, { paddingLeft: 1, marginTop: direction === "below" ? 1 : 0, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: label }) });
+};
+var DEFAULT_TERMINAL_WIDTH = 80;
+var CategoryGrid = ({
+  categories,
+  showDescriptions,
+  expertMode,
+  onToggle,
+  onToggleDescriptions,
+  defaultFocusedRow = 0,
+  defaultFocusedCol = 0,
+  onFocusChange,
+  availableHeight,
+  terminalWidth
+}) => {
+  const processedCategories = useMemo2(
+    () => categories.map((category) => ({
+      ...category,
+      sortedOptions: sortOptions(category.options, expertMode)
+    })),
+    [categories, expertMode]
+  );
+  const getColCount = useCallback2(
+    (row) => processedCategories[row]?.sortedOptions.length ?? 0,
+    [processedCategories]
+  );
+  const isRowLocked = useCallback2(
+    (row) => {
+      const cat = processedCategories[row];
+      return cat ? isSectionLocked(cat.id, categories) : false;
+    },
+    [processedCategories, categories]
+  );
+  const findValidCol = useCallback2(
+    (row, currentCol, direction) => {
+      const options = processedCategories[row]?.sortedOptions || [];
+      const catId = processedCategories[row]?.id;
+      if (catId && isSectionLocked(catId, categories)) return currentCol;
+      return findNextValidOption(options, currentCol, direction, true);
+    },
+    [processedCategories, categories]
+  );
+  const adjustCol = useCallback2(
+    (row, clampedCol) => {
+      const options = processedCategories[row]?.sortedOptions || [];
+      if (options[clampedCol]?.state === "disabled") {
+        return findValidStartColumn(options);
+      }
+      return clampedCol;
+    },
+    [processedCategories]
+  );
+  const { focusedRow, focusedCol, setFocused, moveFocus } = useFocusedListItem(
+    processedCategories.length,
+    getColCount,
+    {
+      wrap: true,
+      isRowLocked,
+      findValidCol,
+      adjustCol,
+      onChange: onFocusChange,
+      initialRow: defaultFocusedRow,
+      initialCol: defaultFocusedCol
+    }
+  );
+  useCategoryGridInput({
+    processedCategories,
+    categories,
+    focusedRow,
+    focusedCol,
+    setFocused,
+    moveFocus,
+    onToggle,
+    onToggleDescriptions
+  });
+  const { visibleItems, startIndex, hiddenAbove, hiddenBelow, isScrollable } = useVirtualScroll({
+    items: processedCategories,
+    availableHeight: availableHeight ?? Infinity,
+    focusedIndex: focusedRow,
+    estimateItemHeight: estimateCategoryHeight,
+    terminalWidth: terminalWidth ?? DEFAULT_TERMINAL_WIDTH
+  });
+  if (categories.length === 0) {
+    return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "No categories to display." }) });
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    isScrollable && /* @__PURE__ */ jsx(ScrollIndicator, { count: hiddenAbove, direction: "above" }),
+    visibleItems.map((category, visibleIndex) => {
+      const originalIndex = startIndex + visibleIndex;
+      const isLocked = isSectionLocked(category.id, categories);
+      return /* @__PURE__ */ jsx(
+        CategorySection,
+        {
+          category,
+          options: category.sortedOptions,
+          isLocked,
+          isFocused: originalIndex === focusedRow,
+          focusedOptionIndex: focusedCol,
+          showDescriptions
+        },
+        category.id
+      );
+    }),
+    isScrollable && /* @__PURE__ */ jsx(ScrollIndicator, { count: hiddenBelow, direction: "below" })
+  ] });
+};
+
+export {
+  CategoryGrid
+};
+//# sourceMappingURL=chunk-OGJIZ6QH.js.map