@nmakarov/cli-toolkit 0.7.1 → 0.8.0

package/dist/init.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,6 +30,1091 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/screen/components.ts
+function getScreenWidth(maxWidth = null) {
+  const terminalWidth = process.stdout.columns || 80;
+  const availableWidth = Math.max(20, terminalWidth - 4);
+  return maxWidth ? Math.min(availableWidth, maxWidth) : availableWidth;
+}
+function ScreenContainer({ children }) {
+  const width = getScreenWidth();
+  return (0, import_react.createElement)(import_ink.Box, {
+    flexDirection: "column",
+    marginTop: 1,
+    borderStyle: "single",
+    borderColor: "cyan",
+    paddingX: 1,
+    width
+    // Use the calculated width directly
+  }, children);
+}
+function ScreenRow({ children }) {
+  return (0, import_react.createElement)(import_ink.Box, { flexDirection: "column" }, children);
+}
+function ScreenTitle({ text }) {
+  return (0, import_react.createElement)(
+    ScreenRow,
+    {},
+    (0, import_react.createElement)(import_ink.Text, { bold: true, color: "cyan" }, text)
+  );
+}
+function ScreenDivider({ width }) {
+  const dividerWidth = width || getScreenWidth() - 4;
+  return (0, import_react.createElement)(import_ink.Text, { color: "cyan", dimColor: true }, "\u2500".repeat(dividerWidth));
+}
+function ScreenBody({ children, alignItems = "flex-start" }) {
+  return (0, import_react.createElement)(import_ink.Box, { flexDirection: "column", alignItems }, children);
+}
+function ScreenFooter({ lines, textStyle }) {
+  const defaultTextStyle = {
+    dimColor: true,
+    color: "white"
+  };
+  const finalTextStyle = { ...defaultTextStyle, ...textStyle };
+  const flattenAndWrap = (items, keyPrefix = "") => {
+    const result = [];
+    let keyIndex = 0;
+    items.forEach((item, index) => {
+      if (Array.isArray(item)) {
+        const nested = flattenAndWrap(item, `${keyPrefix}-${index}`);
+        result.push(...nested);
+      } else if (typeof item === "string") {
+        result.push(
+          (0, import_react.createElement)(import_ink.Text, { key: `${keyPrefix}-${keyIndex++}`, ...finalTextStyle }, item)
+        );
+      } else {
+        const element = item;
+        if (element.key === null || element.key === void 0) {
+          result.push(
+            (0, import_react.createElement)(import_ink.Text, { key: `${keyPrefix}-${keyIndex++}`, ...finalTextStyle }, element)
+          );
+        } else {
+          result.push(element);
+        }
+      }
+    });
+    return result;
+  };
+  const wrappedItems = flattenAndWrap(lines);
+  return (0, import_react.createElement)(
+    import_ink.Box,
+    { flexDirection: "column" },
+    (0, import_react.createElement)(import_ink.Box, { flexDirection: "row" }, ...wrappedItems)
+  );
+}
+var import_react, import_ink;
+var init_components = __esm({
+  "src/screen/components.ts"() {
+    "use strict";
+    import_react = require("react");
+    import_ink = require("ink");
+  }
+});
+
+// src/screen/list-components.ts
+function MultiColumnListComponent({ items, ctx, selectedIndexRef }) {
+  const [, forceUpdate] = (0, import_react2.useState)({});
+  const termWidth = (process.stdout.columns || 80) - 8;
+  const maxItemLength = Math.max(...items.map((w) => w.length));
+  const columnWidth = maxItemLength + 3;
+  const columns = Math.max(1, Math.floor(termWidth / columnWidth));
+  const itemsPerColumn = Math.ceil(items.length / columns);
+  (0, import_react2.useEffect)(() => {
+    ctx.setAction("moveUp", () => {
+      selectedIndexRef.current = Math.max(0, selectedIndexRef.current - 1);
+      forceUpdate({});
+    });
+    ctx.setAction("moveDown", () => {
+      selectedIndexRef.current = Math.min(items.length - 1, selectedIndexRef.current + 1);
+      forceUpdate({});
+    });
+    ctx.setAction("moveLeft", () => {
+      if (selectedIndexRef.current === 0) {
+        ctx.goBack();
+      } else {
+        selectedIndexRef.current = Math.max(0, selectedIndexRef.current - itemsPerColumn);
+        forceUpdate({});
+      }
+    });
+    ctx.setAction("moveRight", () => {
+      selectedIndexRef.current = Math.min(items.length - 1, selectedIndexRef.current + itemsPerColumn);
+      forceUpdate({});
+    });
+    ctx.setKeyBinding([
+      { key: "leftArrow", caption: "navigate", action: "moveLeft", order: 0 },
+      { key: "rightArrow", caption: "navigate", action: "moveRight", order: 0 },
+      { key: "upArrow", caption: "navigate", action: "moveUp", order: 0 },
+      { key: "downArrow", caption: "navigate", action: "moveDown", order: 0 }
+    ]);
+    ctx.addFooter(`Total: ${items.length} items`);
+  }, []);
+  const selectedIndex = selectedIndexRef.current;
+  const rows = [];
+  for (let row = 0; row < itemsPerColumn; row++) {
+    const cols = [];
+    for (let col = 0; col < columns; col++) {
+      const index = col * itemsPerColumn + row;
+      if (index < items.length) {
+        const isSelected = index === selectedIndex;
+        cols.push(
+          h2(
+            import_ink2.Box,
+            { key: index, width: columnWidth },
+            h2(import_ink2.Text, {
+              color: isSelected ? "black" : "white",
+              backgroundColor: isSelected ? "cyan" : void 0,
+              bold: isSelected
+            }, items[index].padEnd(maxItemLength))
+          )
+        );
+      }
+    }
+    rows.push(
+      h2(ScreenRow, { key: row, children: h2(import_ink2.Box, { flexDirection: "row" }, ...cols) })
+    );
+  }
+  return h2(import_ink2.Box, { flexDirection: "column" }, ...rows);
+}
+function MultiColumnListWithPreviewComponent({
+  items,
+  getPreviewContent,
+  ctx,
+  selectedIndexRef
+}) {
+  const [, forceUpdate] = (0, import_react2.useState)({});
+  const termWidth = (process.stdout.columns || 80) - 8;
+  const maxItemLength = Math.max(...items.map((w) => w.length));
+  const columnWidth = maxItemLength + 3;
+  const columns = Math.max(1, Math.floor(termWidth / columnWidth));
+  const itemsPerColumn = Math.ceil(items.length / columns);
+  (0, import_react2.useEffect)(() => {
+    ctx.setAction("moveUp", () => {
+      selectedIndexRef.current = Math.max(0, selectedIndexRef.current - 1);
+      forceUpdate({});
+    });
+    ctx.setAction("moveDown", () => {
+      selectedIndexRef.current = Math.min(items.length - 1, selectedIndexRef.current + 1);
+      forceUpdate({});
+    });
+    ctx.setAction("moveLeft", () => {
+      if (selectedIndexRef.current === 0) {
+        ctx.goBack();
+      } else {
+        selectedIndexRef.current = Math.max(0, selectedIndexRef.current - itemsPerColumn);
+        forceUpdate({});
+      }
+    });
+    ctx.setAction("moveRight", () => {
+      selectedIndexRef.current = Math.min(items.length - 1, selectedIndexRef.current + itemsPerColumn);
+      forceUpdate({});
+    });
+    ctx.setKeyBinding([
+      { key: "leftArrow", caption: "navigate", action: "moveLeft", order: 0 },
+      { key: "rightArrow", caption: "navigate", action: "moveRight", order: 0 },
+      { key: "upArrow", caption: "navigate", action: "moveUp", order: 0 },
+      { key: "downArrow", caption: "navigate", action: "moveDown", order: 0 }
+    ]);
+    ctx.addFooter(`Total: ${items.length} items`);
+  }, []);
+  const selectedIndex = selectedIndexRef.current;
+  const selectedItem = items[selectedIndex];
+  const rows = [];
+  for (let row = 0; row < itemsPerColumn; row++) {
+    const cols = [];
+    for (let col = 0; col < columns; col++) {
+      const index = col * itemsPerColumn + row;
+      if (index < items.length) {
+        const isSelected = index === selectedIndex;
+        cols.push(
+          h2(
+            import_ink2.Box,
+            { key: index, width: columnWidth },
+            h2(import_ink2.Text, {
+              color: isSelected ? "black" : "white",
+              backgroundColor: isSelected ? "cyan" : void 0,
+              bold: isSelected
+            }, items[index].padEnd(maxItemLength))
+          )
+        );
+      }
+    }
+    rows.push(
+      h2(ScreenRow, { key: row, children: h2(import_ink2.Box, { flexDirection: "row" }, ...cols) })
+    );
+  }
+  const previewContent = getPreviewContent ? getPreviewContent(selectedItem) : selectedItem;
+  const previewRows = [];
+  if (typeof previewContent === "string") {
+    previewRows.push(h2(ScreenRow, { key: "preview-string", children: h2(import_ink2.Text, { bold: true }, previewContent) }));
+  } else if (typeof previewContent === "object" && !import_react2.default.isValidElement(previewContent) && previewContent !== null) {
+    Object.entries(previewContent).forEach(([key, value], idx) => {
+      previewRows.push(h2(ScreenRow, { key: `preview-${key}-${idx}`, children: h2(import_ink2.Text, {}, `${key}: ${value}`) }));
+    });
+  } else if (import_react2.default.isValidElement(previewContent)) {
+    previewRows.push(h2(ScreenRow, { key: "preview-element", children: previewContent }));
+  }
+  return h2(
+    import_ink2.Box,
+    { flexDirection: "column" },
+    ...rows,
+    h2(ScreenRow, { key: "spacer-1", children: h2(import_ink2.Text, {}, " ") }),
+    h2(ScreenDivider, { key: "divider" }),
+    h2(ScreenRow, { key: "spacer-2", children: h2(import_ink2.Text, {}, " ") }),
+    ...previewRows
+  );
+}
+function ListComponent({ items, ctx, selectedIndexRef, renderItem, getTitle, sortable = false, maxHeight, sortHighlightStyle, selectionMarker = " " }) {
+  const [, forceUpdate] = (0, import_react2.useState)({});
+  const [sortOrder, setSortOrder] = (0, import_react2.useState)("none");
+  const [scrollOffset, setScrollOffset] = (0, import_react2.useState)(0);
+  const scrollStateRef = (0, import_react2.useRef)({ scrollOffset: 0, maxHeight: 0, totalItems: 0 });
+  const defaultGetTitle = (item) => {
+    return getTitle ? getTitle(item) : typeof item.value === "string" ? item.value : item.value?.title || item.name;
+  };
+  const titleGetter = getTitle || defaultGetTitle;
+  const displayItems = sortable && sortOrder !== "none" ? [...items].sort((a, b) => {
+    const titleA = titleGetter(a).toLowerCase();
+    const titleB = titleGetter(b).toLowerCase();
+    if (sortOrder === "asc") {
+      return titleA < titleB ? -1 : titleA > titleB ? 1 : 0;
+    } else {
+      return titleA > titleB ? -1 : titleA < titleB ? 1 : 0;
+    }
+  }) : items;
+  const effectiveMaxHeight = maxHeight || displayItems.length;
+  const canScroll = displayItems.length > effectiveMaxHeight;
+  const maxScrollOffset = Math.max(0, displayItems.length - effectiveMaxHeight);
+  const clampedScrollOffset = Math.min(Math.max(0, scrollOffset), maxScrollOffset);
+  const visibleItems = displayItems.slice(clampedScrollOffset, clampedScrollOffset + effectiveMaxHeight);
+  const canScrollUp = clampedScrollOffset > 0;
+  const canScrollDown = clampedScrollOffset < maxScrollOffset;
+  scrollStateRef.current = { scrollOffset, maxHeight: effectiveMaxHeight, totalItems: displayItems.length };
+  (0, import_react2.useEffect)(() => {
+    ctx.setAction("moveUp", () => {
+      const newIndex = Math.max(0, selectedIndexRef.current - 1);
+      selectedIndexRef.current = newIndex;
+      const { scrollOffset: currentScrollOffset, maxHeight: currentMaxHeight, totalItems } = scrollStateRef.current;
+      const currentMaxScrollOffset = Math.max(0, totalItems - currentMaxHeight);
+      const currentClampedScrollOffset = Math.min(Math.max(0, currentScrollOffset), currentMaxScrollOffset);
+      if (newIndex < currentClampedScrollOffset) {
+        setScrollOffset(newIndex);
+      }
+      forceUpdate({});
+    });
+    ctx.setAction("moveDown", () => {
+      const currentItems = sortable && sortOrder !== "none" ? [...items].sort((a, b) => {
+        const titleA = titleGetter(a).toLowerCase();
+        const titleB = titleGetter(b).toLowerCase();
+        if (sortOrder === "asc") {
+          return titleA < titleB ? -1 : titleA > titleB ? 1 : 0;
+        } else {
+          return titleA > titleB ? -1 : titleA < titleB ? 1 : 0;
+        }
+      }) : items;
+      const maxIndex = currentItems.length - 1;
+      const newIndex = Math.min(maxIndex, selectedIndexRef.current + 1);
+      selectedIndexRef.current = newIndex;
+      const { scrollOffset: currentScrollOffset, maxHeight: currentMaxHeight, totalItems } = scrollStateRef.current;
+      const currentMaxScrollOffset = Math.max(0, totalItems - currentMaxHeight);
+      const currentClampedScrollOffset = Math.min(Math.max(0, currentScrollOffset), currentMaxScrollOffset);
+      if (newIndex >= currentClampedScrollOffset + currentMaxHeight) {
+        setScrollOffset(newIndex - currentMaxHeight + 1);
+      }
+      forceUpdate({});
+    });
+    ctx.setAction("scrollUp", () => {
+      const { scrollOffset: currentScrollOffset, maxHeight: currentMaxHeight, totalItems } = scrollStateRef.current;
+      const currentMaxScrollOffset = Math.max(0, totalItems - currentMaxHeight);
+      const newScrollOffset = Math.max(0, currentScrollOffset - 1);
+      setScrollOffset(newScrollOffset);
+      forceUpdate({});
+    });
+    ctx.setAction("scrollDown", () => {
+      const { scrollOffset: currentScrollOffset, maxHeight: currentMaxHeight, totalItems } = scrollStateRef.current;
+      const currentMaxScrollOffset = Math.max(0, totalItems - currentMaxHeight);
+      const newScrollOffset = Math.min(currentMaxScrollOffset, currentScrollOffset + 1);
+      setScrollOffset(newScrollOffset);
+      forceUpdate({});
+    });
+    if (sortable) {
+      ctx.setAction("toggleSort", () => {
+        const nextSort = sortOrder === "none" ? "asc" : sortOrder === "asc" ? "desc" : "none";
+        const currentSelectedItem = displayItems[selectedIndexRef.current];
+        setSortOrder(nextSort);
+        const newSortedItems = nextSort !== "none" ? [...items].sort((a, b) => {
+          const titleA = titleGetter(a).toLowerCase();
+          const titleB = titleGetter(b).toLowerCase();
+          if (nextSort === "asc") {
+            return titleA < titleB ? -1 : titleA > titleB ? 1 : 0;
+          } else {
+            return titleA > titleB ? -1 : titleA < titleB ? 1 : 0;
+          }
+        }) : items;
+        const newIndex = newSortedItems.findIndex((item) => item === currentSelectedItem);
+        if (newIndex !== -1) {
+          selectedIndexRef.current = newIndex;
+          setScrollOffset(newIndex);
+        } else {
+          selectedIndexRef.current = 0;
+          setScrollOffset(0);
+        }
+        forceUpdate({});
+      });
+      const defaultHighlightStyle = {
+        color: "black",
+        backgroundColor: "green",
+        bold: true
+      };
+      const highlightStyle = { ...defaultHighlightStyle, ...sortHighlightStyle };
+      const sortCaption = () => {
+        if (sortOrder === "none") {
+          return h2(import_ink2.Text, {}, "s to toggle sort");
+        } else {
+          const sortLabel = sortOrder === "asc" ? "ASC" : "DESC";
+          return h2(
+            import_ink2.Text,
+            {},
+            "s to toggle ",
+            h2(import_ink2.Text, { color: "white", bold: true }, "sort"),
+            " ",
+            h2(import_ink2.Text, highlightStyle, ` ${sortLabel} `)
+          );
+        }
+      };
+      ctx.setKeyBinding([
+        { key: "upArrow", caption: "navigate", action: "moveUp", order: 0 },
+        { key: "downArrow", caption: "navigate", action: "moveDown", order: 0 },
+        {
+          key: "s",
+          caption: sortCaption,
+          action: "toggleSort",
+          order: 5
+        }
+      ]);
+      ctx.update();
+    } else {
+      ctx.setKeyBinding([
+        { key: "upArrow", caption: "navigate", action: "moveUp", order: 0 },
+        { key: "downArrow", caption: "navigate", action: "moveDown", order: 0 }
+      ]);
+    }
+  }, [sortOrder, sortable]);
+  const selectedIndex = selectedIndexRef.current;
+  const defaultRenderItem = (item, isSelected, displayIndex, actualIndex) => {
+    const isFirstVisible = displayIndex === 0;
+    const isLastVisible = displayIndex === visibleItems.length - 1;
+    let arrowPrefix = "";
+    let selectionPrefix = "";
+    if (isFirstVisible && canScrollUp) {
+      arrowPrefix = "\u2191 ";
+    } else if (isLastVisible && canScrollDown) {
+      arrowPrefix = "\u2193 ";
+    } else {
+      arrowPrefix = "  ";
+    }
+    if (isSelected) {
+      selectionPrefix = selectionMarker;
+    } else {
+      selectionPrefix = " ".repeat(selectionMarker.length);
+    }
+    return h2(
+      import_ink2.Box,
+      { flexDirection: "row" },
+      // Arrow (clickable if functional, not highlighted)
+      h2(import_ink2.Text, {
+        key: `arrow-${actualIndex}`,
+        color: "white"
+      }, arrowPrefix),
+      // Selection marker space (always same width, not highlighted) 
+      h2(import_ink2.Text, { key: `marker-${actualIndex}`, color: "white" }, selectionPrefix),
+      // Item name (highlighted if selected)
+      h2(import_ink2.Text, {
+        key: `name-${actualIndex}`,
+        color: isSelected ? "black" : "white",
+        backgroundColor: isSelected ? "cyan" : void 0,
+        bold: isSelected
+      }, item.name)
+    );
+  };
+  const itemRenderer = renderItem || defaultRenderItem;
+  return h2(
+    import_ink2.Box,
+    { flexDirection: "column" },
+    ...visibleItems.map((item, displayIndex) => {
+      const actualIndex = clampedScrollOffset + displayIndex;
+      const isSelected = actualIndex === selectedIndex;
+      if (renderItem) {
+        const isFirstVisible = displayIndex === 0;
+        const isLastVisible = displayIndex === visibleItems.length - 1;
+        let arrowPrefix = "";
+        let selectionPrefix = "";
+        if (isFirstVisible && canScrollUp) {
+          arrowPrefix = "\u2191 ";
+        } else if (isLastVisible && canScrollDown) {
+          arrowPrefix = "\u2193 ";
+        } else {
+          arrowPrefix = "  ";
+        }
+        if (isSelected) {
+          selectionPrefix = selectionMarker;
+        } else {
+          selectionPrefix = " ".repeat(selectionMarker.length);
+        }
+        return h2(ScreenRow, {
+          key: `item-${actualIndex}`,
+          children: h2(
+            import_ink2.Box,
+            { flexDirection: "row" },
+            // Arrow (clickable if functional, not highlighted)
+            h2(import_ink2.Text, {
+              key: `arrow-${actualIndex}`,
+              color: "white"
+            }, arrowPrefix),
+            // Selection marker space (always same width, not highlighted) 
+            h2(import_ink2.Text, { key: `marker-${actualIndex}`, color: "white" }, selectionPrefix),
+            // Custom rendered content
+            renderItem(item, isSelected, displayIndex)
+          )
+        });
+      } else {
+        return h2(ScreenRow, {
+          key: `item-${actualIndex}`,
+          children: itemRenderer(item, isSelected, displayIndex, actualIndex)
+        });
+      }
+    })
+  );
+}
+var import_react2, import_ink2, h2;
+var init_list_components = __esm({
+  "src/screen/list-components.ts"() {
+    "use strict";
+    import_react2 = __toESM(require("react"), 1);
+    import_ink2 = require("ink");
+    init_components();
+    h2 = import_react2.createElement;
+  }
+});
+
+// src/screen/screens.ts
+function groupKeyBindings(bindings) {
+  const groups = {};
+  const enabledBindings = bindings.filter((b) => b.enabled !== false);
+  enabledBindings.forEach((binding) => {
+    const caption = typeof binding.caption === "string" ? binding.caption : "";
+    if (!groups[caption]) {
+      groups[caption] = {
+        keys: [],
+        caption,
+        order: binding.order || 999
+      };
+    }
+    groups[caption].keys.push(binding.key);
+  });
+  return Object.values(groups);
+}
+function formatKeyBindings(bindings, mode = "long") {
+  const resolvedBindings = bindings.map((binding) => {
+    let resolvedCaption = binding.caption;
+    if (typeof binding.caption === "function") {
+      resolvedCaption = binding.caption();
+    }
+    return {
+      ...binding,
+      resolvedCaption
+    };
+  });
+  const groups = groupKeyBindings(resolvedBindings.map((b) => ({
+    ...b,
+    caption: typeof b.resolvedCaption === "string" ? b.resolvedCaption : ""
+  })));
+  groups.sort((a, b) => a.order - b.order);
+  const items = [];
+  groups.forEach((group) => {
+    const bindingWithCustom = resolvedBindings.find(
+      (b) => group.keys.includes(b.key) && typeof b.resolvedCaption !== "string"
+    );
+    if (bindingWithCustom && bindingWithCustom.resolvedCaption) {
+      items.push(bindingWithCustom.resolvedCaption);
+    } else {
+      const keyStr = formatKeys(group.keys);
+      if (mode === "long") {
+        items.push(`${keyStr} to ${group.caption}`);
+      } else {
+        items.push(keyStr);
+      }
+    }
+  });
+  return items;
+}
+function formatKeys(keys) {
+  const keyMap = {
+    "escape": "esc",
+    "leftArrow": "\u2190",
+    "rightArrow": "\u2192",
+    "upArrow": "\u2191",
+    "downArrow": "\u2193",
+    "return": "enter"
+  };
+  return keys.map((k) => keyMap[k] || k).join("/");
+}
+async function showScreen(config2) {
+  const {
+    title,
+    onRender,
+    parentData = {}
+  } = config2;
+  return new Promise((resolve2) => {
+    let instance;
+    const keyBindings = [];
+    const actions = {};
+    const customFooterItems = [];
+    let renderResult = null;
+    let initialized = false;
+    const Screen = () => {
+      const [updateCounter, setUpdateCounter] = (0, import_react3.useState)(0);
+      if (!initialized) {
+        const defaultBindings = [
+          { key: "escape", caption: "go back", action: "back", protected: true, order: 1 },
+          { key: "leftArrow", caption: "go back", action: "back", protected: false, order: 1 }
+          // Note: 'select' is not a default - components add it if needed
+        ];
+        defaultBindings.forEach((binding) => {
+          keyBindings.push(binding);
+        });
+        actions.back = () => {
+          cleanup(null);
+        };
+        initialized = true;
+      }
+      const context = {
+        setAction: (actionName, handlerFn) => {
+          actions[actionName] = handlerFn;
+        },
+        setKeyBinding: (bindingOrBindings) => {
+          const bindingsToSet = Array.isArray(bindingOrBindings) ? bindingOrBindings : [bindingOrBindings];
+          bindingsToSet.forEach((binding) => {
+            const existingIndex = keyBindings.findIndex((b) => b.key === binding.key);
+            if (existingIndex >= 0) {
+              const existing = keyBindings[existingIndex];
+              if (existing.protected) {
+                console.warn(`Cannot override protected key: ${binding.key}`);
+                return;
+              }
+              keyBindings[existingIndex] = {
+                ...existing,
+                ...binding,
+                order: binding.order !== void 0 ? binding.order : existing.order,
+                enabled: binding.enabled !== void 0 ? binding.enabled : existing.enabled !== void 0 ? existing.enabled : true
+              };
+            } else {
+              keyBindings.push({
+                protected: false,
+                order: 999,
+                enabled: true,
+                ...binding
+              });
+            }
+          });
+        },
+        updateKeyBinding: (keyName, updates) => {
+          const index = keyBindings.findIndex((b) => b.key === keyName);
+          if (index >= 0) {
+            keyBindings[index] = {
+              ...keyBindings[index],
+              ...updates
+            };
+          }
+        },
+        removeKeyBinding: (keyName) => {
+          const index = keyBindings.findIndex((b) => b.key === keyName);
+          if (index >= 0) {
+            if (keyBindings[index].protected) {
+              console.warn(`Cannot remove protected key: ${keyName}`);
+              return;
+            }
+            keyBindings.splice(index, 1);
+          }
+        },
+        addFooter: (item) => {
+          customFooterItems.push(item);
+        },
+        clearFooter: () => {
+          customFooterItems.length = 0;
+        },
+        setFooter: (items) => {
+          customFooterItems.length = 0;
+          const itemsArray = Array.isArray(items) ? items : [items];
+          customFooterItems.push(...itemsArray);
+        },
+        update: () => {
+          setUpdateCounter((c) => c + 1);
+        },
+        goBack: () => {
+          if (actions.back) {
+            actions.back();
+          }
+        },
+        close: (result) => {
+          cleanup(result);
+        },
+        parentData
+      };
+      if (!renderResult) {
+        renderResult = onRender(context);
+      }
+      (0, import_ink3.useInput)((input, key) => {
+        if (key.ctrl && input === "c") {
+          cleanup(null);
+          process.exit(0);
+          return;
+        }
+        let matchedBinding = null;
+        for (const binding of keyBindings) {
+          let keyMatches = false;
+          if (key[binding.key]) {
+            keyMatches = true;
+          } else if (input === binding.key) {
+            keyMatches = true;
+          }
+          if (keyMatches) {
+            if (binding.enabled === false) {
+              continue;
+            }
+            if (binding.condition && !binding.condition(context)) {
+              continue;
+            }
+            matchedBinding = binding;
+            break;
+          }
+        }
+        if (matchedBinding && actions[matchedBinding.action]) {
+          const actionResult = actions[matchedBinding.action]({
+            input,
+            key,
+            binding: matchedBinding
+          });
+        }
+      });
+      const footerLines = [];
+      const bindingItems = formatKeyBindings(keyBindings, "long");
+      if (bindingItems.length > 0) {
+        const bindingsLine = [];
+        bindingItems.forEach((item, idx) => {
+          if (idx > 0) {
+            bindingsLine.push(", ");
+          }
+          bindingsLine.push(item);
+        });
+        const allStrings = bindingItems.every((item) => typeof item === "string");
+        if (allStrings) {
+          footerLines.push(bindingsLine.join(""));
+        } else {
+          const wrappedBindingsLine = bindingsLine.map(
+            (item) => typeof item === "string" ? (0, import_react3.createElement)(import_ink3.Text, {}, item) : item
+          );
+          footerLines.push(wrappedBindingsLine);
+        }
+      }
+      customFooterItems.forEach((item) => {
+        if (typeof item === "string") {
+          footerLines.push(item);
+        } else {
+          footerLines.push(item);
+        }
+      });
+      return (0, import_react3.createElement)(
+        ScreenContainer,
+        {},
+        (0, import_react3.createElement)(ScreenTitle, { text: title }),
+        (0, import_react3.createElement)(ScreenDivider),
+        (0, import_react3.createElement)(ScreenRow, {}, (0, import_react3.createElement)(import_ink3.Text, {}, " ")),
+        renderResult,
+        (0, import_react3.createElement)(ScreenRow, {}, (0, import_react3.createElement)(import_ink3.Text, {}, " ")),
+        (0, import_react3.createElement)(ScreenDivider),
+        (0, import_react3.createElement)(ScreenFooter, { lines: footerLines })
+      );
+    };
+    const cleanup = (result) => {
+      if (instance) instance.unmount();
+      setTimeout(() => resolve2(result), 50);
+    };
+    instance = (0, import_ink3.render)((0, import_react3.createElement)(Screen));
+  });
+}
+async function showListScreen(config2) {
+  const { title, items, onSelect, onEscape, parentData, initialSelectedIndex = 0, renderItem, getTitle, sortable, maxHeight, sortHighlightStyle, selectionMarker } = config2;
+  return showScreen({
+    title,
+    parentData,
+    onRender: (ctx) => {
+      const selectedIndexRef = { current: initialSelectedIndex };
+      ctx.setAction("select", () => {
+        const selected = items[selectedIndexRef.current];
+        if (onSelect) {
+          const result = onSelect(selected.value, selectedIndexRef.current);
+          ctx.close(result);
+        }
+      });
+      if (onEscape) {
+        ctx.setAction("back", () => {
+          const result = onEscape(selectedIndexRef.current);
+          ctx.close(result);
+        });
+      }
+      ctx.setKeyBinding({ key: "return", caption: "select", action: "select", order: 2 });
+      return (0, import_react3.createElement)(ListComponent, { items, ctx, selectedIndexRef, renderItem, getTitle, sortable, maxHeight, sortHighlightStyle, selectionMarker });
+    }
+  });
+}
+async function showMultiColumnListScreen(config2) {
+  const { title, items, onSelect, onEscape, parentData, initialSelectedIndex = 0 } = config2;
+  return showScreen({
+    title,
+    parentData,
+    onRender: (ctx) => {
+      const selectedIndexRef = { current: initialSelectedIndex };
+      ctx.setAction("select", () => {
+        const selected = items[selectedIndexRef.current];
+        if (onSelect) {
+          const result = onSelect(selected, selectedIndexRef.current);
+          ctx.close(result);
+        }
+      });
+      if (onEscape) {
+        ctx.setAction("back", () => {
+          const result = onEscape(selectedIndexRef.current);
+          ctx.close(result);
+        });
+      }
+      ctx.setKeyBinding({ key: "return", caption: "select", action: "select", order: 2 });
+      return (0, import_react3.createElement)(MultiColumnListComponent, { items, ctx, selectedIndexRef });
+    }
+  });
+}
+async function showMultiColumnListWithPreviewScreen(config2) {
+  const { title, items, getPreviewContent, onSelect, onEscape, parentData, initialSelectedIndex = 0 } = config2;
+  return showScreen({
+    title,
+    parentData,
+    onRender: (ctx) => {
+      const selectedIndexRef = { current: initialSelectedIndex };
+      ctx.setAction("select", () => {
+        const selected = items[selectedIndexRef.current];
+        if (onSelect) {
+          const result = onSelect(selected, selectedIndexRef.current);
+          ctx.close(result);
+        }
+      });
+      if (onEscape) {
+        ctx.setAction("back", () => {
+          const result = onEscape(selectedIndexRef.current);
+          ctx.close(result);
+        });
+      }
+      ctx.setKeyBinding({ key: "return", caption: "select", action: "select", order: 2 });
+      return (0, import_react3.createElement)(MultiColumnListWithPreviewComponent, { items, getPreviewContent, ctx, selectedIndexRef });
+    }
+  });
+}
+var import_react3, import_ink3, showMenuScreen, showWordGridScreen;
+var init_screens = __esm({
+  "src/screen/screens.ts"() {
+    "use strict";
+    import_react3 = require("react");
+    import_ink3 = require("ink");
+    init_components();
+    init_list_components();
+    showMenuScreen = showListScreen;
+    showWordGridScreen = showMultiColumnListScreen;
+  }
+});
+
+// src/screen/ui-elements.ts
+function ListItem({
+  children,
+  isSelected = false,
+  color = "white",
+  backgroundColor,
+  bold = false,
+  dimColor = false
+}) {
+  return (0, import_react4.createElement)(
+    import_ink4.Box,
+    {},
+    (0, import_react4.createElement)(import_ink4.Text, {
+      color: isSelected ? backgroundColor || "green" : color,
+      backgroundColor: isSelected ? color : backgroundColor,
+      bold: isSelected || bold,
+      dimColor: !isSelected && dimColor
+    }, children)
+  );
+}
+function TextBlock({
+  text,
+  color = "white",
+  dimmed = false,
+  bold = false,
+  maxWidth
+}) {
+  return (0, import_react4.createElement)(
+    import_ink4.Box,
+    {},
+    (0, import_react4.createElement)(import_ink4.Text, {
+      color,
+      dimColor: dimmed,
+      bold
+    }, text)
+  );
+}
+function Divider({ character = "\u2500", width = 80 }) {
+  return (0, import_react4.createElement)(
+    import_ink4.Box,
+    { marginY: 1 },
+    (0, import_react4.createElement)(import_ink4.Text, { dimColor: true }, character.repeat(width))
+  );
+}
+function GridCell({
+  children,
+  width,
+  color = "white",
+  backgroundColor,
+  bold = false,
+  dimColor = false,
+  align = "left"
+}) {
+  return (0, import_react4.createElement)(
+    import_ink4.Box,
+    { width },
+    (0, import_react4.createElement)(import_ink4.Text, {
+      color,
+      backgroundColor,
+      bold,
+      dimColor,
+      textAlign: align
+    }, children)
+  );
+}
+function InputField({ prompt, value, onChange, onSubmit }) {
+  return (0, import_react4.createElement)(
+    import_ink4.Box,
+    { flexDirection: "column" },
+    (0, import_react4.createElement)(import_ink4.Text, {}, prompt),
+    (0, import_react4.createElement)(
+      import_ink4.Box,
+      { marginTop: 1 },
+      (0, import_react4.createElement)(import_ink4.Text, { color: "cyan" }, " > ", value, "_")
+    )
+  );
+}
+var import_react4, import_ink4;
+var init_ui_elements = __esm({
+  "src/screen/ui-elements.ts"() {
+    "use strict";
+    import_react4 = require("react");
+    import_ink4 = require("ink");
+  }
+});
+
+// src/screen/utils.ts
+function buildBreadcrumb(parts) {
+  if (parts.length === 0) return "";
+  if (parts.length === 1) return parts[0];
+  return parts.slice(1).map((part) => `\u2190  ${part}`).join("  ");
+}
+function buildDetailBreadcrumb(path, suffix = "") {
+  if (path.length <= 1) {
+    return suffix ? `\u2190  ${suffix}` : path[0] || "";
+  }
+  const breadcrumb = buildBreadcrumb(path);
+  return suffix ? `${breadcrumb} ${suffix}` : breadcrumb;
+}
+var init_utils = __esm({
+  "src/screen/utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/screen/footer-builder.ts
+function buildFooter(config2 = {}) {
+  const {
+    navigation = null,
+    actions = null,
+    info = null,
+    escape = "Esc to go back",
+    custom = null
+  } = config2;
+  const lines = [];
+  const mainParts = [];
+  if (navigation) {
+    mainParts.push(navigation);
+  }
+  if (actions) {
+    mainParts.push(actions);
+  }
+  if (escape) {
+    mainParts.push(escape);
+  }
+  if (mainParts.length > 0) {
+    lines.push(mainParts.join(", "));
+  }
+  if (info) {
+    const infoLines = Array.isArray(info) ? info : [info];
+    lines.push(...infoLines);
+  }
+  if (custom) {
+    const customLines = Array.isArray(custom) ? custom : [custom];
+    lines.push(...customLines);
+  }
+  return lines;
+}
+function organizeFooterMessages(messages) {
+  if (!messages || messages.length === 0) {
+    return ["Esc to go back"];
+  }
+  const navigation = messages.filter((m) => m.includes("\u2191") || m.includes("\u2193") || m.includes("\u2190") || m.includes("\u2192"));
+  const actions = messages.filter((m) => m.includes("Enter") || m.includes("select") || m.includes("submit"));
+  const escape = messages.filter((m) => m.includes("Esc"));
+  const others = messages.filter(
+    (m) => !navigation.includes(m) && !actions.includes(m) && !escape.includes(m)
+  );
+  const lines = [];
+  const mainLine = [...navigation, ...actions, ...escape].join(", ");
+  if (mainLine) lines.push(mainLine);
+  lines.push(...others);
+  return lines;
+}
+var FooterPresets;
+var init_footer_builder = __esm({
+  "src/screen/footer-builder.ts"() {
+    "use strict";
+    FooterPresets = {
+      /**
+       * Menu screen footer
+       */
+      menu: (customInfo = null) => buildFooter({
+        navigation: "\u2191/\u2193 to navigate",
+        actions: "Enter to select",
+        escape: "Esc to go back",
+        info: customInfo
+      }),
+      /**
+       * Word grid footer
+       */
+      wordGrid: (totalWords) => buildFooter({
+        navigation: "\u2191\u2193\u2190\u2192 to navigate",
+        actions: "Enter to select",
+        escape: "Esc to go back",
+        info: `Total: ${totalWords} words`
+      }),
+      /**
+       * Text input footer
+       */
+      textInput: () => buildFooter({
+        actions: "Type and press Enter to submit",
+        escape: "Esc to cancel"
+      }),
+      /**
+       * Info/static screen footer
+       */
+      info: () => buildFooter({
+        escape: "Esc to continue"
+      }),
+      /**
+       * Main menu footer (escape exits)
+       */
+      mainMenu: () => buildFooter({
+        navigation: "\u2191/\u2193 to navigate",
+        actions: "Enter to select",
+        escape: "Esc to exit"
+      }),
+      /**
+       * Action menu footer (for word cards, etc.)
+       */
+      actionMenu: (hasAudio = false) => {
+        const parts = buildFooter({
+          navigation: "\u2191/\u2193 to navigate",
+          actions: "Enter to select",
+          escape: "Esc to go back"
+        });
+        if (hasAudio) {
+          parts.push("Audio available");
+        }
+        return parts;
+      }
+    };
+  }
+});
+
+// src/screen/index.ts
+var screen_exports = {};
+__export(screen_exports, {
+  Box: () => import_ink5.Box,
+  Divider: () => Divider,
+  FooterPresets: () => FooterPresets,
+  GridCell: () => GridCell,
+  InputField: () => InputField,
+  ListComponent: () => ListComponent,
+  ListItem: () => ListItem,
+  MultiColumnListComponent: () => MultiColumnListComponent,
+  MultiColumnListWithPreviewComponent: () => MultiColumnListWithPreviewComponent,
+  React: () => import_react5.default,
+  ScreenBody: () => ScreenBody,
+  ScreenContainer: () => ScreenContainer,
+  ScreenDivider: () => ScreenDivider,
+  ScreenFooter: () => ScreenFooter,
+  ScreenRow: () => ScreenRow,
+  ScreenTitle: () => ScreenTitle,
+  Text: () => import_ink5.Text,
+  TextBlock: () => TextBlock,
+  buildBreadcrumb: () => buildBreadcrumb,
+  buildDetailBreadcrumb: () => buildDetailBreadcrumb,
+  buildFooter: () => buildFooter,
+  h: () => import_react5.createElement,
+  load: () => load,
+  organizeFooterMessages: () => organizeFooterMessages,
+  showListScreen: () => showListScreen,
+  showMenuScreen: () => showMenuScreen,
+  showMultiColumnListScreen: () => showMultiColumnListScreen,
+  showMultiColumnListWithPreviewScreen: () => showMultiColumnListWithPreviewScreen,
+  showScreen: () => showScreen,
+  showWordGridScreen: () => showWordGridScreen,
+  useCallback: () => import_react5.useCallback,
+  useEffect: () => import_react5.useEffect,
+  useInput: () => import_ink5.useInput,
+  useMemo: () => import_react5.useMemo,
+  useRef: () => import_react5.useRef,
+  useState: () => import_react5.useState
+});
+async function load() {
+  if (loadPromise) return loadPromise;
+  loadPromise = Promise.all([
+    import("react"),
+    import("ink")
+  ]).then(() => {
+  });
+  return loadPromise;
+}
+var import_react5, import_ink5, loadPromise;
+var init_screen = __esm({
+  "src/screen/index.ts"() {
+    "use strict";
+    import_react5 = __toESM(require("react"), 1);
+    import_ink5 = require("ink");
+    init_screens();
+    init_list_components();
+    init_components();
+    init_ui_elements();
+    init_utils();
+    init_footer_builder();
+    loadPromise = null;
+    if (typeof window === "undefined") {
+      load().catch(() => {
+      });
+    }
+  }
+});
+
 // src/init.ts
 var init_exports = {};
 __export(init_exports, {
@@ -39,7 +1127,7 @@ module.exports = __toCommonJS(init_exports);
 var import_fs = require("fs");
 var import_path = require("path");
 var import_dotenv = require("dotenv");
-var Args = class {
+var Args = class _Args {
   args = {};
   flags = {};
   options = {};
@@ -54,10 +1142,13 @@ var Args = class {
   configsLoaded = [];
   env = "local";
   constructor(config2 = {}) {
-    this.aliases = config2.aliases || {};
-    this.overrides = config2.overrides || {};
-    this.defaults = config2.defaults || {};
-    this.prefixes = config2.prefixes || ["not", "no"];
+    this.aliases = {};
+    this.overrides = {};
+    this.defaults = {};
+    this.prefixes = ["not", "no"];
+    if (Object.keys(config2).length > 0) {
+      this.configure(config2);
+    }
     const args = config2.args || process.argv.slice(2);
     this.parseArgs(args);
     this.env = this.get("env")?.toLowerCase() || "local";
@@ -65,6 +1156,33 @@ var Args = class {
     this.loadConfigFiles();
     this.checkConflicts();
   }
+  /**
+   * Configure Args options
+   * Only parameters present in config are updated
+   * Note: Args is special - it's initialized first, so it can't take context
+   */
+  configure(config2) {
+    if (config2.aliases !== void 0) {
+      this.aliases = config2.aliases;
+    }
+    if (config2.overrides !== void 0) {
+      this.overrides = config2.overrides;
+    }
+    if (config2.defaults !== void 0) {
+      this.defaults = config2.defaults;
+    }
+    if (config2.prefixes !== void 0) {
+      this.prefixes = config2.prefixes;
+    }
+  }
+  /**
+   * Initialize Args instance
+   * Note: Args is special - it's initialized first, so it can't take context
+   * This static method is for consistency with other components
+   */
+  static init(config2 = {}) {
+    return new _Args(config2);
+  }
   /**
    * Parse command line arguments
    */
@@ -580,18 +1698,76 @@ var joiStringArrayType = (type) => (value, helpers) => {
 };
 
 // src/params/index.ts
-var Params = class {
+var Params = class _Params {
+  context;
+  // Partial context during initialization
   params = {};
   definitions = {};
   args;
   paramSetters = [];
   paramGetters = [];
-  constructor({ args }, opts = {}) {
-    this.args = args;
-    for (const [k, v] of Object.entries(opts)) {
+  trackedParams = [];
+  constructor(context, options = {}) {
+    this.context = context;
+    this.args = context.args;
+    if (Object.keys(options).length > 0) {
+      this.configure(options);
+    }
+  }
+  /**
+   * Configure parameters
+   * Only parameters present in options are updated
+   */
+  configure(options) {
+    for (const [k, v] of Object.entries(options)) {
       this.params[k] = v;
     }
   }
+  /**
+   * Initialize Params from context and CLI parameters
+   * Note: Params is special - it's initialized early with partial context
+   */
+  static init(context, options) {
+    return new _Params(context, options || {});
+  }
+  /**
+   * Track a parameter request for --stopAfter=init feature
+   */
+  trackParam(key, definition, value, source) {
+    this.trackedParams.push({
+      key,
+      definition,
+      value,
+      source
+    });
+  }
+  /**
+   * Get all tracked parameters (for --stopAfter=init)
+   */
+  getTrackedParams() {
+    return [...this.trackedParams];
+  }
+  /**
+   * Get all figured parameters as a record
+   * Returns all parameters that were collected during initialization,
+   * whether from CLI args, options, or defaults
+   */
+  getAllFigured() {
+    const result = {};
+    for (const param of this.trackedParams) {
+      result[param.key] = {
+        value: param.value,
+        source: param.source
+      };
+    }
+    return result;
+  }
+  /**
+   * Clear tracked parameters
+   */
+  clearTrackedParams() {
+    this.trackedParams = [];
+  }
   /**
    * Assign a parameter definition
    */
@@ -665,6 +1841,8 @@ var Params = class {
       type = type.default(defValObj.value);
     } else if (str.match(/required/)) {
       type = type.required();
+    } else {
+      type = type.optional();
     }
     return type;
   }
@@ -672,7 +1850,12 @@ var Params = class {
    * Validate a value against a definition
    */
   validate(key, val, def) {
-    const { value, error } = def.type.validate(val, { context: { params: this.params } });
+    const normalizedVal = val === null ? void 0 : val;
+    const { value, error } = def.type.validate(normalizedVal, {
+      context: { params: this.params },
+      abortEarly: false,
+      allowUnknown: false
+    });
     if (error) {
       const errs = error.details.map((el) => el.message).join(", ");
       throw new ParamError(`"${key}" validation error: ${errs}`);
@@ -690,11 +1873,26 @@ var Params = class {
     }
     const valFromArgs = this.args.get(key);
     const valFromParams = this.params[key];
-    const res = valFromGetters ? this.validate(key, valFromGetters, def) : valFromArgs ? this.validate(key, valFromArgs, def) : this.validate(key, valFromParams, def);
-    if (res !== void 0 && def.values && !def.values.includes(res)) {
+    let source = "default";
+    let value;
+    if (valFromGetters !== void 0 && valFromGetters !== null) {
+      value = this.validate(key, valFromGetters, def);
+      source = "options";
+    } else if (valFromArgs !== void 0 && valFromArgs !== null) {
+      value = this.validate(key, valFromArgs, def);
+      source = "cli";
+    } else if (valFromParams !== void 0 && valFromParams !== null) {
+      value = this.validate(key, valFromParams, def);
+      source = "options";
+    } else {
+      value = this.validate(key, void 0, def);
+      source = "default";
+    }
+    this.trackParam(key, definition || "string", value, source);
+    if (value !== void 0 && def.values && !def.values.includes(value)) {
       throw new ParamError(`key ${key} should be one of ${def.values}`);
     }
-    return res;
+    return value;
   }
   /**
    * Set a parameter value with validation
@@ -728,10 +1926,10 @@ var Params = class {
    * Run all registered getters for a key
    */
   runAllRegisteredGetters(key) {
-    let val = null;
+    let val = void 0;
     for (const getter of this.paramGetters) {
       val = getter(key, this.definitions[key]);
-      if (val !== void 0) {
+      if (val !== void 0 && val !== null) {
         break;
       }
     }
@@ -802,6 +2000,7 @@ var ALL_LEVELS = [
   "response",
   "progress"
 ];
+var MAX_LEVEL_LENGTH = Math.max(...ALL_LEVELS.map((level) => level.toUpperCase().length));
 var LEVEL_COLORS = {
   error: import_chalk.default.red.bold,
   warn: import_chalk.default.rgb(255, 165, 0),
@@ -815,13 +2014,104 @@ var LEVEL_COLORS = {
   progress: import_chalk.default.green,
   results: import_chalk.default.magenta
 };
-var CliToolkitLogger = class {
+var Logger = class _Logger {
+  context;
+  // Partial context during initialization
   options;
   transport;
   startTimes = {};
   lastProgressTimes = {};
-  constructor(options = {}) {
-    this.options = this.normalizeOptions(options);
+  constructor(context, options = {}) {
+    this.context = context;
+    this.options = this.getDefaultOptions();
+    if (options) {
+      this.configure(options);
+    }
+    this.updateTransport();
+  }
+  /**
+   * Configure logger options
+   * Only parameters present in options are updated
+   */
+  configure(options) {
+    if (options.mode !== void 0) {
+      this.options.mode = this.isValidMode(options.mode) ? options.mode : "text";
+    }
+    if (options.route !== void 0) {
+      this.options.route = options.route;
+      this.updateTransport();
+    }
+    if (options.prefix !== void 0) {
+      this.options.prefix = options.prefix;
+    }
+    if (options.silent !== void 0) {
+      this.options.silent = options.silent;
+    }
+    if (options.showLevel !== void 0) {
+      this.options.showLevel = options.showLevel;
+    }
+    if (options.timestamp !== void 0) {
+      this.options.timestamp = options.timestamp;
+    }
+    if (options.levels !== void 0) {
+      this.options.levels = this.normalizeLevels(options.levels);
+    }
+    if (options.progress !== void 0) {
+      if (options.progress.withTimes !== void 0) {
+        this.options.progressTimes = options.progress.withTimes;
+      }
+      if (options.progress.throttleMs !== void 0) {
+        this.options.progressThrottle = options.progress.throttleMs;
+      }
+    }
+  }
+  /**
+   * Initialize logger from context and CLI parameters
+   */
+  static init(context, options) {
+    const paramDefs = {
+      mode: "string default text",
+      route: "string default console",
+      prefix: "string",
+      silent: "boolean default false",
+      showLevel: "boolean default true",
+      timestamp: "boolean default false",
+      levels: "string",
+      progressWithTimes: "boolean default false",
+      progressThrottleMs: "number"
+    };
+    const cliParams = context.params.getAll(paramDefs);
+    const config2 = {
+      mode: options?.mode ?? cliParams.mode,
+      route: options?.route ?? cliParams.route,
+      prefix: options?.prefix ?? cliParams.prefix,
+      silent: options?.silent ?? cliParams.silent,
+      showLevel: options?.showLevel ?? cliParams.showLevel,
+      timestamp: options?.timestamp ?? cliParams.timestamp,
+      levels: options?.levels ?? (cliParams.levels ? cliParams.levels.split(",") : void 0),
+      progress: options?.progress ?? {
+        withTimes: cliParams.progressWithTimes,
+        throttleMs: cliParams.progressThrottleMs
+      }
+    };
+    const logger = new _Logger(context, config2);
+    context.logger = logger;
+    return logger;
+  }
+  getDefaultOptions() {
+    return {
+      mode: "text",
+      route: this.shouldUseIpcRoute() ? "ipc" : "console",
+      prefix: void 0,
+      silent: false,
+      showLevel: true,
+      timestamp: false,
+      levels: ALL_LEVELS,
+      progressTimes: false,
+      progressThrottle: void 0
+    };
+  }
+  updateTransport() {
     this.transport = this.options.route === "ipc" ? new ParentProcessTransport() : new ConsoleTransport();
   }
   setMode(mode) {
@@ -930,7 +2220,7 @@ var CliToolkitLogger = class {
       parts.push(now.toISOString());
     }
     if (this.options.showLevel) {
-      parts.push(struct.level.toUpperCase());
+      parts.push(struct.level.toUpperCase().padEnd(MAX_LEVEL_LENGTH));
     }
     if (struct.level === "progress") {
       if (struct.prefix) {
@@ -964,22 +2254,6 @@ var CliToolkitLogger = class {
   inspectChunks(chunks) {
     return chunks.map((chunk) => import_util.default.inspect(chunk, { colors: true, depth: null })).join(" ");
   }
-  normalizeOptions(options) {
-    const { route, mode, prefix, silent, showLevel, timestamp, levels, progress } = options;
-    const shouldUseIpc = this.shouldUseIpcRoute();
-    const normalized = {
-      mode: this.isValidMode(mode) ? mode : "text",
-      route: route ?? (shouldUseIpc ? "ipc" : "console"),
-      prefix,
-      silent: silent ?? false,
-      showLevel: showLevel ?? true,
-      timestamp: timestamp ?? false,
-      levels: this.normalizeLevels(levels),
-      progressTimes: progress?.withTimes ?? false,
-      progressThrottle: progress?.throttleMs
-    };
-    return normalized;
-  }
   shouldUseIpcRoute() {
     if (process.env.VITEST || process.env.NODE_ENV === "test") {
       return false;
@@ -1010,35 +2284,44 @@ var CliToolkitLogger = class {
 
 // src/init/index.ts
 var import_events = require("events");
+function extractComponentOptions(opts, componentName) {
+  const reservedKeys = ["overrides", "defaults", "modules"];
+  const componentOptions = {};
+  for (const [key, value] of Object.entries(opts)) {
+    if (!reservedKeys.includes(key)) {
+      componentOptions[key] = value;
+    }
+  }
+  return componentOptions;
+}
 function setup(opts = {}) {
-  const args = new Args({
+  const args = Args.init({
     overrides: opts.overrides || {},
     defaults: opts.defaults || {}
   });
-  const params = new Params({ args }, opts.overrides || {});
-  const loggerOptions = opts.logger || {};
-  const logger = new CliToolkitLogger({
-    mode: loggerOptions.mode || "text",
-    route: loggerOptions.route || "console",
-    prefix: loggerOptions.prefix,
-    silent: loggerOptions.silent,
-    showLevel: loggerOptions.showLevel,
-    timestamp: loggerOptions.timestamp,
-    levels: loggerOptions.levels
-  });
-  const cleanupFunctions = [];
-  const context = {
+  const partialContext = {
     args,
-    params,
-    logger,
     emitter: new import_events.EventEmitter(),
     isStop: () => false,
-    // Will be set in init function
-    cleanupFunctions,
+    cleanupFunctions: [],
     registerCleanup: (fn) => {
-      cleanupFunctions.push(fn);
+      partialContext.cleanupFunctions.push(fn);
     }
   };
+  const params = Params.init(partialContext, opts.overrides || {});
+  partialContext.params = params;
+  const loggerOptions = extractComponentOptions(opts, "logger");
+  const logger = Logger.init(partialContext, loggerOptions);
+  partialContext.logger = logger;
+  const context = {
+    args,
+    params,
+    logger,
+    emitter: partialContext.emitter,
+    isStop: partialContext.isStop,
+    cleanupFunctions: partialContext.cleanupFunctions,
+    registerCleanup: partialContext.registerCleanup
+  };
   logger.debug("[setup] completed successfully");
   return context;
 }
@@ -1049,13 +2332,46 @@ async function setupModules(context, opts = {}) {
   context.logger.debug("[setupModules] completed successfully");
   return context;
 }
+function printAllParameters(context) {
+  const trackedParams = context.params.getTrackedParams();
+  console.log("\n=== All Figured Parameters ===");
+  console.log("\nComponent: Logger");
+  const loggerParams = trackedParams.filter(
+    (p) => ["mode", "route", "prefix", "silent", "showLevel", "timestamp", "levels"].includes(p.key)
+  );
+  if (loggerParams.length > 0) {
+    loggerParams.forEach((p) => {
+      console.log(`  ${p.key}: ${JSON.stringify(p.value)} (from ${p.source})`);
+    });
+  } else {
+    console.log("  (no parameters requested)");
+  }
+  console.log("\n=== End Parameters ===\n");
+}
 async function init(flow, opts = {}) {
   let stop = false;
   let context = null;
   try {
+    try {
+      const screenModule = await Promise.resolve().then(() => (init_screen(), screen_exports));
+      if (screenModule && typeof screenModule.load === "function") {
+        await screenModule.load();
+      }
+    } catch {
+      if (typeof require !== "undefined") {
+        try {
+        } catch {
+        }
+      }
+    }
     context = setup(opts);
     context.isStop = () => stop;
     context = await setupModules(context, opts);
+    const stopAfter = context.args.get("stopAfter");
+    if (stopAfter === "init") {
+      printAllParameters(context);
+      process.exit(0);
+    }
     process.on("SIGINT", async () => {
       if (stop) {
         context.logger.warn("[process] killed");
@@ -1073,14 +2389,21 @@ async function init(flow, opts = {}) {
     await flow(context);
   } catch (error) {
     const errorLocation = error instanceof Error && error.stack ? error.stack.split("\n")[1]?.trim() || "Unknown location" : "Unknown location";
+    const logError = (msg, ...args) => {
+      if (context?.logger) {
+        context.logger.error(msg, ...args);
+      } else {
+        console.error(msg, ...args);
+      }
+    };
     if (error instanceof ParamError) {
-      context?.logger.error(`[params]: ${error.message} (${errorLocation})`);
+      logError(`[params]: ${error.message} (${errorLocation})`);
       process.exitCode = 3;
     } else if (error instanceof InitError) {
-      context?.logger.error(`[init]: ${error.message} (${errorLocation})`);
+      logError(`[init]: ${error.message} (${errorLocation})`);
       process.exitCode = 4;
     } else {
-      context?.logger.error(`[other] error:`, error, errorLocation);
+      logError(`[other] error:`, error, errorLocation);
       process.exitCode = 5;
     }
   } finally {