@almadar/eslint-plugin 2.4.1 → 2.4.3

package/index.js

@@ -28,6 +28,9 @@ const organismRequireEntityRow = require("./rules/organism-require-entity-row");
 // Atom/molecule rules
 const atomMoleculeNoEntityProp = require("./rules/atom-molecule-no-entity-prop");
 
+// Behavior rules
+const behaviorNoOrganisms = require("./rules/behavior-no-organisms");
+
 // Service rules - Phase 1-3 (Implemented)
 const serviceLazySingleton = require("./rules/service-lazy-singleton");
 const serviceSingletonResettable = require("./rules/service-singleton-resettable");
@@ -82,6 +85,9 @@ const plugin = {
     // Atom/molecule rules
     "atom-molecule-no-entity-prop": atomMoleculeNoEntityProp,
 
+    // Behavior rules
+    "behavior-no-organisms": behaviorNoOrganisms,
+
     // Service rules - Phase 1-3
     "service-lazy-singleton": serviceLazySingleton,
     "service-singleton-resettable": serviceSingletonResettable,
@@ -134,6 +140,9 @@ plugin.configs.recommended = {
     "almadar/template-extends-base": "warn",
     "almadar/require-translate": "warn",
 
+    // Behavior rules — restrict to atoms/molecules only
+    "almadar/behavior-no-organisms": "error",
+
     // Organism rules — enforce dumb organism pattern
     "almadar/organism-no-data-state": "error",
     "almadar/organism-no-auto-fetch": "error",
@@ -230,4 +239,17 @@ plugin.configs["services-strict"] = {
   },
 };
 
+// Behaviors config — lint .orb behavior schemas for pattern tier compliance
+// Requires: jsonc-eslint-parser (pnpm add -D jsonc-eslint-parser)
+// Usage in eslint.config.js: { files: ["**/*.orb"], ...almadar.configs.behaviors }
+plugin.configs.behaviors = {
+  plugins: { almadar: plugin },
+  languageOptions: {
+    parser: require("jsonc-eslint-parser"),
+  },
+  rules: {
+    "almadar/behavior-no-organisms": "error",
+  },
+};
+
 module.exports = plugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@almadar/eslint-plugin",
-  "version": "2.4.1",
+  "version": "2.4.3",
   "private": false,
   "description": "Custom ESLint rules for Almadar component architecture",
   "main": "index.js",
@@ -22,6 +22,9 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "jsonc-eslint-parser": "3.1.0"
+  },
   "scripts": {
     "lint": "eslint index.js rules/ utils/"
   }

package/rules/behavior-no-organisms.js

@@ -0,0 +1,166 @@
+"use strict";
+
+/**
+ * behavior-no-organisms
+ *
+ * Behaviors (.orb files in behaviors/) must only use atom and molecule patterns.
+ * Organisms and templates are forbidden, with exceptions for:
+ *   - form / form-section (explicitly allowed by convention)
+ *
+ * All game components (canvas renderers, HUDs, menus, logs, panels) have been
+ * moved to molecule level. No game exception is needed.
+ *
+ * Requires: jsonc-eslint-parser configured for *.orb files.
+ *
+ * To regenerate BLOCKED_PATTERNS from component-mapping.json:
+ *   node -e "
+ *     const m = require('../almadar-patterns/src/component-mapping.json').mappings;
+ *     const blocked = Object.entries(m)
+ *       .filter(([k, v]) =>
+ *         (v.importPath.includes('/organisms/') || v.importPath.includes('/templates/'))
+ *         && !['form', 'form-section'].includes(k))
+ *       .map(([k]) => k);
+ *     console.log(JSON.stringify(blocked, null, 2));
+ *   "
+ */
+
+// Organism patterns: importPath contains /organisms/ or /templates/
+// Excludes: form, form-section (allowed by convention)
+const BLOCKED_PATTERNS = new Set([
+  // ── Organisms (non-game, non-form) ────────────────────────────────
+  "page-header",
+  "entity-list",
+  "entity-table",
+  "entity-cards",
+  "stats",
+  "detail-panel",
+  "wizard-container",
+  "confirm-dialog",
+  "master-detail",
+  "dashboard-grid",
+  "runtime-debugger",
+  "button-pattern",
+  "custom-pattern",
+  "drawer-slot",
+  "header",
+  "layout-pattern",
+  "modal-slot",
+  "navigation",
+  "orbital-visualization",
+  "section",
+  "sidebar",
+  "split",
+  "table",
+  "toast-slot",
+  "u-i-slot-renderer",
+  "split-pane",
+  "tabbed-container",
+  "collapsible-section",
+  "camera3-d",
+  "lighting3-d",
+  "scene3-d",
+  "canvas3-d-error-boundary",
+  "canvas3-d-loading-state",
+  "model-loader",
+  "physics-object3-d",
+  "feature-renderer",
+  "feature-renderer3-d",
+  "unit-renderer",
+  "trait-slot",
+  "trait-state-viewer",
+  "content-renderer",
+  "jazari-state-machine",
+  "state-machine-view",
+  "book-chapter-view",
+  "book-cover-page",
+  "book-nav-bar",
+  "book-table-of-contents",
+  "book-viewer",
+  "simulation-controls",
+  "simulation-graph",
+  "chart",
+  "timeline",
+  "media-gallery",
+  "signature-pad",
+  "document-viewer",
+  "graph-canvas",
+  "code-viewer",
+  "event-log",
+  "object-rule-panel",
+  "rule-editor",
+  "action-palette",
+  "sequence-bar",
+  "code-view",
+  "state-architect-board",
+  "state-node",
+  "transition-arrow",
+  "variable-panel",
+
+  // ── Templates (non-game) ──────────────────────────────────────────
+  "auth-layout",
+  "counter-template",
+  "dashboard-layout",
+  "generic-app-template",
+]);
+
+// Alternative names that map to the same organism
+const ALIASES = {
+  form: null, // explicitly allowed
+  "form-section": null, // explicitly allowed
+};
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Behavior schemas must only use atom and molecule patterns. " +
+        "Organisms and templates (except canvas game organisms and form-section) are forbidden.",
+      category: "Almadar Architecture",
+    },
+    messages: {
+      blockedPattern:
+        'Pattern "{{pattern}}" is an organism/template. ' +
+        "Behaviors must only use atoms and molecules. " +
+        "Replace with a molecule-level equivalent or restructure the schema.",
+    },
+    schema: [],
+  },
+
+  create(context) {
+    const filename = context.filename || context.getFilename();
+
+    // Only apply to .orb files inside behaviors/ directories
+    if (!filename.endsWith(".orb") || !filename.includes("behaviors")) {
+      return {};
+    }
+
+    return {
+      // jsonc-eslint-parser provides JSONProperty AST nodes
+      JSONProperty(node) {
+        // Look for "type": "<pattern-name>" properties
+        if (
+          node.key &&
+          node.key.type === "JSONLiteral" &&
+          node.key.value === "type" &&
+          node.value &&
+          node.value.type === "JSONLiteral" &&
+          typeof node.value.value === "string"
+        ) {
+          const pattern = node.value.value;
+
+          // Skip explicitly allowed aliases
+          if (pattern in ALIASES) return;
+
+          if (BLOCKED_PATTERNS.has(pattern)) {
+            context.report({
+              node: node.value,
+              messageId: "blockedPattern",
+              data: { pattern },
+            });
+          }
+        }
+      },
+    };
+  },
+};