vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/lib/polish/index.js

@@ -0,0 +1,27 @@
+/**
+ * Engine Registry
+ *
+ * Single source of truth for all polish engines.
+ * Adding a new engine = add one line here + create the file.
+ */
+
+const engines = {
+  frontend: require("./frontend"),
+  backend: require("./backend"),
+  security: require("./security"),
+  performance: require("./performance"),
+  accessibility: require("./accessibility"),
+  seo: require("./seo"),
+  configuration: require("./configuration"),
+  documentation: require("./documentation"),
+  infrastructure: require("./infrastructure"),
+  observability: require("./observability"),
+  resilience: require("./resilience"),
+  internationalization: require("./internationalization"),
+  privacy: require("./privacy"),
+};
+
+/** All registered category names */
+const categories = Object.keys(engines);
+
+module.exports = { engines, categories };

package/bin/runners/lib/polish/infrastructure.js

@@ -0,0 +1,80 @@
+/**
+ * Infrastructure Polish Engine
+ *
+ * Checks: Docker, CI/CD, deployment config, env validation.
+ */
+
+const path = require("path");
+const { pathExists, readFileSafe } = require("./utils");
+
+module.exports = async function infrastructureEngine(projectPath) {
+  const issues = [];
+  const packageJson = await readFileSafe(path.join(projectPath, "package.json"));
+
+  // Docker
+  const hasDocker =
+    (await pathExists(path.join(projectPath, "Dockerfile"))) ||
+    (await pathExists(path.join(projectPath, "docker-compose.yml")));
+  if (!hasDocker) {
+    issues.push({
+      id: "missing-docker",
+      category: "Infrastructure",
+      severity: "low",
+      title: "Missing Docker Configuration",
+      description: "No Docker setup found. Deployment may be inconsistent.",
+      suggestion: "Add Dockerfile for consistent deployment environments.",
+      autoFixable: true,
+    });
+  }
+
+  // CI/CD
+  const hasCi =
+    (await pathExists(path.join(projectPath, ".github", "workflows"))) ||
+    (await pathExists(path.join(projectPath, ".gitlab-ci.yml"))) ||
+    (await pathExists(path.join(projectPath, ".circleci")));
+  if (!hasCi) {
+    issues.push({
+      id: "missing-ci",
+      category: "Infrastructure",
+      severity: "high",
+      title: "Missing CI/CD Configuration",
+      description: "No CI/CD pipeline found. Code changes are not automatically tested.",
+      suggestion: "Add GitHub Actions, GitLab CI, or CircleCI for automated testing.",
+      autoFixable: true,
+    });
+  }
+
+  // Deployment config
+  const hasDeployConfig =
+    (await pathExists(path.join(projectPath, "vercel.json"))) ||
+    (await pathExists(path.join(projectPath, "netlify.toml"))) ||
+    (await pathExists(path.join(projectPath, "railway.json")));
+  if (!hasDeployConfig && !hasDocker) {
+    issues.push({
+      id: "missing-deployment-config",
+      category: "Infrastructure",
+      severity: "medium",
+      title: "No Deployment Configuration",
+      description: "No deployment platform configuration found.",
+      suggestion: "Add vercel.json, netlify.toml, or similar for deployment settings.",
+      autoFixable: false,
+    });
+  }
+
+  // Env validation
+  const hasEnvValidation =
+    packageJson && /@t3-oss\/env|envalid|dotenv-safe/i.test(packageJson);
+  if (!hasEnvValidation) {
+    issues.push({
+      id: "missing-env-validation",
+      category: "Infrastructure",
+      severity: "medium",
+      title: "No Environment Validation",
+      description: "Environment variables are not validated at startup.",
+      suggestion: "Add @t3-oss/env-nextjs or envalid to validate env vars at startup.",
+      autoFixable: false,
+    });
+  }
+
+  return issues;
+};

package/bin/runners/lib/polish/internationalization.js

@@ -0,0 +1,85 @@
+/**
+ * Internationalization Polish Engine
+ *
+ * Checks: i18n library, locale detection, RTL support, translation files.
+ */
+
+const path = require("path");
+const { pathExists, findFile, readFileSafe } = require("./utils");
+
+module.exports = async function internationalizationEngine(projectPath) {
+  const issues = [];
+  const packageJson = await readFileSafe(path.join(projectPath, "package.json"));
+  const srcPath = path.join(projectPath, "src");
+  const hasSrc = await pathExists(srcPath);
+  const searchPath = hasSrc ? srcPath : projectPath;
+
+  const hasI18n =
+    packageJson && /next-intl|react-i18next|i18next|lingui|formatjs|react-intl/i.test(packageJson);
+
+  if (!hasI18n) {
+    issues.push({
+      id: "missing-i18n",
+      category: "Internationalization",
+      severity: "low",
+      title: "Missing Internationalization (i18n)",
+      description: "No i18n library found. Adding translations later is costly.",
+      suggestion: "Add next-intl or react-i18next for internationalization support.",
+      autoFixable: false,
+      aiPrompt: "Set up internationalization using next-intl or react-i18next. Include locale detection, language switching, and translation extraction workflow.",
+    });
+  }
+
+  // Locale detection (only if i18n is installed)
+  if (hasI18n) {
+    const hasLocaleDetection = await findFile(searchPath, /locale|navigator\.language|accept-language|getLocale/i);
+    if (!hasLocaleDetection) {
+      issues.push({
+        id: "missing-locale-detection",
+        category: "Internationalization",
+        severity: "medium",
+        title: "Missing Locale Detection",
+        description: "i18n setup found but no automatic locale detection.",
+        suggestion: "Add automatic locale detection from browser settings or Accept-Language header.",
+        autoFixable: false,
+        aiPrompt: "Add automatic locale detection. Detect from Accept-Language header on server, navigator.language on client, allow user override with persistence.",
+      });
+    }
+
+    // RTL support
+    const hasRTL = await findFile(searchPath, /rtl|dir=.*rtl|direction.*rtl|ltr.*rtl/i);
+    if (!hasRTL) {
+      issues.push({
+        id: "missing-rtl-support",
+        category: "Internationalization",
+        severity: "low",
+        title: "Missing RTL Support",
+        description: "No RTL (right-to-left) support found. Arabic/Hebrew users affected.",
+        suggestion: "Add RTL layout support using CSS logical properties or rtlcss.",
+        autoFixable: false,
+        aiPrompt: "Add RTL support for Arabic/Hebrew locales. Use CSS logical properties, directional icons, and proper text alignment.",
+      });
+    }
+
+    // Translation files
+    const hasTranslationFiles =
+      (await pathExists(path.join(projectPath, "locales"))) ||
+      (await pathExists(path.join(projectPath, "translations"))) ||
+      (await pathExists(path.join(projectPath, "messages"))) ||
+      (await pathExists(path.join(srcPath, "locales")));
+    if (!hasTranslationFiles) {
+      issues.push({
+        id: "missing-translation-files",
+        category: "Internationalization",
+        severity: "medium",
+        title: "Missing Translation Files",
+        description: "i18n library found but no translation files directory.",
+        suggestion: "Create locales/ directory with JSON translation files for each language.",
+        autoFixable: true,
+        aiPrompt: "Create a translation file structure with English as base, organized namespaces, and a script to extract translation keys from code.",
+      });
+    }
+  }
+
+  return issues;
+};

package/bin/runners/lib/polish/libraries.js

@@ -0,0 +1,180 @@
+/**
+ * Library detection for context-aware polish checking.
+ *
+ * When a project already uses a library that provides a feature,
+ * we skip the corresponding check to reduce false positives.
+ */
+
+const path = require("path");
+const { pathExists, readFileSafe } = require("./utils");
+
+/**
+ * Common libraries grouped by the functionality they provide.
+ */
+const LIBRARY_ALTERNATIVES = {
+  errorBoundary: [
+    "react-error-boundary",
+    "@sentry/react",
+    "bugsnag-react",
+  ],
+
+  toast: [
+    "react-hot-toast",
+    "react-toastify",
+    "sonner",
+    "@radix-ui/react-toast",
+    "notistack",
+    "react-notifications",
+  ],
+
+  spinner: [
+    "react-spinners",
+    "react-loader-spinner",
+    "react-loading",
+    "@chakra-ui/react",
+    "@mantine/core",
+  ],
+
+  skeleton: [
+    "react-loading-skeleton",
+    "react-content-loader",
+    "@chakra-ui/react",
+    "@mantine/core",
+    "@radix-ui/themes",
+  ],
+
+  formValidation: [
+    "react-hook-form",
+    "formik",
+    "@tanstack/react-form",
+    "react-final-form",
+    "zod",
+    "yup",
+  ],
+
+  uiLibrary: [
+    "@chakra-ui/react",
+    "@mantine/core",
+    "@radix-ui/themes",
+    "@mui/material",
+    "antd",
+    "@nextui-org/react",
+    "shadcn",
+    "@headlessui/react",
+  ],
+
+  stateManagement: [
+    "zustand",
+    "@reduxjs/toolkit",
+    "jotai",
+    "recoil",
+    "mobx",
+    "@tanstack/react-query",
+  ],
+
+  i18n: [
+    "next-intl",
+    "react-i18next",
+    "next-translate",
+    "@formatjs/intl",
+    "lingui",
+  ],
+
+  analytics: [
+    "@sentry/nextjs",
+    "@sentry/react",
+    "@vercel/analytics",
+    "posthog-js",
+    "mixpanel-browser",
+    "@segment/analytics-next",
+  ],
+};
+
+/**
+ * Check if package.json contains any of the specified libraries.
+ * @param {string} packageJsonContent - Raw package.json content
+ * @param {string[]} libraries - Library names to look for
+ * @returns {string|null} First matched library name, or null
+ */
+function hasLibrary(packageJsonContent, libraries) {
+  if (!packageJsonContent) return null;
+
+  for (const lib of libraries) {
+    const escaped = lib.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`"${escaped}"\\s*:`, "i");
+    if (pattern.test(packageJsonContent)) {
+      return lib;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Detect project type for context-aware severity adjustments.
+ */
+async function detectProjectType(projectPath, packageJsonContent) {
+  const hasApp = await pathExists(path.join(projectPath, "app"));
+  const hasPages = await pathExists(path.join(projectPath, "pages"));
+  const hasSrc = await pathExists(path.join(projectPath, "src"));
+
+  const isNextJs = packageJsonContent && /["']next["']/.test(packageJsonContent);
+  const isRemix = packageJsonContent && /["']@remix-run\//.test(packageJsonContent);
+  const isVite = packageJsonContent && /["']vite["']/.test(packageJsonContent);
+  const isAstro = packageJsonContent && /["']astro["']/.test(packageJsonContent);
+
+  const isLibrary = packageJsonContent && /"main"|"module"|"exports"/.test(packageJsonContent);
+  const isCli = packageJsonContent && /"bin"/.test(packageJsonContent);
+  const isApi =
+    !hasApp &&
+    !hasPages &&
+    packageJsonContent &&
+    /["']express["']|["']fastify["']|["']hono["']/.test(packageJsonContent);
+
+  const uiLib = hasLibrary(packageJsonContent, LIBRARY_ALTERNATIVES.uiLibrary);
+
+  return {
+    isNextJs,
+    isRemix,
+    isVite,
+    isAstro,
+    isLibrary,
+    isCli,
+    isApi,
+    hasAppRouter: hasApp && isNextJs,
+    hasPagesRouter: hasPages && isNextJs,
+    hasSrc,
+    uiLibrary: uiLib,
+    skipFrontend: isLibrary || isCli || isApi,
+  };
+}
+
+/**
+ * Adjust severity based on project context.
+ */
+function adjustSeverity(baseSeverity, projectType, issueId) {
+  if (projectType.skipFrontend && issueId.startsWith("missing-")) {
+    return "low";
+  }
+
+  if (projectType.uiLibrary) {
+    const componentIssues = [
+      "missing-spinner",
+      "missing-skeleton",
+      "missing-toast",
+      "missing-empty-states",
+    ];
+    if (componentIssues.includes(issueId)) {
+      return "low";
+    }
+  }
+
+  return baseSeverity;
+}
+
+module.exports = {
+  LIBRARY_ALTERNATIVES,
+  hasLibrary,
+  detectProjectType,
+  adjustSeverity,
+};

package/bin/runners/lib/polish/observability.js

@@ -0,0 +1,75 @@
+/**
+ * Observability Polish Engine
+ *
+ * Checks: OpenTelemetry, structured logging, metrics, correlation IDs.
+ */
+
+const path = require("path");
+const { pathExists, findFile, readFileSafe } = require("./utils");
+
+module.exports = async function observabilityEngine(projectPath) {
+  const issues = [];
+  const packageJson = await readFileSafe(path.join(projectPath, "package.json"));
+  const srcPath = path.join(projectPath, "src");
+  const hasSrc = await pathExists(srcPath);
+  const searchPath = hasSrc ? srcPath : projectPath;
+
+  // OpenTelemetry
+  if (!(packageJson && /@opentelemetry|otel/i.test(packageJson))) {
+    issues.push({
+      id: "missing-opentelemetry",
+      category: "Observability",
+      severity: "medium",
+      title: "Missing OpenTelemetry",
+      description: "No OpenTelemetry setup found. Distributed tracing helps debug production issues.",
+      suggestion: "Add @opentelemetry/sdk-node and configure tracing for your application.",
+      autoFixable: false,
+      aiPrompt: "Set up OpenTelemetry for distributed tracing in my Node.js/Next.js application. Include automatic instrumentation for HTTP requests, database queries, and external API calls.",
+    });
+  }
+
+  // Structured logging
+  if (!(packageJson && /pino|winston|bunyan|@elastic\/ecs-pino-format/i.test(packageJson))) {
+    issues.push({
+      id: "missing-structured-logging",
+      category: "Observability",
+      severity: "high",
+      title: "Missing Structured Logging",
+      description: "No structured logging library found. console.log is hard to parse in production.",
+      suggestion: "Add pino or winston for structured JSON logging.",
+      autoFixable: false,
+      aiPrompt: "Set up structured logging using pino. Configure JSON output in production with request ID correlation, log levels, and proper error serialization. Include dev mode pretty-printing.",
+    });
+  }
+
+  // Metrics
+  if (!(packageJson && /prom-client|@opentelemetry\/sdk-metrics|datadog-metrics/i.test(packageJson))) {
+    issues.push({
+      id: "missing-metrics",
+      category: "Observability",
+      severity: "medium",
+      title: "Missing Metrics Collection",
+      description: "No metrics library found. You won't have visibility into application performance.",
+      suggestion: "Add prom-client or OpenTelemetry metrics for application monitoring.",
+      autoFixable: false,
+      aiPrompt: "Set up Prometheus metrics collection using prom-client. Include default metrics (CPU, memory, event loop lag) and custom business metrics.",
+    });
+  }
+
+  // Correlation IDs
+  const hasCorrelationId = await findFile(searchPath, /correlation|request.*id|trace.*id|x-request-id/i);
+  if (!hasCorrelationId && hasSrc) {
+    issues.push({
+      id: "missing-correlation-ids",
+      category: "Observability",
+      severity: "medium",
+      title: "Missing Request Correlation IDs",
+      description: "No correlation ID handling found. Debugging distributed requests is difficult.",
+      suggestion: "Add correlation ID middleware to trace requests across services.",
+      autoFixable: true,
+      aiPrompt: "Add request correlation ID middleware. Generate unique IDs per request, propagate in headers, include in all log output.",
+    });
+  }
+
+  return issues;
+};

package/bin/runners/lib/polish/performance.js

@@ -0,0 +1,64 @@
+/**
+ * Performance Polish Engine
+ *
+ * Checks: Image optimization, caching, bundle analysis.
+ */
+
+const path = require("path");
+const { findFile, readFileSafe } = require("./utils");
+
+module.exports = async function performanceEngine(projectPath) {
+  const issues = [];
+  const packageJson = await readFileSafe(path.join(projectPath, "package.json"));
+
+  // Image optimization
+  const nextConfig =
+    (await readFileSafe(path.join(projectPath, "next.config.js"))) ||
+    (await readFileSafe(path.join(projectPath, "next.config.mjs")));
+  const hasImageOptimization =
+    (packageJson && /sharp|next\/image|@next\/image/i.test(packageJson)) ||
+    (nextConfig && /images:/i.test(nextConfig));
+
+  if (!hasImageOptimization) {
+    issues.push({
+      id: "missing-image-optimization",
+      category: "Performance",
+      severity: "medium",
+      title: "Missing Image Optimization",
+      description: "No image optimization setup found. Images may be served unoptimized.",
+      suggestion: "Use Next.js Image component or sharp for image optimization.",
+      autoFixable: false,
+    });
+  }
+
+  // Caching
+  const hasCaching = await findFile(projectPath, /cache|stale-while-revalidate/i);
+  if (!hasCaching) {
+    issues.push({
+      id: "missing-caching",
+      category: "Performance",
+      severity: "medium",
+      title: "No Caching Strategy",
+      description: "No caching configuration found. API responses may not be cached.",
+      suggestion: "Add Cache-Control headers or use SWR/React Query for client-side caching.",
+      autoFixable: false,
+    });
+  }
+
+  // Bundle analyzer
+  const hasBundleAnalyzer =
+    packageJson && /@next\/bundle-analyzer|webpack-bundle-analyzer/i.test(packageJson);
+  if (!hasBundleAnalyzer) {
+    issues.push({
+      id: "missing-bundle-analyzer",
+      category: "Performance",
+      severity: "low",
+      title: "No Bundle Analyzer",
+      description: "No bundle analyzer installed. Can't visualize bundle size.",
+      suggestion: "Add @next/bundle-analyzer to track and optimize bundle size.",
+      autoFixable: false,
+    });
+  }
+
+  return issues;
+};

package/bin/runners/lib/polish/privacy.js

@@ -0,0 +1,110 @@
+/**
+ * Privacy Polish Engine
+ *
+ * Checks: Cookie consent, privacy policy, data export, account deletion,
+ * data retention, PII encryption.
+ */
+
+const path = require("path");
+const { pathExists, findFile, readFileSafe } = require("./utils");
+
+module.exports = async function privacyEngine(projectPath) {
+  const issues = [];
+  const packageJson = await readFileSafe(path.join(projectPath, "package.json"));
+  const srcPath = path.join(projectPath, "src");
+  const hasSrc = await pathExists(srcPath);
+  const searchPath = hasSrc ? srcPath : projectPath;
+
+  // Cookie consent
+  const hasCookieConsentLib =
+    packageJson && /cookie-consent|cookieconsent|react-cookie-consent|gdpr|onetrust|cookiebot/i.test(packageJson);
+  const hasCookieConsentCode = await findFile(searchPath, /cookie.*consent|gdpr.*consent|consent.*banner/i);
+  if (!hasCookieConsentLib && !hasCookieConsentCode) {
+    issues.push({
+      id: "missing-cookie-consent",
+      category: "Privacy",
+      severity: "high",
+      title: "Missing Cookie Consent",
+      description: "No cookie consent mechanism found. GDPR/CCPA compliance required.",
+      suggestion: "Add a cookie consent banner for EU/California visitors.",
+      autoFixable: false,
+      aiPrompt: "Implement GDPR-compliant cookie consent banner with categories (necessary, analytics, marketing), persist choice, only load tracking scripts after consent.",
+    });
+  }
+
+  // Privacy policy
+  const hasPrivacyPolicy =
+    (await pathExists(path.join(projectPath, "public", "privacy.html"))) ||
+    (await pathExists(path.join(projectPath, "public", "privacy-policy.html"))) ||
+    (await findFile(searchPath, /privacy.*policy|PrivacyPolicy/i));
+  if (!hasPrivacyPolicy) {
+    issues.push({
+      id: "missing-privacy-policy",
+      category: "Privacy",
+      severity: "high",
+      title: "Missing Privacy Policy",
+      description: "No privacy policy page found. Required by law in many jurisdictions.",
+      suggestion: "Add a privacy policy page explaining data collection and usage.",
+      autoFixable: false,
+      aiPrompt: "Create a privacy policy page covering: data collected, usage, third-party services, cookies, user rights (GDPR), and contact information.",
+    });
+  }
+
+  // Data export
+  if (!(await findFile(searchPath, /export.*data|download.*data|gdpr.*export|data.*portability/i))) {
+    issues.push({
+      id: "missing-data-export",
+      category: "Privacy",
+      severity: "medium",
+      title: "Missing Data Export Feature",
+      description: "No data export capability found. GDPR requires data portability.",
+      suggestion: "Add ability for users to export their data in a standard format.",
+      autoFixable: false,
+      aiPrompt: "Implement data export for GDPR compliance. Allow users to download personal data in JSON/CSV including profile, activity history, and preferences.",
+    });
+  }
+
+  // Account deletion
+  if (!(await findFile(searchPath, /delete.*account|account.*deletion|remove.*account|gdpr.*delete/i))) {
+    issues.push({
+      id: "missing-account-deletion",
+      category: "Privacy",
+      severity: "high",
+      title: "Missing Account Deletion",
+      description: "No account deletion feature found. GDPR requires right to erasure.",
+      suggestion: "Add ability for users to delete their account and all associated data.",
+      autoFixable: false,
+      aiPrompt: "Implement account deletion with confirmation flow, grace period, cascade deletion, and anonymization of non-deletable records.",
+    });
+  }
+
+  // Data retention
+  if (!(await findFile(searchPath, /retention|data.*cleanup|purge.*old|ttl.*expire/i))) {
+    issues.push({
+      id: "missing-data-retention",
+      category: "Privacy",
+      severity: "medium",
+      title: "Missing Data Retention Policy",
+      description: "No data retention/cleanup logic found. Old data should be purged.",
+      suggestion: "Implement data retention policies to automatically purge old data.",
+      autoFixable: false,
+      aiPrompt: "Implement data retention policy. Add scheduled jobs to purge old sessions, logs, and inactive accounts. Document retention periods.",
+    });
+  }
+
+  // PII encryption
+  if (!(await findFile(searchPath, /encrypt|crypto.*cipher|aes|bcrypt|argon2/i))) {
+    issues.push({
+      id: "missing-pii-encryption",
+      category: "Privacy",
+      severity: "high",
+      title: "Missing Data Encryption",
+      description: "No encryption utilities found. Sensitive data should be encrypted.",
+      suggestion: "Add encryption for PII at rest and ensure passwords use bcrypt/argon2.",
+      autoFixable: false,
+      aiPrompt: "Set up encryption for sensitive data. Use bcrypt/argon2 for passwords, field-level encryption for PII, proper key management.",
+    });
+  }
+
+  return issues;
+};