@claryai/cli 0.1.0

package/dist/dbt/targets/redshift.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertRedshiftSchema = exports.redshiftSchema = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const better_ajv_errors_1 = tslib_1.__importDefault(require("better-ajv-errors"));
+const ajv_1 = require("../../ajv");
+exports.redshiftSchema = {
+    type: 'object',
+    properties: {
+        type: {
+            type: 'string',
+            enum: ['redshift'],
+        },
+        host: {
+            type: 'string',
+        },
+        user: {
+            type: 'string',
+        },
+        port: {
+            type: 'integer',
+        },
+        dbname: {
+            type: 'string',
+            nullable: true,
+        },
+        database: {
+            type: 'string',
+            nullable: true,
+        },
+        schema: {
+            type: 'string',
+        },
+        threads: {
+            type: 'integer',
+            nullable: true,
+        },
+        pass: {
+            type: 'string',
+            nullable: true,
+        },
+        password: {
+            type: 'string',
+            nullable: true,
+        },
+        keepalives_idle: {
+            type: 'integer',
+            nullable: true,
+        },
+        connect_timeout: {
+            type: 'integer',
+            nullable: true,
+        },
+        search_path: {
+            type: 'string',
+            nullable: true,
+        },
+        role: {
+            type: 'string',
+            nullable: true,
+        },
+        sslmode: {
+            type: 'string',
+            nullable: true,
+        },
+    },
+    required: ['type', 'host', 'user', 'port', 'schema'],
+};
+const convertRedshiftSchema = (target) => {
+    const validate = ajv_1.ajv.compile(exports.redshiftSchema);
+    if (validate(target)) {
+        const password = target.pass || target.password;
+        if (!password) {
+            throw new common_1.ParseError(`Redshift target requires a password: "password"`);
+        }
+        const dbname = target.dbname || target.database;
+        if (!dbname) {
+            throw new common_1.ParseError(`Redshift target requires a database name: "database"`);
+        }
+        return {
+            type: common_1.WarehouseTypes.REDSHIFT,
+            host: target.host,
+            user: target.user,
+            password,
+            port: target.port,
+            dbname,
+            schema: target.schema,
+            keepalivesIdle: target.keepalives_idle,
+            sslmode: target.sslmode,
+        };
+    }
+    const errs = (0, better_ajv_errors_1.default)(exports.redshiftSchema, target, validate.errors || []);
+    throw new common_1.ParseError(`Couldn't read profiles.yml file for ${target.type}:\n${errs}`);
+};
+exports.convertRedshiftSchema = convertRedshiftSchema;

package/dist/dbt/targets/snowflake.d.ts

@@ -0,0 +1,4 @@
+import { CreateSnowflakeCredentials } from '@lightdash/common';
+import { Target } from '../types';
+export declare const convertSnowflakeSchema: (target: Target) => Promise<CreateSnowflakeCredentials>;
+//# sourceMappingURL=snowflake.d.ts.map

package/dist/dbt/targets/snowflake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snowflake.d.ts","sourceRoot":"","sources":["../../../src/dbt/targets/snowflake.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,0BAA0B,EAK7B,MAAM,mBAAmB,CAAC;AAK3B,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAsGlC,eAAO,MAAM,sBAAsB,GAC/B,QAAQ,MAAM,KACf,OAAO,CAAC,0BAA0B,CA0DpC,CAAC"}

package/dist/dbt/targets/snowflake.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertSnowflakeSchema = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const better_ajv_errors_1 = tslib_1.__importDefault(require("better-ajv-errors"));
+const fs_1 = require("fs");
+const ajv_1 = require("../../ajv");
+const snowflakeSchema = {
+    type: 'object',
+    properties: {
+        type: {
+            type: 'string',
+            enum: ['snowflake'],
+        },
+        account: {
+            type: 'string',
+        },
+        user: {
+            type: 'string',
+        },
+        password: {
+            type: 'string',
+            nullable: true,
+        },
+        authenticator: {
+            type: 'string',
+            nullable: true,
+        },
+        private_key_path: {
+            type: 'string',
+            nullable: true,
+        },
+        private_key: {
+            type: 'string',
+            nullable: true,
+        },
+        private_key_passphrase: {
+            type: 'string',
+            nullable: true,
+        },
+        role: {
+            type: 'string',
+            nullable: true,
+        },
+        database: {
+            type: 'string',
+        },
+        warehouse: {
+            type: 'string',
+        },
+        schema: {
+            type: 'string',
+        },
+        threads: {
+            type: 'integer',
+            nullable: true,
+        },
+        client_session_keep_alive: {
+            type: 'boolean',
+            nullable: true,
+        },
+        query_tag: {
+            type: 'string',
+            nullable: true,
+        },
+        connect_retries: {
+            type: 'integer',
+            nullable: true,
+        },
+        connect_timeout: {
+            type: 'integer',
+            nullable: true,
+        },
+        retry_on_database_errors: {
+            type: 'boolean',
+            nullable: true,
+        },
+        retry_all: {
+            type: 'boolean',
+            nullable: true,
+        },
+    },
+    required: ['type', 'account', 'user', 'database', 'warehouse', 'schema'],
+};
+const convertSnowflakeSchema = async (target) => {
+    const validate = ajv_1.ajv.compile(snowflakeSchema);
+    if (validate(target)) {
+        const keyfilePath = target.private_key_path;
+        let privateKey;
+        if (keyfilePath) {
+            try {
+                privateKey = await fs_1.promises.readFile(keyfilePath, 'utf8');
+            }
+            catch (e) {
+                const msg = (0, common_1.getErrorMessage)(e);
+                throw new common_1.ParseError(`Cannot read keyfile for snowflake target at: ${keyfilePath}:\n  ${msg}`);
+            }
+        }
+        if (target.private_key) {
+            privateKey = target.private_key;
+        }
+        // Determine authentication type based on authenticator field or credentials present
+        let authenticationType;
+        if (target.authenticator &&
+            target.authenticator.toLowerCase() === 'externalbrowser') {
+            authenticationType = common_1.SnowflakeAuthenticationType.EXTERNAL_BROWSER;
+        }
+        else if (privateKey) {
+            authenticationType = common_1.SnowflakeAuthenticationType.PRIVATE_KEY;
+        }
+        else {
+            authenticationType = common_1.SnowflakeAuthenticationType.PASSWORD;
+        }
+        return {
+            type: common_1.WarehouseTypes.SNOWFLAKE,
+            account: target.account,
+            user: target.user,
+            password: target.password,
+            privateKey,
+            privateKeyPass: target.private_key_passphrase,
+            authenticationType,
+            role: target.role,
+            warehouse: target.warehouse,
+            database: target.database,
+            schema: target.schema,
+            clientSessionKeepAlive: target.client_session_keep_alive,
+            queryTag: target.query_tag,
+        };
+    }
+    const errs = (0, better_ajv_errors_1.default)(snowflakeSchema, target, validate.errors || []);
+    throw new common_1.ParseError(`Couldn't read profiles.yml file for ${target.type}:\n${errs}`);
+};
+exports.convertSnowflakeSchema = convertSnowflakeSchema;

package/dist/dbt/targets/trino.d.ts

@@ -0,0 +1,16 @@
+import { CreateTrinoCredentials } from '@lightdash/common';
+import { JSONSchemaType } from 'ajv';
+import { Target } from '../types';
+export type TrinoTarget = {
+    type: 'trino';
+    host: string;
+    user: string;
+    password: string;
+    port: number;
+    database: string;
+    schema: string;
+    http_scheme: string;
+};
+export declare const trinoSchema: JSONSchemaType<TrinoTarget>;
+export declare const convertTrinoSchema: (target: Target) => CreateTrinoCredentials;
+//# sourceMappingURL=trino.d.ts.map

package/dist/dbt/targets/trino.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trino.d.ts","sourceRoot":"","sources":["../../../src/dbt/targets/trino.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,sBAAsB,EAGzB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAGrC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,MAAM,MAAM,WAAW,GAAG;IACtB,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,cAAc,CAAC,WAAW,CAuCnD,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,QAAQ,MAAM,KAAG,sBAoBnD,CAAC"}

package/dist/dbt/targets/trino.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertTrinoSchema = exports.trinoSchema = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const better_ajv_errors_1 = tslib_1.__importDefault(require("better-ajv-errors"));
+const ajv_1 = require("../../ajv");
+exports.trinoSchema = {
+    type: 'object',
+    properties: {
+        type: {
+            type: 'string',
+            enum: ['trino'],
+        },
+        schema: {
+            type: 'string',
+        },
+        host: {
+            type: 'string',
+        },
+        user: {
+            type: 'string',
+        },
+        password: {
+            type: 'string',
+        },
+        port: {
+            type: 'number',
+        },
+        database: {
+            type: 'string',
+        },
+        http_scheme: {
+            type: 'string',
+        },
+    },
+    required: [
+        'type',
+        'schema',
+        'host',
+        'user',
+        'password',
+        'port',
+        'database',
+        'http_scheme',
+    ],
+};
+const convertTrinoSchema = (target) => {
+    const validate = ajv_1.ajv.compile(exports.trinoSchema);
+    if (validate(target)) {
+        return {
+            type: common_1.WarehouseTypes.TRINO,
+            schema: target.schema,
+            host: target.host,
+            user: target.user,
+            password: target.password,
+            port: target.port,
+            dbname: target.database,
+            http_scheme: target.http_scheme,
+        };
+    }
+    const errs = (0, better_ajv_errors_1.default)(exports.trinoSchema, target, validate.errors || []);
+    throw new common_1.ParseError(`Couldn't read profiles.yml file for ${target.type}:\n${errs}`);
+};
+exports.convertTrinoSchema = convertTrinoSchema;

package/dist/dbt/templating.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Render a dbt YAML file with Jinja templating (env_var, var, filters)
+ * @param raw - Raw YAML content as string
+ * @param context - Additional context variables to pass to the template
+ * @returns Rendered YAML string with Jinja expressions resolved
+ */
+export declare const renderTemplatedYml: (raw: string, context?: Record<string, unknown>) => string;
+/**
+ * Render a profiles.yml file with Jinja templating and private key handling
+ * @param raw - Raw profiles.yml content as string
+ * @param context - Additional context variables to pass to the template
+ * @returns Rendered profiles.yml string with Jinja expressions resolved and private keys escaped
+ */
+export declare const renderProfilesYml: (raw: string, context?: Record<string, unknown>) => string;
+//# sourceMappingURL=templating.d.ts.map

package/dist/dbt/templating.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templating.d.ts","sourceRoot":"","sources":["../../src/dbt/templating.ts"],"names":[],"mappings":"AAqBA;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAC3B,KAAK,MAAM,EACX,UAAU,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAClC,MAMF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAC1B,KAAK,MAAM,EACX,UAAU,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAClC,MASF,CAAC"}

package/dist/dbt/templating.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderProfilesYml = exports.renderTemplatedYml = void 0;
+const tslib_1 = require("tslib");
+const nunjucks = tslib_1.__importStar(require("nunjucks"));
+// jinja filters
+const nunjucksEnv = new nunjucks.Environment(null, { autoescape: false });
+nunjucksEnv.addFilter('as_number', (str) => parseFloat(str));
+// jinja global functions
+const nunjucksContext = {
+    env_var: (key, options) => {
+        let fallbackValue;
+        if (typeof options === 'string') {
+            fallbackValue = options;
+        }
+        else if (typeof options === 'object') {
+            fallbackValue = options.default;
+        }
+        return process.env[key] ?? fallbackValue;
+    },
+    var: (key) => JSON.parse(process.argv[process.argv.indexOf('--vars') + 1])[key],
+};
+/**
+ * Render a dbt YAML file with Jinja templating (env_var, var, filters)
+ * @param raw - Raw YAML content as string
+ * @param context - Additional context variables to pass to the template
+ * @returns Rendered YAML string with Jinja expressions resolved
+ */
+const renderTemplatedYml = (raw, context) => {
+    const template = nunjucks.compile(raw, nunjucksEnv);
+    return template.render({
+        ...nunjucksContext,
+        ...(context || {}),
+    });
+};
+exports.renderTemplatedYml = renderTemplatedYml;
+/**
+ * Render a profiles.yml file with Jinja templating and private key handling
+ * @param raw - Raw profiles.yml content as string
+ * @param context - Additional context variables to pass to the template
+ * @returns Rendered profiles.yml string with Jinja expressions resolved and private keys escaped
+ */
+const renderProfilesYml = (raw, context) => {
+    const rendered = (0, exports.renderTemplatedYml)(raw, context);
+    // Fix multiline privatekey strings
+    // Prevents error: Error: error:1E08010C:DECODER routines::unsupported
+    const privateKeyRegex = /(-----BEGIN(?:\s+ENCRYPTED)?\s+PRIVATE KEY-----[\s\S]*?-----END(?:\s+ENCRYPTED)?\s+PRIVATE KEY-----)/g;
+    return rendered.replace(privateKeyRegex, (match) => match.replace(/\n/g, '\\n'));
+};
+exports.renderProfilesYml = renderProfilesYml;

package/dist/dbt/templating.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=templating.test.d.ts.map

package/dist/dbt/templating.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templating.test.d.ts","sourceRoot":"","sources":["../../src/dbt/templating.test.ts"],"names":[],"mappings":""}

package/dist/dbt/templating.test.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const templating_1 = require("./templating");
+describe('Templating', () => {
+    const { env, argv } = process;
+    beforeEach(() => {
+        jest.resetModules();
+        process.env = { ...env };
+        process.argv = { ...argv };
+    });
+    afterEach(() => {
+        process.env = env;
+        process.argv = argv;
+    });
+    describe('renderProfilesYml', () => {
+        describe('env_var()', () => {
+            test('should not escape values', () => {
+                process.env.SPAN = '<span>';
+                expect((0, templating_1.renderProfilesYml)("{{ env_var('SPAN') }}")).toBe('<span>');
+                process.env.WINDOWS_PATH = 'C:\\example';
+                expect((0, templating_1.renderProfilesYml)("{{ env_var('WINDOWS_PATH') }}")).toBe('C:\\example');
+            });
+            test('should convert env_var functions and return env var values', () => {
+                process.env.DBT_USER = 'test';
+                expect((0, templating_1.renderProfilesYml)("{{ env_var('DBT_USER') }}")).toBe('test');
+                process.env.DBT_ENV_SECRET_HOST_DOMAIN = 'domain';
+                process.env.DBT_ENV_SECRET_HOST_PATH = 'host_path';
+                expect((0, templating_1.renderProfilesYml)("www.{{ env_var('DBT_ENV_SECRET_HOST_DOMAIN') }}.com/{{ env_var('DBT_ENV_SECRET_HOST_PATH') }}")).toBe('www.domain.com/host_path');
+            });
+            test('should convert env_var function with number conversion', () => {
+                process.env.REDSHIFT_PORT = '2000';
+                expect((0, templating_1.renderProfilesYml)("{{ env_var('REDSHIFT_PORT') | as_number}}")).toBe('2000');
+            });
+            test('should convert env_var function and fallback to default value', () => {
+                expect((0, templating_1.renderProfilesYml)("{{ env_var('DBT_USER', 'default_value') }}")).toBe('default_value');
+            });
+            test('should convert env_var function and fallback to default value using keyword default', () => {
+                expect((0, templating_1.renderProfilesYml)("{{ env_var('DBT_USER', default='default_value') }}")).toBe('default_value');
+            });
+        });
+        describe('var()', () => {
+            test('should convert var functions and return env var values', () => {
+                process.argv = [
+                    '--vars',
+                    '{"domain": "domain", "host_path": "host_path"}',
+                ];
+                expect((0, templating_1.renderProfilesYml)("www.{{ var('domain') }}.com/{{ var('host_path') }}")).toBe('www.domain.com/host_path');
+            });
+        });
+    });
+});

package/dist/dbt/types.d.ts

@@ -0,0 +1,17 @@
+export type LoadProfileArgs = {
+    profilesDir: string;
+    profileName: string;
+    targetName?: string;
+};
+export type Target = Record<string, unknown> & {
+    type: string;
+};
+type Profile = {
+    target: string;
+    outputs: Record<string, Target>;
+};
+export type Profiles = {
+    [name: string]: Profile;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/dbt/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/dbt/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AACF,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAC3C,IAAI,EAAE,MAAM,CAAC;CAChB,CAAC;AACF,KAAK,OAAO,GAAG;IACX,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC,CAAC;AACF,MAAM,MAAM,QAAQ,GAAG;IACnB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;CAC3B,CAAC"}

package/dist/dbt/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/dbt/validation.d.ts

@@ -0,0 +1,9 @@
+import { DbtModelNode, DbtRawModelNode, ExploreError, type DbtManifestVersion } from '@lightdash/common';
+type DbtModelsGroupedByState = {
+    valid: DbtModelNode[];
+    invalid: ExploreError[];
+    skipped: DbtRawModelNode[];
+};
+export declare const validateDbtModel: (adapterType: string, manifestVersion: DbtManifestVersion, models: DbtRawModelNode[]) => Promise<DbtModelsGroupedByState>;
+export {};
+//# sourceMappingURL=validation.d.ts.map

package/dist/dbt/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/dbt/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,YAAY,EACZ,eAAe,EACf,YAAY,EAOZ,KAAK,kBAAkB,EAC1B,MAAM,mBAAmB,CAAC;AAG3B,KAAK,uBAAuB,GAAG;IAC3B,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,OAAO,EAAE,eAAe,EAAE,CAAC;CAC9B,CAAC;AACF,eAAO,MAAM,gBAAgB,GACzB,aAAa,MAAM,EACnB,iBAAiB,kBAAkB,EACnC,QAAQ,eAAe,EAAE,KAC1B,OAAO,CAAC,uBAAuB,CAgEjC,CAAC"}

package/dist/dbt/validation.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDbtModel = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const globalState_1 = tslib_1.__importDefault(require("../globalState"));
+const validateDbtModel = async (adapterType, manifestVersion, models) => {
+    globalState_1.default.debug(`> Validating ${models.length} models from dbt manifest`);
+    globalState_1.default.debug(`> Validating models using dbt manifest version ${manifestVersion}`);
+    const validator = new common_1.ManifestValidator(manifestVersion);
+    const results = models.reduce((acc, model) => {
+        let error;
+        // Match against json schema
+        const [isValid, errorMessage] = validator.isModelValid(model);
+        if (!isValid) {
+            error = {
+                type: common_1.InlineErrorType.METADATA_PARSE_ERROR,
+                message: errorMessage,
+            };
+        }
+        else if (isValid && Object.values(model.columns).length <= 0) {
+            error = {
+                type: common_1.InlineErrorType.NO_DIMENSIONS_FOUND,
+                message: 'No dimensions available',
+            };
+        }
+        if (error) {
+            const exploreError = {
+                name: model.name,
+                label: model.meta.label || (0, common_1.friendlyName)(model.name),
+                errors: [error],
+            };
+            return { ...acc, invalid: [...acc.invalid, exploreError] };
+        }
+        // Fix null databases
+        const validatedModel = (0, common_1.normaliseModelDatabase)(model, adapterType);
+        return { ...acc, valid: [...acc.valid, validatedModel] };
+    }, { valid: [], invalid: [], skipped: [] });
+    if (results.valid.length > 0) {
+        globalState_1.default.debug(`> Valid compiled models (${results.valid.length}): ${results.valid
+            .map((m) => m.name)
+            .join(', ')}`);
+    }
+    if (results.skipped.length > 0) {
+        globalState_1.default.debug(`> Skipped models (${results.skipped.length}): ${results.skipped
+            .map((m) => m.name)
+            .join(', ')}`);
+    }
+    if (results.invalid.length > 0) {
+        globalState_1.default.debug(`> Invalid compiled models (${results.invalid.length}): ${results.invalid.map((m) => m.name).join(', ')}`);
+    }
+    return results;
+};
+exports.validateDbtModel = validateDbtModel;

package/dist/env.d.ts

@@ -0,0 +1,12 @@
+export declare const NODE_VERSION: {
+    major: number;
+};
+export declare const OPTIMIZED_NODE_VERSION = 20;
+export declare const CLI_VERSION: string;
+export declare const DEFAULT_DBT_PROJECT_DIR: string;
+export declare const DEFAULT_DBT_PROFILES_DIR: string;
+type InstallMethod = 'npm' | 'homebrew' | 'binary';
+export declare const getInstallMethod: () => InstallMethod;
+export declare const getUpdateInstructions: (version: string) => string;
+export {};
+//# sourceMappingURL=env.d.ts.map

package/dist/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../src/env.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY;;CAAqD,CAAC;AAE/E,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC,eAAO,MAAiB,WAAW,QAAgB,CAAC;AAEpD,eAAO,MAAM,uBAAuB,QAAqC,CAAC;AAC1E,eAAO,MAAM,wBAAwB,EAAE,MAAgC,CAAC;AAExE,KAAK,aAAa,GAAG,KAAK,GAAG,UAAU,GAAG,QAAQ,CAAC;AAEnD,eAAO,MAAM,gBAAgB,QAAO,aAiBnC,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,SAAS,MAAM,KAAG,MAWvD,CAAC"}

package/dist/env.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUpdateInstructions = exports.getInstallMethod = exports.DEFAULT_DBT_PROFILES_DIR = exports.DEFAULT_DBT_PROJECT_DIR = exports.CLI_VERSION = exports.OPTIMIZED_NODE_VERSION = exports.NODE_VERSION = void 0;
+const tslib_1 = require("tslib");
+const parse_node_version_1 = tslib_1.__importDefault(require("parse-node-version"));
+const package_json_1 = tslib_1.__importDefault(require("../package.json"));
+const profile_1 = require("./dbt/profile");
+exports.NODE_VERSION = { major: (0, parse_node_version_1.default)(process.version).major };
+exports.OPTIMIZED_NODE_VERSION = 20;
+exports.CLI_VERSION = package_json_1.default.version;
+exports.DEFAULT_DBT_PROJECT_DIR = process.env.DBT_PROJECT_DIR || '.';
+exports.DEFAULT_DBT_PROFILES_DIR = (0, profile_1.findDbtDefaultProfile)();
+const getInstallMethod = () => {
+    // pkg-compiled binary
+    if (process.pkg) {
+        return 'binary';
+    }
+    const { execPath } = process;
+    // Homebrew: macOS (Apple Silicon, Intel) or Linux (Linuxbrew)
+    if (execPath.includes('/opt/homebrew/') ||
+        execPath.includes('/usr/local/Cellar/') ||
+        execPath.includes('linuxbrew')) {
+        return 'homebrew';
+    }
+    return 'npm';
+};
+exports.getInstallMethod = getInstallMethod;
+const getUpdateInstructions = (version) => {
+    const method = (0, exports.getInstallMethod)();
+    switch (method) {
+        case 'homebrew':
+            return 'running: brew upgrade clary';
+        case 'binary':
+            return 'downloading from: https://github.com/claryai/clary-cli/releases';
+        case 'npm':
+        default:
+            return `running: npm install -g @claryai/cli@${version}`;
+    }
+};
+exports.getUpdateInstructions = getUpdateInstructions;

package/dist/error.d.ts

@@ -0,0 +1,2 @@
+export declare const getDiagnosticsHint: (argv?: string[]) => string | null;
+//# sourceMappingURL=error.d.ts.map

package/dist/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,kBAAkB,GAC3B,OAAM,MAAM,EAA0B,KACvC,MAAM,GAAG,IAMX,CAAC"}

package/dist/error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDiagnosticsHint = void 0;
+const tslib_1 = require("tslib");
+const styles = tslib_1.__importStar(require("./styles"));
+const getDiagnosticsHint = (argv = process.argv.slice(2)) => {
+    if (argv.includes('diagnostics')) {
+        return null;
+    }
+    return `\n💡 Run ${styles.bold('clary diagnostics')} for more info.\n`;
+};
+exports.getDiagnosticsHint = getDiagnosticsHint;

package/dist/globalState.d.ts

@@ -0,0 +1,29 @@
+import ora from 'ora';
+import { Config } from './config';
+type PromptAnswer = {
+    useFallbackDbtVersion?: boolean;
+    useExperimentalDbtCloudCLI?: boolean;
+};
+declare class GlobalState {
+    private verbose;
+    private nonInteractive;
+    private activeSpinner;
+    private savedPromptAnswers;
+    private sessionId;
+    constructor();
+    getSessionId(): string;
+    setNonInteractive(value: boolean): void;
+    isNonInteractive(): boolean;
+    getActiveSpinner(): ora.Ora | undefined;
+    startSpinner(options?: ora.Options | string): ora.Ora;
+    log(message: unknown, ...optionalParams: unknown[]): void;
+    setVerbose(verbose: boolean): void;
+    getSavedPromptAnswer<T extends keyof PromptAnswer>(prompt: T): PromptAnswer[T] | undefined;
+    savePromptAnswer<T extends keyof PromptAnswer>(prompt: T, value: PromptAnswer[T]): void;
+    clearPromptAnswer(): void;
+    debug(message: string): void;
+    logProjectInfo(config: Config): void;
+}
+declare const _default: GlobalState;
+export default _default;
+//# sourceMappingURL=globalState.d.ts.map