pasika 0.10.48 → 0.10.50

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();
       }
     };
   }
@@ -4685,6 +4758,15 @@ import path37 from "path";
 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"]);
+var PRIMITIVE_TYPE_NAMES = {
+  TSBigIntKeyword: "bigint",
+  TSBooleanKeyword: "boolean",
+  TSNullKeyword: "null",
+  TSNumberKeyword: "number",
+  TSStringKeyword: "string",
+  TSSymbolKeyword: "symbol",
+  TSUndefinedKeyword: "undefined"
+};
 function entityNameText(name) {
   if (name.type === "Identifier") return name.name;
   if (name.type === "TSQualifiedName") {
@@ -4696,6 +4778,12 @@ function entityNameText(name) {
   const property = name.property.name;
   return object && property ? `${object}.${property}` : void 0;
 }
+function aliasedTypeName(annotation) {
+  const primitiveTypeName = PRIMITIVE_TYPE_NAMES[annotation.type];
+  if (primitiveTypeName) return primitiveTypeName;
+  if (annotation.type !== "TSTypeReference" || annotation.typeArguments || !annotation.typeName) return void 0;
+  return entityNameText(annotation.typeName);
+}
 function aliasMessage(alias, source) {
   const aliasName = alias ?? "This declaration";
   const sourceName = source ?? "the original symbol";
@@ -4726,8 +4814,8 @@ var noRedundantAliasRule = {
       TSTypeAliasDeclaration(node) {
         if (node.typeParameters) return;
         const annotation = node.typeAnnotation;
-        if (annotation?.type !== "TSTypeReference" || annotation.typeArguments) return;
-        const source = entityNameText(annotation.typeName);
+        if (!annotation) return;
+        const source = aliasedTypeName(annotation);
         if (!source) return;
         context.report({
           node,
@@ -5308,6 +5396,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: [],
@@ -5337,25 +5446,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;
@@ -5364,6 +5475,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);
       }
     };
@@ -5443,6 +5564,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: [],
@@ -5453,18 +5594,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();
@@ -8155,6 +8315,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.48",
+  "version": "0.10.50",
   "description": "Reusable agent setup package",
   "repository": {
     "type": "git",