@wix/origami-lint 1.34.17 → 1.34.19

package/dist/bi/names.js

@@ -0,0 +1,3 @@
+import { trackStep, trackStepSync } from '@wix/origami-bi';
+export const track = trackStep;
+export const trackSync = trackStepSync;

package/dist/bi/read-stats.js

@@ -0,0 +1,27 @@
+import { readFileSync } from 'node:fs';
+import { ruleRegistry } from "../rules/index.js";
+/** Best-effort transport, explicitly projecting the plugin's data so messages and paths cannot ride along. */
+export function readStats(file, run) {
+    try {
+        const stats = JSON.parse(readFileSync(file, 'utf8'));
+        const validPage = (page) => page === undefined || typeof page === 'string' && /^[\w-]+$/.test(page);
+        const validKind = (kind) => kind === 'page' || kind === 'component';
+        const count = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0;
+        if (!Array.isArray(stats.rules) || !Array.isArray(stats.models)
+            || !stats.rules.every(s => s && ruleRegistry.some(rule => rule.name === s.rule) && validPage(s.page) && validKind(s.kind) && Number.isSafeInteger(s.violations) && s.violations >= 0 && count(s.duration_ms))
+            || !stats.models.every(s => s && validPage(s.page) && validKind(s.kind) && count(s.duration_ms) && count(s.components) && count(s.css_files) && (s.error_name === undefined || s.error_name === 'css_syntax_error' || s.error_name === 'unknown_error')))
+            return;
+        for (const model of stats.models) {
+            run.recordRow('step', 'build_page_model', { item_type: model.kind, item_id: model.page,
+                step_details: { components: model.components, css_files: model.css_files } }, {
+                success: !model.error_name, failure: model.error_name ? { error_name: model.error_name } : undefined, duration_ms: model.duration_ms,
+            });
+        }
+        for (const statsRow of stats.rules) {
+            run.recordRow('lint_rule', statsRow.rule, { item_type: statsRow.kind, item_id: statsRow.page, step_details: { violations: statsRow.violations } }, {
+                success: statsRow.violations === 0, duration_ms: statsRow.duration_ms,
+            });
+        }
+    }
+    catch { /* Missing, truncated or malformed stats never affect lint. */ }
+}

package/dist/bi/stats.js

@@ -0,0 +1,43 @@
+// The oxlint process collects only ids, counts and timings. No BI sender runs in the plugin.
+import { writeFileSync } from 'node:fs';
+import { GLOBAL_COMPONENTS_FOLDER } from "../shared/site-files-tree-mapping.js";
+import { readStructure } from "../page-model/read-structure.js";
+const rules = [];
+export const models = [];
+const pages = new Map();
+let registered = false;
+/** Resolve the same root component id the page model reads; never use its path as a BI id. */
+export function pageId(filename, text, program) {
+    let page = pages.get(filename);
+    if (!pages.has(filename)) {
+        const { components } = readStructure(filename, text, program);
+        const id = Object.values(components).find(component => component.parentKey === null)?.id;
+        page = id && /^[\w-]+$/.test(id) ? id : undefined;
+        pages.set(filename, page);
+    }
+    return page;
+}
+/** Called once per rule and file by the adapter. Passing rules retain their zero count. */
+export function startRuleStats(rule, filename, text, program) {
+    const destination = process.env.ORIGAMI_LINT_STATS;
+    if (!destination)
+        return;
+    try {
+        if (!registered) {
+            registered = true;
+            process.once('exit', () => {
+                try {
+                    writeFileSync(destination, JSON.stringify({ rules, models }), { mode: 0o600 });
+                }
+                catch { /* Stats must never fail lint. */ }
+            });
+        }
+        const kind = filename.startsWith(`${GLOBAL_COMPONENTS_FOLDER}/`) ? 'component' : 'page';
+        const stats = { rule, kind, page: pageId(filename, text, program), violations: 0, duration_ms: 0 };
+        rules.push(stats);
+        return stats;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/history/changed-files.js

@@ -1,5 +1,6 @@
 // Which files changed since the last passing run. Now = the tree hash of the whole folder, committed or not,
 // taken with a private index file, so your staging area, branches and history are never touched.
+import { trackSync } from "../bi/names.js";
 import { mkdirSync } from 'node:fs';
 import path from 'node:path';
 import { log } from "../shared/log.js";
@@ -10,15 +11,23 @@ const PRIVATE_INDEX = { GIT_INDEX_FILE: path.join(LINT_DIR, 'index') };
 /** `--full`: compare with nothing. `ORIGAMI_LINT_BASE=main`: compare with main instead of the last passing run. */
 export function getChangedFiles() {
     const base = process.env.ORIGAMI_LINT_BASE;
-    const now = takeSnapshot();
-    const before = findVersionToCompareWith(base);
-    const changedFiles = {
-        now,
-        since: before && (base ?? before.slice(0, 7)),
-        comparedWithBase: Boolean(base),
-        changed: before ? gitList(['diff', '--name-only', '-z', '--no-renames', before, now]) : null,
-        all: gitList(['ls-tree', '-r', '-z', '--name-only', now]),
-    };
+    const now = trackSync('step', 'take_snapshot', {}, () => takeSnapshot());
+    const before = trackSync('step', 'find_compare_version', {}, row => {
+        const before = findVersionToCompareWith(base);
+        row?.update({ step_details: { compare_mode: before.mode, lint_version_changed: before.lintVersionChanged } });
+        return before.version;
+    });
+    const changedFiles = trackSync('step', 'diff_changed_files', {}, row => {
+        const changedFiles = {
+            now,
+            since: before && (base ?? before.slice(0, 7)),
+            comparedWithBase: Boolean(base),
+            changed: before ? gitList(['diff', '--name-only', '-z', '--no-renames', before, now]) : null,
+            all: gitList(['ls-tree', '-r', '-z', '--name-only', now]),
+        };
+        row?.update({ step_details: { changed_files: changedFiles.changed?.length ?? changedFiles.all.length, all_files: changedFiles.all.length } });
+        return changedFiles;
+    });
     logChangedFiles(changedFiles);
     return changedFiles;
 }
@@ -29,9 +38,9 @@ function takeSnapshot() {
 }
 function findVersionToCompareWith(base) {
     if (process.argv.includes('--full'))
-        return null;
+        return { version: null, mode: 'full', lintVersionChanged: false };
     if (base)
-        return git(['rev-parse', base]);
+        return { version: git(['rev-parse', base]), mode: 'base', lintVersionChanged: false };
     return lastPassingVersion();
 }
 function logChangedFiles({ since, changed }) {

package/dist/history/last-passing.js

@@ -7,24 +7,27 @@ import { git } from "./utils.js";
 const LAST_PASSING_REF = 'refs/origami/last-valid';
 const LAST_PASSING_FILE = path.join(LINT_DIR, 'last-passing.json');
 const LINT_VERSION = JSON.parse(readFileSync(LINT_PACKAGE_FILE, 'utf8')).version;
-/** null = nothing to compare with: nothing passed yet, or another lint version passed it (its rules may differ). */
+/** No version when nothing passed yet, or another lint version passed it (its rules may differ). */
 export function lastPassingVersion() {
     const snapshot = lastPassingSnapshot();
     if (!snapshot)
-        return null;
+        return { version: null, mode: 'none', lintVersionChanged: false };
     const passedWith = lastPassingLintVersion();
     if (passedWith === LINT_VERSION)
-        return snapshot;
+        return { version: snapshot, mode: 'last_passing', lintVersionChanged: false };
     log(`the lint changed since the last passing run (${passedWith ?? 'unknown'} → ${LINT_VERSION})`);
-    return null;
+    return { version: null, mode: 'none', lintVersionChanged: true };
 }
 /** The next run compares with the version that just passed. */
 export function markPassing({ now, comparedWithBase }) {
-    if (comparedWithBase)
-        return log('not saved as passing: compared with ORIGAMI_LINT_BASE');
+    if (comparedWithBase) {
+        log('not saved as passing: compared with ORIGAMI_LINT_BASE');
+        return 'not_saved_base';
+    }
     git(['update-ref', LAST_PASSING_REF, now]);
     writeFileSync(LAST_PASSING_FILE, `${JSON.stringify({ lintVersion: LINT_VERSION }, null, 2)}\n`);
     log('saved as passing: the next run compares with now');
+    return 'saved';
 }
 function lastPassingSnapshot() {
     try {

package/dist/lint.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import { createWorkspaceRun, sendAndExit } from '@wix/origami-bi';
-import { readFileSync } from 'node:fs';
+import { readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
 // Origami lint: runs the project rules on the site's own files, then lints the pages whose files changed since the last
 // passing run. See lint/README.md.
 import { getChangedFiles, markPassing } from "./history/index.js";
@@ -8,15 +10,55 @@ import { runRules } from "./rules-adapter/index.js";
 import { findPagesToLint } from "./page-model/index.js";
 import { runProjectRules } from "./project-rules-runner/index.js";
 import { checkStartedAtSiteRoot, LINT_PACKAGE_FILE } from "./shared/paths.js";
+import { GLOBAL_COMPONENTS_FOLDER, THEME_FILE } from "./shared/site-files-tree-mapping.js";
+import { track, trackSync } from "./bi/names.js";
+import { readStats } from "./bi/read-stats.js";
 const run = createWorkspaceRun({ command: 'yarn lint', toolVersion: JSON.parse(readFileSync(LINT_PACKAGE_FILE, 'utf8')).version });
 await run.trackCommand(async () => {
-    await checkStartedAtSiteRoot();
+    run.commandRow.update({ step_details: { is_full: process.argv.includes('--full'), has_base: Boolean(process.env.ORIGAMI_LINT_BASE) } });
+    await track('step', 'check_site_root', {}, async (row) => {
+        const problem = checkStartedAtSiteRoot();
+        if (problem) {
+            row?.end(false, { error_name: problem.error_name });
+            await sendAndExit(1);
+        }
+    });
     const changedFiles = getChangedFiles();
-    const projectPassed = runProjectRules(changedFiles.all);
-    const pagesToLint = findPagesToLint(changedFiles);
-    const pagesPassed = runRules(pagesToLint);
+    const projectPassed = trackSync('step', 'run_project_rules', {}, row => {
+        const passed = runProjectRules(changedFiles.all, { parentRow: row });
+        row?.end(passed);
+        return passed;
+    });
+    const pagesToLint = trackSync('step', 'find_pages_to_lint', {}, row => {
+        const pages = findPagesToLint(changedFiles);
+        const globals = pages.filter(file => file.startsWith(`${GLOBAL_COMPONENTS_FOLDER}/`)).length;
+        row?.update({ step_details: { pages: pages.length - globals, global_components: globals, theme_changed: changedFiles.changed === null || changedFiles.changed.includes(THEME_FILE) } });
+        return pages;
+    });
+    const statsFile = run.enabled ? path.join(tmpdir(), `origami-lint-${run.id}.json`) : undefined;
+    const pagesPassed = trackSync('step', 'run_rules', { items_total: pagesToLint.length }, row => {
+        try {
+            const result = runRules(pagesToLint, statsFile);
+            if (statsFile)
+                readStats(statsFile, run);
+            row?.update({ step_details: { exit_code: result.exitCode, signal: result.signal, outcome: result.outcome } });
+            row?.end(result.passed);
+            return result.passed;
+        }
+        finally {
+            if (statsFile) {
+                try {
+                    rmSync(statsFile, { force: true });
+                }
+                catch { /* Stats must never fail lint. */ }
+            }
+        }
+    });
     const passed = projectPassed && pagesPassed;
     if (passed)
-        markPassing(changedFiles);
+        trackSync('step', 'mark_passing', {}, row => {
+            const outcome = markPassing(changedFiles);
+            row?.update({ step_details: { outcome } });
+        });
     await sendAndExit(passed ? 0 : 1);
 });

package/dist/project-rules-runner/run-project-rules.js

@@ -1,5 +1,3 @@
-// Runs every project rule, on every run, on the whole site; prints each problem in the line shape the page rules'
-// problems print in.
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
 import { projectRuleRegistry } from "../rules/project/index.js";
@@ -7,10 +5,11 @@ import { log } from "../shared/log.js";
 import { ROOT } from "../shared/paths.js";
 import { createProjectModel } from "../project-model/index.js";
 /** true when no error rule reported a problem, on the site of these files. Logs how many rules run, and whether they passed. */
-export function runProjectRules(files, { rules = projectRuleRegistry, readFile = readFromSite, print = console.log } = {}) {
+export function runProjectRules(files, { rules = projectRuleRegistry, readFile = readFromSite, print = console.log, parentRow } = {}) {
     log(`${rules.length} project rules to run`);
     let passed = true;
     for (const rule of rules) {
+        const row = parentRow?.run.openRow('lint_rule', rule.name, { item_type: 'site', step_details: { scope: 'project', severity: rule.severity ?? 'error' } });
         let problems;
         try {
             problems = rule.check(createProjectModel(rule.name, files, readFile));
@@ -18,9 +17,12 @@ export function runProjectRules(files, { rules = projectRuleRegistry, readFile =
         catch (error) {
             // A rule that couldn't finish (a file it can't parse, a path out of the site) fails the run, whatever its severity.
             print(formatProblem({ name: rule.name }, { file: '.', message: `the rule couldn't finish, so this run can't pass: ${error instanceof Error ? error.message : String(error)}` }));
+            row?.end(false, { error_name: 'rule_crashed' });
             passed = false;
             continue;
         }
+        row?.update({ step_details: { violations: problems.length } });
+        row?.end(problems.length === 0);
         for (const problem of problems) {
             print(formatProblem(rule, problem));
             if ((rule.severity ?? 'error') === 'error')

package/dist/rules-adapter/oxlint/adapt-rule.js

@@ -1,3 +1,6 @@
+// An origami rule as an oxlint rule: its callbacks are oxlint's, so the adapter only adds what every callback gets.
+import path from 'node:path';
+import { startRuleStats } from "../../bi/stats.js";
 import { getOrCreateRulesApi } from "../../rules-api/index.js";
 import { createReport, createToolCallbacks } from "../utils.js";
 export function toOxlintRule(rule) {
@@ -5,8 +8,9 @@ export function toOxlintRule(rule) {
         meta: { type: 'problem' },
         // oxlint calls this once per rule per file. The file's rules API is shared by every rule (getOrCreateRulesApi caches it).
         create: (context) => {
-            const report = createReport((problem) => context.report(problem));
-            return createToolCallbacks(rule, { rulesApi: () => getOrCreateRulesApi(toLintedFile(context)), report, context });
+            const stats = startRuleStats(rule.name, path.relative(context.cwd, context.filename), context.sourceCode.text, context.sourceCode.ast);
+            const report = createReport((problem) => context.report(problem), stats);
+            return createToolCallbacks(rule, { rulesApi: () => getOrCreateRulesApi(toLintedFile(context)), report, context, stats });
         },
     };
 }

package/dist/rules-adapter/oxlint/run-rules.js

@@ -9,14 +9,20 @@ const OXLINT_BIN = path.join(path.dirname(createRequire(import.meta.url).resolve
 // .ts in the origami repo, .js once built.
 const OXLINT_CONFIG = path.join(import.meta.dirname, `origami-rules.config${path.extname(import.meta.filename)}`);
 /** jsxFiles: the pages' structure files, from the site root. true when there was nothing to lint, or oxlint found no errors. */
-export function runRules(jsxFiles) {
-    const passed = runOxlint(jsxFiles);
-    log(passed ? 'rules passed' : 'rules failed');
-    return passed;
+export function runRules(jsxFiles, statsFile) {
+    const result = runOxlint(jsxFiles, statsFile);
+    log(result.passed ? 'rules passed' : 'rules failed');
+    return result;
 }
-function runOxlint(files) {
-    if (files.length === 0)
-        return true;
-    const result = spawnSync(process.execPath, [OXLINT_BIN, '-c', OXLINT_CONFIG, ...files], { cwd: ROOT, stdio: 'inherit' });
-    return result.status === 0;
+function runOxlint(files, statsFile) {
+    if (files.length === 0) {
+        return { passed: true, exitCode: null, signal: null, outcome: 'no_files' };
+    }
+    const env = { ...process.env };
+    delete env.ORIGAMI_LINT_STATS;
+    if (statsFile)
+        env.ORIGAMI_LINT_STATS = statsFile;
+    const result = spawnSync(process.execPath, [OXLINT_BIN, '-c', OXLINT_CONFIG, ...files], { cwd: ROOT, stdio: 'inherit', env });
+    return { passed: result.status === 0, exitCode: result.status, signal: result.signal,
+        outcome: result.status === 0 ? 'passed' : result.status === 1 ? 'violations' : 'plugin_crash' };
 }

package/dist/rules-adapter/utils.js

@@ -1,5 +1,5 @@
 /** The report a rule gets on a file: a violation found from both sides (parent and child) is reported once. Neither oxlint nor ESLint does that. */
-export function createReport(send) {
+export function createReport(send, stats) {
     const reported = new Set();
     return (problem) => {
         const { start, end } = problem.loc;
@@ -7,14 +7,25 @@ export function createReport(send) {
         if (reported.has(key))
             return;
         reported.add(key);
+        if (stats)
+            stats.violations++;
         send(problem);
     };
 }
 /** A rule's callbacks as the tool calls them, with the node only: every entry of rule.callbacks, so there's no list of names to keep. */
-export function createToolCallbacks(rule, { rulesApi, report, context }) {
+export function createToolCallbacks(rule, { rulesApi, report, context, stats }) {
     return Object.fromEntries(Object.entries(rule.callbacks).map(([name, callback]) => {
         // The tool calls each callback with the node its name is for, as Callbacks types it.
         const check = callback;
-        return [name, (node) => check({ node, get rulesApi() { return rulesApi(); }, report, context })];
+        return [name, (node) => {
+                const started = stats ? performance.now() : 0;
+                try {
+                    check({ node, get rulesApi() { return rulesApi(); }, report, context });
+                }
+                finally {
+                    if (stats)
+                        stats.duration_ms += performance.now() - started;
+                }
+            }];
     }));
 }

package/dist/rules-api/rules-api.js

@@ -2,6 +2,8 @@
 // and reading the file's own code that more than one rule needs (what type a tag is, its name, its id, its slot, its children, the elements in its attributes, where a name is imported from, the name an import is exported under, what is TypeScript, the props an arrow destructures).
 // One per file, shared by every rule on it. Only building its page reads from disk, once per file.
 import path from 'node:path';
+import { GLOBAL_COMPONENTS_FOLDER } from "../shared/site-files-tree-mapping.js";
+import { models, pageId } from "../bi/stats.js";
 import { readPage } from "../page-model/index.js";
 import { getAttributeElements as getHeldElements, getChildren, getId, getImport, getImportKind, getImportedName, getPropNames, getSlot, getTagName, getType, hasDataAttributes, isTypeScript } from "../shared/utils.js";
 import { readBreakpointName, readCustomMedia, readThemeTokens } from "../shared/css.js";
@@ -55,8 +57,30 @@ const rulesApis = new Map();
 /** This file's rules API: its page is built on the first call for the file (CSS and theme from disk), then shared by every rule. */
 export function getOrCreateRulesApi(file) {
     let rulesApi = rulesApis.get(file.filename);
-    if (!rulesApi)
-        rulesApis.set(file.filename, (rulesApi = createRulesApi(readPage(file.cwd, { jsxFile: getRelativeJsxPath(file), text: file.text, program: file.program }))));
+    if (!rulesApi) {
+        const started = performance.now();
+        let errorName;
+        try {
+            rulesApi = createRulesApi(readPage(file.cwd, { jsxFile: getRelativeJsxPath(file), text: file.text, program: file.program }));
+            rulesApis.set(file.filename, rulesApi);
+        }
+        catch (error) {
+            errorName = error instanceof Error && error.name === 'CssSyntaxError' ? 'css_syntax_error' : 'unknown_error';
+            throw error;
+        }
+        finally {
+            if (process.env.ORIGAMI_LINT_STATS) {
+                try {
+                    const kind = getRelativeJsxPath(file).startsWith(`${GLOBAL_COMPONENTS_FOLDER}/`) ? 'component' : 'page';
+                    models.push({ kind, page: pageId(getRelativeJsxPath(file), file.text, file.program), duration_ms: performance.now() - started,
+                        components: rulesApi ? Object.keys(rulesApi.page.components).length : 0,
+                        css_files: rulesApi ? Object.values(rulesApi.page.css.files).filter(Boolean).length : 0,
+                        ...(errorName ? { error_name: errorName } : {}) });
+                }
+                catch { /* Stats must never fail lint. */ }
+            }
+        }
+    }
     return rulesApi;
 }
 /** The tool gives an absolute path; pages are keyed by the path from the site root. */

package/dist/shared/paths.js

@@ -1,4 +1,3 @@
-import { sendAndExit } from '@wix/origami-bi';
 import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 /** The site: the folder the lint was started from (`yarn lint` at the site's root). */
@@ -9,20 +8,20 @@ export const LINT_PACKAGE_FILE = path.resolve(import.meta.dirname, '../../packag
 const LINT_PACKAGE = 'origami-lint';
 const LINT_PACKAGE_NAME = `@wix/${LINT_PACKAGE}`;
 /** The lint runs only from the folder whose package.json adds it, which holds the site's git repository. */
-export async function checkStartedAtSiteRoot() {
+export function checkStartedAtSiteRoot() {
     const problem = siteRootProblem();
     if (!problem)
-        return;
-    console.error(`${LINT_PACKAGE}: ${problem}`);
-    await sendAndExit(1);
+        return null;
+    console.error(`${LINT_PACKAGE}: ${problem.message}`);
+    return problem;
 }
 function siteRootProblem() {
     const packageFile = path.join(ROOT, 'package.json');
     if (!existsSync(packageFile) || !addsTheLint(JSON.parse(readFileSync(packageFile, 'utf8')))) {
-        return `run it from the site's root, the folder whose package.json has ${LINT_PACKAGE_NAME} (started in ${ROOT})`;
+        return { error_name: 'no_lint_package', message: `run it from the site's root, the folder whose package.json has ${LINT_PACKAGE_NAME} (started in ${ROOT})` };
     }
     if (!existsSync(path.join(ROOT, '.git'))) {
-        return `no git repository in ${ROOT}. The lint keeps the last passing version in the site's repository: run git init here.`;
+        return { error_name: 'no_git', message: `no git repository in ${ROOT}. The lint keeps the last passing version in the site's repository: run git init here.` };
     }
     return null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/origami-lint",
-  "version": "1.34.17",
+  "version": "1.34.19",
   "description": "Offline lint for an exported Origami site: lints the pages that changed since the last passing run",
   "type": "module",
   "bin": {
@@ -25,7 +25,7 @@
     "oxc-parser": "^0.151.0",
     "oxlint": "^1.39.0",
     "postcss": "^8.5.3",
-    "@wix/origami-bi": "0.6.0"
+    "@wix/origami-bi": "0.8.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
@@ -52,5 +52,5 @@
       ]
     }
   },
-  "falconPackageHash": "0d8ae1fbf9f13971b01e3327b341f95e28d59c6dff47b785d1aae3d0"
+  "falconPackageHash": "791d9d5c3c5c2e15912796c5bfa7def4c696084174385a57d767c143"
 }