@next-vibe/checker 1.0.52 → 3.0.0

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

@@ -1,264 +0,0 @@
-#!/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?: "json" | "table" | "pretty";
-  verbose?: boolean;
-  debug?: boolean;
-  interactive?: boolean;
-  dryRun?: boolean;
-}
-
-/**
- * CLI Constants to avoid literal strings
- */
-const CLI_NAME = "vibe-check" as const;
-const CLI_VERSION = "1.0.52";
-const DEFAULT_OUTPUT = "pretty" 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_NAME)
-  .description(earlyT("app.api.system.unifiedInterface.cli.vibe.help.description"))
-  .version(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("-d, --data <json>", earlyT("app.api.system.unifiedInterface.cli.vibe.executeCommand"))
-  .option(
-    "-u, --user-type <type>",
-    earlyT("app.api.system.unifiedInterface.cli.vibe.help.userType"),
-    "ADMIN",
-  )
-  .option(
-    "-l, --locale <locale>",
-    earlyT("app.api.system.unifiedInterface.cli.vibe.help.locale"),
-    cliEnv.VIBE_CLI_LOCALE,
-  )
-  .option(
-    "-o, --output <format>",
-    earlyT("app.api.system.unifiedInterface.cli.vibe.output"),
-    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(
-    "-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();
-
-        // Change to PROJECT_ROOT immediately if set
-        const projectRoot = process.env.PROJECT_ROOT;
-        if (projectRoot) {
-          process.chdir(projectRoot);
-        }
-      }
-
-      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(
-          `[CLI] Executing command: ${command} ${(args || []).join(" ")} (verbose: ${debug}, interactive: ${options.interactive ?? false})`,
-        );
-        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, show help
-        if (!command) {
-          performanceMonitor.mark("routeStart");
-          const helpResult = await cliEntryPoint.executeCommand(
-            "help",
-            {
-              user: undefined, // Let route executor handle authentication via getCliUser()
-              locale: options.locale,
-              platform: cliPlatform,
-              output: options.output ?? DEFAULT_OUTPUT,
-              verbose: debug ?? false,
-              interactive: options.interactive ?? false,
-              dryRun: options.dryRun ?? false,
-            },
-            logger,
-            t,
-            options.locale,
-          );
-          performanceMonitor.mark("routeEnd");
-
-          performanceMonitor.mark("renderStart");
-          if (helpResult.formattedOutput) {
-            process.stdout.write(`${helpResult.formattedOutput}\n`);
-          }
-          performanceMonitor.mark("renderEnd");
-
-          await cliResourceManager.cleanupAndExit(logger, debug ?? false, helpResult);
-          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 ?? 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();

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

@@ -1,246 +0,0 @@
-/**
- * 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`;
-  }
-}