pasika 0.1.6 → 0.2.0

package/README.md

@@ -1,14 +1,13 @@
 # pasika
 
-Reusable agent setup package, starting with Claude.
+Reusable agent setup package.
 
-`pasika` stores portable agent setup assets that individual repos can apply or adapt. Today it focuses on Claude, with room for Codex and other agent-specific setup flows later.
+`pasika` stores portable agent setup assets that individual repos can apply or adapt.
 
 ## Scope
 
 This repo intentionally starts narrow:
 
-- Claude first for v1
 - reusable agent setup assets only
 - shared docs at the repo root
 - no project-specific workflows or business logic
@@ -16,32 +15,21 @@ This repo intentionally starts narrow:
 ## Layout
 
 ```text
-claude/
-  settings.base.json
-  hooks/
-    status-line/
-      index.js
-    notification.sh
-    protect-files.sh
-  scripts/
-    render-settings.ts
 docs/
-  claude/
-    hooks.md
-scripts/
-  pasika.ts
+  code-organization-guide/
+  documentation-guide/
+  styling-guide/
+  agent-conventions.md
+eslint/
+  pasika/
+    rules/
 dist/
   ...
-vulyk.json
-AGENTS.md
-CLAUDE.md
 ```
 
 ## What belongs here
 
 - portable setup scripts
-- base settings templates
-- shared docs and generated `CLAUDE.md`
 - shared naming and layout conventions
 - reusable source-organization lint rules
 
@@ -52,56 +40,39 @@ CLAUDE.md
 - repository-specific plugin choices
 - scripts that depend on a specific app, CI setup, or codebase
 
-## CLI
-
-The current entry point is:
-
-```bash
-npx pasika claude
-```
-
-Optional flags:
-
-- `--target-dir <path>` writes into another repo
-- `--force` replaces an existing generated file instead of merging
-
 ## Development
 
-The CLI source lives in TypeScript.
-
 ```bash
 npm run lint
 npm run typecheck
 npm run build
 ```
 
-`npm run build` uses `vulyk docs` to emit root `AGENTS.md` and `CLAUDE.md`.
-
-## Recommended Integration
-
-Hooks and helper executables should come from `node_modules`.
+## ESLint Pasika Ruleset
 
-That gives us:
+Pasika ships enforceable lint rules derived from its documentation. Each rule carries a `@see` annotation linking to its source doc so future audits can verify rule/doc alignment.
 
-- versioned reusable scripts
-- easy upgrades through the package manager
-- no manual copying of hook files into every repo
+### Usage with Zirka (recommended)
 
-`settings.json` is different. It still needs to exist in each project repo, because Claude Code does not give us a clean inheritance model for it.
+Enable pasika through Zirka's `styleguide`:
 
-So the recommended pattern is:
+```ts
+// eslint.config.ts
+import { RuleSeverity, styleguide } from "zirka";
 
-1. install `pasika` as a dev dependency
-2. run `npx pasika claude`
-3. generate or merge into `.claude/settings.json` in the project
-4. point hook commands at `./node_modules/pasika/claude/...`
-5. keep project-specific plugin, skill, and rule decisions in the project repo
+const { eslintConfig } = styleguide({
+  next: RuleSeverity.Error,
+  node: RuleSeverity.Error,
+  typescript: RuleSeverity.Error,
+  pasika: RuleSeverity.Error,
+});
 
-`npx pasika claude` also copies the packaged Claude hooks docs into `.claude/hooks/` in the target repo.
+export default eslintConfig;
+```
 
-## ESLint Pasika Ruleset
+### Usage without Zirka
 
-Pasika packages its source-organization rules separately from its own Node and TypeScript lint configuration. A consumer composes the exported ruleset with Zirka and enables any framework-specific Zirka blocks it needs.
+Import the config directly and compose with your own:
 
 ```ts
 // eslint.config.ts
@@ -116,3 +87,17 @@ const { eslintConfig } = styleguide({
 
 export default [...((await eslintConfig) ?? []), pasikaConfig];
 ```
+
+### Rule → Doc Mapping
+
+Every rule's source file declares the documentation it enforces. Use this table to trace a lint hit back to its reasoning:
+
+| Rule | Enforces | Source Doc |
+|---|---|---|
+| `pasika/filename-case` | Smart/PascalCase vs dumb/kebab-case file names | `docs/code-organization-guide/rules/smart-vs-dumb-component-rule.md` |
+| `pasika/import-boundaries` | Relative vs `@/*` imports, layer boundaries | `docs/code-organization-guide/rules/exports-and-imports-rule.md` |
+| `pasika/no-mixed-concerns` | One React component per `.tsx` file | `docs/code-organization-guide/rules/no-mixed-concerns-rule.md` |
+| `pasika/no-arbitrary-tailwind` | No arbitrary `-[value]` Tailwind classes | `docs/styling-guide/rules/arbitrary-value-rule.md` |
+| `pasika/enforce-cn-merge` | Use `cn()` not `+`/template literals; ≤5 classes per group | `docs/styling-guide/rules/class-composition-rule.md` |
+| `pasika/enforce-cva-variant-props` | Use `VariantProps<typeof>` not manual union types | `docs/styling-guide/rules/component-variant-rule.md` |
+| `pasika/enforce-barrel-exports` | Nested `index.ts` only re-exports the parent component | `docs/code-organization-guide/rules/folder-nesting-rule.md` |

package/dist/eslint/pasika/index.d.ts

@@ -1,2 +1,20 @@
+/**
+ * Pasika ESLint Ruleset
+ *
+ * Each rule enforces a specific documentation Rule from the `docs/` tree.
+ * Every rule file carries a `@see` annotation linking to the source doc.
+ * This mapping is maintained so future agents can audit rule/doc alignment.
+ *
+ * Rule → Doc mapping:
+ *
+ *   filename-case          → docs/code-organization-guide/rules/smart-vs-dumb-component-rule.md
+ *   import-boundaries      → docs/code-organization-guide/rules/exports-and-imports-rule.md
+ *   no-mixed-concerns      → docs/code-organization-guide/rules/no-mixed-concerns-rule.md
+ *   no-arbitrary-tailwind  → docs/styling-guide/rules/arbitrary-value-rule.md
+ *   enforce-cn-merge       → docs/styling-guide/rules/class-composition-rule.md
+ *   enforce-cva-variant-props → docs/styling-guide/rules/component-variant-rule.md
+ *   enforce-barrel-exports → docs/code-organization-guide/rules/folder-nesting-rule.md
+ *                          + docs/code-organization-guide/rules/exports-and-imports-rule.md
+ */
 import type { Linter } from "eslint";
 export declare const pasikaConfig: Linter.Config;

package/dist/eslint/pasika/index.js

@@ -1,17 +1,32 @@
 import { filenameCaseRule } from "./rules/filename-case.js";
-import { organizationImportsRule } from "./rules/organization-imports.js";
+import { importBoundariesRule } from "./rules/import-boundaries.js";
+import { noMixedConcernsRule } from "./rules/no-mixed-concerns.js";
+import { noArbitraryTailwindRule } from "./rules/no-arbitrary-tailwind.js";
+import { enforceCnMergeRule } from "./rules/enforce-cn-merge.js";
+import { enforceCvaVariantPropsRule } from "./rules/enforce-cva-variant-props.js";
+import { enforceBarrelExportsRule } from "./rules/enforce-barrel-exports.js";
 export const pasikaConfig = {
     files: ["src/**/*.{cjs,cts,js,jsx,mjs,mts,ts,tsx}"],
     plugins: {
         pasika: {
             rules: {
                 "filename-case": filenameCaseRule,
-                "organization-imports": organizationImportsRule,
+                "import-boundaries": importBoundariesRule,
+                "no-mixed-concerns": noMixedConcernsRule,
+                "no-arbitrary-tailwind": noArbitraryTailwindRule,
+                "enforce-cn-merge": enforceCnMergeRule,
+                "enforce-cva-variant-props": enforceCvaVariantPropsRule,
+                "enforce-barrel-exports": enforceBarrelExportsRule,
             },
         },
     },
     rules: {
         "pasika/filename-case": "error",
-        "pasika/organization-imports": "error",
+        "pasika/import-boundaries": "error",
+        "pasika/no-mixed-concerns": "error",
+        "pasika/no-arbitrary-tailwind": "error",
+        "pasika/enforce-cn-merge": "error",
+        "pasika/enforce-cva-variant-props": "error",
+        "pasika/enforce-barrel-exports": "error",
     },
 };

package/dist/eslint/pasika/rules/enforce-barrel-exports.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ESLint rule: pasika/enforce-barrel-exports
+ *
+ * Enforces the "Folder Nesting Rule" — index.ts only re-exports parent component.
+ *
+ * @see docs/code-organization-guide/rules/folder-nesting-rule.md
+ */
+import type { Rule } from "eslint";
+export declare const enforceBarrelExportsRule: Rule.RuleModule;

package/dist/eslint/pasika/rules/enforce-barrel-exports.js

@@ -0,0 +1,78 @@
+/**
+ * ESLint rule: pasika/enforce-barrel-exports
+ *
+ * Enforces the "Folder Nesting Rule" — index.ts only re-exports parent component.
+ *
+ * @see docs/code-organization-guide/rules/folder-nesting-rule.md
+ */
+import path from "node:path";
+import fs from "node:fs";
+function isPascalCase(str) {
+    return /^[A-Z][A-Za-z0-9]*$/.test(str);
+}
+function isKebabCase(str) {
+    return /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(str);
+}
+const SUPPORT_FOLDERS = new Set(["types", "schemas", "hooks", "constants", "utils", "config", "locales"]);
+export const enforceBarrelExportsRule = {
+    meta: {
+        schema: [],
+        type: "problem",
+        docs: {
+            description: "Enforce index.ts barrels only re-export the parent component.",
+        },
+    },
+    create(context) {
+        const filename = context.filename;
+        if (!filename)
+            return {};
+        const baseName = path.basename(filename);
+        if (baseName !== "index.ts" && baseName !== "index.cts" && baseName !== "index.mts")
+            return {};
+        const dirPath = path.dirname(filename);
+        const folderName = path.basename(dirPath);
+        const parentFolderName = path.basename(path.dirname(dirPath));
+        if (SUPPORT_FOLDERS.has(folderName))
+            return {};
+        if (!isPascalCase(folderName) && !isKebabCase(folderName))
+            return {};
+        const matchingTsx = fs.existsSync(path.join(dirPath, `${folderName}.tsx`)) ? folderName : null;
+        if (!matchingTsx)
+            return {};
+        if (!isPascalCase(parentFolderName) && !isKebabCase(parentFolderName))
+            return {};
+        const reExportedNames = new Set();
+        return {
+            ExportNamedDeclaration(node) {
+                if (!node.source)
+                    return;
+                for (const spec of node.specifiers) {
+                    if (spec.exported.type === "Identifier") {
+                        reExportedNames.add(spec.exported.name);
+                    }
+                }
+            },
+            "Program:exit"() {
+                if (reExportedNames.size === 0)
+                    return;
+                if (!reExportedNames.has(matchingTsx)) {
+                    context.report({
+                        loc: { line: 1, column: 0 },
+                        message: `index.ts in "${folderName}/" must re-export "${matchingTsx}". ` +
+                            "See docs/code-organization-guide/rules/folder-nesting-rule.md",
+                    });
+                    return;
+                }
+                const nonParentExports = [...reExportedNames].filter((n) => n !== matchingTsx);
+                if (nonParentExports.length > 0) {
+                    context.report({
+                        loc: { line: 1, column: 0 },
+                        message: `index.ts must not re-export exclusive children: ${nonParentExports.join(", ")}. ` +
+                            `Only "${matchingTsx}" may be re-exported. ` +
+                            "See docs/code-organization-guide/rules/folder-nesting-rule.md",
+                    });
+                }
+            },
+        };
+    },
+};

package/dist/eslint/pasika/rules/enforce-cn-merge.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ESLint rule: pasika/enforce-cn-merge
+ *
+ * Enforces the "Class Composition Rule".
+ *
+ * @see docs/styling-guide/rules/class-composition-rule.md
+ */
+import type { Rule } from "eslint";
+export declare const enforceCnMergeRule: Rule.RuleModule;

package/dist/eslint/pasika/rules/enforce-cn-merge.js

@@ -0,0 +1,84 @@
+/**
+ * ESLint rule: pasika/enforce-cn-merge
+ *
+ * Enforces the "Class Composition Rule".
+ *
+ * @see docs/styling-guide/rules/class-composition-rule.md
+ */
+function classCount(str) {
+    return str.split(/\s+/).filter(Boolean).length;
+}
+export const enforceCnMergeRule = {
+    meta: {
+        schema: [],
+        type: "problem",
+        docs: {
+            description: "Enforce cn() for conditional class merging.",
+        },
+    },
+    create(context) {
+        return {
+            JSXAttribute(node) {
+                if (node.name.name !== "className" && node.name.name !== "class")
+                    return;
+                const valueNode = node.value;
+                if (!valueNode)
+                    return;
+                if (valueNode.type === "Literal" && typeof valueNode.value === "string") {
+                    if (classCount(valueNode.value) > 5) {
+                        context.report({
+                            node,
+                            message: "Static className with more than 5 classes must use cn() with grouped string literals. " +
+                                "See docs/styling-guide/rules/class-composition-rule.md",
+                        });
+                    }
+                    return;
+                }
+                if (valueNode.type !== "JSXExpressionContainer" || !valueNode.expression)
+                    return;
+                const expr = valueNode.expression;
+                if (expr.type === "BinaryExpression" && expr.operator === "+") {
+                    context.report({
+                        node,
+                        message: "Use cn() instead of + operator for className. " +
+                            "See docs/styling-guide/rules/class-composition-rule.md",
+                    });
+                    return;
+                }
+                if (expr.type === "TemplateLiteral" && expr.expressions.length > 0) {
+                    context.report({
+                        node,
+                        message: "Use cn() instead of template literals with conditionals for className. " +
+                            "See docs/styling-guide/rules/class-composition-rule.md",
+                    });
+                    return;
+                }
+                if (expr.type === "Literal" && typeof expr.value === "string") {
+                    if (classCount(expr.value) > 5) {
+                        context.report({
+                            node,
+                            message: "Static className with more than 5 classes must use cn() with grouped string literals. " +
+                                "See docs/styling-guide/rules/class-composition-rule.md",
+                        });
+                    }
+                    return;
+                }
+                if (expr.type === "CallExpression" && expr.callee.type === "Identifier" && expr.callee.name === "cn") {
+                    for (const arg of expr.arguments) {
+                        if (arg.type === "Literal" && typeof arg.value === "string") {
+                            if (classCount(arg.value) > 5) {
+                                context.report({
+                                    node: arg,
+                                    message: "Each cn() string argument must contain at most 5 class names. " +
+                                        "Group by styling concern. " +
+                                        "See docs/styling-guide/rules/class-composition-rule.md",
+                                });
+                            }
+                        }
+                    }
+                }
+            },
+        };
+    },
+};
+/* eslint-enable  -- re-enable rules disabled for AST access @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-argument */

package/dist/eslint/pasika/rules/enforce-cva-variant-props.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ESLint rule: pasika/enforce-cva-variant-props
+ *
+ * Enforces the "Component Variant Rule" — VariantProps from CVA.
+ *
+ * @see docs/styling-guide/rules/component-variant-rule.md
+ */
+import type { Rule } from "eslint";
+export declare const enforceCvaVariantPropsRule: Rule.RuleModule;

package/dist/eslint/pasika/rules/enforce-cva-variant-props.js

@@ -0,0 +1,76 @@
+/**
+ * ESLint rule: pasika/enforce-cva-variant-props
+ *
+ * Enforces the "Component Variant Rule" — VariantProps from CVA.
+ *
+ * @see docs/styling-guide/rules/component-variant-rule.md
+ */
+export const enforceCvaVariantPropsRule = {
+    meta: {
+        schema: [],
+        type: "problem",
+        docs: {
+            description: "Enforce VariantProps from CVA instead of manual variant union types.",
+        },
+    },
+    create(context) {
+        const cvaDefinitions = new Map();
+        return {
+            VariableDeclarator(node) {
+                if (node.init?.type === "CallExpression" &&
+                    node.init.callee.type === "Identifier" &&
+                    node.init.callee.name === "cva" &&
+                    node.id.type === "Identifier") {
+                    const args = node.init.arguments;
+                    if (args.length < 2)
+                        return;
+                    const options = args[1];
+                    if (options?.type === "ObjectExpression") {
+                        for (const prop of options.properties) {
+                            if (prop.type === "Property" &&
+                                prop.key.type === "Identifier" &&
+                                prop.key.name === "variants" &&
+                                prop.value.type === "ObjectExpression") {
+                                const variantNames = prop.value.properties
+                                    .filter((p) => p.type === "Property" && p.key.type === "Identifier")
+                                    .map((p) => p.key.name);
+                                if (variantNames.length > 0) {
+                                    cvaDefinitions.set(node.id.name, variantNames);
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+            TSTypeAliasDeclaration(node) {
+                if (!node.id.name.endsWith("Props"))
+                    return;
+                if (node.typeAnnotation.type !== "TSTypeLiteral")
+                    return;
+                for (const member of node.typeAnnotation.members) {
+                    if (member.type === "TSPropertySignature" &&
+                        member.key.type === "Identifier" &&
+                        member.typeAnnotation?.typeAnnotation?.type === "TSUnionType") {
+                        const keyName = String(member.key.name);
+                        const typeAnn = member.typeAnnotation.typeAnnotation;
+                        const allStringLiterals = typeAnn.types.every((t) => t.type === "TSLiteralType" && t.literal.type === "StringLiteral");
+                        if (allStringLiterals && typeAnn.types.length >= 2) {
+                            for (const [, variantNames] of cvaDefinitions) {
+                                if (variantNames.includes(keyName)) {
+                                    context.report({
+                                        node: member,
+                                        message: `Variant prop "${keyName}" duplicates CVA variant values. ` +
+                                            "Use VariantProps<typeof variants> instead of manually writing union types. " +
+                                            "See docs/styling-guide/rules/component-variant-rule.md",
+                                    });
+                                    return;
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+        };
+    },
+};
+/* eslint-enable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any -- re-enable after AST node access block */

package/dist/eslint/pasika/rules/filename-case.js

@@ -1,3 +1,13 @@
+/**
+ * ESLint rule: pasika/filename-case
+ *
+ * Enforces the naming conventions from the "Smart vs Dumb Component Rule":
+ *  - Smart components: PascalCase.tsx
+ *  - Dumb components: kebab-case.tsx
+ *  - Non-component files: kebab-case
+ *
+ * @see docs/code-organization-guide/rules/smart-vs-dumb-component-rule.md
+ */
 import path from "node:path";
 /**
  * Next.js App Router routing files that are exempt from filename-case checks.

package/dist/eslint/pasika/rules/import-boundaries.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "eslint";
+export declare const importBoundariesRule: Rule.RuleModule;

package/dist/eslint/pasika/rules/{organization-imports.js → import-boundaries.js}

@@ -1,3 +1,13 @@
+/**
+ * ESLint rule: pasika/import-boundaries
+ *
+ * Enforces the import conventions from the "Exports and Imports Rule":
+ *  - Relative imports for nearby files (same folder, subfolder, one level up).
+ *  - @/* alias for imports beyond one folder up.
+ *  - Layer boundary enforcement (app → compositions → features → shared → root).
+ *
+ * @see docs/code-organization-guide/rules/exports-and-imports-rule.md
+ */
 import path from "node:path";
 const sourceRoot = path.resolve("src");
 const rootSupportFolders = new Set(["config", "constants", "hooks", "locales", "schemas", "types", "utils"]);
@@ -26,7 +36,7 @@ function isNearbyImport(filename, resolvedPath) {
     const nonParentSegments = segments.length - parentTraversals;
     return (parentTraversals === 0 && nonParentSegments <= 2) || (parentTraversals === 1 && nonParentSegments <= 1);
 }
-export const organizationImportsRule = {
+export const importBoundariesRule = {
     meta: {
         schema: [],
         type: "problem",

package/dist/eslint/pasika/rules/no-arbitrary-tailwind.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ESLint rule: pasika/no-arbitrary-tailwind
+ *
+ * Enforces the "Arbitrary Value Rule" — no arbitrary-value Tailwind classes.
+ *
+ * @see docs/styling-guide/rules/arbitrary-value-rule.md
+ */
+import type { Rule } from "eslint";
+export declare const noArbitraryTailwindRule: Rule.RuleModule;

package/dist/eslint/pasika/rules/no-arbitrary-tailwind.js

@@ -0,0 +1,107 @@
+/**
+ * ESLint rule: pasika/no-arbitrary-tailwind
+ *
+ * Enforces the "Arbitrary Value Rule" — no arbitrary-value Tailwind classes.
+ *
+ * @see docs/styling-guide/rules/arbitrary-value-rule.md
+ */
+/**
+ * Matches Tailwind arbitrary-value utility classes like rounded-[13px], text-[#fff].
+ *
+ * Does NOT match variant prefixes like min-[400px]:flex-row or md:flex.
+ * The negative lookahead (?![-\w]*:) excludes anything followed by a colon + more.
+ *
+ * Note: Tailwind breakpoint variants (sm:, md:, lg:, etc.) don't use brackets,
+ * so they're never matched. Only bracket-based variants like min-[400px]: need
+ * the lookahead exclusion.
+ */
+const ARBITRARY_VALUE_RE = /(?:^|(?<=\s))(?:[a-z]+(?:-[a-z]+)*)-\[[^\]]+\](?![-\w]*:)/g;
+export const noArbitraryTailwindRule = {
+    meta: {
+        schema: [],
+        type: "problem",
+        docs: {
+            description: "Disallow Tailwind arbitrary-value classes like rounded-[13px].",
+        },
+    },
+    create(context) {
+        function checkQuasis(node, quasis) {
+            for (const quasi of quasis) {
+                ARBITRARY_VALUE_RE.lastIndex = 0;
+                const match = ARBITRARY_VALUE_RE.exec(quasi.value.raw);
+                if (match) {
+                    context.report({
+                        node,
+                        message: `Tailwind arbitrary-value class "${match[0]}" is not allowed. ` +
+                            "Use a named token or custom utility. " +
+                            "See docs/styling-guide/rules/arbitrary-value-rule.md",
+                    });
+                }
+            }
+        }
+        return {
+            JSXAttribute(node) {
+                if (node.name.name !== "className" && node.name.name !== "class")
+                    return;
+                const valueNode = node.value;
+                if (!valueNode)
+                    return;
+                if (valueNode.type === "Literal" && typeof valueNode.value === "string") {
+                    ARBITRARY_VALUE_RE.lastIndex = 0;
+                    const match = ARBITRARY_VALUE_RE.exec(valueNode.value);
+                    if (match) {
+                        context.report({
+                            node,
+                            message: `Tailwind arbitrary-value class "${match[0]}" is not allowed. ` +
+                                "Use a named token or custom utility. " +
+                                "See docs/styling-guide/rules/arbitrary-value-rule.md",
+                        });
+                    }
+                }
+                else if (valueNode.type === "JSXExpressionContainer" && valueNode.expression) {
+                    const expr = valueNode.expression;
+                    if (expr.type === "Literal" && typeof expr.value === "string") {
+                        ARBITRARY_VALUE_RE.lastIndex = 0;
+                        const match = ARBITRARY_VALUE_RE.exec(expr.value);
+                        if (match) {
+                            context.report({
+                                node,
+                                message: `Tailwind arbitrary-value class "${match[0]}" is not allowed. ` +
+                                    "Use a named token or custom utility. " +
+                                    "See docs/styling-guide/rules/arbitrary-value-rule.md",
+                            });
+                        }
+                    }
+                    else if (expr.type === "TemplateLiteral") {
+                        checkQuasis(node, expr.quasis);
+                    }
+                }
+            },
+            CallExpression(node) {
+                if (node.callee.type !== "Identifier")
+                    return;
+                const calleeName = node.callee.name;
+                if (calleeName !== "cn" && calleeName !== "clsx" && calleeName !== "twMerge" && calleeName !== "twJoin")
+                    return;
+                for (const arg of node.arguments) {
+                    if (arg.type === "Literal" && typeof arg.value === "string") {
+                        ARBITRARY_VALUE_RE.lastIndex = 0;
+                        const match = ARBITRARY_VALUE_RE.exec(arg.value);
+                        if (match) {
+                            context.report({
+                                node,
+                                message: `Tailwind arbitrary-value class "${match[0]}" is not allowed. ` +
+                                    "Use a named token or custom utility. " +
+                                    "See docs/styling-guide/rules/arbitrary-value-rule.md",
+                            });
+                        }
+                    }
+                    else if (arg.type === "TemplateLiteral") {
+                        checkQuasis(node, arg.quasis);
+                    }
+                }
+            },
+        };
+    },
+};
+/* eslint-enable  -- re-enable rules disabled for AST access @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-argument */

package/dist/eslint/pasika/rules/no-mixed-concerns.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ESLint rule: pasika/no-mixed-concerns
+ *
+ * Enforces the "No Mixed Concerns Rule" — one React component per .tsx file.
+ *
+ * @see docs/code-organization-guide/rules/no-mixed-concerns-rule.md
+ */
+import type { Rule } from "eslint";
+export declare const noMixedConcernsRule: Rule.RuleModule;