@blzsky/variant 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,56 @@
+import * as z from 'zod';
+
+declare const taskConfigSchema: z.ZodObject<{
+    inputs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dependsOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    command: z.ZodOptional<z.ZodString>;
+    cpuHeavy: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const variantConfigSchema: z.ZodObject<{
+    strategy: z.ZodDefault<z.ZodEnum<{
+        adaptive: "adaptive";
+        strict: "strict";
+    }>>;
+    cache: z.ZodDefault<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodLiteral<"content">>;
+        directory: z.ZodDefault<z.ZodString>;
+        ttlDays: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    tasks: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        inputs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        dependsOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        command: z.ZodOptional<z.ZodString>;
+        cpuHeavy: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        scripts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    git: z.ZodOptional<z.ZodObject<{
+        baseRef: z.ZodDefault<z.ZodString>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    semanticDiff: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    scheduler: z.ZodOptional<z.ZodObject<{
+        policy: z.ZodDefault<z.ZodEnum<{
+            auto: "auto";
+            "light-first": "light-first";
+            "pack-heavy": "pack-heavy";
+            "critical-path": "critical-path";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+/** The object a user passes to `defineConfig`: every field optional. */
+type VariantConfig = z.input<typeof variantConfigSchema>;
+/** The same config after validation, with every default filled in. */
+type ResolvedVariantConfig = z.output<typeof variantConfigSchema>;
+type Strategy = ResolvedVariantConfig["strategy"];
+type TaskConfig = z.infer<typeof taskConfigSchema>;
+type CacheConfig = ResolvedVariantConfig["cache"];
+
+declare function defineConfig(config: VariantConfig): VariantConfig;
+
+export { type CacheConfig, type ResolvedVariantConfig, type Strategy, type TaskConfig, type VariantConfig, defineConfig };

package/dist/index.js

@@ -0,0 +1,7 @@
+import {
+  defineConfig
+} from "./chunk-RGD422OM.js";
+import "./chunk-RVXUCJYA.js";
+export {
+  defineConfig
+};

package/dist/init-KJIUNGAN.js

@@ -0,0 +1,158 @@
+import {
+  detectProject
+} from "./chunk-V5CTGXMM.js";
+import {
+  findVariantConfigPath
+} from "./chunk-RGD422OM.js";
+import "./chunk-RVXUCJYA.js";
+import {
+  lines
+} from "./chunk-6J4XDG44.js";
+import {
+  getPrinter
+} from "./chunk-V22IPJ7A.js";
+
+// src/cli/commands/init.ts
+import { writeFile } from "fs/promises";
+import path2 from "path";
+import { createInterface } from "readline/promises";
+
+// src/core/scaffold/config-template.ts
+import { readFile } from "fs/promises";
+import path from "path";
+var DEFAULT_TASK_INPUTS = {
+  build: ["src/**/*", "package.json"],
+  lint: ["src/**/*", "*.config.*"],
+  test: ["src/**/*", "**/__tests__/**/*"],
+  typecheck: ["src/**/*", "tsconfig*.json"],
+  format: ["src/**/*"]
+};
+var TASK_ORDER = ["build", "lint", "test", "typecheck", "format"];
+var FALLBACK_TASKS = ["build", "lint", "test"];
+function inputsFor(task) {
+  return DEFAULT_TASK_INPUTS[task] ?? DEFAULT_TASK_INPUTS["build"] ?? [];
+}
+function runPrefix(pm) {
+  return pm === "pnpm" || pm === "yarn" ? pm : "npm run";
+}
+function binaryRunner(pm) {
+  if (pm === "pnpm") return "pnpm";
+  if (pm === "yarn") return "yarn";
+  return "npx";
+}
+function defaultCommandFor(pm, task, framework) {
+  if (task === "build" && framework === "next") {
+    return `${binaryRunner(pm)} next build`;
+  }
+  if (task === "build" && framework === "vite") {
+    return `${binaryRunner(pm)} vite build`;
+  }
+  return `${runPrefix(pm)} ${task}`;
+}
+async function detectScriptTasks(cwd) {
+  try {
+    const manifest = JSON.parse(
+      await readFile(path.join(cwd, "package.json"), "utf8")
+    );
+    const present = new Set(Object.keys(manifest.scripts ?? {}));
+    const ordered = TASK_ORDER.filter((task) => present.has(task));
+    return ordered.length > 0 ? ordered : [...FALLBACK_TASKS];
+  } catch {
+    return [...FALLBACK_TASKS];
+  }
+}
+function renderConfigTemplate(tasks) {
+  const taskLines = tasks.map(
+    ({ name, command, inputs }) => `    ${name}: {
+      command: "${command}",
+      inputs: [${inputs.map((i) => `"${i}"`).join(", ")}],
+    }`
+  ).join(",\n");
+  return `import { defineConfig } from "@blzsky/variant";
+
+export default defineConfig({
+  strategy: "adaptive",
+  tasks: {
+${taskLines},
+  },
+});
+`;
+}
+
+// src/cli/commands/init.ts
+var CONFIG_FILENAME = "variant.config.ts";
+function splitList(answer) {
+  return answer.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+async function registerInitAction() {
+  const cwd = process.cwd();
+  const printer = getPrinter();
+  const existing = findVariantConfigPath(cwd);
+  if (existing) {
+    lines(
+      printer,
+      `${path2.basename(existing)} already exists \u2014 nothing written.`
+    );
+    return;
+  }
+  const [{ pm, framework }, detectedScripts] = await Promise.all([
+    detectProject(cwd),
+    detectScriptTasks(cwd)
+  ]);
+  const pmName = pm.name;
+  const frameworkName = framework?.name ?? null;
+  const destination = path2.join(cwd, CONFIG_FILENAME);
+  if (!process.stdin.isTTY) {
+    const build = {
+      name: "build",
+      command: defaultCommandFor(pmName, "build", frameworkName),
+      inputs: inputsFor("build")
+    };
+    await writeFile(destination, renderConfigTemplate([build]));
+    lines(
+      printer,
+      `Created ${CONFIG_FILENAME} (non-interactive, detected ${pmName}${frameworkName ? `/${frameworkName}` : ""})`
+    );
+    return;
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    lines(
+      printer,
+      "",
+      `Detected: ${pmName}${frameworkName ? ` \xB7 ${frameworkName}` : ""} \xB7 scripts: ${detectedScripts.join(", ")}`,
+      ""
+    );
+    const answeredTasks = await rl.question(
+      `Tasks to configure [${detectedScripts.join(",")}]: `
+    );
+    const taskNames = answeredTasks.trim() ? splitList(answeredTasks) : detectedScripts;
+    const tasks = [];
+    for (const name of taskNames) {
+      const suggestedCommand = defaultCommandFor(pmName, name, frameworkName);
+      const answeredCommand = await rl.question(
+        `  Command for "${name}" [${suggestedCommand}]: `
+      );
+      const suggestedInputs = inputsFor(name);
+      const answeredInputs = await rl.question(
+        `  Inputs for "${name}" [${suggestedInputs.join(", ")}]: `
+      );
+      tasks.push({
+        name,
+        command: answeredCommand.trim() || suggestedCommand,
+        inputs: answeredInputs.trim() ? splitList(answeredInputs) : suggestedInputs
+      });
+    }
+    await writeFile(destination, renderConfigTemplate(tasks));
+    lines(
+      printer,
+      "",
+      `Created ${CONFIG_FILENAME} \u2014 run \`variant doctor\` to verify.`
+    );
+  } finally {
+    rl.close();
+  }
+}
+export {
+  registerInitAction
+};

package/dist/insight-DZ5NQY6D.js

@@ -0,0 +1,29 @@
+import {
+  computeInsights,
+  readCache
+} from "./chunk-LXKLCLL6.js";
+import {
+  renderInsights
+} from "./chunk-ISRF5F3Q.js";
+import {
+  createContext
+} from "./chunk-SWPVR2DF.js";
+import "./chunk-V5CTGXMM.js";
+import "./chunk-RGD422OM.js";
+import "./chunk-YYGCSKIQ.js";
+import "./chunk-MZZOE7L4.js";
+import "./chunk-3E5LBU3O.js";
+import "./chunk-RVXUCJYA.js";
+import "./chunk-XUBWCTJZ.js";
+import "./chunk-6J4XDG44.js";
+import "./chunk-V22IPJ7A.js";
+
+// src/cli/commands/insight.ts
+async function registerInsightAction() {
+  const ctx = await createContext(process.cwd(), { scope: false });
+  const cache = await readCache(ctx.cacheDir);
+  renderInsights(computeInsights([], cache));
+}
+export {
+  registerInsightAction
+};

package/dist/pr-UFZRZX6S.js

@@ -0,0 +1,152 @@
+import {
+  deriveVerdict,
+  verdictText
+} from "./chunk-DRMASVYN.js";
+import {
+  classifyFileAgainstRef
+} from "./chunk-NSNZOH5P.js";
+import "./chunk-LJDDS4RR.js";
+import {
+  listChangedFilesSinceMergeBase
+} from "./chunk-XUBWCTJZ.js";
+import {
+  classificationLabel
+} from "./chunk-CXNXZLDG.js";
+import {
+  lines
+} from "./chunk-6J4XDG44.js";
+import {
+  getPrinter
+} from "./chunk-V22IPJ7A.js";
+import "./chunk-O4LZKXNZ.js";
+
+// src/cli/commands/pr.ts
+import { writeFile } from "fs/promises";
+import path from "path";
+
+// src/core/pr/check.ts
+var DEFAULT_PR_BASE_REF = "main";
+var TS_FILE = /\.tsx?$/;
+async function runPrCheck(cwd, options = {}) {
+  const baseRef = options.base ?? DEFAULT_PR_BASE_REF;
+  const changed = options.changedFiles ?? await listChangedFilesSinceMergeBase(cwd, baseRef) ?? [];
+  const tsFiles = changed.filter((file) => TS_FILE.test(file));
+  const files = [];
+  for (const relPath of tsFiles) {
+    files.push(await classifyFileAgainstRef(cwd, relPath, baseRef));
+  }
+  return {
+    baseRef,
+    tsFilesChanged: tsFiles.length,
+    files,
+    verdict: deriveVerdict(files.map((file) => file.classification))
+  };
+}
+
+// src/core/pr/report.ts
+async function buildPrReport(cwd, options = {}) {
+  const check = await runPrCheck(cwd, options);
+  return { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), check };
+}
+var VERDICT_EMOJI = {
+  "safe-to-skip": "\u2705",
+  "build-recommended": "\u26A0\uFE0F",
+  "build-required": "\u{1F534}"
+};
+var VERDICT_HEADING = {
+  "safe-to-skip": "Safe to skip build",
+  "build-recommended": "Build recommended",
+  "build-required": "Build required"
+};
+function symbolDelta(counts) {
+  const delta = [];
+  if (counts.added.length > 0) delta.push(`+${counts.added.length}`);
+  if (counts.removed.length > 0) delta.push(`-${counts.removed.length}`);
+  if (counts.changed.length > 0) delta.push(`~${counts.changed.length}`);
+  return delta;
+}
+function formatPrReportJson(report) {
+  return JSON.stringify(report, null, 2);
+}
+function formatPrReportMarkdown(report) {
+  const { check } = report;
+  const lines2 = [
+    "## Variant PR Report",
+    "",
+    `**Generated:** ${report.generatedAt}  `,
+    `**Base ref:** \`${check.baseRef}\`  `,
+    "",
+    "### Semantic Diff",
+    "",
+    `${VERDICT_EMOJI[check.verdict]} **${VERDICT_HEADING[check.verdict]}**`,
+    ""
+  ];
+  if (check.files.length > 0) {
+    lines2.push(
+      "| File | Classification | API Changes |",
+      "|------|----------------|-------------|"
+    );
+    for (const file of check.files) {
+      const delta = symbolDelta(file.exportedSymbols);
+      lines2.push(
+        `| \`${file.filePath}\` | ${file.classification} | ${delta.join(" ") || "\u2014"} |`
+      );
+    }
+    lines2.push("");
+  } else {
+    lines2.push("_No TypeScript files changed._", "");
+  }
+  return lines2.join("\n");
+}
+
+// src/cli/render/pr.ts
+function symbolSummary(symbols) {
+  const changes = [];
+  if (symbols.added.length > 0) changes.push(`+${symbols.added.length} added`);
+  if (symbols.removed.length > 0) {
+    changes.push(`-${symbols.removed.length} removed`);
+  }
+  if (symbols.changed.length > 0) {
+    changes.push(`~${symbols.changed.length} changed`);
+  }
+  return changes.length > 0 ? `  (${changes.join(", ")})` : "";
+}
+function renderPrCheck(result, printer = getPrinter()) {
+  lines(
+    printer,
+    "",
+    `Base ref: ${result.baseRef}`,
+    `Changed .ts files: ${result.tsFilesChanged}`
+  );
+  if (result.files.length > 0) {
+    lines(printer, "", "File classifications:");
+    for (const file of result.files) {
+      lines(
+        printer,
+        `  ${classificationLabel(file.classification)}  ${file.filePath}${symbolSummary(file.exportedSymbols)}`
+      );
+    }
+  }
+  lines(printer, "", `Verdict: ${verdictText(result.verdict)}`);
+}
+
+// src/cli/commands/pr.ts
+async function registerPrCheckAction(opts) {
+  renderPrCheck(await runPrCheck(process.cwd(), opts));
+}
+async function registerPrReportAction(opts) {
+  const cwd = process.cwd();
+  const report = await buildPrReport(cwd, opts);
+  const content = opts.markdown ? formatPrReportMarkdown(report) : formatPrReportJson(report);
+  if (opts.output === void 0) {
+    lines(getPrinter(), content);
+    return;
+  }
+  await writeFile(path.resolve(cwd, opts.output), content, "utf8");
+  const kind = opts.markdown ? "Markdown report" : "Report";
+  lines(getPrinter(), `${kind} written to ${opts.output}`);
+}
+export {
+  registerPrCheckAction,
+  registerPrReportAction
+};

package/dist/run-6PNH4QRA.js

@@ -0,0 +1,40 @@
+import {
+  executeTarget,
+  renderDryRunPlan,
+  reportRunInsights
+} from "./chunk-4LLK2S4R.js";
+import "./chunk-LXKLCLL6.js";
+import "./chunk-ISRF5F3Q.js";
+import {
+  createContext,
+  toRunOptions
+} from "./chunk-SWPVR2DF.js";
+import "./chunk-V5CTGXMM.js";
+import "./chunk-RGD422OM.js";
+import "./chunk-YYGCSKIQ.js";
+import "./chunk-GDSZFIHM.js";
+import "./chunk-MZZOE7L4.js";
+import "./chunk-3E5LBU3O.js";
+import "./chunk-RVXUCJYA.js";
+import "./chunk-XUBWCTJZ.js";
+import "./chunk-6J4XDG44.js";
+import "./chunk-V22IPJ7A.js";
+
+// src/cli/commands/run.ts
+async function registerRunAction(taskName, opts = {}) {
+  const ctx = await createContext();
+  if (opts.dryRun) {
+    renderDryRunPlan(taskName, ctx.graph.toLevels(taskName));
+    return;
+  }
+  const results = await executeTarget(
+    taskName,
+    ctx,
+    toRunOptions(ctx, opts),
+    `Running ${taskName} tasks...`
+  );
+  await reportRunInsights(ctx, results);
+}
+export {
+  registerRunAction
+};

package/dist/symbol-graph-YYUEMZGR.js

@@ -0,0 +1,22 @@
+import {
+  SYMBOL_GRAPH_VERSION,
+  buildSymbolGraph,
+  defaultGraphDir,
+  findSymbol,
+  getFileIndex,
+  loadSymbolGraph,
+  saveSymbolGraph,
+  updateSymbolGraph
+} from "./chunk-VTJ67TT5.js";
+import "./chunk-RVXUCJYA.js";
+import "./chunk-O4LZKXNZ.js";
+export {
+  SYMBOL_GRAPH_VERSION,
+  buildSymbolGraph,
+  defaultGraphDir,
+  findSymbol,
+  getFileIndex,
+  loadSymbolGraph,
+  saveSymbolGraph,
+  updateSymbolGraph
+};

package/dist/tsconfig-paths-E3UEDGXZ.js

@@ -0,0 +1,10 @@
+import {
+  matchPathAlias,
+  readPathAliases,
+  toPathAliases
+} from "./chunk-KSHWC2XN.js";
+export {
+  matchPathAlias,
+  readPathAliases,
+  toPathAliases
+};

package/dist/workspace-X5FUBTY3.js

@@ -0,0 +1,186 @@
+import {
+  resolveRelativeImport
+} from "./chunk-XTYVVUWW.js";
+import {
+  loadPackageGraph
+} from "./chunk-3E5LBU3O.js";
+import "./chunk-KSHWC2XN.js";
+import {
+  updateSymbolGraph
+} from "./chunk-VTJ67TT5.js";
+import "./chunk-RVXUCJYA.js";
+import {
+  plural
+} from "./chunk-CXNXZLDG.js";
+import {
+  lines
+} from "./chunk-6J4XDG44.js";
+import {
+  getPrinter
+} from "./chunk-V22IPJ7A.js";
+import "./chunk-O4LZKXNZ.js";
+
+// src/core/graph/workspace-audit.ts
+import { readFile } from "fs/promises";
+import path from "path";
+
+// src/core/graph/workspace-check.ts
+import { builtinModules } from "module";
+var BUILTINS = new Set(builtinModules);
+function checkWorkspace(input) {
+  const { symbolGraph, packages } = input;
+  const rootDeclared = input.rootDeclared ?? /* @__PURE__ */ new Set();
+  const byName = new Map(packages.map((p) => [p.name, p]));
+  const files = new Set(Object.keys(symbolGraph.files));
+  const grouped = /* @__PURE__ */ new Map();
+  const addViolation = (kind, pkg, target, file) => {
+    const key = `${kind}|${pkg}|${target}`;
+    let violation = grouped.get(key);
+    if (violation === void 0) {
+      violation = { kind, package: pkg, target, files: [] };
+      grouped.set(key, violation);
+    }
+    if (!violation.files.includes(file)) violation.files.push(file);
+  };
+  for (const file of [...files].sort()) {
+    const owner = fileToPackage(file, packages);
+    if (owner === void 0) continue;
+    for (const imp of symbolGraph.files[file]?.imports ?? []) {
+      const spec = imp.module;
+      if (spec.startsWith("./") || spec.startsWith("../")) {
+        const target = resolveRelativeImport(file, spec, files);
+        if (target === void 0) continue;
+        const targetOwner = fileToPackage(target, packages);
+        if (targetOwner !== void 0 && targetOwner.name !== owner.name) {
+          addViolation(
+            "cross-package-relative-import",
+            owner.name,
+            targetOwner.name,
+            file
+          );
+        }
+        continue;
+      }
+      const name = packageNameOf(stripNodePrefix(spec));
+      if (name === void 0 || BUILTINS.has(name)) continue;
+      if (spec.startsWith("node:") || name === owner.name) continue;
+      if (byName.has(name)) {
+        if (!owner.declared.has(name)) {
+          addViolation("undeclared-workspace-dep", owner.name, name, file);
+        }
+        continue;
+      }
+      if (!owner.declared.has(name) && !rootDeclared.has(name)) {
+        addViolation("undeclared-external-dep", owner.name, name, file);
+      }
+    }
+  }
+  const violations = [...grouped.values()].map((v) => ({ ...v, files: [...v.files].sort() })).sort(
+    (a, b) => a.package.localeCompare(b.package) || a.target.localeCompare(b.target) || a.kind.localeCompare(b.kind)
+  );
+  return { packagesChecked: packages.length, violations };
+}
+function fileToPackage(file, packages) {
+  let best;
+  let bestLength = -1;
+  for (const pkg of packages) {
+    const prefix = `${pkg.dir}/`;
+    if (file.startsWith(prefix) && prefix.length > bestLength) {
+      best = pkg;
+      bestLength = prefix.length;
+    }
+  }
+  return best;
+}
+function packageNameOf(spec) {
+  const segments = spec.split("/");
+  const nameLength = spec.startsWith("@") ? 2 : 1;
+  if (segments.length < nameLength) return void 0;
+  const name = segments.slice(0, nameLength).join("/");
+  return name === "" ? void 0 : name;
+}
+function stripNodePrefix(spec) {
+  return spec.startsWith("node:") ? spec.slice(5) : spec;
+}
+
+// src/core/graph/workspace-audit.ts
+function declaredNames(manifest) {
+  return /* @__PURE__ */ new Set([
+    ...Object.keys(manifest.dependencies ?? {}),
+    ...Object.keys(manifest.devDependencies ?? {}),
+    ...Object.keys(manifest.peerDependencies ?? {})
+  ]);
+}
+async function readRootDeclared(cwd) {
+  try {
+    const manifest = JSON.parse(
+      await readFile(path.join(cwd, "package.json"), "utf8")
+    );
+    return declaredNames(manifest);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+async function auditWorkspace(cwd) {
+  const packageGraph = await loadPackageGraph(cwd).catch(() => null);
+  if (packageGraph === null || packageGraph.packages.length === 0) return null;
+  const packages = packageGraph.packages.map((pkg) => ({
+    name: pkg.manifest.name,
+    dir: path.relative(cwd, pkg.dir).replace(/\\/g, "/"),
+    declared: declaredNames(pkg.manifest)
+  }));
+  const { graph: symbolGraph } = await updateSymbolGraph(cwd);
+  return checkWorkspace({
+    symbolGraph,
+    packages,
+    rootDeclared: await readRootDeclared(cwd)
+  });
+}
+
+// src/cli/render/workspace.ts
+var MAX_FILES_SHOWN = 5;
+var NO_WORKSPACE_MESSAGE = "workspace check: no workspace packages found (pnpm-workspace.yaml or package.json `workspaces` required).";
+var DESCRIBE = {
+  "undeclared-workspace-dep": (v) => `${v.package} imports ${v.target} but does not declare it`,
+  "undeclared-external-dep": (v) => `${v.package} imports ${v.target} but neither it nor the workspace root declares it`,
+  "cross-package-relative-import": (v) => `${v.package} reaches into ${v.target} via a relative import (bypasses its public entry)`
+};
+function renderWorkspaceCheck(result, printer = getPrinter()) {
+  lines(printer, "", `Checked ${plural(result.packagesChecked, "package")}.`);
+  if (result.violations.length === 0) {
+    lines(printer, "", "No dependency violations found.");
+    return;
+  }
+  lines(printer, "");
+  for (const violation of result.violations) {
+    lines(printer, `  \u2717 ${DESCRIBE[violation.kind](violation)}`);
+    for (const file of violation.files.slice(0, MAX_FILES_SHOWN)) {
+      lines(printer, `      ${file}`);
+    }
+    if (violation.files.length > MAX_FILES_SHOWN) {
+      lines(
+        printer,
+        `      \u2026 and ${violation.files.length - MAX_FILES_SHOWN} more file(s)`
+      );
+    }
+  }
+  lines(printer, "", `${plural(result.violations.length, "violation")} found.`);
+}
+
+// src/cli/commands/workspace.ts
+async function registerWorkspaceCheckAction(opts = {}) {
+  const result = await auditWorkspace(process.cwd());
+  if (result === null) {
+    lines(getPrinter(), NO_WORKSPACE_MESSAGE);
+    return;
+  }
+  if (opts.json === true) {
+    lines(getPrinter(), JSON.stringify(result, null, 2));
+  } else {
+    renderWorkspaceCheck(result);
+  }
+  if (result.violations.length > 0) process.exitCode = 1;
+}
+export {
+  registerWorkspaceCheckAction
+};