@claryai/cli 0.1.0

package/dist/lightdash/loader.js

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * Loader for Lightdash YAML model files
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadLightdashModel = loadLightdashModel;
+exports.findLightdashModelFiles = findLightdashModelFiles;
+exports.loadLightdashModels = loadLightdashModels;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const fs = tslib_1.__importStar(require("fs"));
+const yaml = tslib_1.__importStar(require("js-yaml"));
+const path = tslib_1.__importStar(require("path"));
+const globalState_1 = tslib_1.__importDefault(require("../globalState"));
+/**
+ * Load a single Lightdash YAML model file
+ */
+async function loadLightdashModel(filePath) {
+    try {
+        const fileContents = await fs.promises.readFile(filePath, 'utf8');
+        const parsed = yaml.load(fileContents);
+        // Basic validation
+        if (!parsed.type || !parsed.name || !parsed.dimensions) {
+            throw new common_1.ParseError(`Invalid Lightdash model in ${filePath}: must have type, name, and dimensions`);
+        }
+        if (!parsed.sql_from) {
+            throw new common_1.ParseError(`Invalid Lightdash model in ${filePath}: must have sql_from`);
+        }
+        return parsed;
+    }
+    catch (error) {
+        if (error instanceof common_1.ParseError) {
+            throw error;
+        }
+        throw new common_1.ParseError(`Failed to load Lightdash model from ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Check if a YAML file contains a Lightdash model definition
+ * A valid model file must have a `type` field with value 'model', 'model/v1beta', or 'model/v1'
+ */
+async function isLightdashModelFile(filePath) {
+    try {
+        const fileContents = await fs.promises.readFile(filePath, 'utf8');
+        const parsed = yaml.load(fileContents);
+        if (!parsed || typeof parsed !== 'object') {
+            return false;
+        }
+        // Check for valid model type values
+        const validModelTypes = ['model', 'model/v1beta', 'model/v1'];
+        return validModelTypes.includes(parsed.type ?? '');
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Find all Lightdash YAML model files in a directory
+ * Looks for files in models/ or lightdash/models/ directory that contain `type: model`
+ *
+ * This explicitly checks the YAML content for `type: model` (or versioned variants)
+ * to avoid false positives from other YAML files (e.g., content-as-code spaces).
+ */
+async function findLightdashModelFiles(projectDir) {
+    // Check both possible model locations: models/ (preferred) and lightdash/models/ (legacy)
+    const possibleDirs = [
+        path.join(projectDir, 'models'),
+        path.join(projectDir, 'lightdash', 'models'),
+    ];
+    const lightdashModelsDir = possibleDirs.find((dir) => fs.existsSync(dir));
+    if (!lightdashModelsDir) {
+        globalState_1.default.debug(`No models directory found at ${possibleDirs.join(' or ')}`);
+        return [];
+    }
+    globalState_1.default.debug(`Using models directory: ${lightdashModelsDir}`);
+    const yamlFiles = [];
+    async function walkDir(dir) {
+        const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+        for await (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walkDir(fullPath);
+            }
+            else if (entry.isFile() &&
+                (entry.name.endsWith('.yml') || entry.name.endsWith('.yaml'))) {
+                yamlFiles.push(fullPath);
+            }
+        }
+    }
+    await walkDir(lightdashModelsDir);
+    // Filter to only include files that actually contain `type: model`
+    const modelFiles = [];
+    for await (const filePath of yamlFiles) {
+        const isModel = await isLightdashModelFile(filePath);
+        if (isModel) {
+            modelFiles.push(filePath);
+        }
+        else {
+            globalState_1.default.debug(`Skipping ${filePath}: not a valid Lightdash model file (missing type: model)`);
+        }
+    }
+    return modelFiles;
+}
+/**
+ * Load all Lightdash YAML models from a project directory
+ */
+async function loadLightdashModels(projectDir) {
+    const modelFiles = await findLightdashModelFiles(projectDir);
+    globalState_1.default.debug(`Found ${modelFiles.length} Lightdash model files in ${projectDir}`);
+    const models = [];
+    for await (const filePath of modelFiles) {
+        try {
+            const model = await loadLightdashModel(filePath);
+            models.push(model);
+            globalState_1.default.debug(`Loaded Lightdash model: ${model.name}`);
+        }
+        catch (error) {
+            console.error(`Warning: Failed to load ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return models;
+}

package/dist/lightdash/projectType.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Project type detection utilities
+ *
+ * Determines whether a project is:
+ * - A Lightdash YAML-only project (no dbt required)
+ * - A dbt project (requires dbt)
+ *
+ * Detection order:
+ * 1. If ANY Lightdash YAML models exist (with `type: model`) → YAML-only project
+ * 2. Otherwise → dbt project
+ *
+ * For YAML-only projects:
+ * - warehouseCredentials, skipDbtCompile, skipWarehouseCatalog are fixed
+ * - dbt is never checked (user may not have it installed)
+ *
+ * For dbt projects:
+ * - User controls warehouseCredentials, skipDbtCompile, skipWarehouseCatalog
+ */
+/**
+ * Enum for project types to ensure type safety
+ */
+export declare enum CliProjectType {
+    LightdashYaml = "lightdash-yaml",
+    Dbt = "dbt"
+}
+export type LightdashYamlProjectConfig = {
+    type: CliProjectType.LightdashYaml;
+    /**
+     * YAML-only projects don't load warehouse credentials from dbt profiles
+     */
+    warehouseCredentials: false;
+    /**
+     * YAML-only projects skip dbt compilation
+     */
+    skipDbtCompile: true;
+    /**
+     * YAML-only projects skip warehouse catalog (types are in YAML)
+     */
+    skipWarehouseCatalog: true;
+};
+export type DbtProjectConfig = {
+    type: CliProjectType.Dbt;
+    /**
+     * User-controlled: whether to load warehouse credentials from dbt profiles
+     */
+    warehouseCredentials: boolean | undefined;
+    /**
+     * User-controlled: whether to skip dbt compilation
+     */
+    skipDbtCompile: boolean | undefined;
+    /**
+     * User-controlled: whether to skip warehouse catalog fetch
+     */
+    skipWarehouseCatalog: boolean | undefined;
+};
+export type ProjectTypeConfig = LightdashYamlProjectConfig | DbtProjectConfig;
+export declare function isLightdashYamlProject(config: ProjectTypeConfig): config is LightdashYamlProjectConfig;
+export declare function isDbtProject(config: ProjectTypeConfig): config is DbtProjectConfig;
+type DetectProjectTypeOptions = {
+    /**
+     * Path to the project directory
+     */
+    projectDir: string;
+    /**
+     * User-specified options (only used for dbt projects)
+     */
+    userOptions?: {
+        warehouseCredentials?: boolean;
+        skipDbtCompile?: boolean;
+        skipWarehouseCatalog?: boolean;
+    };
+};
+/**
+ * Detect project type based on project contents
+ *
+ * Detection is based on YAML files containing `type: model` (or versioned variants).
+ * This ensures we don't get false positives from other YAML files like content-as-code spaces.
+ *
+ * If ANY Lightdash YAML models exist → YAML-only project (dbt options ignored)
+ * Otherwise → dbt project (user controls dbt options)
+ */
+export declare function detectProjectType(options: DetectProjectTypeOptions): Promise<ProjectTypeConfig>;
+export {};
+//# sourceMappingURL=projectType.d.ts.map

package/dist/lightdash/projectType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectType.d.ts","sourceRoot":"","sources":["../../src/lightdash/projectType.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAMH;;GAEG;AACH,oBAAY,cAAc;IACtB,aAAa,mBAAmB;IAChC,GAAG,QAAQ;CACd;AAED,MAAM,MAAM,0BAA0B,GAAG;IACrC,IAAI,EAAE,cAAc,CAAC,aAAa,CAAC;IACnC;;OAEG;IACH,oBAAoB,EAAE,KAAK,CAAC;IAC5B;;OAEG;IACH,cAAc,EAAE,IAAI,CAAC;IACrB;;OAEG;IACH,oBAAoB,EAAE,IAAI,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC3B,IAAI,EAAE,cAAc,CAAC,GAAG,CAAC;IACzB;;OAEG;IACH,oBAAoB,EAAE,OAAO,GAAG,SAAS,CAAC;IAC1C;;OAEG;IACH,cAAc,EAAE,OAAO,GAAG,SAAS,CAAC;IACpC;;OAEG;IACH,oBAAoB,EAAE,OAAO,GAAG,SAAS,CAAC;CAC7C,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,0BAA0B,GAAG,gBAAgB,CAAC;AAE9E,wBAAgB,sBAAsB,CAClC,MAAM,EAAE,iBAAiB,GAC1B,MAAM,IAAI,0BAA0B,CAEtC;AAED,wBAAgB,YAAY,CACxB,MAAM,EAAE,iBAAiB,GAC1B,MAAM,IAAI,gBAAgB,CAE5B;AAED,KAAK,wBAAwB,GAAG;IAC5B;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,WAAW,CAAC,EAAE;QACV,oBAAoB,CAAC,EAAE,OAAO,CAAC;QAC/B,cAAc,CAAC,EAAE,OAAO,CAAC;QACzB,oBAAoB,CAAC,EAAE,OAAO,CAAC;KAClC,CAAC;CACL,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CACnC,OAAO,EAAE,wBAAwB,GAClC,OAAO,CAAC,iBAAiB,CAAC,CAiC5B"}

package/dist/lightdash/projectType.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * Project type detection utilities
+ *
+ * Determines whether a project is:
+ * - A Lightdash YAML-only project (no dbt required)
+ * - A dbt project (requires dbt)
+ *
+ * Detection order:
+ * 1. If ANY Lightdash YAML models exist (with `type: model`) → YAML-only project
+ * 2. Otherwise → dbt project
+ *
+ * For YAML-only projects:
+ * - warehouseCredentials, skipDbtCompile, skipWarehouseCatalog are fixed
+ * - dbt is never checked (user may not have it installed)
+ *
+ * For dbt projects:
+ * - User controls warehouseCredentials, skipDbtCompile, skipWarehouseCatalog
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliProjectType = void 0;
+exports.isLightdashYamlProject = isLightdashYamlProject;
+exports.isDbtProject = isDbtProject;
+exports.detectProjectType = detectProjectType;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const globalState_1 = tslib_1.__importDefault(require("../globalState"));
+const loader_1 = require("./loader");
+/**
+ * Enum for project types to ensure type safety
+ */
+var CliProjectType;
+(function (CliProjectType) {
+    CliProjectType["LightdashYaml"] = "lightdash-yaml";
+    CliProjectType["Dbt"] = "dbt";
+})(CliProjectType || (exports.CliProjectType = CliProjectType = {}));
+function isLightdashYamlProject(config) {
+    return config.type === CliProjectType.LightdashYaml;
+}
+function isDbtProject(config) {
+    return config.type === CliProjectType.Dbt;
+}
+/**
+ * Detect project type based on project contents
+ *
+ * Detection is based on YAML files containing `type: model` (or versioned variants).
+ * This ensures we don't get false positives from other YAML files like content-as-code spaces.
+ *
+ * If ANY Lightdash YAML models exist → YAML-only project (dbt options ignored)
+ * Otherwise → dbt project (user controls dbt options)
+ */
+async function detectProjectType(options) {
+    const absoluteProjectPath = path_1.default.resolve(options.projectDir);
+    // Check for Lightdash YAML models (files with `type: model`)
+    const yamlModelFiles = await (0, loader_1.findLightdashModelFiles)(absoluteProjectPath);
+    if (yamlModelFiles.length > 0) {
+        globalState_1.default.debug(`> Found ${yamlModelFiles.length} Lightdash YAML model(s), using YAML-only project mode`);
+        return {
+            type: CliProjectType.LightdashYaml,
+            warehouseCredentials: false,
+            skipDbtCompile: true,
+            skipWarehouseCatalog: true,
+        };
+    }
+    // No YAML models found → dbt project
+    globalState_1.default.debug('> No Lightdash YAML models found, using dbt project mode');
+    // For dbt projects, --no-warehouse-credentials implies skip dbt compile and warehouse catalog
+    const noCredentials = options.userOptions?.warehouseCredentials === false;
+    return {
+        type: CliProjectType.Dbt,
+        warehouseCredentials: options.userOptions?.warehouseCredentials,
+        skipDbtCompile: noCredentials || options.userOptions?.skipDbtCompile,
+        skipWarehouseCatalog: noCredentials || options.userOptions?.skipWarehouseCatalog,
+    };
+}

package/dist/lightdash-config/index.d.ts

@@ -0,0 +1,2 @@
+export declare const readAndLoadLightdashProjectConfig: (projectDir: string, projectUuid?: string) => Promise<import("@lightdash/common").LightdashProjectConfig>;
+//# sourceMappingURL=index.d.ts.map

package/dist/lightdash-config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lightdash-config/index.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,iCAAiC,GAC1C,YAAY,MAAM,EAClB,cAAc,MAAM,gEAsCvB,CAAC"}

package/dist/lightdash-config/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readAndLoadLightdashProjectConfig = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const promises_1 = tslib_1.__importDefault(require("fs/promises"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const analytics_1 = require("../analytics/analytics");
+const config_1 = require("../config");
+const globalState_1 = tslib_1.__importDefault(require("../globalState"));
+const readAndLoadLightdashProjectConfig = async (projectDir, projectUuid) => {
+    const { user, context } = await (0, config_1.getConfig)();
+    const configPath = path_1.default.join(projectDir, 'lightdash.config.yml');
+    try {
+        const fileContents = await promises_1.default.readFile(configPath, 'utf8');
+        const config = await (0, common_1.loadLightdashProjectConfig)(fileContents, async (lightdashConfig) => {
+            void analytics_1.LightdashAnalytics.track({
+                event: 'lightdashconfig.loaded',
+                properties: {
+                    projectId: projectUuid ?? context?.project ?? '',
+                    userId: user?.userUuid,
+                    organizationId: user?.organizationUuid,
+                    categories_count: Number(Object.keys(lightdashConfig.spotlight.categories ?? {}).length),
+                    default_visibility: lightdashConfig.spotlight.default_visibility,
+                },
+            });
+        });
+        return config;
+    }
+    catch (e) {
+        globalState_1.default.debug(`No lightdash.config.yml found in ${configPath}`);
+        if (e instanceof Error && 'code' in e && e.code === 'ENOENT') {
+            // Return default config if file doesn't exist
+            return {
+                spotlight: common_1.DEFAULT_SPOTLIGHT_CONFIG,
+            };
+        }
+        throw e;
+    }
+};
+exports.readAndLoadLightdashProjectConfig = readAndLoadLightdashProjectConfig;

package/dist/lightdash-config/lightdash-config.test.d.ts

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

package/dist/lightdash-config/lightdash-config.test.d.ts.map

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

package/dist/lightdash-config/lightdash-config.test.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const promises_1 = tslib_1.__importDefault(require("fs/promises"));
+const _1 = require(".");
+const VALID_CONFIG_CONTENTS = 'spotlight:\n' +
+    '  default_visibility: show # Optional, defaults to "show"\n' +
+    '  categories:\n' +
+    '    core:\n' +
+    '      label: "Core Metrics"\n' +
+    '      color: blue\n' +
+    '    experimental:\n' +
+    '      label: "Experimental Metrics"\n' +
+    '      color: orange\n' +
+    '    sales:\n' +
+    '      label: "Sales"\n' +
+    '      color: green\n';
+const VALID_CONFIG = {
+    spotlight: {
+        default_visibility: 'show',
+        categories: {
+            core: { label: 'Core Metrics', color: 'blue' },
+            experimental: { label: 'Experimental Metrics', color: 'orange' },
+            sales: { label: 'Sales', color: 'green' },
+        },
+    },
+};
+const INVALID_CONFIG_CONTENTS = 'spotlight:\n  default_visibility: invalid_value';
+const readFileSpy = jest.spyOn(promises_1.default, 'readFile');
+// Mock getConfig
+jest.mock('../config', () => ({
+    getConfig: jest.fn().mockResolvedValue({ user: null, context: null }),
+}));
+describe('Existing lightdash.config.yml file', () => {
+    describe('when valid', () => {
+        it('should load the config file', async () => {
+            readFileSpy.mockResolvedValueOnce(VALID_CONFIG_CONTENTS);
+            const config = await (0, _1.readAndLoadLightdashProjectConfig)('');
+            expect(config).toEqual(VALID_CONFIG);
+        });
+    });
+    describe('when invalid', () => {
+        it('should throw an error', async () => {
+            readFileSpy.mockResolvedValueOnce(INVALID_CONFIG_CONTENTS);
+            await expect((0, _1.readAndLoadLightdashProjectConfig)('')).rejects.toThrow(/Invalid lightdash.config.yml with errors/);
+        });
+    });
+});
+class MockedFSError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+    }
+}
+describe('Missing lightdash.config.yml file', () => {
+    it('should load the default config', async () => {
+        // ! Throwing a mock error, not something we should rely on but when running the test in jest `e instanceof Error` is false, but when running the code in node it is true
+        // ! Check: https://github.com/jestjs/jest/issues/11808
+        readFileSpy.mockRejectedValueOnce(new MockedFSError('file not found', 'ENOENT'));
+        const config = await (0, _1.readAndLoadLightdashProjectConfig)('./some/path/to/nonexisting/file');
+        expect(config).toEqual({
+            spotlight: common_1.DEFAULT_SPOTLIGHT_CONFIG,
+        });
+    });
+});
+afterAll(() => {
+    jest.restoreAllMocks();
+});

package/dist/styles.d.ts

@@ -0,0 +1,10 @@
+import chalk from 'chalk';
+export declare const error: chalk.Chalk;
+export declare const title: chalk.Chalk;
+export declare const info: (s: string) => string;
+export declare const bold: chalk.Chalk;
+export declare const secondary: chalk.Chalk;
+export declare const success: chalk.Chalk;
+export declare const warning: chalk.Chalk;
+export declare const debug: chalk.Chalk;
+//# sourceMappingURL=styles.d.ts.map

package/dist/styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../src/styles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,eAAO,MAAM,KAAK,aAAY,CAAC;AAC/B,eAAO,MAAM,KAAK,aAA0B,CAAC;AAC7C,eAAO,MAAM,IAAI,GAAI,GAAG,MAAM,WAAM,CAAC;AACrC,eAAO,MAAQ,IAAI,aAAU,CAAC;AAC9B,eAAO,MAAM,SAAS,aAAY,CAAC;AACnC,eAAO,MAAM,OAAO,aAAmB,CAAC;AACxC,eAAO,MAAM,OAAO,aAAe,CAAC;AACpC,eAAO,MAAM,KAAK,aAAa,CAAC"}

package/dist/styles.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debug = exports.warning = exports.success = exports.secondary = exports.bold = exports.info = exports.title = exports.error = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+exports.error = chalk_1.default.red;
+exports.title = chalk_1.default.bold.yellowBright;
+const info = (s) => s;
+exports.info = info;
+exports.bold = chalk_1.default.bold;
+exports.secondary = chalk_1.default.dim;
+exports.success = chalk_1.default.bold.green;
+exports.warning = chalk_1.default.yellow;
+exports.debug = chalk_1.default.grey;

package/entitlements.plist

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <!-- Allow JIT compilation for V8 JavaScript engine -->
+    <key>com.apple.security.cs.allow-jit</key>
+    <true/>
+
+    <!-- Allow unsigned executable memory for V8 -->
+    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+    <true/>
+
+    <!-- Allow DYLD environment variables -->
+    <key>com.apple.security.cs.allow-dyld-environment-variables</key>
+    <true/>
+
+    <!-- Disable library validation to allow loading of unsigned libraries -->
+    <key>com.apple.security.cs.disable-library-validation</key>
+    <true/>
+
+    <!-- Disable executable memory protection -->
+    <key>com.apple.security.cs.disable-executable-page-protection</key>
+    <true/>
+
+    <!-- Network client for API calls -->
+    <key>com.apple.security.network.client</key>
+    <true/>
+
+    <!-- File system access for dbt projects -->
+    <key>com.apple.security.files.user-selected.read-write</key>
+    <true/>
+</dict>
+</plist>

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@claryai/cli",
+  "version": "0.1.0",
+  "description": "Clary CLI tool",
+  "bin": {
+    "clary": "dist/index.js"
+  },
+  "files": [
+    "dist/**/*",
+    "track.sh",
+    "entitlements.plist"
+  ],
+  "dependencies": {
+    "@actions/core": "1.11.1",
+    "@casl/ability": "6.8.0",
+    "@types/columnify": "1.5.1",
+    "ajv": "8.18.0",
+    "ajv-formats": "2.1.1",
+    "better-ajv-errors": "1.2.0",
+    "chalk": "4.1.2",
+    "chokidar": "3.6.0",
+    "columnify": "1.6.0",
+    "commander": "9.5.0",
+    "execa": "5.1.1",
+    "google-auth-library": "9.15.1",
+    "inquirer": "8.2.4",
+    "js-yaml": "4.1.1",
+    "lodash": "4.17.23",
+    "node-fetch": "2.7.0",
+    "nunjucks": "3.2.3",
+    "openid-client": "5.6.4",
+    "ora": "5.4.1",
+    "p-limit": "3.1.0",
+    "parse-node-version": "2.0.0",
+    "unique-names-generator": "4.7.1",
+    "uuid": "11.0.3",
+    "yaml": "2.7.0",
+    "@lightdash/common": "0.2712.0",
+    "@lightdash/warehouses": "0.2712.0"
+  },
+  "devDependencies": {
+    "@types/inquirer": "8.2.4",
+    "@types/js-yaml": "4.0.9",
+    "@types/lodash": "4.14.202",
+    "@types/node-fetch": "2.6.13",
+    "@types/nunjucks": "3.2.1",
+    "@types/parse-node-version": "1.0.0",
+    "@types/uuid": "10.0.0",
+    "@vercel/ncc": "0.38.4",
+    "@yao-pkg/pkg": "6.7.0",
+    "ts-node": "10.9.2",
+    "typescript": "6.0.0-beta"
+  },
+  "scripts": {
+    "test": "jest",
+    "dev": "ts-node src/index.ts",
+    "build": "tsc --build tsconfig.json",
+    "bundle": "ncc build dist/index.js -o bundle -e @duckdb/node-api -e @duckdb/node-bindings -e @duckdb/node-bindings-darwin-arm64 -e @duckdb/node-bindings-darwin-x64 -e @duckdb/node-bindings-linux-arm64 -e @duckdb/node-bindings-linux-x64 -e @duckdb/node-bindings-win32-x64 && bash ./scripts/copy-bundle-assets.sh",
+    "build:binary": "DUCKDB_BINDINGS=node-bindings-darwin-x64,node-bindings-darwin-arm64 pnpm bundle && npx @yao-pkg/pkg bundle/index.js --config pkg.config.json --targets node20-macos-x64,node20-macos-arm64 --output bin/clary --compress Brotli",
+    "typecheck": "tsc --project tsconfig.json --noEmit",
+    "linter": "eslint -c .eslintrc.js --ignore-path ./../../.gitignore",
+    "formatter": "oxfmt",
+    "lint": "pnpm run linter ./src",
+    "fix-lint": "pnpm run linter ./src --fix",
+    "format": "oxfmt ./src --check",
+    "fix-format": "oxfmt ./src",
+    "preinstall": "bash track.sh started || echo 'skipping preinstall'",
+    "postinstall": "bash track.sh completed || echo 'skipping postinstall'",
+    "release": "pnpm publish --no-git-checks --access public"
+  }
+}

package/track.sh

@@ -0,0 +1,116 @@
+#!/bin/bash
+# Send anonymous tracking events to rudderstack so we can monitor installations and errors
+
+INSTALLATION_ID=$(curl -s 'https://www.uuidgenerator.net/api/version4')
+
+os=""
+
+is_mac() {
+    [[ $OSTYPE == darwin* ]]
+}
+
+is_windows() {
+    [[ $OSTYPE == msys* ]]
+}
+
+check_os() {
+    if is_mac; then
+        os="Mac"
+        return
+    fi
+
+    if is_windows; then
+        os="Windows"
+        return
+    fi
+
+    os_name="$(cat /etc/*-release | awk -F= '$1 == "NAME" { gsub(/"/, ""); print $2; exit }')"
+
+    case "$os_name" in
+        Ubuntu*)
+            os="ubuntu"
+            ;;
+        Amazon\ Linux*)
+            os="amazon linux"
+            ;;
+        Debian*)
+            os="debian"
+            ;;
+        Linux\ Mint*)
+            os="linux mint"
+            ;;
+        Red\ Hat*)
+            os="red hat"
+            ;;
+        CentOS*)
+            os="centos"
+            ;;
+        SLES*)
+            os="sles"
+            ;;
+        openSUSE*)
+            os="opensuse"
+            ;;
+        *)
+            os="Not Found: $os_name"
+    esac
+}
+
+# Check whether the given command exists.
+has_cmd() {
+    command -v "$1" > /dev/null 2>&1
+}
+# Check whether 'wget' command exists.
+has_wget() {
+    has_cmd wget
+}
+
+# Check whether 'curl' command exists.
+has_curl() {
+    has_cmd curl
+}
+
+inform_macos_xcrun_requirement() {
+    # Check if xcrun is installed
+    if ! command -v xcrun >/dev/null 2>&1; then
+        echo "⚠️  macOS users: Before installing the Clary CLI, make sure you have 'xcrun' installed."
+        echo "    You can install it by running the following command:"
+        echo "    xcode-select --install"
+        echo "    After installing 'xcrun', you can proceed with the Clary CLI installation."
+        echo ""
+    fi
+}
+
+if  [[ $NODE_ENV == "development" || "$CI" == "true" ]]; then 
+    echo "Do not send tracking on NODE_ENV=$NODE_ENV or CI=$CI mode" 
+    exit 0 
+fi
+
+if is_mac; then
+    inform_macos_xcrun_requirement
+fi
+
+track() {
+
+  check_os
+  
+  DATA='{
+    "anonymousId":"'"$INSTALLATION_ID"'",
+    "event": "lightdash_cli.install.'"$1"'",
+    "properties": { "os": "'"$os"'"}
+  }'
+  echo $DATA
+  URL="https://analytics.getclary.com/v1/track"
+  HEADER='Content-Type: application/json'
+  HEADER_AUTH='Authorization: Basic MXZxa1NsV01WdFlPbDcwcmszUVNFMHYxZnFZOg=='
+
+  if has_curl; then
+      curl -sfL -d "$DATA" --header "$HEADER" --header "$HEADER_AUTH" "$URL" > /dev/null 2>&1
+  elif has_wget; then
+      wget -q --post-data="$DATA" --header="$HEADER" --header "$HEADER_AUTH" "$URL" > /dev/null 2>&1
+  fi
+}
+
+track $1
+
+exit 0