@hyphaene/hexa-ts-kit 1.2.4 → 1.4.0

package/dist/cli.js

@@ -3,17 +3,583 @@ import {
   analyzeCommand,
   lintCommand,
   scaffoldCommand
-} from "./chunk-56VIQG3N.js";
+} from "./chunk-FV47ZLIM.js";
 
 // src/cli.ts
 import { program } from "commander";
 import { createRequire } from "module";
+
+// src/commands/analyze-bff.ts
+import { writeFileSync } from "fs";
+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";
+var MODULE_TO_SERVICE = {
+  SeeCoreModule: "seeCore",
+  LocusModule: "locus",
+  SeeBudgetModule: "seeBudget",
+  SmdModule: "smd",
+  SeeProviderModule: "seeProvider"
+};
+var PERMISSION_CONST_TO_VALUE = {
+  CAN_MANAGE_CONTRACT: "canManageContract",
+  CAN_MANAGE_BUDGET_FLOW: "canManageBudgetFlow",
+  CAN_UPLOAD_BUDGET: "canUploadBudget",
+  CAN_DELETE_BUDGET: "canDeleteBudget",
+  CAN_MANAGE_NOTES: "canManageNotes",
+  CAN_MANAGE_EXTRA_COSTS: "canManageExtraCosts",
+  CAN_MANAGE_CUSTOMER_INFORMATION: "canManageCustomerInformation",
+  CAN_ASSIGN_PROVIDER: "canAssignProvider",
+  CAN_ASSIGN_WORKER: "canAssignWorker",
+  CAN_UPLOAD_DOCUMENTS: "canUploadDocuments",
+  CAN_DOWNLOAD_DOCUMENTS: "canDownloadDocuments",
+  CAN_DELETE_DOCUMENTS: "canDeleteDocuments",
+  CAN_SELECT_UNAVAILABLE_PROVIDER_WORKER: "canSelectUnavailableProviderAndWorker",
+  CAN_RESCHEDULE_SERVICE_EXECUTION: "canRescheduleServiceExecution",
+  CAN_MANAGE_REWORK: "canManageRework",
+  CAN_CANCEL_SERVICE_EXECUTION: "canCancelServiceExecution",
+  CAN_MANAGE_WORKING_CLOSED_FORM: "canManageWorkingClosedForm",
+  CAN_SKIP_CONTRACT: "canSkipContract"
+};
+async function analyzeBff(bffPath) {
+  const mappings = [];
+  const errors = [];
+  const controllerFiles = await fg("**/src/domains/**/*.controller.ts", {
+    cwd: bffPath,
+    ignore: [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/*.spec.ts",
+      "**/*.test.ts"
+    ],
+    absolute: true
+  });
+  const moduleFiles = await fg("**/src/domains/**/*.module.ts", {
+    cwd: bffPath,
+    ignore: ["**/node_modules/**", "**/dist/**"],
+    absolute: true
+  });
+  const featureApiServices = /* @__PURE__ */ new Map();
+  for (const modulePath of moduleFiles) {
+    const featureName = extractFeatureName(modulePath);
+    const apiServices = extractApiServicesFromModule(modulePath);
+    if (featureName && apiServices.length > 0) {
+      featureApiServices.set(featureName, apiServices);
+    }
+  }
+  for (const controllerPath of controllerFiles) {
+    try {
+      const featureName = extractFeatureName(controllerPath);
+      const apiServices = featureName ? featureApiServices.get(featureName) ?? [] : [];
+      const controllerMappings = analyzeController(controllerPath, apiServices);
+      mappings.push(...controllerMappings);
+    } catch (err) {
+      errors.push(
+        `Error analyzing ${controllerPath}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return { mappings, errors };
+}
+function extractFeatureName(filePath) {
+  const match = filePath.match(/domains\/([^/]+)\//);
+  return match?.[1] ?? null;
+}
+function extractApiServicesFromModule(modulePath) {
+  const content = readFileSync(modulePath, "utf-8");
+  const services = [];
+  for (const [moduleName, serviceName] of Object.entries(MODULE_TO_SERVICE)) {
+    if (content.includes(moduleName)) {
+      services.push(serviceName);
+    }
+  }
+  return services;
+}
+function analyzeController(controllerPath, apiServices) {
+  const content = readFileSync(controllerPath, "utf-8");
+  const mappings = [];
+  let ast;
+  try {
+    ast = parse(content, { loc: true, range: true, comment: true });
+  } 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);
+    }
+  }
+  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;
+    if (methodName === "constructor" || methodName.startsWith("_")) continue;
+    const decorators = member.decorators ?? [];
+    let permission = null;
+    let method = 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;
+          }
+        }
+        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 (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;
+          }
+        }
+      }
+    }
+    const endpointName = contractEndpointName ?? methodName;
+    const permissionValue = permission ? PERMISSION_CONST_TO_VALUE[permission] ?? null : null;
+    const apiModules = Object.entries(MODULE_TO_SERVICE).filter(([_, service]) => apiServices.includes(service)).map(([module]) => module);
+    mappings.push({
+      endpointName,
+      controllerPath,
+      permission,
+      permissionValue,
+      apiModules,
+      apiServices,
+      method,
+      path
+    });
+  }
+}
+function generateMigrationMap(result) {
+  const map = {};
+  for (const mapping of result.mappings) {
+    const existing = map[mapping.endpointName];
+    const hasMoreInfo = !existing || mapping.permissionValue && !existing.requiredPermission || mapping.apiServices.length > 0 && existing.apiServices.length === 0 || mapping.permissionValue && mapping.apiServices.length > 0;
+    if (hasMoreInfo) {
+      map[mapping.endpointName] = {
+        requiredPermission: mapping.permissionValue ?? "NO_PERMISSION",
+        apiServices: mapping.apiServices
+      };
+    }
+  }
+  return map;
+}
+
+// src/commands/analyze-bff.ts
+async function analyzeBffCommand(bffPath, options) {
+  const absolutePath = resolve(bffPath);
+  console.log(`Analyzing BFF at: ${absolutePath}
+`);
+  const result = await analyzeBff(absolutePath);
+  if (result.errors.length > 0) {
+    console.error("Errors encountered:");
+    for (const error of result.errors) {
+      console.error(`  - ${error}`);
+    }
+    console.log();
+  }
+  if (options.format === "table") {
+    printTable(result.mappings);
+  } else {
+    const migrationMap = generateMigrationMap(result);
+    const output = JSON.stringify(
+      {
+        mappings: result.mappings,
+        migrationMap,
+        summary: {
+          total: result.mappings.length,
+          withPermission: result.mappings.filter((m) => m.permission).length,
+          withApiServices: result.mappings.filter(
+            (m) => m.apiServices.length > 0
+          ).length,
+          errors: result.errors.length
+        }
+      },
+      null,
+      2
+    );
+    if (options.output) {
+      writeFileSync(options.output, output, "utf-8");
+      console.log(`Output written to: ${options.output}`);
+    } else {
+      console.log(output);
+    }
+  }
+}
+function printTable(mappings) {
+  console.log("Endpoint Mappings:");
+  console.log("\u2500".repeat(100));
+  console.log(
+    padEnd("Endpoint", 30) + padEnd("Permission", 25) + padEnd("API Services", 20) + "Controller"
+  );
+  console.log("\u2500".repeat(100));
+  for (const m of mappings) {
+    const endpoint = padEnd(m.endpointName, 30);
+    const permission = padEnd(m.permissionValue ?? "(none)", 25);
+    const services = padEnd(m.apiServices.join(", ") || "(none)", 20);
+    const controller = m.controllerPath.split("/").slice(-3).join("/");
+    console.log(`${endpoint}${permission}${services}${controller}`);
+  }
+  console.log("\u2500".repeat(100));
+  console.log(`Total: ${mappings.length} endpoints`);
+  console.log(
+    `With permission: ${mappings.filter((m) => m.permission).length}`
+  );
+  console.log(
+    `With API services: ${mappings.filter((m) => m.apiServices.length > 0).length}`
+  );
+}
+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");
 program.name("hexa-ts").description(
   "TypeScript dev kit: architecture linting, scaffolding, knowledge analysis"
 ).version(VERSION);
-program.command("lint [path]").description("Lint files for colocation architecture rules").option("-f, --format <type>", "Output format: console, json", "console").option("--changed", "Only lint files changed in git").option(
+program.command("lint [path]").description("Lint files for colocation architecture rules").option("-f, --format <type>", "Output format: console, json", "console").option("--cwd <path>", "Working directory to lint (alias for path argument)").option("--changed", "Only lint files changed in git").option(
   "--rules <rules>",
   "Comma-separated list of rule prefixes to run (COL,NAM,DOM,VUE,etc)"
 ).option("--quiet", "Only show errors, hide warnings and info").option("--debug", "Show debug information").action(lintCommand);
@@ -22,5 +588,22 @@ program.command("analyze [files...]").description("Map files to their associated
   "Path to knowledge files",
   "~/.claude/marketplace/shared/knowledge"
 ).action(analyzeCommand);
-program.command("scaffold <type> <path>").description("Generate a colocated feature structure").option("--dry-run", "Show what would be created without writing files").action(scaffoldCommand);
+program.command("scaffold <type> <path>").description("Generate a colocated feature structure").option("--dry-run", "Show what would be created without writing files").option(
+  "--contract-path <path>",
+  "Path to contract file (for nestjs-bff-feature)"
+).option(
+  "--endpoint-name <name>",
+  "Endpoint name from contract (for nestjs-bff-feature)"
+).option(
+  "--contracts-lib <import>",
+  "Import path for contracts lib",
+  "@adeo/ahs-operator-execution-contracts"
+).action(scaffoldCommand);
+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-56VIQG3N.js";
+} from "./chunk-FV47ZLIM.js";
 
 // src/mcp-server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -20,16 +20,17 @@ 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.",
   {
-    path: z.string().optional().describe("Path to lint (default: current working directory)"),
+    cwd: z.string().optional().describe("Working directory to lint (default: current directory)"),
+    path: z.string().optional().describe("Alias for cwd - path to lint"),
     changed: z.boolean().optional().describe("Only lint git-changed files (staged and unstaged)"),
     rules: z.string().optional().describe(
-      "Filter by rule prefix, comma-separated (COL, NAM, DOM, VUE, RUL, TSP)"
+      "Filter by rule prefix, comma-separated (COL, NAM, DOM, VUE, RUL, TSP, CTR)"
     ),
     quiet: z.boolean().optional().describe("Only show errors, hide warnings and info")
   },
   async (params) => {
     const result = await lintCore({
-      path: params.path,
+      path: params.cwd || params.path,
       changed: params.changed,
       rules: params.rules,
       quiet: params.quiet

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyphaene/hexa-ts-kit",
-  "version": "1.2.4",
+  "version": "1.4.0",
   "description": "TypeScript dev kit for Claude Code agents: architecture linting, scaffolding, knowledge analysis",
   "type": "module",
   "bin": {
@@ -54,6 +54,7 @@
     "minimatch": "^10.0.1",
     "picocolors": "^1.1.1",
     "vue-eslint-parser": "^10.2.0",
+    "yaml": "^2.8.2",
     "zod": "^4.3.4"
   },
   "devDependencies": {
@@ -61,7 +62,7 @@
     "@semantic-release/git": "^10.0.1",
     "@types/node": "^22.10.2",
     "@vitest/coverage-v8": "^3.1.4",
-    "semantic-release": "^24.2.5",
+    "semantic-release": "^25.0.2",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
     "vitest": "^3.1.4"