@almadar/eslint-plugin 2.2.0 → 2.4.1

package/index.js

@@ -8,6 +8,7 @@ const templateNoIteration = require("./rules/template-no-iteration");
 const templateSerializableProps = require("./rules/template-serializable-props");
 const noTypeProp = require("./rules/no-type-prop");
 const noAsAny = require("./rules/no-as-any");
+const noEntityStringType = require("./rules/no-entity-string-type");
 const noImportGenerated = require("./rules/no-import-generated");
 const noUseNavigate = require("./rules/no-use-navigate");
 const requireEventBus = require("./rules/require-event-bus");
@@ -22,8 +23,12 @@ const organismNoAutoFetch = require("./rules/organism-no-auto-fetch");
 const organismNoCallbackProps = require("./rules/organism-no-callback-props");
 const organismExtendsEntityDisplay = require("./rules/organism-extends-entity-display");
 const organismRenderingStateOnly = require("./rules/organism-rendering-state-only");
+const organismRequireEntityRow = require("./rules/organism-require-entity-row");
 
-// Service rules
+// Atom/molecule rules
+const atomMoleculeNoEntityProp = require("./rules/atom-molecule-no-entity-prop");
+
+// Service rules - Phase 1-3 (Implemented)
 const serviceLazySingleton = require("./rules/service-lazy-singleton");
 const serviceSingletonResettable = require("./rules/service-singleton-resettable");
 const serviceNoModuleSideEffects = require("./rules/service-no-module-side-effects");
@@ -32,6 +37,16 @@ const serviceEventNameScreaming = require("./rules/service-event-name-screaming"
 const serviceIntegrationExtendsBase = require("./rules/service-integration-extends-base");
 const serviceStoreIsolation = require("./rules/service-store-isolation");
 
+// Service rules - Phase 4 (New)
+const serviceBarrelComplete = require("./rules/service-barrel-complete");
+const serviceSubpathMatchTsup = require("./rules/service-subpath-match-tsup");
+const serviceNoWorkspaceRefs = require("./rules/service-no-workspace-refs");
+const serviceExternalDeclared = require("./rules/service-external-declared");
+
+// Service rules - Additional (New)
+const serviceUseEventbus = require("./rules/service-use-eventbus");
+const serviceNoInlineQueries = require("./rules/service-no-inline-queries");
+
 const plugin = {
   meta: {
     name: "@almadar/eslint-plugin",
@@ -47,6 +62,7 @@ const plugin = {
     "template-serializable-props": templateSerializableProps,
     "no-type-prop": noTypeProp,
     "no-as-any": noAsAny,
+    "no-entity-string-type": noEntityStringType,
     "no-import-generated": noImportGenerated,
     "no-use-navigate": noUseNavigate,
     "require-event-bus": requireEventBus,
@@ -61,8 +77,12 @@ const plugin = {
     "organism-no-callback-props": organismNoCallbackProps,
     "organism-extends-entity-display": organismExtendsEntityDisplay,
     "organism-rendering-state-only": organismRenderingStateOnly,
+    "organism-require-entity-row": organismRequireEntityRow,
 
-    // Service rules
+    // Atom/molecule rules
+    "atom-molecule-no-entity-prop": atomMoleculeNoEntityProp,
+
+    // Service rules - Phase 1-3
     "service-lazy-singleton": serviceLazySingleton,
     "service-singleton-resettable": serviceSingletonResettable,
     "service-no-module-side-effects": serviceNoModuleSideEffects,
@@ -70,6 +90,16 @@ const plugin = {
     "service-event-name-screaming": serviceEventNameScreaming,
     "service-integration-extends-base": serviceIntegrationExtendsBase,
     "service-store-isolation": serviceStoreIsolation,
+
+    // Service rules - Phase 4
+    "service-barrel-complete": serviceBarrelComplete,
+    "service-subpath-match-tsup": serviceSubpathMatchTsup,
+    "service-no-workspace-refs": serviceNoWorkspaceRefs,
+    "service-external-declared": serviceExternalDeclared,
+
+    // Service rules - Additional
+    "service-use-eventbus": serviceUseEventbus,
+    "service-no-inline-queries": serviceNoInlineQueries,
   },
 
   configs: {},
@@ -90,8 +120,10 @@ plugin.configs.recommended = {
     "almadar/template-serializable-props": "error",
     "almadar/no-type-prop": "error",
     "almadar/no-as-any": "error",
+    "almadar/no-entity-string-type": "error",
     "almadar/no-import-generated": "error",
     "almadar/no-use-navigate": "error",
+    "almadar/atom-molecule-no-entity-prop": "error",
 
     // Warn-level — conventions that should be followed
     "almadar/require-event-bus": "warn",
@@ -108,6 +140,7 @@ plugin.configs.recommended = {
     "almadar/organism-no-callback-props": "error",
     "almadar/organism-extends-entity-display": "error",
     "almadar/organism-rendering-state-only": "warn",
+    "almadar/organism-require-entity-row": "error",
   },
 };
 
@@ -147,6 +180,7 @@ plugin.configs.organisms = {
     "almadar/organism-rendering-state-only": "warn",
     "almadar/require-event-bus": "error",
     "almadar/require-closed-circuit-props": "error",
+    "almadar/organism-require-entity-row": "error",
   },
 };
 
@@ -154,6 +188,7 @@ plugin.configs.organisms = {
 plugin.configs.services = {
   plugins: { almadar: plugin },
   rules: {
+    // Phase 1-3
     "almadar/service-lazy-singleton": "error",
     "almadar/service-singleton-resettable": "error",
     "almadar/service-no-module-side-effects": "error",
@@ -161,13 +196,22 @@ plugin.configs.services = {
     "almadar/service-event-name-screaming": "error",
     "almadar/service-integration-extends-base": "error",
     "almadar/service-store-isolation": "error",
+    // Phase 4
+    "almadar/service-barrel-complete": "warn",
+    "almadar/service-subpath-match-tsup": "warn",
+    "almadar/service-no-workspace-refs": "error",
+    "almadar/service-external-declared": "error",
+    // Additional
+    "almadar/service-use-eventbus": "warn",
+    "almadar/service-no-inline-queries": "error",
   },
 };
 
-// Services strict config — all service rules as error (same for now, diverges as warn-level rules are added)
+// Services strict config — all service rules as error
 plugin.configs["services-strict"] = {
   plugins: { almadar: plugin },
   rules: {
+    // Phase 1-3
     "almadar/service-lazy-singleton": "error",
     "almadar/service-singleton-resettable": "error",
     "almadar/service-no-module-side-effects": "error",
@@ -175,6 +219,14 @@ plugin.configs["services-strict"] = {
     "almadar/service-event-name-screaming": "error",
     "almadar/service-integration-extends-base": "error",
     "almadar/service-store-isolation": "error",
+    // Phase 4
+    "almadar/service-barrel-complete": "error",
+    "almadar/service-subpath-match-tsup": "error",
+    "almadar/service-no-workspace-refs": "error",
+    "almadar/service-external-declared": "error",
+    // Additional
+    "almadar/service-use-eventbus": "error",
+    "almadar/service-no-inline-queries": "error",
   },
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@almadar/eslint-plugin",
-  "version": "2.2.0",
+  "version": "2.4.1",
   "private": false,
   "description": "Custom ESLint rules for Almadar component architecture",
   "main": "index.js",
@@ -12,11 +12,17 @@
   "peerDependencies": {
     "eslint": ">=8.0.0"
   },
+  "devDependencies": {
+    "eslint": "10.0.0"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/almadar-io/almadar-eslint.git"
   },
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "lint": "eslint index.js rules/ utils/"
   }
 }

package/rules/atom-molecule-no-entity-prop.js

@@ -0,0 +1,82 @@
+"use strict";
+const { isAtomOrMolecule, isStoryFile } = require("../utils/helpers");
+
+/**
+ * Exceptions: molecules that legitimately need entity-like array data props
+ * because they are data-iteration components (mini-organisms promoted to molecules).
+ */
+const EXCEPTED_FILES = new Set([
+  "DataGrid",
+  "DataList",
+  "ButtonGroup",    // uses entity as string name for event context
+  "FilterGroup",    // uses entity as string name for filter events
+  "SearchInput",    // uses entity as string name for search events
+]);
+
+function isExcepted(filename) {
+  for (const name of EXCEPTED_FILES) {
+    if (filename.endsWith(`/${name}.tsx`) || filename.endsWith(`/${name}.jsx`)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow 'entity' prop on atoms and molecules. Atoms/molecules are pure UI building blocks that accept normal typed props. Only organisms and templates should accept 'entity'.",
+      category: "Almadar Architecture",
+    },
+    messages: {
+      noEntityProp:
+        "Atoms and molecules must not accept an 'entity' prop. Use normal typed props instead (e.g., markers, nodes, items). Only organisms and templates should be entity-aware.",
+    },
+    schema: [],
+  },
+
+  create(context) {
+    const filename = context.filename || context.getFilename();
+    if (!isAtomOrMolecule(filename)) return {};
+    if (isStoryFile(filename)) return {};
+    if (isExcepted(filename)) return {};
+
+    return {
+      // Check interface declarations: interface FooProps { entity?: ... }
+      TSPropertySignature(node) {
+        if (
+          node.key?.type === "Identifier" &&
+          node.key.name === "entity"
+        ) {
+          // Only flag if inside an interface ending with "Props"
+          const parent = node.parent?.parent;
+          if (
+            parent?.type === "TSInterfaceDeclaration" &&
+            parent.id?.name?.endsWith("Props")
+          ) {
+            context.report({ node, messageId: "noEntityProp" });
+          }
+        }
+      },
+
+      // Check type alias declarations: type FooProps = { entity?: ... }
+      TSTypeAliasDeclaration(node) {
+        if (!node.id?.name?.endsWith("Props")) return;
+        const typeAnnotation = node.typeAnnotation;
+        if (typeAnnotation?.type !== "TSTypeLiteral") return;
+
+        for (const member of typeAnnotation.members) {
+          if (
+            member.type === "TSPropertySignature" &&
+            member.key?.type === "Identifier" &&
+            member.key.name === "entity"
+          ) {
+            context.report({ node: member, messageId: "noEntityProp" });
+          }
+        }
+      },
+    };
+  },
+};

package/rules/no-entity-string-type.js

@@ -0,0 +1,84 @@
+"use strict";
+
+/**
+ * Rule: no-entity-string-type
+ *
+ * Prevents typing the `entity` prop as `string` in TypeScript interfaces and type aliases.
+ * Entity props must carry actual data (objects, arrays, or domain types), never string identifiers.
+ */
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow typing the 'entity' prop as 'string' — entity carries data, not a type name",
+      category: "Almadar Architecture",
+    },
+    messages: {
+      noEntityString:
+        "The 'entity' prop must not be typed as 'string'. Use a proper entity type (object, array, or domain interface) instead.",
+    },
+    schema: [],
+  },
+
+  create(context) {
+    /**
+     * Check if a type annotation contains 'string' at any level
+     * (direct TSStringKeyword, or inside a union/intersection).
+     */
+    function typeIncludesString(typeNode) {
+      if (!typeNode) return false;
+
+      // Direct string keyword
+      if (typeNode.type === "TSStringKeyword") return true;
+
+      // Union: string | Foo
+      if (typeNode.type === "TSUnionType") {
+        return typeNode.types.some(typeIncludesString);
+      }
+
+      // Intersection: string & Foo (unlikely but defensive)
+      if (typeNode.type === "TSIntersectionType") {
+        return typeNode.types.some(typeIncludesString);
+      }
+
+      return false;
+    }
+
+    /**
+     * Check a property signature (interface member or type literal member)
+     */
+    function checkPropertySignature(node) {
+      // Only check properties named "entity"
+      const key = node.key;
+      if (!key) return;
+
+      const propName =
+        key.type === "Identifier"
+          ? key.name
+          : key.type === "Literal"
+            ? String(key.value)
+            : null;
+
+      if (propName !== "entity") return;
+
+      // Check the type annotation
+      const typeAnnotation = node.typeAnnotation;
+      if (!typeAnnotation) return;
+
+      const typeNode =
+        typeAnnotation.type === "TSTypeAnnotation"
+          ? typeAnnotation.typeAnnotation
+          : typeAnnotation;
+
+      if (typeIncludesString(typeNode)) {
+        context.report({ node, messageId: "noEntityString" });
+      }
+    }
+
+    return {
+      TSPropertySignature: checkPropertySignature,
+    };
+  },
+};

package/rules/organism-require-entity-row.js

@@ -0,0 +1,179 @@
+"use strict";
+const { isOrganism, isStoryFile, isGameOrganism } = require("../utils/helpers");
+
+/**
+ * Find the outermost JSX element returned from a .map() callback.
+ * Handles: arrow with expression body, arrow with block body + return,
+ * and conditional expressions.
+ */
+function getReturnedJSX(callbackBody) {
+  if (
+    callbackBody.type === "JSXElement" ||
+    callbackBody.type === "JSXFragment"
+  ) {
+    return callbackBody;
+  }
+
+  if (callbackBody.type === "ConditionalExpression") {
+    return (
+      getReturnedJSX(callbackBody.consequent) ||
+      getReturnedJSX(callbackBody.alternate)
+    );
+  }
+
+  if (callbackBody.type === "BlockStatement") {
+    for (const stmt of callbackBody.body) {
+      if (stmt.type === "ReturnStatement" && stmt.argument) {
+        const jsx = getReturnedJSX(stmt.argument);
+        if (jsx) return jsx;
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Check if a JSX element has a specific attribute (by name).
+ */
+function hasJSXAttribute(jsxElement, attrName) {
+  if (jsxElement.type !== "JSXElement") return false;
+  return jsxElement.openingElement.attributes.some(
+    (attr) =>
+      attr.type === "JSXAttribute" &&
+      attr.name?.type === "JSXIdentifier" &&
+      attr.name.name === attrName
+  );
+}
+
+/**
+ * Check if a JSX element has key={param.id} where param is the callback's
+ * first parameter. This distinguishes entity iteration (key={hero.id})
+ * from utility iteration (key={field}, key={index}, key={actionIdx}).
+ */
+function hasEntityKeyPattern(jsxElement, callbackParam) {
+  if (jsxElement.type !== "JSXElement") return false;
+  if (!callbackParam) return false;
+
+  // Get the callback parameter name
+  const paramName =
+    callbackParam.type === "Identifier"
+      ? callbackParam.name
+      : callbackParam.type === "ObjectPattern"
+        ? null // destructured param, check differently
+        : null;
+
+  for (const attr of jsxElement.openingElement.attributes) {
+    if (attr.type !== "JSXAttribute") continue;
+    if (attr.name?.type !== "JSXIdentifier" || attr.name.name !== "key") continue;
+
+    const value = attr.value;
+    if (!value || value.type !== "JSXExpressionContainer") continue;
+
+    const expr = value.expression;
+
+    // key={param.id} pattern
+    if (
+      paramName &&
+      expr.type === "MemberExpression" &&
+      expr.object?.type === "Identifier" &&
+      expr.object.name === paramName &&
+      expr.property?.type === "Identifier" &&
+      expr.property.name === "id"
+    ) {
+      return true;
+    }
+
+    // key={param?.id} optional chaining
+    if (
+      paramName &&
+      expr.type === "ChainExpression" &&
+      expr.expression?.type === "MemberExpression" &&
+      expr.expression.object?.type === "Identifier" &&
+      expr.expression.object.name === paramName &&
+      expr.expression.property?.type === "Identifier" &&
+      expr.expression.property.name === "id"
+    ) {
+      return true;
+    }
+
+    // Destructured: key={id} when param is { id, ... }
+    if (
+      callbackParam.type === "ObjectPattern" &&
+      expr.type === "Identifier" &&
+      expr.name === "id"
+    ) {
+      // Verify 'id' is actually destructured from the param
+      const hasId = callbackParam.properties.some(
+        (p) =>
+          p.type === "Property" &&
+          p.key?.type === "Identifier" &&
+          p.key.name === "id"
+      );
+      if (hasId) return true;
+    }
+  }
+
+  return false;
+}
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Require data-entity-row attribute on the outermost JSX element returned from .map() in organisms when iterating over entities",
+      category: "Almadar Architecture",
+    },
+    messages: {
+      missingEntityRow:
+        "Entity row element in .map() is missing 'data-entity-row' attribute. Add it to the root DOM element of each entity card so the verification system can detect entity rows.",
+    },
+    schema: [],
+  },
+  create(context) {
+    const filename = context.filename || context.getFilename();
+
+    if (!isOrganism(filename) || isStoryFile(filename)) return {};
+    if (isGameOrganism(filename)) return {};
+
+    return {
+      CallExpression(node) {
+        if (
+          node.callee.type !== "MemberExpression" ||
+          node.callee.property.type !== "Identifier" ||
+          node.callee.property.name !== "map"
+        ) {
+          return;
+        }
+
+        const callback = node.arguments[0];
+        if (!callback) return;
+
+        let body;
+        if (
+          callback.type === "ArrowFunctionExpression" ||
+          callback.type === "FunctionExpression"
+        ) {
+          body = callback.body;
+        } else {
+          return;
+        }
+
+        const jsxElement = getReturnedJSX(body);
+        if (!jsxElement || jsxElement.type !== "JSXElement") return;
+
+        // Only flag entity iteration: key={param.id} pattern
+        const callbackParam = callback.params[0];
+        if (!hasEntityKeyPattern(jsxElement, callbackParam)) return;
+
+        if (!hasJSXAttribute(jsxElement, "data-entity-row")) {
+          context.report({
+            node: jsxElement.openingElement,
+            messageId: "missingEntityRow",
+          });
+        }
+      },
+    };
+  },
+};

package/rules/require-closed-circuit-props.js

@@ -3,7 +3,7 @@
 const { isOrganism } = require("../utils/helpers");
 
 const REQUIRED_PROPS = ["className"];
-const RECOMMENDED_PROPS = ["isLoading", "error", "entity", "data", "sortBy", "sortDirection", "page", "pageSize", "totalCount", "searchValue"];
+const RECOMMENDED_PROPS = ["isLoading", "error", "entity", "sortBy", "sortDirection", "page", "pageSize", "totalCount", "searchValue"];
 
 module.exports = {
   meta: {

package/rules/require-translate.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const { isStoryFile, isTemplateFile, isAtomOrMolecule, isOrganism } = require("../utils/helpers");
+const { isStoryFile, isTemplateFile, isOrganism } = require("../utils/helpers");
 
 /**
  * Check if a file is inside a molecules/ directory.

package/rules/service-barrel-complete.js

@@ -0,0 +1,129 @@
+"use strict";
+
+/**
+ * @fileoverview Rule to ensure all public functions are exported from barrel files (index.ts)
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Ensure all public functions are exported from barrel files (index.ts)",
+      category: "Almadar Services",
+      recommended: true,
+    },
+    messages: {
+      missingFromBarrel: "Public export '{{name}}' from '{{source}}' is not re-exported in '{{barrel}}'.",
+      notExported: "Function '{{name}}' is declared but not exported. Add export keyword or include in index.ts.",
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          barrelFile: {
+            type: "string",
+            default: "index.ts",
+          },
+          ignorePrivate: {
+            type: "boolean",
+            default: true,
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+
+  create(context) {
+    const options = context.options[0] || {};
+    const barrelFileName = options.barrelFile || "index.ts";
+    void options.ignorePrivate;
+
+    const filename = context.filename;
+    const dir = path.dirname(filename);
+    const barrelPath = path.join(dir, barrelFileName);
+
+    // Skip if this IS the barrel file itself
+    if (path.basename(filename) === barrelFileName) {
+      return {};
+    }
+
+    // Skip if no barrel file exists
+    if (!fs.existsSync(barrelPath)) {
+      return {};
+    }
+
+    // Read barrel file content
+    let barrelContent = "";
+    try {
+      barrelContent = fs.readFileSync(barrelPath, "utf-8");
+    } catch {
+      return {};
+    }
+
+    // Track exports in this file
+    const fileExports = new Set();
+
+    return {
+      // Export declarations: export function foo() {}
+      ExportNamedDeclaration(node) {
+        if (node.declaration) {
+          if (node.declaration.type === "FunctionDeclaration" && node.declaration.id) {
+            fileExports.add(node.declaration.id.name);
+          } else if (node.declaration.type === "VariableDeclaration") {
+            node.declaration.declarations.forEach((decl) => {
+              if (decl.id && decl.id.type === "Identifier") {
+                fileExports.add(decl.id.name);
+              }
+            });
+          } else if (node.declaration.type === "ClassDeclaration" && node.declaration.id) {
+            fileExports.add(node.declaration.id.name);
+          }
+        }
+        // Handle: export { foo, bar }
+        if (node.specifiers) {
+          node.specifiers.forEach((spec) => {
+            if (spec.exported && spec.exported.type === "Identifier") {
+              fileExports.add(spec.exported.name);
+            }
+          });
+        }
+      },
+
+      // Export default: export default foo
+      ExportDefaultDeclaration(node) {
+        if (node.declaration && node.declaration.type === "Identifier") {
+          fileExports.add(node.declaration.name);
+        }
+      },
+
+      // Check function declarations at end of file
+      "Program:exit"() {
+        fileExports.forEach((name) => {
+          // Check if this export is in the barrel file
+          // Look for: export { name } or export * from './this-file'
+          const exportPattern = new RegExp(`export\\s*\\{[^}]*\\b${name}\\b`, "i");
+          const starExportPattern = new RegExp(`export\\s*\\*\\s*from\\s*['"]\\.\\/${path.basename(filename, path.extname(filename))}['"]`, "i");
+          
+          const isInBarrel = exportPattern.test(barrelContent) || 
+                            starExportPattern.test(barrelContent);
+
+          if (!isInBarrel) {
+            context.report({
+              node: context.getSourceCode().ast,
+              messageId: "missingFromBarrel",
+              data: {
+                name,
+                source: path.basename(filename),
+                barrel: barrelFileName,
+              },
+            });
+          }
+        });
+      },
+    };
+  },
+};

package/rules/service-external-declared.js

@@ -0,0 +1,172 @@
+"use strict";
+
+/**
+ * @fileoverview Rule to ensure all imports are declared in package.json dependencies
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Ensure all imports are declared in package.json dependencies",
+      category: "Almadar Services",
+      recommended: true,
+    },
+    messages: {
+      undeclaredImport: "Import '{{package}}' is not declared in package.json dependencies. Add to dependencies, devDependencies, or peerDependencies.",
+      missingPackageJson: "Could not find package.json to validate imports.",
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowBuiltin: {
+            type: "boolean",
+            default: true,
+          },
+          allowInternal: {
+            type: "boolean",
+            default: true,
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+
+  create(context) {
+    const options = context.options[0] || {};
+    const allowBuiltin = options.allowBuiltin !== false;
+    const allowInternal = options.allowInternal !== false;
+
+    // Find package.json
+    let dir = path.dirname(context.filename);
+    let pkgPath = null;
+    let pkg = null;
+
+    while (dir !== path.dirname(dir)) {
+      const candidate = path.join(dir, "package.json");
+      if (fs.existsSync(candidate)) {
+        pkgPath = candidate;
+        break;
+      }
+      dir = path.dirname(dir);
+    }
+
+    if (!pkgPath) {
+      return {};
+    }
+
+    try {
+      pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    } catch {
+      return {};
+    }
+
+    // Collect all declared dependencies
+    const declaredDeps = new Set();
+    ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"].forEach((field) => {
+      if (pkg[field]) {
+        Object.keys(pkg[field]).forEach((dep) => declaredDeps.add(dep));
+      }
+    });
+
+    // Node.js built-in modules
+    const builtinModules = new Set([
+      "assert", "buffer", "child_process", "cluster", "console", "constants",
+      "crypto", "dgram", "dns", "domain", "events", "fs", "http", "https",
+      "module", "net", "os", "path", "punycode", "querystring", "readline",
+      "repl", "stream", "string_decoder", "sys", "timers", "tls", "tty",
+      "url", "util", "v8", "vm", "zlib", "worker_threads", "perf_hooks",
+      "async_hooks", "http2", "diagnostics_channel", "stream/web",
+    ]);
+
+    return {
+      ImportDeclaration(node) {
+        const source = node.source.value;
+        
+        // Skip relative imports
+        if (source.startsWith(".") || source.startsWith("/")) {
+          return;
+        }
+
+        // Skip internal package imports (e.g., @almadar/* in monorepo)
+        if (allowInternal && source.startsWith("@almadar/")) {
+          // Only check if it's actually in the monorepo
+          // For now, assume internal packages are allowed
+          return;
+        }
+
+        // Extract package name (handle @scope/pkg and scoped packages with subpaths)
+        let packageName = source;
+        if (source.startsWith("@")) {
+          // @scope/pkg or @scope/pkg/subpath
+          const parts = source.split("/");
+          packageName = `${parts[0]}/${parts[1]}`;
+        } else {
+          // pkg or pkg/subpath
+          packageName = source.split("/")[0];
+        }
+
+        // Skip built-in modules
+        if (allowBuiltin && builtinModules.has(packageName)) {
+          return;
+        }
+
+        // Skip Node: prefixed imports
+        if (packageName.startsWith("node:")) {
+          return;
+        }
+
+        // Check if declared
+        if (!declaredDeps.has(packageName)) {
+          context.report({
+            node,
+            messageId: "undeclaredImport",
+            data: { package: packageName },
+          });
+        }
+      },
+
+      // Handle require() calls
+      CallExpression(node) {
+        if (
+          node.callee.type === "Identifier" &&
+          node.callee.name === "require" &&
+          node.arguments.length > 0 &&
+          node.arguments[0].type === "Literal" &&
+          typeof node.arguments[0].value === "string"
+        ) {
+          const source = node.arguments[0].value;
+          
+          if (source.startsWith(".") || source.startsWith("/")) {
+            return;
+          }
+
+          if (allowInternal && source.startsWith("@almadar/")) {
+            return;
+          }
+
+          let packageName = source;
+          if (source.startsWith("@")) {
+            const parts = source.split("/");
+            packageName = `${parts[0]}/${parts[1]}`;
+          } else {
+            packageName = source.split("/")[0];
+          }
+
+          if (!declaredDeps.has(packageName)) {
+            context.report({
+              node,
+              messageId: "undeclaredImport",
+              data: { package: packageName },
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/rules/service-no-inline-queries.js

@@ -0,0 +1,117 @@
+"use strict";
+
+/**
+ * @fileoverview Rule to prevent inline Firestore queries in route handlers
+ */
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Prevent inline Firestore queries embedded in route handlers",
+      category: "Almadar Services",
+      recommended: true,
+    },
+    messages: {
+      inlineFirestore: "Inline Firestore query detected. Extract to DataService or use StoreContract abstraction.",
+      directDbAccess: "Direct database access in route handler. Use service layer (DataService) instead.",
+      firestoreImport: "Firestore imports should not be used directly in route files. Use service abstraction.",
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          routePatterns: {
+            type: "array",
+            items: { type: "string" },
+            default: ["routes/", "src/routes/", "api/"],
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+
+  create(context) {
+    const options = context.options[0] || {};
+    const routePatterns = options.routePatterns || ["routes/", "src/routes/", "api/"];
+
+    const filename = context.filename;
+    
+    // Check if this is a route file
+    const isRouteFile = routePatterns.some((pattern) => filename.includes(pattern));
+    
+    // Also check if it looks like a route handler (contains route handler patterns)
+    let hasRouteHandlerPattern = false;
+    
+    return {
+      // Check for Firestore imports
+      ImportDeclaration(node) {
+        const source = node.source.value;
+        
+        if (source.includes("firebase-admin") || source.includes("@google-cloud/firestore")) {
+          if (isRouteFile) {
+            context.report({
+              node,
+              messageId: "firestoreImport",
+            });
+          }
+        }
+      },
+
+      // Check for Express route handler patterns
+      "CallExpression[callee.object.name='app'][callee.property.name=/^(get|post|put|delete|patch)$/]"(_node) {
+        hasRouteHandlerPattern = true;
+      },
+
+      "CallExpression[callee.object.name='router'][callee.property.name=/^(get|post|put|delete|patch)$/]"(_node) {
+        hasRouteHandlerPattern = true;
+      },
+
+      // Check for Firestore method calls
+      "CallExpression[callee.type='MemberExpression']"(node) {
+        const callee = node.callee;
+        
+        // Check for db.collection(), doc.get(), etc.
+        if (callee.property && callee.property.type === "Identifier") {
+          const methodName = callee.property.name;
+          
+          const firestoreMethods = [
+            "collection", "doc", "get", "set", "update", "delete", 
+            "where", "orderBy", "limit", "startAfter", "endBefore",
+            "add", "batch", "runTransaction"
+          ];
+          
+          if (firestoreMethods.includes(methodName)) {
+            // Check if this is being called on a Firestore-like object
+            const objectName = callee.object.name || 
+                              (callee.object.property && callee.object.property.name);
+            
+            const firestoreObjectNames = ["db", "firestore", "admin", "firestoreDb", "firebase"];
+            
+            if (objectName && firestoreObjectNames.some(name => 
+              objectName.toLowerCase().includes(name)
+            )) {
+              if (isRouteFile || hasRouteHandlerPattern) {
+                context.report({
+                  node,
+                  messageId: "inlineFirestore",
+                });
+              }
+            }
+          }
+        }
+      },
+
+      // Check for direct db access patterns
+      "MemberExpression[object.name='db']"(node) {
+        if (isRouteFile || hasRouteHandlerPattern) {
+          context.report({
+            node,
+            messageId: "directDbAccess",
+          });
+        }
+      },
+    };
+  },
+};

package/rules/service-no-workspace-refs.js

@@ -0,0 +1,76 @@
+"use strict";
+
+/**
+ * @fileoverview Rule to prevent workspace:* references in published packages
+ */
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Prevent workspace:* references in published package.json dependencies",
+      category: "Almadar Services",
+      recommended: true,
+    },
+    messages: {
+      workspaceRef: "Workspace reference '{{ref}}' found in '{{field}}'. Use explicit version for published packages.",
+      workspaceProtocol: "workspace: protocol found in '{{field}}'. This will fail when package is published.",
+    },
+    schema: [],
+  },
+
+  create(context) {
+    // Only check package.json files
+    if (!context.filename.endsWith("package.json")) {
+      return {};
+    }
+
+    return {
+      Program(node) {
+        const sourceCode = context.getSourceCode();
+        const text = sourceCode.getText();
+        
+        let pkg;
+        try {
+          pkg = JSON.parse(text);
+        } catch {
+          return;
+        }
+
+        // Check if this is a private package
+        if (pkg.private === true) {
+          return;
+        }
+
+        // Check all dependency fields
+        const depFields = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
+        
+        for (const field of depFields) {
+          const deps = pkg[field];
+          if (!deps || typeof deps !== "object") {
+            continue;
+          }
+
+          for (const [, version] of Object.entries(deps)) {
+            // Check for workspace:*
+            if (version === "workspace:*" || version === "workspace:") {
+              context.report({
+                node,
+                messageId: "workspaceRef",
+                data: { ref: version, field },
+              });
+            }
+            // Check for any workspace: protocol
+            if (typeof version === "string" && version.startsWith("workspace:")) {
+              context.report({
+                node,
+                messageId: "workspaceProtocol",
+                data: { field },
+              });
+            }
+          }
+        }
+      },
+    };
+  },
+};

package/rules/service-subpath-match-tsup.js

@@ -0,0 +1,89 @@
+"use strict";
+
+/**
+ * @fileoverview Rule to ensure package.json exports match tsup build configuration
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Ensure package.json exports match tsup build entries",
+      category: "Almadar Services",
+      recommended: true,
+    },
+    messages: {
+      exportMismatch: "package.json export '{{exportPath}}' does not match any tsup entry.",
+      missingExport: "tsup entry '{{entry}}' is not exported in package.json.",
+      invalidPattern: "Export pattern '{{pattern}}' does not match expected format (./dist/*.js).",
+    },
+    schema: [],
+  },
+
+  create(context) {
+    // Only check package.json files
+    if (!context.filename.endsWith("package.json")) {
+      return {};
+    }
+
+    const dir = path.dirname(context.filename);
+    const tsupConfigPath = path.join(dir, "tsup.config.ts");
+
+    // Skip if no tsup config
+    if (!fs.existsSync(tsupConfigPath)) {
+      return {};
+    }
+
+    return {
+      Program(node) {
+        const sourceCode = context.getSourceCode();
+        const text = sourceCode.getText();
+        
+        let pkg;
+        try {
+          pkg = JSON.parse(text);
+        } catch {
+          return;
+        }
+
+        // Read tsup config (simplified - just check if entries exist)
+        let tsupContent = "";
+        try {
+          tsupContent = fs.readFileSync(tsupConfigPath, "utf-8");
+        } catch {
+          return;
+        }
+
+        // Extract entry points from tsup config
+        // Look for: entry: ['src/index.ts'] or entry: { main: 'src/index.ts' }
+        const entryMatch = tsupContent.match(/entry\s*:\s*(\[[^\]]+\]|\{[^}]+\})/);
+        if (!entryMatch) {
+          return;
+        }
+
+        const exports = pkg.exports || {};
+        
+        // Check each export has a corresponding tsup entry
+        for (const [exportPath] of Object.entries(exports)) {
+          if (exportPath.startsWith("./")) {
+            // Check if there's a matching entry in tsup
+            const hasMatchingEntry = tsupContent.includes(exportPath.replace(/^\.\//, "src/")) ||
+                                    tsupContent.includes(exportPath.replace(/^\.\//, "")) ||
+                                    (exportPath === "." && tsupContent.includes("src/index"));
+
+            if (!hasMatchingEntry) {
+              context.report({
+                node,
+                messageId: "exportMismatch",
+                data: { exportPath },
+              });
+            }
+          }
+        }
+      },
+    };
+  },
+};

package/rules/service-use-eventbus.js

@@ -0,0 +1,144 @@
+"use strict";
+
+/**
+ * @fileoverview Rule to enforce EventBus usage over direct function calls between modules
+ */
+
+const path = require("path");
+
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce EventBus usage over direct function calls between modules",
+      category: "Almadar Services",
+      recommended: true,
+    },
+    messages: {
+      directCall: "Cross-module function call to '{{function}}' from '{{module}}'. Consider using EventBus for loose coupling.",
+      directImport: "Direct import from service module '{{module}}'. Use EventBus or service factory instead.",
+      useEventBus: "Use getGlobalEventBus() or eventBus.emit() for cross-module communication instead of direct function calls.",
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          servicePaths: {
+            type: "array",
+            items: { type: "string" },
+            default: ["src/services/", "src/lib/"],
+          },
+          allowSameDirectory: {
+            type: "boolean",
+            default: true,
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+
+  create(context) {
+    const options = context.options[0] || {};
+    const servicePaths = options.servicePaths || ["src/services/", "src/lib/"];
+    const allowSameDirectory = options.allowSameDirectory !== false;
+
+    const filename = context.filename;
+    const currentDir = path.dirname(filename);
+
+    // Track imports from service directories
+    const serviceImports = new Map();
+
+    return {
+      ImportDeclaration(node) {
+        const source = node.source.value;
+        
+        // Check if importing from a service path
+        const isServiceImport = servicePaths.some(sp => 
+          source.includes(sp) || source.includes("/services/")
+        );
+
+        if (!isServiceImport) {
+          return;
+        }
+
+        // Allow same directory imports
+        if (allowSameDirectory) {
+          const importDir = path.dirname(path.resolve(currentDir, source));
+          if (importDir === currentDir) {
+            return;
+          }
+        }
+
+        // Track the imported bindings
+        node.specifiers.forEach((spec) => {
+          if (spec.type === "ImportSpecifier" && spec.imported) {
+            serviceImports.set(spec.local.name, {
+              source,
+              imported: spec.imported.name,
+            });
+          } else if (spec.type === "ImportDefaultSpecifier") {
+            serviceImports.set(spec.local.name, {
+              source,
+              imported: "default",
+            });
+          } else if (spec.type === "ImportNamespaceSpecifier") {
+            serviceImports.set(spec.local.name, {
+              source,
+              imported: "*",
+            });
+          }
+        });
+
+        // Report direct service imports
+        if (source.includes("/services/") && !source.startsWith(".")) {
+          context.report({
+            node,
+            messageId: "directImport",
+            data: { module: source },
+          });
+        }
+      },
+
+      // Check for direct function calls to imported service functions
+      CallExpression(node) {
+        if (node.callee.type === "Identifier") {
+          const name = node.callee.name;
+          const importInfo = serviceImports.get(name);
+
+          if (importInfo && importInfo.source.includes("/services/")) {
+            context.report({
+              node,
+              messageId: "directCall",
+              data: {
+                function: name,
+                module: importInfo.source,
+              },
+            });
+          }
+        }
+
+        // Check for member expressions: Service.method()
+        if (
+          node.callee.type === "MemberExpression" &&
+          node.callee.object.type === "Identifier"
+        ) {
+          const objectName = node.callee.object.name;
+          const importInfo = serviceImports.get(objectName);
+
+          if (importInfo && importInfo.source.includes("/services/")) {
+            const methodName = node.callee.property.name || node.callee.property.value;
+            context.report({
+              node,
+              messageId: "directCall",
+              data: {
+                function: `${objectName}.${methodName}`,
+                module: importInfo.source,
+              },
+            });
+          }
+        }
+      },
+    };
+  },
+};