pasika 0.3.1 → 0.3.3

package/dist/enforcement/doctor.js

@@ -0,0 +1,249 @@
+/**
+ * `pasika doctor` checks.
+ *
+ * Diagnoses gaps between a consumer repository and the pasika framework
+ * baseline. Scope: dependencies, configuration, managed files, and
+ * source structure. Code-level and path-level rules belong to ESLint.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+const packageJsonSchema = z.object({
+    dependencies: z.record(z.string(), z.string()).optional(),
+    devDependencies: z.record(z.string(), z.string()).optional(),
+    scripts: z.record(z.string(), z.string()).optional(),
+});
+function readPackageJson(filePath) {
+    try {
+        const result = packageJsonSchema.safeParse(JSON.parse(fs.readFileSync(filePath, "utf8")));
+        if (result.success)
+            return result.data;
+    }
+    catch {
+        // missing or unparseable
+    }
+    return {};
+}
+/**
+ * Check that pasika and zirka are installed at compatible versions.
+ */
+function checkFrameworkPackages(pkg) {
+    const findings = [];
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (!allDeps.pasika) {
+        findings.push({
+            check: "pasika-installed",
+            message: "pasika is not listed in package.json.",
+            severity: "error",
+        });
+    }
+    if (!allDeps.zirka) {
+        findings.push({
+            check: "zirka-installed",
+            message: "zirka is not listed in package.json.",
+            severity: "error",
+        });
+    }
+    return findings;
+}
+/**
+ * Check that application source lives under src/.
+ */
+function checkSourceRoot(cwd) {
+    const findings = [];
+    const srcDir = path.join(cwd, "src");
+    if (!fs.existsSync(srcDir)) {
+        findings.push({
+            check: "source-under-src",
+            message: "Application source must live under src/.",
+            severity: "error",
+        });
+        return findings;
+    }
+    // Check for common non-src source directories at the project root
+    const entries = fs.readdirSync(cwd, { withFileTypes: true });
+    const suspicious = entries.filter((e) => e.isDirectory() &&
+        !e.name.startsWith(".") &&
+        e.name !== "src" &&
+        e.name !== "node_modules" &&
+        e.name !== "dist" &&
+        e.name !== "build" &&
+        e.name !== ".vulyk" &&
+        e.name !== "docs" &&
+        e.name !== "enforcement" &&
+        e.name !== "eslint" &&
+        e.name !== "cli" &&
+        e.name !== "__tests__" &&
+        e.name !== "test" &&
+        e.name !== "tests" &&
+        e.name !== "coverage" &&
+        e.name !== ".github" &&
+        e.name !== ".agents" &&
+        e.name !== ".husky" &&
+        e.name !== ".next" &&
+        e.name !== ".turbo" &&
+        e.name !== ".vercel" &&
+        e.name !== ".cache" &&
+        e.name !== ".tmp" &&
+        e.name !== "tmp" &&
+        e.name !== "public" &&
+        e.name !== "static" &&
+        e.name !== "assets" &&
+        e.name !== "bin" &&
+        e.name !== "vendor");
+    if (suspicious.length > 0) {
+        const names = suspicious.map((e) => e.name).join(", ");
+        findings.push({
+            check: "source-under-src",
+            message: `Possible source directories outside src/: ${names}.`,
+            severity: "warning",
+        });
+    }
+    return findings;
+}
+/**
+ * Find the global CSS file that registers Tailwind.
+ */
+function findGlobalStylesheet(cwd) {
+    const candidates = ["src/app/globals.css", "src/styles/globals.css", "src/globals.css"];
+    for (const candidate of candidates) {
+        const full = path.join(cwd, candidate);
+        if (fs.existsSync(full))
+            return full;
+    }
+    // Search for any CSS file containing @import "tailwindcss"
+    const srcDir = path.join(cwd, "src");
+    if (!fs.existsSync(srcDir))
+        return undefined;
+    const walk = (dir) => {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== ".next") {
+                const found = walk(full);
+                if (found)
+                    return found;
+            }
+            if (entry.isFile() && entry.name.endsWith(".css")) {
+                const content = fs.readFileSync(full, "utf8");
+                if (content.includes('@import "tailwindcss"') || content.includes("@import 'tailwindcss'")) {
+                    return full;
+                }
+            }
+        }
+        return undefined;
+    };
+    return walk(srcDir);
+}
+/**
+ * Check that the repository has a global stylesheet entry point that
+ * registers Tailwind. The stylesheet's contents are the ESLint CSS rules'
+ * concern, so doctor only checks that it exists.
+ */
+function checkGlobalStylesheet(cwd) {
+    const findings = [];
+    const stylesheet = findGlobalStylesheet(cwd);
+    if (!stylesheet) {
+        findings.push({
+            check: "global-stylesheet",
+            message: 'No global stylesheet found. Create src/app/globals.css with @import "tailwindcss".',
+            severity: "error",
+        });
+    }
+    return findings;
+}
+/**
+ * Check that configuration files follow the pasika baseline.
+ *
+ * Repositories must take their lint, format, and TypeScript configuration
+ * from pasika and zirka rather than restating it locally.
+ */
+function checkConfigBaseline(cwd) {
+    const findings = [];
+    // eslint.config.ts must exist and reference zirka
+    const eslintConfigs = ["eslint.config.ts", "eslint.config.mjs", "eslint.config.js"];
+    const eslintConfig = eslintConfigs.find((name) => fs.existsSync(path.join(cwd, name)));
+    if (!eslintConfig) {
+        findings.push({
+            check: "config-baseline",
+            message: "No eslint config found. Create eslint.config.ts extending the pasika/zirka baseline.",
+            severity: "error",
+        });
+    }
+    else {
+        const content = fs.readFileSync(path.join(cwd, eslintConfig), "utf8");
+        if (!content.includes("zirka")) {
+            findings.push({
+                check: "config-baseline",
+                message: `eslint config does not reference zirka. Use the pasika/zirka baseline configuration.`,
+                severity: "warning",
+            });
+        }
+    }
+    // tsconfig.json must exist
+    if (!fs.existsSync(path.join(cwd, "tsconfig.json"))) {
+        findings.push({
+            check: "config-baseline",
+            message: "No tsconfig.json found. Create one extending the pasika baseline.",
+            severity: "error",
+        });
+    }
+    return findings;
+}
+/**
+ * Check that vulyk-managed files have not been hand-edited.
+ *
+ * Files listed in the .vulyk manifest are generated by vulyk commands
+ * and must not be edited directly.
+ */
+function checkManagedFiles(cwd) {
+    const findings = [];
+    const vulykDir = path.join(cwd, ".vulyk");
+    if (!fs.existsSync(vulykDir))
+        return findings;
+    const manifestPath = path.join(vulykDir, "manifest.json");
+    if (!fs.existsSync(manifestPath))
+        return findings;
+    try {
+        const manifestEntrySchema = z.looseObject({
+            targets: z.array(z.string()).optional(),
+        });
+        const manifestSchema = z.record(z.string(), manifestEntrySchema);
+        const result = manifestSchema.safeParse(JSON.parse(fs.readFileSync(manifestPath, "utf8")));
+        if (!result.success)
+            return findings;
+        for (const [, entry] of Object.entries(result.data)) {
+            const targets = entry.targets ?? [];
+            for (const target of targets) {
+                const targetPath = path.join(cwd, target);
+                if (fs.existsSync(targetPath)) {
+                    // File exists — check it hasn't been modified since vulyk last wrote it
+                    const stat = fs.statSync(targetPath);
+                    const vulykStat = fs.statSync(manifestPath);
+                    // If target is newer than the manifest, it was edited after vulyk wrote it
+                    if (stat.mtimeMs > vulykStat.mtimeMs + 1000) {
+                        findings.push({
+                            check: "managed-file-edit",
+                            message: `File "${target}" appears to have been edited after vulyk wrote it. Use vulyk commands to update managed files.`,
+                            severity: "warning",
+                        });
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // manifest unreadable
+    }
+    return findings;
+}
+export function runDoctor(cwd) {
+    const pkgPath = path.join(cwd, "package.json");
+    const pkg = readPackageJson(pkgPath);
+    return [
+        ...checkFrameworkPackages(pkg),
+        ...checkConfigBaseline(cwd),
+        ...checkManagedFiles(cwd),
+        ...checkSourceRoot(cwd),
+        ...checkGlobalStylesheet(cwd),
+    ];
+}

package/dist/enforcement/parse-docs.js

@@ -40,6 +40,7 @@ function findDocLinks(line) {
 }
 export function parseDoc(filePath, docsRoot) {
     const body = readFileSync(filePath, "utf8");
+    const sourceLines = body.split("\n");
     const prose = toProse(body, "$<content>");
     const proseWithoutCode = toProse(body, "");
     const fileName = path.basename(filePath);
@@ -56,7 +57,10 @@ export function parseDoc(filePath, docsRoot) {
         }
         if (/^\s*[-*]\s/.test(line) && RFC_2119.test(line)) {
             const text = normalizeRequirement(line);
-            requirements.push({ text, hash: hashRequirement(text), raw: line.replace(/^\s*[-*]\s+/, ""), line: lineNumber });
+            // The raw bullet as written in the source file (code spans and links intact),
+            // so a registry entry's text is greppable in the doc it came from.
+            const raw = (sourceLines[index] ?? "").replace(/^\s*[-*]\s+/, "");
+            requirements.push({ text, hash: hashRequirement(text), raw, line: lineNumber });
         }
         if (/^\s*\d+\.\s/.test(line)) {
             steps.push({ line: lineNumber, text: line.replace(/^\s*\d+\.\s+/, ""), links: findDocLinks(line) });

package/dist/enforcement/types.d.ts

@@ -11,7 +11,6 @@ import { z } from "zod";
 export declare const enforcementKindSchema: z.ZodEnum<{
     eslint: "eslint";
     doctor: "doctor";
-    "docs-check": "docs-check";
     judgment: "judgment";
     permission: "permission";
     planned: "planned";
@@ -23,7 +22,6 @@ export declare const requirementSchema: z.ZodObject<{
     kind: z.ZodEnum<{
         eslint: "eslint";
         doctor: "doctor";
-        "docs-check": "docs-check";
         judgment: "judgment";
         permission: "permission";
         planned: "planned";
@@ -39,7 +37,6 @@ export declare const registrySchema: z.ZodObject<{
         kind: z.ZodEnum<{
             eslint: "eslint";
             doctor: "doctor";
-            "docs-check": "docs-check";
             judgment: "judgment";
             permission: "permission";
             planned: "planned";

package/dist/enforcement/types.js

@@ -13,8 +13,6 @@ export const enforcementKindSchema = z.enum([
     "eslint",
     /** A `pasika doctor` check reports it. */
     "doctor",
-    /** A `pasika docs` check reports it. */
-    "docs-check",
     /** No mechanical check can decide it; a reviewer or agent applies it. */
     "judgment",
     /** The requirement grants permission, so there is nothing to check. */
@@ -31,8 +29,8 @@ export const requirementSchema = z.object({
     hash: z.string(),
     kind: enforcementKindSchema,
     /**
-     * Identifier of the check that covers this requirement: an ESLint rule id, a
-     * doctor check id, or a docs-check id. Several ids are comma-separated.
+     * Identifier of the check that covers this requirement: an ESLint rule id or
+     * a doctor check id. Several ids are comma-separated.
      * Absent for judgment and permission.
      */
     ref: z.string().optional(),
@@ -47,13 +45,6 @@ export const registrySchema = z.object({
     requirements: z.array(requirementSchema),
 });
 /** Every kind, in the order the coverage summary prints them. */
-export const ENFORCEMENT_KINDS = [
-    "eslint",
-    "doctor",
-    "docs-check",
-    "planned",
-    "judgment",
-    "permission",
-];
+export const ENFORCEMENT_KINDS = ["eslint", "doctor", "planned", "judgment", "permission"];
 /** The kinds that count as mechanically enforced today. */
-export const MECHANICAL_KINDS = ["eslint", "doctor", "docs-check"];
+export const MECHANICAL_KINDS = ["eslint", "doctor"];

package/dist/eslint/pasika/ast-types.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Local AST node types for the parser-specific shapes ESLint's ESTree types
+ * do not carry: JSX nodes and TypeScript type nodes.
+ *
+ * Every extra field is optional so that any `Rule.Node` is assignable to these
+ * types — the handler parameters of the rules must accept whatever the parser
+ * hands them. Narrowing happens with `type`-discriminant checks inside each
+ * rule, exactly as in `no-arbitrary-tailwind.ts`.
+ */
+import type { Rule } from "eslint";
+import type * as ESTree from "estree";
+/** JSXIdentifier — the parser-specific name node of a JSX element or attribute. */
+export interface JsxIdentifier {
+    type: "JSXIdentifier";
+    name: string;
+}
+/** JSXMemberExpression — `<Foo.Bar>`, used by element and attribute names. */
+export interface JsxMemberExpression {
+    type: "JSXMemberExpression";
+    object: JsxIdentifier | JsxMemberExpression;
+    property: JsxIdentifier;
+}
+/** JSXExpressionContainer — the `{expression}` part of a JSX attribute value. */
+export interface JsxExpressionContainer {
+    type: "JSXExpressionContainer";
+    expression: ESTree.Expression;
+}
+/** JSXAttribute — `name="value"` or `name={expression}`. */
+export type JsxAttribute = Omit<Rule.Node, "type"> & {
+    type: string;
+    name: JsxIdentifier;
+    value: ESTree.Literal | JsxExpressionContainer | null;
+    parent?: JsxOpeningElementNode;
+};
+/** JSXSpreadAttribute — `{...props}`. */
+export interface JsxSpreadAttribute {
+    type: "JSXSpreadAttribute";
+    name?: never;
+    value?: never;
+    argument: ESTree.Expression;
+}
+/** Anything that can appear inside `attributes` of a JSX opening element. */
+export type JsxAttributeLike = JsxAttribute | JsxSpreadAttribute;
+/** JSXOpeningElement — the part before the closing `>` of an element. */
+export interface JsxOpeningElement {
+    type: "JSXOpeningElement";
+    name: JsxIdentifier | JsxMemberExpression;
+    attributes: JsxAttributeLike[];
+}
+/** A node that may be a JSX element — used for parents and helper parameters. */
+export type MaybeJsxElement = Rule.Node & {
+    openingElement?: JsxOpeningElement;
+};
+/** JSXElement as received by a `JSXElement` visitor. */
+export type JsxElementNode = MaybeJsxElement & {
+    parent?: MaybeJsxElement;
+};
+/** JSXAttribute as received by a `JSXAttribute` visitor, with its parent chain. */
+export type JsxAttributeNode = Rule.Node & {
+    name?: JsxIdentifier;
+    value?: ESTree.Literal | JsxExpressionContainer | null;
+    parent?: JsxOpeningElementNode;
+};
+/** JSXOpeningElement reached through a parent chain. */
+export type JsxOpeningElementNode = Rule.Node & {
+    name?: JsxIdentifier;
+    attributes?: JsxAttributeLike[];
+    parent?: JsxElementNode;
+};
+/**
+ * FunctionDeclaration as seen by a rule visitor. ESLint's ESTree typing says
+ * `id` is always present, but an anonymous `export default function () {}`
+ * reaches the visitor with `id: null`, so the field is kept nullable.
+ */
+export type FunctionDeclarationNode = Rule.Node & {
+    id?: {
+        name?: string;
+    } | null;
+    body?: ESTree.BlockStatement;
+};
+/**
+ * TSTypeAliasDeclaration — `type X = ...`, from the typescript-eslint parser.
+ *
+ * Kept as a plain `Rule.Node` intersection so it can be passed to
+ * `context.report`, which requires an ESTree node.
+ */
+export type TsTypeAliasDeclarationNode = Rule.Node & {
+    id?: {
+        type?: string;
+        name?: string;
+    };
+    typeAnnotation?: TsTypeNode;
+};
+/**
+ * A member of a type literal (TSPropertySignature, TSIndexSignature, ...).
+ *
+ * The `type` field is widened (via Omit) so it can be compared against the
+ * parser-specific "TSPropertySignature" string that ESTree's union lacks.
+ */
+export type TsTypeElementNode = Omit<Rule.Node, "type"> & {
+    type: string;
+    key?: {
+        type?: string;
+        name?: string;
+    };
+    typeAnnotation?: TsTypeAnnotationNode;
+};
+/** TSTypeAnnotation — the `: T` wrapper around a type node. */
+export type TsTypeAnnotationNode = Omit<Rule.Node, "type"> & {
+    type: string;
+    typeAnnotation?: TsTypeNode;
+};
+/** Any TypeScript type node the rules read (TSTypeLiteral, TSUnionType, ...). */
+export type TsTypeNode = Omit<Rule.Node, "type"> & {
+    type: string;
+    members?: TsTypeElementNode[];
+    types?: TsTypeNode[];
+    literal?: {
+        type?: string;
+        value?: unknown;
+    };
+};

package/dist/eslint/pasika/ast-types.js

@@ -0,0 +1 @@
+export {};

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

@@ -6,9 +6,64 @@
  * documented requirement each rule covers is recorded in
  * `enforcement/registry.json` and verified by `pasika coverage`.
  */
-import type { Linter, Rule } from "eslint";
-/** Every rule the plugin provides, keyed by its unprefixed name. */
-export declare const pasikaRules: Record<string, Rule.RuleModule>;
+import type { Linter } from "eslint";
+import { mdRules } from "./rules/md/index.js";
+import { cssRules } from "./rules/css/index.js";
+import { jsonRules } from "./rules/json/index.js";
+export declare const pasikaRules: {
+    "component-placement": import("eslint").Rule.RuleModule;
+    "support-file-placement": import("eslint").Rule.RuleModule;
+    "application-structure": import("eslint").Rule.RuleModule;
+    "named-exports": import("eslint").Rule.RuleModule;
+    "data-testid-case": import("eslint").Rule.RuleModule;
+    "support-folder-shape": import("eslint").Rule.RuleModule;
+    "import-through-index": import("eslint").Rule.RuleModule;
+    "util-file-name": import("eslint").Rule.RuleModule;
+    "no-util-barrel": import("eslint").Rule.RuleModule;
+    "jsx-hygiene": import("eslint").Rule.RuleModule;
+    "interactive-component": import("eslint").Rule.RuleModule;
+    "ui-state": import("eslint").Rule.RuleModule;
+    "filename-case": import("eslint").Rule.RuleModule;
+    "import-boundaries": import("eslint").Rule.RuleModule;
+    "no-mixed-concerns": import("eslint").Rule.RuleModule;
+    "no-arbitrary-tailwind": import("eslint").Rule.RuleModule;
+    "enforce-cn-merge": {
+        meta: {
+            schema: never[];
+            type: "problem";
+            docs: {
+                description: string;
+            };
+        };
+        create(context: import("eslint").Rule.RuleContext): {
+            JSXAttribute(node: import("./ast-types.js").JsxAttributeNode): void;
+        };
+    };
+    "enforce-cva-variant-props": import("eslint").Rule.RuleModule;
+    "cva-appearance-props": import("eslint").Rule.RuleModule;
+    "cva-boolean-variants": import("eslint").Rule.RuleModule;
+    "enforce-barrel-exports": import("eslint").Rule.RuleModule;
+    "cross-feature-import": import("eslint").Rule.RuleModule;
+    "pure-function-extract": import("eslint").Rule.RuleModule;
+    "hook-complexity": import("eslint").Rule.RuleModule;
+    "locale-dotted-path": import("eslint").Rule.RuleModule;
+    "locales-location": import("eslint").Rule.RuleModule;
+    "hook-extraction": import("eslint").Rule.RuleModule;
+    "value-extraction": import("eslint").Rule.RuleModule;
+    "config-extraction": import("eslint").Rule.RuleModule;
+    "component-nesting": import("eslint").Rule.RuleModule;
+    "stay-flat": import("eslint").Rule.RuleModule;
+    "type-extraction": import("eslint").Rule.RuleModule;
+    "locale-placement": import("eslint").Rule.RuleModule;
+    "shared-style-dedup": import("eslint").Rule.RuleModule;
+    "no-eslint-disable": import("eslint").Rule.RuleModule;
+};
+export { mdRules, cssRules, jsonRules };
 /** Rule ids as they appear in configuration and in lint output. */
 export declare const pasikaRuleIds: string[];
+export declare const pasikaMdRuleIds: string[];
+export declare const pasikaCssRuleIds: string[];
+export declare const pasikaJsonRuleIds: string[];
+/** Every rule id, as they appear in configuration and in lint output. */
+export declare const allPasikaRuleIds: string[];
 export declare const pasikaConfig: Linter.Config;

package/dist/eslint/pasika/index.js

@@ -7,20 +7,80 @@ import { enforceCvaVariantPropsRule } from "./rules/enforce-cva-variant-props.js
 import { enforceBarrelExportsRule } from "./rules/enforce-barrel-exports.js";
 import { componentPlacementRule } from "./rules/component-placement.js";
 import { supportFilePlacementRule } from "./rules/support-file-placement.js";
-/** Every rule the plugin provides, keyed by its unprefixed name. */
+import { applicationStructureRule } from "./rules/application-structure.js";
+import { namedExportsRule } from "./rules/named-exports.js";
+import { dataTestIdCaseRule } from "./rules/data-testid-case.js";
+import { supportFolderShapeRule } from "./rules/support-folder-shape.js";
+import { importThroughIndexRule } from "./rules/import-through-index.js";
+import { utilFileNameRule } from "./rules/util-file-name.js";
+import { noUtilBarrelRule } from "./rules/no-util-barrel.js";
+import { jsxHygieneRule } from "./rules/jsx-hygiene.js";
+import { interactiveComponentRule } from "./rules/interactive-component.js";
+import { uiStateRule } from "./rules/ui-state.js";
+import { cvaAppearancePropsRule } from "./rules/cva-appearance-props.js";
+import { cvaBooleanVariantsRule } from "./rules/cva-boolean-variants.js";
+import { crossFeatureImportRule } from "./rules/cross-feature-import.js";
+import { pureFunctionExtractRule } from "./rules/pure-function-extract.js";
+import { hookComplexityRule } from "./rules/hook-complexity.js";
+import { localeDottedPathRule } from "./rules/locale-dotted-path.js";
+import { localesLocationRule } from "./rules/locales-location.js";
+import { hookExtractionRule } from "./rules/hook-extraction.js";
+import { valueExtractionRule } from "./rules/value-extraction.js";
+import { configExtractionRule } from "./rules/config-extraction.js";
+import { componentNestingRule } from "./rules/component-nesting.js";
+import { stayFlatRule } from "./rules/stay-flat.js";
+import { typeExtractionRule } from "./rules/type-extraction.js";
+import { localePlacementRule } from "./rules/locale-placement.js";
+import { sharedStyleDedupRule } from "./rules/shared-style-dedup.js";
+import { noEslintDisableRule } from "./rules/no-eslint-disable.js";
+import { mdRules } from "./rules/md/index.js";
+import { cssRules } from "./rules/css/index.js";
+import { jsonRules } from "./rules/json/index.js";
 export const pasikaRules = {
     "component-placement": componentPlacementRule,
     "support-file-placement": supportFilePlacementRule,
+    "application-structure": applicationStructureRule,
+    "named-exports": namedExportsRule,
+    "data-testid-case": dataTestIdCaseRule,
+    "support-folder-shape": supportFolderShapeRule,
+    "import-through-index": importThroughIndexRule,
+    "util-file-name": utilFileNameRule,
+    "no-util-barrel": noUtilBarrelRule,
+    "jsx-hygiene": jsxHygieneRule,
+    "interactive-component": interactiveComponentRule,
+    "ui-state": uiStateRule,
     "filename-case": filenameCaseRule,
     "import-boundaries": importBoundariesRule,
     "no-mixed-concerns": noMixedConcernsRule,
     "no-arbitrary-tailwind": noArbitraryTailwindRule,
     "enforce-cn-merge": enforceCnMergeRule,
     "enforce-cva-variant-props": enforceCvaVariantPropsRule,
+    "cva-appearance-props": cvaAppearancePropsRule,
+    "cva-boolean-variants": cvaBooleanVariantsRule,
     "enforce-barrel-exports": enforceBarrelExportsRule,
+    "cross-feature-import": crossFeatureImportRule,
+    "pure-function-extract": pureFunctionExtractRule,
+    "hook-complexity": hookComplexityRule,
+    "locale-dotted-path": localeDottedPathRule,
+    "locales-location": localesLocationRule,
+    "hook-extraction": hookExtractionRule,
+    "value-extraction": valueExtractionRule,
+    "config-extraction": configExtractionRule,
+    "component-nesting": componentNestingRule,
+    "stay-flat": stayFlatRule,
+    "type-extraction": typeExtractionRule,
+    "locale-placement": localePlacementRule,
+    "shared-style-dedup": sharedStyleDedupRule,
+    "no-eslint-disable": noEslintDisableRule,
 };
+export { mdRules, cssRules, jsonRules };
 /** Rule ids as they appear in configuration and in lint output. */
 export const pasikaRuleIds = Object.keys(pasikaRules).map((name) => `pasika/${name}`);
+export const pasikaMdRuleIds = Object.keys(mdRules).map((name) => `pasika/${name}`);
+export const pasikaCssRuleIds = Object.keys(cssRules).map((name) => `pasika/${name}`);
+export const pasikaJsonRuleIds = Object.keys(jsonRules).map((name) => `pasika/${name}`);
+/** Every rule id, as they appear in configuration and in lint output. */
+export const allPasikaRuleIds = [...pasikaRuleIds, ...pasikaMdRuleIds, ...pasikaCssRuleIds, ...pasikaJsonRuleIds];
 export const pasikaConfig = {
     files: ["src/**/*.{cjs,cts,js,jsx,mjs,mts,ts,tsx}"],
     plugins: {

package/dist/eslint/pasika/rules/application-structure.d.ts

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