@next-vibe/checker 1.0.11 → 1.0.12

package/src/app/api/[locale]/system/unified-interface/cli/setup/update/route.ts

@@ -0,0 +1,22 @@
+/**
+ * Setup Update Route
+ * API route for CLI update (uninstall + reinstall)
+ */
+
+import "server-only";
+
+import { endpointsHandler } from "@/app/api/[locale]/system/unified-interface/shared/endpoints/route/multi";
+import { Methods } from "@/app/api/[locale]/system/unified-interface/shared/types/enums";
+
+import updateEndpoints from "./definition";
+import { setupUpdateRepository } from "./repository";
+
+export const { POST, tools } = endpointsHandler({
+  endpoint: updateEndpoints,
+  [Methods.POST]: {
+    handler: ({ data, user, logger, locale }) => {
+      logger.info("Setup update operation started", { verbose: data.verbose });
+      return setupUpdateRepository.updateCli(data, user, locale);
+    },
+  },
+});

package/src/app/api/[locale]/system/unified-interface/cli/vibe-runtime.ts

@@ -0,0 +1,304 @@
+#!/usr/bin/env bun
+
+/**
+ * Vibe CLI Main Entry Point
+ * Command line interface that can execute any route.ts from generated index files
+ */
+
+import { Command } from "commander";
+import { parseError } from "next-vibe/shared/utils/parse-error";
+
+import { enableDebug, enableMcpSilentMode } from "@/config/debug";
+import type { CountryLanguage } from "@/i18n/core/config";
+import { simpleT } from "@/i18n/core/shared";
+
+import { createEndpointLogger } from "../shared/logger/endpoint";
+import { type EnvironmentResult, loadEnvironment } from "./runtime/environment";
+import {
+  ErrorHandler,
+  setupGlobalErrorHandlers,
+} from "./runtime/execution-errors";
+import {
+  parseCliArguments,
+  parseCliArgumentsSimple,
+  type ParsedCliData,
+} from "./runtime/parsing";
+
+export const binaryStartTime = Date.now();
+
+// Load environment first and capture platform
+const environmentResult: EnvironmentResult = loadEnvironment();
+
+/** The detected CLI platform (CLI for local dev, CLI_PACKAGE for npm package) */
+export const cliPlatform = environmentResult.platform;
+
+/** Whether running from npm package */
+export const isCliPackage: boolean = environmentResult.isPackage;
+
+/** Project root path if detected */
+export const projectRoot: string | null = environmentResult.projectRoot;
+
+/**
+ * CLI Options interface for type safety
+ */
+interface CliOptions {
+  data?: string;
+  userType?: string;
+  locale: CountryLanguage;
+  output?: string;
+  verbose?: boolean;
+  debug?: boolean;
+  interactive?: boolean;
+  dryRun?: boolean;
+}
+
+/**
+ * CLI Constants to avoid literal strings
+ */
+const CLI_CONSTANTS = {
+  CLI_NAME: "vibe" as const,
+  CLI_VERSION: "2.0.0" as const,
+  ADMIN_USER_TYPE: "ADMIN" as const,
+  DEFAULT_OUTPUT: "pretty" as const,
+  JSON_OUTPUT: "json" as const,
+  COLON_CHAR: ":" as const,
+  QUOTED_COLON_PATTERN: '"":' as const,
+} as const;
+
+import { cliEnv } from "./env";
+import { cliEntryPoint } from "./runtime/entry-point";
+
+const program = new Command();
+
+const { t: earlyT } = simpleT(cliEnv.VIBE_CLI_LOCALE);
+
+program
+  .name(CLI_CONSTANTS.CLI_NAME)
+  .description(
+    earlyT("app.api.system.unifiedInterface.cli.vibe.help.description"),
+  )
+  .version(CLI_CONSTANTS.CLI_VERSION);
+
+// Main command - execute any route with schema-driven UI
+
+program
+  .argument(
+    "[command]",
+    earlyT("app.api.system.unifiedInterface.cli.vibe.help.usage"),
+  )
+  .argument(
+    "[args...]",
+    earlyT("app.api.system.unifiedInterface.cli.vibe.help.commands"),
+  )
+  .option(
+    // eslint-disable-next-line i18next/no-literal-string
+    "-d, --data <json>",
+    earlyT("app.api.system.unifiedInterface.cli.vibe.executeCommand"),
+  )
+  .option(
+    // eslint-disable-next-line i18next/no-literal-string
+    "-u, --user-type <type>",
+    earlyT("app.api.system.unifiedInterface.cli.vibe.help.userType"),
+    "ADMIN",
+  )
+  .option(
+    // eslint-disable-next-line i18next/no-literal-string
+    "-l, --locale <locale>",
+    earlyT("app.api.system.unifiedInterface.cli.vibe.help.locale"),
+    cliEnv.VIBE_CLI_LOCALE,
+  )
+  .option(
+    // eslint-disable-next-line i18next/no-literal-string
+    "-o, --output <format>",
+    earlyT("app.api.system.unifiedInterface.cli.vibe.output"),
+    CLI_CONSTANTS.DEFAULT_OUTPUT,
+  )
+
+  .option(
+    "-v, --verbose", // eslint-disable-line i18next/no-literal-string
+    earlyT("app.api.system.unifiedInterface.cli.vibe.help.verbose"),
+    false,
+  )
+  .option(
+    "-x, --debug", // eslint-disable-line i18next/no-literal-string
+    earlyT("app.api.system.unifiedInterface.cli.vibe.help.verbose"),
+    false,
+  )
+  .option(
+    // eslint-disable-next-line i18next/no-literal-string
+    "-i, --interactive",
+    earlyT("app.api.system.unifiedInterface.cli.vibe.help.interactive"),
+    false,
+  )
+  .option(
+    "--dry-run",
+    earlyT("app.api.system.unifiedInterface.cli.vibe.help.dryRun"),
+    false,
+  )
+  .allowUnknownOption() // Allow dynamic CLI arguments
+  .action(
+    async (
+      command: string,
+      args: string[],
+      options: CliOptions,
+      cmd: Record<string, string | number | boolean>,
+    ) => {
+      // Enable MCP silent mode FIRST if this is an MCP command
+      if (command === "mcp") {
+        enableMcpSilentMode();
+      }
+
+      const debug = options.debug || options.verbose;
+      const logger = createEndpointLogger(
+        debug ?? false,
+        Date.now(),
+        options.locale,
+      );
+      const { t } = simpleT(options.locale);
+      // Setup global error handlers
+      setupGlobalErrorHandlers(logger);
+
+      if (debug) {
+        logger.debug("Command execution details", {
+          command,
+          args: (args || []).join(" "),
+          verbose: debug ?? false,
+          interactive: options.interactive ?? false,
+          rawDataOption: options.data || "none",
+        });
+        enableDebug();
+      }
+
+      // Initialize CLI resource manager and performance monitoring
+      const { cliResourceManager } = await import("./runtime/debug");
+      await cliResourceManager.initialize(logger, options.locale);
+      const performanceMonitor = cliResourceManager.getPerformanceMonitor();
+
+      try {
+        // Initialize performance monitoring
+        performanceMonitor.mark("initStart");
+
+        performanceMonitor.mark("initEnd");
+
+        // If no command provided, start interactive mode
+        if (!command) {
+          logger.info(t("app.api.system.unifiedInterface.cli.vibe.startingUp"));
+          await cliEntryPoint.executeCommand(
+            "interactive",
+            {
+              user: undefined, // Let route executor handle authentication via getCliUser()
+              locale: options.locale,
+              platform: cliPlatform,
+              output: (options.output ?? CLI_CONSTANTS.DEFAULT_OUTPUT) as
+                | "table"
+                | "pretty"
+                | "json",
+              verbose: debug ?? false,
+              interactive: options.interactive ?? false,
+              dryRun: options.dryRun ?? false,
+            },
+            logger,
+            t,
+            options.locale,
+          );
+          return;
+        }
+
+        // Parse CLI arguments for dynamic field mapping
+        const cmdWithParent = cmd as { parent?: { rawArgs?: string[] } };
+        // If rawArgs is not available, use args directly as positional arguments
+        const rawArgs = cmdWithParent.parent?.rawArgs;
+        const parsedArgs = rawArgs
+          ? parseCliArguments(args || [], rawArgs, logger)
+          : parseCliArgumentsSimple(args || []);
+
+        // Execute the command with schema-driven UI
+        performanceMonitor.mark("parseStart");
+        let parsedData: ParsedCliData | undefined;
+        if (options.data) {
+          try {
+            // Clean up the data string - remove any potential corruption
+            const cleanData = options.data.trim();
+            // Try to parse JSON directly - let JSON.parse handle validation
+            parsedData = JSON.parse(cleanData) as ParsedCliData;
+          } catch (error) {
+            if (debug) {
+              logger.error("JSON parse error", error as Error, {
+                originalData: options.data,
+              });
+            }
+            // Use empty object as fallback
+            parsedData = {};
+          }
+        }
+        performanceMonitor.mark("parseEnd");
+
+        performanceMonitor.mark("routeStart");
+        const result = await cliEntryPoint.executeCommand(
+          command,
+          {
+            data: parsedData,
+            cliArgs: {
+              positionalArgs: parsedArgs.positionalArgs,
+              namedArgs: parsedArgs.namedArgs,
+            },
+            user: undefined, // Let route executor handle authentication via getCliUser()
+            locale: options.locale,
+            platform: cliPlatform,
+            output: (options.output ?? CLI_CONSTANTS.DEFAULT_OUTPUT) as
+              | "table"
+              | "pretty"
+              | "json",
+            verbose: debug ?? false,
+            interactive: options.interactive ?? false,
+            dryRun: options.dryRun ?? false,
+          },
+          logger,
+          t,
+          options.locale,
+        );
+        performanceMonitor.mark("routeEnd");
+
+        performanceMonitor.mark("renderStart");
+        if (result.formattedOutput && command !== "mcp") {
+          process.stdout.write(`${result.formattedOutput}\n`);
+        }
+        performanceMonitor.mark("renderEnd");
+
+        // Use the new resource manager for cleanup and exit
+        await cliResourceManager.cleanupAndExit(logger, debug ?? false, result);
+      } catch (error) {
+        const handled = ErrorHandler.handleError(parseError(error), logger);
+
+        logger.error(handled.message);
+
+        if (debug) {
+          logger.error(
+            t(
+              "app.api.system.unifiedInterface.cli.vibe.errors.executionFailed",
+            ),
+            error as Error,
+          );
+        }
+
+        // Cleanup and exit with error code
+        await cliResourceManager.cleanupAndExit(logger, debug ?? false, {
+          success: false,
+          error:
+            "app.api.system.unifiedInterface.cli.vibe.errors.executionFailed",
+          errorParams: {
+            error: handled.message,
+          },
+        });
+        process.exit(handled.exitCode);
+      }
+    },
+  );
+
+// Parse command line arguments
+program.parse();
+
+// If no arguments provided, show help
+if (process.argv.slice(2).length === 0) {
+  program.help();
+}

package/src/app/api/[locale]/system/unified-interface/cli/widgets/core/base-renderer.ts

@@ -0,0 +1,270 @@
+/**
+ * Base Widget Renderer
+ * Abstract base class for all widget renderers with common utilities
+ */
+
+import chalk from "chalk";
+
+import type { UnifiedField } from "@/app/api/[locale]/system/unified-interface/shared/types/endpoint";
+import type { WidgetType } from "@/app/api/[locale]/system/unified-interface/shared/types/enums";
+import type { WidgetData } from "@/app/api/[locale]/system/unified-interface/shared/widgets/types";
+import { getTranslator } from "@/app/api/[locale]/system/unified-interface/shared/widgets/utils/field-helpers";
+import { getBaseFormatter } from "@/app/api/[locale]/system/unified-interface/shared/widgets/utils/formatting";
+import type { CountryLanguage } from "@/i18n/core/config";
+
+import type {
+  CLIWidgetProps,
+  DataFormatter,
+  WidgetRenderContext,
+  WidgetRenderer,
+} from "./types";
+
+/**
+ * Base widget renderer with common utilities.
+ * TWidget is the specific widget type this renderer handles.
+ */
+export abstract class BaseWidgetRenderer<
+  TWidget extends WidgetType = WidgetType,
+> implements WidgetRenderer<TWidget> {
+  abstract readonly widgetType: TWidget;
+  protected formatter: DataFormatter;
+
+  constructor() {
+    this.formatter = new DefaultDataFormatter();
+  }
+
+  abstract render(props: CLIWidgetProps<TWidget, string>): string;
+
+  /**
+   * Create indentation for the given depth
+   */
+  protected createIndent(depth: number, context: WidgetRenderContext): string {
+    return " ".repeat(depth * context.options.indentSize);
+  }
+
+  /**
+   * Style text with colors if enabled
+   */
+  protected styleText(
+    text: string,
+    style:
+      | "bold"
+      | "dim"
+      | "underline"
+      | "italic"
+      | "red"
+      | "green"
+      | "yellow"
+      | "blue",
+    context: WidgetRenderContext,
+  ): string {
+    if (!context.options.useColors) {
+      return text;
+    }
+
+    switch (style) {
+      case "bold":
+        return chalk.bold(text);
+      case "dim":
+        return chalk.dim(text);
+      case "underline":
+        return chalk.underline(text);
+      case "italic":
+        return chalk.italic(text);
+      case "red":
+        return chalk.red(text);
+      case "green":
+        return chalk.green(text);
+      case "yellow":
+        return chalk.yellow(text);
+      case "blue":
+        return chalk.blue(text);
+      default:
+        return text;
+    }
+  }
+
+  /**
+   * Add icon if emojis are enabled
+   */
+  protected addIcon(
+    icon: string,
+    text: string,
+    context: WidgetRenderContext,
+  ): string {
+    if (!context.options.useEmojis) {
+      return text;
+    }
+    return `${icon} ${text}`;
+  }
+
+  protected formatLabel<const TKey extends string>(
+    field: UnifiedField<TKey>,
+    context: WidgetRenderContext,
+  ): string {
+    // Check if ui config has a label property
+    if ("label" in field.ui && field.ui.label) {
+      const { t } = getTranslator(context);
+      return this.styleText(t(field.ui.label), "bold", context);
+    }
+    return "";
+  }
+
+  /**
+   * Wrap text to fit within max width
+   */
+  protected wrapText(text: string, maxWidth: number, indent = ""): string {
+    // Safety check for text parameter
+    if (!text || typeof text !== "string") {
+      return "";
+    }
+
+    if (text.length <= maxWidth) {
+      return text;
+    }
+
+    const words = text.split(" ");
+    const lines: string[] = [];
+    let currentLine = "";
+
+    for (const word of words) {
+      if ((currentLine + word).length > maxWidth) {
+        if (currentLine) {
+          lines.push(currentLine.trim());
+          currentLine = `${indent + word} `;
+        } else {
+          // Word is longer than max width, force break
+          lines.push(word);
+        }
+      } else {
+        currentLine += `${word} `;
+      }
+    }
+
+    if (currentLine.trim()) {
+      lines.push(currentLine.trim());
+    }
+
+    return lines.join("\n");
+  }
+
+  /**
+   * Create a separator line
+   */
+  protected createSeparator(width: number, char = "─"): string {
+    return char.repeat(width);
+  }
+
+  /**
+   * Pad text to a specific width
+   */
+  protected padText(
+    text: string,
+    width: number,
+    align: "left" | "center" | "right" = "left",
+  ): string {
+    if (text.length >= width) {
+      return text;
+    }
+
+    const padding = width - text.length;
+
+    switch (align) {
+      case "center": {
+        const leftPad = Math.floor(padding / 2);
+        const rightPad = padding - leftPad;
+        return " ".repeat(leftPad) + text + " ".repeat(rightPad);
+      }
+      case "right":
+        return " ".repeat(padding) + text;
+      default:
+        return text + " ".repeat(padding);
+    }
+  }
+}
+
+/**
+ * Default data formatter implementation
+ * Uses shared base formatter to eliminate duplication
+ */
+class DefaultDataFormatter implements DataFormatter {
+  private baseFormatter = getBaseFormatter();
+
+  formatText(value: string, options?: { maxLength?: number }): string {
+    return this.baseFormatter.formatText(value, {
+      maxLength: options?.maxLength,
+    });
+  }
+
+  formatNumber(
+    value: number,
+    locale: CountryLanguage,
+    options?: { precision?: number; unit?: string },
+  ): string {
+    return this.baseFormatter.formatNumber(value, {
+      precision: options?.precision,
+      unit: options?.unit,
+      locale,
+    });
+  }
+
+  formatBoolean(value: boolean): string {
+    return this.baseFormatter.formatBoolean(value, { style: "emoji" });
+  }
+
+  formatDate(value: Date | string, locale: CountryLanguage): string {
+    return this.baseFormatter.formatDate(value, locale, {});
+  }
+
+  formatArray(
+    value: WidgetData[],
+    options?: { separator?: string; maxItems?: number },
+  ): string {
+    const separator = options?.separator ?? ", ";
+    const maxItems = options?.maxItems ?? 10;
+
+    const items = value.slice(0, maxItems);
+    const formatted = items
+      .map((item) => {
+        if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+          return JSON.stringify(item);
+        }
+        if (
+          typeof item === "string" ||
+          typeof item === "number" ||
+          typeof item === "boolean"
+        ) {
+          return String(item);
+        }
+        if (item === null || item === undefined) {
+          return String(item);
+        }
+        if (Array.isArray(item)) {
+          return JSON.stringify(item);
+        }
+        return "";
+      })
+      .join(separator);
+
+    if (value.length > maxItems) {
+      // eslint-disable-next-line i18next/no-literal-string
+      return `${formatted}... (+${value.length - maxItems} more)`;
+    }
+
+    return formatted;
+  }
+
+  formatObject(value: Record<string, WidgetData>): string {
+    try {
+      return JSON.stringify(value, null, 2);
+    } catch {
+      // eslint-disable-next-line i18next/no-literal-string
+      return "[Object]";
+    }
+  }
+
+  formatDuration(milliseconds: number): string {
+    const seconds = milliseconds / 1000;
+    return `${seconds.toFixed(2)}s`;
+  }
+}