@claryai/cli 0.1.0

package/dist/handlers/installSkills.js

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installSkillsHandler = void 0;
+exports.getVersionWithSkills = getVersionWithSkills;
+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 analytics_1 = require("../analytics/analytics");
+const env_1 = require("../env");
+const globalState_1 = tslib_1.__importDefault(require("../globalState"));
+const styles = tslib_1.__importStar(require("../styles"));
+const SKILL_MANIFEST_FILENAME = '.clary-skill-manifest.json';
+const DEFAULT_SOURCE_REPO = 'claryai/lightdash-fork';
+function getGitHubApiBase(repo) {
+    return `https://api.github.com/repos/${repo}/contents`;
+}
+function getGitHubRawBase(repo) {
+    return `https://raw.githubusercontent.com/${repo}/${env_1.CLI_VERSION}`;
+}
+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, repo) {
+    const url = `${getGitHubApiBase(repo)}/${repoPath}?ref=${env_1.CLI_VERSION}`;
+    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': 'clary-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': 'clary-cli',
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch file: ${response.status} ${response.statusText}`);
+    }
+    return response.text();
+}
+function resolveSymlinkTarget(symlinkPath, target) {
+    const symlinkDir = path.posix.dirname(symlinkPath);
+    return path.posix.normalize(path.posix.join(symlinkDir, target.trim()));
+}
+function interpolateVersionPlaceholders(content) {
+    return content.replace(/\{\{CLI_VERSION\}\}/g, env_1.CLI_VERSION);
+}
+/* eslint-disable no-await-in-loop */
+// Sequential downloads are intentional to avoid GitHub rate limits and handle symlinks
+async function downloadSkillFiles(repoPath, localDir, repo, 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, repo);
+    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, repo, visited);
+        }
+        else if (item.type === 'symlink' && item.target) {
+            // Resolve the symlink and fetch the actual content
+            const resolvedPath = 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, repo);
+                // 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, repo, visited);
+                    }
+                    else if (targetItem.download_url) {
+                        const content = await fetchFileContent(targetItem.download_url);
+                        fs.writeFileSync(targetLocalPath, interpolateVersionPlaceholders(content));
+                    }
+                }
+            }
+            catch {
+                // It's a file, fetch its content directly
+                const downloadUrl = `${getGitHubRawBase(repo)}/${resolvedPath}`;
+                const content = await fetchFileContent(downloadUrl);
+                // Ensure parent directory exists
+                fs.mkdirSync(path.dirname(localPath), { recursive: true });
+                fs.writeFileSync(localPath, interpolateVersionPlaceholders(content));
+            }
+        }
+        else if (item.type === 'file' && item.download_url) {
+            let content = await fetchFileContent(item.download_url);
+            // GitHub returns symlink content as the target path - resolve it
+            if (content.startsWith('../') || content.startsWith('./')) {
+                const resolvedPath = resolveSymlinkTarget(item.path, content);
+                globalState_1.default.debug(`> Resolving symlink: ${item.path} -> ${resolvedPath}`);
+                content = await fetchFileContent(`${getGitHubRawBase(repo)}/${resolvedPath}`);
+            }
+            fs.mkdirSync(path.dirname(localPath), { recursive: true });
+            fs.writeFileSync(localPath, interpolateVersionPlaceholders(content));
+        }
+    }
+}
+/* eslint-enable no-await-in-loop */
+async function listAvailableSkills(repo) {
+    const items = await fetchGitHubDirectory('skills', repo);
+    return items.filter((item) => item.type === 'dir').map((item) => item.name);
+}
+function writeSkillManifest(skillDir) {
+    const manifest = {
+        version: env_1.CLI_VERSION,
+        installed_at: new Date().toISOString(),
+    };
+    fs.writeFileSync(path.join(skillDir, SKILL_MANIFEST_FILENAME), JSON.stringify(manifest, null, 2));
+}
+function readSkillManifest(skillDir) {
+    const manifestPath = path.join(skillDir, SKILL_MANIFEST_FILENAME);
+    if (!fs.existsSync(manifestPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function findInstalledSkills() {
+    const agents = ['claude', 'cursor', 'codex'];
+    const results = [];
+    const roots = [
+        { path: os.homedir(), scope: 'global' },
+    ];
+    const cwd = process.cwd();
+    const gitRoot = findGitRoot(cwd);
+    roots.push({ path: gitRoot || cwd, scope: 'project' });
+    for (const root of roots) {
+        for (const agent of agents) {
+            const skillsDir = path.join(root.path, getAgentSkillsDir(agent));
+            if (!fs.existsSync(skillsDir)) {
+                // eslint-disable-next-line no-continue
+                continue;
+            }
+            let entries;
+            try {
+                entries = fs.readdirSync(skillsDir);
+            }
+            catch {
+                // eslint-disable-next-line no-continue
+                continue;
+            }
+            entries
+                .filter((e) => fs.statSync(path.join(skillsDir, e)).isDirectory())
+                .forEach((entry) => {
+                const manifest = readSkillManifest(path.join(skillsDir, entry));
+                if (manifest) {
+                    results.push({
+                        name: entry,
+                        version: manifest.version,
+                        agent,
+                        scope: root.scope,
+                        isOutdated: manifest.version !== env_1.CLI_VERSION,
+                    });
+                }
+            });
+        }
+    }
+    return results;
+}
+function getVersionWithSkills() {
+    const lines = [env_1.CLI_VERSION];
+    const skills = findInstalledSkills();
+    if (skills.length > 0) {
+        lines.push('');
+        lines.push('Installed skills:');
+        for (const skill of skills) {
+            const line = `  ${skill.name} v${skill.version} [${skill.agent}, ${skill.scope}]`;
+            lines.push(skill.isOutdated ? styles.warning(line) : line);
+        }
+        const outdated = skills.filter((s) => s.isOutdated);
+        if (outdated.length > 0) {
+            lines.push('');
+            lines.push(styles.warning('Update with:'));
+            const seen = new Set();
+            for (const skill of outdated) {
+                const globalFlag = skill.scope === 'global' ? ' --global' : '';
+                const agentFlag = ` --agent ${skill.agent}`;
+                const cmd = `clary install-skills${globalFlag}${agentFlag}`;
+                if (!seen.has(cmd)) {
+                    seen.add(cmd);
+                    lines.push(styles.warning(`  ${cmd}`));
+                }
+            }
+        }
+    }
+    return lines.join('\n');
+}
+const installSkillsHandler = async (options) => {
+    const startTime = Date.now();
+    let success = true;
+    globalState_1.default.setVerbose(options.verbose);
+    const installPath = getInstallPath(options);
+    const sourceRepo = options.source ?? DEFAULT_SOURCE_REPO;
+    console.error(styles.title('\n⚡ Clary Skills Installer\n'));
+    console.error(`Agent: ${styles.bold(options.agent)}`);
+    console.error(`Scope: ${styles.bold(options.global ? 'global' : 'project')}`);
+    console.error(`Version: ${styles.bold(env_1.CLI_VERSION)}`);
+    if (sourceRepo !== DEFAULT_SOURCE_REPO) {
+        console.error(`Source: ${styles.bold(sourceRepo)}`);
+    }
+    console.error(`Install path: ${styles.bold(installPath)}\n`);
+    const spinner = globalState_1.default.startSpinner('Fetching available skills...');
+    try {
+        const skills = await listAvailableSkills(sourceRepo);
+        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, sourceRepo);
+                writeSkillManifest(skillLocalPath);
+                skillSpinner.succeed(`Installed skill: ${skill} (v${env_1.CLI_VERSION})`);
+            }
+            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) {
+        success = false;
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        spinner.fail(`Failed to fetch skills: ${errorMessage}`);
+        throw err;
+    }
+    finally {
+        await analytics_1.LightdashAnalytics.track({
+            event: 'command.executed',
+            properties: {
+                command: 'install-skills',
+                durationMs: Date.now() - startTime,
+                success,
+            },
+        });
+    }
+};
+exports.installSkillsHandler = installSkillsHandler;

package/dist/handlers/lint/ajvToSarif.d.ts

@@ -0,0 +1,66 @@
+import type { ErrorObject } from 'ajv';
+type LocationMap = Map<string, {
+    line: number;
+    column: number;
+}>;
+type FileValidationResult = {
+    filePath: string;
+    errors: ErrorObject[];
+    fileContent: string;
+    locationMap?: LocationMap;
+    schemaType: 'chart' | 'dashboard' | 'model';
+};
+export type SarifLog = {
+    version: '2.1.0';
+    $schema: string;
+    runs: SarifRun[];
+};
+type SarifRun = {
+    tool: {
+        driver: {
+            name: string;
+            version: string;
+            informationUri?: string;
+            rules?: SarifRule[];
+        };
+    };
+    results: SarifResult[];
+};
+type SarifRule = {
+    id: string;
+    shortDescription: {
+        text: string;
+    };
+    fullDescription?: {
+        text: string;
+    };
+    help?: {
+        text: string;
+    };
+};
+export type SarifResult = {
+    ruleId: string;
+    level: 'error' | 'warning' | 'note';
+    message: {
+        text: string;
+    };
+    locations: SarifLocation[];
+    properties?: Record<string, unknown>;
+};
+type SarifLocation = {
+    physicalLocation: {
+        artifactLocation: {
+            uri: string;
+        };
+        region: {
+            startLine: number;
+            startColumn: number;
+        };
+    };
+};
+/**
+ * Convert validation results to SARIF format
+ */
+export declare function createSarifReport(results: FileValidationResult[]): SarifLog;
+export {};
+//# sourceMappingURL=ajvToSarif.d.ts.map

package/dist/handlers/lint/ajvToSarif.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ajvToSarif.d.ts","sourceRoot":"","sources":["../../../src/handlers/lint/ajvToSarif.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,KAAK,CAAC;AAEvC,KAAK,WAAW,GAAG,GAAG,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAEjE,KAAK,oBAAoB,GAAG;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,UAAU,EAAE,OAAO,GAAG,WAAW,GAAG,OAAO,CAAC;CAC/C,CAAC;AAGF,MAAM,MAAM,QAAQ,GAAG;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,QAAQ,EAAE,CAAC;CACpB,CAAC;AAEF,KAAK,QAAQ,GAAG;IACZ,IAAI,EAAE;QACF,MAAM,EAAE;YACJ,IAAI,EAAE,MAAM,CAAC;YACb,OAAO,EAAE,MAAM,CAAC;YAChB,cAAc,CAAC,EAAE,MAAM,CAAC;YACxB,KAAK,CAAC,EAAE,SAAS,EAAE,CAAC;SACvB,CAAC;KACL,CAAC;IACF,OAAO,EAAE,WAAW,EAAE,CAAC;CAC1B,CAAC;AAEF,KAAK,SAAS,GAAG;IACb,EAAE,EAAE,MAAM,CAAC;IACX,gBAAgB,EAAE;QACd,IAAI,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,eAAe,CAAC,EAAE;QACd,IAAI,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,IAAI,CAAC,EAAE;QACH,IAAI,EAAE,MAAM,CAAC;KAChB,CAAC;CACL,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;IACpC,OAAO,EAAE;QACL,IAAI,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACxC,CAAC;AAEF,KAAK,aAAa,GAAG;IACjB,gBAAgB,EAAE;QACd,gBAAgB,EAAE;YACd,GAAG,EAAE,MAAM,CAAC;SACf,CAAC;QACF,MAAM,EAAE;YACJ,SAAS,EAAE,MAAM,CAAC;YAClB,WAAW,EAAE,MAAM,CAAC;SACvB,CAAC;KACL,CAAC;CACL,CAAC;AAmJF;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,oBAAoB,EAAE,GAAG,QAAQ,CAwG3E"}

package/dist/handlers/lint/ajvToSarif.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSarifReport = createSarifReport;
+/**
+ * Find the line and column number in YAML content for a given data path using regex-based search.
+ *
+ * This is a FALLBACK strategy used when the locationMap doesn't have an entry for the error path.
+ * Primary use case: root-level missing required properties (dataPath='/' which isn't in locationMap).
+ *
+ * The function uses regex patterns to search through the YAML content and locate:
+ * - Array items by counting '-' markers
+ * - Nested properties within array items
+ * - Simple top-level keys
+ *
+ * Returns line 1, column 1 if no match is found (used for root-level errors).
+ */
+function findLocationForPath(yamlContent, dataPath) {
+    const lines = yamlContent.split('\n');
+    // Remove leading slash and split path
+    const pathParts = dataPath
+        .replace(/^\//, '')
+        .split('/')
+        .filter((p) => p !== '');
+    if (pathParts.length === 0) {
+        // Error at root level
+        return { line: 1, column: 1 };
+    }
+    // Check if we have an array index in the path (e.g., /dimensions/1/type)
+    let arrayParentKey = null;
+    let arrayIndex = null;
+    let propertyInArray = null;
+    // Look for pattern: parent/index/property
+    if (pathParts.length >= 3) {
+        const secondToLast = pathParts[pathParts.length - 2];
+        if (/^\d+$/.test(secondToLast)) {
+            // We have an array index
+            arrayParentKey = pathParts[pathParts.length - 3];
+            arrayIndex = parseInt(secondToLast, 10);
+            propertyInArray = pathParts[pathParts.length - 1];
+        }
+    }
+    else if (pathParts.length === 2) {
+        const [firstPart, lastPart] = pathParts;
+        if (/^\d+$/.test(lastPart)) {
+            // Path is like /dimensions/1
+            arrayParentKey = firstPart;
+            arrayIndex = parseInt(lastPart, 10);
+        }
+    }
+    // For array items with nested property errors (e.g., /dimensions/1/type)
+    if (arrayParentKey && arrayIndex !== null && propertyInArray) {
+        const parentPattern = new RegExp(`^\\s*${arrayParentKey}\\s*:`);
+        let foundParent = false;
+        let arrayItemCount = 0;
+        let arrayItemStartLine = -1;
+        for (let i = 0; i < lines.length; i += 1) {
+            if (!foundParent && parentPattern.test(lines[i])) {
+                foundParent = true;
+            }
+            else if (foundParent && /^\s*-\s/.test(lines[i])) {
+                if (arrayItemCount === arrayIndex) {
+                    arrayItemStartLine = i;
+                    break;
+                }
+                arrayItemCount += 1;
+            }
+        }
+        // Now find the nested property within this array item
+        if (arrayItemStartLine >= 0) {
+            // Check if property is on the same line as the array marker (e.g., "- id: value")
+            const sameLinePattern = new RegExp(`^\\s*-\\s+${propertyInArray}\\s*:`);
+            if (sameLinePattern.test(lines[arrayItemStartLine])) {
+                const match = lines[arrayItemStartLine].match(/^(\s*-\s+)/);
+                const column = match ? match[1].length + 1 : 1;
+                return { line: arrayItemStartLine + 1, column };
+            }
+            // Otherwise, look for the property on subsequent lines
+            const propPattern = new RegExp(`^\\s*${propertyInArray}\\s*:`);
+            for (let i = arrayItemStartLine + 1; i < Math.min(lines.length, arrayItemStartLine + 20); i += 1) {
+                if (propPattern.test(lines[i])) {
+                    const match = lines[i].match(/^(\s*)/);
+                    const column = match ? match[1].length + 1 : 1;
+                    return { line: i + 1, column };
+                }
+                if (/^\s*-\s/.test(lines[i])) {
+                    break;
+                }
+            }
+        }
+    }
+    // Simple search for the last key in the path
+    const lastPart = pathParts[pathParts.length - 1];
+    if (!/^\d+$/.test(lastPart)) {
+        const keyPattern = new RegExp(`^\\s*${lastPart}\\s*:`);
+        for (let i = 0; i < lines.length; i += 1) {
+            if (keyPattern.test(lines[i])) {
+                const match = lines[i].match(/^(\s*)/);
+                const column = match ? match[1].length + 1 : 1;
+                return { line: i + 1, column };
+            }
+        }
+    }
+    return { line: 1, column: 1 };
+}
+/**
+ * Get a friendly error message for an AJV error
+ */
+function getFriendlyMessage(error) {
+    if (error.keyword === 'required' && error.params.missingProperty) {
+        return `Missing required property '${error.params.missingProperty}'`;
+    }
+    if (error.keyword === 'additionalProperties' &&
+        error.params.additionalProperty) {
+        return `Property '${error.params.additionalProperty}' is not allowed`;
+    }
+    if (error.keyword === 'type') {
+        return `Expected type '${error.params.type}'`;
+    }
+    if (error.keyword === 'enum' && error.params.allowedValues) {
+        return `Value must be one of: ${error.params.allowedValues.join(', ')}`;
+    }
+    if (error.keyword === 'const') {
+        return `Value must be '${error.params.allowedValue}'`;
+    }
+    return error.message || 'Validation error';
+}
+/**
+ * Convert validation results to SARIF format
+ */
+function createSarifReport(results) {
+    const sarifResults = [];
+    const rules = new Map();
+    for (const result of results) {
+        for (const error of result.errors) {
+            // For additionalProperties errors, append the property name to the path
+            // Handle root-level errors carefully to avoid double slashes (//propertyName)
+            let dataPath = error.instancePath || '/';
+            if (error.keyword === 'additionalProperties' &&
+                error.params.additionalProperty) {
+                dataPath =
+                    dataPath === '/'
+                        ? `/${error.params.additionalProperty}`
+                        : `${dataPath}/${error.params.additionalProperty}`;
+            }
+            // Determine error location using a two-strategy approach:
+            // 1. PRIMARY: Use locationMap (built from YAML AST during parsing)
+            //    - Fast O(1) lookup for ~95% of cases
+            //    - Works for: additional properties, type errors, enum errors, nested errors, array items
+            //    - Works for: nested missing required fields (e.g., missing 'exploreName' in 'metricQuery')
+            //
+            // 2. FALLBACK: Use regex-based search when locationMap lookup fails
+            //    - Needed for: root-level missing required properties (e.g., missing 'name', 'version')
+            //      These have dataPath='/' which doesn't exist in locationMap since it stores actual YAML keys
+            //    - Also provides defensive error handling if AST traversal misses any edge cases
+            let location = null;
+            if (result.locationMap) {
+                location = result.locationMap.get(dataPath) || null;
+            }
+            if (!location) {
+                // Fallback to regex search - primarily for root-level missing required properties
+                location = findLocationForPath(result.fileContent, dataPath);
+            }
+            const message = getFriendlyMessage(error);
+            const ruleId = `${result.schemaType}/${error.keyword}`;
+            // Add rule if we haven't seen it before
+            if (!rules.has(ruleId)) {
+                rules.set(ruleId, {
+                    id: ruleId,
+                    shortDescription: {
+                        text: `${error.keyword} validation error`,
+                    },
+                });
+            }
+            const sarifResult = {
+                ruleId,
+                level: 'error',
+                message: {
+                    text: message,
+                },
+                locations: [
+                    {
+                        physicalLocation: {
+                            artifactLocation: {
+                                uri: result.filePath,
+                            },
+                            region: {
+                                startLine: location?.line || 1,
+                                startColumn: location?.column || 1,
+                            },
+                        },
+                    },
+                ],
+            };
+            // Add additional context
+            if (error.params) {
+                const properties = {};
+                Object.entries(error.params).forEach(([key, value]) => {
+                    properties[key] = value;
+                });
+                sarifResult.properties = { errorParams: properties };
+            }
+            sarifResults.push(sarifResult);
+        }
+    }
+    return {
+        version: '2.1.0',
+        $schema: 'https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json',
+        runs: [
+            {
+                tool: {
+                    driver: {
+                        name: 'lightdash-lint',
+                        version: '1.0.0',
+                        informationUri: 'https://github.com/lightdash/lightdash',
+                        rules: Array.from(rules.values()),
+                    },
+                },
+                results: sarifResults,
+            },
+        ],
+    };
+}

package/dist/handlers/lint/sarifFormatter.d.ts

@@ -0,0 +1,14 @@
+import type { SarifLog } from './ajvToSarif';
+/**
+ * Format SARIF results for CLI output
+ */
+export declare function formatSarifForCli(sarifLog: SarifLog, searchPath: string): string;
+/**
+ * Get summary statistics from SARIF log
+ */
+export declare function getSarifSummary(sarifLog: SarifLog): {
+    totalFiles: number;
+    totalErrors: number;
+    hasErrors: boolean;
+};
+//# sourceMappingURL=sarifFormatter.d.ts.map

package/dist/handlers/lint/sarifFormatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sarifFormatter.d.ts","sourceRoot":"","sources":["../../../src/handlers/lint/sarifFormatter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAe,MAAM,cAAc,CAAC;AAgC1D;;GAEG;AACH,wBAAgB,iBAAiB,CAC7B,QAAQ,EAAE,QAAQ,EAClB,UAAU,EAAE,MAAM,GACnB,MAAM,CA2ER;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,QAAQ,GAAG;IACjD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;CACtB,CAsBA"}