pasika 0.10.45 → 0.10.47

package/dist/eslint/pasika/index.js

@@ -3485,14 +3485,11 @@ function relativeSpecifier(filename, resolvedPath) {
 function aliasSpecifier(sourceRoot, resolvedPath) {
   return `@/${(sourceSegments(sourceRoot, resolvedPath) ?? []).join("/")}`;
 }
-function segmentCount(specifier) {
-  return specifier.replace(/^@\//, "").split("/").filter((segment) => segment !== "." && segment !== "").length;
+function parentTraversalCount(specifier) {
+  return specifier.split("/").filter((segment) => segment === "..").length;
 }
-function describeSegments(count) {
-  return `${String(count)} segment${count === 1 ? "" : "s"}`;
-}
-function prefersRelative(sourceRoot, filename, resolvedPath) {
-  return segmentCount(relativeSpecifier(filename, resolvedPath)) <= segmentCount(aliasSpecifier(sourceRoot, resolvedPath));
+function prefersRelative(filename, resolvedPath) {
+  return parentTraversalCount(relativeSpecifier(filename, resolvedPath)) <= 1;
 }
 var importBoundariesRule = {
   meta: {
@@ -3536,23 +3533,17 @@ var importBoundariesRule = {
       }
       const relativeForm = relativeSpecifier(filename, resolvedPath);
       const aliasForm = aliasSpecifier(sourceRoot, resolvedPath);
-      const relativeSegments = segmentCount(relativeForm);
-      const aliasSegments = segmentCount(aliasForm);
-      function describeChoice(preferred, preferredSegments, other, otherSegments) {
-        const tie = preferredSegments === otherSegments ? ", and a tie goes to the relative path" : "";
-        return `Use "${preferred}" (${describeSegments(preferredSegments)}) instead of "${other}" (${describeSegments(otherSegments)})${tie}.`;
-      }
-      if (prefersRelative(sourceRoot, filename, resolvedPath) && importPath.startsWith("@/")) {
+      if (prefersRelative(filename, resolvedPath) && importPath.startsWith("@/")) {
         context.report({
           node: source,
-          message: describeChoice(relativeForm, relativeSegments, aliasForm, aliasSegments)
+          message: `Use "${relativeForm}" instead of "${aliasForm}".`
         });
         return;
       }
-      if (!prefersRelative(sourceRoot, filename, resolvedPath) && importPath.startsWith(".")) {
+      if (!prefersRelative(filename, resolvedPath) && importPath.startsWith(".")) {
         context.report({
           node: source,
-          message: describeChoice(aliasForm, aliasSegments, relativeForm, relativeSegments)
+          message: `Use "${aliasForm}" instead of "${relativeForm}".`
         });
       }
     }
@@ -5184,19 +5175,82 @@ function isEnumLiteralType(node) {
 function isEnumLiteralUnion(node) {
   return node?.type === "TSUnionType" && (node.types?.length ?? 0) >= 2 && (node.types ?? []).every(isEnumLiteralType);
 }
+function isZodCall(node, method) {
+  const { callee } = node;
+  return callee?.type === "MemberExpression" && !callee.computed && callee.object.type === "Identifier" && callee.object.name === "z" && callee.property.type === "Identifier" && callee.property.name === method;
+}
+function propertyName2(property) {
+  if (property.computed) return void 0;
+  if (property.key.type === "Identifier") return property.key.name;
+  if (property.key.type === "Literal" && typeof property.key.value === "string") return property.key.value;
+  return void 0;
+}
+function rawZodDiscriminantLiteral(schemaCall, discriminator) {
+  if (!isZodCall(schemaCall, "object")) return void 0;
+  const shape = schemaCall.arguments[0];
+  if (shape?.type !== "ObjectExpression") return void 0;
+  for (const property of shape.properties) {
+    if (property.type !== "Property" || propertyName2(property) !== discriminator) continue;
+    if (property.value.type !== "CallExpression" || !isZodCall(property.value, "literal")) return void 0;
+    const literal = property.value.arguments[0];
+    if (literal?.type === "Literal" && (typeof literal.value === "string" || typeof literal.value === "number")) {
+      return literal;
+    }
+    return void 0;
+  }
+  return void 0;
+}
 var preferEnumRule = {
   meta: {
     schema: [],
     type: "problem",
     docs: {
-      description: "Require fixed sets of named string/number values to be TypeScript enums instead of `as const` objects, literal-union aliases, or inline literal-union property types."
+      description: "Require fixed sets of named string/number values to be TypeScript enums, including Zod discriminated-union discriminator values."
     }
   },
   create(context) {
     const filename = path40.resolve(context.filename);
     const sourceRoot = sourceRootOf(context);
     if (!filename.startsWith(sourceRoot + path40.sep)) return {};
+    const objectSchemas = /* @__PURE__ */ new Map();
+    const discriminatedUnions = [];
+    const reportedDiscriminants = /* @__PURE__ */ new Set();
     return {
+      VariableDeclarator(node) {
+        const { id, init } = node;
+        if (id?.type !== "Identifier" || init?.type !== "CallExpression" || !isZodCall(init, "object")) return;
+        objectSchemas.set(id.name, init);
+      },
+      CallExpression(node) {
+        if (isZodCall(node, "discriminatedUnion")) {
+          discriminatedUnions.push(node);
+        }
+      },
+      "Program:exit"() {
+        for (const unionCall of discriminatedUnions) {
+          const [discriminatorArg, optionsArg] = unionCall.arguments ?? [];
+          if (discriminatorArg?.type !== "Literal" || typeof discriminatorArg.value !== "string" || optionsArg?.type !== "ArrayExpression") {
+            continue;
+          }
+          for (const option of optionsArg.elements) {
+            if (!option || option.type === "SpreadElement") continue;
+            let schemaCall;
+            if (option.type === "Identifier") {
+              schemaCall = objectSchemas.get(option.name);
+            } else if (option.type === "CallExpression" && isZodCall(option, "object")) {
+              schemaCall = option;
+            }
+            if (!schemaCall) continue;
+            const literal = rawZodDiscriminantLiteral(schemaCall, discriminatorArg.value);
+            if (!literal || reportedDiscriminants.has(literal)) continue;
+            reportedDiscriminants.add(literal);
+            context.report({
+              node: literal,
+              message: "A Zod discriminated-union discriminator literal must use a TypeScript enum member. See docs/next-codebase-guide/rules/constants-rule.md"
+            });
+          }
+        }
+      },
       TSAsExpression(node) {
         if (!isConstAssertion(node)) return;
         const expression = node.expression;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pasika",
-  "version": "0.10.45",
+  "version": "0.10.47",
   "description": "Reusable agent setup package",
   "repository": {
     "type": "git",