viewlint 0.0.0 → 0.0.1

package/README.md

@@ -0,0 +1,3 @@
+# viewlint
+
+See the [docs](https://viewlint.vercel.app/docs).

package/dist/bin/viewlint.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=viewlint.d.ts.map

package/dist/bin/viewlint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewlint.d.ts","sourceRoot":"","sources":["../../bin/viewlint.ts"],"names":[],"mappings":""}

package/dist/bin/viewlint.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { sync } from "cross-spawn";
+import debug from "debug";
+import { createDefaultBinDeps, runBin } from "../src/binEntry.js";
+import { runCli } from "../src/cli.js";
+const argv = process.argv;
+process.exitCode = await runBin(argv, createDefaultBinDeps({
+    spawnSync: sync,
+    runCli,
+    enableDebug: debug.enable,
+}));

package/dist/config/index.d.ts

@@ -0,0 +1,6 @@
+import type { ConfigObject } from "../src/types.js";
+import type { ConfigWithExtendsArray } from "./types.js";
+export declare function defineConfig(...configs: ConfigWithExtendsArray): ConfigObject[];
+export { findNearestViewlintConfigFile } from "../src/configFile.js";
+export { defaultView, defineViewFromActions } from "./views.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../config/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAU,MAAM,iBAAiB,CAAA;AAE3D,OAAO,KAAK,EAEX,sBAAsB,EAGtB,MAAM,YAAY,CAAA;AAmMnB,wBAAgB,YAAY,CAC3B,GAAG,OAAO,EAAE,sBAAsB,GAChC,YAAY,EAAE,CAiBhB;AAED,OAAO,EAAE,6BAA6B,EAAE,MAAM,sBAAsB,CAAA;AACpE,OAAO,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA"}

package/dist/config/index.js

@@ -0,0 +1,150 @@
+function resolveExtendsString(reference, plugins) {
+    const normalized = reference.trim();
+    const lastSlashIndex = normalized.lastIndexOf("/");
+    let pluginNamespace = "";
+    let configName = "";
+    if (lastSlashIndex === -1) {
+        const candidates = [...plugins.keys()].filter((knownNamespace) => {
+            return knownNamespace.endsWith(`/${reference}`);
+        });
+        if (candidates.length === 0) {
+            throw new Error(`Invalid extends reference '${reference}'. Expected '<configName>' or '<pluginNamespace>/<configName>'.`);
+        }
+        else if (candidates.length === 1) {
+            const candidate = candidates[0];
+            if (!candidate) {
+                throw new Error(`Invalid extends reference '${reference}'. Expected '<configName>' or '<pluginNamespace>/<configName>'.`);
+            }
+            pluginNamespace = candidate;
+            configName = reference;
+        }
+        else if (candidates.length > 1) {
+            candidates.sort();
+            throw new Error(`Ambiguous plugin '${reference}' in extends '${reference}'. Specify with a namespace. Matches: ${candidates
+                .map((candidate) => `'${candidate}'`)
+                .join(", ")}.`);
+        }
+    }
+    else {
+        const pluginRef = normalized.slice(0, lastSlashIndex).trim();
+        configName = normalized.slice(lastSlashIndex + 1).trim();
+        if (pluginRef.length === 0 || configName.length === 0) {
+            throw new Error(`Invalid extends reference '${reference}'. Expected '<pluginNamespace>/<configName>'.`);
+        }
+        if (plugins.has(pluginRef)) {
+            pluginNamespace = pluginRef;
+        }
+        else {
+            const knownPlugins = [...plugins.keys()].sort();
+            const knownPluginsMessage = knownPlugins.length === 0
+                ? "No plugins are registered."
+                : `Known plugins: ${knownPlugins
+                    .map((name) => `'${name}'`)
+                    .join(", ")}.`;
+            throw new Error(`Unknown plugin referenced by extends '${reference}'. Ensure it is registered in plugins. ${knownPluginsMessage}`);
+        }
+    }
+    const plugin = plugins.get(pluginNamespace);
+    if (!plugin) {
+        throw new Error(`Unknown plugin '${pluginNamespace}' referenced by extends '${reference}'. Ensure it is registered in plugins.`);
+    }
+    if (!plugin.configs)
+        throw new Error(`No configuration found in plugin '${pluginNamespace}'.`);
+    const config = plugin.configs[configName];
+    if (!config) {
+        const availableConfigs = Object.keys(plugin.configs).sort();
+        const availableConfigsMessage = availableConfigs.length === 0
+            ? "No configs are available in this plugin."
+            : `Available configs: ${availableConfigs
+                .map((name) => `'${name}'`)
+                .join(", ")}.`;
+        throw new Error(`Unknown config '${configName}' in plugin '${pluginNamespace}' (extends '${reference}'). ${availableConfigsMessage}`);
+    }
+    return config;
+}
+function applyExtendsEntry(entry, state, context) {
+    if (typeof entry === "string") {
+        const normalized = entry.trim();
+        const cycleIndex = context.stringStack.indexOf(normalized);
+        if (cycleIndex !== -1) {
+            const chain = [...context.stringStack.slice(cycleIndex), normalized].join(" -> ");
+            throw new Error(`Circular extends detected: ${chain}`);
+        }
+        context.stringStack.push(normalized);
+        try {
+            const resolved = resolveExtendsString(normalized, state.plugins);
+            applyConfig(resolved, state, context);
+        }
+        finally {
+            context.stringStack.pop();
+        }
+        return;
+    }
+    applyConfig(entry, state, context);
+}
+function applyConfig(config, state, context) {
+    if (Array.isArray(config)) {
+        if (context.activeArrays.has(config)) {
+            throw new Error("Circular extends detected: a config array was recursively extended.");
+        }
+        context.activeArrays.add(config);
+        try {
+            for (const item of config) {
+                applyConfig(item, state, context);
+            }
+        }
+        finally {
+            context.activeArrays.delete(config);
+        }
+        return;
+    }
+    if (context.activeItems.has(config)) {
+        throw new Error("Circular extends detected: a config item was recursively extended.");
+    }
+    context.activeItems.add(config);
+    try {
+        if (config.plugins) {
+            for (const [pluginNamespace, plugin] of Object.entries(config.plugins)) {
+                state.plugins.set(pluginNamespace, plugin);
+            }
+        }
+        if (config.extends) {
+            for (const extendsEntry of config.extends) {
+                applyExtendsEntry(extendsEntry, state, context);
+            }
+        }
+        const { extends: _extends, ...rest } = config;
+        const hasEntries = (value) => {
+            if (!value)
+                return false;
+            return Object.keys(value).length > 0;
+        };
+        if (hasEntries(rest.plugins) ||
+            hasEntries(rest.rules) ||
+            hasEntries(rest.options) ||
+            hasEntries(rest.views) ||
+            hasEntries(rest.scopes)) {
+            state.output.push(rest);
+        }
+    }
+    finally {
+        context.activeItems.delete(config);
+    }
+}
+export function defineConfig(...configs) {
+    const state = {
+        plugins: new Map(),
+        output: [],
+    };
+    const context = {
+        activeArrays: new WeakSet(),
+        activeItems: new WeakSet(),
+        stringStack: [],
+    };
+    for (const config of configs) {
+        applyConfig(config, state, context);
+    }
+    return state.output;
+}
+export { findNearestViewlintConfigFile } from "../src/configFile.js";
+export { defaultView, defineViewFromActions } from "./views.js";

package/dist/config/types.d.ts

@@ -0,0 +1,8 @@
+import type { ConfigObject } from "../src/types.js";
+export type InfiniteArray<T> = T | Array<InfiniteArray<T>>;
+export type ExtendsElement = string | InfiniteArray<ConfigWithExtends>;
+export type ConfigWithExtends = ConfigObject & {
+    extends?: readonly ExtendsElement[];
+};
+export type ConfigWithExtendsArray = InfiniteArray<ConfigWithExtends>[];
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../config/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAEnD,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAA;AAE1D,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,aAAa,CAAC,iBAAiB,CAAC,CAAA;AAEtE,MAAM,MAAM,iBAAiB,GAAG,YAAY,GAAG;IAC9C,OAAO,CAAC,EAAE,SAAS,cAAc,EAAE,CAAA;CACnC,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,iBAAiB,CAAC,EAAE,CAAA"}

package/dist/config/types.js

@@ -0,0 +1 @@
+export {};

package/dist/config/views.d.ts

@@ -0,0 +1,10 @@
+import type { Page } from "playwright";
+import type { View } from "../src/types.js";
+export type DefineViewAction = (args: {
+    page: Page;
+}) => Promise<void> | void;
+export declare const defineViewFromActions: (maybeActionArr: DefineViewAction | DefineViewAction[], opts?: {
+    name?: string;
+}) => View;
+export declare const defaultView: View;
+//# sourceMappingURL=views.d.ts.map

package/dist/config/views.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"views.d.ts","sourceRoot":"","sources":["../../config/views.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAItC,OAAO,KAAK,EAAa,IAAI,EAAgB,MAAM,iBAAiB,CAAA;AAEpE,MAAM,MAAM,gBAAgB,GAAG,CAAC,IAAI,EAAE;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;AAE7E,eAAO,MAAM,qBAAqB,GACjC,gBAAgB,gBAAgB,GAAG,gBAAgB,EAAE,EACrD,OAAO;IACN,IAAI,CAAC,EAAE,MAAM,CAAA;CACb,KACC,IAgDF,CAAA;AAED,eAAO,MAAM,WAAW,EAAE,IAAqD,CAAA"}

package/dist/config/views.js

@@ -0,0 +1,43 @@
+import { chromium } from "playwright";
+import { toArray } from "../src/helpers.js";
+export const defineViewFromActions = (maybeActionArr, opts) => {
+    return {
+        meta: {
+            name: opts?.name,
+        },
+        setup: async (opts) => {
+            const actions = toArray(maybeActionArr);
+            const baseURL = opts?.context?.baseURL;
+            if (!baseURL) {
+                throw new Error("Views created with defineView require options.context.baseURL to be set.");
+            }
+            const browser = await chromium.launch();
+            const context = await browser.newContext(opts?.context);
+            const page = await context.newPage();
+            const waitForSettled = async () => {
+                await page.waitForLoadState("load");
+            };
+            const runActions = async () => {
+                for (const action of actions) {
+                    await action({ page });
+                    await waitForSettled();
+                }
+            };
+            const reset = async () => {
+                await page.goto(baseURL);
+                await waitForSettled();
+                await runActions();
+            };
+            await reset();
+            return {
+                page,
+                reset,
+                close: async () => {
+                    await context.close();
+                    await browser.close();
+                },
+            };
+        },
+    };
+};
+export const defaultView = defineViewFromActions([], { name: "default" });

package/dist/plugin/index.d.ts

@@ -0,0 +1,8 @@
+import type { RuleDefinition, RuleMeta, RuleSchema } from "../src/types.js";
+export declare function defineRule<Schema extends RuleSchema>(rule: RuleDefinition<Schema> & {
+    meta: RuleMeta<Schema> & {
+        schema: Schema;
+    };
+}): RuleDefinition<Schema>;
+export declare function defineRule(rule: RuleDefinition<undefined>): RuleDefinition<undefined>;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../plugin/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAE3E,wBAAgB,UAAU,CAAC,MAAM,SAAS,UAAU,EACnD,IAAI,EAAE,cAAc,CAAC,MAAM,CAAC,GAAG;IAC9B,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;CAC3C,GACC,cAAc,CAAC,MAAM,CAAC,CAAA;AAEzB,wBAAgB,UAAU,CACzB,IAAI,EAAE,cAAc,CAAC,SAAS,CAAC,GAC7B,cAAc,CAAC,SAAS,CAAC,CAAA"}

package/dist/plugin/index.js

@@ -0,0 +1,3 @@
+export function defineRule(rule) {
+    return rule;
+}

package/dist/src/binEntry.d.ts

@@ -0,0 +1,22 @@
+type SpawnSyncOptions = {
+    encoding: "utf8";
+    stdio: "inherit";
+};
+type SpawnSync = (command: string, args: string[], options: SpawnSyncOptions) => unknown;
+type RunCli = (argv: string[]) => Promise<number>;
+type EnableDebug = (namespaces: string) => void;
+type BinDeps = {
+    spawnSync: SpawnSync;
+    runCli: RunCli;
+    enableDebug: EnableDebug;
+    writeStdout: (text: string) => void;
+    writeStderr: (text: string) => void;
+};
+export declare function runBin(argv: string[], deps: BinDeps): Promise<number>;
+export declare function createDefaultBinDeps(opts: {
+    spawnSync: SpawnSync;
+    runCli: RunCli;
+    enableDebug: EnableDebug;
+}): BinDeps;
+export {};
+//# sourceMappingURL=binEntry.d.ts.map

package/dist/src/binEntry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binEntry.d.ts","sourceRoot":"","sources":["../../src/binEntry.ts"],"names":[],"mappings":"AAAA,KAAK,gBAAgB,GAAG;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,SAAS,CAAA;CAChB,CAAA;AAMD,KAAK,SAAS,GAAG,CAChB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE,gBAAgB,KACrB,OAAO,CAAA;AAEZ,KAAK,MAAM,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;AAEjD,KAAK,WAAW,GAAG,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAA;AAE/C,KAAK,OAAO,GAAG;IACd,SAAS,EAAE,SAAS,CAAA;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,WAAW,CAAA;IACxB,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IACnC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CACnC,CAAA;AAaD,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAgC3E;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE;IAC1C,SAAS,EAAE,SAAS,CAAA;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,WAAW,CAAA;CACxB,GAAG,OAAO,CAQV"}

package/dist/src/binEntry.js

@@ -0,0 +1,45 @@
+function isSpawnSyncResult(value) {
+    return typeof value === "object" && value !== null;
+}
+function coerceExitCode(result) {
+    if (!isSpawnSyncResult(result))
+        return 1;
+    if (typeof result.status !== "number")
+        return 1;
+    if (!Number.isFinite(result.status))
+        return 1;
+    return result.status;
+}
+export async function runBin(argv, deps) {
+    // Keep this entrypoint extremely lightweight, similar to ESLint.
+    // We intentionally scan argv for early flags instead of doing full parse.
+    if (argv.includes("--init")) {
+        deps.writeStderr("You can also run this command directly using 'npx @viewlint/create-config@latest'.\n");
+        const result = deps.spawnSync("npx", ["@viewlint/create-config@latest"], {
+            encoding: "utf8",
+            stdio: "inherit",
+        });
+        return coerceExitCode(result);
+    }
+    if (argv.includes("--mcp")) {
+        deps.writeStderr("You can also run this command directly using 'npx @viewlint/mcp@latest'.\n");
+        const result = deps.spawnSync("npx", ["@viewlint/mcp@latest"], {
+            encoding: "utf8",
+            stdio: "inherit",
+        });
+        return coerceExitCode(result);
+    }
+    if (argv.includes("--verbose")) {
+        deps.enableDebug("viewlint*");
+    }
+    return deps.runCli(argv);
+}
+export function createDefaultBinDeps(opts) {
+    return {
+        spawnSync: opts.spawnSync,
+        runCli: opts.runCli,
+        enableDebug: opts.enableDebug,
+        writeStdout: (text) => process.stdout.write(text),
+        writeStderr: (text) => process.stderr.write(text),
+    };
+}

package/dist/src/cli.d.ts

@@ -0,0 +1,2 @@
+export declare function runCli(argv: string[]): Promise<number>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/src/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":"AAwUA,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CA2E5D"}

package/dist/src/cli.js

@@ -0,0 +1,292 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Command, InvalidArgumentError } from "commander";
+import { defaultView } from "../config/views.js";
+import { isRecord, toArray } from "./helpers.js";
+import { ViewLint } from "./index.js";
+function parseIntStrict(raw) {
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) {
+        throw new InvalidArgumentError(`Expected an integer but got '${raw}'.`);
+    }
+    return parsed;
+}
+function countSeverities(messages) {
+    let errorCount = 0;
+    let warningCount = 0;
+    let infoCount = 0;
+    for (const message of messages) {
+        if (message.severity === "error")
+            errorCount += 1;
+        if (message.severity === "warn")
+            warningCount += 1;
+        if (message.severity === "info")
+            infoCount += 1;
+    }
+    return { errorCount, warningCount, infoCount };
+}
+function sumCounts(results) {
+    let errorCount = 0;
+    let warningCount = 0;
+    for (const result of results) {
+        errorCount += result.errorCount;
+        warningCount += result.warningCount;
+    }
+    return { errorCount, warningCount };
+}
+function computeExitCode(counts, maxWarnings) {
+    const tooManyWarnings = maxWarnings >= 0 && counts.warningCount > maxWarnings;
+    return counts.errorCount > 0 || tooManyWarnings ? 1 : 0;
+}
+async function isDirectory(filePath) {
+    try {
+        return (await fs.stat(filePath)).isDirectory();
+    }
+    catch (error) {
+        if (isRecord(error) &&
+            "code" in error &&
+            typeof error.code === "string" &&
+            (error.code === "ENOENT" || error.code === "ENOTDIR")) {
+            return false;
+        }
+        throw error;
+    }
+}
+async function writeOrStdout(output, outputFile) {
+    if (!outputFile) {
+        process.stdout.write(output);
+        return;
+    }
+    const filePath = path.resolve(process.cwd(), outputFile);
+    if (await isDirectory(filePath)) {
+        throw new Error(`Cannot write to output file path, it is a directory: ${outputFile}`);
+    }
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, output, "utf8");
+}
+async function readPackageVersion() {
+    const candidatePaths = [
+        new URL("../package.json", import.meta.url),
+        new URL("../../package.json", import.meta.url),
+    ];
+    for (const url of candidatePaths) {
+        try {
+            const raw = await fs.readFile(url, "utf8");
+            const parsed = JSON.parse(raw);
+            if (isRecord(parsed) && typeof parsed.version === "string") {
+                return parsed.version;
+            }
+        }
+        catch {
+            // Try next candidate.
+        }
+    }
+    throw new Error("packages/viewlint/package.json must include a string 'version' field for --version.");
+}
+function filterResultsForQuietMode(results) {
+    return results.map((result) => {
+        const messages = result.messages.filter((m) => m.severity === "error");
+        const counts = countSeverities(messages);
+        return {
+            ...result,
+            messages,
+            suppressedMessages: [],
+            errorCount: counts.errorCount,
+            warningCount: 0,
+            infoCount: 0,
+            recommendCount: 0,
+        };
+    });
+}
+async function execute(options, urls) {
+    const viewlint = new ViewLint({
+        overrideConfigFile: options.config,
+    });
+    let targets;
+    try {
+        const resolved = await viewlint.getResolvedOptions();
+        const optionNames = options.option ?? [];
+        const scopeNames = options.scope ?? [];
+        const optionLayersFromRegistry = optionNames.flatMap((name) => {
+            const entry = resolved.optionsRegistry.get(name);
+            if (!entry) {
+                const known = [...resolved.optionsRegistry.keys()].sort();
+                const knownMessage = known.length === 0
+                    ? "No named options are defined in config."
+                    : `Known options: ${known.map((x) => `'${x}'`).join(", ")}.`;
+                throw new Error(`Unknown option '${name}'. ${knownMessage}`);
+            }
+            const layers = toArray(entry);
+            return layers.map((layer) => {
+                if (layer.meta?.name)
+                    return layer;
+                // Attempt to give the option a name from the key for better reporting.
+                return {
+                    ...layer,
+                    meta: { ...(layer.meta ?? {}), name },
+                };
+            });
+        });
+        const scopesFromRegistry = scopeNames.flatMap((name) => {
+            const entry = resolved.scopeRegistry.get(name);
+            if (!entry) {
+                const known = [...resolved.scopeRegistry.keys()].sort();
+                const knownMessage = known.length === 0
+                    ? "No named scopes are defined in config."
+                    : `Known scopes: ${known.map((x) => `'${x}'`).join(", ")}.`;
+                throw new Error(`Unknown scope '${name}'. ${knownMessage}`);
+            }
+            const scopes = toArray(entry);
+            return scopes.map((scope) => {
+                if (scope.meta?.name)
+                    return scope;
+                // Attempt to give the scope a name from the key for better reporting.
+                return {
+                    ...scope,
+                    meta: { ...(scope.meta ?? {}), name },
+                };
+            });
+        });
+        const selectorScopes = (options.selector ?? []).map((selector) => {
+            return {
+                meta: { name: selector },
+                getLocator: ({ page }) => page.locator(selector),
+            };
+        });
+        const resolvedScopes = [...scopesFromRegistry, ...selectorScopes];
+        const resolveView = () => {
+            if (options.view) {
+                const view = resolved.viewRegistry.get(options.view);
+                if (!view) {
+                    const known = [...resolved.viewRegistry.keys()].sort();
+                    const knownMessage = known.length === 0
+                        ? "No named views are defined in config."
+                        : `Known views: ${known.map((x) => `'${x}'`).join(", ")}.`;
+                    throw new Error(`Unknown view '${options.view}'. ${knownMessage}`);
+                }
+                if (view.meta?.name)
+                    return view;
+                // Attempt to give the view a name from the key for better reporting.
+                return { ...view, meta: { ...(view.meta ?? {}), name: options.view } };
+            }
+            return defaultView;
+        };
+        const compileTarget = (url) => {
+            const urlLayer = url
+                ? [
+                    {
+                        context: { baseURL: url },
+                    },
+                ]
+                : [];
+            return {
+                view: resolveView(),
+                options: urlLayer.length === 0 && optionLayersFromRegistry.length === 0
+                    ? undefined
+                    : [...urlLayer, ...optionLayersFromRegistry],
+                scope: resolvedScopes.length === 0 ? undefined : resolvedScopes,
+            };
+        };
+        targets =
+            urls.length > 0
+                ? urls.map((url) => compileTarget(url))
+                : [compileTarget(undefined)];
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${message}\n`);
+        return 2;
+    }
+    if (targets.length === 0) {
+        process.stderr.write("No lint targets resolved. Provide a URL, or provide --option entries that set options.context.baseURL to use the default View.\n");
+        return 2;
+    }
+    let results;
+    try {
+        results = await viewlint.lintTargets(targets);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${message}\n`);
+        return 2;
+    }
+    const resultsForPrinting = options.quiet
+        ? filterResultsForQuietMode(results)
+        : results;
+    let formatter;
+    try {
+        formatter = await viewlint.loadFormatter(options.format);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${message}\n`);
+        return 2;
+    }
+    try {
+        const output = await formatter.format(resultsForPrinting);
+        await writeOrStdout(output, options.outputFile);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${message}\n`);
+        return 2;
+    }
+    const counts = sumCounts(results);
+    return computeExitCode(counts, options.maxWarnings);
+}
+function isCommanderError(value) {
+    return isRecord(value) && typeof value.exitCode === "number";
+}
+export async function runCli(argv) {
+    const version = await readPackageVersion();
+    let exitCode = 0;
+    const program = new Command();
+    program
+        .name("viewlint")
+        .description("Lint accessibility and UI issues on web pages")
+        .usage("[options] <url> [url]")
+        .argument("[url...]", "One or more URLs to lint")
+        .showHelpAfterError()
+        .allowUnknownOption(false);
+    // Help group headings are part of the Commander-native help output.
+    program
+        .optionsGroup("Basic configuration:")
+        .option("-c, --config <path>", "Use this configuration instead of viewlint.config.ts, viewlint.config.mjs, or viewlint.config.js");
+    program
+        .optionsGroup("Targets:")
+        .option("--view <name>", "Use a named view from config")
+        .option("--option <name...>", "Apply named option layers from config (in order)")
+        .option("--scope <name...>", "Apply named scopes from config (in order)")
+        .option("--selector <css...>", "Use one or more ad-hoc CSS selectors as additional scope roots");
+    program
+        .optionsGroup("Handle Warnings:")
+        .option("--quiet", "Report errors only", false)
+        .option("--max-warnings <n>", "Number of warnings to trigger nonzero exit code", parseIntStrict, -1);
+    program
+        .optionsGroup("Output:")
+        .option("-f, --format <format>", "Use a specific output format", "stylish")
+        .option("-o, --output-file <path>", "Specify file to write report to");
+    program
+        .optionsGroup("Miscellaneous:")
+        .option("--verbose", "Log progress details to stderr", false)
+        .option("--init", "Run config initialization wizard", false)
+        .option("--mcp", "Start the ViewLint MCP server", false)
+        .version(version, "-v, --version", "Output the version number")
+        .helpOption("-h, --help", "Show help");
+    program.action(async (urls, options) => {
+        exitCode = await execute(options, urls);
+    });
+    program.exitOverride();
+    try {
+        await program.parseAsync(argv);
+        return exitCode;
+    }
+    catch (error) {
+        if (isCommanderError(error)) {
+            return error.exitCode === 0 ? 0 : 2;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${message}\n`);
+        return 2;
+    }
+}

package/dist/src/configFile.d.ts

@@ -0,0 +1,3 @@
+export type ViewLintConfigFileName = "viewlint.config.ts" | "viewlint.config.js" | "viewlint.config.mjs";
+export declare function findNearestViewlintConfigFile(startDirPath?: string): string | undefined;
+//# sourceMappingURL=configFile.d.ts.map

package/dist/src/configFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configFile.d.ts","sourceRoot":"","sources":["../../src/configFile.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,sBAAsB,GAC/B,oBAAoB,GACpB,oBAAoB,GACpB,qBAAqB,CAAA;AAiBxB,wBAAgB,6BAA6B,CAC5C,YAAY,GAAE,MAAsB,GAClC,MAAM,GAAG,SAAS,CAYpB"}