@next-vibe/checker 1.0.11 → 1.0.13

package/src/app/api/[locale]/system/unified-interface/cli/widgets/implementations/accordion.ts

@@ -0,0 +1,74 @@
+/**
+ * Accordion Widget Renderer
+ * Handles ACCORDION widget type for CLI display
+ */
+
+import { WidgetType } from "@/app/api/[locale]/system/unified-interface/shared/types/enums";
+import { extractAccordionData } from "@/app/api/[locale]/system/unified-interface/shared/widgets/logic/accordion";
+
+import { BaseWidgetRenderer } from "../core/base-renderer";
+import type { CLIWidgetProps } from "../core/types";
+
+export class AccordionWidgetRenderer extends BaseWidgetRenderer<
+  typeof WidgetType.ACCORDION
+> {
+  readonly widgetType = WidgetType.ACCORDION;
+
+  render(props: CLIWidgetProps<typeof WidgetType.ACCORDION, string>): string {
+    const { value, context } = props;
+    const indent = this.createIndent(context.depth, context);
+
+    // Extract data using shared logic
+    const data = extractAccordionData(value);
+
+    // Handle null case
+    if (!data) {
+      return `${indent}—`;
+    }
+
+    const lines: string[] = [];
+
+    // Render each accordion item
+    for (const item of data.items) {
+      // Item header with expand/collapse indicator
+      const icon = context.options.useEmojis
+        ? item.expanded
+          ? "▼ "
+          : "▶ "
+        : item.expanded
+          ? "- "
+          : "+ ";
+
+      const title = this.styleText(item.title, "bold", context);
+      lines.push(`${indent}${icon}${title}`);
+
+      // Item content (only if expanded)
+      if (item.expanded && item.content !== null) {
+        const contentStr =
+          typeof item.content === "string"
+            ? item.content
+            : JSON.stringify(item.content, null, 2);
+
+        // Indent content
+        const contentLines = contentStr.split("\n");
+        for (const line of contentLines) {
+          lines.push(`${indent}  ${line}`);
+        }
+      }
+
+      // Add separator between items
+      if (data.variant === "separated" || data.variant === "bordered") {
+        lines.push(`${indent}${this.createSeparator(60)}`);
+      } else {
+        lines.push("");
+      }
+    }
+
+    // Remove trailing empty line
+    if (lines.at(-1) === "") {
+      lines.pop();
+    }
+
+    return lines.join("\n");
+  }
+}

package/src/app/api/[locale]/system/unified-interface/cli/widgets/implementations/avatar.ts

@@ -0,0 +1,39 @@
+/**
+ * Avatar Widget Renderer
+ * Handles AVATAR widget type for CLI display
+ */
+
+import { WidgetType } from "@/app/api/[locale]/system/unified-interface/shared/types/enums";
+import { extractAvatarData } from "@/app/api/[locale]/system/unified-interface/shared/widgets/logic/avatar";
+
+import { BaseWidgetRenderer } from "../core/base-renderer";
+import type { CLIWidgetProps } from "../core/types";
+
+export class AvatarWidgetRenderer extends BaseWidgetRenderer<
+  typeof WidgetType.AVATAR
+> {
+  readonly widgetType = WidgetType.AVATAR;
+
+  render(props: CLIWidgetProps<typeof WidgetType.AVATAR, string>): string {
+    const { field, value, context } = props;
+    const indent = this.createIndent(context.depth, context);
+    const label = this.formatLabel(field, context);
+
+    // Extract data using shared logic
+    const data = extractAvatarData(value);
+
+    // Handle null case
+    if (!data) {
+      return `${indent}${label}: —`;
+    }
+
+    // In CLI, we show the fallback (initials) in a styled format
+    const avatarDisplay = this.styleText(`[${data.fallback}]`, "blue", context);
+
+    if (label) {
+      return `${indent}${label}: ${avatarDisplay}`;
+    }
+
+    return `${indent}${avatarDisplay}`;
+  }
+}

package/src/app/api/[locale]/system/unified-interface/cli/widgets/implementations/badge.ts

@@ -0,0 +1,54 @@
+/**
+ * Badge Widget Renderer
+ * Handles BADGE widget type for CLI display
+ */
+
+import { WidgetType } from "@/app/api/[locale]/system/unified-interface/shared/types/enums";
+import {
+  extractBadgeData,
+  getBadgeColor,
+} from "@/app/api/[locale]/system/unified-interface/shared/widgets/logic/badge";
+
+import { BaseWidgetRenderer } from "../core/base-renderer";
+import type { CLIWidgetProps } from "../core/types";
+
+export class BadgeWidgetRenderer extends BaseWidgetRenderer<
+  typeof WidgetType.BADGE
+> {
+  readonly widgetType = WidgetType.BADGE;
+
+  render(props: CLIWidgetProps<typeof WidgetType.BADGE, string>): string {
+    const { field, value, context } = props;
+    const indent = this.createIndent(context.depth, context);
+    const label = this.formatLabel(field, context);
+
+    // Extract data using shared logic
+    const data = extractBadgeData(value);
+
+    // Handle null case
+    if (!data) {
+      return `${indent}${label}: —`;
+    }
+
+    // Get color based on variant
+    const color = getBadgeColor(data.variant);
+
+    // Style the badge text
+    let badgeText = data.text;
+    if (data.icon && context.options.useEmojis) {
+      badgeText = `${data.icon} ${badgeText}`;
+    }
+
+    const styledBadge = this.styleText(
+      badgeText,
+      color as "red" | "green" | "yellow" | "blue",
+      context,
+    );
+
+    if (label) {
+      return `${indent}${label}: ${styledBadge}`;
+    }
+
+    return `${indent}${styledBadge}`;
+  }
+}

package/src/app/api/[locale]/system/unified-interface/cli/widgets/implementations/code-output.ts

@@ -0,0 +1,298 @@
+/**
+ * Code Output Widget Renderer
+ * Pure rendering implementation - ANSI codes, styling, layout only
+ * All business logic imported from shared
+ */
+
+import { WidgetType } from "@/app/api/[locale]/system/unified-interface/shared/types/enums";
+import {
+  buildTableData,
+  type CodeOutputConfig,
+  type CodeOutputItem,
+  countCodeOutputBySeverity,
+  getCodeOutputConfig,
+  groupCodeOutputData,
+} from "@/app/api/[locale]/system/unified-interface/shared/widgets/logic/code-output";
+import {
+  formatLocation,
+  processSummaryTemplate,
+} from "@/app/api/[locale]/system/unified-interface/shared/widgets/utils/formatting";
+
+import { BaseWidgetRenderer } from "../core/base-renderer";
+import type { CLIWidgetProps, WidgetRenderContext } from "../core/types";
+
+// Default severity icon constants
+const DEFAULT_SEVERITY_ICONS = {
+  ERROR: "✖ ",
+  WARNING: "⚠ ",
+  INFO: "ℹ ",
+  SUCCESS: "✓ ",
+  SPARKLE: "✨ ",
+} as const;
+
+export class CodeOutputWidgetRenderer extends BaseWidgetRenderer<
+  typeof WidgetType.CODE_OUTPUT
+> {
+  readonly widgetType = WidgetType.CODE_OUTPUT;
+
+  render(props: CLIWidgetProps<typeof WidgetType.CODE_OUTPUT, string>): string {
+    const { field, value, context } = props;
+    // Use shared logic to extract config
+    const config = getCodeOutputConfig(field);
+
+    // Handle plain string output (e.g., build logs, command output)
+    if (typeof value === "string") {
+      if (value.trim() === "") {
+        return this.renderEmptyState(context);
+      }
+      return value;
+    }
+
+    if (!Array.isArray(value) || value.length === 0) {
+      return this.renderEmptyState(context);
+    }
+
+    const typedData: CodeOutputItem[] = value.filter(
+      (item): item is CodeOutputItem =>
+        typeof item === "object" && item !== null && !Array.isArray(item),
+    ) as CodeOutputItem[];
+
+    switch (config.format) {
+      case "eslint":
+        return this.renderESLintFormat(typedData, config, context);
+      case "json":
+        return this.renderJSONFormat(typedData);
+      case "table":
+        return this.renderTableFormat(typedData);
+      default:
+        return this.renderGenericFormat(typedData);
+    }
+  }
+
+  private renderEmptyState(context: WidgetRenderContext): string {
+    const t = context.t;
+    const icon = context.options.useEmojis
+      ? DEFAULT_SEVERITY_ICONS.SPARKLE
+      : "";
+    const text = t(
+      "app.api.system.unifiedInterface.cli.vibe.endpoints.renderers.cliUi.widgets.common.noIssuesFound",
+    );
+    return this.styleText(`${icon}${text}`, "green", context);
+  }
+
+  private renderESLintFormat(
+    data: CodeOutputItem[],
+    config: CodeOutputConfig,
+    context: WidgetRenderContext,
+  ): string {
+    let output = "";
+
+    if (config.groupBy) {
+      output += this.renderGroupedData(data, config, context);
+    } else {
+      output += this.renderFlatData(data, config, context);
+    }
+
+    if (config.showSummary) {
+      // eslint-disable-next-line i18next/no-literal-string
+      output += `\n${this.renderSummary(data, config, context)}`;
+    }
+
+    return output;
+  }
+
+  private renderGroupedData(
+    data: CodeOutputItem[],
+    config: CodeOutputConfig,
+    context: WidgetRenderContext,
+  ): string {
+    // Use shared grouping logic
+    const groups = groupCodeOutputData(data, config.groupBy!);
+    const result: string[] = [];
+
+    for (const [groupKey, items] of groups) {
+      const groupHeader = this.styleText(groupKey, "underline", context);
+      // eslint-disable-next-line i18next/no-literal-string
+      result.push(`\n${groupHeader}`);
+
+      for (const item of items) {
+        const line = this.renderDataItem(item, config, context);
+        result.push(`  ${line}`);
+      }
+    }
+
+    return result.join("\n");
+  }
+
+  private renderFlatData(
+    data: CodeOutputItem[],
+    config: CodeOutputConfig,
+    context: WidgetRenderContext,
+  ): string {
+    return data
+      .map((item) => this.renderDataItem(item, config, context))
+      .join("\n");
+  }
+
+  private renderDataItem(
+    item: CodeOutputItem,
+    config: CodeOutputConfig,
+    context: WidgetRenderContext,
+  ): string {
+    const parts: string[] = [];
+
+    if (item.line || item.column) {
+      // Use shared formatting logic
+      const location = formatLocation(item.line, item.column);
+      parts.push(location.padEnd(10));
+    }
+
+    if (item.severity && typeof item.severity === "string") {
+      const severity = this.formatSeverity(item.severity, config, context);
+      parts.push(severity.padEnd(9));
+    }
+
+    if (item.message && typeof item.message === "string") {
+      parts.push(item.message);
+    }
+
+    if (item.rule && typeof item.rule === "string") {
+      parts.push(this.styleText(item.rule, "dim", context));
+    }
+
+    return parts.join(" ");
+  }
+
+  private formatSeverity(
+    severity: string,
+    config: CodeOutputConfig,
+    context: WidgetRenderContext,
+  ): string {
+    const icons = config.severityIcons || {};
+    const icon = context.options.useEmojis ? icons[severity] || "" : "";
+    const text = severity;
+
+    if (!context.options.useColors) {
+      return `${icon}${text}`;
+    }
+
+    switch (severity) {
+      case "error":
+        return `${icon}${this.styleText(text, "red", context)}`;
+      case "warning":
+        return `${icon}${this.styleText(text, "yellow", context)}`;
+      case "info":
+        return `${icon}${this.styleText(text, "blue", context)}`;
+      case "success":
+        return `${icon}${this.styleText(text, "green", context)}`;
+      default:
+        return `${icon}${text}`;
+    }
+  }
+
+  private renderSummary(
+    data: CodeOutputItem[],
+    config: CodeOutputConfig,
+    context: WidgetRenderContext,
+  ): string {
+    if (config.summaryTemplate) {
+      return this.renderCustomSummary(data, config);
+    }
+
+    return this.renderDefaultSummary(data, config, context);
+  }
+
+  private renderDefaultSummary(
+    data: CodeOutputItem[],
+    config: CodeOutputConfig,
+    context: WidgetRenderContext,
+  ): string {
+    const t = context.t;
+    // Use shared counting logic
+    const severityCounts = countCodeOutputBySeverity(data);
+    const totalCount = data.length;
+
+    if (totalCount === 0) {
+      const icon = context.options.useEmojis
+        ? DEFAULT_SEVERITY_ICONS.SPARKLE
+        : "";
+      const text = t(
+        "app.api.system.unifiedInterface.cli.vibe.endpoints.renderers.cliUi.widgets.common.noIssuesFound",
+      );
+      return this.styleText(`${icon}${text}`, "green", context);
+    }
+
+    const parts: string[] = [];
+    const icons = config.severityIcons || {};
+    const icon = context.options.useEmojis
+      ? icons.error || DEFAULT_SEVERITY_ICONS.ERROR
+      : "";
+
+    if (severityCounts.error > 0) {
+      const errorText = `${severityCounts.error} error${severityCounts.error === 1 ? "" : "s"}`;
+      parts.push(this.styleText(errorText, "red", context));
+    }
+
+    if (severityCounts.warning > 0) {
+      const warningText = `${severityCounts.warning} warning${severityCounts.warning === 1 ? "" : "s"}`;
+      parts.push(this.styleText(warningText, "yellow", context));
+    }
+
+    if (parts.length === 1) {
+      return `${icon}${parts[0]}`;
+    } else if (parts.length > 1) {
+      const problemText = `${totalCount} problem${totalCount === 1 ? "" : "s"}`;
+      // eslint-disable-next-line i18next/no-literal-string
+      return `${icon}${problemText} (${parts.join(", ")})`;
+    }
+
+    return `${icon}${totalCount} issue${totalCount === 1 ? "" : "s"}`;
+  }
+
+  private renderCustomSummary(
+    data: CodeOutputItem[],
+    config: CodeOutputConfig,
+  ): string {
+    // Use shared counting and template processing logic
+    const severityCounts = countCodeOutputBySeverity(data);
+    const variables = {
+      total: data.length,
+      errors: severityCounts.error,
+      warnings: severityCounts.warning,
+      info: severityCounts.info,
+    };
+
+    return processSummaryTemplate(config.summaryTemplate!, variables);
+  }
+
+  private renderJSONFormat(data: CodeOutputItem[]): string {
+    return JSON.stringify(data, null, 2);
+  }
+
+  private renderTableFormat(data: CodeOutputItem[]): string {
+    return this.renderSimpleTable(data);
+  }
+
+  private renderGenericFormat(data: CodeOutputItem[]): string {
+    return data.map((item) => JSON.stringify(item)).join("\n");
+  }
+
+  private renderSimpleTable(data: CodeOutputItem[]): string {
+    if (data.length === 0) {
+      return "";
+    }
+
+    // Use shared table building logic
+    const { keys, rows } = buildTableData(data);
+    // eslint-disable-next-line i18next/no-literal-string
+    const header = keys.join(" | ");
+    // eslint-disable-next-line i18next/no-literal-string
+    const separator = keys.map(() => "---").join(" | ");
+    const tableRows = rows.map((row) => {
+      // eslint-disable-next-line i18next/no-literal-string
+      return keys.map((key) => row[key] || "").join(" | ");
+    });
+
+    return [header, separator, ...tableRows].join("\n");
+  }
+}

package/src/app/api/[locale]/system/unified-interface/cli/widgets/implementations/code-quality-files.ts

@@ -0,0 +1,89 @@
+/**
+ * Code Quality Files Widget Renderer
+ * Renders list of affected files with error counts
+ */
+
+import { WidgetType } from "@/app/api/[locale]/system/unified-interface/shared/types/enums";
+import { formatFilePath } from "@/app/api/[locale]/system/unified-interface/shared/widgets/utils/formatting";
+
+import { BaseWidgetRenderer } from "../core/base-renderer";
+import type { CLIWidgetProps } from "../core/types";
+
+export class CodeQualityFilesWidgetRenderer extends BaseWidgetRenderer<
+  typeof WidgetType.CODE_QUALITY_FILES
+> {
+  readonly widgetType = WidgetType.CODE_QUALITY_FILES;
+
+  render(
+    props: CLIWidgetProps<typeof WidgetType.CODE_QUALITY_FILES, string>,
+  ): string {
+    const { value, context } = props;
+
+    if (!Array.isArray(value) || value.length === 0) {
+      return "";
+    }
+
+    const result: string[] = [];
+
+    // Header
+    const headerIcon = context.options.useEmojis ? "📂 " : "";
+    const headerText = this.styleText(
+      `${headerIcon}Affected Files`,
+      "bold",
+      context,
+    );
+    result.push(headerText);
+
+    // Separator
+    const separator = "─".repeat(50);
+    result.push(this.styleText(separator, "dim", context));
+
+    // Render each file
+    for (const fileData of value) {
+      if (typeof fileData !== "object" || fileData === null) {
+        continue;
+      }
+
+      const file =
+        "file" in fileData && typeof fileData.file === "string"
+          ? fileData.file
+          : "";
+      const errors =
+        "errors" in fileData && typeof fileData.errors === "number"
+          ? fileData.errors
+          : 0;
+      const warnings =
+        "warnings" in fileData && typeof fileData.warnings === "number"
+          ? fileData.warnings
+          : 0;
+      const total =
+        "total" in fileData && typeof fileData.total === "number"
+          ? fileData.total
+          : 0;
+
+      if (!file) {
+        continue;
+      }
+
+      const displayPath = formatFilePath(file);
+
+      // Build count text
+      const parts: string[] = [];
+      if (errors > 0) {
+        parts.push(`${errors} error${errors !== 1 ? "s" : ""}`);
+      }
+      if (warnings > 0) {
+        parts.push(`${warnings} warning${warnings !== 1 ? "s" : ""}`);
+      }
+
+      const countText =
+        parts.length > 0
+          ? parts.join(", ")
+          : `${total} issue${total !== 1 ? "s" : ""}`;
+
+      result.push(`   ${displayPath} (${countText})`);
+    }
+
+    return result.join("\n");
+  }
+}