pasika 0.10.47 → 0.10.49

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

@@ -192,6 +192,7 @@ declare const pasikaPlugin: {
         "glossary-term-linking": _eslint_markdown.MarkdownRuleDefinition;
         "guide-mentions-documents": _eslint_markdown.MarkdownRuleDefinition;
         "guide-section-shape": _eslint_markdown.MarkdownRuleDefinition;
+        "file-length": eslint.Rule.RuleModule;
         "filename-case": eslint.Rule.RuleModule;
         "import-boundaries": eslint.Rule.RuleModule;
         "import-spacing": eslint.Rule.RuleModule;

package/dist/eslint/pasika/index.js

@@ -2925,6 +2925,31 @@ var enforceCvaVariantPropsRule = {
   }
 };
 
+// eslint/rules/file-length.ts
+var MAX_SOURCE_FILE_LINES = 300;
+var fileLengthRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require application source files to stay at or below 300 lines."
+    }
+  },
+  create(context) {
+    return {
+      Program(node) {
+        const lineCount = context.sourceCode.lines.length;
+        if (lineCount <= MAX_SOURCE_FILE_LINES) return;
+        context.report({
+          node,
+          loc: { line: 1, column: 0 },
+          message: `Source file has ${String(lineCount)} lines; split it so no source file exceeds ${String(MAX_SOURCE_FILE_LINES)} lines. See docs/next-codebase-guide/rules/application-structure-rule.md`
+        });
+      }
+    };
+  }
+};
+
 // eslint/rules/filename-case.ts
 import path24 from "path";
 var NEXT_ROUTING_FILES2 = /* @__PURE__ */ new Set([
@@ -3087,6 +3112,10 @@ function sideEffectCategoryOf(node) {
   }
   return void 0;
 }
+function score(hookNames, sideEffectCategories) {
+  const hookDiversityPoint = hookNames.size >= 2 ? 1 : 0;
+  return hookDiversityPoint + sideEffectCategories.size;
+}
 function computeExtractionScore(body, sourceText) {
   const start = body.range?.[0] ?? 0;
   const end = body.range?.[1] ?? sourceText.length;
@@ -3107,15 +3136,44 @@ function computeExtractionScore(body, sourceText) {
     ts3.forEachChild(node, visit);
   };
   visit(sourceFile);
-  const hookDiversityPoint = hookNames.size >= 2 ? 1 : 0;
-  return hookDiversityPoint + sideEffectCategories.size;
+  return score(hookNames, sideEffectCategories);
+}
+function componentBody(component) {
+  const { declaration } = component;
+  if (ts3.isFunctionDeclaration(declaration)) return declaration.body;
+  const initializer = declaration.initializer;
+  if (!initializer || !ts3.isArrowFunction(initializer) && !ts3.isFunctionExpression(initializer)) return void 0;
+  return ts3.isBlock(initializer.body) ? initializer.body : void 0;
+}
+function computeInlineComponentExtractionScore(component) {
+  const body = componentBody(component);
+  if (!body) return 0;
+  const hookNames = /* @__PURE__ */ new Set();
+  const sideEffectCategories = /* @__PURE__ */ new Set();
+  const collectSideEffects = (node) => {
+    const sideEffect = sideEffectCategoryOf(node);
+    if (sideEffect) sideEffectCategories.add(sideEffect);
+    ts3.forEachChild(node, collectSideEffects);
+  };
+  const visit = (node) => {
+    if (node !== body && ts3.isFunctionLike(node)) return;
+    const hookName = calledHookName(node);
+    if (hookName && ts3.isCallExpression(node)) {
+      hookNames.add(hookName);
+      for (const argument of node.arguments) collectSideEffects(argument);
+      return;
+    }
+    ts3.forEachChild(node, visit);
+  };
+  visit(body);
+  return score(hookNames, sideEffectCategories);
 }
 var hookComplexityRule = {
   meta: {
     schema: [],
     type: "problem",
     docs: {
-      description: "Require extraction of complex single-consumer hooks and inline of simple ones."
+      description: "Require extraction of complex inline or single-consumer hook logic and inline of simple hooks."
     }
   },
   create(context) {
@@ -3132,18 +3190,32 @@ var hookComplexityRule = {
       if (!name || !isHookName2(name) || !body) return;
       hooks.push({ node, name, body, exported });
     }
+    function reportInlineComponentHooks() {
+      if (!filename.endsWith(".tsx") && !filename.endsWith(".jsx")) return;
+      const components = parseComponentInfo(sourceText, filename, { includeNonExported: true });
+      for (const component of components) {
+        const extractionScore = computeInlineComponentExtractionScore(component);
+        if (extractionScore < 2) continue;
+        const sourceFile = component.declaration.getSourceFile();
+        const { line } = sourceFile.getLineAndCharacterOfPosition(component.declaration.getStart(sourceFile));
+        context.report({
+          loc: { line: line + 1, column: 0 },
+          message: `Component "${component.name}" has inline hook logic with an extraction score of ${String(extractionScore)}; extract that logic to a custom hook in a hooks/ folder. See docs/next-codebase-guide/rules/hook-extraction-rule.md`
+        });
+      }
+    }
     function reportHooks() {
       const parentFolder = segments.length >= 2 ? segments[segments.length - 2] : void 0;
       const inSupportFolder = parentFolder === "hooks";
       for (const { node, name, body, exported } of hooks) {
-        const score = computeExtractionScore(body, sourceText);
+        const extractionScore = computeExtractionScore(body, sourceText);
         const hasLocalConsumer = localHookCalls.has(name);
         const externalConsumerCount = exported ? index?.symbolConsumers.get(symbolKey(filename, name))?.size ?? 0 : 0;
-        if (score >= 2) {
+        if (extractionScore >= 2) {
           if (!inSupportFolder && (exported || hasLocalConsumer)) {
             context.report({
               node,
-              message: `Hook "${name}" has an extraction score of ${String(score)} and must be extracted to a hooks/ folder. See docs/next-codebase-guide/rules/hook-extraction-rule.md`
+              message: `Hook "${name}" has an extraction score of ${String(extractionScore)} and must be extracted to a hooks/ folder. See docs/next-codebase-guide/rules/hook-extraction-rule.md`
             });
           }
           continue;
@@ -3189,6 +3261,7 @@ var hookComplexityRule = {
       },
       "Program:exit"() {
         reportHooks();
+        reportInlineComponentHooks();
       }
     };
   }
@@ -3363,14 +3436,6 @@ var httpErrorUsageRule = {
 // eslint/rules/husky/husky-hook.ts
 import { existsSync as existsSync4, readFileSync as readFileSync6 } from "fs";
 import path28 from "path";
-var VITEST_CONFIG_NAMES = [
-  "vitest.config.ts",
-  "vitest.config.mts",
-  "vitest.config.cts",
-  "vitest.config.js",
-  "vitest.config.mjs",
-  "vitest.config.cjs"
-];
 function memberName(member) {
   return member.name.type === "String" ? member.name.value : member.name.name;
 }
@@ -3379,7 +3444,7 @@ var huskyHookRule = {
     schema: [],
     type: "problem",
     docs: {
-      description: "Require a pre-commit hook that runs lint-staged, typecheck, coverage and suppression pruning with local staging, and the libyear drift check."
+      description: "Require a pre-commit hook that runs lint-staged, typecheck, coverage, suppression pruning, and the libyear drift check."
     }
   },
   create(context) {
@@ -3412,17 +3477,6 @@ var huskyHookRule = {
         }
         requireNamedScript("typecheck");
         requireNamedScript("test:unit:coverage");
-        const vitestConfigName = VITEST_CONFIG_NAMES.find((name) => existsSync4(path28.join(context.cwd, name)));
-        if (vitestConfigName !== void 0) {
-          const coverageIndex = content.indexOf("npm run test:unit:coverage");
-          const localAddIndex = content.indexOf(`git add ${vitestConfigName}`);
-          if (localAddIndex <= coverageIndex) {
-            context.report({
-              node,
-              message: `.husky/pre-commit must stage an auto-updated ${vitestConfigName} after coverage.`
-            });
-          }
-        }
         if (!content.includes("libyear --limit-major-individual=1")) {
           context.report({ node, message: ".husky/pre-commit must run npx libyear --limit-major-individual=1." });
         }
@@ -4705,19 +4759,15 @@ var DOC3 = "See docs/next-codebase-guide/rules/redundant-aliases-rule.md";
 var VALUE_SENTINELS = /* @__PURE__ */ new Set(["undefined", "NaN", "Infinity"]);
 var HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
 function entityNameText(name) {
-  if (!name) return void 0;
   if (name.type === "Identifier") return name.name;
   if (name.type === "TSQualifiedName") {
     const left = entityNameText(name.left);
-    const right = name.right?.name;
+    const right = name.right.name;
     return left && right ? `${left}.${right}` : void 0;
   }
-  if (name.type === "MemberExpression" && !name.computed) {
-    const object = entityNameText(name.object);
-    const property = name.property?.name;
-    return object && property ? `${object}.${property}` : void 0;
-  }
-  return void 0;
+  const object = entityNameText(name.object);
+  const property = name.property.name;
+  return object && property ? `${object}.${property}` : void 0;
 }
 function aliasMessage(alias, source) {
   const aliasName = alias ?? "This declaration";
@@ -4757,16 +4807,31 @@ var noRedundantAliasRule = {
           message: aliasMessage(node.id?.name, source)
         });
       },
+      ExportNamedDeclaration(node) {
+        for (const specifier of node.specifiers) {
+          if (specifier.local.type !== "Identifier" || specifier.exported.type !== "Identifier") continue;
+          const source = specifier.local.name;
+          const alias = specifier.exported.name;
+          if (source === alias) continue;
+          const frameworkRouteAlias = path37.basename(context.filename) === "route.ts" && HTTP_METHODS.has(alias);
+          if (frameworkRouteAlias) continue;
+          context.report({
+            node: specifier,
+            message: aliasMessage(alias, source)
+          });
+        }
+      },
       TSInterfaceDeclaration(node) {
         if (node.typeParameters || node.body?.body?.length !== 0 || node.extends?.length !== 1) return;
-        const heritage = node.extends[0];
-        if (heritage?.typeArguments) return;
-        const source = entityNameText(heritage?.expression);
-        if (!source) return;
-        context.report({
-          node,
-          message: aliasMessage(node.id?.name, source)
-        });
+        for (const heritage of node.extends) {
+          if (heritage.typeArguments) return;
+          const source = entityNameText(heritage.expression);
+          if (!source) return;
+          context.report({
+            node,
+            message: aliasMessage(node.id?.name, source)
+          });
+        }
       }
     };
   }
@@ -5046,7 +5111,7 @@ function stringValues2(value) {
   if (value.type !== "Array") return [];
   return value.elements.flatMap((element) => element.value.type === "String" ? [element.value.value] : []);
 }
-var VITEST_CONFIG_NAMES2 = [
+var VITEST_CONFIG_NAMES = [
   "vitest.config.ts",
   "vitest.config.mts",
   "vitest.config.cts",
@@ -5103,7 +5168,7 @@ var vitestCoverageRule = {
             message: 'package.json must declare a "test:unit:coverage" script that runs Vitest with coverage.'
           });
         }
-        const configName = VITEST_CONFIG_NAMES2.find((name) => existsSync5(path39.join(context.cwd, name)));
+        const configName = VITEST_CONFIG_NAMES.find((name) => existsSync5(path39.join(context.cwd, name)));
         if (!configName) {
           context.report({
             node,
@@ -5316,6 +5381,27 @@ function hasHookUsage(body) {
   }
   return false;
 }
+function enclosingComponentFunction(node) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === "FunctionDeclaration") {
+      const name = current.id.name;
+      return name && isComponentLikeName(name) ? current : void 0;
+    }
+    if (current.type === "ArrowFunctionExpression" || current.type === "FunctionExpression") {
+      const declarator = current.parent;
+      if (declarator.type !== "VariableDeclarator" || declarator.id.type !== "Identifier") return void 0;
+      return isComponentLikeName(declarator.id.name) ? current : void 0;
+    }
+    current = current.parent;
+  }
+  return void 0;
+}
+function capturesComponentLocal(context, helper, component) {
+  const helperScope = context.sourceCode.getScope(helper);
+  const componentScope = context.sourceCode.getScope(component);
+  return helperScope.through.some((reference) => reference.resolved?.scope === componentScope);
+}
 var pureFunctionExtractRule = {
   meta: {
     schema: [],
@@ -5345,25 +5431,27 @@ var pureFunctionExtractRule = {
     }
     return {
       FunctionDeclaration(node) {
-        const exported = node.parent?.type === "ExportNamedDeclaration";
-        const moduleLevel = exported || node.parent?.type === "Program";
-        if (!moduleLevel) return;
         const name = node.id?.name;
         if (!name) return;
         if (isRouteFile && ROUTE_HANDLER_EXPORT_NAMES.has(name)) return;
         if (isComponentLikeName(name) || isHookName3(name)) return;
         if (isHookSupportFile && node.async) return;
         if (!node.body || hasHookUsage(node.body)) return;
+        const exported = node.parent?.type === "ExportNamedDeclaration";
+        const moduleLevel = exported || node.parent?.type === "Program";
+        if (moduleLevel) {
+          report3(node, name);
+          return;
+        }
+        if (!isComponentFile) return;
+        const component = enclosingComponentFunction(node);
+        if (!component || capturesComponentLocal(context, node, component)) return;
         report3(node, name);
       },
       VariableDeclarator(node) {
         if (node.id.type !== "Identifier") return;
         const name = node.id.name;
         if (!name) return;
-        const container = node.parent.parent;
-        const exported = container?.type === "ExportNamedDeclaration";
-        const moduleLevel = exported || container?.type === "Program";
-        if (!moduleLevel) return;
         if (isRouteFile && ROUTE_HANDLER_EXPORT_NAMES.has(name)) return;
         if (isComponentLikeName(name) || isHookName3(name)) return;
         const init = node.init;
@@ -5372,6 +5460,16 @@ var pureFunctionExtractRule = {
         }
         if (isHookSupportFile && init.async) return;
         if (init.body.type === "BlockStatement" && hasHookUsage(init.body)) return;
+        const container = node.parent.parent;
+        const exported = container?.type === "ExportNamedDeclaration";
+        const moduleLevel = exported || container?.type === "Program";
+        if (moduleLevel) {
+          report3(node, name);
+          return;
+        }
+        if (!isComponentFile) return;
+        const component = enclosingComponentFunction(node);
+        if (!component || capturesComponentLocal(context, init, component)) return;
         report3(node, name);
       }
     };
@@ -5451,6 +5549,26 @@ function structuralChildren(node) {
     (child) => isJsxNode(child) || isJsxExpressionContainer(child)
   );
 }
+function branchRootSignature(node) {
+  const children = blockChildren(node);
+  if (children.length < 2) return void 0;
+  return children.map((child) => {
+    const opening = nodeKind(child) === "JSXFragment" ? "<>" : child.openingElement?.name.name ?? "<>";
+    const attributes = (child.openingElement?.attributes ?? []).filter((attribute) => attribute.type === "JSXAttribute").map((attribute) => attribute.name?.name ?? "").sort().join(",");
+    return `${opening}[${attributes}]`;
+  }).join("/");
+}
+function isConditionalAssignmentRoot(node) {
+  let current = node;
+  let parent = current.parent;
+  while (parent) {
+    const parentType = parent.type;
+    if (parentType !== "ParenthesizedExpression") break;
+    current = parent;
+    parent = current.parent;
+  }
+  return parent?.type === "AssignmentExpression" || parent?.type === "ConditionalExpression";
+}
 var repeatedStructureRule = {
   meta: {
     schema: [],
@@ -5461,18 +5579,37 @@ var repeatedStructureRule = {
   },
   create(context) {
     if (!context.filename.endsWith(".tsx") && !context.filename.endsWith(".jsx")) return {};
+    const conditionalAssignmentBlocks = /* @__PURE__ */ new Map();
     return {
       JSXElement(node) {
         checkChildren(node);
+        collectConditionalAssignmentBlock(node);
       },
       JSXFragment(node) {
         checkChildren(node);
+        collectConditionalAssignmentBlock(node);
+      },
+      "Program:exit"() {
+        for (const group of conditionalAssignmentBlocks.values()) {
+          if (group.length < 2) continue;
+          const first = group[0];
+          if (!first) continue;
+          reportRepeatedStructure(first, group.length);
+        }
       }
     };
     function checkChildren(node) {
       checkSubstantialBlocks(node);
       checkSmallElementExpressionPairs(node);
     }
+    function collectConditionalAssignmentBlock(node) {
+      if (!isConditionalAssignmentRoot(node) || !isSubstantial(node)) return;
+      const sig = branchRootSignature(node);
+      if (!sig) return;
+      const group = conditionalAssignmentBlocks.get(sig) ?? [];
+      group.push(node);
+      conditionalAssignmentBlocks.set(sig, group);
+    }
     function checkSubstantialBlocks(node) {
       const children = blockChildren(node);
       const seen = /* @__PURE__ */ new Map();
@@ -8163,6 +8300,7 @@ function assertTypescriptAlignment() {
 // eslint/index.ts
 var pasikaNextjsAppRules = {
   // Framework-agnostic TypeScript rules.
+  "file-length": fileLengthRule,
   "filename-case": filenameCaseRule,
   "import-boundaries": importBoundariesRule,
   "import-spacing": importSpacingRule,

package/package.json

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