@hyphaene/hexa-ts-kit 1.12.1 → 1.12.2

package/dist/{chunk-EB6S5X3P.js → chunk-4LVIIP2D.js}

@@ -1043,7 +1043,7 @@ function getVaultConfig(config) {
 
 // src/lib/contracts/permissions-extractor.ts
 import { readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
-import { parse } from "@typescript-eslint/typescript-estree";
+import { Project, SyntaxKind } from "ts-morph";
 function extractValues(sourcePath, config) {
   if (!existsSync3(sourcePath)) {
     return {
@@ -1062,12 +1062,13 @@ function extractValues(sourcePath, config) {
       sourcePath
     };
   }
-  let ast;
+  const project = new Project({
+    useInMemoryFileSystem: true,
+    skipAddingFilesFromTsConfig: true
+  });
+  let sourceFile;
   try {
-    ast = parse(content, {
-      loc: true,
-      range: true
-    });
+    sourceFile = project.createSourceFile("temp.ts", content);
   } catch (err) {
     return {
       success: false,
@@ -1078,9 +1079,9 @@ function extractValues(sourcePath, config) {
   const exportName = config.export;
   const extractMode = config.extract;
   if (extractMode === "const-values") {
-    return extractConstValues(ast, exportName, sourcePath);
+    return extractConstValues(sourceFile, exportName, sourcePath);
   } else if (extractMode === "zod-keys") {
-    return extractZodKeys(ast, exportName, sourcePath);
+    return extractZodKeys(sourceFile, exportName, sourcePath);
   }
   return {
     success: false,
@@ -1088,33 +1089,34 @@ function extractValues(sourcePath, config) {
     sourcePath
   };
 }
-function extractConstValues(ast, exportName, sourcePath) {
+function extractConstValues(sourceFile, exportName, sourcePath) {
   const values = [];
   const keyToValue = {};
-  for (const node of ast.body) {
-    if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "VariableDeclaration") {
-      for (const declarator of node.declaration.declarations) {
-        if (declarator.id.type === "Identifier" && declarator.id.name === exportName && declarator.init) {
-          let objectExpr = null;
-          if (declarator.init.type === "TSAsExpression") {
-            const expr = declarator.init.expression;
-            if (expr.type === "ObjectExpression") {
-              objectExpr = expr;
-            }
-          } else if (declarator.init.type === "ObjectExpression") {
-            objectExpr = declarator.init;
-          }
-          if (objectExpr) {
-            for (const prop of objectExpr.properties) {
-              if (prop.type === "Property" && prop.value.type === "Literal" && typeof prop.value.value === "string") {
-                const value = prop.value.value;
-                values.push(value);
-                if (prop.key.type === "Identifier") {
-                  keyToValue[prop.key.name] = value;
-                }
-              }
-            }
-          }
+  for (const varStmt of sourceFile.getVariableStatements()) {
+    if (!varStmt.isExported()) continue;
+    for (const decl of varStmt.getDeclarations()) {
+      if (decl.getName() !== exportName) continue;
+      const init = decl.getInitializer();
+      if (!init) continue;
+      let objLiteral = init.asKind(SyntaxKind.ObjectLiteralExpression);
+      if (!objLiteral) {
+        const asExpr = init.asKind(SyntaxKind.AsExpression);
+        if (asExpr) {
+          objLiteral = asExpr.getExpression().asKind(SyntaxKind.ObjectLiteralExpression);
+        }
+      }
+      if (!objLiteral) continue;
+      for (const prop of objLiteral.getProperties()) {
+        const propAssign = prop.asKind(SyntaxKind.PropertyAssignment);
+        if (!propAssign) continue;
+        const val = propAssign.getInitializer();
+        const strLiteral = val?.asKind(SyntaxKind.StringLiteral);
+        if (!strLiteral) continue;
+        const value = strLiteral.getLiteralValue();
+        values.push(value);
+        const keyNode = propAssign.getNameNode();
+        if (keyNode.getKind() === SyntaxKind.Identifier) {
+          keyToValue[keyNode.getText()] = value;
         }
       }
     }
@@ -1133,24 +1135,26 @@ function extractConstValues(ast, exportName, sourcePath) {
     sourcePath
   };
 }
-function extractZodKeys(ast, exportName, sourcePath) {
+function extractZodKeys(sourceFile, exportName, sourcePath) {
   const values = [];
-  for (const node of ast.body) {
-    if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "VariableDeclaration") {
-      for (const declarator of node.declaration.declarations) {
-        if (declarator.id.type === "Identifier" && declarator.id.name === exportName && declarator.init) {
-          const init = declarator.init;
-          if (init.type === "CallExpression" && init.callee.type === "MemberExpression" && init.callee.property.type === "Identifier" && init.callee.property.name === "object") {
-            const firstArg = init.arguments[0];
-            if (firstArg && firstArg.type === "ObjectExpression") {
-              for (const prop of firstArg.properties) {
-                if (prop.type === "Property" && prop.key.type === "Identifier") {
-                  values.push(prop.key.name);
-                }
-              }
-            }
-          }
-        }
+  for (const varStmt of sourceFile.getVariableStatements()) {
+    if (!varStmt.isExported()) continue;
+    for (const decl of varStmt.getDeclarations()) {
+      if (decl.getName() !== exportName) continue;
+      const init = decl.getInitializer();
+      if (!init) continue;
+      const callExpr = init.asKind(SyntaxKind.CallExpression);
+      if (!callExpr) continue;
+      const callee = callExpr.getExpression();
+      if (!callee.getText().endsWith(".object")) continue;
+      const firstArg = callExpr.getArguments()[0];
+      if (!firstArg) continue;
+      const objLiteral = firstArg.asKind(SyntaxKind.ObjectLiteralExpression);
+      if (!objLiteral) continue;
+      for (const prop of objLiteral.getProperties()) {
+        const propAssign = prop.asKind(SyntaxKind.PropertyAssignment);
+        if (!propAssign) continue;
+        values.push(propAssign.getName());
       }
     }
   }
@@ -1171,7 +1175,7 @@ function extractZodKeys(ast, exportName, sourcePath) {
 // src/lib/contracts/contract-parser.ts
 import { readFileSync as readFileSync3, existsSync as existsSync4 } from "fs";
 import fg7 from "fast-glob";
-import { parse as parse2 } from "@typescript-eslint/typescript-estree";
+import { Project as Project2, SyntaxKind as SyntaxKind2 } from "ts-morph";
 async function findContractFiles(repoPath) {
   const files = await fg7("**/*.contract.ts", {
     cwd: repoPath,
@@ -1198,12 +1202,13 @@ function parseContractFile(filePath) {
       filePath
     };
   }
-  let ast;
+  const project = new Project2({
+    useInMemoryFileSystem: true,
+    skipAddingFilesFromTsConfig: true
+  });
+  let sourceFile;
   try {
-    ast = parse2(content, {
-      loc: true,
-      range: true
-    });
+    sourceFile = project.createSourceFile("contract.ts", content);
   } catch (err) {
     return {
       success: false,
@@ -1213,20 +1218,15 @@ function parseContractFile(filePath) {
   }
   const endpoints = [];
   let contractName = "UnknownContract";
-  for (const node of ast.body) {
-    if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "VariableDeclaration") {
-      for (const declarator of node.declaration.declarations) {
-        if (declarator.id.type === "Identifier") {
-          contractName = declarator.id.name;
-          const routerCall = findRouterCall(declarator.init);
-          if (routerCall) {
-            const parsedEndpoints = extractEndpointsFromRouter(
-              routerCall,
-              content
-            );
-            endpoints.push(...parsedEndpoints);
-          }
-        }
+  for (const varStmt of sourceFile.getVariableStatements()) {
+    if (!varStmt.isExported()) continue;
+    for (const decl of varStmt.getDeclarations()) {
+      contractName = decl.getName();
+      const init = decl.getInitializer();
+      const routerObj = findRouterObjectArg(init);
+      if (routerObj) {
+        const parsedEndpoints = extractEndpointsFromRouter(routerObj);
+        endpoints.push(...parsedEndpoints);
       }
     }
   }
@@ -1265,31 +1265,33 @@ async function parseContracts(repoPath) {
     contracts
   };
 }
-function findRouterCall(node) {
+function findRouterObjectArg(node) {
   if (!node) return null;
-  if (node.type === "CallExpression" && node.callee.type === "MemberExpression" && node.callee.property.type === "Identifier" && node.callee.property.name === "router") {
-    return node;
-  }
-  return null;
-}
-function extractEndpointsFromRouter(routerCall, sourceContent) {
+  const callExpr = node.asKind(SyntaxKind2.CallExpression);
+  if (!callExpr) return null;
+  const callee = callExpr.getExpression();
+  const propAccess = callee.asKind(SyntaxKind2.PropertyAccessExpression);
+  if (!propAccess || propAccess.getName() !== "router") return null;
+  const firstArg = callExpr.getArguments()[0];
+  if (!firstArg) return null;
+  return firstArg.asKind(SyntaxKind2.ObjectLiteralExpression) ?? null;
+}
+function extractEndpointsFromRouter(routerObj) {
   const endpoints = [];
-  const firstArg = routerCall.arguments[0];
-  if (!firstArg || firstArg.type !== "ObjectExpression") {
-    return endpoints;
-  }
-  const routerObject = firstArg;
-  for (const prop of routerObject.properties) {
-    if (prop.type !== "Property") continue;
-    if (prop.key.type !== "Identifier") continue;
-    const endpointName = prop.key.name;
-    const endpointLine = prop.loc?.start.line ?? 0;
-    if (prop.value.type !== "ObjectExpression") continue;
+  for (const prop of routerObj.getProperties()) {
+    const propAssign = prop.asKind(SyntaxKind2.PropertyAssignment);
+    if (!propAssign) continue;
+    const endpointName = propAssign.getName();
+    const endpointLine = propAssign.getStartLineNumber();
+    const endpointValue = propAssign.getInitializer();
+    const endpointObj = endpointValue?.asKind(
+      SyntaxKind2.ObjectLiteralExpression
+    );
+    if (!endpointObj) continue;
     const endpoint = extractEndpointDetails(
       endpointName,
-      prop.value,
-      endpointLine,
-      sourceContent
+      endpointObj,
+      endpointLine
     );
     if (endpoint) {
       endpoints.push(endpoint);
@@ -1297,28 +1299,34 @@ function extractEndpointsFromRouter(routerCall, sourceContent) {
   }
   return endpoints;
 }
-function extractEndpointDetails(name, objectExpr, line, sourceContent) {
+function extractEndpointDetails(name, endpointObj, line) {
   let method = "";
   let path = "";
   let metadata;
   let strictStatusCodes;
-  for (const prop of objectExpr.properties) {
-    if (prop.type !== "Property") continue;
-    if (prop.key.type !== "Identifier") continue;
-    const propName = prop.key.name;
-    if (propName === "method" && prop.value.type === "Literal") {
-      method = String(prop.value.value);
-    }
-    if (propName === "path" && prop.value.type === "Literal") {
-      path = String(prop.value.value);
-    }
-    if (propName === "metadata") {
-      if (prop.value.type === "ObjectExpression" || prop.value.type === "CallExpression") {
-        metadata = extractMetadata(prop.value, sourceContent);
+  for (const prop of endpointObj.getProperties()) {
+    const propAssign = prop.asKind(SyntaxKind2.PropertyAssignment);
+    if (!propAssign) continue;
+    const propName = propAssign.getName();
+    const propVal = propAssign.getInitializer();
+    if (!propVal) continue;
+    if (propName === "method") {
+      const strLit = propVal.asKind(SyntaxKind2.StringLiteral);
+      if (strLit) method = strLit.getLiteralValue();
+    }
+    if (propName === "path") {
+      const strLit = propVal.asKind(SyntaxKind2.StringLiteral);
+      if (strLit) path = strLit.getLiteralValue();
+    }
+    if (propName === "strictStatusCodes") {
+      if (propVal.getKind() === SyntaxKind2.TrueKeyword) {
+        strictStatusCodes = true;
+      } else if (propVal.getKind() === SyntaxKind2.FalseKeyword) {
+        strictStatusCodes = false;
       }
     }
-    if (propName === "strictStatusCodes" && prop.value.type === "Literal") {
-      strictStatusCodes = prop.value.value === true;
+    if (propName === "metadata") {
+      metadata = extractMetadata(propVal);
     }
   }
   return {
@@ -1330,82 +1338,105 @@ function extractEndpointDetails(name, objectExpr, line, sourceContent) {
     line
   };
 }
-function extractMetadata(node, sourceContent) {
-  if (node.type === "ObjectExpression") {
-    return parseMetadataObject(node, sourceContent);
-  }
-  if (node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "contractMetadata") {
-    const firstArg = node.arguments[0];
-    if (firstArg && firstArg.type === "ObjectExpression") {
-      return parseMetadataObject(firstArg, sourceContent);
+function extractMetadata(node) {
+  const objLiteral = node.asKind(SyntaxKind2.ObjectLiteralExpression);
+  if (objLiteral) {
+    return parseMetadataObject(objLiteral);
+  }
+  const callExpr = node.asKind(SyntaxKind2.CallExpression);
+  if (callExpr) {
+    const callee = callExpr.getExpression();
+    if (callee.getKind() === SyntaxKind2.Identifier && callee.getText() === "contractMetadata") {
+      const firstArg = callExpr.getArguments()[0];
+      if (firstArg) {
+        const argObj = firstArg.asKind(SyntaxKind2.ObjectLiteralExpression);
+        if (argObj) {
+          return parseMetadataObject(argObj);
+        }
+      }
     }
   }
   return void 0;
 }
-function parseMetadataObject(objectExpr, sourceContent) {
+function parseMetadataObject(objLiteral) {
   const metadata = {};
-  for (const prop of objectExpr.properties) {
-    if (prop.type !== "Property") continue;
-    if (prop.key.type !== "Identifier") continue;
-    const propName = prop.key.name;
-    if (propName === "openApiTags" && prop.value.type === "ArrayExpression") {
-      metadata.openApiTags = extractStringArray(prop.value);
+  for (const prop of objLiteral.getProperties()) {
+    const propAssign = prop.asKind(SyntaxKind2.PropertyAssignment);
+    if (!propAssign) continue;
+    const propName = propAssign.getName();
+    const propVal = propAssign.getInitializer();
+    if (!propVal) continue;
+    if (propName === "openApiTags") {
+      const arr = propVal.asKind(SyntaxKind2.ArrayLiteralExpression);
+      if (arr) {
+        metadata.openApiTags = extractStringArray(arr);
+      }
     }
     if (propName === "requiredPermission") {
-      if (prop.value.type === "Literal" || prop.value.type === "MemberExpression") {
-        const permValue = extractPermissionValue(prop.value, sourceContent);
-        if (permValue) {
-          metadata.requiredPermission = permValue;
-        }
+      const permValue = extractPermissionValue(propVal);
+      if (permValue) {
+        metadata.requiredPermission = permValue;
       }
     }
-    if (propName === "requiresAuth" && prop.value.type === "Literal") {
-      metadata.requiresAuth = prop.value.value === true;
+    if (propName === "requiresAuth") {
+      metadata.requiresAuth = propVal.getKind() === SyntaxKind2.TrueKeyword;
     }
-    if (propName === "bff" && prop.value.type === "ObjectExpression") {
-      metadata.bff = extractBffConfig(prop.value);
+    if (propName === "bff") {
+      const bffObj = propVal.asKind(SyntaxKind2.ObjectLiteralExpression);
+      if (bffObj) {
+        metadata.bff = extractBffConfig(bffObj);
+      }
     }
-    if (propName === "openapi" && prop.value.type === "ObjectExpression") {
-      metadata.openapi = extractLegacyOpenApi(prop.value);
+    if (propName === "openapi") {
+      const openapiObj = propVal.asKind(SyntaxKind2.ObjectLiteralExpression);
+      if (openapiObj) {
+        metadata.openapi = extractLegacyOpenApi(openapiObj);
+      }
     }
   }
   return metadata;
 }
 function extractStringArray(arrayExpr) {
   const values = [];
-  for (const element of arrayExpr.elements) {
-    if (element?.type === "Literal" && typeof element.value === "string") {
-      values.push(element.value);
+  for (const element of arrayExpr.getElements()) {
+    const strLit = element.asKind(SyntaxKind2.StringLiteral);
+    if (strLit) {
+      values.push(strLit.getLiteralValue());
     }
   }
   return values;
 }
-function extractPermissionValue(node, sourceContent) {
-  if (node.type === "Literal" && typeof node.value === "string") {
-    return node.value;
+function extractPermissionValue(node) {
+  const strLit = node.asKind(SyntaxKind2.StringLiteral);
+  if (strLit) {
+    return strLit.getLiteralValue();
   }
-  if (node.type === "MemberExpression") {
-    if (node.range) {
-      const [start, end] = node.range;
-      return sourceContent.slice(start, end);
-    }
+  const propAccess = node.asKind(SyntaxKind2.PropertyAccessExpression);
+  if (propAccess) {
+    return propAccess.getText();
   }
   return void 0;
 }
-function extractBffConfig(objectExpr) {
+function extractBffConfig(objLiteral) {
   const bff = {};
-  for (const prop of objectExpr.properties) {
-    if (prop.type !== "Property") continue;
-    if (prop.key.type !== "Identifier") continue;
-    if (prop.key.name === "apiServices" && prop.value.type === "ArrayExpression") {
-      bff.apiServices = [];
-      for (const element of prop.value.elements) {
-        if (element?.type === "Literal" && typeof element.value === "string") {
-          bff.apiServices.push(element.value);
-        }
-        if (element?.type === "MemberExpression") {
-          if (element.property.type === "Identifier") {
-            bff.apiServices.push(element.property.name);
+  for (const prop of objLiteral.getProperties()) {
+    const propAssign = prop.asKind(SyntaxKind2.PropertyAssignment);
+    if (!propAssign) continue;
+    if (propAssign.getName() === "apiServices") {
+      const arr = propAssign.getInitializer()?.asKind(SyntaxKind2.ArrayLiteralExpression);
+      if (arr) {
+        bff.apiServices = [];
+        for (const element of arr.getElements()) {
+          const strLit = element.asKind(SyntaxKind2.StringLiteral);
+          if (strLit) {
+            bff.apiServices.push(strLit.getLiteralValue());
+            continue;
+          }
+          const propAccess = element.asKind(
+            SyntaxKind2.PropertyAccessExpression
+          );
+          if (propAccess) {
+            bff.apiServices.push(propAccess.getName());
           }
         }
       }
@@ -1413,13 +1444,16 @@ function extractBffConfig(objectExpr) {
   }
   return bff;
 }
-function extractLegacyOpenApi(objectExpr) {
+function extractLegacyOpenApi(objLiteral) {
   const openapi = {};
-  for (const prop of objectExpr.properties) {
-    if (prop.type !== "Property") continue;
-    if (prop.key.type !== "Identifier") continue;
-    if (prop.key.name === "tags" && prop.value.type === "ArrayExpression") {
-      openapi.tags = extractStringArray(prop.value);
+  for (const prop of objLiteral.getProperties()) {
+    const propAssign = prop.asKind(SyntaxKind2.PropertyAssignment);
+    if (!propAssign) continue;
+    if (propAssign.getName() === "tags") {
+      const arr = propAssign.getInitializer()?.asKind(SyntaxKind2.ArrayLiteralExpression);
+      if (arr) {
+        openapi.tags = extractStringArray(arr);
+      }
     }
   }
   return openapi;
@@ -2392,7 +2426,7 @@ function checkSchemaImport(contractFile, _contractDir, imp) {
 import fg9 from "fast-glob";
 import { readFileSync as readFileSync4 } from "fs";
 import { basename as basename5 } from "path";
-import { parse as parse3 } from "@typescript-eslint/typescript-estree";
+import { Node, Project as Project3, SyntaxKind as SyntaxKind3 } from "ts-morph";
 var ALLOWED_SUFFIXES = [
   ".enum-bundle.ts",
   ".schema.ts",
@@ -2411,13 +2445,12 @@ var ALLOWED_SUFFIXES = [
 var ALLOWED_SPECIAL_FILES = ["index.ts", "openapi.ts"];
 function parseFile(filePath) {
   try {
-    const content = readFileSync4(filePath, "utf-8");
-    return parse3(content, {
-      loc: true,
-      range: true,
-      comment: true,
-      jsx: false
+    const project = new Project3({
+      useInMemoryFileSystem: false,
+      skipAddingFilesFromTsConfig: true
     });
+    project.addSourceFileAtPath(filePath);
+    return project.getSourceFileOrThrow(filePath);
   } catch {
     return null;
   }
@@ -2425,48 +2458,58 @@ function parseFile(filePath) {
 function readFileContent(filePath) {
   return readFileSync4(filePath, "utf-8");
 }
-function getExportedNames(ast) {
+function getExportedNames(sourceFile) {
   const names = [];
-  for (const node of ast.body) {
-    if (node.type === "ExportNamedDeclaration") {
-      if (node.declaration) {
-        if (node.declaration.type === "VariableDeclaration") {
-          for (const decl of node.declaration.declarations) {
-            if (decl.id.type === "Identifier") {
-              names.push(decl.id.name);
-            } else if (decl.id.type === "ObjectPattern") {
-              for (const prop of decl.id.properties) {
-                if (prop.type === "Property" && prop.value.type === "Identifier") {
-                  names.push(prop.value.name);
-                }
-              }
+  for (const statement of sourceFile.getStatements()) {
+    const kind = statement.getKind();
+    if (kind === SyntaxKind3.ExportDeclaration) {
+      const exportDecl = statement.asKindOrThrow(SyntaxKind3.ExportDeclaration);
+      for (const namedExport of exportDecl.getNamedExports()) {
+        names.push(
+          namedExport.getAliasNode()?.getText() ?? namedExport.getName()
+        );
+      }
+    }
+    if (Node.isModifierable(statement) && statement.hasModifier(SyntaxKind3.ExportKeyword)) {
+      if (kind === SyntaxKind3.VariableStatement) {
+        const varStatement = statement.asKindOrThrow(
+          SyntaxKind3.VariableStatement
+        );
+        for (const decl of varStatement.getDeclarations()) {
+          const nameNode = decl.getNameNode();
+          if (nameNode.getKind() === SyntaxKind3.Identifier) {
+            names.push(nameNode.getText());
+          } else if (nameNode.getKind() === SyntaxKind3.ObjectBindingPattern) {
+            const objectPattern = nameNode.asKindOrThrow(
+              SyntaxKind3.ObjectBindingPattern
+            );
+            for (const element of objectPattern.getElements()) {
+              const propertyName = element.getPropertyNameNode();
+              const elementName = element.getNameNode();
+              names.push(elementName.getText());
             }
           }
         }
-        if (node.declaration.type === "TSTypeAliasDeclaration") {
-          names.push(node.declaration.id.name);
-        }
-        if (node.declaration.type === "FunctionDeclaration" && node.declaration.id) {
-          names.push(node.declaration.id.name);
-        }
       }
-      if (node.specifiers) {
-        for (const spec of node.specifiers) {
-          if (spec.exported.type === "Identifier") {
-            names.push(spec.exported.name);
-          }
-        }
+      if (kind === SyntaxKind3.TypeAliasDeclaration) {
+        const typeAlias = statement.asKindOrThrow(
+          SyntaxKind3.TypeAliasDeclaration
+        );
+        names.push(typeAlias.getName());
+      }
+      if (kind === SyntaxKind3.FunctionDeclaration) {
+        const funcDecl = statement.asKindOrThrow(
+          SyntaxKind3.FunctionDeclaration
+        );
+        const funcName = funcDecl.getName();
+        if (funcName) names.push(funcName);
       }
     }
   }
   return names;
 }
-function hasDefaultExport(ast) {
-  return ast.body.some(
-    (node) => node.type === "ExportDefaultDeclaration" || node.type === "ExportNamedDeclaration" && node.specifiers?.some(
-      (s) => s.exported.type === "Identifier" && s.exported.name === "default"
-    )
-  );
+function hasDefaultExport(sourceFile) {
+  return sourceFile.getExportedDeclarations().has("default");
 }
 function hasOpenApiDocumentation(content) {
   return /\.describe\s*\(/.test(content) || /\.openapi\s*\(/.test(content);
@@ -2482,43 +2525,62 @@ function hasZodDataSchemas(content) {
     content
   );
 }
-function getExportsWithoutDeprecatedJsdoc(ast, content) {
+function getExportsWithoutDeprecatedJsdoc(sourceFile) {
   const missingDeprecated = [];
-  for (const node of ast.body) {
-    if (node.type !== "ExportNamedDeclaration" && node.type !== "ExportDefaultDeclaration") {
+  for (const statement of sourceFile.getStatements()) {
+    const kind = statement.getKind();
+    const isExported = Node.isModifierable(statement) && statement.hasModifier(SyntaxKind3.ExportKeyword);
+    if (kind !== SyntaxKind3.ExportDeclaration && kind !== SyntaxKind3.ExportAssignment && !isExported) {
       continue;
     }
-    let exportName = "default";
-    if (node.type === "ExportNamedDeclaration") {
-      if (node.declaration) {
-        if (node.declaration.type === "VariableDeclaration") {
-          const decl = node.declaration.declarations[0];
-          if (decl?.id.type === "Identifier") {
-            exportName = decl.id.name;
-          }
-        } else if (node.declaration.type === "TSTypeAliasDeclaration" || node.declaration.type === "FunctionDeclaration" && node.declaration.id) {
-          exportName = node.declaration.type === "TSTypeAliasDeclaration" ? node.declaration.id.name : node.declaration.id.name;
-        }
+    if (kind === SyntaxKind3.ExportAssignment) {
+      if (!hasDeprecatedComment(statement)) {
+        missingDeprecated.push("default");
+      }
+      continue;
+    }
+    if (kind === SyntaxKind3.ExportDeclaration) {
+      const exportDecl = statement.asKindOrThrow(SyntaxKind3.ExportDeclaration);
+      if (exportDecl.getModuleSpecifier() !== void 0) continue;
+    }
+    let exportName = "unknown";
+    if (kind === SyntaxKind3.VariableStatement) {
+      const varStatement = statement.asKindOrThrow(
+        SyntaxKind3.VariableStatement
+      );
+      const declarations = varStatement.getDeclarations();
+      const firstDecl = declarations[0];
+      if (firstDecl) {
+        exportName = firstDecl.getName();
       }
-      if (node.source) continue;
+    } else if (kind === SyntaxKind3.TypeAliasDeclaration) {
+      const typeAlias = statement.asKindOrThrow(
+        SyntaxKind3.TypeAliasDeclaration
+      );
+      exportName = typeAlias.getName();
+    } else if (kind === SyntaxKind3.FunctionDeclaration) {
+      const funcDecl = statement.asKindOrThrow(SyntaxKind3.FunctionDeclaration);
+      exportName = funcDecl.getName() ?? "anonymous";
     }
-    const linesBefore = content.substring(0, node.range?.[0] ?? 0);
-    const lastCommentBlock = linesBefore.match(/\/\*\*[\s\S]*?\*\/\s*$/);
-    if (!lastCommentBlock || !lastCommentBlock[0].includes("@deprecated")) {
+    if (!hasDeprecatedComment(statement)) {
       missingDeprecated.push(exportName);
     }
   }
   return missingDeprecated;
 }
-function getNonReexportStatements(ast) {
+function hasDeprecatedComment(node) {
+  return node.getLeadingCommentRanges().some((comment) => comment.getText().includes("@deprecated"));
+}
+function getNonReexportStatements(sourceFile) {
   const violations = [];
-  for (const node of ast.body) {
-    if (node.type === "ImportDeclaration") continue;
-    if (node.type === "ExportAllDeclaration") continue;
-    if (node.type === "ExportNamedDeclaration" && node.source) continue;
-    if (node.type === "ExportNamedDeclaration" && node.exportKind === "type" && node.source)
-      continue;
-    violations.push(node);
+  for (const statement of sourceFile.getStatements()) {
+    const kind = statement.getKind();
+    if (kind === SyntaxKind3.ImportDeclaration) continue;
+    if (kind === SyntaxKind3.ExportDeclaration) {
+      const exportDecl = statement.asKindOrThrow(SyntaxKind3.ExportDeclaration);
+      if (exportDecl.getModuleSpecifier() !== void 0) continue;
+    }
+    violations.push(statement);
   }
   return violations;
 }
@@ -2531,9 +2593,9 @@ async function checkEnumBundleRules(cwd) {
   for (const file of files) {
     const fullPath = `${cwd}/${file}`;
     const content = readFileContent(fullPath);
-    const ast = parseFile(fullPath);
-    if (!ast) continue;
-    const exportedNames = getExportedNames(ast);
+    const sourceFile = parseFile(fullPath);
+    if (!sourceFile) continue;
+    const exportedNames = getExportedNames(sourceFile);
     const fileName = basename5(file, ".enum-bundle.ts");
     const upperName = fileName.replace(/[^a-zA-Z0-9]/g, "_").toUpperCase();
     const hasSchema = exportedNames.some((n) => n.endsWith("Schema"));
@@ -2584,9 +2646,9 @@ async function checkResponseRules(cwd) {
   for (const file of files) {
     const fullPath = `${cwd}/${file}`;
     const content = readFileContent(fullPath);
-    const ast = parseFile(fullPath);
-    if (!ast) continue;
-    const exportedNames = getExportedNames(ast);
+    const sourceFile = parseFile(fullPath);
+    if (!sourceFile) continue;
+    const exportedNames = getExportedNames(sourceFile);
     const fileName = basename5(file, ".response.ts");
     const httpCode = fileName.match(/^(\d{3})$/)?.[1];
     if (httpCode) {
@@ -2600,7 +2662,7 @@ async function checkResponseRules(cwd) {
         });
       }
     }
-    if (!hasDefaultExport(ast)) {
+    if (!hasDefaultExport(sourceFile)) {
       results.push({
         ruleId: "CTR-RESPONSE-002",
         severity: "error",
@@ -2630,9 +2692,9 @@ async function checkRequestRules(cwd) {
   for (const file of files) {
     const fullPath = `${cwd}/${file}`;
     const content = readFileContent(fullPath);
-    const ast = parseFile(fullPath);
-    if (!ast) continue;
-    const exportedNames = getExportedNames(ast);
+    const sourceFile = parseFile(fullPath);
+    if (!sourceFile) continue;
+    const exportedNames = getExportedNames(sourceFile);
     const hasTypedSchema = exportedNames.some(
       (n) => /(Query|Body|Headers|Params)Schema$/.test(n)
     );
@@ -2666,9 +2728,9 @@ async function checkContractFileRules(cwd) {
   for (const file of files) {
     const fullPath = `${cwd}/${file}`;
     const content = readFileContent(fullPath);
-    const ast = parseFile(fullPath);
-    if (!ast) continue;
-    const exportedNames = getExportedNames(ast);
+    const sourceFile = parseFile(fullPath);
+    if (!sourceFile) continue;
+    const exportedNames = getExportedNames(sourceFile);
     const hasContractExport = exportedNames.some((n) => n.endsWith("Contract"));
     if (!hasContractExport) {
       results.push({
@@ -2708,16 +2770,16 @@ async function checkIndexRules(cwd) {
   });
   for (const file of files) {
     const fullPath = `${cwd}/${file}`;
-    const ast = parseFile(fullPath);
-    if (!ast) continue;
-    const violations = getNonReexportStatements(ast);
+    const sourceFile = parseFile(fullPath);
+    if (!sourceFile) continue;
+    const violations = getNonReexportStatements(sourceFile);
     if (violations.length > 0) {
       results.push({
         ruleId: "CTR-INDEX-001",
         severity: "error",
         message: `Index file ${file} contains ${violations.length} non-reexport statement(s)`,
         file,
-        line: violations[0]?.loc?.start.line,
+        line: violations[0]?.getStartLineNumber(),
         suggestion: "Index files should only contain: export * from '...' or export { X } from '...'"
       });
     }
@@ -2782,10 +2844,9 @@ async function checkDeprecatedRules(cwd) {
   });
   for (const file of files) {
     const fullPath = `${cwd}/${file}`;
-    const content = readFileContent(fullPath);
-    const ast = parseFile(fullPath);
-    if (!ast) continue;
-    const missing = getExportsWithoutDeprecatedJsdoc(ast, content);
+    const sourceFile = parseFile(fullPath);
+    if (!sourceFile) continue;
+    const missing = getExportsWithoutDeprecatedJsdoc(sourceFile);
     if (missing.length > 0) {
       results.push({
         ruleId: "CTR-DEPRECATED-001",
@@ -2948,7 +3009,7 @@ var contractsChecker = {
 // src/lint/checkers/vault/index.ts
 import { existsSync as existsSync5, readdirSync } from "fs";
 import { join as join3, dirname as dirname4 } from "path";
-import { Project, SyntaxKind } from "ts-morph";
+import { Project as Project4, SyntaxKind as SyntaxKind4 } from "ts-morph";
 var VAULT_PATHS = [
   "src/common/config/vault",
   "server/vault",
@@ -2977,7 +3038,7 @@ function isInsideZodObject(node) {
   if (!node) return false;
   let current = node;
   while (current) {
-    if (current.getKind() === SyntaxKind.CallExpression) {
+    if (current.getKind() === SyntaxKind4.CallExpression) {
       const text = current.getText();
       if (text.startsWith("z.object(")) return true;
     }
@@ -2989,7 +3050,7 @@ function checkAstPatterns(sourceFile) {
   const results = [];
   const filePath = sourceFile.getFilePath();
   sourceFile.forEachDescendant((node) => {
-    if (node.getKind() === SyntaxKind.CallExpression) {
+    if (node.getKind() === SyntaxKind4.CallExpression) {
       const text = node.getText();
       if (text.startsWith("z.lazy(")) {
         results.push({
@@ -3001,11 +3062,11 @@ function checkAstPatterns(sourceFile) {
         });
       }
       if (text.startsWith("z.enum(")) {
-        const callExpr = node.asKind(SyntaxKind.CallExpression);
+        const callExpr = node.asKind(SyntaxKind4.CallExpression);
         const args = callExpr?.getArguments();
         if (args && args.length > 0) {
           const firstArg = args[0];
-          if (firstArg?.getKind() === SyntaxKind.Identifier) {
+          if (firstArg?.getKind() === SyntaxKind4.Identifier) {
             results.push({
               ruleId: "VAULT-AST-004",
               severity: getRuleSeverity("VAULT-AST-004"),
@@ -3018,11 +3079,11 @@ function checkAstPatterns(sourceFile) {
         }
       }
       if (text.startsWith("z.object(")) {
-        const callExpr = node.asKind(SyntaxKind.CallExpression);
+        const callExpr = node.asKind(SyntaxKind4.CallExpression);
         const args = callExpr?.getArguments();
         if (args && args.length > 0) {
           const firstArg = args[0];
-          if (firstArg?.getKind() === SyntaxKind.Identifier) {
+          if (firstArg?.getKind() === SyntaxKind4.Identifier) {
             results.push({
               ruleId: "VAULT-AST-006",
               severity: getRuleSeverity("VAULT-AST-006"),
@@ -3034,11 +3095,11 @@ function checkAstPatterns(sourceFile) {
         }
       }
     }
-    if (node.getKind() === SyntaxKind.SpreadAssignment) {
+    if (node.getKind() === SyntaxKind4.SpreadAssignment) {
       if (isInsideZodObject(node)) {
-        const spreadExpr = node.asKind(SyntaxKind.SpreadAssignment);
+        const spreadExpr = node.asKind(SyntaxKind4.SpreadAssignment);
         const expr = spreadExpr?.getExpression();
-        if (expr?.getKind() === SyntaxKind.ConditionalExpression || expr?.getKind() === SyntaxKind.Identifier) {
+        if (expr?.getKind() === SyntaxKind4.ConditionalExpression || expr?.getKind() === SyntaxKind4.Identifier) {
           results.push({
             ruleId: "VAULT-AST-002",
             severity: getRuleSeverity("VAULT-AST-002"),
@@ -3049,8 +3110,8 @@ function checkAstPatterns(sourceFile) {
         }
       }
     }
-    if (node.getKind() === SyntaxKind.FunctionDeclaration || node.getKind() === SyntaxKind.ArrowFunction) {
-      const funcNode = node.asKind(SyntaxKind.FunctionDeclaration) || node.asKind(SyntaxKind.ArrowFunction);
+    if (node.getKind() === SyntaxKind4.FunctionDeclaration || node.getKind() === SyntaxKind4.ArrowFunction) {
+      const funcNode = node.asKind(SyntaxKind4.FunctionDeclaration) || node.asKind(SyntaxKind4.ArrowFunction);
       if (funcNode) {
         const body = funcNode.getBody();
         if (body) {
@@ -3082,7 +3143,7 @@ var vaultChecker = {
     }
     const configResult = loadConfig(ctx.cwd);
     const disabledRules = configResult.success ? getDisabledVaultRules(configResult.config) : [];
-    const project = new Project({
+    const project = new Project4({
       skipAddingFilesFromTsConfig: true,
       skipFileDependencyResolution: true
     });

package/dist/cli.js

@@ -5,7 +5,7 @@ import {
   lintCommand,
   loadConfig,
   scaffoldCommand
-} from "./chunk-EB6S5X3P.js";
+} from "./chunk-4LVIIP2D.js";
 import {
   scanForVaultRepos
 } from "./chunk-WXFSGE4N.js";
@@ -21,7 +21,7 @@ import { resolve } from "path";
 // src/lib/contracts/codemod/analyze-bff.ts
 import { readFileSync } from "fs";
 import fg from "fast-glob";
-import { parse } from "@typescript-eslint/typescript-estree";
+import { Project, SyntaxKind } from "ts-morph";
 var MODULE_TO_SERVICE = {
   SeeCoreModule: "seeCore",
   LocusModule: "locus",
@@ -104,63 +104,48 @@ function extractApiServicesFromModule(modulePath) {
   return services;
 }
 function analyzeController(controllerPath, apiServices) {
-  const content = readFileSync(controllerPath, "utf-8");
   const mappings = [];
-  let ast;
+  const project = new Project({ skipAddingFilesFromTsConfig: true });
+  let sourceFile;
   try {
-    ast = parse(content, { loc: true, range: true, comment: true });
+    sourceFile = project.addSourceFileAtPath(controllerPath);
   } catch {
     return mappings;
   }
-  for (const node of ast.body) {
-    if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "ClassDeclaration") {
-      const classNode = node.declaration;
-      analyzeClassMethods(
-        classNode,
-        controllerPath,
-        apiServices,
-        content,
-        mappings
-      );
-    }
-    if (node.type === "ClassDeclaration") {
-      analyzeClassMethods(node, controllerPath, apiServices, content, mappings);
-    }
+  for (const classDecl of sourceFile.getClasses()) {
+    analyzeClassMethods(classDecl, controllerPath, apiServices, mappings);
   }
   return mappings;
 }
-function analyzeClassMethods(classNode, controllerPath, apiServices, content, mappings) {
-  for (const member of classNode.body.body) {
-    if (member.type !== "MethodDefinition") continue;
-    if (member.key.type !== "Identifier") continue;
-    const methodName = member.key.name;
+function analyzeClassMethods(classDecl, controllerPath, apiServices, mappings) {
+  for (const method of classDecl.getMethods()) {
+    const methodName = method.getName();
     if (methodName === "constructor" || methodName.startsWith("_")) continue;
-    const decorators = member.decorators ?? [];
     let permission = null;
-    let method = null;
+    let httpMethod = null;
     let path = null;
     let contractEndpointName = null;
-    for (const decorator of decorators) {
-      if (decorator.expression.type === "CallExpression") {
-        const callee = decorator.expression.callee;
-        if (callee.type === "Identifier" && callee.name === "TsRestHandler") {
-          const arg = decorator.expression.arguments[0];
-          if (arg?.type === "MemberExpression" && arg.property.type === "Identifier") {
-            contractEndpointName = arg.property.name;
-          }
+    for (const decorator of method.getDecorators()) {
+      const decoratorName = decorator.getName();
+      const args = decorator.getArguments();
+      if (decoratorName === "TsRestHandler" && args[0]) {
+        const arg = args[0];
+        if (arg.getKind() === SyntaxKind.PropertyAccessExpression) {
+          const propAccess = arg.asKind(SyntaxKind.PropertyAccessExpression);
+          contractEndpointName = propAccess.getName();
         }
-        if (callee.type === "Identifier" && callee.name === "Authorize") {
-          const arg = decorator.expression.arguments[0];
-          if (arg?.type === "MemberExpression" && arg.property.type === "Identifier") {
-            permission = arg.property.name;
-          }
+      }
+      if (decoratorName === "Authorize" && args[0]) {
+        const arg = args[0];
+        if (arg.getKind() === SyntaxKind.PropertyAccessExpression) {
+          const propAccess = arg.asKind(SyntaxKind.PropertyAccessExpression);
+          permission = propAccess.getName();
         }
-        if (callee.type === "Identifier" && ["Get", "Post", "Put", "Patch", "Delete"].includes(callee.name)) {
-          method = callee.name.toUpperCase();
-          const arg = decorator.expression.arguments[0];
-          if (arg?.type === "Literal" && typeof arg.value === "string") {
-            path = arg.value;
-          }
+      }
+      if (["Get", "Post", "Put", "Patch", "Delete"].includes(decoratorName)) {
+        httpMethod = decoratorName.toUpperCase();
+        if (args[0]?.getKind() === SyntaxKind.StringLiteral) {
+          path = args[0].asKind(SyntaxKind.StringLiteral).getLiteralValue();
         }
       }
     }
@@ -174,7 +159,7 @@ function analyzeClassMethods(classNode, controllerPath, apiServices, content, ma
       permissionValue,
       apiModules,
       apiServices,
-      method,
+      method: httpMethod,
       path
     });
   }

package/dist/mcp-server.js

@@ -3,7 +3,7 @@ import {
   analyzeCore,
   lintCore,
   scaffoldCore
-} from "./chunk-EB6S5X3P.js";
+} from "./chunk-4LVIIP2D.js";
 
 // src/mcp-server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyphaene/hexa-ts-kit",
-  "version": "1.12.1",
+  "version": "1.12.2",
   "description": "TypeScript dev kit for Claude Code agents: architecture linting, scaffolding, knowledge analysis",
   "type": "module",
   "bin": {
@@ -47,8 +47,6 @@
   "homepage": "https://github.com/hyphaene/hexa-ts-kit#readme",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.1",
-    "@typescript-eslint/parser": "^8.50.1",
-    "@typescript-eslint/typescript-estree": "^8.50.1",
     "commander": "^12.1.0",
     "fast-glob": "^3.3.2",
     "gray-matter": "^4.0.3",
@@ -60,7 +58,6 @@
     "picocolors": "^1.1.1",
     "react": "^19.2.4",
     "ts-morph": "^27.0.2",
-    "vue-eslint-parser": "^10.2.0",
     "yaml": "^2.8.2",
     "zod": "^4.3.4"
   },