@hyphaene/hexa-ts-kit 1.2.4 → 1.3.0

package/dist/chunk-FV47ZLIM.js

@@ -0,0 +1,2922 @@
+// src/commands/lint.ts
+import { resolve as resolve2 } from "path";
+import { execSync } from "child_process";
+
+// src/lint/checkers/structure/colocation.ts
+import fg from "fast-glob";
+import { existsSync } from "fs";
+import { basename, dirname, join } from "path";
+
+// src/lint/checkers/structure/naming.ts
+import fg2 from "fast-glob";
+import { readFile } from "fs/promises";
+import { basename as basename2 } from "path";
+
+// src/lint/checkers/structure/domains.ts
+import fg3 from "fast-glob";
+import { basename as basename3 } from "path";
+
+// src/lint/checkers/ast/vue-component.ts
+import fg4 from "fast-glob";
+import { readFile as readFile2 } from "fs/promises";
+
+// src/lint/checkers/ast/rules-file.ts
+import fg5 from "fast-glob";
+import { readFile as readFile3 } from "fs/promises";
+
+// src/lint/checkers/ast/typescript.ts
+import fg6 from "fast-glob";
+import { readFile as readFile4 } from "fs/promises";
+
+// src/lint/rules.registry.ts
+var rulesRegistry = {
+  // ==========================================================================
+  // Colocation Rules (COL-*)
+  // ==========================================================================
+  "COL-001": {
+    title: "Vue component outside domains",
+    severity: "error",
+    category: "colocation",
+    why: "All Vue components must live in src/domains/{domain}/{feature}/ for colocation.",
+    autoFixable: false
+  },
+  "COL-002": {
+    title: "Missing colocated composable",
+    severity: "error",
+    category: "colocation",
+    why: "Each Vue component should have a colocated composable for logic separation.",
+    autoFixable: false
+  },
+  "COL-003": {
+    title: "Missing colocated types",
+    severity: "warning",
+    category: "colocation",
+    why: "Types should be colocated with the component that uses them.",
+    autoFixable: false
+  },
+  "COL-004": {
+    title: "Missing colocated tests",
+    severity: "warning",
+    category: "colocation",
+    why: "Tests should be colocated with the code they test.",
+    autoFixable: false
+  },
+  "COL-005": {
+    title: "Forbidden src/components directory",
+    severity: "error",
+    category: "colocation",
+    why: "Root-level components/ directory violates colocation. Move to domains/.",
+    autoFixable: false
+  },
+  "COL-006": {
+    title: "Forbidden src/hooks or src/composables directory",
+    severity: "error",
+    category: "colocation",
+    why: "Root-level hooks/composables directories violate colocation. Move to domains/.",
+    autoFixable: false
+  },
+  "COL-007": {
+    title: "Forbidden src/services directory",
+    severity: "error",
+    category: "colocation",
+    why: "Root-level services/ directory violates colocation. Move to domains/.",
+    autoFixable: false
+  },
+  "COL-008": {
+    title: "Forbidden src/types directory",
+    severity: "error",
+    category: "colocation",
+    why: "Root-level types/ directory violates colocation. Move to domains/ or shared/.",
+    autoFixable: false
+  },
+  "COL-009": {
+    title: "Unused colocated file",
+    severity: "warning",
+    category: "colocation",
+    why: "Colocated files should be used by their parent component.",
+    autoFixable: false
+  },
+  "COL-010": {
+    title: "Cross-domain import",
+    severity: "error",
+    category: "colocation",
+    why: "Direct imports between domains create coupling. Use shared/ for common code.",
+    autoFixable: false
+  },
+  "COL-011": {
+    title: "Missing index barrel export",
+    severity: "warning",
+    category: "colocation",
+    why: "Features should expose a clean public API via index.ts.",
+    autoFixable: true
+  },
+  "COL-012": {
+    title: "Deep import into feature",
+    severity: "warning",
+    category: "colocation",
+    why: "Import from feature index, not internal files.",
+    autoFixable: false
+  },
+  // ==========================================================================
+  // Naming Rules (NAM-*)
+  // ==========================================================================
+  "NAM-001": {
+    title: "Vue file not PascalCase",
+    severity: "error",
+    category: "naming",
+    why: "Vue components must use PascalCase naming (e.g., MyComponent.vue).",
+    autoFixable: false
+  },
+  "NAM-002": {
+    title: "Composable missing use prefix",
+    severity: "error",
+    category: "naming",
+    why: "Composables must start with 'use' (e.g., useMyFeature.ts).",
+    autoFixable: false
+  },
+  "NAM-003": {
+    title: "Types file wrong suffix",
+    severity: "error",
+    category: "naming",
+    why: "Type files must use .types.ts suffix.",
+    autoFixable: false
+  },
+  "NAM-004": {
+    title: "Test file wrong suffix",
+    severity: "error",
+    category: "naming",
+    why: "Test files must use .test.ts or .spec.ts suffix.",
+    autoFixable: false
+  },
+  "NAM-005": {
+    title: "Feature folder not kebab-case",
+    severity: "error",
+    category: "naming",
+    why: "Feature folders must use kebab-case (e.g., my-feature/).",
+    autoFixable: false
+  },
+  "NAM-006": {
+    title: "Domain folder not kebab-case",
+    severity: "error",
+    category: "naming",
+    why: "Domain folders must use kebab-case.",
+    autoFixable: false
+  },
+  "NAM-007": {
+    title: "Constant not SCREAMING_SNAKE_CASE",
+    severity: "warning",
+    category: "naming",
+    why: "Constants should use SCREAMING_SNAKE_CASE.",
+    autoFixable: false
+  },
+  "NAM-008": {
+    title: "Interface missing I prefix",
+    severity: "info",
+    category: "naming",
+    why: "Consider using I prefix for interfaces (IMyInterface).",
+    autoFixable: false
+  },
+  "NAM-009": {
+    title: "Type alias wrong suffix",
+    severity: "info",
+    category: "naming",
+    why: "Consider using Type suffix for type aliases (MyType).",
+    autoFixable: false
+  },
+  "NAM-010": {
+    title: "Enum not PascalCase",
+    severity: "error",
+    category: "naming",
+    why: "Enums must use PascalCase naming.",
+    autoFixable: false
+  },
+  "NAM-011": {
+    title: "Query key not camelCase",
+    severity: "error",
+    category: "naming",
+    why: "Query keys must use camelCase.",
+    autoFixable: false
+  },
+  "NAM-012": {
+    title: "Event handler missing on prefix",
+    severity: "warning",
+    category: "naming",
+    why: "Event handlers should start with 'on' (e.g., onSubmit).",
+    autoFixable: false
+  },
+  // ==========================================================================
+  // Vue Component Rules (VUE-*)
+  // ==========================================================================
+  "VUE-001": {
+    title: "ref() in component",
+    severity: "error",
+    category: "vue",
+    why: "ref() should be in composable, not component. Components are for template binding.",
+    autoFixable: false
+  },
+  "VUE-002": {
+    title: "reactive() in component",
+    severity: "error",
+    category: "vue",
+    why: "reactive() should be in composable, not component.",
+    autoFixable: false
+  },
+  "VUE-003": {
+    title: "computed() in component",
+    severity: "error",
+    category: "vue",
+    why: "computed() should be in composable, not component.",
+    autoFixable: false
+  },
+  "VUE-004": {
+    title: "watch() in component",
+    severity: "error",
+    category: "vue",
+    why: "watch() should be in composable, not component.",
+    autoFixable: false
+  },
+  "VUE-005": {
+    title: "watchEffect() in component",
+    severity: "error",
+    category: "vue",
+    why: "watchEffect() should be in composable, not component.",
+    autoFixable: false
+  },
+  "VUE-006": {
+    title: "Complex logic in template",
+    severity: "warning",
+    category: "vue",
+    why: "Move complex expressions to computed properties in composable.",
+    autoFixable: false
+  },
+  "VUE-007": {
+    title: "Inline styles in template",
+    severity: "warning",
+    category: "vue",
+    why: "Use CSS classes instead of inline styles.",
+    autoFixable: false
+  },
+  "VUE-008": {
+    title: "Missing component name",
+    severity: "warning",
+    category: "vue",
+    why: "Components should have explicit names for debugging.",
+    autoFixable: true
+  },
+  "VUE-009": {
+    title: "v-if with v-for",
+    severity: "error",
+    category: "vue",
+    why: "v-if and v-for on same element is anti-pattern. Use computed or wrapper.",
+    autoFixable: false
+  },
+  "VUE-010": {
+    title: "Missing key in v-for",
+    severity: "error",
+    category: "vue",
+    why: "v-for requires :key for proper DOM diffing.",
+    autoFixable: false
+  },
+  "VUE-011": {
+    title: "Direct DOM manipulation",
+    severity: "error",
+    category: "vue",
+    why: "Avoid direct DOM manipulation. Use refs and Vue reactivity.",
+    autoFixable: false
+  },
+  "VUE-012": {
+    title: "Prop mutation",
+    severity: "error",
+    category: "vue",
+    why: "Never mutate props directly. Emit events instead.",
+    autoFixable: false
+  },
+  "VUE-013": {
+    title: "Missing prop validation",
+    severity: "warning",
+    category: "vue",
+    why: "Props should have type validation.",
+    autoFixable: false
+  },
+  // ==========================================================================
+  // Composable Rules (CMP-*)
+  // ==========================================================================
+  "CMP-001": {
+    title: "Missing return statement",
+    severity: "error",
+    category: "composable",
+    why: "Composables must return their reactive state and methods.",
+    autoFixable: false
+  },
+  "CMP-002": {
+    title: "Side effect outside onMounted",
+    severity: "warning",
+    category: "composable",
+    why: "Side effects should be in lifecycle hooks, not at module level.",
+    autoFixable: false
+  },
+  "CMP-003": {
+    title: "Missing cleanup in onUnmounted",
+    severity: "warning",
+    category: "composable",
+    why: "Subscriptions and listeners need cleanup to prevent memory leaks.",
+    autoFixable: false
+  },
+  "CMP-004": {
+    title: "Non-reactive return value",
+    severity: "warning",
+    category: "composable",
+    why: "Composables should return reactive values (ref, computed, reactive).",
+    autoFixable: false
+  },
+  "CMP-005": {
+    title: "Direct API call without error handling",
+    severity: "warning",
+    category: "composable",
+    why: "API calls should have try/catch or error handling.",
+    autoFixable: false
+  },
+  "CMP-006": {
+    title: "Hardcoded values",
+    severity: "info",
+    category: "composable",
+    why: "Consider extracting hardcoded values to constants or config.",
+    autoFixable: false
+  },
+  "CMP-007": {
+    title: "Missing TypeScript types",
+    severity: "warning",
+    category: "composable",
+    why: "Composable parameters and return type should be typed.",
+    autoFixable: false
+  },
+  "CMP-008": {
+    title: "Too many responsibilities",
+    severity: "warning",
+    category: "composable",
+    why: "Composable does too much. Consider splitting into smaller composables.",
+    autoFixable: false
+  },
+  "CMP-009": {
+    title: "Global state mutation",
+    severity: "error",
+    category: "composable",
+    why: "Avoid mutating global state directly. Use stores.",
+    autoFixable: false
+  },
+  "CMP-010": {
+    title: "Synchronous blocking operation",
+    severity: "warning",
+    category: "composable",
+    why: "Heavy operations should be async to avoid blocking UI.",
+    autoFixable: false
+  },
+  "CMP-011": {
+    title: "Missing loading state",
+    severity: "info",
+    category: "composable",
+    why: "Async operations should expose loading state.",
+    autoFixable: false
+  },
+  // ==========================================================================
+  // Rules File Rules (RUL-*)
+  // ==========================================================================
+  "RUL-001": {
+    title: "Missing rules file",
+    severity: "warning",
+    category: "rules",
+    why: "Features should have a .rules.ts file documenting business rules.",
+    autoFixable: false
+  },
+  "RUL-002": {
+    title: "Rules not exported",
+    severity: "error",
+    category: "rules",
+    why: "Rules must be exported for documentation generation.",
+    autoFixable: false
+  },
+  "RUL-003": {
+    title: "Rule missing description",
+    severity: "warning",
+    category: "rules",
+    why: "Each rule should have a human-readable description.",
+    autoFixable: false
+  },
+  "RUL-004": {
+    title: "Rule missing validation",
+    severity: "warning",
+    category: "rules",
+    why: "Rules should include validation logic.",
+    autoFixable: false
+  },
+  "RUL-005": {
+    title: "Orphan rule",
+    severity: "warning",
+    category: "rules",
+    why: "Rule is defined but not used in any composable.",
+    autoFixable: false
+  },
+  "RUL-006": {
+    title: "Inline business rule",
+    severity: "warning",
+    category: "rules",
+    why: "Business logic should be in .rules.ts, not inline in component.",
+    autoFixable: false
+  },
+  "RUL-007": {
+    title: "Missing rule test",
+    severity: "info",
+    category: "rules",
+    why: "Business rules should have unit tests.",
+    autoFixable: false
+  },
+  "RUL-008": {
+    title: "Rule complexity too high",
+    severity: "warning",
+    category: "rules",
+    why: "Complex rules should be broken down into smaller rules.",
+    autoFixable: false
+  },
+  "RUL-009": {
+    title: "Duplicate rule logic",
+    severity: "warning",
+    category: "rules",
+    why: "Same rule logic appears in multiple places. Centralize it.",
+    autoFixable: false
+  },
+  "RUL-010": {
+    title: "Rule without error message",
+    severity: "warning",
+    category: "rules",
+    why: "Rules should define user-facing error messages.",
+    autoFixable: false
+  },
+  "RUL-011": {
+    title: "Magic number in rule",
+    severity: "warning",
+    category: "rules",
+    why: "Extract magic numbers to named constants.",
+    autoFixable: false
+  },
+  "RUL-012": {
+    title: "Rule depends on external state",
+    severity: "warning",
+    category: "rules",
+    why: "Rules should be pure functions. Pass dependencies as parameters.",
+    autoFixable: false
+  },
+  // ==========================================================================
+  // Query Rules (QRY-*)
+  // ==========================================================================
+  "QRY-001": {
+    title: "Query key not array",
+    severity: "error",
+    category: "query",
+    why: "Query keys must be arrays for proper cache invalidation.",
+    autoFixable: true
+  },
+  "QRY-002": {
+    title: "Missing query key factory",
+    severity: "warning",
+    category: "query",
+    why: "Use query key factories for consistency.",
+    autoFixable: false
+  },
+  "QRY-003": {
+    title: "Hardcoded stale time",
+    severity: "info",
+    category: "query",
+    why: "Consider extracting stale time to config.",
+    autoFixable: false
+  },
+  "QRY-004": {
+    title: "Missing error handling",
+    severity: "warning",
+    category: "query",
+    why: "Queries should handle errors gracefully.",
+    autoFixable: false
+  },
+  "QRY-005": {
+    title: "Query in component",
+    severity: "error",
+    category: "query",
+    why: "useQuery should be in composable, not component.",
+    autoFixable: false
+  },
+  "QRY-006": {
+    title: "Missing enabled condition",
+    severity: "info",
+    category: "query",
+    why: "Consider using enabled option for conditional queries.",
+    autoFixable: false
+  },
+  "QRY-007": {
+    title: "Mutation without invalidation",
+    severity: "warning",
+    category: "query",
+    why: "Mutations should invalidate related queries.",
+    autoFixable: false
+  },
+  "QRY-008": {
+    title: "Direct fetch instead of query",
+    severity: "warning",
+    category: "query",
+    why: "Use useQuery/useMutation for API calls to get caching benefits.",
+    autoFixable: false
+  },
+  // ==========================================================================
+  // Translation Rules (TRN-*)
+  // ==========================================================================
+  "TRN-001": {
+    title: "Hardcoded string",
+    severity: "warning",
+    category: "translations",
+    why: "User-facing strings should use i18n.",
+    autoFixable: false
+  },
+  "TRN-002": {
+    title: "Missing translation key",
+    severity: "error",
+    category: "translations",
+    why: "Translation key not found in any locale file.",
+    autoFixable: false
+  },
+  "TRN-003": {
+    title: "Unused translation key",
+    severity: "warning",
+    category: "translations",
+    why: "Translation key is defined but never used.",
+    autoFixable: false
+  },
+  "TRN-004": {
+    title: "Inconsistent translation keys",
+    severity: "warning",
+    category: "translations",
+    why: "Key exists in some locales but not all.",
+    autoFixable: false
+  },
+  "TRN-005": {
+    title: "Non-namespaced translation key",
+    severity: "info",
+    category: "translations",
+    why: "Translation keys should be namespaced by feature.",
+    autoFixable: false
+  },
+  // ==========================================================================
+  // TypeScript Rules (TSP-*)
+  // ==========================================================================
+  "TSP-001": {
+    title: "any type usage",
+    severity: "error",
+    category: "typescript",
+    why: "Avoid 'any'. Use 'unknown' or proper types.",
+    autoFixable: false
+  },
+  "TSP-002": {
+    title: "Type assertion without check",
+    severity: "warning",
+    category: "typescript",
+    why: "Type assertions (as X) should be preceded by runtime checks.",
+    autoFixable: false
+  },
+  "TSP-003": {
+    title: "Non-null assertion",
+    severity: "warning",
+    category: "typescript",
+    why: "Avoid ! operator. Use proper null checks.",
+    autoFixable: false
+  },
+  "TSP-004": {
+    title: "Implicit any in function",
+    severity: "error",
+    category: "typescript",
+    why: "Function parameters must have explicit types.",
+    autoFixable: false
+  },
+  "TSP-005": {
+    title: "Missing return type",
+    severity: "warning",
+    category: "typescript",
+    why: "Functions should have explicit return types.",
+    autoFixable: false
+  },
+  "TSP-006": {
+    title: "Type import not type-only",
+    severity: "info",
+    category: "typescript",
+    why: "Use 'import type' for type-only imports.",
+    autoFixable: true
+  },
+  "TSP-007": {
+    title: "Enum instead of const object",
+    severity: "info",
+    category: "typescript",
+    why: "Consider using const objects instead of enums for better tree-shaking.",
+    autoFixable: false
+  },
+  "TSP-008": {
+    title: "Object type instead of Record",
+    severity: "info",
+    category: "typescript",
+    why: "Use Record<K, V> instead of { [key: K]: V }.",
+    autoFixable: true
+  },
+  "TSP-009": {
+    title: "Function type instead of arrow",
+    severity: "info",
+    category: "typescript",
+    why: "Use arrow function type: (x: T) => R instead of Function.",
+    autoFixable: false
+  },
+  "TSP-010": {
+    title: "Redundant type annotation",
+    severity: "info",
+    category: "typescript",
+    why: "Type can be inferred. Remove redundant annotation.",
+    autoFixable: true
+  },
+  "TSP-011": {
+    title: "Unsafe optional chaining",
+    severity: "warning",
+    category: "typescript",
+    why: "Optional chaining on non-nullable type suggests incorrect types.",
+    autoFixable: false
+  },
+  "TSP-012": {
+    title: "Missing generic constraint",
+    severity: "info",
+    category: "typescript",
+    why: "Generics should have constraints when possible.",
+    autoFixable: false
+  },
+  // ==========================================================================
+  // Domain Rules (DOM-*)
+  // ==========================================================================
+  "DOM-001": {
+    title: "Missing domain index",
+    severity: "warning",
+    category: "domain",
+    why: "Domains should have index.ts exposing public API.",
+    autoFixable: true
+  },
+  "DOM-002": {
+    title: "Circular domain dependency",
+    severity: "error",
+    category: "domain",
+    why: "Domains should not have circular dependencies.",
+    autoFixable: false
+  },
+  "DOM-003": {
+    title: "Shared code in domain",
+    severity: "warning",
+    category: "domain",
+    why: "Code used by multiple domains should be in shared/.",
+    autoFixable: false
+  },
+  "DOM-004": {
+    title: "Domain too large",
+    severity: "info",
+    category: "domain",
+    why: "Consider splitting large domains into sub-domains.",
+    autoFixable: false
+  },
+  // ==========================================================================
+  // Contracts Rules (CTR-*)
+  // ==========================================================================
+  "CTR-001": {
+    title: "Missing metadata",
+    severity: "error",
+    category: "contracts",
+    why: "Every contract endpoint must have metadata for documentation and tooling.",
+    autoFixable: false,
+    examples: {
+      invalid: "contracts/CTR-001-invalid.ts",
+      valid: "contracts/CTR-001-valid.ts"
+    }
+  },
+  "CTR-002": {
+    title: "Missing openApiTags",
+    severity: "error",
+    category: "contracts",
+    why: "Endpoints must have openApiTags for API documentation grouping.",
+    autoFixable: false,
+    examples: {
+      invalid: "contracts/CTR-002-invalid.ts",
+      valid: "contracts/CTR-002-valid.ts"
+    }
+  },
+  "CTR-003": {
+    title: "Legacy openapi format",
+    severity: "error",
+    category: "contracts",
+    why: "Use metadata.openApiTags instead of metadata.openapi.tags.",
+    autoFixable: true,
+    examples: {
+      invalid: "contracts/CTR-003-invalid.ts",
+      valid: "contracts/CTR-003-valid.ts"
+    }
+  },
+  "CTR-004": {
+    title: "Missing permission",
+    severity: "error",
+    category: "contracts",
+    why: "Every endpoint must declare its requiredPermission for access control.",
+    autoFixable: false,
+    examples: {
+      invalid: "contracts/CTR-004-invalid.ts",
+      valid: "contracts/CTR-004-valid.ts"
+    }
+  },
+  "CTR-005": {
+    title: "Invalid permission value",
+    severity: "error",
+    category: "contracts",
+    why: "Permission must be a valid value from the Permission enum.",
+    autoFixable: false
+  },
+  "CTR-006": {
+    title: "Invalid apiService value",
+    severity: "error",
+    category: "contracts",
+    why: "apiService must be a valid value from the ApiService enum.",
+    autoFixable: false
+  },
+  "CTR-007": {
+    title: "Missing strictStatusCodes",
+    severity: "warning",
+    category: "contracts",
+    why: "Contracts should use strictStatusCodes: true for type safety.",
+    autoFixable: true,
+    examples: {
+      invalid: "contracts/CTR-007-invalid.ts",
+      valid: "contracts/CTR-007-valid.ts"
+    }
+  }
+};
+var allRuleIds = Object.keys(rulesRegistry);
+function getRulesByCategory(category) {
+  return allRuleIds.filter((id) => rulesRegistry[id].category === category);
+}
+
+// src/lib/contracts/config-loader.ts
+import { readFileSync, existsSync as existsSync2 } from "fs";
+import { resolve, join as join2 } from "path";
+import { parse as parseYaml } from "yaml";
+import { z } from "zod";
+var SourceExtractConfigSchema = z.object({
+  source: z.string(),
+  export: z.string(),
+  extract: z.enum(["const-values", "zod-keys"]).default("const-values")
+});
+var ContractsLintConfigSchema = z.object({
+  metadata: z.object({
+    permissions: SourceExtractConfigSchema,
+    apiServices: SourceExtractConfigSchema
+  }),
+  disabledRules: z.array(z.string()).optional()
+});
+var ContractsScaffoldConfigSchema = z.object({
+  path: z.string(),
+  // Absolute path to contracts lib
+  importPath: z.string()
+  // Import path for generated files
+});
+var ProjectConfigSchema = z.object({
+  type: z.enum(["contracts-lib", "nestjs-bff", "vue-frontend"])
+});
+var HexaTsKitConfigSchema = z.object({
+  project: ProjectConfigSchema,
+  lint: z.object({
+    contracts: ContractsLintConfigSchema.optional()
+  }).optional(),
+  scaffold: z.object({
+    contracts: ContractsScaffoldConfigSchema.optional()
+  }).optional()
+});
+var CONFIG_FILE_NAME = ".hexa-ts-kit.yaml";
+function loadConfig(repoPath) {
+  const absolutePath = resolve(repoPath);
+  const configPath = join2(absolutePath, CONFIG_FILE_NAME);
+  if (!existsSync2(configPath)) {
+    return {
+      success: false,
+      error: `Config file not found: ${configPath}`,
+      configPath
+    };
+  }
+  let content;
+  try {
+    content = readFileSync(configPath, "utf-8");
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to read config file: ${err instanceof Error ? err.message : String(err)}`,
+      configPath
+    };
+  }
+  let rawConfig;
+  try {
+    rawConfig = parseYaml(content);
+  } catch (err) {
+    return {
+      success: false,
+      error: `Invalid YAML syntax: ${err instanceof Error ? err.message : String(err)}`,
+      configPath
+    };
+  }
+  const result = HexaTsKitConfigSchema.safeParse(rawConfig);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
+    return {
+      success: false,
+      error: `Invalid config:
+${issues}`,
+      configPath
+    };
+  }
+  return {
+    success: true,
+    config: result.data,
+    configPath
+  };
+}
+function getPermissionsConfig(config) {
+  return config.lint?.contracts?.metadata?.permissions ?? null;
+}
+function getApiServicesConfig(config) {
+  return config.lint?.contracts?.metadata?.apiServices ?? null;
+}
+function resolveConfigPath(repoPath, relativePath) {
+  return resolve(repoPath, relativePath);
+}
+function getDisabledRules(config) {
+  return config.lint?.contracts?.disabledRules ?? [];
+}
+
+// src/lib/contracts/permissions-extractor.ts
+import { readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
+import { parse } from "@typescript-eslint/typescript-estree";
+function extractValues(sourcePath, config) {
+  if (!existsSync3(sourcePath)) {
+    return {
+      success: false,
+      error: `Source file not found: ${sourcePath}`,
+      sourcePath
+    };
+  }
+  let content;
+  try {
+    content = readFileSync2(sourcePath, "utf-8");
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to read source file: ${err instanceof Error ? err.message : String(err)}`,
+      sourcePath
+    };
+  }
+  let ast;
+  try {
+    ast = parse(content, {
+      loc: true,
+      range: true
+    });
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to parse TypeScript: ${err instanceof Error ? err.message : String(err)}`,
+      sourcePath
+    };
+  }
+  const exportName = config.export;
+  const extractMode = config.extract;
+  if (extractMode === "const-values") {
+    return extractConstValues(ast, exportName, sourcePath);
+  } else if (extractMode === "zod-keys") {
+    return extractZodKeys(ast, exportName, sourcePath);
+  }
+  return {
+    success: false,
+    error: `Unknown extract mode: ${extractMode}`,
+    sourcePath
+  };
+}
+function extractConstValues(ast, exportName, sourcePath) {
+  const values = [];
+  const keyToValue = {};
+  for (const node of ast.body) {
+    if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "VariableDeclaration") {
+      for (const declarator of node.declaration.declarations) {
+        if (declarator.id.type === "Identifier" && declarator.id.name === exportName && declarator.init) {
+          let objectExpr = null;
+          if (declarator.init.type === "TSAsExpression") {
+            const expr = declarator.init.expression;
+            if (expr.type === "ObjectExpression") {
+              objectExpr = expr;
+            }
+          } else if (declarator.init.type === "ObjectExpression") {
+            objectExpr = declarator.init;
+          }
+          if (objectExpr) {
+            for (const prop of objectExpr.properties) {
+              if (prop.type === "Property" && prop.value.type === "Literal" && typeof prop.value.value === "string") {
+                const value = prop.value.value;
+                values.push(value);
+                if (prop.key.type === "Identifier") {
+                  keyToValue[prop.key.name] = value;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if (values.length === 0) {
+    return {
+      success: false,
+      error: `Could not find const object '${exportName}' with string values in ${sourcePath}`,
+      sourcePath
+    };
+  }
+  return {
+    success: true,
+    values,
+    keyToValue,
+    sourcePath
+  };
+}
+function extractZodKeys(ast, exportName, sourcePath) {
+  const values = [];
+  for (const node of ast.body) {
+    if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "VariableDeclaration") {
+      for (const declarator of node.declaration.declarations) {
+        if (declarator.id.type === "Identifier" && declarator.id.name === exportName && declarator.init) {
+          const init = declarator.init;
+          if (init.type === "CallExpression" && init.callee.type === "MemberExpression" && init.callee.property.type === "Identifier" && init.callee.property.name === "object") {
+            const firstArg = init.arguments[0];
+            if (firstArg && firstArg.type === "ObjectExpression") {
+              for (const prop of firstArg.properties) {
+                if (prop.type === "Property" && prop.key.type === "Identifier") {
+                  values.push(prop.key.name);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if (values.length === 0) {
+    return {
+      success: false,
+      error: `Could not find zod schema '${exportName}' with z.object() in ${sourcePath}`,
+      sourcePath
+    };
+  }
+  return {
+    success: true,
+    values,
+    sourcePath
+  };
+}
+
+// src/lib/contracts/contract-parser.ts
+import { readFileSync as readFileSync3, existsSync as existsSync4 } from "fs";
+import fg7 from "fast-glob";
+import { parse as parse2 } from "@typescript-eslint/typescript-estree";
+async function findContractFiles(repoPath) {
+  const files = await fg7("**/*.contract.ts", {
+    cwd: repoPath,
+    ignore: ["**/node_modules/**", "**/dist/**", "**/worktrees/**"],
+    absolute: true
+  });
+  return files;
+}
+function parseContractFile(filePath) {
+  if (!existsSync4(filePath)) {
+    return {
+      success: false,
+      error: `Contract file not found: ${filePath}`,
+      filePath
+    };
+  }
+  let content;
+  try {
+    content = readFileSync3(filePath, "utf-8");
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to read contract file: ${err instanceof Error ? err.message : String(err)}`,
+      filePath
+    };
+  }
+  let ast;
+  try {
+    ast = parse2(content, {
+      loc: true,
+      range: true
+    });
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to parse TypeScript: ${err instanceof Error ? err.message : String(err)}`,
+      filePath
+    };
+  }
+  const endpoints = [];
+  let contractName = "UnknownContract";
+  for (const node of ast.body) {
+    if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "VariableDeclaration") {
+      for (const declarator of node.declaration.declarations) {
+        if (declarator.id.type === "Identifier") {
+          contractName = declarator.id.name;
+          const routerCall = findRouterCall(declarator.init);
+          if (routerCall) {
+            const parsedEndpoints = extractEndpointsFromRouter(
+              routerCall,
+              content
+            );
+            endpoints.push(...parsedEndpoints);
+          }
+        }
+      }
+    }
+  }
+  return {
+    filePath,
+    contractName,
+    endpoints
+  };
+}
+async function parseContracts(repoPath) {
+  const files = await findContractFiles(repoPath);
+  if (files.length === 0) {
+    return {
+      success: true,
+      contracts: []
+    };
+  }
+  const contracts = [];
+  const errors = [];
+  for (const file of files) {
+    const result = parseContractFile(file);
+    if ("success" in result && !result.success) {
+      errors.push(result.error);
+    } else {
+      contracts.push(result);
+    }
+  }
+  if (errors.length > 0 && contracts.length === 0) {
+    return {
+      success: false,
+      error: errors.join("\n")
+    };
+  }
+  return {
+    success: true,
+    contracts
+  };
+}
+function findRouterCall(node) {
+  if (!node) return null;
+  if (node.type === "CallExpression" && node.callee.type === "MemberExpression" && node.callee.property.type === "Identifier" && node.callee.property.name === "router") {
+    return node;
+  }
+  return null;
+}
+function extractEndpointsFromRouter(routerCall, sourceContent) {
+  const endpoints = [];
+  const firstArg = routerCall.arguments[0];
+  if (!firstArg || firstArg.type !== "ObjectExpression") {
+    return endpoints;
+  }
+  const routerObject = firstArg;
+  for (const prop of routerObject.properties) {
+    if (prop.type !== "Property") continue;
+    if (prop.key.type !== "Identifier") continue;
+    const endpointName = prop.key.name;
+    const endpointLine = prop.loc?.start.line ?? 0;
+    if (prop.value.type !== "ObjectExpression") continue;
+    const endpoint = extractEndpointDetails(
+      endpointName,
+      prop.value,
+      endpointLine,
+      sourceContent
+    );
+    if (endpoint) {
+      endpoints.push(endpoint);
+    }
+  }
+  return endpoints;
+}
+function extractEndpointDetails(name, objectExpr, line, sourceContent) {
+  let method = "";
+  let path = "";
+  let metadata;
+  let strictStatusCodes;
+  for (const prop of objectExpr.properties) {
+    if (prop.type !== "Property") continue;
+    if (prop.key.type !== "Identifier") continue;
+    const propName = prop.key.name;
+    if (propName === "method" && prop.value.type === "Literal") {
+      method = String(prop.value.value);
+    }
+    if (propName === "path" && prop.value.type === "Literal") {
+      path = String(prop.value.value);
+    }
+    if (propName === "metadata") {
+      if (prop.value.type === "ObjectExpression" || prop.value.type === "CallExpression") {
+        metadata = extractMetadata(prop.value, sourceContent);
+      }
+    }
+    if (propName === "strictStatusCodes" && prop.value.type === "Literal") {
+      strictStatusCodes = prop.value.value === true;
+    }
+  }
+  return {
+    name,
+    method,
+    path,
+    metadata,
+    strictStatusCodes,
+    line
+  };
+}
+function extractMetadata(node, sourceContent) {
+  if (node.type === "ObjectExpression") {
+    return parseMetadataObject(node, sourceContent);
+  }
+  if (node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "contractMetadata") {
+    const firstArg = node.arguments[0];
+    if (firstArg && firstArg.type === "ObjectExpression") {
+      return parseMetadataObject(firstArg, sourceContent);
+    }
+  }
+  return void 0;
+}
+function parseMetadataObject(objectExpr, sourceContent) {
+  const metadata = {};
+  for (const prop of objectExpr.properties) {
+    if (prop.type !== "Property") continue;
+    if (prop.key.type !== "Identifier") continue;
+    const propName = prop.key.name;
+    if (propName === "openApiTags" && prop.value.type === "ArrayExpression") {
+      metadata.openApiTags = extractStringArray(prop.value);
+    }
+    if (propName === "requiredPermission") {
+      if (prop.value.type === "Literal" || prop.value.type === "MemberExpression") {
+        const permValue = extractPermissionValue(prop.value, sourceContent);
+        if (permValue) {
+          metadata.requiredPermission = permValue;
+        }
+      }
+    }
+    if (propName === "requiresAuth" && prop.value.type === "Literal") {
+      metadata.requiresAuth = prop.value.value === true;
+    }
+    if (propName === "bff" && prop.value.type === "ObjectExpression") {
+      metadata.bff = extractBffConfig(prop.value);
+    }
+    if (propName === "openapi" && prop.value.type === "ObjectExpression") {
+      metadata.openapi = extractLegacyOpenApi(prop.value);
+    }
+  }
+  return metadata;
+}
+function extractStringArray(arrayExpr) {
+  const values = [];
+  for (const element of arrayExpr.elements) {
+    if (element?.type === "Literal" && typeof element.value === "string") {
+      values.push(element.value);
+    }
+  }
+  return values;
+}
+function extractPermissionValue(node, sourceContent) {
+  if (node.type === "Literal" && typeof node.value === "string") {
+    return node.value;
+  }
+  if (node.type === "MemberExpression") {
+    if (node.range) {
+      const [start, end] = node.range;
+      return sourceContent.slice(start, end);
+    }
+  }
+  return void 0;
+}
+function extractBffConfig(objectExpr) {
+  const bff = {};
+  for (const prop of objectExpr.properties) {
+    if (prop.type !== "Property") continue;
+    if (prop.key.type !== "Identifier") continue;
+    if (prop.key.name === "apiServices" && prop.value.type === "ArrayExpression") {
+      bff.apiServices = [];
+      for (const element of prop.value.elements) {
+        if (element?.type === "Literal" && typeof element.value === "string") {
+          bff.apiServices.push(element.value);
+        }
+        if (element?.type === "MemberExpression") {
+          if (element.property.type === "Identifier") {
+            bff.apiServices.push(element.property.name);
+          }
+        }
+      }
+    }
+  }
+  return bff;
+}
+function extractLegacyOpenApi(objectExpr) {
+  const openapi = {};
+  for (const prop of objectExpr.properties) {
+    if (prop.type !== "Property") continue;
+    if (prop.key.type !== "Identifier") continue;
+    if (prop.key.name === "tags" && prop.value.type === "ArrayExpression") {
+      openapi.tags = extractStringArray(prop.value);
+    }
+  }
+  return openapi;
+}
+
+// src/lib/contracts/metadata-validator.ts
+import { z as z2 } from "zod";
+function validateContracts(contracts, ctx) {
+  const issues = [];
+  for (const contract of contracts) {
+    for (const endpoint of contract.endpoints) {
+      const endpointIssues = validateEndpoint(endpoint, contract.filePath, ctx);
+      issues.push(...endpointIssues);
+    }
+  }
+  return {
+    valid: issues.filter((i) => i.severity === "error").length === 0,
+    issues
+  };
+}
+function validateEndpoint(endpoint, filePath, ctx) {
+  const issues = [];
+  const { metadata, name, line } = endpoint;
+  if (endpoint.strictStatusCodes !== true) {
+    issues.push({
+      rule: "CTR-007",
+      severity: "error",
+      message: `Endpoint '${name}' is missing strictStatusCodes: true`,
+      endpointName: name,
+      filePath,
+      line,
+      suggestion: "Add strictStatusCodes: true to the endpoint definition"
+    });
+  }
+  if (!metadata) {
+    issues.push({
+      rule: "CTR-001",
+      severity: "error",
+      message: `Endpoint '${name}' is missing metadata`,
+      endpointName: name,
+      filePath,
+      line,
+      suggestion: "Add metadata: contractMetadata({ openApiTags: [...], requiredPermission: Permission.XXX })"
+    });
+    return issues;
+  }
+  if (metadata.openapi?.tags) {
+    issues.push({
+      rule: "CTR-003",
+      severity: "error",
+      message: `Endpoint '${name}' uses legacy format metadata.openapi.tags`,
+      endpointName: name,
+      filePath,
+      line,
+      suggestion: "Migrate to openApiTags: [...] at the root of metadata"
+    });
+  }
+  if (!metadata.openApiTags || metadata.openApiTags.length === 0) {
+    if (!metadata.openapi?.tags || metadata.openapi.tags.length === 0) {
+      issues.push({
+        rule: "CTR-002",
+        severity: "error",
+        message: `Endpoint '${name}' is missing openApiTags`,
+        endpointName: name,
+        filePath,
+        line,
+        suggestion: "Add openApiTags: ['TagName'] to metadata"
+      });
+    }
+  }
+  if (!metadata.requiredPermission) {
+    if (metadata.requiresAuth === false) {
+      issues.push({
+        rule: "CTR-004",
+        severity: "warning",
+        message: `Endpoint '${name}' uses legacy requiresAuth: false instead of Permission.NO_PERMISSION`,
+        endpointName: name,
+        filePath,
+        line,
+        suggestion: "Replace with requiredPermission: Permission.NO_PERMISSION"
+      });
+    } else {
+      issues.push({
+        rule: "CTR-004",
+        severity: "error",
+        message: `Endpoint '${name}' is missing requiredPermission`,
+        endpointName: name,
+        filePath,
+        line,
+        suggestion: "Add requiredPermission: Permission.XXX (or Permission.NO_PERMISSION for public endpoints)"
+      });
+    }
+  }
+  if (metadata.requiredPermission && ctx.validPermissions.length > 0) {
+    const permission = normalizePermissionValue(
+      metadata.requiredPermission,
+      ctx.permissionKeyToValue
+    );
+    if (!ctx.validPermissions.includes(permission)) {
+      issues.push({
+        rule: "CTR-005",
+        severity: "error",
+        message: `Endpoint '${name}' uses invalid permission '${metadata.requiredPermission}'`,
+        endpointName: name,
+        filePath,
+        line,
+        suggestion: `Valid permissions: ${ctx.validPermissions.slice(0, 5).join(", ")}...`
+      });
+    }
+  }
+  if (metadata.bff?.apiServices && ctx.validApiServices.length > 0) {
+    for (const service of metadata.bff.apiServices) {
+      const normalizedService = normalizeApiServiceValue(service);
+      if (!ctx.validApiServices.includes(normalizedService)) {
+        issues.push({
+          rule: "CTR-006",
+          severity: "error",
+          message: `Endpoint '${name}' uses invalid apiService '${service}'`,
+          endpointName: name,
+          filePath,
+          line,
+          suggestion: `Valid services: ${ctx.validApiServices.join(", ")}`
+        });
+      }
+    }
+  }
+  return issues;
+}
+function normalizePermissionValue(value, keyToValue) {
+  if (value.includes(".")) {
+    const parts = value.split(".");
+    const enumKey = parts[parts.length - 1] ?? value;
+    if (keyToValue && enumKey in keyToValue) {
+      const resolved = keyToValue[enumKey];
+      if (resolved) return resolved;
+    }
+    return enumKey;
+  }
+  return value;
+}
+function normalizeApiServiceValue(value) {
+  const serviceMap = {
+    SEE_CORE: "seeCore",
+    LOCUS: "locus",
+    SEE_BUDGET: "seeBudget",
+    SMD: "smd",
+    SEE_PROVIDER: "seeProvider"
+  };
+  if (serviceMap[value]) {
+    return serviceMap[value];
+  }
+  return value;
+}
+
+// src/lib/contracts/generators/types.ts
+var API_SERVICE_CONFIG = {
+  seeCore: {
+    moduleName: "SeeCoreModule",
+    moduleImport: "@/common/apis/seeCore/seeCore.module",
+    serviceName: "SeeCoreService",
+    serviceImport: "@/common/apis/seeCore/seeCore.service",
+    configMethod: "getAPIConfig",
+    configReturn: { baseUrl: "seeCoreBaseUrl", apiKey: "seeCoreApiKey" }
+  },
+  locus: {
+    moduleName: "LocusModule",
+    moduleImport: "@/common/apis/locus/locus.module",
+    serviceName: "LocusService",
+    serviceImport: "@/common/apis/locus/locus.service",
+    configMethod: "getAPIConfig",
+    configReturn: { baseUrl: "locusBaseUrl", apiKey: "locusApiKey" }
+  },
+  seeBudget: {
+    moduleName: "SeeBudgetModule",
+    moduleImport: "@/common/apis/seeBudget/seeBudget.module",
+    serviceName: "SeeBudgetService",
+    serviceImport: "@/common/apis/seeBudget/seeBudget.service",
+    configMethod: "getAPIConfig",
+    configReturn: { baseUrl: "seeBudgetBaseUrl", apiKey: "seeBudgetApiKey" }
+  },
+  smd: {
+    moduleName: "SmdModule",
+    moduleImport: "@/common/apis/smd/smd.module",
+    serviceName: "SmdService",
+    serviceImport: "@/common/apis/smd/smd.service",
+    configMethod: "getAPIConfig",
+    configReturn: { baseUrl: "smdBaseUrl", apiKey: "smdApiKey" }
+  },
+  seeProvider: {
+    moduleName: "SeeProviderModule",
+    moduleImport: "@/common/apis/seeProvider/seeProvider.module",
+    serviceName: "SeeProviderService",
+    serviceImport: "@/common/apis/seeProvider/seeProvider.service",
+    configMethod: "getAPIConfig",
+    configReturn: {
+      baseUrl: "seeProviderBaseUrl",
+      apiKey: "seeProviderApiKey"
+    }
+  }
+};
+function toCase(name, targetCase) {
+  const words = name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/-/g, " ").replace(/_/g, " ").toLowerCase().split(" ").filter(Boolean);
+  switch (targetCase) {
+    case "pascal":
+      return words.map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+    case "camel":
+      return words.map((w, i) => i === 0 ? w : w.charAt(0).toUpperCase() + w.slice(1)).join("");
+    case "snake":
+      return words.join("_").toUpperCase();
+    case "kebab":
+      return words.join("-");
+  }
+}
+function toPermissionConstant(permissionValue) {
+  if (permissionValue.includes(".")) {
+    const parts = permissionValue.split(".");
+    return parts[parts.length - 1] ?? permissionValue;
+  }
+  return permissionValue.replace(/([a-z])([A-Z])/g, "$1_$2").toUpperCase();
+}
+function getSuccessStatus(responses) {
+  if (!responses) return 200;
+  const statusCodes = Object.keys(responses).map(Number).filter((code) => code >= 200 && code < 300).sort();
+  return statusCodes[0] ?? 200;
+}
+
+// src/lib/contracts/generators/module.generator.ts
+function generateModule(ctx) {
+  const { featureName, featureNameCamel, apiServices } = ctx;
+  const apiModuleImports = apiServices.map((service) => {
+    const config = API_SERVICE_CONFIG[service];
+    if (!config) return null;
+    return `import { ${config.moduleName} } from "${config.moduleImport}";`;
+  }).filter(Boolean).join("\n");
+  const apiModuleNames = apiServices.map((service) => API_SERVICE_CONFIG[service]?.moduleName).filter(Boolean);
+  const content = `import { Module } from "@nestjs/common";
+${apiModuleImports}
+import { AuthorizationModule } from "@/common/security/authorization/module/authorization.module";
+import { TsRestClientModule } from "@/common/ts-rest/tsrestclient.module";
+
+import { ${featureName}Config } from "./config/${featureNameCamel}.config";
+import { ${featureName}Controller } from "./controller/${featureNameCamel}.controller";
+import { ${featureName}Service } from "./service/${featureNameCamel}.service";
+import { ${featureNameCamel}QueryProvider } from "./service/${featureNameCamel}Query.factory";
+
+@Module({
+  controllers: [${featureName}Controller],
+  providers: [${featureName}Service, ${featureName}Config, ${featureNameCamel}QueryProvider],
+  imports: [AuthorizationModule, TsRestClientModule${apiModuleNames.length > 0 ? ", " + apiModuleNames.join(", ") : ""}],
+  exports: [${featureName}Service],
+})
+export class ${featureName}Module {}
+`;
+  return {
+    path: `${featureNameCamel}.module.ts`,
+    content,
+    isComplete: true
+  };
+}
+
+// src/lib/contracts/generators/controller.generator.ts
+function generateController(ctx) {
+  const {
+    featureName,
+    featureNameCamel,
+    contractName,
+    contractsLib,
+    endpoint,
+    permissionConstant,
+    successStatus
+  } = ctx;
+  const pathParams = extractPathParams(endpoint.path);
+  const hasPathParams = pathParams.length > 0;
+  const paramImports = hasPathParams ? ", Param" : "";
+  const paramDecorators = pathParams.map((param) => `@Param("${param}") ${param}: string`).join(", ");
+  const httpMethod = endpoint.method.charAt(0).toUpperCase() + endpoint.method.slice(1).toLowerCase();
+  const needsBody = ["POST", "PUT", "PATCH"].includes(
+    endpoint.method.toUpperCase()
+  );
+  const bodyImport = needsBody ? ", Body" : "";
+  const serviceParams = pathParams.join(", ");
+  const content = `import { ${contractName} } from "${contractsLib}";
+import { Controller, HttpCode, Inject${paramImports}${bodyImport}, ${httpMethod} } from "@nestjs/common";
+import { TsRestHandler, tsRestHandler } from "@ts-rest/nest";
+
+import { Authorize } from "@/common/security/authorization/decorators/authorize.decorator";
+import { Permissions } from "@/common/security/session/constants/permissions.constants";
+
+import { ${featureName}Service } from "../service/${featureNameCamel}.service";
+
+@Controller()
+export class ${featureName}Controller {
+  constructor(
+    @Inject(${featureName}Service)
+    private readonly ${featureNameCamel}Service: ${featureName}Service,
+  ) {}
+
+  @${httpMethod}("${endpoint.path}")
+  @Authorize(Permissions.${permissionConstant})
+  @TsRestHandler(${contractName}.${endpoint.name})
+  @HttpCode(${successStatus})
+  async ${endpoint.name}(${paramDecorators}) {
+    return tsRestHandler(${contractName}.${endpoint.name}, async () => {
+      await this.${featureNameCamel}Service.${endpoint.name}(${serviceParams});
+      return { status: ${successStatus} as const, body: undefined };
+    });
+  }
+}
+`;
+  return {
+    path: `controller/${featureNameCamel}.controller.ts`,
+    content,
+    isComplete: true
+  };
+}
+function extractPathParams(path) {
+  const matches = path.match(/:(\w+)/g);
+  if (!matches) return [];
+  return matches.map((m) => m.slice(1));
+}
+
+// src/lib/contracts/generators/config.generator.ts
+function generateConfig(ctx) {
+  const { featureName, featureNameCamel, apiServices } = ctx;
+  const primaryService = apiServices[0];
+  const config = primaryService ? API_SERVICE_CONFIG[primaryService] : null;
+  if (!config) {
+    const content2 = `import { Injectable } from "@nestjs/common";
+
+@Injectable()
+export class ${featureName}Config {
+  public get${featureName}Config() {
+    return {};
+  }
+}
+`;
+    return {
+      path: `config/${featureNameCamel}.config.ts`,
+      content: content2,
+      isComplete: true
+    };
+  }
+  const serviceImports = apiServices.map((service) => {
+    const svcConfig = API_SERVICE_CONFIG[service];
+    if (!svcConfig) return null;
+    return `import { ${svcConfig.serviceName} } from "${svcConfig.serviceImport}";`;
+  }).filter(Boolean).join("\n");
+  const constructorParams = apiServices.map((service) => {
+    const svcConfig = API_SERVICE_CONFIG[service];
+    if (!svcConfig) return null;
+    const serviceCamel = svcConfig.serviceName.charAt(0).toLowerCase() + svcConfig.serviceName.slice(1);
+    return `    @Inject(${svcConfig.serviceName}) private readonly ${serviceCamel}: ${svcConfig.serviceName},`;
+  }).filter(Boolean).join("\n");
+  const configReturns = apiServices.map((service) => {
+    const svcConfig = API_SERVICE_CONFIG[service];
+    if (!svcConfig) return null;
+    const serviceCamel = svcConfig.serviceName.charAt(0).toLowerCase() + svcConfig.serviceName.slice(1);
+    return `    const { ${svcConfig.configReturn.baseUrl}, ${svcConfig.configReturn.apiKey} } = this.${serviceCamel}.${svcConfig.configMethod}();`;
+  }).filter(Boolean).join("\n");
+  const returnProps = apiServices.map((service) => {
+    const svcConfig = API_SERVICE_CONFIG[service];
+    if (!svcConfig) return null;
+    return `${svcConfig.configReturn.baseUrl}, ${svcConfig.configReturn.apiKey}`;
+  }).filter(Boolean).join(", ");
+  const content = `import { Inject, Injectable } from "@nestjs/common";
+${serviceImports}
+
+@Injectable()
+export class ${featureName}Config {
+  constructor(
+${constructorParams}
+  ) {}
+
+  public get${featureName}Config() {
+${configReturns}
+    return { ${returnProps} };
+  }
+}
+`;
+  return {
+    path: `config/${featureNameCamel}.config.ts`,
+    content,
+    isComplete: true
+  };
+}
+
+// src/lib/contracts/generators/service.generator.ts
+function generateService(ctx) {
+  const { featureName, featureNameCamel, featureNameUpperSnake, endpoint } = ctx;
+  const pathParams = extractPathParams2(endpoint.path);
+  const methodParams = pathParams.map((p) => `${p}: string`).join(", ");
+  const content = `import { Inject, Injectable } from "@nestjs/common";
+
+import {
+  ${featureNameUpperSnake}_QUERY,
+  ${featureName}Query,
+} from "./${featureNameCamel}Query.factory";
+
+@Injectable()
+export class ${featureName}Service {
+  constructor(
+    @Inject(${featureNameUpperSnake}_QUERY)
+    private readonly ${featureNameCamel}Query: ${featureName}Query,
+  ) {}
+
+  async ${endpoint.name}(${methodParams}): Promise<void> {
+    // TODO: Implement business logic
+    // 1. Call external API via query factory
+    // 2. Transform response if needed
+    // 3. Handle errors
+
+    const response = await this.${featureNameCamel}Query(${pathParams.join(", ")});
+
+    if (response.status !== 200 && response.status !== 204) {
+      // TODO: Handle error response
+      throw new Error(\`External API error: \${response.status}\`);
+    }
+  }
+}
+`;
+  return {
+    path: `service/${featureNameCamel}.service.ts`,
+    content,
+    isComplete: false
+    // Has TODOs
+  };
+}
+function extractPathParams2(path) {
+  const matches = path.match(/:(\w+)/g);
+  if (!matches) return [];
+  return matches.map((m) => m.slice(1));
+}
+
+// src/lib/contracts/generators/query-factory.generator.ts
+function generateQueryFactory(ctx) {
+  const {
+    featureName,
+    featureNameCamel,
+    featureNameUpperSnake,
+    apiServices,
+    endpoint
+  } = ctx;
+  const primaryService = apiServices[0];
+  const config = primaryService ? API_SERVICE_CONFIG[primaryService] : null;
+  const baseUrlVar = config?.configReturn.baseUrl ?? "baseUrl";
+  const apiKeyVar = config?.configReturn.apiKey ?? "apiKey";
+  const pathParams = extractPathParams3(endpoint.path);
+  const methodParams = pathParams.map((p) => `${p}: string`).join(", ");
+  const content = `import {
+  SESSION_REQUEST_HEADERS_WITH_AUTH,
+  SessionRequestHeadersWithAuthFactory,
+} from "@/common/security/session/services/sessionUserRequest.provider";
+import { TSREST_INIT_CLIENT_SERVICE } from "@/common/ts-rest/tsrestclient.service";
+import { TsRestInitClient } from "@/common/ts-rest/types";
+
+import { ${featureName}Config } from "../config/${featureNameCamel}.config";
+import { ${featureName}ExternalContract } from "../${featureNameCamel}.external.contract";
+
+export const ${featureNameUpperSnake}_QUERY = "${featureNameUpperSnake}_QUERY";
+
+export type ${featureName}Query = ReturnType<typeof create${featureName}QueryFactory>;
+
+export const ${featureNameCamel}QueryProvider = {
+  provide: ${featureNameUpperSnake}_QUERY,
+  useFactory: create${featureName}QueryFactory,
+  inject: [
+    ${featureName}Config,
+    SESSION_REQUEST_HEADERS_WITH_AUTH,
+    TSREST_INIT_CLIENT_SERVICE,
+  ],
+};
+
+export function create${featureName}QueryFactory(
+  configService: ${featureName}Config,
+  getRequestHeaders: SessionRequestHeadersWithAuthFactory,
+  initClient: TsRestInitClient,
+) {
+  function ${featureNameCamel}Query(${methodParams}) {
+    const { ${baseUrlVar}, ${apiKeyVar} } = configService.get${featureName}Config();
+
+    const client = initClient(${featureName}ExternalContract, {
+      baseUrl: ${baseUrlVar},
+    });
+
+    return client.${endpoint.name}({
+      params: {
+        // TODO: Map path params from contract to external API
+        ${pathParams.map((p) => `// ${p},`).join("\n        ")}
+      },
+      body: {
+        // TODO: Map request body if needed
+      },
+      headers: getRequestHeaders({ apiKey: ${apiKeyVar} }),
+    });
+  }
+
+  return ${featureNameCamel}Query;
+}
+`;
+  return {
+    path: `service/${featureNameCamel}Query.factory.ts`,
+    content,
+    isComplete: false
+    // Has TODOs
+  };
+}
+function extractPathParams3(path) {
+  const matches = path.match(/:(\w+)/g);
+  if (!matches) return [];
+  return matches.map((m) => m.slice(1));
+}
+
+// src/lib/contracts/generators/external-contract.generator.ts
+function generateExternalContract(ctx) {
+  const { featureName, featureNameCamel, apiServices, endpoint } = ctx;
+  const apiComment = apiServices.length > 0 ? `// API: ${apiServices.join(", ")} (see config/${featureNameCamel}.config.ts for reference)` : "// API: (not specified in metadata)";
+  const content = `// TODO: Define external API contract
+${apiComment}
+// Reference: src/domains/serviceExecution/skipContract/skipContract.external.contract.ts
+
+import { initContract } from "@ts-rest/core";
+import { z } from "zod";
+import { Headers } from "@/common/contants/headers.contants";
+
+const c = initContract();
+
+export const ${featureName}ExternalContract = c.router({
+  ${endpoint.name}: {
+    method: "${endpoint.method}",
+    path: "/v1/...", // TODO: External API path
+    pathParams: z.object({
+      // TODO: Define path params for external API
+    }),
+    headers: z.object({
+      [Headers.AUTHORIZATION]: z.string(),
+      [Headers.X_GATEWAY_APIKEY]: z.string(),
+      [Headers.X_BU_CODE]: z.string(),
+    }),
+    body: z.object({
+      // TODO: External API body schema
+    }),
+    responses: {
+      200: z.object({
+        // TODO: Success response schema
+      }),
+      400: z.object({
+        status: z.number(),
+        message: z.string().nullable(),
+      }),
+    },
+  },
+});
+`;
+  return {
+    path: `${featureNameCamel}.external.contract.ts`,
+    content,
+    isComplete: false
+    // Has TODOs
+  };
+}
+
+// src/lib/contracts/generators/e2e-test.generator.ts
+function generateE2eTest(ctx) {
+  const {
+    featureName,
+    featureNameCamel,
+    apiServices,
+    endpoint,
+    permissionConstant,
+    successStatus
+  } = ctx;
+  const primaryService = apiServices[0];
+  const config = primaryService ? API_SERVICE_CONFIG[primaryService] : null;
+  const mockBaseUrl = config && primaryService ? `https://mock-${primaryService.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "")}-api` : "https://mock-api";
+  const pathParams = extractPathParams4(endpoint.path);
+  const testPath = endpoint.path.replace(
+    /:(\w+)/g,
+    (_, param) => `\${${param.toUpperCase()}}`
+  );
+  const fixtureConstants = pathParams.map(
+    (p) => `  const ${p.toUpperCase()} = "12345"; // TODO: Use appropriate test value`
+  ).join("\n");
+  const permissionCamel = permissionConstant.toLowerCase().replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+  const content = `import { INestApplication } from "@nestjs/common";
+import { JwtService } from "@nestjs/jwt";
+import {
+  TEST_ROLES,
+  initServerApp,
+  mockExpiredToken,
+  mockToken,
+} from "src/test/mock/mock.utils";
+import request from "supertest";
+import {
+  afterAll,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  vi,
+} from "vitest";
+
+import { Headers } from "@/common/contants/headers.contants";
+import { BACK_PARAMETERS } from "@/test/mock/backParameters";
+import { getCookieHeader } from "@/test/utils/test.utils";
+
+describe("${featureName}Controller (e2e)", () => {
+  let app: INestApplication;
+  let jwtService: JwtService;
+  let mock${featureName}Fn: ReturnType<typeof vi.fn>;
+  let mockInitClient: ReturnType<typeof vi.fn>;
+  let mockGetExternalParametersFn: ReturnType<typeof vi.fn>;
+
+${fixtureConstants}
+
+  beforeAll(async () => {
+    mock${featureName}Fn = vi.fn();
+    mockGetExternalParametersFn = vi.fn();
+    mockGetExternalParametersFn.mockResolvedValue(BACK_PARAMETERS);
+
+    mockInitClient = vi.fn().mockReturnValue({
+      ${endpoint.name}: mock${featureName}Fn,
+      getExternalParameters: mockGetExternalParametersFn,
+    });
+
+    app = await initServerApp(mockInitClient);
+    jwtService = app.get(JwtService);
+    await app.listen(0);
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  beforeEach(() => {
+    mock${featureName}Fn.mockReset();
+    mockInitClient.mockClear();
+  });
+
+  const verifyApiHeaders = () => {
+    expect(mockInitClient).toHaveBeenCalled();
+    expect(mockInitClient.mock.calls[0][1].baseUrl).toBe("${mockBaseUrl}");
+    expect(mock${featureName}Fn).toHaveBeenCalled();
+    expect(
+      mock${featureName}Fn.mock.calls[0][0].headers[Headers.X_GATEWAY_APIKEY],
+    ).toBe("see"); // TODO: Verify expected API key
+    expect(
+      mock${featureName}Fn.mock.calls[0][0].headers[Headers.AUTHORIZATION],
+    ).toBe("Bearer token");
+    expect(mock${featureName}Fn.mock.calls[0][0].headers[Headers.X_BU_CODE]).toBe(
+      "LMES",
+    );
+  };
+
+  describe.each(TEST_ROLES)(
+    "User with $role role",
+    ({ roleValue, ${permissionCamel} }) => {
+      it("${endpoint.method} Valid request: ${successStatus}", async () => {
+        mockToken(jwtService, roleValue);
+
+        if (${permissionCamel}) {
+          mock${featureName}Fn.mockResolvedValue({ status: ${successStatus} });
+        }
+
+        const response = await request(app.getHttpServer())
+          .${endpoint.method.toLowerCase()}(\`${testPath}\`)
+          .send({}) // TODO: Add valid request body
+          .set("x-kobi-authentication-cookie-name", "ahs-operator-portal.jwt")
+          .set("cookie", getCookieHeader("token", "ES"));
+
+        expect(response.status).toBe(${permissionCamel} ? ${successStatus} : 403);
+
+        if (${permissionCamel}) {
+          expect(mock${featureName}Fn).toHaveBeenCalled();
+          // TODO: Verify body transformation
+          verifyApiHeaders();
+        } else {
+          expect(mock${featureName}Fn).not.toHaveBeenCalled();
+        }
+      });
+
+      it("${endpoint.method} Invalid request: 400", async () => {
+        mockToken(jwtService, roleValue);
+        if (${permissionCamel}) {
+          mock${featureName}Fn.mockResolvedValue({ status: 400 });
+        }
+
+        const response = await request(app.getHttpServer())
+          .${endpoint.method.toLowerCase()}(\`${testPath}\`)
+          .send({}) // TODO: Add invalid request body
+          .set("x-kobi-authentication-cookie-name", "ahs-operator-portal.jwt")
+          .set("cookie", getCookieHeader("token", "ES"));
+
+        if (${permissionCamel}) {
+          expect(response.status).toBe(400);
+          expect(mock${featureName}Fn).toHaveBeenCalled();
+        } else {
+          expect(response.status).toBe(403);
+          expect(mock${featureName}Fn).not.toHaveBeenCalled();
+        }
+      });
+
+      it("${endpoint.method} Unauthorized: 401", async () => {
+        mockExpiredToken(jwtService);
+
+        const response = await request(app.getHttpServer())
+          .${endpoint.method.toLowerCase()}(\`${testPath}\`)
+          .send({})
+          .set("x-kobi-authentication-cookie-name", "ahs-operator-execution.jwt")
+          .set("cookie", getCookieHeader("token", "ES"));
+
+        expect(response.status).toBe(401);
+        expect(mock${featureName}Fn).not.toHaveBeenCalled();
+      });
+    },
+  );
+});
+`;
+  return {
+    path: `controller/__tests__/${featureNameCamel}.controller.e2e.spec.ts`,
+    content,
+    isComplete: false
+    // Has TODOs
+  };
+}
+function extractPathParams4(path) {
+  const matches = path.match(/:(\w+)/g);
+  if (!matches) return [];
+  return matches.map((m) => m.slice(1));
+}
+
+// src/lib/contracts/generators/types.generator.ts
+function generateTypes(ctx) {
+  const { featureName, featureNameCamel } = ctx;
+  const content = `// TODO: Define types specific to ${featureName}
+// These types are for internal use within this feature
+
+/**
+ * Request payload after transformation (if different from contract)
+ */
+export interface ${featureName}Request {
+  // TODO: Define internal request type
+}
+
+/**
+ * Response type from external API (if different from contract response)
+ */
+export interface ${featureName}ExternalResponse {
+  // TODO: Define external API response type
+}
+`;
+  return {
+    path: `${featureNameCamel}.types.ts`,
+    content,
+    isComplete: false
+    // Has TODOs
+  };
+}
+
+// src/lib/contracts/generators/index.ts
+function generateNestJsFeature(endpoint, options) {
+  const errors = [];
+  const baseName = options.featureName ?? endpoint.name;
+  const featureName = toCase(baseName, "pascal");
+  const featureNameCamel = toCase(baseName, "camel");
+  const featureNameUpperSnake = toCase(baseName, "snake");
+  const featureNameKebab = toCase(baseName, "kebab");
+  const apiServices = endpoint.metadata?.bff?.apiServices ?? [];
+  const permissionValue = endpoint.metadata?.requiredPermission ?? "NO_PERMISSION";
+  const permissionConstant = toPermissionConstant(permissionValue);
+  const ctx = {
+    featureName,
+    featureNameCamel,
+    featureNameUpperSnake,
+    featureNameKebab,
+    contractName: options.contractName,
+    contractsLib: options.contractsLib,
+    endpoint,
+    apiServices,
+    permissionConstant,
+    successStatus: getSuccessStatus(void 0)
+    // TODO: pass responses from endpoint
+  };
+  const files = [
+    generateModule(ctx),
+    generateController(ctx),
+    generateConfig(ctx),
+    generateService(ctx),
+    generateQueryFactory(ctx),
+    generateExternalContract(ctx),
+    generateE2eTest(ctx),
+    generateTypes(ctx)
+  ];
+  return { files, errors };
+}
+function summarizeGeneration(result) {
+  const complete = result.files.filter((f) => f.isComplete);
+  const skeleton = result.files.filter((f) => !f.isComplete);
+  const lines = [];
+  if (complete.length > 0) {
+    lines.push(`\u2705 Complete files (${complete.length}):`);
+    for (const file of complete) {
+      lines.push(`   - ${file.path}`);
+    }
+  }
+  if (skeleton.length > 0) {
+    lines.push(`\u{1F4DD} Skeleton files with TODOs (${skeleton.length}):`);
+    for (const file of skeleton) {
+      lines.push(`   - ${file.path}`);
+    }
+  }
+  if (result.errors.length > 0) {
+    lines.push(`\u274C Errors (${result.errors.length}):`);
+    for (const error of result.errors) {
+      lines.push(`   - ${error}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/lint/checkers/contracts/index.ts
+var contractsChecker = {
+  name: "contracts",
+  rules: getRulesByCategory("contracts"),
+  async check(ctx) {
+    const results = [];
+    const configResult = loadConfig(ctx.cwd);
+    if (!configResult.success) {
+      return [];
+    }
+    const config = configResult.config;
+    if (config.project.type !== "contracts-lib") {
+      return [];
+    }
+    const permissionsConfig = getPermissionsConfig(config);
+    let validPermissions = [];
+    let permissionKeyToValue;
+    if (permissionsConfig) {
+      const sourcePath = resolveConfigPath(ctx.cwd, permissionsConfig.source);
+      const permissionsResult = extractValues(sourcePath, permissionsConfig);
+      if (permissionsResult.success) {
+        validPermissions = permissionsResult.values;
+        permissionKeyToValue = permissionsResult.keyToValue;
+      } else {
+        results.push({
+          ruleId: "CTR-005",
+          severity: "warning",
+          message: `Failed to load permissions: ${permissionsResult.error}`,
+          file: permissionsConfig.source,
+          suggestion: "Check lint.contracts.metadata.permissions config in .hexa-ts-kit.yaml"
+        });
+      }
+    }
+    const apiServicesConfig = getApiServicesConfig(config);
+    let validApiServices = [];
+    if (apiServicesConfig) {
+      const sourcePath = resolveConfigPath(ctx.cwd, apiServicesConfig.source);
+      const apiServicesResult = extractValues(sourcePath, apiServicesConfig);
+      if (apiServicesResult.success) {
+        validApiServices = apiServicesResult.values;
+      } else {
+        results.push({
+          ruleId: "CTR-006",
+          severity: "warning",
+          message: `Failed to load apiServices: ${apiServicesResult.error}`,
+          file: apiServicesConfig.source,
+          suggestion: "Check lint.contracts.metadata.apiServices config in .hexa-ts-kit.yaml"
+        });
+      }
+    }
+    const parseResult = await parseContracts(ctx.cwd);
+    if (!parseResult.success) {
+      results.push({
+        ruleId: "CTR-001",
+        severity: "error",
+        message: `Failed to parse contracts: ${parseResult.error}`,
+        file: ctx.cwd
+      });
+      return results;
+    }
+    const disabledRules = getDisabledRules(config);
+    const validationResult = validateContracts(parseResult.contracts, {
+      validPermissions,
+      validApiServices,
+      permissionKeyToValue
+    });
+    for (const issue of validationResult.issues) {
+      if (disabledRules.includes(issue.rule)) {
+        continue;
+      }
+      results.push({
+        ruleId: issue.rule,
+        severity: issue.severity,
+        message: issue.message,
+        file: issue.filePath,
+        line: issue.line,
+        suggestion: issue.suggestion
+      });
+    }
+    return results;
+  }
+};
+
+// src/lint/reporters/console.ts
+import pc from "picocolors";
+var severityColors = {
+  error: pc.red,
+  warning: pc.yellow,
+  info: pc.blue
+};
+var severityIcons = {
+  error: "\u2716",
+  warning: "\u26A0",
+  info: "\u2139"
+};
+function formatConsole(results) {
+  if (results.length === 0) {
+    return pc.green("\u2713 No issues found");
+  }
+  const byFile = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    const existing = byFile.get(result.file) ?? [];
+    existing.push(result);
+    byFile.set(result.file, existing);
+  }
+  const lines = [];
+  for (const [file, fileResults] of byFile) {
+    lines.push("");
+    lines.push(pc.underline(file));
+    for (const result of fileResults) {
+      const color = severityColors[result.severity];
+      const icon = severityIcons[result.severity];
+      const location = result.line !== void 0 ? `:${result.line}:${result.column ?? 0}` : "";
+      lines.push(
+        `  ${color(icon)} ${result.message} ${pc.dim(`[${result.ruleId}]`)}`
+      );
+      if (result.suggestion) {
+        lines.push(`    ${pc.dim("\u2192")} ${pc.cyan(result.suggestion)}`);
+      }
+    }
+  }
+  const errorCount = results.filter((r) => r.severity === "error").length;
+  const warningCount = results.filter((r) => r.severity === "warning").length;
+  const infoCount = results.filter((r) => r.severity === "info").length;
+  lines.push("");
+  lines.push(
+    pc.bold(
+      `${pc.red(`${errorCount} error${errorCount !== 1 ? "s" : ""}`)}, ${pc.yellow(`${warningCount} warning${warningCount !== 1 ? "s" : ""}`)}, ${pc.blue(`${infoCount} info`)}`
+    )
+  );
+  return lines.join("\n");
+}
+function formatSummary(results) {
+  return {
+    errors: results.filter((r) => r.severity === "error").length,
+    warnings: results.filter((r) => r.severity === "warning").length,
+    info: results.filter((r) => r.severity === "info").length,
+    total: results.length
+  };
+}
+
+// src/commands/lint.ts
+var contractsLibCheckers = [contractsChecker];
+function detectProjectType(cwd) {
+  const configResult = loadConfig(cwd);
+  if (!configResult.success) {
+    return {
+      type: null,
+      checkers: [],
+      supported: false,
+      message: "No .hexa-ts-kit.yaml found. Skipping lint."
+    };
+  }
+  const projectType = configResult.config.project.type;
+  switch (projectType) {
+    case "contracts-lib":
+      return {
+        type: "contracts-lib",
+        checkers: contractsLibCheckers,
+        supported: true
+      };
+    case "vue-frontend":
+      return {
+        type: "vue-frontend",
+        checkers: [],
+        supported: false,
+        message: "vue-frontend lint not yet implemented. Skipping. (Coming soon)"
+      };
+    case "nestjs-bff":
+      return {
+        type: "nestjs-bff",
+        checkers: [],
+        supported: false,
+        message: "nestjs-bff lint not yet implemented. Skipping. (Coming soon)"
+      };
+    default:
+      return {
+        type: null,
+        checkers: [],
+        supported: false,
+        message: `Unknown project type: ${projectType}. Valid types: contracts-lib, vue-frontend, nestjs-bff`
+      };
+  }
+}
+function getChangedFiles(cwd) {
+  try {
+    const output = execSync("git diff --name-only HEAD", {
+      cwd,
+      encoding: "utf-8"
+    });
+    const stagedOutput = execSync("git diff --name-only --cached", {
+      cwd,
+      encoding: "utf-8"
+    });
+    const allFiles = [...output.split("\n"), ...stagedOutput.split("\n")].filter(Boolean).filter((f) => f.endsWith(".ts") || f.endsWith(".vue"));
+    return [...new Set(allFiles)];
+  } catch {
+    return [];
+  }
+}
+async function lintCore(options) {
+  const cwd = resolve2(options.path || ".");
+  const projectConfig = detectProjectType(cwd);
+  if (!projectConfig.supported) {
+    return {
+      success: true,
+      // Not an error, just not supported yet
+      command: "lint",
+      projectType: projectConfig.type,
+      message: projectConfig.message,
+      results: [],
+      summary: { errors: 0, warnings: 0, info: 0, total: 0 }
+    };
+  }
+  let files = [];
+  if (options.changed) {
+    files = getChangedFiles(cwd);
+    if (files.length === 0) {
+      return {
+        success: true,
+        command: "lint",
+        projectType: projectConfig.type,
+        message: "No changed files to lint",
+        files: [],
+        results: [],
+        summary: { errors: 0, warnings: 0, info: 0, total: 0 }
+      };
+    }
+  }
+  let checkersToRun = projectConfig.checkers;
+  if (options.rules) {
+    const prefixes = options.rules.split(",").map((r) => r.trim().toUpperCase());
+    checkersToRun = checkersToRun.filter(
+      (checker) => checker.rules.some(
+        (rule) => prefixes.some((p) => rule.startsWith(p))
+      )
+    );
+  }
+  const allResults = [];
+  for (const checker of checkersToRun) {
+    const results = await checker.check({ cwd, files });
+    if (options.changed && files.length > 0) {
+      const filteredResults2 = results.filter(
+        (r) => files.some((f) => r.file.endsWith(f))
+      );
+      allResults.push(...filteredResults2);
+    } else {
+      allResults.push(...results);
+    }
+  }
+  const filteredResults = options.quiet ? allResults.filter((r) => r.severity === "error") : allResults;
+  const summary = formatSummary(allResults);
+  return {
+    success: summary.errors === 0,
+    command: "lint",
+    projectType: projectConfig.type,
+    files: options.changed ? files : void 0,
+    results: filteredResults,
+    summary
+  };
+}
+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(`Project type: ${projectConfig.type ?? "not configured"}`);
+    console.log(
+      `Checkers: ${projectConfig.checkers.map((c) => c.name).join(", ") || "none"}`
+    );
+  }
+  const result = await lintCore({
+    path: targetPath,
+    changed: options.changed,
+    rules: options.rules,
+    quiet: options.quiet
+  });
+  if (options.format === "json") {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    if (result.message) {
+      console.log(result.message);
+    } else {
+      console.log(formatConsole(result.results));
+    }
+  }
+  if (options.debug) {
+    const elapsed = (performance.now() - startTime).toFixed(0);
+    console.log(`
+Completed in ${elapsed}ms`);
+  }
+  process.exit(result.summary.errors > 0 ? 1 : 0);
+}
+
+// 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 fg8 from "fast-glob";
+import matter from "gray-matter";
+import { minimatch } from "minimatch";
+function expandPath(p) {
+  if (p.startsWith("~")) {
+    return p.replace("~", process.env.HOME || "");
+  }
+  return p;
+}
+function getChangedFiles2(cwd) {
+  try {
+    const output = execSync2("git diff --name-only HEAD", {
+      cwd,
+      encoding: "utf-8"
+    });
+    const stagedOutput = execSync2("git diff --name-only --cached", {
+      cwd,
+      encoding: "utf-8"
+    });
+    return [...output.split("\n"), ...stagedOutput.split("\n")].filter(Boolean).filter((f) => f.endsWith(".ts") || f.endsWith(".vue"));
+  } catch {
+    return [];
+  }
+}
+function loadKnowledgeMappings(knowledgePath) {
+  const expandedPath = expandPath(knowledgePath);
+  if (!existsSync5(expandedPath)) {
+    return [];
+  }
+  const knowledgeFiles = fg8.sync("**/*.knowledge.md", {
+    cwd: expandedPath,
+    absolute: true
+  });
+  const mappings = [];
+  for (const file of knowledgeFiles) {
+    try {
+      const content = readFileSync4(file, "utf-8");
+      const { data } = matter(content);
+      if (data.match) {
+        mappings.push({
+          name: data.name || basename4(file, ".knowledge.md"),
+          path: file,
+          match: data.match,
+          description: data.description
+        });
+      }
+    } catch {
+    }
+  }
+  return mappings;
+}
+function matchFileToKnowledges(file, mappings) {
+  const results = [];
+  const fileName = basename4(file);
+  for (const mapping of mappings) {
+    if (minimatch(fileName, mapping.match) || minimatch(file, mapping.match)) {
+      results.push({
+        file,
+        knowledge: mapping.name,
+        path: mapping.path
+      });
+    }
+  }
+  return results;
+}
+var DEFAULT_KNOWLEDGE_PATH = "~/.claude/marketplace/shared/knowledge";
+async function analyzeCore(options) {
+  const cwd = process.cwd();
+  const knowledgePath = options.knowledgePath || DEFAULT_KNOWLEDGE_PATH;
+  let filesToAnalyze = options.files || [];
+  if (options.changed) {
+    filesToAnalyze = getChangedFiles2(cwd);
+  }
+  if (filesToAnalyze.length === 0) {
+    return {
+      success: true,
+      command: "analyze",
+      message: "No files to analyze",
+      files: [],
+      knowledges: []
+    };
+  }
+  const mappings = loadKnowledgeMappings(knowledgePath);
+  if (mappings.length === 0) {
+    return {
+      success: false,
+      command: "analyze",
+      error: `No knowledge files with 'match' pattern found in ${knowledgePath}`,
+      files: filesToAnalyze,
+      knowledges: []
+    };
+  }
+  const allResults = [];
+  for (const file of filesToAnalyze) {
+    const matches = matchFileToKnowledges(file, mappings);
+    allResults.push(...matches);
+  }
+  return {
+    success: true,
+    command: "analyze",
+    files: filesToAnalyze,
+    knowledges: allResults,
+    availableMappings: mappings.length
+  };
+}
+async function analyzeCommand(files = [], options) {
+  const result = await analyzeCore({
+    files,
+    changed: options.changed,
+    knowledgePath: options.knowledgePath
+  });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+// 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";
+function toPascalCase(str) {
+  return str.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+function toCamelCase(str) {
+  const pascal = toPascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function generateVueFeature(featurePath) {
+  const featureName = basename5(featurePath);
+  const pascalName = toPascalCase(featureName);
+  const camelName = toCamelCase(featureName);
+  return [
+    {
+      path: `${featurePath}/${pascalName}.vue`,
+      content: `<script setup lang="ts">
+import { use${pascalName} } from './${camelName}.composable';
+
+const { /* state and methods */ } = use${pascalName}();
+</script>
+
+<template>
+  <div class="${featureName}">
+    <!-- Template -->
+  </div>
+</template>
+`,
+      knowledge: "vue-component",
+      rules: ["COL-001", "VUE-001"]
+    },
+    {
+      path: `${featurePath}/${camelName}.composable.ts`,
+      content: `import { ref, computed } from 'vue';
+import { ${camelName}Rules } from './${camelName}.rules';
+import type { ${pascalName}State } from './${camelName}.types';
+
+export function use${pascalName}() {
+  // State
+
+  // Computed
+
+  // Methods
+
+  return {
+    // Expose state and methods
+  };
+}
+`,
+      knowledge: "vue-composable",
+      rules: ["COL-002", "NAM-002", "NAM-003"]
+    },
+    {
+      path: `${featurePath}/${camelName}.rules.ts`,
+      content: `// Pure functions only - no framework imports, no side effects
+
+export class ${pascalName}Rules {
+  // Validation, calculation, transformation functions
+
+  static validate(input: unknown): boolean {
+    // Implement validation logic
+    return true;
+  }
+}
+
+export const ${camelName}Rules = ${pascalName}Rules;
+`,
+      knowledge: "vue-rules",
+      rules: ["RUL-001", "RUL-002", "NAM-008"]
+    },
+    {
+      path: `${featurePath}/${camelName}.types.ts`,
+      content: `export interface ${pascalName}State {
+  // Define state types
+}
+
+export interface ${pascalName}Props {
+  // Define component props
+}
+`,
+      knowledge: "typescript-types",
+      rules: ["COL-010", "NAM-005"]
+    },
+    {
+      path: `${featurePath}/${camelName}.query.ts`,
+      content: `import { useQuery, useMutation } from '@tanstack/vue-query';
+
+export function use${pascalName}Query() {
+  // Implement TanStack Query hooks
+}
+`,
+      knowledge: "tanstack-query",
+      rules: ["NAM-007"]
+    },
+    {
+      path: `${featurePath}/${camelName}.translations.ts`,
+      content: `export const ${camelName}Translations = {
+  fr: {
+    // French translations
+  },
+  en: {
+    // English translations
+  },
+} as const;
+`,
+      knowledge: "translations",
+      rules: ["COL-011", "NAM-009"]
+    },
+    {
+      path: `${featurePath}/__tests__/${camelName}.rules.test.ts`,
+      content: `import { describe, it, expect } from 'vitest';
+import { ${pascalName}Rules } from '../${camelName}.rules';
+
+describe('${pascalName}Rules', () => {
+  describe('validate', () => {
+    it('should validate correct input', () => {
+      expect(${pascalName}Rules.validate({})).toBe(true);
+    });
+  });
+});
+`,
+      knowledge: "testing-rules",
+      rules: ["COL-004"]
+    }
+  ];
+}
+function generateNestJSFeature(featurePath) {
+  const featureName = basename5(featurePath);
+  const pascalName = toPascalCase(featureName);
+  const camelName = toCamelCase(featureName);
+  return [
+    {
+      path: `${featurePath}/${camelName}.module.ts`,
+      content: `import { Module } from '@nestjs/common';
+import { ${pascalName}Controller } from './${camelName}.controller';
+import { ${pascalName}Service } from './${camelName}.service';
+
+@Module({
+  controllers: [${pascalName}Controller],
+  providers: [${pascalName}Service],
+  exports: [${pascalName}Service],
+})
+export class ${pascalName}Module {}
+`,
+      knowledge: "nestjs-module"
+    },
+    {
+      path: `${featurePath}/${camelName}.controller.ts`,
+      content: `import { Controller, Get, Post, Body, Param } from '@nestjs/common';
+import { ${pascalName}Service } from './${camelName}.service';
+
+@Controller('${featureName}')
+export class ${pascalName}Controller {
+  constructor(private readonly ${camelName}Service: ${pascalName}Service) {}
+
+  @Get()
+  findAll() {
+    return this.${camelName}Service.findAll();
+  }
+}
+`,
+      knowledge: "nestjs-controller"
+    },
+    {
+      path: `${featurePath}/${camelName}.service.ts`,
+      content: `import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class ${pascalName}Service {
+  findAll() {
+    // Implement service logic
+    return [];
+  }
+}
+`,
+      knowledge: "nestjs-service"
+    },
+    {
+      path: `${featurePath}/${camelName}.types.ts`,
+      content: `export interface ${pascalName}Entity {
+  id: string;
+  // Define entity properties
+}
+
+export interface Create${pascalName}Dto {
+  // Define creation DTO
+}
+`,
+      knowledge: "typescript-types"
+    },
+    {
+      path: `${featurePath}/__tests__/${camelName}.controller.e2e.spec.ts`,
+      content: `import { Test, TestingModule } from '@nestjs/testing';
+import { ${pascalName}Controller } from '../${camelName}.controller';
+import { ${pascalName}Service } from '../${camelName}.service';
+
+describe('${pascalName}Controller', () => {
+  let controller: ${pascalName}Controller;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [${pascalName}Controller],
+      providers: [${pascalName}Service],
+    }).compile();
+
+    controller = module.get<${pascalName}Controller>(${pascalName}Controller);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});
+`,
+      knowledge: "nestjs-testing"
+    }
+  ];
+}
+function generatePlaywrightFeature(featurePath) {
+  const featureName = basename5(featurePath);
+  const pascalName = toPascalCase(featureName);
+  const camelName = toCamelCase(featureName);
+  return [
+    {
+      path: `${featurePath}/${camelName}.spec.ts`,
+      content: `import { test, expect } from '@playwright/test';
+import { ${pascalName}Page } from './${camelName}.page';
+
+test.describe('${pascalName}', () => {
+  test('should load correctly', async ({ page }) => {
+    const ${camelName}Page = new ${pascalName}Page(page);
+    await ${camelName}Page.goto();
+    // Add assertions
+  });
+});
+`,
+      knowledge: "playwright-spec"
+    },
+    {
+      path: `${featurePath}/${camelName}.page.ts`,
+      content: `import type { Page, Locator } from '@playwright/test';
+
+export class ${pascalName}Page {
+  readonly page: Page;
+
+  constructor(page: Page) {
+    this.page = page;
+  }
+
+  async goto() {
+    await this.page.goto('/${featureName}');
+  }
+
+  // Add page object methods
+}
+`,
+      knowledge: "playwright-page-object"
+    },
+    {
+      path: `${featurePath}/${camelName}.fixtures.ts`,
+      content: `import { test as base } from '@playwright/test';
+import { ${pascalName}Page } from './${camelName}.page';
+
+export const test = base.extend<{ ${camelName}Page: ${pascalName}Page }>({
+  ${camelName}Page: async ({ page }, use) => {
+    const ${camelName}Page = new ${pascalName}Page(page);
+    await use(${camelName}Page);
+  },
+});
+
+export { expect } from '@playwright/test';
+`,
+      knowledge: "playwright-fixtures"
+    }
+  ];
+}
+var generators = {
+  "vue-feature": generateVueFeature,
+  "nestjs-feature": generateNestJSFeature,
+  "playwright-feature": generatePlaywrightFeature
+};
+function generateNestJsBffFeature(outputPath, contractPath, endpointName, contractsLib) {
+  const parseResult = parseContractFile(contractPath);
+  if ("success" in parseResult && !parseResult.success) {
+    return { success: false, error: parseResult.error };
+  }
+  const contract = parseResult;
+  const endpoint = contract.endpoints.find((e) => e.name === endpointName);
+  if (!endpoint) {
+    return {
+      success: false,
+      error: `Endpoint '${endpointName}' not found in contract. Available: ${contract.endpoints.map((e) => e.name).join(", ")}`
+    };
+  }
+  const result = generateNestJsFeature(endpoint, {
+    contractName: contract.contractName,
+    contractsLib,
+    featureName: endpointName
+  });
+  const files = result.files.map((f) => ({
+    path: join3(outputPath, f.path),
+    content: f.content,
+    knowledge: f.isComplete ? void 0 : "nestjs-bff-skeleton"
+  }));
+  return {
+    success: true,
+    files,
+    summary: summarizeGeneration(result)
+  };
+}
+async function scaffoldCore(options) {
+  const featureType = options.type;
+  if (featureType === "nestjs-bff-feature") {
+    if (!options.contractPath || !options.endpointName) {
+      return {
+        success: false,
+        command: "scaffold",
+        error: "nestjs-bff-feature requires contractPath and endpointName options",
+        availableTypes: [...Object.keys(generators), "nestjs-bff-feature"]
+      };
+    }
+    const contractsLib = options.contractsLib ?? "@adeo/ahs-operator-execution-contracts";
+    const absolutePath2 = resolve3(options.path);
+    const absoluteContractPath = resolve3(options.contractPath);
+    const bffResult = generateNestJsBffFeature(
+      absolutePath2,
+      absoluteContractPath,
+      options.endpointName,
+      contractsLib
+    );
+    if (!bffResult.success || !bffResult.files) {
+      return {
+        success: false,
+        command: "scaffold",
+        error: bffResult.error
+      };
+    }
+    if (options.dryRun) {
+      return {
+        success: true,
+        command: "scaffold",
+        dryRun: true,
+        type: featureType,
+        path: absolutePath2,
+        files: bffResult.files.map((f) => ({
+          path: f.path,
+          knowledge: f.knowledge
+        }))
+      };
+    }
+    const created2 = [];
+    const errors2 = [];
+    for (const file of bffResult.files) {
+      try {
+        const dir = dirname3(file.path);
+        if (!existsSync6(dir)) {
+          mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync(file.path, file.content, "utf-8");
+        created2.push(file.path);
+      } catch (err) {
+        errors2.push({
+          path: file.path,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    return {
+      success: errors2.length === 0,
+      command: "scaffold",
+      type: featureType,
+      path: absolutePath2,
+      created: created2,
+      errors: errors2.length > 0 ? errors2 : void 0
+    };
+  }
+  const generator = generators[featureType];
+  if (!generator) {
+    return {
+      success: false,
+      command: "scaffold",
+      error: `Unknown feature type: ${options.type}`,
+      availableTypes: [...Object.keys(generators), "nestjs-bff-feature"]
+    };
+  }
+  const absolutePath = resolve3(options.path);
+  const files = generator(absolutePath);
+  if (options.dryRun) {
+    return {
+      success: true,
+      command: "scaffold",
+      dryRun: true,
+      type: featureType,
+      path: absolutePath,
+      files: files.map((f) => ({
+        path: f.path,
+        knowledge: f.knowledge,
+        rules: f.rules
+      }))
+    };
+  }
+  const created = [];
+  const errors = [];
+  for (const file of files) {
+    try {
+      const dir = dirname3(file.path);
+      if (!existsSync6(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+      writeFileSync(file.path, file.content, "utf-8");
+      created.push(file.path);
+    } catch (err) {
+      errors.push({
+        path: file.path,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return {
+    success: errors.length === 0,
+    command: "scaffold",
+    type: featureType,
+    path: absolutePath,
+    created,
+    errors: errors.length > 0 ? errors : void 0,
+    knowledges: files.filter((f) => f.knowledge).map((f) => ({
+      path: f.path,
+      knowledge: f.knowledge,
+      rules: f.rules
+    }))
+  };
+}
+async function scaffoldCommand(type, path, options) {
+  const result = await scaffoldCore({
+    type,
+    path,
+    dryRun: options.dryRun,
+    contractPath: options.contractPath,
+    endpointName: options.endpointName,
+    contractsLib: options.contractsLib
+  });
+  console.log(JSON.stringify(result, null, 2));
+  if (!result.success) {
+    process.exit(1);
+  }
+}
+
+export {
+  lintCore,
+  lintCommand,
+  analyzeCore,
+  analyzeCommand,
+  scaffoldCore,
+  scaffoldCommand
+};