@jterrazz/codestyle 1.1.2 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jterrazz/codestyle",
-  "version": "1.1.2",
+  "version": "1.2.1",
   "author": "Jean-Baptiste Terrazzoni <contact@jterrazz.com>",
   "bin": {
     "codestyle": "./src/codestyle.sh"
@@ -16,6 +16,7 @@
     "./oxlint/expo": "./src/oxlint/expo.json",
     "./oxlint/nextjs": "./src/oxlint/nextjs.json",
     "./oxlint/architectures/hexagonal": "./src/oxlint/architectures/hexagonal.json",
+    "./oxlint/plugins/codestyle": "./src/oxlint/plugins/codestyle.js",
     "./oxfmt": "./src/oxfmt/index.json"
   },
   "publishConfig": {
@@ -26,7 +27,8 @@
     "lint:fix": "oxlint --fix --ignore-pattern '**/fixtures/**' && oxfmt",
     "test": "vitest --run",
     "test:watch": "vitest",
-    "build": "# no build script"
+    "build": "# no build script",
+    "postinstall": "node src/postinstall.js"
   },
   "dependencies": {
     "@typescript/native-preview": "^7.0.0-dev",

package/src/oxfmt/index.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://oxc.rs/schemas/oxfmt/0.19.0/schema.json",
+  "$schema": "https://raw.githubusercontent.com/oxc-project/oxc/main/npm/oxfmt/configuration_schema.json",
   "printWidth": 100,
   "tabWidth": 4,
   "useTabs": false,

package/src/oxlint/architectures/hexagonal.json

@@ -1,23 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/oxc-project/oxc/main/npm/oxlint/configuration_schema.json",
-  "jsPlugins": ["../plugins/architecture-boundaries.js"],
   "rules": {
-    // Hexagonal Architecture (Ports & Adapters)
-    //
-    // Dependency rule: outer layers depend on inner layers, never the reverse
-    // All layers CAN import domain (it's the core)
-    //
-    //   ┌─────────────────────────────────────────┐
-    //   │  infrastructure / presentation (outer)  │
-    //   │  ┌─────────────────────────────────┐    │
-    //   │  │  application (use-cases, ports) │    │
-    //   │  │  ┌─────────────────────────┐    │    │
-    //   │  │  │  domain (core business) │    │    │
-    //   │  │  └─────────────────────────┘    │    │
-    //   │  └─────────────────────────────────┘    │
-    //   └─────────────────────────────────────────┘
-
-    "architecture-boundaries/architecture-boundaries": [
+    "codestyle/arch-hexagonal": [
       "error",
       {
         "rules": [

package/src/oxlint/base.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/oxc-project/oxc/main/npm/oxlint/configuration_schema.json",
   "plugins": ["typescript", "import", "oxc", "unicorn"],
-  "jsPlugins": ["eslint-plugin-perfectionist"],
+  "jsPlugins": ["eslint-plugin-perfectionist", "./plugins/codestyle.js"],
   "categories": {
     "correctness": "error",
     "suspicious": "error",

package/src/oxlint/expo.json

@@ -2,7 +2,6 @@
   "$schema": "https://raw.githubusercontent.com/oxc-project/oxc/main/npm/oxlint/configuration_schema.json",
   "extends": ["./base.json"],
   "plugins": ["typescript", "import", "react"],
-  "jsPlugins": ["./plugins/remove-ts-extensions.js"],
   "rules": {
     "typescript/no-require-imports": [
       "error",
@@ -10,13 +9,9 @@
         "allow": ["\\.png$", "\\.jpg$", "\\.jpeg$", "\\.gif$", "\\.webp$"]
       }
     ],
-    "remove-ts-extensions/remove-ts-extensions": "error",
-
-    // React 17+ doesn't require importing React
+    "codestyle/imports-without-ext": "error",
     "react/react-in-jsx-scope": "off",
-    // Prop spreading is common in React Native
     "react/jsx-props-no-spreading": "off",
-    // Style preferences - not worth enforcing
     "react/jsx-boolean-value": "off",
     "react/jsx-handler-names": "off",
     "react/jsx-curly-brace-presence": "off",

package/src/oxlint/nextjs.json

@@ -2,9 +2,8 @@
   "$schema": "https://raw.githubusercontent.com/oxc-project/oxc/main/npm/oxlint/configuration_schema.json",
   "extends": ["./base.json"],
   "plugins": ["typescript", "import", "react", "nextjs"],
-  "jsPlugins": ["./plugins/remove-ts-extensions.js"],
   "ignorePatterns": ["dist/**", "node_modules/**", ".next/**", "next-env.d.ts"],
   "rules": {
-    "remove-ts-extensions/remove-ts-extensions": "error"
+    "codestyle/imports-without-ext": "error"
   }
 }

package/src/oxlint/node.json

@@ -1,8 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/oxc-project/oxc/main/npm/oxlint/configuration_schema.json",
   "extends": ["./base.json"],
-  "jsPlugins": ["./plugins/require-js-extensions.js"],
   "rules": {
-    "require-js-extensions/require-js-extensions": "error"
+    "codestyle/imports-with-ext": "error"
   }
 }

package/src/oxlint/plugins/codestyle.js

@@ -0,0 +1,197 @@
+// Codestyle plugin - custom rules for code quality
+// Contains: architecture boundaries, import extensions
+
+import hexagonalConfig from "../architectures/hexagonal.json" with { type: "json" };
+
+// ============================================
+// Hexagonal - Architecture boundary rules
+// ============================================
+
+function createHexagonalRule() {
+  const ruleConfig = hexagonalConfig.rules["codestyle/arch-hexagonal"];
+  const defaultRules = Array.isArray(ruleConfig) ? ruleConfig[1]?.rules || [] : [];
+
+  return {
+    meta: {
+      type: "problem",
+      docs: {
+        description: "Enforce hexagonal architecture layer boundaries",
+        category: "Best Practices",
+      },
+      schema: [
+        {
+          type: "object",
+          properties: {
+            rules: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  from: { type: "string" },
+                  disallow: { type: "array", items: { type: "string" } },
+                  message: { type: "string" },
+                },
+                required: ["from", "disallow"],
+              },
+            },
+          },
+        },
+      ],
+    },
+    create(context) {
+      const options = context.options[0];
+      const rules = options && options.rules ? options.rules : defaultRules;
+      const filename = context.getFilename();
+
+      function checkNode(node) {
+        if (!node.source || !node.source.value) {
+          return;
+        }
+
+        const importPath = node.source.value;
+
+        for (const rule of rules) {
+          const fromPattern = new RegExp(rule.from);
+          if (!fromPattern.test(filename)) {
+            continue;
+          }
+
+          for (const disallowPattern of rule.disallow) {
+            if (new RegExp(disallowPattern).test(importPath)) {
+              context.report({
+                node: node.source,
+                message: rule.message || "Import violates architecture boundaries",
+              });
+              break;
+            }
+          }
+        }
+      }
+
+      return {
+        ImportDeclaration: checkNode,
+        ExportNamedDeclaration: checkNode,
+        ExportAllDeclaration: checkNode,
+      };
+    },
+  };
+}
+
+// ============================================
+// Imports-with-ext - Require .js extensions
+// ============================================
+
+const importsWithExtRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require .js extension in imports for Node.js ESM compatibility",
+      category: "Best Practices",
+    },
+    fixable: "code",
+    schema: [],
+  },
+  create(context) {
+    const hasExtension = /\.[a-zA-Z0-9]+$/;
+
+    function checkNode(node) {
+      if (!node.source || !node.source.value) {
+        return;
+      }
+
+      const importPath = node.source.value;
+
+      // Only check relative imports
+      if (!importPath.startsWith(".")) {
+        return;
+      }
+
+      // Skip if it already has an extension
+      if (hasExtension.test(importPath)) {
+        return;
+      }
+
+      // Skip type-only imports (they are erased at runtime)
+      if (node.importKind === "type") {
+        return;
+      }
+
+      context.report({
+        node: node.source,
+        message: "Missing .js extension in import (required for Node.js ESM)",
+        fix(fixer) {
+          const newPath = `${importPath}.js`;
+          return fixer.replaceText(node.source, `'${newPath}'`);
+        },
+      });
+    }
+
+    return {
+      ImportDeclaration: checkNode,
+      ExportNamedDeclaration: checkNode,
+      ExportAllDeclaration: checkNode,
+    };
+  },
+};
+
+// ============================================
+// Imports-without-ext - Remove extensions
+// ============================================
+
+const importsWithoutExtRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Remove .js, .jsx, .ts, .tsx extensions from imports",
+      category: "Best Practices",
+    },
+    fixable: "code",
+    schema: [],
+  },
+  create(context) {
+    const extensionsToRemove = /\.(js|jsx|ts|tsx)$/;
+
+    function checkNode(node) {
+      if (!node.source || !node.source.value) {
+        return;
+      }
+
+      const importPath = node.source.value;
+
+      // Check both relative imports and path alias imports
+      if (!importPath.startsWith(".") && !importPath.startsWith("@/")) {
+        return;
+      }
+
+      if (extensionsToRemove.test(importPath)) {
+        const match = importPath.match(extensionsToRemove);
+        context.report({
+          node: node.source,
+          message: `Remove "${match[0]}" extension from import`,
+          fix(fixer) {
+            const newPath = importPath.replace(extensionsToRemove, "");
+            return fixer.replaceText(node.source, `'${newPath}'`);
+          },
+        });
+      }
+    }
+
+    return {
+      ImportDeclaration: checkNode,
+      ExportNamedDeclaration: checkNode,
+      ExportAllDeclaration: checkNode,
+    };
+  },
+};
+
+export default {
+  meta: {
+    name: "codestyle",
+    version: "1.0.0",
+  },
+  rules: {
+    "arch-hexagonal": createHexagonalRule(),
+    "imports-with-ext": importsWithExtRule,
+    "imports-without-ext": importsWithoutExtRule,
+  },
+};

package/src/postinstall.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function findProjectRoot() {
+  let dir = process.cwd();
+  if (dir.includes("node_modules")) {
+    dir = dir.split("node_modules")[0];
+  }
+  return dir;
+}
+
+// Rule mappings based on extended configs
+const ruleMappings = [
+  {
+    pattern: "architectures/hexagonal",
+    rule: ["codestyle/arch-hexagonal", "error"],
+  },
+  {
+    pattern: "oxlint/node",
+    rule: ["codestyle/imports-with-ext", "error"],
+  },
+  {
+    pattern: "oxlint/expo",
+    rule: ["codestyle/imports-without-ext", "error"],
+  },
+  {
+    pattern: "oxlint/nextjs",
+    rule: ["codestyle/imports-without-ext", "error"],
+  },
+];
+
+function run() {
+  const projectRoot = findProjectRoot();
+  const configPath = path.join(projectRoot, ".oxlintrc.json");
+
+  if (!fs.existsSync(configPath)) {
+    return;
+  }
+
+  let config;
+  try {
+    config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+  } catch {
+    console.log("[@jterrazz/codestyle] Could not parse .oxlintrc.json");
+    return;
+  }
+
+  const configStr = JSON.stringify(config);
+  const neededRules = new Map();
+  let needsPlugin = false;
+
+  for (const mapping of ruleMappings) {
+    if (configStr.includes(mapping.pattern)) {
+      neededRules.set(mapping.rule[0], mapping.rule[1]);
+      needsPlugin = true;
+    }
+  }
+
+  if (!needsPlugin) {
+    return;
+  }
+
+  let updated = false;
+  const updates = [];
+
+  // Add plugin
+  const pluginPath = "./node_modules/@jterrazz/codestyle/src/oxlint/plugins/codestyle.js";
+  config.jsPlugins = config.jsPlugins || [];
+  if (!config.jsPlugins.includes(pluginPath)) {
+    config.jsPlugins.push(pluginPath);
+    updated = true;
+    updates.push("  + jsPlugins: codestyle.js");
+  }
+
+  // Add rules
+  config.rules = config.rules || {};
+  for (const [ruleName, ruleLevel] of neededRules) {
+    if (!config.rules[ruleName]) {
+      config.rules[ruleName] = ruleLevel;
+      updated = true;
+      updates.push(`  + rule: ${ruleName}`);
+    }
+  }
+
+  if (!updated) {
+    return;
+  }
+
+  fs.writeFileSync(
+    configPath,
+    `${JSON.stringify(config, null, 2)}
+`,
+  );
+
+  console.log("[@jterrazz/codestyle] Updated .oxlintrc.json:");
+  for (const update of updates) {
+    console.log(update);
+  }
+}
+
+run();

package/src/oxlint/plugins/architecture-boundaries.js

@@ -1,86 +0,0 @@
-// Custom rule to enforce architecture boundaries
-// Prevents imports between layers (e.g., domain cannot import infra)
-
-const architectureBoundariesRule = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Enforce architecture layer boundaries",
-      category: "Best Practices",
-    },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          rules: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                from: { type: "string" }, // Regex pattern for source file path
-                disallow: {
-                  type: "array",
-                  items: { type: "string" }, // Regex patterns for disallowed imports
-                },
-                message: { type: "string" },
-              },
-              required: ["from", "disallow"],
-            },
-          },
-        },
-      },
-    ],
-  },
-  create(context) {
-    const options = context.options[0] || {};
-    const rules = options.rules || [];
-    const filename = context.getFilename();
-
-    function checkNode(node) {
-      if (!node.source || !node.source.value) {
-        return;
-      }
-
-      const importPath = node.source.value;
-
-      for (const rule of rules) {
-        const fromPattern = new RegExp(rule.from);
-
-        // Check if this file matches the "from" pattern
-        if (!fromPattern.test(filename)) {
-          continue;
-        }
-
-        // Check if the import matches any disallowed pattern
-        for (const disallowPattern of rule.disallow) {
-          const disallowRegex = new RegExp(disallowPattern);
-
-          if (disallowRegex.test(importPath)) {
-            context.report({
-              node: node.source,
-              message:
-                rule.message || `Import from "${importPath}" violates architecture boundaries`,
-            });
-            break;
-          }
-        }
-      }
-    }
-
-    return {
-      ImportDeclaration: checkNode,
-      ExportNamedDeclaration: checkNode,
-      ExportAllDeclaration: checkNode,
-    };
-  },
-};
-
-export default {
-  meta: {
-    name: "architecture-boundaries",
-    version: "1.0.0",
-  },
-  rules: {
-    "architecture-boundaries": architectureBoundariesRule,
-  },
-};

package/src/oxlint/plugins/remove-ts-extensions.js

@@ -1,58 +0,0 @@
-// Custom rule to remove TS/JS extensions from imports
-// Compatible with both ESLint and Oxlint JS plugin API
-
-const removeTsExtensionsRule = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Remove .js, .jsx, .ts, .tsx extensions from imports",
-      category: "Best Practices",
-    },
-    fixable: "code",
-    schema: [],
-  },
-  create(context) {
-    const extensionsToRemove = /\.(js|jsx|ts|tsx)$/;
-
-    function checkNode(node) {
-      if (!node.source || !node.source.value) {
-        return;
-      }
-
-      const importPath = node.source.value;
-
-      // Check both relative imports (starting with . or ..) AND path alias imports (starting with @/)
-      if (!importPath.startsWith(".") && !importPath.startsWith("@/")) {
-        return;
-      }
-
-      if (extensionsToRemove.test(importPath)) {
-        const match = importPath.match(extensionsToRemove);
-        context.report({
-          node: node.source,
-          message: `Remove "${match[0]}" extension from import`,
-          fix(fixer) {
-            const newPath = importPath.replace(extensionsToRemove, "");
-            return fixer.replaceText(node.source, `'${newPath}'`);
-          },
-        });
-      }
-    }
-
-    return {
-      ImportDeclaration: checkNode,
-      ExportNamedDeclaration: checkNode,
-      ExportAllDeclaration: checkNode,
-    };
-  },
-};
-
-export default {
-  meta: {
-    name: "remove-ts-extensions",
-    version: "1.0.0",
-  },
-  rules: {
-    "remove-ts-extensions": removeTsExtensionsRule,
-  },
-};

package/src/oxlint/plugins/require-js-extensions.js

@@ -1,65 +0,0 @@
-// Custom rule to require .js extensions in imports (for Node.js ESM)
-// Compatible with both ESLint and Oxlint JS plugin API
-
-const requireJsExtensionsRule = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Require .js extension in imports for Node.js ESM compatibility",
-      category: "Best Practices",
-    },
-    fixable: "code",
-    schema: [],
-  },
-  create(context) {
-    const hasExtension = /\.[a-zA-Z0-9]+$/;
-
-    function checkNode(node) {
-      if (!node.source || !node.source.value) {
-        return;
-      }
-
-      const importPath = node.source.value;
-
-      // Only check relative imports
-      if (!importPath.startsWith(".")) {
-        return;
-      }
-
-      // Skip if it already has an extension
-      if (hasExtension.test(importPath)) {
-        return;
-      }
-
-      // Skip type-only imports (they are erased at runtime)
-      if (node.importKind === "type") {
-        return;
-      }
-
-      context.report({
-        node: node.source,
-        message: "Missing .js extension in import (required for Node.js ESM)",
-        fix(fixer) {
-          const newPath = `${importPath}.js`;
-          return fixer.replaceText(node.source, `'${newPath}'`);
-        },
-      });
-    }
-
-    return {
-      ImportDeclaration: checkNode,
-      ExportNamedDeclaration: checkNode,
-      ExportAllDeclaration: checkNode,
-    };
-  },
-};
-
-export default {
-  meta: {
-    name: "require-js-extensions",
-    version: "1.0.0",
-  },
-  rules: {
-    "require-js-extensions": requireJsExtensionsRule,
-  },
-};