@hyphaene/hexa-ts-kit 1.4.2 → 1.5.0

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

@@ -1,5 +1,5 @@
 // src/commands/lint.ts
-import { resolve as resolve2 } from "path";
+import { resolve as resolve3 } from "path";
 import { execSync } from "child_process";
 
 // src/lint/checkers/structure/colocation.ts
@@ -751,9 +751,57 @@ var rulesRegistry = {
       invalid: "contracts/CTR-007-invalid.ts",
       valid: "contracts/CTR-007-valid.ts"
     }
+  },
+  // ==========================================================================
+  // Vault Schema Rules (VAULT-*) - Critical rules for AST parsing
+  // ==========================================================================
+  "VAULT-IMP-001": {
+    title: "External schema import",
+    severity: "error",
+    category: "vault",
+    why: "External imports break static AST parsing. Duplicate schema with @sync-check.",
+    autoFixable: false
+  },
+  "VAULT-AST-001": {
+    title: "Forbidden z.lazy()",
+    severity: "error",
+    category: "vault",
+    why: "z.lazy() creates recursive schemas that cannot be parsed statically.",
+    autoFixable: false
+  },
+  "VAULT-AST-002": {
+    title: "Forbidden conditional spread",
+    severity: "error",
+    category: "vault",
+    why: "Conditional spreads make schema structure non-deterministic.",
+    autoFixable: false
+  },
+  "VAULT-AST-003": {
+    title: "Forbidden function generator",
+    severity: "error",
+    category: "vault",
+    why: "Schemas returned by functions cannot be parsed statically.",
+    autoFixable: false
+  },
+  "VAULT-AST-004": {
+    title: "Enum with non-literal values",
+    severity: "error",
+    category: "vault",
+    why: "z.enum() must contain only string literals, not variables.",
+    autoFixable: false
+  },
+  "VAULT-AST-006": {
+    title: "z.object() with non-literal argument",
+    severity: "error",
+    category: "vault",
+    why: "z.object() must receive an object literal, not a variable.",
+    autoFixable: false
   }
 };
 var allRuleIds = Object.keys(rulesRegistry);
+function getRuleSeverity(ruleId) {
+  return rulesRegistry[ruleId].severity;
+}
 function getRulesByCategory(category) {
   return allRuleIds.filter((id) => rulesRegistry[id].category === category);
 }
@@ -2135,6 +2183,205 @@ var contractsChecker = {
   }
 };
 
+// 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 { Project, SyntaxKind } from "ts-morph";
+var VAULT_PATHS = [
+  "src/common/config/vault",
+  "server/vault",
+  "src/config/vault"
+];
+var LEGACY_FILES = ["server/vault.ts", "src/vault.ts"];
+function findVaultLocation(cwd) {
+  for (const path of VAULT_PATHS) {
+    const fullPath = join3(cwd, path);
+    if (existsSync5(fullPath)) {
+      const files = readdirSync(fullPath).filter((f) => f.endsWith(".ts")).map((f) => join3(fullPath, f));
+      if (files.length > 0) {
+        return { basePath: fullPath, files };
+      }
+    }
+  }
+  for (const file of LEGACY_FILES) {
+    const fullPath = join3(cwd, file);
+    if (existsSync5(fullPath)) {
+      return { basePath: dirname3(fullPath), files: [fullPath] };
+    }
+  }
+  return null;
+}
+function isInsideZodObject(node) {
+  if (!node) return false;
+  let current = node;
+  while (current) {
+    if (current.getKind() === SyntaxKind.CallExpression) {
+      const text = current.getText();
+      if (text.startsWith("z.object(")) return true;
+    }
+    current = current.getParent();
+  }
+  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();
+  sourceFile.forEachDescendant((node) => {
+    if (node.getKind() === SyntaxKind.CallExpression) {
+      const text = node.getText();
+      if (text.startsWith("z.lazy(")) {
+        results.push({
+          ruleId: "VAULT-AST-001",
+          severity: getRuleSeverity("VAULT-AST-001"),
+          message: "z.lazy() cannot be parsed statically",
+          file: filePath,
+          line: node.getStartLineNumber()
+        });
+      }
+      if (text.startsWith("z.enum(")) {
+        const callExpr = node.asKind(SyntaxKind.CallExpression);
+        const args = callExpr?.getArguments();
+        if (args && args.length > 0) {
+          const firstArg = args[0];
+          if (firstArg?.getKind() === SyntaxKind.Identifier) {
+            results.push({
+              ruleId: "VAULT-AST-004",
+              severity: getRuleSeverity("VAULT-AST-004"),
+              message: "z.enum() must receive literal array, not variable",
+              file: filePath,
+              line: node.getStartLineNumber(),
+              suggestion: "Use z.enum(['value1', 'value2']) with literals"
+            });
+          }
+        }
+      }
+      if (text.startsWith("z.object(")) {
+        const callExpr = node.asKind(SyntaxKind.CallExpression);
+        const args = callExpr?.getArguments();
+        if (args && args.length > 0) {
+          const firstArg = args[0];
+          if (firstArg?.getKind() === SyntaxKind.Identifier) {
+            results.push({
+              ruleId: "VAULT-AST-006",
+              severity: getRuleSeverity("VAULT-AST-006"),
+              message: "z.object() must receive object literal, not variable",
+              file: filePath,
+              line: node.getStartLineNumber()
+            });
+          }
+        }
+      }
+    }
+    if (node.getKind() === SyntaxKind.SpreadAssignment) {
+      if (isInsideZodObject(node)) {
+        const spreadExpr = node.asKind(SyntaxKind.SpreadAssignment);
+        const expr = spreadExpr?.getExpression();
+        if (expr?.getKind() === SyntaxKind.ConditionalExpression || expr?.getKind() === SyntaxKind.Identifier) {
+          results.push({
+            ruleId: "VAULT-AST-002",
+            severity: getRuleSeverity("VAULT-AST-002"),
+            message: "Conditional/dynamic spreads not parsable in z.object()",
+            file: filePath,
+            line: node.getStartLineNumber()
+          });
+        }
+      }
+    }
+    if (node.getKind() === SyntaxKind.FunctionDeclaration || node.getKind() === SyntaxKind.ArrowFunction) {
+      const funcNode = node.asKind(SyntaxKind.FunctionDeclaration) || node.asKind(SyntaxKind.ArrowFunction);
+      if (funcNode) {
+        const body = funcNode.getBody();
+        if (body) {
+          const bodyText = body.getText();
+          if (bodyText.includes("z.object(") || bodyText.includes("return z.")) {
+            results.push({
+              ruleId: "VAULT-AST-003",
+              severity: getRuleSeverity("VAULT-AST-003"),
+              message: "Functions returning Zod schemas are not parsable",
+              file: filePath,
+              line: node.getStartLineNumber(),
+              suggestion: "Define schemas as const, not functions"
+            });
+          }
+        }
+      }
+    }
+  });
+  return results;
+}
+var vaultChecker = {
+  name: "vault",
+  rules: getRulesByCategory("vault"),
+  async check(ctx) {
+    const results = [];
+    const vault = findVaultLocation(ctx.cwd);
+    if (!vault) {
+      return results;
+    }
+    const project = new Project({
+      skipAddingFilesFromTsConfig: true,
+      skipFileDependencyResolution: true
+    });
+    const sourceFiles = [];
+    for (const filePath of vault.files) {
+      try {
+        const sf = project.addSourceFileAtPath(filePath);
+        sourceFiles.push(sf);
+      } catch {
+        continue;
+      }
+    }
+    for (const sourceFile of sourceFiles) {
+      results.push(...checkExternalImports(sourceFile, vault));
+      results.push(...checkAstPatterns(sourceFile));
+    }
+    return results;
+  }
+};
+
 // src/lint/reporters/console.ts
 import pc from "picocolors";
 var severityColors = {
@@ -2195,6 +2442,9 @@ function formatSummary(results) {
 
 // src/commands/lint.ts
 var contractsLibCheckers = [contractsChecker];
+var standaloneCheckers = {
+  VAULT: vaultChecker
+};
 function detectProjectType(cwd) {
   const configResult = loadConfig(cwd);
   if (!configResult.success) {
@@ -2253,7 +2503,23 @@ function getChangedFiles(cwd) {
   }
 }
 async function lintCore(options) {
-  const cwd = resolve2(options.path || ".");
+  const cwd = resolve3(options.path || ".");
+  if (options.rules) {
+    const standaloneKey = options.rules.toUpperCase();
+    if (standaloneCheckers[standaloneKey]) {
+      const checker = standaloneCheckers[standaloneKey];
+      const results = await checker.check({ cwd, files: [] });
+      const filteredResults2 = options.quiet ? results.filter((r) => r.severity === "error") : results;
+      const summary2 = formatSummary(results);
+      return {
+        success: summary2.errors === 0,
+        command: "lint",
+        projectType: null,
+        results: filteredResults2,
+        summary: summary2
+      };
+    }
+  }
   const projectConfig = detectProjectType(cwd);
   if (!projectConfig.supported) {
     return {
@@ -2317,8 +2583,8 @@ async function lintCommand(path = ".", options) {
   const startTime = performance.now();
   const targetPath = options.cwd || path;
   if (options.debug) {
-    console.log(`Linting: ${resolve2(targetPath)}`);
-    const projectConfig = detectProjectType(resolve2(targetPath));
+    console.log(`Linting: ${resolve3(targetPath)}`);
+    const projectConfig = detectProjectType(resolve3(targetPath));
     console.log(`Project type: ${projectConfig.type ?? "not configured"}`);
     console.log(
       `Checkers: ${projectConfig.checkers.map((c) => c.name).join(", ") || "none"}`
@@ -2350,7 +2616,7 @@ Completed in ${elapsed}ms`);
 // src/commands/analyze.ts
 import { basename as basename4 } from "path";
 import { execSync as execSync2 } from "child_process";
-import { readFileSync as readFileSync4, existsSync as existsSync5 } from "fs";
+import { readFileSync as readFileSync4, existsSync as existsSync6 } from "fs";
 import fg8 from "fast-glob";
 import matter from "gray-matter";
 import { minimatch } from "minimatch";
@@ -2377,7 +2643,7 @@ function getChangedFiles2(cwd) {
 }
 function loadKnowledgeMappings(knowledgePath) {
   const expandedPath = expandPath(knowledgePath);
-  if (!existsSync5(expandedPath)) {
+  if (!existsSync6(expandedPath)) {
     return [];
   }
   const knowledgeFiles = fg8.sync("**/*.knowledge.md", {
@@ -2466,8 +2732,8 @@ async function analyzeCommand(files = [], options) {
 }
 
 // src/commands/scaffold.ts
-import { resolve as resolve3, dirname as dirname3, basename as basename5, join as join3 } from "path";
-import { mkdirSync, writeFileSync, existsSync as existsSync6 } from "fs";
+import { resolve as resolve4, dirname as dirname4, basename as basename5, 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("");
 }
@@ -2765,7 +3031,7 @@ function generateNestJsBffFeature(outputPath, contractPath, endpointName, contra
     featureName: endpointName
   });
   const files = result.files.map((f) => ({
-    path: join3(outputPath, f.path),
+    path: join4(outputPath, f.path),
     content: f.content,
     knowledge: f.isComplete ? void 0 : "nestjs-bff-skeleton"
   }));
@@ -2787,8 +3053,8 @@ async function scaffoldCore(options) {
       };
     }
     const contractsLib = options.contractsLib ?? "@adeo/ahs-operator-execution-contracts";
-    const absolutePath2 = resolve3(options.path);
-    const absoluteContractPath = resolve3(options.contractPath);
+    const absolutePath2 = resolve4(options.path);
+    const absoluteContractPath = resolve4(options.contractPath);
     const bffResult = generateNestJsBffFeature(
       absolutePath2,
       absoluteContractPath,
@@ -2819,8 +3085,8 @@ async function scaffoldCore(options) {
     const errors2 = [];
     for (const file of bffResult.files) {
       try {
-        const dir = dirname3(file.path);
-        if (!existsSync6(dir)) {
+        const dir = dirname4(file.path);
+        if (!existsSync7(dir)) {
           mkdirSync(dir, { recursive: true });
         }
         writeFileSync(file.path, file.content, "utf-8");
@@ -2850,7 +3116,7 @@ async function scaffoldCore(options) {
       availableTypes: [...Object.keys(generators), "nestjs-bff-feature"]
     };
   }
-  const absolutePath = resolve3(options.path);
+  const absolutePath = resolve4(options.path);
   const files = generator(absolutePath);
   if (options.dryRun) {
     return {
@@ -2870,8 +3136,8 @@ async function scaffoldCore(options) {
   const errors = [];
   for (const file of files) {
     try {
-      const dir = dirname3(file.path);
-      if (!existsSync6(dir)) {
+      const dir = dirname4(file.path);
+      if (!existsSync7(dir)) {
         mkdirSync(dir, { recursive: true });
       }
       writeFileSync(file.path, file.content, "utf-8");

package/dist/cli.js

@@ -3,7 +3,7 @@ import {
   analyzeCommand,
   lintCommand,
   scaffoldCommand
-} from "./chunk-FV47ZLIM.js";
+} from "./chunk-UNAQG5HI.js";
 
 // src/cli.ts
 import { program } from "commander";
@@ -257,322 +257,6 @@ function padEnd(str, length) {
   return str.length >= length ? str.slice(0, length - 1) + " " : str + " ".repeat(length - str.length);
 }
 
-// src/commands/migrate-contracts.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { resolve as resolve2 } from "path";
-
-// src/lib/contracts/codemod/migrate-contracts.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import fg2 from "fast-glob";
-async function migrateContracts(contractsPath, migrationMap, options = {}) {
-  const results = [];
-  const contractFiles = await fg2("**/*.contract.ts", {
-    cwd: contractsPath,
-    ignore: ["**/node_modules/**", "**/dist/**"],
-    absolute: true
-  });
-  for (const filePath of contractFiles) {
-    const fileResults = migrateContractFile(filePath, migrationMap, options);
-    results.push(...fileResults);
-  }
-  return results;
-}
-function migrateContractFile(filePath, migrationMap, options) {
-  const results = [];
-  let content = readFileSync2(filePath, "utf-8");
-  let modified = false;
-  const changes = [];
-  const hasContractMetadataImport = content.includes("contractMetadata");
-  const hasPermissionImport = content.includes("from '../../../common/permissions'") || content.includes("from '../../common/permissions'") || content.includes('from "../../../common/permissions"') || content.includes('from "../../common/permissions"');
-  const endpointPattern = /(\w+):\s*\{[^}]*?method:\s*['"](\w+)['"][^}]*?metadata:\s*(\{[^}]+\}|\w+\([^)]+\))/gs;
-  const simpleEndpointPattern = /(\w+):\s*\{[^}]*?method:\s*['"](\w+)['"][^}]*?\}/gs;
-  for (const [endpointName, mapping] of Object.entries(migrationMap)) {
-    const endpointRegex = new RegExp(`(${endpointName}):\\s*\\{`, "g");
-    if (!endpointRegex.test(content)) {
-      continue;
-    }
-    const metadataInfo = analyzeEndpointMetadata(content, endpointName);
-    if (!metadataInfo.found) {
-      results.push({
-        file: filePath,
-        endpoint: endpointName,
-        status: "skipped",
-        message: "Endpoint structure not found or complex"
-      });
-      continue;
-    }
-    if (metadataInfo.hasNewFormat) {
-      results.push({
-        file: filePath,
-        endpoint: endpointName,
-        status: "skipped",
-        message: "Already using new metadata format"
-      });
-      continue;
-    }
-    const newMetadata = buildNewMetadata(mapping, metadataInfo);
-    if (metadataInfo.hasMetadata) {
-      content = replaceMetadata(
-        content,
-        endpointName,
-        metadataInfo,
-        newMetadata
-      );
-      changes.push(`Replaced metadata for ${endpointName}`);
-    } else {
-      content = addMetadata(content, endpointName, newMetadata);
-      changes.push(`Added metadata for ${endpointName}`);
-    }
-    modified = true;
-    results.push({
-      file: filePath,
-      endpoint: endpointName,
-      status: "migrated",
-      message: `Migrated to new format: permission=${mapping.requiredPermission}, apiServices=[${mapping.apiServices.join(", ")}]`,
-      changes
-    });
-  }
-  if (modified) {
-    if (!hasContractMetadataImport) {
-      content = addContractMetadataImport(content);
-      changes.push("Added contractMetadata import");
-    }
-    if (!hasPermissionImport) {
-      content = addPermissionImport(content);
-      changes.push("Added Permission import");
-    }
-    if (!options.dryRun) {
-      writeFileSync2(filePath, content, "utf-8");
-    }
-  }
-  return results;
-}
-function analyzeEndpointMetadata(content, endpointName) {
-  const info = {
-    found: false,
-    hasMetadata: false,
-    hasNewFormat: false,
-    hasLegacyOpenapi: false,
-    hasRequiresAuth: false,
-    existingTags: [],
-    startIndex: -1,
-    endIndex: -1,
-    fullMatch: ""
-  };
-  const endpointStart = content.indexOf(`${endpointName}: {`);
-  if (endpointStart === -1) {
-    const quotedStart = content.indexOf(`'${endpointName}': {`) !== -1 ? content.indexOf(`'${endpointName}': {`) : content.indexOf(`"${endpointName}": {`);
-    if (quotedStart === -1) return info;
-  }
-  info.found = true;
-  if (content.includes(`metadata: contractMetadata(`)) {
-    const newFormatRegex = new RegExp(
-      `${endpointName}:[\\s\\S]*?metadata:\\s*contractMetadata\\(`,
-      "m"
-    );
-    if (newFormatRegex.test(content)) {
-      info.hasNewFormat = true;
-      info.hasMetadata = true;
-      return info;
-    }
-  }
-  const legacyPattern = new RegExp(
-    `(${endpointName}:[\\s\\S]*?metadata:\\s*\\{[\\s\\S]*?openapi:\\s*\\{[\\s\\S]*?tags:\\s*\\[([^\\]]+)\\])`,
-    "m"
-  );
-  const legacyMatch = content.match(legacyPattern);
-  if (legacyMatch?.[2]) {
-    info.hasMetadata = true;
-    info.hasLegacyOpenapi = true;
-    const tagsStr = legacyMatch[2];
-    info.existingTags = tagsStr.split(",").map((t) => t.trim().replace(/['"]/g, "")).filter(Boolean);
-  }
-  const requiresAuthPattern = new RegExp(
-    `${endpointName}:[\\s\\S]*?requiresAuth:\\s*(true|false)`,
-    "m"
-  );
-  if (requiresAuthPattern.test(content)) {
-    info.hasRequiresAuth = true;
-    info.hasMetadata = true;
-  }
-  const simpleMetadataPattern = new RegExp(
-    `${endpointName}:[\\s\\S]*?metadata:\\s*\\{`,
-    "m"
-  );
-  if (simpleMetadataPattern.test(content)) {
-    info.hasMetadata = true;
-  }
-  return info;
-}
-function buildNewMetadata(mapping, metadataInfo) {
-  const tags = metadataInfo.existingTags.length > 0 ? metadataInfo.existingTags : ["TODO: Add tags"];
-  const tagsArray = tags.map((t) => `'${t}'`).join(", ");
-  let metadata = `metadata: contractMetadata({
-      openApiTags: [${tagsArray}],
-      requiredPermission: '${mapping.requiredPermission}',`;
-  if (mapping.apiServices.length > 0) {
-    const servicesArray = mapping.apiServices.map((s) => `'${s}'`).join(", ");
-    metadata += `
-      bff: {
-        apiServices: [${servicesArray}],
-      },`;
-  }
-  metadata += `
-    }),`;
-  return metadata;
-}
-function replaceMetadata(content, endpointName, metadataInfo, newMetadata) {
-  const metadataPattern = new RegExp(
-    `(${endpointName}:[\\s\\S]*?)(metadata:\\s*\\{[\\s\\S]*?\\}(?:\\s*as\\s*const)?,?)`,
-    "m"
-  );
-  return content.replace(metadataPattern, `$1${newMetadata}`);
-}
-function addMetadata(content, endpointName, newMetadata) {
-  const strictPattern = new RegExp(
-    `(${endpointName}:[\\s\\S]*?)(strictStatusCodes:\\s*true,?)`,
-    "m"
-  );
-  if (strictPattern.test(content)) {
-    return content.replace(strictPattern, `$1${newMetadata}
-    $2`);
-  }
-  const endpointStart = content.indexOf(`${endpointName}: {`);
-  if (endpointStart === -1) {
-    return content;
-  }
-  const blockStart = content.indexOf("{", endpointStart);
-  if (blockStart === -1) return content;
-  let braceCount = 1;
-  let pos = blockStart + 1;
-  while (pos < content.length && braceCount > 0) {
-    const char = content[pos];
-    if (char === "{") braceCount++;
-    else if (char === "}") braceCount--;
-    pos++;
-  }
-  if (braceCount !== 0) return content;
-  const closingBracePos = pos - 1;
-  const responsesMatch = content.slice(endpointStart, closingBracePos).match(/\n(\s+)responses:/);
-  const indent = responsesMatch?.[1] ?? "    ";
-  const before = content.slice(0, closingBracePos);
-  const after = content.slice(closingBracePos);
-  const lastNonWhitespace = before.trimEnd().slice(-1);
-  const needsComma = lastNonWhitespace !== ",";
-  return before.trimEnd() + (needsComma ? "," : "") + `
-
-${indent}${newMetadata}
-${indent.slice(2)}` + after;
-}
-function addContractMetadataImport(content) {
-  const metadataImportPattern = /import\s*\{[^}]*\}\s*from\s*['"]\.\.\/.*common\/metadata\/contract-metadata['"]/;
-  if (metadataImportPattern.test(content)) {
-    return content.replace(
-      /(import\s*\{)([^}]*)(}\s*from\s*['"]\.\.\/.*common\/metadata\/contract-metadata['"])/,
-      "$1$2, contractMetadata$3"
-    );
-  }
-  const lastImportMatch = content.match(/import[^;]+;/g);
-  if (lastImportMatch && lastImportMatch.length > 0) {
-    const lastImport = lastImportMatch[lastImportMatch.length - 1];
-    const insertPos = content.indexOf(lastImport) + lastImport.length;
-    const depth = (content.match(/from ['"](\.\.\/)*/)?.[0]?.match(/\.\.\//g) ?? []).length;
-    const relativePath = "../".repeat(Math.max(3, depth)) + "common/metadata/contract-metadata";
-    return content.slice(0, insertPos) + `
-import { contractMetadata } from '${relativePath}';` + content.slice(insertPos);
-  }
-  return content;
-}
-function addPermissionImport(content) {
-  const permissionImportPattern = /import\s*\{[^}]*Permission[^}]*\}\s*from\s*['"].*permissions['"]/;
-  if (permissionImportPattern.test(content)) {
-    return content;
-  }
-  const lastImportMatch = content.match(/import[^;]+;/g);
-  if (lastImportMatch && lastImportMatch.length > 0) {
-    const lastImport = lastImportMatch[lastImportMatch.length - 1];
-    const insertPos = content.indexOf(lastImport) + lastImport.length;
-    const depth = (content.match(/from ['"](\.\.\/)*/)?.[0]?.match(/\.\.\//g) ?? []).length;
-    const relativePath = "../".repeat(Math.max(3, depth)) + "common/permissions";
-    return content.slice(0, insertPos) + `
-import { Permission } from '${relativePath}';` + content.slice(insertPos);
-  }
-  return content;
-}
-
-// src/commands/migrate-contracts.ts
-async function migrateContractsCommand(contractsPath, options) {
-  const absoluteContractsPath = resolve2(contractsPath);
-  const absoluteMapPath = resolve2(options.migrationMap);
-  console.log(`Migrating contracts at: ${absoluteContractsPath}`);
-  console.log(`Using migration map: ${absoluteMapPath}`);
-  if (options.dryRun) {
-    console.log("DRY RUN - no files will be modified\n");
-  } else {
-    console.log("");
-  }
-  let mapData;
-  try {
-    const mapContent = readFileSync3(absoluteMapPath, "utf-8");
-    mapData = JSON.parse(mapContent);
-  } catch (err) {
-    console.error(
-      `Failed to load migration map: ${err instanceof Error ? err.message : String(err)}`
-    );
-    process.exit(1);
-  }
-  if (!mapData.migrationMap) {
-    console.error("Migration map file must contain a 'migrationMap' property");
-    process.exit(1);
-  }
-  const results = await migrateContracts(
-    absoluteContractsPath,
-    mapData.migrationMap,
-    { dryRun: options.dryRun }
-  );
-  const migrated = results.filter((r) => r.status === "migrated");
-  const skipped = results.filter((r) => r.status === "skipped");
-  const errors = results.filter((r) => r.status === "error");
-  if (migrated.length > 0) {
-    console.log(`\u2705 Migrated (${migrated.length}):`);
-    for (const r of migrated) {
-      const shortPath = r.file.split("/").slice(-3).join("/");
-      console.log(`   ${r.endpoint} in ${shortPath}`);
-      console.log(`      \u2192 ${r.message}`);
-    }
-    console.log("");
-  }
-  if (skipped.length > 0) {
-    console.log(`\u23ED\uFE0F  Skipped (${skipped.length}):`);
-    const byReason = /* @__PURE__ */ new Map();
-    for (const r of skipped) {
-      const existing = byReason.get(r.message) ?? [];
-      existing.push(r.endpoint);
-      byReason.set(r.message, existing);
-    }
-    for (const [reason, endpoints] of byReason) {
-      console.log(
-        `   ${reason}: ${endpoints.slice(0, 5).join(", ")}${endpoints.length > 5 ? ` (+${endpoints.length - 5} more)` : ""}`
-      );
-    }
-    console.log("");
-  }
-  if (errors.length > 0) {
-    console.log(`\u274C Errors (${errors.length}):`);
-    for (const r of errors) {
-      console.log(`   ${r.endpoint}: ${r.message}`);
-    }
-    console.log("");
-  }
-  console.log("\u2500".repeat(50));
-  console.log(
-    `Total: ${results.length} | Migrated: ${migrated.length} | Skipped: ${skipped.length} | Errors: ${errors.length}`
-  );
-  if (options.dryRun && migrated.length > 0) {
-    console.log("\nRun without --dry-run to apply changes");
-  }
-}
-
 // src/cli.ts
 var require2 = createRequire(import.meta.url);
 var { version: VERSION } = require2("../package.json");
@@ -602,8 +286,4 @@ program.command("scaffold <type> <path>").description("Generate a colocated feat
 program.command("analyze-bff <bff-path>").description(
   "Analyze BFF to extract endpoint \u2192 permission \u2192 apiService mappings"
 ).option("-o, --output <file>", "Output JSON file path").option("--format <type>", "Output format: json, table", "json").action(analyzeBffCommand);
-program.command("migrate-contracts <contracts-path>").description("Migrate contracts to new metadata format using migration map").requiredOption(
-  "-m, --migration-map <file>",
-  "Path to migration map JSON file (from analyze-bff)"
-).option("--dry-run", "Show what would be changed without writing files").action(migrateContractsCommand);
 program.parse();

package/dist/mcp-server.js

@@ -3,7 +3,7 @@ import {
   analyzeCore,
   lintCore,
   scaffoldCore
-} from "./chunk-FV47ZLIM.js";
+} from "./chunk-UNAQG5HI.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.4.2",
+  "version": "1.5.0",
   "description": "TypeScript dev kit for Claude Code agents: architecture linting, scaffolding, knowledge analysis",
   "type": "module",
   "bin": {
@@ -53,6 +53,7 @@
     "gray-matter": "^4.0.3",
     "minimatch": "^10.0.1",
     "picocolors": "^1.1.1",
+    "ts-morph": "^27.0.2",
     "vue-eslint-parser": "^10.2.0",
     "yaml": "^2.8.2",
     "zod": "^4.3.4"