@next-vibe/checker 1.0.13 → 1.0.15

package/.dist/oxlint-plugins/restricted-syntax.js

@@ -1,4 +1,409 @@
-(function() {
-  "use strict";
-})();
-//# sourceMappingURL=restricted-syntax.js.map
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/app/api/[locale]/system/check/oxlint/plugins/shared/config-loader.ts
+var exports_config_loader = {};
+__export(exports_config_loader, {
+  loadPluginConfig: () => loadPluginConfig,
+  getCheckConfig: () => getCheckConfig,
+  createPluginMessages: () => createPluginMessages,
+  clearConfigCache: () => clearConfigCache
+});
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+function findProjectRoot() {
+  const cwd = process.cwd();
+  let currentDir = cwd;
+  const root = resolve("/");
+  while (currentDir !== root) {
+    const configPath = resolve(currentDir, "check.config.ts");
+    if (existsSync(configPath)) {
+      return currentDir;
+    }
+    const jsConfigPath = resolve(currentDir, "check.config.js");
+    if (existsSync(jsConfigPath)) {
+      return currentDir;
+    }
+    currentDir = dirname(currentDir);
+  }
+  return cwd;
+}
+function getConfigPaths() {
+  const projectRoot = findProjectRoot();
+  return [
+    resolve(projectRoot, "check.config.ts"),
+    resolve(projectRoot, "check.config.js"),
+    resolve(projectRoot, "node_modules", "next-vibe", "check.config.js"),
+    resolve(projectRoot, "node_modules", "next-vibe", "dist", "check.config.js")
+  ];
+}
+function loadCheckConfigSync() {
+  if (configLoadAttempted) {
+    return cachedCheckConfig;
+  }
+  configLoadAttempted = true;
+  const configPaths = getConfigPaths();
+  for (const configPath of configPaths) {
+    if (!existsSync(configPath)) {
+      continue;
+    }
+    try {
+      const configModule = __require(configPath);
+      const exportedValue = configModule.default ?? configModule.config;
+      if (!exportedValue) {
+        continue;
+      }
+      const config = typeof exportedValue === "function" ? exportedValue() : exportedValue;
+      cachedCheckConfig = config;
+      return config;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function extractPluginOptions(checkConfig, pluginName) {
+  if (!checkConfig.oxlint.enabled) {
+    return null;
+  }
+  const rules = checkConfig.oxlint.rules;
+  if (!rules) {
+    return null;
+  }
+  const ruleConfig = rules[pluginName];
+  if (Array.isArray(ruleConfig) && ruleConfig.length >= 2) {
+    return ruleConfig[1];
+  }
+  return null;
+}
+function loadPluginConfig(pluginName, defaultConfig) {
+  const cached = pluginConfigCache.get(pluginName);
+  if (cached) {
+    return cached;
+  }
+  const checkConfig = loadCheckConfigSync();
+  if (checkConfig) {
+    const pluginOptions = extractPluginOptions(checkConfig, pluginName);
+    if (pluginOptions) {
+      const result2 = {
+        success: true,
+        config: pluginOptions,
+        source: "rule-config"
+      };
+      pluginConfigCache.set(pluginName, result2);
+      return result2;
+    }
+  }
+  if (defaultConfig) {
+    const result2 = {
+      success: true,
+      config: defaultConfig,
+      source: "default"
+    };
+    pluginConfigCache.set(pluginName, result2);
+    return result2;
+  }
+  const result = {
+    success: false,
+    config: null,
+    source: "error",
+    error: `No configuration found for ${pluginName}`
+  };
+  pluginConfigCache.set(pluginName, result);
+  return result;
+}
+function getCheckConfig() {
+  return loadCheckConfigSync();
+}
+function clearConfigCache() {
+  cachedCheckConfig = null;
+  configLoadAttempted = false;
+  pluginConfigCache.clear();
+}
+function createPluginMessages(defaults, overrides) {
+  return { ...defaults, ...overrides };
+}
+var cachedCheckConfig = null, configLoadAttempted = false, pluginConfigCache;
+var init_config_loader = __esm(() => {
+  pluginConfigCache = new Map;
+});
+
+// src/app/api/[locale]/system/check/oxlint/plugins/restricted-syntax/src/index.ts
+var DEFAULT_CONFIG = {
+  jsxAllowedProperties: [
+    "content",
+    "icon",
+    "title",
+    "label",
+    "description",
+    "children",
+    "render",
+    "fallback",
+    "error",
+    "loading",
+    "empty",
+    "header",
+    "footer",
+    "trigger",
+    "component"
+  ]
+};
+var DEFAULT_MESSAGES = {
+  unknownType: "Usage of the 'unknown' type isn't allowed. Consider using the inferred types from the unified interface system based on definition.ts",
+  objectType: "Usage of the 'object' type isn't allowed. Consider using the inferred types from the unified interface system based on definition.ts",
+  throwStatement: "Usage of 'throw' statements is not allowed. Use proper ResponseType<T> patterns instead.",
+  jsxInObjectLiteral: "JSX elements inside object literals are not allowed. Extract JSX to a separate function to ensure i18n rules work properly."
+};
+var configLoader = null;
+var cachedConfig = null;
+var cachedMessages = null;
+function getConfigLoader() {
+  if (configLoader) {
+    return configLoader;
+  }
+  try {
+    configLoader = (init_config_loader(), __toCommonJS(exports_config_loader));
+    return configLoader;
+  } catch {
+    return null;
+  }
+}
+function loadRestrictedSyntaxConfig() {
+  if (cachedConfig !== null) {
+    return cachedConfig;
+  }
+  const loader = getConfigLoader();
+  if (loader) {
+    const result = loader.loadPluginConfig("oxlint-plugin-restricted/restricted-syntax", DEFAULT_CONFIG);
+    cachedConfig = result.config ?? DEFAULT_CONFIG;
+  } else {
+    cachedConfig = loadConfigFallback();
+  }
+  return cachedConfig;
+}
+function loadConfigFallback() {
+  try {
+    const config = __require(`${process.cwd()}/check.config.ts`);
+    const checkConfig = config.default ?? config;
+    const exported = typeof checkConfig === "function" ? checkConfig() : checkConfig;
+    const ruleConfig = exported?.oxlint?.rules?.["oxlint-plugin-restricted/restricted-syntax"];
+    if (Array.isArray(ruleConfig) && ruleConfig[1]) {
+      return ruleConfig[1];
+    }
+  } catch {}
+  return DEFAULT_CONFIG;
+}
+function getMessages() {
+  if (cachedMessages !== null) {
+    return cachedMessages;
+  }
+  cachedMessages = DEFAULT_MESSAGES;
+  return cachedMessages;
+}
+function isProperty(node) {
+  return node.type === "Property" && typeof node.method === "boolean";
+}
+function isAllowedPath(context) {
+  let filename = "";
+  if (typeof context.getFilename === "function") {
+    filename = context.getFilename();
+  } else if (typeof context.filename === "string") {
+    filename = context.filename;
+  }
+  if (!filename) {
+    return false;
+  }
+  return false;
+}
+function hasDisableComment(context, node) {
+  const getComments = context.getCommentsBefore ?? context.sourceCode?.getCommentsBefore;
+  if (typeof getComments !== "function") {
+    return false;
+  }
+  try {
+    const comments = getComments(node);
+    if (!comments || !Array.isArray(comments)) {
+      return false;
+    }
+    for (const comment of comments) {
+      if (!comment || typeof comment.value !== "string") {
+        continue;
+      }
+      const commentText = comment.value.trim();
+      if ((commentText.includes("eslint-disable-next-line") || commentText.includes("oxlint-disable-next-line")) && (commentText.includes("restricted-syntax") || commentText.includes("no-restricted-syntax"))) {
+        return true;
+      }
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+function isObjectProperty(prop) {
+  return isProperty(prop);
+}
+function getJsxAllowedProperties(context) {
+  const ruleOptions = context.options?.[0];
+  if (ruleOptions?.jsxAllowedProperties) {
+    return new Set(ruleOptions.jsxAllowedProperties);
+  }
+  const config = loadRestrictedSyntaxConfig();
+  if (config.jsxAllowedProperties) {
+    return new Set(config.jsxAllowedProperties);
+  }
+  return new Set;
+}
+function isJSXAllowedKey(prop, jsxAllowedProperties) {
+  const property = prop;
+  if (property.computed) {
+    return false;
+  }
+  const key = property.key;
+  if (!key) {
+    return false;
+  }
+  let keyName = null;
+  if (key.type === "Identifier") {
+    keyName = key.name;
+  } else if (key.type === "Literal" && typeof key.value === "string") {
+    keyName = key.value;
+  }
+  return keyName !== null && jsxAllowedProperties.has(keyName);
+}
+function isJSX(n) {
+  return n && (n.type === "JSXElement" || n.type === "JSXFragment");
+}
+function unwrapParen(n) {
+  let cur = n;
+  while (cur?.type === "ParenthesizedExpression") {
+    const expr = cur.expression;
+    if (!expr) {
+      break;
+    }
+    cur = expr;
+  }
+  return cur;
+}
+var restrictedSyntaxRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforces restricted syntax patterns (no unknown, object, throw, JSX in non-React-node properties)",
+      category: "Best Practices",
+      recommended: true
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          jsxAllowedProperties: { type: "array", items: { type: "string" } }
+        }
+      }
+    ]
+  },
+  create(context) {
+    const isAllowed = isAllowedPath(context);
+    const jsxAllowedProperties = getJsxAllowedProperties(context);
+    const messages = getMessages();
+    return {
+      TSUnknownKeyword(node) {
+        if (isAllowed || hasDisableComment(context, node)) {
+          return;
+        }
+        context.report({
+          node,
+          message: messages.unknownType
+        });
+      },
+      TSObjectKeyword(node) {
+        if (isAllowed || hasDisableComment(context, node)) {
+          return;
+        }
+        context.report({
+          node,
+          message: messages.objectType
+        });
+      },
+      ThrowStatement(node) {
+        if (isAllowed || hasDisableComment(context, node)) {
+          return;
+        }
+        context.report({
+          node,
+          message: messages.throwStatement
+        });
+      },
+      Property(node) {
+        if (!isObjectProperty(node)) {
+          return;
+        }
+        if (isJSXAllowedKey(node, jsxAllowedProperties)) {
+          return;
+        }
+        const property = node;
+        const value = property.value;
+        if (!value || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) {
+          return;
+        }
+        if (isJSX(value)) {
+          context.report({
+            node: value,
+            message: messages.jsxInObjectLiteral
+          });
+          return;
+        }
+        if (value.type === "ParenthesizedExpression") {
+          const inner = unwrapParen(value);
+          if (isJSX(inner)) {
+            context.report({
+              node: inner,
+              message: messages.jsxInObjectLiteral
+            });
+          }
+        }
+      }
+    };
+  }
+};
+var src_default = {
+  meta: {
+    name: "oxlint-plugin-restricted",
+    version: "1.0.0"
+  },
+  rules: {
+    "restricted-syntax": restrictedSyntaxRule
+  }
+};
+export {
+  DEFAULT_MESSAGES as defaultMessages,
+  DEFAULT_CONFIG as defaultConfig,
+  src_default as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@next-vibe/checker",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "main": "./.dist/bin/vibe-runtime.js",
   "author": "Max Brandstätter",
   "description": "TypeScript code quality checker with CLI and MCP support",

package/src/app/api/[locale]/system/builder/definition.ts

@@ -1834,7 +1834,7 @@ export function isViteBuildType(type: BuildType): type is ViteBuildType {
 
 /** Type guard for Bun builds */
 export function isBunBuildType(type: BuildType): type is BunBuildType {
-  return type === BunBuildTypeEnum.EXECUTABLE;
+  return Object.values(BunBuildTypeEnum).includes(type as BunBuildTypeEnum);
 }
 
 // ============================================================================

package/src/app/api/[locale]/system/builder/repository/bun-compiler.ts

@@ -176,7 +176,7 @@ export class BunCompiler implements IBunCompiler {
           : (profileSettings.sourcemap as "external" | "inline" | "none"));
 
     // Build with Bun
-    const result = await Bun.build({
+    const buildOptions = {
       entrypoints: [entrypointPath],
       outdir: outDir,
       target: bunOptions?.target || "bun",
@@ -195,7 +195,9 @@ export class BunCompiler implements IBunCompiler {
       banner: bunOptions?.banner,
       footer: bunOptions?.footer,
       bytecode: bunOptions?.bytecode,
-    });
+    };
+
+    const result = await Bun.build(buildOptions);
 
     if (!result.success) {
       const errorMessages = result.logs

package/src/app/api/[locale]/system/check/test-project/bun.lock

@@ -4,7 +4,7 @@
     "": {
       "name": "check-test-project",
       "dependencies": {
-        "@next-vibe/checker": "^1.0.12",
+        "@next-vibe/checker": "^1.0.14",
       },
     },
   },
@@ -183,7 +183,7 @@
 
     "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.31", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw=="],
 
-    "@next-vibe/checker": ["@next-vibe/checker@1.0.12", "", { "dependencies": { "@inquirer/prompts": "8.1.0", "argon2": "0.44.0", "chalk": "5.6.2", "commander": "14.0.2", "date-fns": "4.1.0", "dotenv": "17.2.3", "eslint-plugin-i18next": "6.1.3", "eslint-plugin-react-compiler": "19.1.0-rc.2", "fs-extra": "^11.3.3", "glob": "13.0.0", "gradient-string": "3.0.0", "jose": "6.1.3", "jsonc-parser": "3.3.1", "server-only": "0.0.1", "typescript": "5.9.3", "vite": "7.3.0", "zod": "4.2.1" }, "bin": { "vibe": ".dist/bin/vibe-runtime.js" } }, "sha512-EAtLlEG522Rd5q3Xthr2TOkt3BAWW6XUvOZUef3oCEEr23Sa35TtMuX7WqzAZmABISZnNjySrNk+mGmeEPMGIg=="],
+    "@next-vibe/checker": ["@next-vibe/checker@1.0.14", "", { "dependencies": { "@inquirer/prompts": "8.1.0", "argon2": "0.44.0", "chalk": "5.6.2", "commander": "14.0.2", "date-fns": "4.1.0", "dotenv": "17.2.3", "eslint-plugin-i18next": "6.1.3", "eslint-plugin-react-compiler": "19.1.0-rc.2", "fs-extra": "^11.3.3", "glob": "13.0.0", "gradient-string": "3.0.0", "jose": "6.1.3", "jsonc-parser": "3.3.1", "server-only": "0.0.1", "typescript": "5.9.3", "vite": "7.3.0", "zod": "4.2.1" }, "bin": { "vibe": ".dist/bin/vibe-runtime.js" } }, "sha512-5uoKsoCAGY9UdV751H3CCNrMB+DvKzWVDMWK1DaNjFmakGe9mR3a4r0ukM/1bUP+VkbXmnvhfPia9HHdUxh1mw=="],
 
     "@phc/format": ["@phc/format@1.0.0", "", {}, "sha512-m7X9U6BG2+J+R1lSOdCiITLLrxm+cWlNI3HUFA92oLO77ObGNzaKdh8pMLqdZcshtkKuV84olNNXDfMc4FezBQ=="],
 

package/src/app/api/[locale]/system/check/test-project/package.json

@@ -7,6 +7,6 @@
     "check-r": "vibe check"
   },
   "dependencies": {
-    "@next-vibe/checker": "^1.0.12"
+    "@next-vibe/checker": "^1.0.14"
   }
 }

package/.dist/oxlint-plugins/i18n.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"i18n.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/.dist/oxlint-plugins/jsx-capitalization.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"jsx-capitalization.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/.dist/oxlint-plugins/restricted-syntax.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"restricted-syntax.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}