@hyphaene/hexa-ts-kit 1.7.2 → 1.9.0

package/dist/{chunk-UNAQG5HI.js → chunk-OI2LN5K5.js}

@@ -1,5 +1,5 @@
 // src/commands/lint.ts
-import { resolve as resolve3 } from "path";
+import { resolve as resolve2 } from "path";
 import { execSync } from "child_process";
 
 // src/lint/checkers/structure/colocation.ts
@@ -753,15 +753,32 @@ var rulesRegistry = {
     }
   },
   // ==========================================================================
-  // Vault Schema Rules (VAULT-*) - Critical rules for AST parsing
+  // Contracts Colocation Rules (COL-CTR-*)
   // ==========================================================================
-  "VAULT-IMP-001": {
-    title: "External schema import",
+  "COL-CTR-001": {
+    title: "Response schema outside dto/ or common/",
     severity: "error",
-    category: "vault",
-    why: "External imports break static AST parsing. Duplicate schema with @sync-check.",
+    category: "contracts",
+    why: "Response schemas ({STATUS}.schema.ts) must be in ./dto/ or ../common/ for colocation.",
+    autoFixable: false
+  },
+  "COL-CTR-002": {
+    title: "Request schema outside dto/",
+    severity: "error",
+    category: "contracts",
+    why: "Request schemas (request.*.ts) must be in ./dto/ for colocation with contract.",
+    autoFixable: false
+  },
+  "COL-CTR-003": {
+    title: "Invalid schema file naming",
+    severity: "warning",
+    category: "contracts",
+    why: "Schema files should follow naming convention: {STATUS}.schema.ts or request.{type}.ts.",
     autoFixable: false
   },
+  // ==========================================================================
+  // Vault Schema Rules (VAULT-*) - Critical rules for AST parsing
+  // ==========================================================================
   "VAULT-AST-001": {
     title: "Forbidden z.lazy()",
     severity: "error",
@@ -823,6 +840,9 @@ var ContractsLintConfigSchema = z.object({
   }),
   disabledRules: z.array(z.string()).optional()
 });
+var VaultLintConfigSchema = z.object({
+  disabledRules: z.array(z.string()).optional()
+});
 var ContractsScaffoldConfigSchema = z.object({
   path: z.string(),
   // Absolute path to contracts lib
@@ -835,7 +855,8 @@ var ProjectConfigSchema = z.object({
 var HexaTsKitConfigSchema = z.object({
   project: ProjectConfigSchema,
   lint: z.object({
-    contracts: ContractsLintConfigSchema.optional()
+    contracts: ContractsLintConfigSchema.optional(),
+    vault: VaultLintConfigSchema.optional()
   }).optional(),
   scaffold: z.object({
     contracts: ContractsScaffoldConfigSchema.optional()
@@ -900,6 +921,9 @@ function resolveConfigPath(repoPath, relativePath) {
 function getDisabledRules(config) {
   return config.lint?.contracts?.disabledRules ?? [];
 }
+function getDisabledVaultRules(config) {
+  return config.lint?.vault?.disabledRules ?? [];
+}
 
 // src/lib/contracts/permissions-extractor.ts
 import { readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
@@ -2100,6 +2124,154 @@ function summarizeGeneration(result) {
   return lines.join("\n");
 }
 
+// src/lint/checkers/contracts/colocation.ts
+import fg8 from "fast-glob";
+import { readFile as readFile5 } from "fs/promises";
+import { basename as basename4, dirname as dirname3 } from "path";
+var RESPONSE_SCHEMA_PATTERN = /^\d{3}\.schema$/;
+var REQUEST_SCHEMA_PATTERN = /^request\./;
+var VALID_RESPONSE_PATHS = ["./dto/", "../common/", "./common/"];
+var VALID_REQUEST_PATHS = ["./dto/"];
+var contractsColocationChecker = {
+  name: "contracts-colocation",
+  rules: ["COL-CTR-001", "COL-CTR-002", "COL-CTR-003"],
+  async check(ctx) {
+    const results = [];
+    const configResult = loadConfig(ctx.cwd);
+    if (!configResult.success || configResult.config.project.type !== "contracts-lib") {
+      return [];
+    }
+    const contractFiles = await fg8("**/contracts/**/*.contract.ts", {
+      cwd: ctx.cwd,
+      ignore: ["**/node_modules/**", "**/dist/**"]
+    });
+    for (const contractFile of contractFiles) {
+      const fullPath = `${ctx.cwd}/${contractFile}`;
+      const content = await readFile5(fullPath, "utf-8");
+      const contractDir = dirname3(contractFile);
+      const imports = parseImports(content);
+      for (const imp of imports) {
+        const schemaResults = checkSchemaImport(contractFile, contractDir, imp);
+        results.push(...schemaResults);
+      }
+    }
+    const schemaFiles = await fg8("**/contracts/**/*.schema.ts", {
+      cwd: ctx.cwd,
+      ignore: ["**/node_modules/**", "**/dist/**", "**/dto/**", "**/common/**"]
+    });
+    for (const schemaFile of schemaFiles) {
+      const fileName = basename4(schemaFile, ".ts");
+      if (RESPONSE_SCHEMA_PATTERN.test(fileName)) {
+        results.push({
+          ruleId: "COL-CTR-001",
+          severity: "error",
+          message: `Response schema outside dto/ or common/: ${schemaFile}`,
+          file: schemaFile,
+          suggestion: `Move to ${dirname3(schemaFile)}/dto/${basename4(schemaFile)}`
+        });
+      } else if (REQUEST_SCHEMA_PATTERN.test(fileName)) {
+        results.push({
+          ruleId: "COL-CTR-002",
+          severity: "error",
+          message: `Request schema outside dto/: ${schemaFile}`,
+          file: schemaFile,
+          suggestion: `Move to ${dirname3(schemaFile)}/dto/${basename4(schemaFile)}`
+        });
+      }
+    }
+    const allSchemaFiles = await fg8("**/contracts/**/*.schema.ts", {
+      cwd: ctx.cwd,
+      ignore: ["**/node_modules/**", "**/dist/**"]
+    });
+    for (const schemaFile of allSchemaFiles) {
+      const fileName = basename4(schemaFile, ".schema.ts");
+      const isValidResponseName = RESPONSE_SCHEMA_PATTERN.test(
+        `${fileName}.schema`
+      );
+      const isValidRequestName = REQUEST_SCHEMA_PATTERN.test(fileName);
+      const isInCommon = schemaFile.includes("/common/");
+      if (!isValidResponseName && !isValidRequestName && !isInCommon) {
+        if (/response|res|status/i.test(fileName)) {
+          results.push({
+            ruleId: "COL-CTR-003",
+            severity: "warning",
+            message: `Schema file may be incorrectly named: ${basename4(schemaFile)}`,
+            file: schemaFile,
+            suggestion: `Use {STATUS_CODE}.schema.ts for response schemas (e.g., 200.schema.ts)`
+          });
+        }
+      }
+    }
+    return results;
+  }
+};
+function parseImports(content) {
+  const imports = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const currentLine = lines[i];
+    if (!currentLine) continue;
+    const importMatch = currentLine.match(
+      /import\s+(?:{([^}]+)}|(\w+))\s+from\s+['"]([^'"]+)['"]/
+    );
+    if (importMatch) {
+      const namedImports = importMatch[1];
+      const defaultImport = importMatch[2];
+      const importPath = importMatch[3];
+      if (!importPath) continue;
+      if (namedImports) {
+        const names = namedImports.split(",").map((n) => n.trim().split(" as ")[0]?.trim()).filter((n) => !!n);
+        for (const name of names) {
+          imports.push({ importPath, importedName: name, line: i + 1 });
+        }
+      } else if (defaultImport) {
+        imports.push({ importPath, importedName: defaultImport, line: i + 1 });
+      }
+    }
+  }
+  return imports;
+}
+function checkSchemaImport(contractFile, _contractDir, imp) {
+  const results = [];
+  const { importPath, importedName, line } = imp;
+  if (!importPath.startsWith(".")) {
+    return [];
+  }
+  const isResponseSchema = /Schema$/.test(importedName) && (/^\d{3}/.test(importedName) || /Response\d{3}/.test(importedName) || /^Response\d{3}Schema/.test(importedName));
+  const isRequestSchema = /Schema$/.test(importedName) && /Query|Request|Body/i.test(importedName);
+  if (isResponseSchema) {
+    const isValidPath = VALID_RESPONSE_PATHS.some(
+      (valid) => importPath.startsWith(valid)
+    );
+    if (!isValidPath) {
+      results.push({
+        ruleId: "COL-CTR-001",
+        severity: "error",
+        message: `Response schema import from invalid path: ${importPath}`,
+        file: contractFile,
+        line,
+        suggestion: `Import from ./dto/ or ../common/ instead`
+      });
+    }
+  }
+  if (isRequestSchema) {
+    const isValidPath = VALID_REQUEST_PATHS.some(
+      (valid) => importPath.startsWith(valid)
+    );
+    if (!isValidPath) {
+      results.push({
+        ruleId: "COL-CTR-002",
+        severity: "error",
+        message: `Request schema import from invalid path: ${importPath}`,
+        file: contractFile,
+        line,
+        suggestion: `Import from ./dto/ instead`
+      });
+    }
+  }
+  return results;
+}
+
 // src/lint/checkers/contracts/index.ts
 var contractsChecker = {
   name: "contracts",
@@ -2179,13 +2351,15 @@ var contractsChecker = {
         suggestion: issue.suggestion
       });
     }
+    const colocationResults = await contractsColocationChecker.check(ctx);
+    results.push(...colocationResults);
     return results;
   }
 };
 
 // src/lint/checkers/vault/index.ts
 import { existsSync as existsSync5, readdirSync } from "fs";
-import { join as join3, dirname as dirname3, resolve as resolve2 } from "path";
+import { join as join3, dirname as dirname4 } from "path";
 import { Project, SyntaxKind } from "ts-morph";
 var VAULT_PATHS = [
   "src/common/config/vault",
@@ -2206,7 +2380,7 @@ function findVaultLocation(cwd) {
   for (const file of LEGACY_FILES) {
     const fullPath = join3(cwd, file);
     if (existsSync5(fullPath)) {
-      return { basePath: dirname3(fullPath), files: [fullPath] };
+      return { basePath: dirname4(fullPath), files: [fullPath] };
     }
   }
   return null;
@@ -2223,49 +2397,6 @@ function isInsideZodObject(node) {
   }
   return false;
 }
-function checkExternalImports(sourceFile, vault) {
-  const results = [];
-  const filePath = sourceFile.getFilePath();
-  sourceFile.getImportDeclarations().forEach((imp) => {
-    const moduleSpec = imp.getModuleSpecifierValue();
-    const namedImports = imp.getNamedImports();
-    if (moduleSpec === "zod") return;
-    if (moduleSpec.startsWith(".")) {
-      const resolvedPath = resolve2(dirname3(filePath), moduleSpec);
-      if (!resolvedPath.startsWith(vault.basePath)) {
-        const hasSchemaImport = namedImports.some(
-          (ni) => ni.getName().toLowerCase().includes("schema")
-        );
-        if (hasSchemaImport) {
-          results.push({
-            ruleId: "VAULT-IMP-001",
-            severity: getRuleSeverity("VAULT-IMP-001"),
-            message: `External schema import from "${moduleSpec}"`,
-            file: filePath,
-            line: imp.getStartLineNumber(),
-            suggestion: "Move schema to vault/ or duplicate with @sync-check"
-          });
-        }
-      }
-    }
-    if (!moduleSpec.startsWith(".")) {
-      const hasSchemaImport = namedImports.some(
-        (ni) => ni.getName().toLowerCase().includes("schema")
-      );
-      if (hasSchemaImport) {
-        results.push({
-          ruleId: "VAULT-IMP-001",
-          severity: getRuleSeverity("VAULT-IMP-001"),
-          message: `External schema import from package "${moduleSpec}"`,
-          file: filePath,
-          line: imp.getStartLineNumber(),
-          suggestion: "Define schema locally in vault/ instead"
-        });
-      }
-    }
-  });
-  return results;
-}
 function checkAstPatterns(sourceFile) {
   const results = [];
   const filePath = sourceFile.getFilePath();
@@ -2361,6 +2492,8 @@ var vaultChecker = {
     if (!vault) {
       return results;
     }
+    const configResult = loadConfig(ctx.cwd);
+    const disabledRules = configResult.success ? getDisabledVaultRules(configResult.config) : [];
     const project = new Project({
       skipAddingFilesFromTsConfig: true,
       skipFileDependencyResolution: true
@@ -2375,8 +2508,12 @@ var vaultChecker = {
       }
     }
     for (const sourceFile of sourceFiles) {
-      results.push(...checkExternalImports(sourceFile, vault));
-      results.push(...checkAstPatterns(sourceFile));
+      const astResults = checkAstPatterns(sourceFile);
+      for (const result of astResults) {
+        if (!disabledRules.includes(result.ruleId)) {
+          results.push(result);
+        }
+      }
     }
     return results;
   }
@@ -2503,7 +2640,7 @@ function getChangedFiles(cwd) {
   }
 }
 async function lintCore(options) {
-  const cwd = resolve3(options.path || ".");
+  const cwd = resolve2(options.path || ".");
   if (options.rules) {
     const standaloneKey = options.rules.toUpperCase();
     if (standaloneCheckers[standaloneKey]) {
@@ -2583,8 +2720,8 @@ async function lintCommand(path = ".", options) {
   const startTime = performance.now();
   const targetPath = options.cwd || path;
   if (options.debug) {
-    console.log(`Linting: ${resolve3(targetPath)}`);
-    const projectConfig = detectProjectType(resolve3(targetPath));
+    console.log(`Linting: ${resolve2(targetPath)}`);
+    const projectConfig = detectProjectType(resolve2(targetPath));
     console.log(`Project type: ${projectConfig.type ?? "not configured"}`);
     console.log(
       `Checkers: ${projectConfig.checkers.map((c) => c.name).join(", ") || "none"}`
@@ -2614,10 +2751,10 @@ Completed in ${elapsed}ms`);
 }
 
 // src/commands/analyze.ts
-import { basename as basename4 } from "path";
+import { basename as basename5 } from "path";
 import { execSync as execSync2 } from "child_process";
 import { readFileSync as readFileSync4, existsSync as existsSync6 } from "fs";
-import fg8 from "fast-glob";
+import fg9 from "fast-glob";
 import matter from "gray-matter";
 import { minimatch } from "minimatch";
 function expandPath(p) {
@@ -2646,7 +2783,7 @@ function loadKnowledgeMappings(knowledgePath) {
   if (!existsSync6(expandedPath)) {
     return [];
   }
-  const knowledgeFiles = fg8.sync("**/*.knowledge.md", {
+  const knowledgeFiles = fg9.sync("**/*.knowledge.md", {
     cwd: expandedPath,
     absolute: true
   });
@@ -2657,7 +2794,7 @@ function loadKnowledgeMappings(knowledgePath) {
       const { data } = matter(content);
       if (data.match) {
         mappings.push({
-          name: data.name || basename4(file, ".knowledge.md"),
+          name: data.name || basename5(file, ".knowledge.md"),
           path: file,
           match: data.match,
           description: data.description
@@ -2670,7 +2807,7 @@ function loadKnowledgeMappings(knowledgePath) {
 }
 function matchFileToKnowledges(file, mappings) {
   const results = [];
-  const fileName = basename4(file);
+  const fileName = basename5(file);
   for (const mapping of mappings) {
     if (minimatch(fileName, mapping.match) || minimatch(file, mapping.match)) {
       results.push({
@@ -2732,7 +2869,7 @@ async function analyzeCommand(files = [], options) {
 }
 
 // src/commands/scaffold.ts
-import { resolve as resolve4, dirname as dirname4, basename as basename5, join as join4 } from "path";
+import { resolve as resolve3, dirname as dirname5, basename as basename6, 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("");
@@ -2742,7 +2879,7 @@ function toCamelCase(str) {
   return pascal.charAt(0).toLowerCase() + pascal.slice(1);
 }
 function generateVueFeature(featurePath) {
-  const featureName = basename5(featurePath);
+  const featureName = basename6(featurePath);
   const pascalName = toPascalCase(featureName);
   const camelName = toCamelCase(featureName);
   return [
@@ -2859,7 +2996,7 @@ describe('${pascalName}Rules', () => {
   ];
 }
 function generateNestJSFeature(featurePath) {
-  const featureName = basename5(featurePath);
+  const featureName = basename6(featurePath);
   const pascalName = toPascalCase(featureName);
   const camelName = toCamelCase(featureName);
   return [
@@ -2950,7 +3087,7 @@ describe('${pascalName}Controller', () => {
   ];
 }
 function generatePlaywrightFeature(featurePath) {
-  const featureName = basename5(featurePath);
+  const featureName = basename6(featurePath);
   const pascalName = toPascalCase(featureName);
   const camelName = toCamelCase(featureName);
   return [
@@ -3053,8 +3190,8 @@ async function scaffoldCore(options) {
       };
     }
     const contractsLib = options.contractsLib ?? "@adeo/ahs-operator-execution-contracts";
-    const absolutePath2 = resolve4(options.path);
-    const absoluteContractPath = resolve4(options.contractPath);
+    const absolutePath2 = resolve3(options.path);
+    const absoluteContractPath = resolve3(options.contractPath);
     const bffResult = generateNestJsBffFeature(
       absolutePath2,
       absoluteContractPath,
@@ -3085,7 +3222,7 @@ async function scaffoldCore(options) {
     const errors2 = [];
     for (const file of bffResult.files) {
       try {
-        const dir = dirname4(file.path);
+        const dir = dirname5(file.path);
         if (!existsSync7(dir)) {
           mkdirSync(dir, { recursive: true });
         }
@@ -3116,7 +3253,7 @@ async function scaffoldCore(options) {
       availableTypes: [...Object.keys(generators), "nestjs-bff-feature"]
     };
   }
-  const absolutePath = resolve4(options.path);
+  const absolutePath = resolve3(options.path);
   const files = generator(absolutePath);
   if (options.dryRun) {
     return {
@@ -3136,7 +3273,7 @@ async function scaffoldCore(options) {
   const errors = [];
   for (const file of files) {
     try {
-      const dir = dirname4(file.path);
+      const dir = dirname5(file.path);
       if (!existsSync7(dir)) {
         mkdirSync(dir, { recursive: true });
       }

package/dist/cli.js

@@ -3,7 +3,7 @@ import {
   analyzeCommand,
   lintCommand,
   scaffoldCommand
-} from "./chunk-UNAQG5HI.js";
+} from "./chunk-OI2LN5K5.js";
 
 // src/cli.ts
 import { program } from "commander";

package/dist/mcp-server.js

@@ -3,7 +3,7 @@ import {
   analyzeCore,
   lintCore,
   scaffoldCore
-} from "./chunk-UNAQG5HI.js";
+} from "./chunk-OI2LN5K5.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.7.2",
+  "version": "1.9.0",
   "description": "TypeScript dev kit for Claude Code agents: architecture linting, scaffolding, knowledge analysis",
   "type": "module",
   "bin": {