@hyphaene/hexa-ts-kit 1.11.0 → 1.12.1

package/dist/{chunk-IBVI6IS2.js → chunk-EB6S5X3P.js}

@@ -753,6 +753,114 @@ var rulesRegistry = {
     }
   },
   // ==========================================================================
+  // Contracts Nomenclature Rules (CTR-ENUM-*, CTR-RESPONSE-*, etc.)
+  // ==========================================================================
+  "CTR-ENUM-001": {
+    title: "Enum bundle missing required exports",
+    severity: "error",
+    category: "contracts",
+    why: "Enum bundles must export {name}Schema, {NAME}, and {NAME}_VALUES for consistent API.",
+    autoFixable: false
+  },
+  "CTR-ENUM-002": {
+    title: "Enum bundle missing createEnumBundle()",
+    severity: "warning",
+    category: "contracts",
+    why: "Enum bundles should use createEnumBundle() for consistent schema/enum/values creation.",
+    autoFixable: false
+  },
+  "CTR-ENUM-003": {
+    title: "Enum bundle missing inferred type export",
+    severity: "error",
+    category: "contracts",
+    why: "Enum bundles must export a type via z.infer for type safety.",
+    autoFixable: false
+  },
+  "CTR-RESPONSE-001": {
+    title: "Response file missing export ending with {HTTP}Schema",
+    severity: "error",
+    category: "contracts",
+    why: "Response files must export a schema whose name ends with {HTTP}Schema (e.g. MyFeature200Schema or MyFeatureResponse200Schema).",
+    autoFixable: false
+  },
+  "CTR-RESPONSE-002": {
+    title: "Response file missing default export",
+    severity: "error",
+    category: "contracts",
+    why: "Response files must have a default export for fixture validation scripts.",
+    autoFixable: false
+  },
+  "CTR-RESPONSE-003": {
+    title: "Response file missing OpenAPI documentation",
+    severity: "error",
+    category: "contracts",
+    why: "Response schema fields must have .describe() or .openapi() for OpenAPI documentation generation.",
+    autoFixable: false
+  },
+  "CTR-REQUEST-001": {
+    title: "Request file missing typed schema export",
+    severity: "error",
+    category: "contracts",
+    why: "Request files must export a schema whose name ends with QuerySchema, BodySchema, HeadersSchema, or ParamsSchema.",
+    autoFixable: false
+  },
+  "CTR-REQUEST-002": {
+    title: "Request file missing OpenAPI documentation",
+    severity: "error",
+    category: "contracts",
+    why: "Request schema fields should use .describe() for OpenAPI documentation.",
+    autoFixable: false
+  },
+  "CTR-CONTRACT-001": {
+    title: "Contract file missing {Name}Contract export",
+    severity: "error",
+    category: "contracts",
+    why: "Contract files must export a named {Name}Contract for discoverability.",
+    autoFixable: false
+  },
+  "CTR-CONTRACT-002": {
+    title: "Contract file missing strictStatusCodes: true",
+    severity: "error",
+    category: "contracts",
+    why: "Contract files must use strictStatusCodes: true for type safety.",
+    autoFixable: false
+  },
+  "CTR-CONTRACT-003": {
+    title: "Contract file missing contractMetadata()",
+    severity: "error",
+    category: "contracts",
+    why: "Contract endpoints must use contractMetadata() for permission and tag declaration.",
+    autoFixable: false
+  },
+  "CTR-INDEX-001": {
+    title: "Index file contains local declarations",
+    severity: "error",
+    category: "contracts",
+    why: "Index files must only contain re-exports (export * from / export { } from).",
+    autoFixable: false
+  },
+  "CTR-HELPER-001": {
+    title: "Helper file contains Zod data schemas",
+    severity: "warning",
+    category: "contracts",
+    why: "Helper files should contain pure functions, not Zod data schemas.",
+    autoFixable: false
+  },
+  "CTR-NAMING-001": {
+    title: "File has non-standard suffix",
+    severity: "error",
+    category: "contracts",
+    why: "All source files must use an allowed suffix from the nomenclature.",
+    autoFixable: false
+  },
+  "CTR-DEPRECATED-001": {
+    title: "Deprecated file export missing @deprecated JSDoc",
+    severity: "error",
+    category: "contracts",
+    why: "All exports in .deprecated.ts files must have @deprecated JSDoc annotation.",
+    autoFixable: false
+  },
+  // ==========================================================================
   // Contracts Colocation Rules (COL-CTR-*)
   // ==========================================================================
   "COL-CTR-001": {
@@ -837,7 +945,7 @@ var ContractsLintConfigSchema = z.object({
   metadata: z.object({
     permissions: SourceExtractConfigSchema,
     apiServices: SourceExtractConfigSchema
-  }),
+  }).optional(),
   disabledRules: z.array(z.string()).optional()
 });
 var VaultLintConfigSchema = z.object({
@@ -2280,6 +2388,476 @@ function checkSchemaImport(contractFile, _contractDir, imp) {
   return results;
 }
 
+// src/lint/checkers/contracts/nomenclature.ts
+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";
+var ALLOWED_SUFFIXES = [
+  ".enum-bundle.ts",
+  ".schema.ts",
+  ".response.ts",
+  ".request.ts",
+  ".presenter.ts",
+  ".contract.ts",
+  ".helpers.ts",
+  ".constants.ts",
+  ".deprecated.ts",
+  ".test.ts",
+  ".contract.test.ts",
+  ".migration.test.ts",
+  ".rules.ts"
+];
+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
+    });
+  } catch {
+    return null;
+  }
+}
+function readFileContent(filePath) {
+  return readFileSync4(filePath, "utf-8");
+}
+function getExportedNames(ast) {
+  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);
+                }
+              }
+            }
+          }
+        }
+        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);
+          }
+        }
+      }
+    }
+  }
+  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 hasOpenApiDocumentation(content) {
+  return /\.describe\s*\(/.test(content) || /\.openapi\s*\(/.test(content);
+}
+function hasCreateEnumBundleCall(content) {
+  return /createEnumBundle\s*\(/.test(content);
+}
+function hasZodInferTypeExport(content) {
+  return /export\s+type\s+\w+\s*=\s*z\.infer/.test(content);
+}
+function hasZodDataSchemas(content) {
+  return /(?:const|let|var)\s+\w+\s*=\s*z\.(?:object|enum|array)\s*\(/.test(
+    content
+  );
+}
+function getExportsWithoutDeprecatedJsdoc(ast, content) {
+  const missingDeprecated = [];
+  for (const node of ast.body) {
+    if (node.type !== "ExportNamedDeclaration" && node.type !== "ExportDefaultDeclaration") {
+      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 (node.source) continue;
+    }
+    const linesBefore = content.substring(0, node.range?.[0] ?? 0);
+    const lastCommentBlock = linesBefore.match(/\/\*\*[\s\S]*?\*\/\s*$/);
+    if (!lastCommentBlock || !lastCommentBlock[0].includes("@deprecated")) {
+      missingDeprecated.push(exportName);
+    }
+  }
+  return missingDeprecated;
+}
+function getNonReexportStatements(ast) {
+  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);
+  }
+  return violations;
+}
+async function checkEnumBundleRules(cwd) {
+  const results = [];
+  const files = await fg9("src/**/*.enum-bundle.ts", {
+    cwd,
+    ignore: ["**/node_modules/**", "**/dist/**"]
+  });
+  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 fileName = basename5(file, ".enum-bundle.ts");
+    const upperName = fileName.replace(/[^a-zA-Z0-9]/g, "_").toUpperCase();
+    const hasSchema = exportedNames.some((n) => n.endsWith("Schema"));
+    const hasEnumMapper = exportedNames.some(
+      (n) => n === n.toUpperCase() && n.length > 1
+    );
+    const hasValues = exportedNames.some((n) => n.endsWith("_VALUES"));
+    if (!hasSchema || !hasEnumMapper || !hasValues) {
+      const missing = [];
+      if (!hasSchema) missing.push("{name}Schema");
+      if (!hasEnumMapper) missing.push("{NAME}");
+      if (!hasValues) missing.push("{NAME}_VALUES");
+      results.push({
+        ruleId: "CTR-ENUM-001",
+        severity: "error",
+        message: `Enum bundle ${file} missing exports: ${missing.join(", ")}`,
+        file,
+        suggestion: `Export ${upperName}_VALUES, ${upperName}, and a Schema const`
+      });
+    }
+    if (!hasCreateEnumBundleCall(content)) {
+      results.push({
+        ruleId: "CTR-ENUM-002",
+        severity: "warning",
+        message: `Enum bundle ${file} does not use createEnumBundle()`,
+        file,
+        suggestion: "Use createEnumBundle() for consistent schema/enum/values creation"
+      });
+    }
+    if (!hasZodInferTypeExport(content)) {
+      results.push({
+        ruleId: "CTR-ENUM-003",
+        severity: "error",
+        message: `Enum bundle ${file} missing type export via z.infer`,
+        file,
+        suggestion: "Add: export type {Name} = z.infer<typeof {name}Schema>"
+      });
+    }
+  }
+  return results;
+}
+async function checkResponseRules(cwd) {
+  const results = [];
+  const files = await fg9("src/**/*.response.ts", {
+    cwd,
+    ignore: ["**/node_modules/**", "**/dist/**"]
+  });
+  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 fileName = basename5(file, ".response.ts");
+    const httpCode = fileName.match(/^(\d{3})$/)?.[1];
+    if (httpCode) {
+      if (!exportedNames.some((n) => n.includes(httpCode) && n.endsWith("Schema"))) {
+        results.push({
+          ruleId: "CTR-RESPONSE-001",
+          severity: "error",
+          message: `Response file ${file} missing export containing "${httpCode}" and ending with "Schema"`,
+          file,
+          suggestion: `Export a schema whose name contains ${httpCode} and ends with Schema (e.g. MyFeature${httpCode}Schema)`
+        });
+      }
+    }
+    if (!hasDefaultExport(ast)) {
+      results.push({
+        ruleId: "CTR-RESPONSE-002",
+        severity: "error",
+        message: `Response file ${file} missing default export`,
+        file,
+        suggestion: "Add: export default Response{HTTP}Schema"
+      });
+    }
+    if (!hasOpenApiDocumentation(content)) {
+      results.push({
+        ruleId: "CTR-RESPONSE-003",
+        severity: "error",
+        message: `Response file ${file} has no OpenAPI documentation (.describe() or .openapi())`,
+        file,
+        suggestion: "Add .describe('...') or .openapi({ description: '...' }) to schema fields"
+      });
+    }
+  }
+  return results;
+}
+async function checkRequestRules(cwd) {
+  const results = [];
+  const files = await fg9("src/**/*.request.ts", {
+    cwd,
+    ignore: ["**/node_modules/**", "**/dist/**"]
+  });
+  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 hasTypedSchema = exportedNames.some(
+      (n) => /(Query|Body|Headers|Params)Schema$/.test(n)
+    );
+    if (!hasTypedSchema) {
+      results.push({
+        ruleId: "CTR-REQUEST-001",
+        severity: "error",
+        message: `Request file ${file} missing typed schema export (ending with QuerySchema, BodySchema, HeadersSchema, or ParamsSchema)`,
+        file,
+        suggestion: "Export a schema whose name ends with: QuerySchema, BodySchema, HeadersSchema, or ParamsSchema"
+      });
+    }
+    if (!hasOpenApiDocumentation(content)) {
+      results.push({
+        ruleId: "CTR-REQUEST-002",
+        severity: "error",
+        message: `Request file ${file} has no OpenAPI documentation (.describe() or .openapi())`,
+        file,
+        suggestion: "Add .describe('...') or .openapi({ description: '...' }) to schema fields"
+      });
+    }
+  }
+  return results;
+}
+async function checkContractFileRules(cwd) {
+  const results = [];
+  const files = await fg9("src/**/*.contract.ts", {
+    cwd,
+    ignore: ["**/node_modules/**", "**/dist/**", "**/*.contract.test.ts"]
+  });
+  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 hasContractExport = exportedNames.some((n) => n.endsWith("Contract"));
+    if (!hasContractExport) {
+      results.push({
+        ruleId: "CTR-CONTRACT-001",
+        severity: "error",
+        message: `Contract file ${file} missing {Name}Contract export`,
+        file,
+        suggestion: "Export const {Name}Contract = c.router({...})"
+      });
+    }
+    if (!content.includes("strictStatusCodes")) {
+      results.push({
+        ruleId: "CTR-CONTRACT-002",
+        severity: "error",
+        message: `Contract file ${file} missing strictStatusCodes: true`,
+        file,
+        suggestion: "Add strictStatusCodes: true to all endpoints"
+      });
+    }
+    if (!content.includes("contractMetadata")) {
+      results.push({
+        ruleId: "CTR-CONTRACT-003",
+        severity: "error",
+        message: `Contract file ${file} missing contractMetadata() usage`,
+        file,
+        suggestion: "Use metadata: contractMetadata({...}) for each endpoint"
+      });
+    }
+  }
+  return results;
+}
+async function checkIndexRules(cwd) {
+  const results = [];
+  const files = await fg9("src/**/index.ts", {
+    cwd,
+    ignore: ["**/node_modules/**", "**/dist/**", "**/lib/**"]
+  });
+  for (const file of files) {
+    const fullPath = `${cwd}/${file}`;
+    const ast = parseFile(fullPath);
+    if (!ast) continue;
+    const violations = getNonReexportStatements(ast);
+    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,
+        suggestion: "Index files should only contain: export * from '...' or export { X } from '...'"
+      });
+    }
+  }
+  return results;
+}
+async function checkHelperRules(cwd) {
+  const results = [];
+  const files = await fg9("src/**/*.helpers.ts", {
+    cwd,
+    ignore: ["**/node_modules/**", "**/dist/**"]
+  });
+  for (const file of files) {
+    const fullPath = `${cwd}/${file}`;
+    const content = readFileContent(fullPath);
+    if (hasZodDataSchemas(content)) {
+      results.push({
+        ruleId: "CTR-HELPER-001",
+        severity: "warning",
+        message: `Helper file ${file} contains Zod data schemas`,
+        file,
+        suggestion: "Move Zod data schemas to .schema.ts or .enum-bundle.ts files"
+      });
+    }
+  }
+  return results;
+}
+async function checkNamingRules(cwd) {
+  const results = [];
+  const files = await fg9("src/**/*.ts", {
+    cwd,
+    ignore: [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/lib/**",
+      "**/__tests__/**"
+    ]
+  });
+  for (const file of files) {
+    const fileName = basename5(file);
+    if (ALLOWED_SPECIAL_FILES.includes(fileName)) continue;
+    const matchesSuffix = ALLOWED_SUFFIXES.some(
+      (suffix) => fileName.endsWith(suffix)
+    );
+    if (!matchesSuffix) {
+      results.push({
+        ruleId: "CTR-NAMING-001",
+        severity: "error",
+        message: `File ${file} has non-standard suffix. Allowed: ${ALLOWED_SUFFIXES.join(", ")}`,
+        file,
+        suggestion: `Rename to use one of: ${ALLOWED_SUFFIXES.map((s) => `*${s}`).join(", ")}`
+      });
+    }
+  }
+  return results;
+}
+async function checkDeprecatedRules(cwd) {
+  const results = [];
+  const files = await fg9("src/**/*.deprecated.ts", {
+    cwd,
+    ignore: ["**/node_modules/**", "**/dist/**"]
+  });
+  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);
+    if (missing.length > 0) {
+      results.push({
+        ruleId: "CTR-DEPRECATED-001",
+        severity: "error",
+        message: `Deprecated file ${file} has exports without @deprecated JSDoc: ${missing.join(", ")}`,
+        file,
+        suggestion: "Add /** @deprecated Use X instead */ before each export"
+      });
+    }
+  }
+  return results;
+}
+var contractsNomenclatureChecker = {
+  name: "contracts-nomenclature",
+  rules: [
+    "CTR-ENUM-001",
+    "CTR-ENUM-002",
+    "CTR-ENUM-003",
+    "CTR-RESPONSE-001",
+    "CTR-RESPONSE-002",
+    "CTR-RESPONSE-003",
+    "CTR-REQUEST-001",
+    "CTR-REQUEST-002",
+    "CTR-CONTRACT-001",
+    "CTR-CONTRACT-002",
+    "CTR-CONTRACT-003",
+    "CTR-INDEX-001",
+    "CTR-HELPER-001",
+    "CTR-NAMING-001",
+    "CTR-DEPRECATED-001"
+  ],
+  async check(ctx) {
+    const configResult = loadConfig(ctx.cwd);
+    if (!configResult.success || configResult.config.project.type !== "contracts-lib") {
+      return [];
+    }
+    const disabledRules = getDisabledRules(configResult.config);
+    const results = [];
+    const [
+      enumResults,
+      responseResults,
+      requestResults,
+      contractResults,
+      indexResults,
+      helperResults,
+      namingResults,
+      deprecatedResults
+    ] = await Promise.all([
+      checkEnumBundleRules(ctx.cwd),
+      checkResponseRules(ctx.cwd),
+      checkRequestRules(ctx.cwd),
+      checkContractFileRules(ctx.cwd),
+      checkIndexRules(ctx.cwd),
+      checkHelperRules(ctx.cwd),
+      checkNamingRules(ctx.cwd),
+      checkDeprecatedRules(ctx.cwd)
+    ]);
+    results.push(
+      ...enumResults,
+      ...responseResults,
+      ...requestResults,
+      ...contractResults,
+      ...indexResults,
+      ...helperResults,
+      ...namingResults,
+      ...deprecatedResults
+    );
+    if (disabledRules.length === 0) return results;
+    return results.filter((r) => !disabledRules.includes(r.ruleId));
+  }
+};
+
 // src/lint/checkers/contracts/index.ts
 var contractsChecker = {
   name: "contracts",
@@ -2361,6 +2939,8 @@ var contractsChecker = {
     }
     const colocationResults = await contractsColocationChecker.check(ctx);
     results.push(...colocationResults);
+    const nomenclatureResults = await contractsNomenclatureChecker.check(ctx);
+    results.push(...nomenclatureResults);
     return results;
   }
 };
@@ -2759,10 +3339,10 @@ Completed in ${elapsed}ms`);
 }
 
 // src/commands/analyze.ts
-import { basename as basename5 } from "path";
+import { basename as basename6 } from "path";
 import { execSync as execSync2 } from "child_process";
-import { readFileSync as readFileSync4, existsSync as existsSync6 } from "fs";
-import fg9 from "fast-glob";
+import { readFileSync as readFileSync5, existsSync as existsSync6 } from "fs";
+import fg10 from "fast-glob";
 import matter from "gray-matter";
 import { minimatch } from "minimatch";
 function expandPath(p) {
@@ -2791,18 +3371,18 @@ function loadKnowledgeMappings(knowledgePath) {
   if (!existsSync6(expandedPath)) {
     return [];
   }
-  const knowledgeFiles = fg9.sync("**/*.knowledge.md", {
+  const knowledgeFiles = fg10.sync("**/*.knowledge.md", {
     cwd: expandedPath,
     absolute: true
   });
   const mappings = [];
   for (const file of knowledgeFiles) {
     try {
-      const content = readFileSync4(file, "utf-8");
+      const content = readFileSync5(file, "utf-8");
       const { data } = matter(content);
       if (data.match) {
         mappings.push({
-          name: data.name || basename5(file, ".knowledge.md"),
+          name: data.name || basename6(file, ".knowledge.md"),
           path: file,
           match: data.match,
           description: data.description
@@ -2815,7 +3395,7 @@ function loadKnowledgeMappings(knowledgePath) {
 }
 function matchFileToKnowledges(file, mappings) {
   const results = [];
-  const fileName = basename5(file);
+  const fileName = basename6(file);
   for (const mapping of mappings) {
     if (minimatch(fileName, mapping.match) || minimatch(file, mapping.match)) {
       results.push({
@@ -2877,7 +3457,7 @@ async function analyzeCommand(files = [], options) {
 }
 
 // src/commands/scaffold.ts
-import { resolve as resolve3, dirname as dirname5, basename as basename6, join as join4 } from "path";
+import { resolve as resolve3, dirname as dirname5, basename as basename7, join as join4 } from "path";
 import { mkdirSync, writeFileSync, existsSync as existsSync7 } from "fs";
 function toPascalCase(str) {
   return str.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
@@ -2887,7 +3467,7 @@ function toCamelCase(str) {
   return pascal.charAt(0).toLowerCase() + pascal.slice(1);
 }
 function generateVueFeature(featurePath) {
-  const featureName = basename6(featurePath);
+  const featureName = basename7(featurePath);
   const pascalName = toPascalCase(featureName);
   const camelName = toCamelCase(featureName);
   return [
@@ -3004,7 +3584,7 @@ describe('${pascalName}Rules', () => {
   ];
 }
 function generateNestJSFeature(featurePath) {
-  const featureName = basename6(featurePath);
+  const featureName = basename7(featurePath);
   const pascalName = toPascalCase(featureName);
   const camelName = toCamelCase(featureName);
   return [
@@ -3095,7 +3675,7 @@ describe('${pascalName}Controller', () => {
   ];
 }
 function generatePlaywrightFeature(featurePath) {
-  const featureName = basename6(featurePath);
+  const featureName = basename7(featurePath);
   const pascalName = toPascalCase(featureName);
   const camelName = toCamelCase(featureName);
   return [

package/dist/cli.js

@@ -5,7 +5,7 @@ import {
   lintCommand,
   loadConfig,
   scaffoldCommand
-} from "./chunk-IBVI6IS2.js";
+} from "./chunk-EB6S5X3P.js";
 import {
   scanForVaultRepos
 } from "./chunk-WXFSGE4N.js";

package/dist/mcp-server.js

@@ -3,7 +3,7 @@ import {
   analyzeCore,
   lintCore,
   scaffoldCore
-} from "./chunk-IBVI6IS2.js";
+} from "./chunk-EB6S5X3P.js";
 
 // src/mcp-server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -18,7 +18,7 @@ var server = new McpServer({
 });
 server.tool(
   "lint",
-  "Lint files for colocation architecture rules. Checks 71 rules across structure (COL, NAM, DOM) and AST (VUE, RUL, TSP) categories. Use --changed for incremental mode on git-modified files only.",
+  "Lint files for colocation architecture rules. Checks 96 rules across structure (COL, NAM, DOM, CTR) and AST (VUE, RUL, TSP) categories. Use --changed for incremental mode on git-modified files only.",
   {
     cwd: z.string().optional().describe("Working directory to lint (default: current directory)"),
     path: z.string().optional().describe("Alias for cwd - path to lint"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyphaene/hexa-ts-kit",
-  "version": "1.11.0",
+  "version": "1.12.1",
   "description": "TypeScript dev kit for Claude Code agents: architecture linting, scaffolding, knowledge analysis",
   "type": "module",
   "bin": {