@runa-ai/runa-cli 0.5.26

package/dist/config/env.d.ts

@@ -0,0 +1,131 @@
+/**
+ * AI HINT: Centralized Environment Configuration
+ * Purpose: Single source of truth for all environment variables with validation
+ * Design: Zod schema validation + type inference
+ *
+ * Benefits:
+ * - Type safety across entire CLI
+ * - Runtime validation at startup
+ * - Clear error messages for missing/invalid env vars
+ * - Easy to test (can override with test values)
+ *
+ * Usage:
+ * ```typescript
+ * import { env } from './config/env';
+ *
+ * const dbUrl = env.DATABASE_URL;  // Type-safe, validated
+ * ```
+ */
+import { z } from 'zod';
+/**
+ * Environment variable schema
+ * Defines all environment variables used by the CLI
+ */
+declare const envSchema: z.ZodObject<{
+    NODE_ENV: z.ZodDefault<z.ZodEnum<{
+        production: "production";
+        test: "test";
+        development: "development";
+    }>>;
+    CI: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<boolean, string | undefined>>;
+    DEBUG: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<boolean, string | undefined>>;
+    DATABASE_URL: z.ZodType<string | undefined, unknown, z.core.$ZodTypeInternals<string | undefined, unknown>>;
+    POSTGRES_PASSWORD: z.ZodOptional<z.ZodString>;
+    POSTGRES_USER: z.ZodDefault<z.ZodString>;
+    POSTGRES_DB: z.ZodDefault<z.ZodString>;
+    POSTGRES_HOST: z.ZodDefault<z.ZodString>;
+    POSTGRES_PORT: z.ZodOptional<z.ZodString>;
+    SUPABASE_URL: z.ZodType<string | undefined, unknown, z.core.$ZodTypeInternals<string | undefined, unknown>>;
+    SUPABASE_ANON_KEY: z.ZodOptional<z.ZodString>;
+    SUPABASE_SERVICE_ROLE_KEY: z.ZodOptional<z.ZodString>;
+    SUPABASE_ACCESS_TOKEN: z.ZodOptional<z.ZodString>;
+    SUPABASE_PROJECT_REF: z.ZodOptional<z.ZodString>;
+    NEXT_PUBLIC_SUPABASE_URL: z.ZodType<string | undefined, unknown, z.core.$ZodTypeInternals<string | undefined, unknown>>;
+    GITHUB_TOKEN: z.ZodOptional<z.ZodString>;
+    GITHUB_APP_ID: z.ZodOptional<z.ZodString>;
+    GITHUB_APP_PRIVATE_KEY: z.ZodOptional<z.ZodString>;
+    GITHUB_INSTALLATION_ID: z.ZodOptional<z.ZodString>;
+    VERCEL_TOKEN: z.ZodOptional<z.ZodString>;
+    VERCEL_PROJECT_ID: z.ZodOptional<z.ZodString>;
+    VERCEL_ORG_ID: z.ZodOptional<z.ZodString>;
+    BASE_URL: z.ZodType<string | undefined, unknown, z.core.$ZodTypeInternals<string | undefined, unknown>>;
+    SKIP_SERVER: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<boolean, string | undefined>>;
+    LOG_LEVEL: z.ZodDefault<z.ZodEnum<{
+        error: "error";
+        debug: "debug";
+        info: "info";
+        warn: "warn";
+    }>>;
+    RUNA_LOG_JSON: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<boolean, string | undefined>>;
+}, z.core.$strip>;
+/**
+ * Parsed and validated environment variables
+ * Type is inferred from the schema
+ */
+export type Env = z.infer<typeof envSchema>;
+/**
+ * Singleton instance of validated environment variables
+ *
+ * Loaded once at module initialization for performance
+ */
+export declare const env: {
+    NODE_ENV: "production" | "test" | "development";
+    CI: boolean;
+    DEBUG: boolean;
+    DATABASE_URL: string | undefined;
+    POSTGRES_USER: string;
+    POSTGRES_DB: string;
+    POSTGRES_HOST: string;
+    SUPABASE_URL: string | undefined;
+    NEXT_PUBLIC_SUPABASE_URL: string | undefined;
+    BASE_URL: string | undefined;
+    SKIP_SERVER: boolean;
+    LOG_LEVEL: "error" | "debug" | "info" | "warn";
+    RUNA_LOG_JSON: boolean;
+    POSTGRES_PASSWORD?: string | undefined;
+    POSTGRES_PORT?: string | undefined;
+    SUPABASE_ANON_KEY?: string | undefined;
+    SUPABASE_SERVICE_ROLE_KEY?: string | undefined;
+    SUPABASE_ACCESS_TOKEN?: string | undefined;
+    SUPABASE_PROJECT_REF?: string | undefined;
+    GITHUB_TOKEN?: string | undefined;
+    GITHUB_APP_ID?: string | undefined;
+    GITHUB_APP_PRIVATE_KEY?: string | undefined;
+    GITHUB_INSTALLATION_ID?: string | undefined;
+    VERCEL_TOKEN?: string | undefined;
+    VERCEL_PROJECT_ID?: string | undefined;
+    VERCEL_ORG_ID?: string | undefined;
+};
+/**
+ * Check if specific environment variables are set
+ * Useful for optional feature detection
+ */
+export declare function hasEnv(...keys: (keyof Env)[]): boolean;
+/**
+ * Get database URL with fallback construction
+ *
+ * Priority:
+ * 1. DATABASE_URL environment variable
+ * 2. Construct from POSTGRES_* variables (with dynamic port detection)
+ *
+ * Zero Hardcode: If POSTGRES_PORT is not set, dynamically detect from:
+ * - runa.config.ts portOffset setting
+ * - supabase/config.toml
+ * - Hash-based port allocation
+ */
+export declare function getDatabaseUrl(): string;
+/**
+ * Check if running in CI environment
+ */
+export declare function isCI(): boolean;
+/**
+ * Check if debug mode is enabled
+ */
+export declare function isDebug(): boolean;
+/**
+ * Sanitize sensitive data from environment variables
+ * Useful for logging
+ */
+export declare function sanitizeEnv(envVars: Partial<Env>): Record<string, string | boolean | undefined>;
+export {};
+//# sourceMappingURL=env.d.ts.map

package/dist/config/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../src/config/env.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAqBxB;;;GAGG;AACH,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqDb,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAuB5C;;;;GAIG;AACH,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAY,CAAC;AAE7B;;;GAGG;AACH,wBAAgB,MAAM,CAAC,GAAG,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,EAAE,GAAG,OAAO,CAKtD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,IAAI,MAAM,CAwBvC;AAED;;GAEG;AACH,wBAAgB,IAAI,IAAI,OAAO,CAE9B;AAED;;GAEG;AACH,wBAAgB,OAAO,IAAI,OAAO,CAEjC;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC,CAoB/F"}

package/dist/constants/versions.d.ts

@@ -0,0 +1,26 @@
+/**
+ * AI HINT: Template Version Constants
+ *
+ * Purpose: Define compatible templates version for CLI
+ * Used by: template-fetcher.ts, init.ts, upgrade.ts
+ *
+ * Version Strategy:
+ * - Templates are versioned independently from SDK
+ * - COMPATIBLE_TEMPLATES_VERSION is the minimum compatible version
+ * - CLI fetches templates from @r06-dev/runa-templates on GitHub Packages
+ */
+/**
+ * Compatible templates version.
+ * This should be updated when templates have breaking changes.
+ */
+export declare const COMPATIBLE_TEMPLATES_VERSION = "0.1.0";
+/**
+ * Templates package name on GitHub Packages.
+ * Published to npm.pkg.github.com (requires NODE_AUTH_TOKEN).
+ */
+export declare const TEMPLATES_PACKAGE_NAME = "@r06-dev/runa-templates";
+/**
+ * GitHub Packages registry URL.
+ */
+export declare const GITHUB_PACKAGES_REGISTRY = "https://npm.pkg.github.com";
+//# sourceMappingURL=versions.d.ts.map

package/dist/constants/versions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"versions.d.ts","sourceRoot":"","sources":["../../src/constants/versions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;GAGG;AACH,eAAO,MAAM,4BAA4B,UAAU,CAAC;AAEpD;;;GAGG;AACH,eAAO,MAAM,sBAAsB,4BAA4B,CAAC;AAEhE;;GAEG;AACH,eAAO,MAAM,wBAAwB,+BAA+B,CAAC"}

package/dist/contracts/envelope.d.ts

@@ -0,0 +1,2 @@
+export { CLI_CONTRACT_VERSION, createSuccessEnvelopeSchema, ErrorEnvelopeSchema, } from '@runa-ai/runa';
+//# sourceMappingURL=envelope.d.ts.map

package/dist/contracts/envelope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelope.d.ts","sourceRoot":"","sources":["../../src/contracts/envelope.ts"],"names":[],"mappings":"AACA,OAAO,EACL,oBAAoB,EACpB,2BAA2B,EAC3B,mBAAmB,GACpB,MAAM,eAAe,CAAC"}

package/dist/errors/catalog.d.ts

@@ -0,0 +1,461 @@
+/**
+ * AI HINT: CLI Error Catalog
+ *
+ * Purpose: Central registry of all CLI error definitions
+ * Philosophy: Industry best practice error handling (pnpm, Vercel, GitHub CLI patterns)
+ *
+ * Benefits:
+ * - Type-safe error creation via createError()
+ * - Consistent error codes (ERR_RUNA_*)
+ * - Categorized exit codes (POSIX-aligned)
+ * - Documentation URLs for each error
+ * - Upgrade-resilient (error definitions separate from detection)
+ *
+ * Usage:
+ *   import { createError, ErrorCode } from '../errors/catalog.js';
+ *   throw createError('CONFIG_NOT_FOUND', { path: 'runa.config.ts' });
+ */
+import { CLIError } from '@runa-ai/runa';
+import { type ExitCode } from './exit-codes.js';
+export interface ErrorDefinition<TParams extends Record<string, unknown> = Record<string, never>> {
+    /** Error code following ERR_RUNA_* pattern */
+    code: string;
+    /** POSIX-aligned exit code category */
+    exitCode: ExitCode;
+    /** Short human-readable title */
+    title: string;
+    /** Message template with {param} placeholders */
+    template: string;
+    /** Recovery suggestions (static or dynamic based on params) */
+    suggestions: string[] | ((params: TParams) => string[]);
+    /** Documentation URL */
+    docUrl?: string;
+}
+/**
+ * Central error catalog with all error definitions.
+ * Grouped by exit code category for clarity.
+ */
+export declare const ERROR_CATALOG: {
+    readonly CONFIG_NOT_FOUND: {
+        code: string;
+        exitCode: 3;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly CONFIG_INVALID: {
+        code: string;
+        exitCode: 3;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly CONFIG_SCHEMA_MISMATCH: {
+        code: string;
+        exitCode: 3;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly ENV_FILE_NOT_FOUND: {
+        code: string;
+        exitCode: 3;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly ENV_KEY_MISSING: {
+        code: string;
+        exitCode: 3;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly ENV_VAR_MISSING: {
+        code: string;
+        exitCode: 3;
+        title: string;
+        template: string;
+        suggestions: (params: {
+            varName: string;
+        }) => string[];
+        docUrl: string;
+    };
+    readonly GITHUB_AUTH_REQUIRED: {
+        code: string;
+        exitCode: 4;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly GITHUB_AUTH_FAILED: {
+        code: string;
+        exitCode: 4;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly VERCEL_AUTH_REQUIRED: {
+        code: string;
+        exitCode: 4;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly SUPABASE_AUTH_REQUIRED: {
+        code: string;
+        exitCode: 4;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly AUTH_TOKEN_MISSING: {
+        code: string;
+        exitCode: 4;
+        title: string;
+        template: string;
+        suggestions: (params: {
+            tokenName: string;
+        }) => string[];
+        docUrl: string;
+    };
+    readonly LICENSE_UNAUTHORIZED: {
+        code: string;
+        exitCode: 4;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly NETWORK_TIMEOUT: {
+        code: string;
+        exitCode: 5;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly NETWORK_CONNECTION_REFUSED: {
+        code: string;
+        exitCode: 5;
+        title: string;
+        template: string;
+        suggestions: (params: {
+            host: string;
+            port: number;
+        }) => string[];
+        docUrl: string;
+    };
+    readonly API_REQUEST_FAILED: {
+        code: string;
+        exitCode: 5;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly DATABASE_CONNECTION_FAILED: {
+        code: string;
+        exitCode: 6;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly DATABASE_URL_MISSING: {
+        code: string;
+        exitCode: 6;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly DATABASE_SCHEMA_SYNC_FAILED: {
+        code: string;
+        exitCode: 6;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly DATABASE_SEED_FAILED: {
+        code: string;
+        exitCode: 6;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly DATABASE_MIGRATION_HAZARD: {
+        code: string;
+        exitCode: 6;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly DATABASE_QUERY_FAILED: {
+        code: string;
+        exitCode: 6;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly DOCKER_NOT_RUNNING: {
+        code: string;
+        exitCode: 7;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly TOOL_NOT_FOUND: {
+        code: string;
+        exitCode: 7;
+        title: string;
+        template: string;
+        suggestions: (params: {
+            tool: string;
+        }) => string[];
+        docUrl: string;
+    };
+    readonly TOOL_EXECUTION_FAILED: {
+        code: string;
+        exitCode: 7;
+        title: string;
+        template: string;
+        suggestions: (params: {
+            tool: string;
+            reason: string;
+        }) => string[];
+        docUrl: string;
+    };
+    readonly PORT_IN_USE: {
+        code: string;
+        exitCode: 7;
+        title: string;
+        template: string;
+        suggestions: (params: {
+            port: number;
+        }) => string[];
+        docUrl: string;
+    };
+    readonly SUPABASE_CLI_ERROR: {
+        code: string;
+        exitCode: 7;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly PG_SCHEMA_DIFF_ERROR: {
+        code: string;
+        exitCode: 7;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly GIT_DIRTY_WORKING_TREE: {
+        code: string;
+        exitCode: 8;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly GIT_NOT_ON_BRANCH: {
+        code: string;
+        exitCode: 8;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly GIT_PUSH_FAILED: {
+        code: string;
+        exitCode: 8;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly TYPE_CHECK_FAILED: {
+        code: string;
+        exitCode: 9;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly LINT_FAILED: {
+        code: string;
+        exitCode: 9;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly BUILD_FAILED: {
+        code: string;
+        exitCode: 9;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly TURBO_CACHE_ERROR: {
+        code: string;
+        exitCode: 9;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly TEST_FAILED: {
+        code: string;
+        exitCode: 10;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly TEST_TIMEOUT: {
+        code: string;
+        exitCode: 10;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly INVALID_ARGUMENT: {
+        code: string;
+        exitCode: 2;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly MISSING_ARGUMENT: {
+        code: string;
+        exitCode: 2;
+        title: string;
+        template: string;
+        suggestions: (params: {
+            argument: string;
+            command: string;
+        }) => string[];
+        docUrl: string;
+    };
+    readonly INVALID_MODE: {
+        code: string;
+        exitCode: 2;
+        title: string;
+        template: string;
+        suggestions: (params: {
+            mode: string;
+            validModes: string;
+        }) => string[];
+        docUrl: string;
+    };
+    readonly INTERNAL_ERROR: {
+        code: string;
+        exitCode: 1;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly OPERATION_CANCELLED: {
+        code: string;
+        exitCode: 1;
+        title: string;
+        template: string;
+        suggestions: string[];
+    };
+    readonly MACHINE_NO_OUTPUT: {
+        code: string;
+        exitCode: 1;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly TEMPLATES_NOT_FOUND: {
+        code: string;
+        exitCode: 1;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly FILE_NOT_FOUND: {
+        code: string;
+        exitCode: 1;
+        title: string;
+        template: string;
+        suggestions: string[];
+    };
+    readonly SCRIPT_NOT_FOUND: {
+        code: string;
+        exitCode: 1;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly HOTFIX_NOT_FOUND: {
+        code: string;
+        exitCode: 1;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+    readonly HOTFIX_INVALID_NAME: {
+        code: string;
+        exitCode: 2;
+        title: string;
+        template: string;
+        suggestions: string[];
+        docUrl: string;
+    };
+};
+/** All available error codes */
+export type ErrorCode = keyof typeof ERROR_CATALOG;
+/**
+ * Create a CLIError from the error catalog.
+ *
+ * @example
+ * throw createError('CONFIG_NOT_FOUND', { path: 'runa.config.ts' });
+ * throw createError('DATABASE_CONNECTION_FAILED', { reason: 'Connection refused' });
+ * throw createError('DOCKER_NOT_RUNNING'); // No params needed
+ *
+ * Note: Params are typed as Record<string, unknown> for simplicity.
+ * The template placeholders {param} are replaced with provided values.
+ */
+export declare function createError(errorCode: ErrorCode, params?: Record<string, unknown>): CLIError;
+/**
+ * Get error definition by code.
+ * Useful for documentation generation or error lookup.
+ */
+export declare function getErrorDefinition<K extends ErrorCode>(errorCode: K): (typeof ERROR_CATALOG)[K];
+/**
+ * Get all error codes for a specific exit code category.
+ */
+export declare function getErrorCodesByExitCode(exitCode: ExitCode): ErrorCode[];
+/**
+ * Check if a CLIError matches a specific catalog error code.
+ */
+export declare function isErrorCode(error: CLIError, errorCode: ErrorCode): boolean;
+//# sourceMappingURL=catalog.d.ts.map

package/dist/errors/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../src/errors/catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAc,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAM5D,MAAM,WAAW,eAAe,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAC9F,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,uCAAuC;IACvC,QAAQ,EAAE,QAAQ,CAAC;IACnB,iCAAiC;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,iDAAiD;IACjD,QAAQ,EAAE,MAAM,CAAC;IACjB,+DAA+D;IAC/D,WAAW,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,MAAM,EAAE,OAAO,KAAK,MAAM,EAAE,CAAC,CAAC;IACxD,wBAAwB;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAMD;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA6De,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAuDJ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;kBA2CX,MAAM;kBAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA8HpB,MAAM;;;;;;;;;;kBAaN,MAAM;oBAAU,MAAM;;;;;;;;;;kBAatB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA4KF,MAAM;qBAAW,MAAM;;;;;;;;;;kBAS3B,MAAM;wBAAc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqFtD,CAAC;AAMX,gCAAgC;AAChC,MAAM,MAAM,SAAS,GAAG,MAAM,OAAO,aAAa,CAAC;AAMnD;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,QAAQ,CAiBhG;AAiBD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,SAAS,EAAE,SAAS,EAAE,CAAC,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,CAAC,CAAC,CAE/F;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,QAAQ,GAAG,SAAS,EAAE,CAIvE;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAE1E"}

package/dist/errors/exit-codes.d.ts

@@ -0,0 +1,46 @@
+/**
+ * AI HINT: CLI Exit Code Definitions
+ *
+ * Purpose: POSIX-aligned exit code categories for CLI
+ * Reference: https://www.ditig.com/linux-exit-status-codes
+ *
+ * Philosophy:
+ * - Exit codes enable programmatic error handling in scripts
+ * - Categories allow callers to handle errors by type
+ * - Compatible with CI systems (GitHub Actions, etc.)
+ */
+/**
+ * Exit code categories
+ *
+ * 0:     Success
+ * 1:     General error (unknown/uncategorized)
+ * 2:     Usage error (invalid arguments, --help needed)
+ * 3:     Configuration error (runa.config.ts, .env files)
+ * 4:     Authentication error (tokens, credentials)
+ * 5:     Network error (API timeout, connection refused)
+ * 6:     Database error (connection, schema, seeds)
+ * 7:     External tool error (Docker, pg-schema-diff, Supabase CLI)
+ * 8:     Git error (uncommitted changes, merge conflict)
+ * 9:     Build error (type-check, lint, compilation)
+ * 10:    Test error (test failures)
+ * 11-20: Reserved for command-specific errors
+ */
+export declare const EXIT_CODES: {
+    readonly SUCCESS: 0;
+    readonly GENERAL_ERROR: 1;
+    readonly USAGE_ERROR: 2;
+    readonly CONFIG_ERROR: 3;
+    readonly AUTH_ERROR: 4;
+    readonly NETWORK_ERROR: 5;
+    readonly DATABASE_ERROR: 6;
+    readonly EXTERNAL_TOOL_ERROR: 7;
+    readonly GIT_ERROR: 8;
+    readonly BUILD_ERROR: 9;
+    readonly TEST_ERROR: 10;
+};
+export type ExitCode = (typeof EXIT_CODES)[keyof typeof EXIT_CODES];
+/**
+ * Get human-readable description for exit code
+ */
+export declare function getExitCodeDescription(code: ExitCode): string;
+//# sourceMappingURL=exit-codes.d.ts.map

package/dist/errors/exit-codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exit-codes.d.ts","sourceRoot":"","sources":["../../src/errors/exit-codes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;CAYb,CAAC;AAEX,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,OAAO,UAAU,CAAC,CAAC;AAEpE;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CA2B7D"}

package/dist/errors/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * AI HINT: CLI Error System
+ *
+ * Purpose: Centralized error handling exports
+ * Pattern: Error Catalog + Exit Codes + Error Factory
+ *
+ * Usage:
+ *   import { createError, EXIT_CODES } from '../errors/index.js';
+ *   throw createError('CONFIG_NOT_FOUND', { path: 'runa.config.ts' });
+ */
+export { EXIT_CODES, type ExitCode, getExitCodeDescription } from './exit-codes.js';
+export { ERROR_CATALOG, type ErrorCode, type ErrorDefinition, createError, getErrorDefinition, getErrorCodesByExitCode, isErrorCode, } from './catalog.js';
+//# sourceMappingURL=index.d.ts.map