@next-vibe/checker 1.0.11 → 1.0.12

package/src/app/api/[locale]/system/unified-interface/shared/field-config/endpoint-field-types.ts

@@ -0,0 +1,107 @@
+/**
+ * Type utilities for extracting field names and types from endpoint definitions
+ * Provides full type inference from definition.POST.fields to form components
+ */
+
+import type { Countries } from "@/i18n/core/config";
+
+import type { PrefillDisplayConfig } from "./field-config-types";
+
+/**
+ * Type for endpoint field structure from unified interface
+ * This matches the structure created by objectField() in endpoint definitions
+ */
+
+export interface EndpointFieldStructure {
+  type?: string;
+  children?: Record<string, EndpointFieldStructure>;
+  // Union-specific fields
+  discriminator?: string;
+  variants?: readonly EndpointFieldStructure[];
+  ui?: {
+    type: string;
+    fieldType?: string;
+    label?: string;
+    placeholder?: string;
+    description?: string;
+    disabled?: boolean;
+    className?: string;
+    defaultCountry?: Countries;
+    preferredCountries?: Countries[];
+    min?: number;
+    max?: number;
+    step?: number;
+    minDate?: Date;
+    maxDate?: Date;
+    rows?: number;
+    maxLength?: number;
+    options?: Array<{
+      value: string | number;
+      label: string;
+      labelParams?: Record<string, string | number>;
+      disabled?: boolean;
+      icon?: string;
+    }>;
+    maxTags?: number;
+    // Readonly and prefill display options
+    readonly?: boolean;
+    prefillDisplay?: PrefillDisplayConfig;
+  };
+}
+/**
+ * Get runtime field structure by path
+ * Supports object, object-optional, and object-union types
+ */
+export function getFieldStructureByPath(
+  fields: EndpointFieldStructure,
+  path: string,
+): EndpointFieldStructure | null {
+  const parts = path.split(".");
+  let current = fields;
+
+  for (const part of parts) {
+    if (!current || typeof current !== "object") {
+      return null;
+    }
+
+    // Handle object-union types
+    if (current.type === "object-union") {
+      const unionField = current as EndpointFieldStructure & {
+        variants?: readonly EndpointFieldStructure[];
+      };
+
+      // Look for the field in any variant (all variants should have the discriminator field)
+      // For other fields, we return the first match (assuming variants have consistent field definitions)
+      if (unionField.variants && Array.isArray(unionField.variants)) {
+        for (const variant of unionField.variants) {
+          if (variant.type === "object" || variant.type === "object-optional") {
+            const variantChildren = variant.children as
+              | Record<string, EndpointFieldStructure>
+              | undefined;
+            if (variantChildren && part in variantChildren) {
+              current = variantChildren[part];
+              break; // Found in this variant, continue with next part
+            }
+          }
+        }
+        // If not found in any variant, return null
+        if (!current || current === fields) {
+          return null;
+        }
+      } else {
+        return null;
+      }
+    }
+    // Navigate through object children (both object and object-optional)
+    else if (
+      (current.type === "object" || current.type === "object-optional") &&
+      current.children
+    ) {
+      current = current.children[part];
+    } else {
+      return null;
+    }
+  }
+
+  return current;
+}

package/src/app/api/[locale]/system/unified-interface/shared/field-config/field-config-types.ts

@@ -0,0 +1,268 @@
+/**
+ * Type definitions for Endpoint Form Field Component
+ * Provides type-safe field definitions for use with useEndpoint hook
+ *
+ * This is the shared version - platform-specific code should import from here
+ */
+
+import type { Countries } from "@/i18n/core/config";
+
+/**
+ * Prefill display configuration for form fields
+ * When a field has a prefilled value from server/URL params, this controls how it's displayed
+ */
+export interface PrefillDisplayConfig<TKey extends string> {
+  /** Display variant when field is prefilled */
+  variant: "badge" | "highlight" | "card";
+  /** Translation key for the label shown with prefilled value */
+  labelKey?: NoInfer<TKey>;
+  /** Icon to show with prefilled value */
+  icon?: string;
+}
+
+// Base field configuration
+export interface BaseFieldConfig<TKey extends string> {
+  label: NoInfer<TKey> | undefined;
+  placeholder?: NoInfer<TKey>;
+  description?: NoInfer<TKey>;
+  disabled?: boolean;
+  className?: string;
+  /**
+   * Make field readonly - displays value but cannot be edited
+   * Use with prefillDisplay to show special styling for server-provided values
+   */
+  readonly?: boolean;
+  /**
+   * Configure how prefilled values are displayed when readonly
+   * Only applies when field has a prefilled value and readonly is true
+   */
+  prefillDisplay?: PrefillDisplayConfig<TKey>;
+}
+
+// Field type specific configurations
+export interface TextFieldConfig<
+  TTranslationKey extends string,
+> extends BaseFieldConfig<TTranslationKey> {
+  type: "text" | "email" | "tel" | "url" | "password";
+}
+
+export interface NumberFieldConfig<
+  TTranslationKey extends string,
+> extends BaseFieldConfig<TTranslationKey> {
+  type: "number";
+  min?: number;
+  max?: number;
+  step?: number;
+}
+
+export interface TextareaFieldConfig<
+  TTranslationKey extends string,
+> extends BaseFieldConfig<TTranslationKey> {
+  type: "textarea";
+  rows?: number;
+  maxLength?: number;
+}
+
+export interface SelectFieldConfig<
+  TTranslationKey extends string,
+  TValue = string,
+> extends BaseFieldConfig<TTranslationKey> {
+  type: "select";
+  options: Array<{
+    value: TValue;
+    label: NoInfer<TTranslationKey>;
+    labelParams?: Record<string, string | number>;
+    disabled?: boolean;
+  }>;
+  placeholder?: NoInfer<TTranslationKey>;
+}
+
+export interface CheckboxFieldConfig<
+  TTranslationKey extends string,
+> extends BaseFieldConfig<TTranslationKey> {
+  type: "checkbox";
+  checkboxLabel?: NoInfer<TTranslationKey>;
+}
+
+export interface RadioFieldConfig<
+  TTranslationKey extends string,
+> extends BaseFieldConfig<TTranslationKey> {
+  type: "radio";
+  options: Array<{
+    value: string;
+    label: NoInfer<TTranslationKey>;
+    labelParams?: Record<string, string | number>;
+    disabled?: boolean;
+  }>;
+  orientation?: "horizontal" | "vertical";
+}
+
+export interface SwitchFieldConfig<
+  TTranslationKey extends string,
+> extends BaseFieldConfig<TTranslationKey> {
+  type: "switch";
+  switchLabel?: NoInfer<TTranslationKey>;
+}
+
+export interface DateFieldConfig<
+  TTranslationKey extends string,
+> extends BaseFieldConfig<TTranslationKey> {
+  type: "date";
+  minDate?: Date;
+  maxDate?: Date;
+}
+
+export interface AutocompleteFieldConfig<
+  TTranslationKey extends string,
+> extends BaseFieldConfig<TTranslationKey> {
+  type: "autocomplete";
+  options: Array<{
+    value: string;
+    label: NoInfer<TTranslationKey>;
+    category?: string;
+  }>;
+  allowCustom?: boolean;
+  searchPlaceholder?: NoInfer<TTranslationKey>;
+}
+
+export interface TagsFieldConfig<
+  TTranslationKey extends string,
+> extends BaseFieldConfig<TTranslationKey> {
+  type: "tags";
+  suggestions?: Array<{
+    value: string;
+    label: NoInfer<TTranslationKey>;
+    category?: string;
+  }>;
+  maxTags?: number;
+  allowCustom?: boolean;
+}
+
+export interface PhoneFieldConfig<
+  TTranslationKey extends string,
+> extends BaseFieldConfig<TTranslationKey> {
+  type: "phone";
+  defaultCountry: Countries;
+  preferredCountries: Countries[];
+}
+
+export interface ColorPickerFieldConfig<
+  TTranslationKey extends string,
+> extends BaseFieldConfig<TTranslationKey> {
+  type: "color";
+  presetColors?: string[];
+  allowCustom?: boolean;
+}
+
+export interface SliderFieldConfig<
+  TTranslationKey extends string,
+> extends BaseFieldConfig<TTranslationKey> {
+  type: "slider";
+  min: number;
+  max: number;
+  step?: number;
+  marks?: Array<{ value: number; label: string }>;
+  formatValue?: (value: number) => string;
+}
+
+export interface MultiSelectFieldConfig<
+  TTranslationKey extends string,
+> extends BaseFieldConfig<TTranslationKey> {
+  type: "multiselect";
+  options: Array<{
+    value: string;
+    label: NoInfer<TTranslationKey>;
+    labelParams?: Record<string, string | number>;
+    disabled?: boolean;
+    icon?: string;
+  }>;
+  maxSelections?: number;
+  searchable?: boolean;
+}
+
+export interface LocationFieldConfig<
+  TTranslationKey extends string,
+> extends BaseFieldConfig<TTranslationKey> {
+  type: "location";
+  types?: Array<"country" | "city" | "region">;
+  multiple?: boolean;
+}
+
+export interface YearPickerFieldConfig<
+  TTranslationKey extends string,
+> extends BaseFieldConfig<TTranslationKey> {
+  type: "year";
+  minYear?: number;
+  maxYear?: number;
+}
+
+export interface IconFieldConfig<
+  TTranslationKey extends string,
+> extends BaseFieldConfig<TTranslationKey> {
+  type: "icon";
+}
+
+export interface FilterPillsFieldConfig<
+  TTranslationKey extends string,
+> extends BaseFieldConfig<TTranslationKey> {
+  type: "filter_pills";
+  options: Array<{
+    value: string;
+    label: NoInfer<TTranslationKey>;
+    icon?: string;
+    disabled?: boolean;
+  }>;
+}
+
+// Union type for all field configurations
+export type FieldConfig<TTranslationKey extends string> =
+  | TextFieldConfig<TTranslationKey>
+  | NumberFieldConfig<TTranslationKey>
+  | TextareaFieldConfig<TTranslationKey>
+  | SelectFieldConfig<TTranslationKey, string>
+  | CheckboxFieldConfig<TTranslationKey>
+  | RadioFieldConfig<TTranslationKey>
+  | SwitchFieldConfig<TTranslationKey>
+  | DateFieldConfig<TTranslationKey>
+  | AutocompleteFieldConfig<TTranslationKey>
+  | TagsFieldConfig<TTranslationKey>
+  | PhoneFieldConfig<TTranslationKey>
+  | ColorPickerFieldConfig<TTranslationKey>
+  | SliderFieldConfig<TTranslationKey>
+  | MultiSelectFieldConfig<TTranslationKey>
+  | LocationFieldConfig<TTranslationKey>
+  | YearPickerFieldConfig<TTranslationKey>
+  | IconFieldConfig<TTranslationKey>
+  | FilterPillsFieldConfig<TTranslationKey>;
+
+// Required field styling options
+export type RequiredFieldStyle =
+  | "highlight" // Highlight required fields with colored borders/backgrounds
+  | "asterisk" // Show asterisk for required fields
+  | "badge" // Show "Required" badge
+  | "none"; // No special styling for required fields
+
+// Form styling theme for required fields
+export interface RequiredFieldTheme {
+  style: RequiredFieldStyle;
+  showAllRequired?: boolean; // If true, show required styling even when all fields are required
+  requiredColor?: "amber" | "red" | "blue" | "green"; // Color theme for required field highlighting
+  completedColor?: "green" | "blue" | "purple"; // Color theme for completed required fields
+}
+
+// Field validation state
+export interface FieldValidationState {
+  hasError: boolean;
+  hasValue: boolean;
+  isRequired: boolean;
+  errorMessage?: string;
+}
+
+// Field styling classes
+export interface FieldStyleClassName {
+  containerClassName: string;
+  labelClassName: string;
+  inputClassName: string;
+  errorClassName: string;
+  descriptionClassName: string;
+}

package/src/app/api/[locale]/system/unified-interface/shared/logger/colors.ts

@@ -0,0 +1,114 @@
+/**
+ * ANSI Color Codes for Terminal Output
+ * Provides consistent, beautiful colors for CLI logging
+ */
+
+/**
+ * ANSI color codes
+ */
+export const colors = {
+  // Reset
+  reset: "\u001B[0m",
+
+  // Text colors
+  black: "\u001B[30m",
+  red: "\u001B[31m",
+  green: "\u001B[32m",
+  yellow: "\u001B[33m",
+  blue: "\u001B[34m",
+  magenta: "\u001B[35m",
+  cyan: "\u001B[36m",
+  white: "\u001B[37m",
+  gray: "\u001B[90m",
+
+  // Bright colors
+  brightRed: "\u001B[91m",
+  brightGreen: "\u001B[92m",
+  brightYellow: "\u001B[93m",
+  brightBlue: "\u001B[94m",
+  brightMagenta: "\u001B[95m",
+  brightCyan: "\u001B[96m",
+  brightWhite: "\u001B[97m",
+
+  // Text styles
+  bold: "\u001B[1m",
+  dim: "\u001B[2m",
+  italic: "\u001B[3m",
+  underline: "\u001B[4m",
+} as const;
+
+/**
+ * Semantic color helpers for consistent styling
+ */
+export const semantic = {
+  // Status colors
+  success: colors.green,
+  error: colors.red,
+  warning: colors.yellow,
+  info: colors.cyan,
+  debug: colors.gray,
+
+  // Component colors
+  server: colors.magenta,
+  database: colors.brightCyan,
+  task: colors.brightMagenta,
+  generator: colors.magenta,
+
+  // Accent colors
+  highlight: colors.white,
+  muted: colors.gray,
+  accent: colors.cyan,
+} as const;
+
+/**
+ * Format a message with color
+ */
+export function colorize(text: string, color: string): string {
+  return `${color}${text}${colors.reset}`;
+}
+
+/**
+ * Format a message with bold
+ */
+export function bold(text: string): string {
+  return `${colors.bold}${text}${colors.reset}`;
+}
+
+/**
+ * Format a message with dim
+ */
+export function dim(text: string): string {
+  return `${colors.dim}${text}${colors.reset}`;
+}
+
+/**
+ * Combine multiple styles
+ */
+export function styled(text: string, ...styles: string[]): string {
+  return `${styles.join("")}${text}${colors.reset}`;
+}
+
+/**
+ * Check if colors should be disabled (e.g., in CI or when piped)
+ */
+export function shouldUseColors(): boolean {
+  // Disable colors if NO_COLOR env var is set
+  if (process.env.NO_COLOR) {
+    return false;
+  }
+
+  // Disable colors if not in a TTY
+  if (!process.stdout.isTTY) {
+    return false;
+  }
+
+  // Enable colors by default in terminal
+  return true;
+}
+
+/**
+ * Conditionally apply color based on environment
+ */
+export function maybeColorize(text: string, color: string): string {
+  return shouldUseColors() ? colorize(text, color) : text;
+}

package/src/app/api/[locale]/system/unified-interface/shared/logger/endpoint.ts

@@ -0,0 +1,169 @@
+import { parseError } from "next-vibe/shared/utils/parse-error";
+
+import { enableDebugLogger, mcpSilentMode } from "@/config/debug";
+import type { CountryLanguage } from "@/i18n/core/config";
+import { simpleT } from "@/i18n/core/shared";
+import type { TranslationKey } from "@/i18n/core/static-types";
+
+import type { ErrorResponseType } from "../../../../shared/types/response.schema";
+
+/**
+ * Logger metadata - structured data for logging
+ */
+export type LoggerMetadata =
+  | string
+  | number
+  | boolean
+  | null
+  | undefined
+  | Error
+  | Date
+  | ErrorResponseType
+  | { [key: string]: LoggerMetadata }
+  | LoggerMetadata[];
+
+/**
+ * Dynamically import and use file logging
+ * Only imports when actually needed (in MCP mode)
+ */
+async function writeToFile(
+  message: string,
+  data?: Record<string, LoggerMetadata>,
+): Promise<void> {
+  try {
+    const { fileLog } = await import("./file-logger");
+    fileLog(message, data);
+  } catch {
+    // Ignore errors - logging is best effort
+    // Can't log the error because we're in silent mode
+  }
+}
+
+/**
+ * Logger interface for endpoint handlers
+ * Provides structured logging with timing information
+ */
+export interface EndpointLogger {
+  /**
+   * Log an info message - always runs
+   */
+  info(message: string, ...metadata: LoggerMetadata[]): void;
+
+  /**
+   * Log an error message - always runs
+   */
+  error(
+    message: string,
+    error?: LoggerMetadata,
+    ...metadata: LoggerMetadata[]
+  ): void;
+
+  /**
+   * Log a warning message - always runs
+   */
+  warn(message: string, ...metadata: LoggerMetadata[]): void;
+
+  /**
+   * Log a vibe message (special formatted info) - always runs
+   */
+  vibe(message: string, ...metadata: LoggerMetadata[]): void;
+
+  /**
+   * Log a debug message - only runs when debug flag is enabled
+   */
+  debug(message: string, ...metadata: LoggerMetadata[]): void;
+
+  isDebugEnabled: boolean;
+}
+
+/**
+ * Creates a logger instance for endpoint handlers
+ * Provides pretty formatted logging with running time in seconds
+ */
+export function createEndpointLogger(
+  debugEnabled = false,
+  startTime: number = Date.now(),
+  locale: CountryLanguage,
+): EndpointLogger {
+  const getElapsedTime = (): string => {
+    const elapsed = (Date.now() - startTime) / 1000;
+    return `${elapsed.toFixed(3)}s`;
+  };
+  const { t } = simpleT(locale);
+
+  const formatMessage = (message: string): string => {
+    return `[${getElapsedTime()}] ${t(message as TranslationKey)}`;
+  };
+
+  return {
+    info(message: string, ...metadata: LoggerMetadata[]): void {
+      if (mcpSilentMode) {
+        // In MCP mode, dynamically import and log to file instead of console
+        const metadataObj = metadata.length > 0 ? { metadata } : undefined;
+        void writeToFile(`[INFO] ${formatMessage(message)}`, metadataObj);
+      } else {
+        // oxlint-disable-next-line no-console
+        console.log(formatMessage(message), ...metadata);
+      }
+    },
+
+    error(
+      message: string,
+      error?: LoggerMetadata,
+      ...metadata: LoggerMetadata[]
+    ): void {
+      if (mcpSilentMode) {
+        // In MCP mode, dynamically import and log to file instead of console
+        const typedError = error ? parseError(error) : undefined;
+        const metadataObj = {
+          error: typedError,
+          ...(metadata.length > 0 && { metadata }),
+        };
+        void writeToFile(`[ERROR] ${formatMessage(message)}`, metadataObj);
+      } else {
+        const typedError = error ? parseError(error) : undefined;
+        // oxlint-disable-next-line no-console
+        console.error(formatMessage(message), typedError, ...metadata);
+      }
+    },
+
+    vibe(message: string, ...metadata: LoggerMetadata[]): void {
+      if (mcpSilentMode) {
+        // In MCP mode, dynamically import and log to file instead of console
+        const metadataObj = metadata.length > 0 ? { metadata } : undefined;
+        void writeToFile(
+          `[VIBE] [${getElapsedTime()}] ${message}`,
+          metadataObj,
+        );
+      } else {
+        // Special vibe formatting - messages are plain strings
+        // oxlint-disable-next-line no-console
+        console.log(`[${getElapsedTime()}] ${message}`, ...metadata);
+      }
+    },
+
+    debug(message: string, ...metadata: LoggerMetadata[]): void {
+      if (debugEnabled || enableDebugLogger) {
+        if (mcpSilentMode) {
+          // In MCP mode, dynamically import and log to file instead of console
+          const metadataObj = metadata.length > 0 ? { metadata } : undefined;
+          void writeToFile(`[DEBUG] ${formatMessage(message)}`, metadataObj);
+        } else {
+          // oxlint-disable-next-line no-console
+          console.log(formatMessage(message), ...metadata);
+        }
+      }
+    },
+    warn(message: string, ...metadata: LoggerMetadata[]): void {
+      if (mcpSilentMode) {
+        // In MCP mode, dynamically import and log to file instead of console
+        const metadataObj = metadata.length > 0 ? { metadata } : undefined;
+        void writeToFile(`[WARN] ${formatMessage(message)}`, metadataObj);
+      } else {
+        // oxlint-disable-next-line no-console
+        console.warn(formatMessage(message), ...metadata);
+      }
+    },
+    isDebugEnabled: debugEnabled || enableDebugLogger,
+  };
+}