codex-configurator 0.2.4 → 0.2.6

package/src/ui/panes/CommandBar.js

@@ -0,0 +1,90 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+
+export const CommandBar = ({
+	appMode,
+	isCommandMode,
+	commandInput,
+	commandMessage,
+	modeHint,
+}) => {
+	const isAutocomplete = isCommandMode && typeof commandInput === 'string';
+	const cleanInput = isAutocomplete
+		? commandInput.replace(/^:/, '').trim().toLowerCase()
+		: '';
+	const isError = Boolean(commandMessage);
+
+	return React.createElement(
+		Box,
+		{
+			paddingX: 1,
+			paddingY: 0,
+			marginTop: 0,
+			minHeight: 1,
+			borderStyle: 'round',
+			borderColor:
+				appMode === 'edit'
+					? 'yellow'
+					: isCommandMode
+						? 'magenta'
+						: 'gray',
+			flexDirection: 'column',
+		},
+		isCommandMode
+			? React.createElement(
+					Box,
+					{ flexDirection: 'row', gap: 1 },
+					React.createElement(
+						Text,
+						{ color: 'yellow', wrap: 'truncate-end', bold: true },
+						`${commandInput || ':'}`,
+						React.createElement(
+							Text,
+							{ color: 'whiteBright' },
+							'█',
+						),
+					),
+					React.createElement(
+						Text,
+						{ color: isError ? 'redBright' : 'gray' },
+						isError ? commandMessage : modeHint || '',
+					),
+				)
+			: React.createElement(
+					Text,
+					{ color: 'gray', wrap: 'truncate-end' },
+					commandMessage || modeHint || '',
+				),
+		isCommandMode
+			? React.createElement(
+					Box,
+					{ flexDirection: 'row', gap: 2, paddingX: 1, marginTop: 0 },
+					...[
+						{ cmd: 'quit', desc: 'exit app' },
+						{ cmd: 'file', desc: 'switch file' },
+						{ cmd: 'filter', desc: 'search' },
+						{ cmd: 'reload', desc: 'refresh' },
+					].map(({ cmd, desc }) => {
+						const matches = cmd.startsWith(cleanInput);
+						return React.createElement(
+							Text,
+							{
+								key: cmd,
+								color:
+									cleanInput && matches
+										? 'cyanBright'
+										: 'gray',
+								bold: cleanInput && matches,
+							},
+							`:${cmd} `,
+							React.createElement(
+								Text,
+								{ color: 'gray', dimColor: true },
+								`${desc}`,
+							),
+						);
+					}),
+				)
+			: null,
+	);
+};

package/src/ui/panes/HelpBubble.js

@@ -0,0 +1,26 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+
+const HINTS = {
+	browse: '↑/↓/PgUp/PgDn navigate • Enter open/edit • Del unset • ←/Backspace parent • :filter • :file • :reload • :quit',
+	edit: '↑/↓/PgUp/PgDn pick • Enter confirm • Esc cancel • Del remove char (text)',
+	filter: 'Type to filter • Enter/Esc done • Del clear last • Ctrl+U clear',
+	'file-switch': '↑/↓ or PgUp/PgDn choose file • Enter switch • Esc cancel',
+	command: 'Quick execute • Esc to cancel',
+};
+
+export const HelpBubble = ({ appMode }) =>
+	React.createElement(
+		Box,
+		{
+			borderStyle: 'round',
+			borderColor: 'blue',
+			paddingX: 1,
+			marginTop: 1,
+		},
+		React.createElement(
+			Text,
+			{ color: 'blue' },
+			HINTS[appMode] || HINTS.browse,
+		),
+	);

package/src/ui/panes/LayoutShell.js

@@ -0,0 +1,17 @@
+import React from 'react';
+import { Box } from 'ink';
+
+export const LayoutShell = ({ children }) =>
+	React.createElement(
+		Box,
+		{
+			flexDirection: 'column',
+			position: 'relative',
+			paddingX: 0,
+			paddingY: 0,
+			gap: 0,
+			width: '100%',
+			height: '100%',
+		},
+		...children,
+	);

package/src/ui/panes/StatusLine.js

@@ -0,0 +1,123 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import { formatActiveFileSummary } from '../../layout.js';
+
+const SEMVER_PREFIX_PATTERN = /^\d+\.\d+\.\d+(?:[-+._][0-9A-Za-z.-]+)*$/;
+const CHECKING_BADGE_TEXT_COLOR = 'white';
+const CHECKING_BADGE_BACKGROUND_COLOR = 'green';
+
+const formatCodexVersion = (version) => {
+	const versionText = String(version || '').trim();
+	if (!versionText) {
+		return '—';
+	}
+
+	return SEMVER_PREFIX_PATTERN.test(versionText)
+		? `v${versionText}`
+		: versionText;
+};
+
+export const StatusLine = ({
+	codexVersion,
+	codexVersionStatus,
+	isSchemaCheckInProgress,
+	schemaCheckStatusText,
+	activeConfigFile,
+	appMode,
+}) => {
+	const codexStatusText = codexVersionStatus || 'Checking Codex version';
+	const schemaStatus =
+		String(schemaCheckStatusText || '').trim() || 'Checking schema';
+	const statusText = codexStatusText;
+	const isUpToDate = !isSchemaCheckInProgress && statusText === 'Up to date';
+	const isCodexChecking =
+		!isSchemaCheckInProgress &&
+		String(statusText).trim() === 'Checking Codex version';
+	const isUpdateAvailable =
+		!isSchemaCheckInProgress &&
+		typeof statusText === 'string' &&
+		statusText.startsWith('Update available');
+	const shouldShowCodexStatus =
+		!isSchemaCheckInProgress && !isUpToDate && !isCodexChecking;
+	const statusPrefix = isUpdateAvailable ? '⚠️ ' : '';
+	const statusTextColor = isUpToDate ? 'white' : 'black';
+	const statusBackgroundColor = isUpToDate ? undefined : 'yellow';
+	const isCheckingLabelVisible = isSchemaCheckInProgress || isCodexChecking;
+	const versionText = isCheckingLabelVisible
+		? ` ${isSchemaCheckInProgress ? schemaStatus : codexStatusText} `
+		: `Using Codex ${formatCodexVersion(codexVersion)}`;
+	const versionTextColor = isCheckingLabelVisible
+		? CHECKING_BADGE_TEXT_COLOR
+		: 'white';
+	const versionTextBackgroundColor = isCheckingLabelVisible
+		? CHECKING_BADGE_BACKGROUND_COLOR
+		: undefined;
+	const codexStatusTextLabel = `${statusText} `;
+	const activeFileSummary = formatActiveFileSummary(activeConfigFile);
+
+	return React.createElement(
+		Box,
+		{
+			paddingX: 1,
+			paddingY: 0,
+			marginTop: 1,
+			flexDirection: 'row',
+			justifyContent: 'space-between',
+			backgroundColor: 'blue',
+			width: '100%',
+		},
+		React.createElement(
+			Box,
+			{ flexDirection: 'row', gap: 2 },
+			React.createElement(
+				Text,
+				{ color: 'white', backgroundColor: 'magenta', bold: true },
+				` ${appMode.toUpperCase()} `,
+			),
+			React.createElement(
+				Text,
+				{ color: 'white', bold: true },
+				`📝 ${activeFileSummary}`,
+			),
+		),
+
+		React.createElement(
+			Box,
+			{ flexDirection: 'row', gap: 2 },
+			React.createElement(
+				Text,
+				{
+					color: versionTextColor,
+					backgroundColor: versionTextBackgroundColor,
+					bold: isCheckingLabelVisible,
+				},
+				versionText,
+			),
+			shouldShowCodexStatus
+				? React.createElement(
+						Box,
+						{ flexDirection: 'row' },
+						statusPrefix
+							? React.createElement(
+									Text,
+									{
+										color: statusTextColor,
+										backgroundColor: statusBackgroundColor,
+									},
+									` ${statusPrefix} `,
+								)
+							: null,
+						React.createElement(
+							Text,
+							{
+								color: statusTextColor,
+								backgroundColor: statusBackgroundColor,
+								bold: true,
+							},
+							codexStatusTextLabel,
+						),
+					)
+				: null,
+		),
+	);
+};

package/src/variantPresets.js

@@ -0,0 +1,268 @@
+const toStringArray = (value) =>
+  Array.isArray(value) ? value.map((item) => String(item)) : [];
+
+const toObject = (value) =>
+  value && typeof value === 'object' && !Array.isArray(value)
+    ? { ...value }
+    : {};
+
+const uniqueScalars = (values) => {
+  const seen = new Set();
+  const ordered = [];
+
+  values.forEach((value) => {
+    const text = String(value);
+    if (seen.has(text)) {
+      return;
+    }
+
+    seen.add(text);
+    ordered.push(text);
+  });
+
+  return ordered;
+};
+
+const normalizeObjectVariant = (variant, index) => ({
+  kind: 'object',
+  id: String(variant?.id || `object_${index + 1}`),
+  label: String(variant?.label || `object_${index + 1}`),
+  requiredKeys: toStringArray(variant?.requiredKeys),
+  fixedValues: toObject(variant?.fixedValues),
+});
+
+const uniquifyPresetLabels = (items) => {
+  const seen = new Map();
+
+  return items.map((item) => {
+    const baseLabel = String(item.label);
+    const occurrence = (seen.get(baseLabel) || 0) + 1;
+    seen.set(baseLabel, occurrence);
+
+    if (occurrence === 1) {
+      return item;
+    }
+
+    return {
+      ...item,
+      label: `${baseLabel} (${occurrence})`,
+    };
+  });
+};
+
+export const isObjectValue = (value) =>
+  value !== null &&
+  typeof value === 'object' &&
+  !Array.isArray(value);
+
+export const objectMatchesVariant = (value, variant) => {
+  if (!isObjectValue(value) || !variant || typeof variant !== 'object') {
+    return false;
+  }
+
+  const fixedValues = toObject(variant.fixedValues);
+  const requiredKeys = toStringArray(variant.requiredKeys);
+  const fixedPairs = Object.entries(fixedValues);
+
+  if (
+    fixedPairs.some(([fixedKey, fixedValue]) => !Object.is(value[fixedKey], fixedValue))
+  ) {
+    return false;
+  }
+
+  return requiredKeys.every((requiredKey) =>
+    Object.prototype.hasOwnProperty.call(value, requiredKey)
+  );
+};
+
+export const buildVariantSelectorOptions = (variantMeta) => {
+  if (!variantMeta || variantMeta.kind !== 'scalar_object') {
+    return [];
+  }
+
+  const scalarOptions = uniqueScalars(toStringArray(variantMeta.scalarOptions));
+  const objectVariants = Array.isArray(variantMeta.objectVariants)
+    ? variantMeta.objectVariants.map(normalizeObjectVariant)
+    : [];
+
+  const rawOptions = [
+    ...scalarOptions.map((value) => ({
+      kind: 'scalar',
+      value,
+      label: value,
+    })),
+    ...objectVariants.map((variant) => ({
+      ...variant,
+      label: `${variant.label} /`,
+    })),
+  ];
+
+  return uniquifyPresetLabels(rawOptions);
+};
+
+const seedObjectVariant = (currentValue, selectedVariant, resolveDefaultValue) => {
+  const seededObject = objectMatchesVariant(currentValue, selectedVariant)
+    ? { ...currentValue }
+    : {};
+  const fixedValues = toObject(selectedVariant.fixedValues);
+  const requiredKeys = toStringArray(selectedVariant.requiredKeys);
+
+  Object.entries(fixedValues).forEach(([fixedKey, fixedValue]) => {
+    seededObject[String(fixedKey)] = fixedValue;
+  });
+
+  requiredKeys.forEach((requiredKey) => {
+    if (Object.prototype.hasOwnProperty.call(seededObject, requiredKey)) {
+      return;
+    }
+
+    seededObject[requiredKey] = resolveDefaultValue(requiredKey);
+  });
+
+  return seededObject;
+};
+
+const shallowObjectEquals = (left, right) => {
+  if (!isObjectValue(left) || !isObjectValue(right)) {
+    return false;
+  }
+
+  const leftKeys = Object.keys(left);
+  const rightKeys = Object.keys(right);
+  if (leftKeys.length !== rightKeys.length) {
+    return false;
+  }
+
+  return leftKeys.every((key) =>
+    Object.prototype.hasOwnProperty.call(right, key) && Object.is(left[key], right[key])
+  );
+};
+
+export const applyVariantSelection = ({
+  currentValue,
+  selectedVariant,
+  resolveDefaultValue,
+}) => {
+  if (!selectedVariant || typeof selectedVariant !== 'object') {
+    return {
+      changed: false,
+      isObjectSelection: false,
+      isObjectVariantSwitch: false,
+      navigateToObject: false,
+      nextValue: currentValue,
+    };
+  }
+
+  if (selectedVariant.kind === 'object') {
+    const resolver = typeof resolveDefaultValue === 'function'
+      ? resolveDefaultValue
+      : () => ({});
+    const nextValue = seedObjectVariant(currentValue, selectedVariant, resolver);
+    const isCurrentObjectValue = isObjectValue(currentValue);
+    const isObjectVariantSwitch =
+      isCurrentObjectValue && !objectMatchesVariant(currentValue, selectedVariant);
+    const changed = !shallowObjectEquals(currentValue, nextValue);
+
+    return {
+      changed,
+      isObjectSelection: true,
+      isObjectVariantSwitch,
+      navigateToObject: true,
+      nextValue,
+    };
+  }
+
+  const nextScalarValue = String(selectedVariant.value);
+  return {
+    changed: isObjectValue(currentValue) || !Object.is(currentValue, nextScalarValue),
+    isObjectSelection: false,
+    isObjectVariantSwitch: false,
+    navigateToObject: false,
+    nextValue: nextScalarValue,
+  };
+};
+
+const asPathSegments = (value) =>
+  Array.isArray(value) ? [...value] : [];
+
+const isContainerValue = (value) =>
+  isObjectValue(value) || Array.isArray(value);
+
+export const resolveObjectVariantNavigationPath = ({
+  basePath,
+  nextValue,
+  preferredKey = null,
+}) => {
+  const normalizedBasePath = asPathSegments(basePath);
+  if (!isObjectValue(nextValue)) {
+    return normalizedBasePath;
+  }
+
+  const preferredSegment = preferredKey === null ? '' : String(preferredKey);
+  if (preferredSegment && Object.prototype.hasOwnProperty.call(nextValue, preferredSegment)) {
+    const preferredValue = nextValue[preferredSegment];
+    if (isContainerValue(preferredValue)) {
+      return [...normalizedBasePath, preferredSegment];
+    }
+  }
+
+  const nestedContainerKeys = Object.keys(nextValue).filter((key) =>
+    isContainerValue(nextValue[key])
+  );
+  if (nestedContainerKeys.length === 1) {
+    return [...normalizedBasePath, nestedContainerKeys[0]];
+  }
+
+  return normalizedBasePath;
+};
+
+const getTopLevelObjectSegments = (variantMeta) => {
+  const fromSchemaPaths = Array.isArray(variantMeta?.objectSchemaPaths)
+    ? variantMeta.objectSchemaPaths
+      .map((path) => String(path || '').split('.')[0])
+      .filter((segment) => segment.length > 0)
+    : [];
+  const fromRequiredKeys = Array.isArray(variantMeta?.objectVariants)
+    ? variantMeta.objectVariants.flatMap((variant) =>
+      Array.isArray(variant?.requiredKeys)
+        ? variant.requiredKeys.map((key) => String(key))
+        : []
+    )
+    : [];
+
+  return new Set([...fromSchemaPaths, ...fromRequiredKeys]);
+};
+
+export const resolveMixedVariantBackNavigationPath = ({
+  pathSegments,
+  resolveVariantMeta,
+}) => {
+  const normalizedPath = asPathSegments(pathSegments);
+  if (normalizedPath.length < 2 || typeof resolveVariantMeta !== 'function') {
+    return null;
+  }
+
+  const parentPath = normalizedPath.slice(0, -1);
+  const parentKey = String(parentPath[parentPath.length - 1] || '');
+  if (!parentKey) {
+    return null;
+  }
+
+  const basePath = parentPath.slice(0, -1);
+  const variantMeta = resolveVariantMeta(basePath, parentKey);
+  if (variantMeta?.kind !== 'scalar_object') {
+    return null;
+  }
+
+  const currentSegment = String(normalizedPath[normalizedPath.length - 1] || '');
+  if (!currentSegment) {
+    return null;
+  }
+
+  const topLevelObjectSegments = getTopLevelObjectSegments(variantMeta);
+  if (!topLevelObjectSegments.has(currentSegment)) {
+    return null;
+  }
+
+  return basePath;
+};