@kuckit/cli 1.0.4 → 2.0.1

package/dist/index.d.ts

@@ -18,4 +18,479 @@ interface DiscoverOptions {
 }
 declare function discoverModules(options: DiscoverOptions): Promise<void>;
 //#endregion
-export { addModule, discoverModules, generateModule };
+//#region src/commands/infra/provider.d.ts
+/**
+ * KuckitInfraProvider Interface
+ *
+ * This interface defines the contract that all cloud infrastructure providers must implement.
+ * It enables multi-cloud support by abstracting provider-specific logic behind a common interface.
+ *
+ * Provider packages (e.g., @kuckit/infra-gcp, @kuckit/infra-aws) implement this interface
+ * and are discovered/loaded by the CLI at runtime.
+ *
+ * @example
+ * ```typescript
+ * // In @kuckit/infra-gcp/src/provider.ts
+ * import { defineInfraProvider } from '@kuckit/cli'
+ *
+ * export const provider = defineInfraProvider({
+ *   id: 'gcp',
+ *   label: 'Google Cloud Platform',
+ *   // ... implementation
+ * })
+ * ```
+ */
+/**
+ * Base configuration stored by CLI (provider-agnostic fields)
+ */
+interface BaseInfraConfig {
+  /** Provider ID (e.g., 'gcp', 'aws', 'azure') */
+  provider: string;
+  /** Environment (dev/staging/prod) */
+  env: string;
+  /** Deployment region */
+  region: string;
+  /** Project/app name for resource naming */
+  projectName: string;
+  /** Pulumi stack name */
+  stackName: string;
+  /** ISO timestamp of config creation */
+  createdAt: string;
+  /** ISO timestamp of last update */
+  updatedAt: string;
+}
+/**
+ * Result from an infrastructure operation (init/deploy/destroy)
+ */
+interface InfraOperationResult<TOutputs = Record<string, unknown>> {
+  /** Whether the operation succeeded */
+  success: boolean;
+  /** Human-readable message */
+  message: string;
+  /** Deployment outputs (only on success) */
+  outputs?: TOutputs;
+  /** Error details (only on failure) */
+  error?: {
+    code: string;
+    message: string;
+    details?: string;
+  };
+}
+/**
+ * Options passed to provider init
+ */
+interface ProviderInitOptions {
+  /** Environment to initialize */
+  env: string;
+  /** Target region */
+  region: string;
+  /** Project root directory */
+  projectRoot: string;
+  /** Skip confirmation prompts */
+  yes?: boolean;
+  /** Provider-specific options */
+  providerOptions?: Record<string, unknown>;
+}
+/**
+ * Options passed to provider deploy
+ */
+interface ProviderDeployOptions {
+  /** Environment to deploy */
+  env: string;
+  /** Project root directory */
+  projectRoot: string;
+  /** Preview changes without applying */
+  preview?: boolean;
+  /** Skip Docker build (use existing image) */
+  skipBuild?: boolean;
+  /** Use specific image URL */
+  image?: string;
+  /** Skip confirmation prompts */
+  yes?: boolean;
+}
+/**
+ * Options passed to provider destroy
+ */
+interface ProviderDestroyOptions {
+  /** Environment to destroy */
+  env: string;
+  /** Project root directory */
+  projectRoot: string;
+  /** Only destroy application layer, keep persistent resources */
+  appOnly?: boolean;
+  /** Skip confirmation prompts */
+  force?: boolean;
+}
+/**
+ * Options passed to provider status check
+ */
+interface ProviderStatusOptions {
+  /** Environment to check */
+  env: string;
+  /** Project root directory */
+  projectRoot: string;
+}
+/**
+ * Status information returned by provider
+ */
+interface ProviderStatus {
+  /** Whether infrastructure is deployed */
+  deployed: boolean;
+  /** Current state (initializing/ready/deploying/error) */
+  state: 'initializing' | 'ready' | 'deploying' | 'error' | 'not_initialized';
+  /** Service URL if deployed */
+  serviceUrl?: string;
+  /** Last deployment timestamp */
+  lastDeployment?: string;
+  /** Provider-specific status details */
+  details?: Record<string, unknown>;
+}
+/**
+ * Options for ejecting provider to local packages
+ */
+interface ProviderEjectOptions {
+  /** Target directory for ejected code */
+  targetDir: string;
+  /** Project root directory */
+  projectRoot: string;
+  /** Skip confirmation prompts */
+  force?: boolean;
+}
+/**
+ * The main infrastructure provider interface.
+ *
+ * All provider packages must export a `provider` object implementing this interface.
+ * The CLI discovers and loads providers dynamically based on installed packages.
+ *
+ * @typeParam TConfig - Provider-specific configuration extending BaseInfraConfig
+ * @typeParam TOutputs - Provider-specific deployment outputs
+ */
+interface KuckitInfraProvider<TConfig extends BaseInfraConfig = BaseInfraConfig, TOutputs extends Record<string, unknown> = Record<string, unknown>> {
+  /**
+   * Unique provider identifier (e.g., 'gcp', 'aws', 'azure')
+   * Used for config storage and provider resolution
+   */
+  readonly id: string;
+  /**
+   * Human-readable provider name for display
+   * (e.g., 'Google Cloud Platform', 'Amazon Web Services')
+   */
+  readonly label: string;
+  /**
+   * Provider version (semver)
+   */
+  readonly version: string;
+  /**
+   * Get the infrastructure directory path for this provider.
+   * This is where Pulumi/Terraform/CDK code lives.
+   *
+   * @param projectRoot - The project root directory
+   * @returns Absolute path to infrastructure directory
+   */
+  getInfraDir(projectRoot: string): string;
+  /**
+   * Check if provider prerequisites are met (CLI tools, auth, etc.)
+   *
+   * @returns Object with status and any missing prerequisites
+   */
+  checkPrerequisites(): Promise<{
+    ok: boolean;
+    missing: Array<{
+      name: string;
+      installUrl: string;
+    }>;
+  }>;
+  /**
+   * Initialize base infrastructure for the project.
+   * Creates foundational resources (VPC, registry, database) without deploying the app.
+   *
+   * @param options - Initialization options
+   * @returns Operation result with deployment outputs
+   */
+  init(options: ProviderInitOptions): Promise<InfraOperationResult<TOutputs>>;
+  /**
+   * Deploy the application to the infrastructure.
+   * Builds container image (if needed) and deploys to compute platform.
+   *
+   * @param options - Deployment options
+   * @param config - Current stored configuration
+   * @returns Operation result with deployment outputs
+   */
+  deploy(options: ProviderDeployOptions, config: TConfig): Promise<InfraOperationResult<TOutputs>>;
+  /**
+   * Destroy infrastructure resources.
+   *
+   * @param options - Destroy options
+   * @param config - Current stored configuration
+   * @returns Operation result
+   */
+  destroy(options: ProviderDestroyOptions, config: TConfig): Promise<InfraOperationResult>;
+  /**
+   * Get current infrastructure status.
+   *
+   * @param options - Status options
+   * @param config - Current stored configuration
+   * @returns Current provider status
+   */
+  status(options: ProviderStatusOptions, config: TConfig): Promise<ProviderStatus>;
+  /**
+   * Get provider-specific configuration prompts for init.
+   * Returns questions to ask user during interactive init.
+   *
+   * @param defaults - Any existing config values to use as defaults
+   * @returns Array of prompts for inquirer
+   */
+  getInitPrompts(defaults?: Partial<TConfig>): Promise<Array<{
+    name: string;
+    message: string;
+    type: 'input' | 'select' | 'confirm';
+    default?: string | boolean;
+    choices?: Array<{
+      value: string;
+      label: string;
+    }>;
+    validate?: (value: string) => boolean | string;
+  }>>;
+  /**
+   * Build provider-specific config from user responses.
+   *
+   * @param responses - User responses from init prompts
+   * @param baseConfig - Base config fields
+   * @returns Complete provider config
+   */
+  buildConfig(responses: Record<string, unknown>, baseConfig: Pick<BaseInfraConfig, 'env' | 'region' | 'projectName' | 'stackName'>): TConfig;
+  /**
+   * Optional: Eject provider infrastructure code to local project.
+   * Allows customization of infrastructure beyond provider defaults.
+   *
+   * @param options - Eject options
+   * @returns Operation result
+   */
+  eject?(options: ProviderEjectOptions): Promise<InfraOperationResult>;
+  /**
+   * Optional: Generate Dockerfile for the project.
+   * Providers can include optimized Dockerfile templates.
+   *
+   * @param projectRoot - Project root directory
+   * @returns Dockerfile content or null if using existing
+   */
+  generateDockerfile?(projectRoot: string): Promise<string | null>;
+  /**
+   * Optional: Validate that project structure is compatible with provider.
+   *
+   * @param projectRoot - Project root directory
+   * @returns Validation result with any issues
+   */
+  validateProject?(projectRoot: string): Promise<{
+    valid: boolean;
+    issues: Array<{
+      severity: 'error' | 'warning';
+      message: string;
+    }>;
+  }>;
+}
+/**
+ * Helper to define a provider with type inference.
+ *
+ * @example
+ * ```typescript
+ * export const provider = defineInfraProvider({
+ *   id: 'gcp',
+ *   label: 'Google Cloud Platform',
+ *   version: '1.0.0',
+ *   getInfraDir: (root) => join(root, 'node_modules/@kuckit/infra-gcp/infra'),
+ *   // ... rest of implementation
+ * })
+ * ```
+ */
+declare function defineInfraProvider<TConfig extends BaseInfraConfig = BaseInfraConfig, TOutputs extends Record<string, unknown> = Record<string, unknown>>(provider: KuckitInfraProvider<TConfig, TOutputs>): KuckitInfraProvider<TConfig, TOutputs>;
+/**
+ * Type for the provider module export.
+ * Provider packages should default export this shape.
+ */
+interface KuckitInfraProviderModule<TConfig extends BaseInfraConfig = BaseInfraConfig, TOutputs extends Record<string, unknown> = Record<string, unknown>> {
+  provider: KuckitInfraProvider<TConfig, TOutputs>;
+}
+//#endregion
+//#region src/commands/infra/types.d.ts
+/**
+ * GCP-specific configuration fields
+ */
+interface GcpProviderConfig {
+  /** GCP Project ID */
+  gcpProject: string;
+}
+/**
+ * AWS-specific configuration fields (future)
+ */
+interface AwsProviderConfig {
+  /** AWS Account ID */
+  awsAccountId: string;
+  /** AWS Profile name */
+  awsProfile?: string;
+}
+/**
+ * Azure-specific configuration fields (future)
+ */
+interface AzureProviderConfig {
+  /** Azure Subscription ID */
+  subscriptionId: string;
+  /** Azure Resource Group */
+  resourceGroup: string;
+}
+/**
+ * Union of all provider configs
+ */
+type ProviderConfig = GcpProviderConfig | AwsProviderConfig | AzureProviderConfig;
+/**
+ * Base deployment outputs common to all providers
+ */
+interface BaseDeploymentOutputs {
+  /** Container registry URL */
+  registryUrl: string;
+  /** Service URL after deployment */
+  serviceUrl?: string;
+}
+/**
+ * GCP-specific deployment outputs
+ */
+interface GcpDeploymentOutputs extends BaseDeploymentOutputs {
+  /** Cloud SQL connection name for Cloud SQL Auth Proxy */
+  databaseConnectionName: string;
+  /** Database name inside Cloud SQL instance */
+  databaseName?: string;
+  /** Database user for Cloud SQL */
+  databaseUser?: string;
+  /** Memorystore Redis private IP address */
+  redisHost: string;
+  /** Secret Manager secret IDs */
+  secretIds: {
+    /** Database password secret ID */
+    dbPassword: string;
+    /** Redis AUTH string secret ID */
+    redisAuth: string;
+  };
+  /** Cloud Run Job name for database migrations */
+  migrationJobName?: string;
+}
+/**
+ * AWS-specific deployment outputs (future)
+ */
+interface AwsDeploymentOutputs extends BaseDeploymentOutputs {
+  /** RDS instance endpoint */
+  databaseEndpoint?: string;
+  /** ElastiCache endpoint */
+  redisEndpoint?: string;
+  /** ECS service ARN */
+  ecsServiceArn?: string;
+}
+/**
+ * Azure-specific deployment outputs (future)
+ */
+interface AzureDeploymentOutputs extends BaseDeploymentOutputs {
+  /** Azure SQL server name */
+  sqlServerName?: string;
+  /** Azure Cache for Redis hostname */
+  redisHostname?: string;
+  /** Container Apps URL */
+  containerAppUrl?: string;
+}
+/**
+ * Union of all deployment output types
+ */
+type DeploymentOutputs = GcpDeploymentOutputs | AwsDeploymentOutputs | AzureDeploymentOutputs;
+/**
+ * Supported cloud provider IDs
+ */
+type SupportedProvider = 'gcp' | 'aws' | 'azure';
+/**
+ * CLI config stored in .kuckit/infra.json
+ *
+ * This is an extended version of BaseInfraConfig with additional fields
+ * specific to CLI storage and provider management.
+ */
+interface StoredInfraConfig extends BaseInfraConfig {
+  /**
+   * Provider ID (e.g., 'gcp', 'aws', 'azure')
+   * @override Narrows the base string type to supported providers
+   */
+  provider: SupportedProvider;
+  /**
+   * npm package name of the provider (e.g., '@kuckit/infra-gcp')
+   * Used to load the provider dynamically at runtime.
+   */
+  providerPackage: string;
+  /**
+   * Environment (dev/staging/prod)
+   * @override Narrows to common environments
+   */
+  env: 'dev' | 'staging' | 'prod';
+  /**
+   * Provider-specific configuration.
+   * Contains fields that vary by cloud provider.
+   */
+  providerConfig: ProviderConfig;
+  /**
+   * Optional local infrastructure directory.
+   * Set when provider has been ejected for customization.
+   * If not set, uses provider's bundled infra.
+   */
+  localInfraDir?: string;
+  /**
+   * Deployment outputs from the last successful deployment.
+   * Structure varies by provider.
+   */
+  outputs?: DeploymentOutputs;
+}
+/**
+ * Legacy config format (pre-provider-module)
+ * Used for migration and backward compatibility
+ *
+ * @deprecated Use StoredInfraConfig instead
+ */
+interface LegacyInfraConfig {
+  provider: 'gcp';
+  gcpProject: string;
+  region: string;
+  projectName: string;
+  stackName: string;
+  env: 'dev' | 'prod';
+  outputs?: GcpDeploymentOutputs;
+  createdAt: string;
+  updatedAt: string;
+}
+/**
+ * Check if config is legacy format
+ */
+declare function isLegacyConfig(config: StoredInfraConfig | LegacyInfraConfig): config is LegacyInfraConfig;
+/**
+ * Migrate legacy config to new format
+ */
+declare function migrateLegacyConfig(legacy: LegacyInfraConfig): StoredInfraConfig;
+/**
+ * Check if config is for GCP
+ */
+declare function isGcpConfig(config: StoredInfraConfig): config is StoredInfraConfig & {
+  provider: 'gcp';
+  providerConfig: GcpProviderConfig;
+  outputs?: GcpDeploymentOutputs;
+};
+/**
+ * Check if config is for AWS
+ */
+declare function isAwsConfig(config: StoredInfraConfig): config is StoredInfraConfig & {
+  provider: 'aws';
+  providerConfig: AwsProviderConfig;
+  outputs?: AwsDeploymentOutputs;
+};
+/**
+ * Check if config is for Azure
+ */
+declare function isAzureConfig(config: StoredInfraConfig): config is StoredInfraConfig & {
+  provider: 'azure';
+  providerConfig: AzureProviderConfig;
+  outputs?: AzureDeploymentOutputs;
+};
+//#endregion
+export { type AwsDeploymentOutputs, type AwsProviderConfig, type AzureDeploymentOutputs, type AzureProviderConfig, type BaseDeploymentOutputs, type BaseInfraConfig, type DeploymentOutputs, type GcpDeploymentOutputs, type GcpProviderConfig, type InfraOperationResult, type KuckitInfraProvider, type KuckitInfraProviderModule, type LegacyInfraConfig, type ProviderConfig, type ProviderDeployOptions, type ProviderDestroyOptions, type ProviderEjectOptions, type ProviderInitOptions, type ProviderStatus, type ProviderStatusOptions, type StoredInfraConfig, type SupportedProvider, addModule, defineInfraProvider, discoverModules, generateModule, isAwsConfig, isAzureConfig, isGcpConfig, isLegacyConfig, migrateLegacyConfig };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/commands/generate-module.ts","../src/commands/add-module.ts","../src/commands/discover-module.ts","../src/commands/infra/provider.ts","../src/commands/infra/types.ts"],"sourcesContent":[],"mappings":";UAGU,qBAAA;EAAA,GAAA,EAAA,MAAA;EAwBY,GAAA,EAAA,MAAA;;iBAAA,cAAA,wBAAsC,wBAAwB;;;UCtB1E,gBAAA;EDFA,WAAA,EAAA,OAAA;AAwBV;iBCwMsB,SAAA,+BAAwC,mBAAmB;;;UC9NhE,eAAA;EFFP,IAAA,EAAA,OAAA;EAwBY,WAAA,EAAA,OAAc;;iBEyId,eAAA,UAAyB,kBAAkB;;;;;AFzIjE;;;;;ACwMA;;;;AC9NA;AA+JA;;;;AC3IA;AAoBA;AAkBA;AAgBA;AAkBA;AAcA;AAUA;AAgBA;AAkBiB,UAlIA,eAAA,CAkImB;EACnB;EAAkB,QAAA,EAAA,MAAA;EACjB;EAA0B,GAAA,EAAA,MAAA;EAmCjC;EAFY,MAAA,EAAA,MAAA;EAYR;EAAmD,WAAA,EAAA,MAAA;EAArB;EAAR,SAAA,EAAA,MAAA;EAUpB;EAA+B,SAAA,EAAA,MAAA;EAAuC;EAArB,SAAA,EAAA,MAAA;;;;;AASN,UAhL3C,oBAgL2C,CAAA,WAhLX,MAgLW,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,CAAA;EAS3C;EAA+B,OAAA,EAAA,OAAA;EAAkB;EAAR,OAAA,EAAA,MAAA;EASvB;EAAR,OAAA,CAAA,EA5LhB,QA4LgB;EAMd;EALX,KAAA,CAAA,EAAA;IAD4C,IAAA,EAAA,MAAA;IAmBjC,OAAA,EAAA,MAAA;IACM,OAAA,CAAA,EAAA,MAAA;EAAL,CAAA;;;;;AAmB6B,UAvN1B,mBAAA,CAuN0B;EAUjC;EAF8B,GAAA,EAAA,MAAA;EAAO;EAoB/B,MAAA,EAAA,MAAA;EACC;EAAkB,WAAA,EAAA,MAAA;EACjB;EAA0B,GAAA,CAAA,EAAA,OAAA;EACZ;EAAS,eAAA,CAAA,EA5OtB,MA4OsB,CAAA,MAAA,EAAA,OAAA,CAAA;;;;;AAA+B,UAtOvD,qBAAA,CAsOuD;EAQvD;EACA,GAAA,EAAA,MAAA;EAAkB;EACjB,WAAA,EAAA,MAAA;EAA0B;EAEb,OAAA,CAAA,EAAA,OAAA;EAAS;EAA7B,SAAA,CAAA,EAAA,OAAA;EAAmB;;;;AChT9B;AAQA;AAUA;AAUA;AAA6B,UDoDZ,sBAAA,CCpDY;EAAoB;EAAoB,GAAA,EAAA,MAAA;EAAmB;EASvE,WAAA,EAAA,MAAA;EAUA;EAuBA,OAAA,CAAA,EAAA,OAAA;EAYA;EAYL,KAAA,CAAA,EAAA,OAAA;;;;;AASA,UDTK,qBAAA,CCSY;EAQZ;EAKN,GAAA,EAAA,MAAA;EAkBM;EAaN,WAAA,EAAA,MAAA;;;AAaX;AAeA;AACS,UDxEQ,cAAA,CCwER;EAAoB;EAChB,QAAA,EAAA,OAAA;EAAiB;EAOd,KAAA,EAAA,cAAA,GAAmB,OAAA,GAAS,WAAA,GAAA,OAAoB,GAAA,iBAAiB;EAwBjE;EAAoB,UAAA,CAAA,EAAA,MAAA;EAA8B;EAEjD,cAAA,CAAA,EAAA,MAAA;EACN;EAAoB,OAAA,CAAA,EDjGpB,MCiGoB,CAAA,MAAA,EAAA,OAAA,CAAA;AAQ/B;;;;AAGW,UDtGM,oBAAA,CCsGN;EAAoB;EAQf,SAAA,EAAA,MAAa;EAAS;EAA8B,WAAA,EAAA,MAAA;EAEnD;EACN,KAAA,CAAA,EAAA,OAAA;;;;;;;;;;;UD/FM,oCACA,kBAAkB,kCACjB,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAiCrB;;aAEZ;;;;;;;;;;;;gBAUI,sBAAsB,QAAQ,qBAAqB;;;;;;;;;kBAUjD,+BAA+B,UAAU,QAAQ,qBAAqB;;;;;;;;mBASrE,gCAAgC,UAAU,QAAQ;;;;;;;;kBASnD,+BAA+B,UAAU,QAAQ;;;;;;;;4BASvC,QAAQ,WAAW,QAC5C;;;;;cAKW;;;;;;;;;;;;;yBAaA,qCACC,KAAK,mEACf;;;;;;;;kBASa,uBAAuB,QAAQ;;;;;;;;4CASL;;;;;;;yCAQH;;YAE9B;;;;;;;;;;;;;;;;;;;;iBAkBM,oCACC,kBAAkB,kCACjB,0BAA0B,mCAChC,oBAAoB,SAAS,YAAY,oBAAoB,SAAS;;;;;UAQjE,0CACA,kBAAkB,kCACjB,0BAA0B;YAEjC,oBAAoB,SAAS;;;;;;;AD5TvB,UEYA,iBAAA,CFZe;EA+JV;;;;AC3ItB;AAoBA;AAkBiB,UCtCA,iBAAA,CDsCmB;EAgBnB;EAkBA,YAAA,EAAA,MAAA;EAcA;EAUA,UAAA,CAAA,EAAA,MAAc;AAgB/B;AAkBA;;;AAEkB,UC1HD,mBAAA,CD0HC;EAA0B;EAmCjC,cAAA,EAAA,MAAA;EAFY;EAYR,aAAA,EAAA,MAAA;;;;;AAUiC,KCvKpC,cAAA,GAAiB,iBDuKmB,GCvKC,iBDuKD,GCvKqB,mBDuKrB;;;;AAS9B,UCvKD,qBAAA,CDuKC;EAAgC;EAAkB,WAAA,EAAA,MAAA;EAAR;EAS3C,UAAA,CAAA,EAAA,MAAA;;;;;AASU,UC/KV,oBAAA,SAA6B,qBD+KnB,CAAA;EAMd;EALX,sBAAA,EAAA,MAAA;EAD4C;EAmBjC,YAAA,CAAA,EAAA,MAAA;EACM;EAAL,YAAA,CAAA,EAAA,MAAA;EACV;EASa,SAAA,EAAA,MAAA;EAA+B;EAAR,SAAA,EAAA;IASG;IAUjC,UAAA,EAAA,MAAA;IAF8B;IAAO,SAAA,EAAA,MAAA;EAoB/B,CAAA;EACC;EAAkB,gBAAA,CAAA,EAAA,MAAA;;;;;AAEvB,UC9NK,oBAAA,SAA6B,qBD8NlC,CAAA;EAA6D;EAAS,gBAAA,CAAA,EAAA,MAAA;EAA7B;EAAmB,aAAA,CAAA,EAAA,MAAA;EAQvD;EACA,aAAA,CAAA,EAAA,MAAA;;;;;AAGuB,UC9NvB,sBAAA,SAA+B,qBD8NR,CAAA;EAA7B;EAAmB,aAAA,CAAA,EAAA,MAAA;;;;EChTb,eAAA,CAAA,EAAA,MAAiB;AAQlC;AAUA;AAUA;;AAAiD,KAkErC,iBAAA,GAAoB,oBAlEiB,GAkEM,oBAlEN,GAkE6B,sBAlE7B;;;AASjD;AAUiB,KAwDL,iBAAA,GAxD0B,KAAA,GAAQ,KAAA,GAAA,OAAA;AAuB9C;AAYA;AAYA;;;;AAAoG,UAiBnF,iBAAA,SAA0B,eAjByD,CAAA;EASxF;AAQZ;;;EAoCW,QAAA,EA/BA,iBA+BA;EApCgC;;AAiD3C;AAeA;EACS,eAAA,EAAA,MAAA;EAAoB;;;AAQ7B;EAwBgB,GAAA,EAAA,KAAA,GAAA,SAAW,GAAA,MAAA;EAAS;;;;EAGL,cAAA,EA7Ed,cA6Ec;EAQf;;;;;EAGe,aAAA,CAAA,EAAA,MAAA;EAQf;;;;EAGL,OAAA,CAAA,EAtFA,iBAsFA;;;;;;;;UAzEM,iBAAA;;;;;;;YAON;;;;;;;iBAQK,cAAA,SACP,oBAAoB,8BAChB;;;;iBAOG,mBAAA,SAA4B,oBAAoB;;;;iBAwBhD,WAAA,SAAoB,8BAA8B;;kBAEjD;YACN;;;;;iBAQK,WAAA,SAAoB,8BAA8B;;kBAEjD;YACN;;;;;iBAQK,aAAA,SAAsB,8BAA8B;;kBAEnD;YACN"}

package/dist/index.js

@@ -1,3 +1,3 @@
-import { i as generateModule, r as addModule, t as discoverModules } from "./discover-module-B4oRIuSK.js";
+import { a as isLegacyConfig, i as isGcpConfig, l as addModule, n as isAwsConfig, o as migrateLegacyConfig, r as isAzureConfig, s as discoverModules, t as defineInfraProvider, u as generateModule } from "./provider-DbqTBb6C.js";
 
-export { addModule, discoverModules, generateModule };
+export { addModule, defineInfraProvider, discoverModules, generateModule, isAwsConfig, isAzureConfig, isGcpConfig, isLegacyConfig, migrateLegacyConfig };

package/dist/{discover-module-B4oRIuSK.js → provider-DbqTBb6C.js}

@@ -1016,4 +1016,69 @@ async function discoverModules(options) {
 }
 
 //#endregion
-export { generateModule as i, loadTryLoadKuckitConfig as n, addModule as r, discoverModules as t };
+//#region src/commands/infra/types.ts
+/**
+* Check if config is legacy format
+*/
+function isLegacyConfig(config) {
+	return "gcpProject" in config && !("providerPackage" in config);
+}
+/**
+* Migrate legacy config to new format
+*/
+function migrateLegacyConfig(legacy) {
+	return {
+		provider: "gcp",
+		providerPackage: "@kuckit/infra-gcp",
+		region: legacy.region,
+		projectName: legacy.projectName,
+		stackName: legacy.stackName,
+		env: legacy.env,
+		providerConfig: { gcpProject: legacy.gcpProject },
+		outputs: legacy.outputs,
+		createdAt: legacy.createdAt,
+		updatedAt: legacy.updatedAt
+	};
+}
+/**
+* Check if config is for GCP
+*/
+function isGcpConfig(config) {
+	return config.provider === "gcp";
+}
+/**
+* Check if config is for AWS
+*/
+function isAwsConfig(config) {
+	return config.provider === "aws";
+}
+/**
+* Check if config is for Azure
+*/
+function isAzureConfig(config) {
+	return config.provider === "azure";
+}
+
+//#endregion
+//#region src/commands/infra/provider.ts
+/**
+* Helper to define a provider with type inference.
+*
+* @example
+* ```typescript
+* export const provider = defineInfraProvider({
+*   id: 'gcp',
+*   label: 'Google Cloud Platform',
+*   version: '1.0.0',
+*   getInfraDir: (root) => join(root, 'node_modules/@kuckit/infra-gcp/infra'),
+*   // ... rest of implementation
+* })
+* ```
+*/
+function defineInfraProvider(provider) {
+	return provider;
+}
+
+//#endregion
+export { isLegacyConfig as a, loadTryLoadKuckitConfig as c, isGcpConfig as i, addModule as l, isAwsConfig as n, migrateLegacyConfig as o, isAzureConfig as r, discoverModules as s, defineInfraProvider as t, generateModule as u };
+//# sourceMappingURL=provider-DbqTBb6C.js.map