@lightdash/cli 0.2395.0 → 0.2397.0

package/dist/handlers/installSkills.d.ts

@@ -0,0 +1,10 @@
+type AgentType = 'claude' | 'cursor' | 'codex';
+type InstallSkillsOptions = {
+    verbose: boolean;
+    agent: AgentType;
+    global: boolean;
+    path?: string;
+};
+export declare const installSkillsHandler: (options: InstallSkillsOptions) => Promise<void>;
+export {};
+//# sourceMappingURL=installSkills.d.ts.map

package/dist/handlers/installSkills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"installSkills.d.ts","sourceRoot":"","sources":["../../src/handlers/installSkills.ts"],"names":[],"mappings":"AAYA,KAAK,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAC;AAE/C,KAAK,oBAAoB,GAAG;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,SAAS,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAsMF,eAAO,MAAM,oBAAoB,YACpB,oBAAoB,KAC9B,OAAO,CAAC,IAAI,CA8Dd,CAAC"}

package/dist/handlers/installSkills.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installSkillsHandler = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
+const os = tslib_1.__importStar(require("os"));
+const path = tslib_1.__importStar(require("path"));
+const globalState_1 = tslib_1.__importDefault(require("../globalState"));
+const styles = tslib_1.__importStar(require("../styles"));
+const GITHUB_API_BASE = 'https://api.github.com/repos/lightdash/lightdash/contents';
+const GITHUB_RAW_BASE = 'https://raw.githubusercontent.com/lightdash/lightdash/main';
+function getAgentSkillsDir(agent) {
+    switch (agent) {
+        case 'claude':
+            return '.claude/skills';
+        case 'cursor':
+            return '.cursor/skills';
+        case 'codex':
+            return '.codex/skills';
+        default:
+            throw new Error(`Unknown agent type: ${agent}`);
+    }
+}
+function findGitRoot(startDir) {
+    let currentDir = startDir;
+    while (currentDir !== path.parse(currentDir).root) {
+        if (fs.existsSync(path.join(currentDir, '.git'))) {
+            return currentDir;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    // Check root directory
+    if (fs.existsSync(path.join(currentDir, '.git'))) {
+        return currentDir;
+    }
+    return null;
+}
+function getInstallPath(options) {
+    const skillsDir = getAgentSkillsDir(options.agent);
+    // If explicit path provided, use it
+    if (options.path) {
+        return path.join(options.path, skillsDir);
+    }
+    // If global, use home directory
+    if (options.global) {
+        return path.join(os.homedir(), skillsDir);
+    }
+    // Project install: find git root
+    const cwd = process.cwd();
+    const gitRoot = findGitRoot(cwd);
+    if (gitRoot) {
+        globalState_1.default.debug(`> Found git root at: ${gitRoot}`);
+        return path.join(gitRoot, skillsDir);
+    }
+    // No git root found, use current directory
+    globalState_1.default.debug(`> No git root found, using current directory: ${cwd}`);
+    return path.join(cwd, skillsDir);
+}
+async function fetchGitHubDirectory(repoPath) {
+    const url = `${GITHUB_API_BASE}/${repoPath}`;
+    globalState_1.default.debug(`> Fetching GitHub directory: ${url}`);
+    const response = await (0, node_fetch_1.default)(url, {
+        headers: {
+            Accept: 'application/vnd.github.v3+json',
+            'User-Agent': 'lightdash-cli',
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch GitHub directory: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+}
+async function fetchFileContent(downloadUrl) {
+    globalState_1.default.debug(`> Fetching file: ${downloadUrl}`);
+    const response = await (0, node_fetch_1.default)(downloadUrl, {
+        headers: {
+            'User-Agent': 'lightdash-cli',
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch file: ${response.status} ${response.statusText}`);
+    }
+    return response.text();
+}
+async function resolveSymlinkTarget(symlinkPath, target) {
+    // Resolve the symlink relative to its location
+    const symlinkDir = path.dirname(symlinkPath);
+    const resolvedPath = path.posix.normalize(path.posix.join(symlinkDir, target));
+    return resolvedPath;
+}
+/* eslint-disable no-await-in-loop */
+// Sequential downloads are intentional to avoid GitHub rate limits and handle symlinks
+async function downloadSkillFiles(repoPath, localDir, visited = new Set()) {
+    // Prevent infinite loops with symlinks
+    if (visited.has(repoPath)) {
+        globalState_1.default.debug(`> Skipping already visited path: ${repoPath}`);
+        return;
+    }
+    visited.add(repoPath);
+    const items = await fetchGitHubDirectory(repoPath);
+    for (const item of items) {
+        const localPath = path.join(localDir, item.name);
+        if (item.type === 'dir') {
+            fs.mkdirSync(localPath, { recursive: true });
+            await downloadSkillFiles(item.path, localPath, visited);
+        }
+        else if (item.type === 'symlink' && item.target) {
+            // Resolve the symlink and fetch the actual content
+            const resolvedPath = await resolveSymlinkTarget(item.path, item.target);
+            globalState_1.default.debug(`> Resolving symlink: ${item.path} -> ${resolvedPath}`);
+            // Check if the target is a directory or file by fetching it
+            try {
+                const targetItems = await fetchGitHubDirectory(resolvedPath);
+                // It's a directory, create it and download contents
+                fs.mkdirSync(localPath, { recursive: true });
+                for (const targetItem of targetItems) {
+                    const targetLocalPath = path.join(localPath, targetItem.name);
+                    if (targetItem.type === 'dir') {
+                        fs.mkdirSync(targetLocalPath, { recursive: true });
+                        await downloadSkillFiles(targetItem.path, targetLocalPath, visited);
+                    }
+                    else if (targetItem.download_url) {
+                        const content = await fetchFileContent(targetItem.download_url);
+                        fs.writeFileSync(targetLocalPath, content);
+                    }
+                }
+            }
+            catch {
+                // It's a file, fetch its content directly
+                const downloadUrl = `${GITHUB_RAW_BASE}/${resolvedPath}`;
+                const content = await fetchFileContent(downloadUrl);
+                // Ensure parent directory exists
+                fs.mkdirSync(path.dirname(localPath), { recursive: true });
+                fs.writeFileSync(localPath, content);
+            }
+        }
+        else if (item.type === 'file' && item.download_url) {
+            const content = await fetchFileContent(item.download_url);
+            // Ensure parent directory exists
+            fs.mkdirSync(path.dirname(localPath), { recursive: true });
+            fs.writeFileSync(localPath, content);
+        }
+    }
+}
+/* eslint-enable no-await-in-loop */
+async function listAvailableSkills() {
+    const items = await fetchGitHubDirectory('skills');
+    return items.filter((item) => item.type === 'dir').map((item) => item.name);
+}
+const installSkillsHandler = async (options) => {
+    globalState_1.default.setVerbose(options.verbose);
+    const installPath = getInstallPath(options);
+    console.error(styles.title('\n⚡ Lightdash Skills Installer\n'));
+    console.error(`Agent: ${styles.bold(options.agent)}`);
+    console.error(`Scope: ${styles.bold(options.global ? 'global' : 'project')}`);
+    console.error(`Install path: ${styles.bold(installPath)}\n`);
+    const spinner = globalState_1.default.startSpinner('Fetching available skills...');
+    try {
+        const skills = await listAvailableSkills();
+        if (skills.length === 0) {
+            spinner.fail('No skills found in the repository');
+            return;
+        }
+        spinner.text = `Found ${skills.length} skill(s): ${skills.join(', ')}`;
+        spinner.succeed();
+        // Create install directory
+        fs.mkdirSync(installPath, { recursive: true });
+        // Install skills sequentially to provide meaningful progress feedback
+        /* eslint-disable no-await-in-loop */
+        for (const skill of skills) {
+            const skillSpinner = globalState_1.default.startSpinner(`Installing skill: ${skill}...`);
+            const skillLocalPath = path.join(installPath, skill);
+            try {
+                // Remove existing skill directory if it exists
+                if (fs.existsSync(skillLocalPath)) {
+                    fs.rmSync(skillLocalPath, { recursive: true, force: true });
+                }
+                fs.mkdirSync(skillLocalPath, { recursive: true });
+                await downloadSkillFiles(`skills/${skill}`, skillLocalPath);
+                skillSpinner.succeed(`Installed skill: ${skill}`);
+            }
+            catch (err) {
+                const errorMessage = err instanceof Error ? err.message : String(err);
+                skillSpinner.fail(`Failed to install skill ${skill}: ${errorMessage}`);
+            }
+        }
+        /* eslint-enable no-await-in-loop */
+        console.error(styles.success('\n✓ Skills installed successfully!\n'));
+        console.error(`Skills are available at: ${styles.bold(installPath)}\n`);
+    }
+    catch (err) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        spinner.fail(`Failed to fetch skills: ${errorMessage}`);
+        throw err;
+    }
+};
+exports.installSkillsHandler = installSkillsHandler;

package/dist/handlers/sql.d.ts

@@ -0,0 +1,9 @@
+type SqlHandlerOptions = {
+    output: string;
+    limit?: number;
+    pageSize?: number;
+    verbose?: boolean;
+};
+export declare const sqlHandler: (sql: string, options: SqlHandlerOptions) => Promise<void>;
+export {};
+//# sourceMappingURL=sql.d.ts.map

package/dist/handlers/sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql.d.ts","sourceRoot":"","sources":["../../src/handlers/sql.ts"],"names":[],"mappings":"AAYA,KAAK,iBAAiB,GAAG;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AA0FF,eAAO,MAAM,UAAU,QACd,MAAM,WACF,iBAAiB,KAC3B,OAAO,CAAC,IAAI,CAiEd,CAAC"}

package/dist/handlers/sql.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sqlHandler = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const fs_1 = require("fs");
+const config_1 = require("../config");
+const globalState_1 = tslib_1.__importDefault(require("../globalState"));
+const styles = tslib_1.__importStar(require("../styles"));
+const apiClient_1 = require("./dbt/apiClient");
+const DEFAULT_PAGE_SIZE = 500;
+const POLL_INTERVAL_MS = 500;
+/**
+ * Convert ResultRow array to CSV string
+ */
+function resultsToCsv(columns, rows) {
+    // Escape CSV value: wrap in quotes if contains comma, quote, or newline
+    const escapeValue = (value) => {
+        if (value === null || value === undefined) {
+            return '';
+        }
+        const str = String(value);
+        if (str.includes(',') || str.includes('"') || str.includes('\n')) {
+            return `"${str.replace(/"/g, '""')}"`;
+        }
+        return str;
+    };
+    const header = columns.map(escapeValue).join(',');
+    const dataRows = rows.map((row) => columns.map((col) => escapeValue(row[col]?.value?.raw)).join(','));
+    return [header, ...dataRows].join('\n');
+}
+/**
+ * Fetch query results once
+ */
+async function fetchQueryResults(projectUuid, queryUuid, pageSize) {
+    const url = `/api/v2/projects/${projectUuid}/query/${queryUuid}?pageSize=${pageSize}`;
+    return (0, apiClient_1.lightdashApi)({
+        method: 'GET',
+        url,
+        body: undefined,
+    });
+}
+/**
+ * Sleep for a given duration
+ */
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+/**
+ * Poll for query results until status is READY or ERROR
+ */
+async function pollQueryResults(projectUuid, queryUuid, pageSize) {
+    const poll = async () => {
+        const result = await fetchQueryResults(projectUuid, queryUuid, pageSize);
+        globalState_1.default.debug(`> Query status: ${result.status}`);
+        if (result.status === common_1.QueryHistoryStatus.READY) {
+            return result;
+        }
+        if (result.status === common_1.QueryHistoryStatus.ERROR) {
+            return result;
+        }
+        if (result.status === common_1.QueryHistoryStatus.CANCELLED) {
+            throw new Error('Query was cancelled');
+        }
+        // Still pending, wait and poll again
+        await sleep(POLL_INTERVAL_MS);
+        return poll();
+    };
+    return poll();
+}
+const sqlHandler = async (sql, options) => {
+    globalState_1.default.setVerbose(options.verbose ?? false);
+    const config = await (0, config_1.getConfig)();
+    const projectUuid = config.context?.project;
+    if (!projectUuid) {
+        throw new Error(`No project selected. Run 'lightdash config set-project' first.`);
+    }
+    globalState_1.default.debug(`> Running SQL query against project: ${projectUuid}`);
+    globalState_1.default.debug(`> SQL: ${sql}`);
+    const pageSize = options.pageSize ?? DEFAULT_PAGE_SIZE;
+    // Submit the query
+    const spinner = globalState_1.default.startSpinner('Submitting SQL query...');
+    const submitResult = await (0, apiClient_1.lightdashApi)({
+        method: 'POST',
+        url: `/api/v2/projects/${projectUuid}/query/sql`,
+        body: JSON.stringify({
+            sql,
+            limit: options.limit,
+            context: 'cli',
+        }),
+    });
+    globalState_1.default.debug(`> Query UUID: ${submitResult.queryUuid}`);
+    spinner.text = 'Waiting for query results...';
+    // Poll for results
+    const result = await pollQueryResults(projectUuid, submitResult.queryUuid, pageSize);
+    if (result.status === common_1.QueryHistoryStatus.ERROR) {
+        spinner.fail('Query failed');
+        throw new Error(result.error ?? 'Query execution failed');
+    }
+    if (result.status !== common_1.QueryHistoryStatus.READY) {
+        spinner.fail('Unexpected query status');
+        throw new Error(`Unexpected query status: ${result.status}`);
+    }
+    // Extract column names from the columns metadata
+    const columns = Object.keys(result.columns);
+    const rowCount = result.rows.length;
+    spinner.text = `Writing ${rowCount} rows to ${options.output}...`;
+    // Convert to CSV and write to file
+    const csv = resultsToCsv(columns, result.rows);
+    await fs_1.promises.writeFile(options.output, csv, 'utf8');
+    spinner.succeed(`${styles.success('Success!')} Wrote ${rowCount} rows to ${options.output}`);
+};
+exports.sqlHandler = sqlHandler;

package/dist/index.js

@@ -15,12 +15,14 @@ const download_1 = require("./handlers/download");
 const generate_1 = require("./handlers/generate");
 const generateExposures_1 = require("./handlers/generateExposures");
 const getProject_1 = require("./handlers/getProject");
+const installSkills_1 = require("./handlers/installSkills");
 const lint_1 = require("./handlers/lint");
 const listProjects_1 = require("./handlers/listProjects");
 const login_1 = require("./handlers/login");
 const preview_1 = require("./handlers/preview");
 const renameHandler_1 = require("./handlers/renameHandler");
 const setProject_1 = require("./handlers/setProject");
+const sql_1 = require("./handlers/sql");
 const validate_1 = require("./handlers/validate");
 const styles = tslib_1.__importStar(require("./styles"));
 // Trigger CLI tests
@@ -423,6 +425,44 @@ ${styles.bold('Examples:')}
     .option('--verbose', 'Show detailed output', false)
     .option('-f, --format <format>', 'Output format: cli (default) or json (SARIF format)', 'cli')
     .action(lint_1.lintHandler);
+commander_1.program
+    .command('sql')
+    .description('Run raw SQL query against the warehouse using project credentials')
+    .argument('<query>', 'SQL query to execute')
+    .requiredOption('-o, --output <file>', 'Output file path for CSV results')
+    .option('--limit <number>', 'Maximum rows to return from query', parseIntArgument)
+    .option('--page-size <number>', 'Number of rows per page (default: 500, max: 5000)', parseIntArgument)
+    .option('--verbose', 'Show detailed output', false)
+    .action(sql_1.sqlHandler);
+commander_1.program
+    .command('install-skills')
+    .description('Installs Lightdash skills for AI coding assistants (Claude, Cursor, Codex)')
+    .addHelpText('after', `
+${styles.bold('Examples:')}
+  ${styles.title('⚡')}️lightdash ${styles.bold('install-skills')} ${styles.secondary('-- installs skills for Claude at git root (default)')}
+  ${styles.title('⚡')}️lightdash ${styles.bold('install-skills')} --agent cursor ${styles.secondary('-- installs skills for Cursor')}
+  ${styles.title('⚡')}️lightdash ${styles.bold('install-skills')} --global ${styles.secondary('-- installs skills globally to ~/.claude/skills/')}
+  ${styles.title('⚡')}️lightdash ${styles.bold('install-skills')} --agent codex --global ${styles.secondary('-- installs skills globally for Codex')}
+  ${styles.title('⚡')}️lightdash ${styles.bold('install-skills')} --path ./my-project ${styles.secondary('-- installs skills to a specific path')}
+
+${styles.bold('Installation paths:')}
+  ${styles.secondary('Project-level (default):')}
+    .claude/skills/    (Claude)
+    .cursor/skills/    (Cursor)
+    .codex/skills/     (Codex)
+
+  ${styles.secondary('Global (--global):')}
+    ~/.claude/skills/  (Claude)
+    ~/.cursor/skills/  (Cursor)
+    ~/.codex/skills/   (Codex)
+`)
+    .option('--verbose', 'Show detailed output', false)
+    .addOption(new commander_1.Option('--agent <agent>', 'Target agent for skill installation')
+    .choices(['claude', 'cursor', 'codex'])
+    .default('claude'))
+    .option('--global', 'Install skills globally to home directory instead of project', false)
+    .option('--path <path>', 'Override the install path (skills directory will be created inside)', undefined)
+    .action(installSkills_1.installSkillsHandler);
 const errorHandler = (err) => {
     // Use error message with fallback for safety
     const errorMessage = (0, common_1.getErrorMessage)(err) || 'An unexpected error occurred';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightdash/cli",
-  "version": "0.2395.0",
+  "version": "0.2397.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -38,8 +38,8 @@
     "unique-names-generator": "^4.7.1",
     "uuid": "^11.0.3",
     "yaml": "^2.7.0",
-    "@lightdash/common": "0.2395.0",
-    "@lightdash/warehouses": "0.2395.0"
+    "@lightdash/common": "0.2397.0",
+    "@lightdash/warehouses": "0.2397.0"
   },
   "description": "Lightdash CLI tool",
   "devDependencies": {