@vaubaan/harness 0.0.0-stage → 1.3.0

package/dist/linters/index.js

@@ -0,0 +1,726 @@
+// src/linters/util.ts
+import { execFileSync } from "child_process";
+import { existsSync, readFileSync, statSync } from "fs";
+import { join, relative } from "path";
+import fg from "fast-glob";
+import matter from "gray-matter";
+function fileExists(repoRoot, relativePath) {
+  return existsSync(join(repoRoot, relativePath));
+}
+function readText(repoRoot, relativePath) {
+  return readFileSync(join(repoRoot, relativePath), "utf8");
+}
+function listMarkdown(repoRoot, dir) {
+  const cwd = join(repoRoot, dir);
+  if (!existsSync(cwd)) return [];
+  return fg.sync("**/*.md", { cwd, absolute: false, ignore: ["**/node_modules/**", "**/dist/**"] }).filter((f) => !f.endsWith("README.md")).map((f) => join(dir, f));
+}
+function dirExists(repoRoot, relativePath) {
+  const full = join(repoRoot, relativePath);
+  if (!existsSync(full)) return false;
+  return statSync(full).isDirectory();
+}
+function parseFrontmatter(text) {
+  const m = matter(text);
+  return { data: m.data, body: m.content };
+}
+function gitLastCommitForPath(repoRoot, relativePath) {
+  try {
+    const out = execFileSync("git", ["log", "-1", "--format=%H:%ct", "--", relativePath], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (!out) return void 0;
+    const idx = out.indexOf(":");
+    if (idx < 0) return void 0;
+    const hash = out.slice(0, idx);
+    const ts = Number.parseInt(out.slice(idx + 1), 10);
+    return { hash, timestamp: ts };
+  } catch {
+    return void 0;
+  }
+}
+function gitCommitsSince(repoRoot, relativePath, sinceCommit) {
+  try {
+    const out = execFileSync(
+      "git",
+      ["log", `${sinceCommit}..HEAD`, "--format=%H", "--", relativePath],
+      {
+        cwd: repoRoot,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }
+    ).trim();
+    if (!out) return 0;
+    return out.split("\n").filter(Boolean).length;
+  } catch {
+    return 0;
+  }
+}
+function findLineNumber(text, needle) {
+  const lines = text.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (typeof needle === "string" ? line.includes(needle) : needle.test(line)) {
+      return i + 1;
+    }
+  }
+  return void 0;
+}
+
+// src/linters/adr-no-tracks.ts
+var ADR_DIR = "docs/decisions";
+var adrNoTracks = {
+  id: "lint:adr-no-tracks",
+  pillars: ["decisions"],
+  defaultSeverity: "error",
+  suggestedSkills: ["/decision"],
+  run(repoRoot) {
+    const issues = [];
+    const files = listMarkdown(repoRoot, ADR_DIR);
+    for (const f of files) {
+      const text = readText(repoRoot, f);
+      const { data } = parseFrontmatter(text);
+      if (!("tracks" in data)) continue;
+      const value = data.tracks;
+      if (Array.isArray(value) && value.length === 0) continue;
+      issues.push({
+        linter: this.id,
+        severity: "error",
+        file: f,
+        message: "ADRs must not declare `tracks:` (or must set it to []). ADRs document a decision frozen in time, not the current state of code \u2014 use status: superseded to mark them obsolete instead."
+      });
+    }
+    return issues;
+  }
+};
+
+// src/linters/cardinal-files.ts
+var REQUIRED_FILES = [
+  "docs/tests/integration-tests.md",
+  "docs/tests/e2e-tests.md",
+  "docs/workflow/coding-workflow.md"
+];
+var cardinalFiles = {
+  id: "lint:cardinal-files",
+  pillars: ["tests", "workflow"],
+  defaultSeverity: "error",
+  suggestedSkills: ["/test-plan", "/workflow"],
+  run(repoRoot) {
+    const issues = [];
+    for (const f of REQUIRED_FILES) {
+      if (!fileExists(repoRoot, f)) {
+        issues.push({
+          linter: this.id,
+          severity: "error",
+          file: f,
+          message: `missing required cardinal file: ${f}`
+        });
+      }
+    }
+    return issues;
+  }
+};
+
+// src/linters/config.ts
+import { cosmiconfigSync } from "cosmiconfig";
+var DEFAULT_CONFIG = { ignore: [] };
+function loadLintConfig(repoRoot) {
+  const explorer = cosmiconfigSync("harness", {
+    searchPlaces: [
+      "package.json",
+      ".harnessrc",
+      ".harnessrc.json",
+      ".harnessrc.yaml",
+      ".harnessrc.yml",
+      "harness.config.js",
+      "harness.config.cjs"
+    ]
+  });
+  const result = explorer.search(repoRoot);
+  if (!result || result.isEmpty) return DEFAULT_CONFIG;
+  const raw = result.config;
+  if (!raw) return DEFAULT_CONFIG;
+  const lint = raw.lint;
+  if (!lint) return DEFAULT_CONFIG;
+  const ignore = lint.ignore;
+  if (!Array.isArray(ignore)) return DEFAULT_CONFIG;
+  return { ignore: ignore.filter((x) => typeof x === "string") };
+}
+
+// src/linters/cross-links.ts
+import { existsSync as existsSync2 } from "fs";
+import { dirname, isAbsolute, join as join2, resolve } from "path";
+import fg2 from "fast-glob";
+var LINK_REGEX = /\[([^\]]+)\]\(([^)]+)\)/g;
+function maskCodeSpans(text) {
+  return text.replace(/```[\s\S]*?```/g, (m) => m.replace(/[^\n]/g, " ")).replace(/`[^`\n]*`/g, (m) => " ".repeat(m.length));
+}
+function isExternalOrAnchor(url) {
+  if (url.startsWith("http://") || url.startsWith("https://")) return true;
+  if (url.startsWith("mailto:")) return true;
+  if (url.startsWith("#")) return true;
+  return false;
+}
+function stripFragment(url) {
+  const i = url.indexOf("#");
+  return i < 0 ? url : url.slice(0, i);
+}
+function resolveLink(repoRoot, sourceFile, link) {
+  const noFrag = stripFragment(link);
+  if (isAbsolute(noFrag)) return join2(repoRoot, noFrag);
+  return resolve(dirname(join2(repoRoot, sourceFile)), noFrag);
+}
+var crossLinks = {
+  id: "lint:cross-links",
+  pillars: ["all"],
+  defaultSeverity: "error",
+  run(repoRoot, ctx) {
+    const extra = ctx?.config.ignore ?? [];
+    const issues = [];
+    const allDocs = fg2.sync("**/*.md", {
+      cwd: repoRoot,
+      absolute: false,
+      ignore: [
+        "**/node_modules/**",
+        "**/dist/**",
+        ".harness-overrides/**",
+        "skills/**",
+        "agents/**",
+        "commands/**",
+        "templates/**",
+        "**/*.skill.md",
+        "**/*.cmd.md",
+        "**/*.agent.md",
+        ...extra
+      ]
+    });
+    for (const f of allDocs) {
+      const text = maskCodeSpans(readText(repoRoot, f));
+      const lines = text.split("\n");
+      for (let lineNo = 0; lineNo < lines.length; lineNo++) {
+        const line = lines[lineNo] ?? "";
+        LINK_REGEX.lastIndex = 0;
+        let match;
+        match = LINK_REGEX.exec(line);
+        while (match !== null) {
+          const url = match[2];
+          if (url && !isExternalOrAnchor(url)) {
+            const noFrag = stripFragment(url);
+            if (noFrag !== "" && !noFrag.startsWith("data:")) {
+              const target = resolveLink(repoRoot, f, url);
+              if (!existsSync2(target)) {
+                issues.push({
+                  linter: this.id,
+                  severity: "error",
+                  file: f,
+                  line: lineNo + 1,
+                  message: `broken link: ${url}`
+                });
+              }
+            }
+          }
+          match = LINK_REGEX.exec(line);
+        }
+      }
+    }
+    return issues;
+  }
+};
+
+// src/linters/decision-schema.ts
+var REQUIRED_SECTIONS = [
+  { label: "Context", pattern: /^##\s+(Context|Contexte)\b/m },
+  { label: "Decision", pattern: /^##\s+(Decision|D[ée]cision)\b/m },
+  { label: "Consequences", pattern: /^##\s+(Consequences|Cons[ée]quences)\b/m },
+  {
+    label: "Rejected alternatives",
+    pattern: /^##\s+(Rejected\s+alternatives|Alternatives(\s+rejet[ée]es)?)\b/im
+  }
+];
+var decisionSchema = {
+  id: "lint:decision-schema",
+  pillars: ["decisions"],
+  defaultSeverity: "error",
+  suggestedSkills: ["/decision"],
+  run(repoRoot) {
+    const issues = [];
+    const files = listMarkdown(repoRoot, "docs/decisions");
+    for (const f of files) {
+      const text = readText(repoRoot, f);
+      for (const { label, pattern } of REQUIRED_SECTIONS) {
+        if (!pattern.test(text)) {
+          issues.push({
+            linter: this.id,
+            severity: "error",
+            file: f,
+            message: `missing required section: "${label}"`
+          });
+        }
+      }
+    }
+    return issues;
+  }
+};
+
+// src/linters/doc-layout.ts
+var REQUIRED_DIRS = [
+  "docs/spec",
+  "docs/decisions",
+  "docs/handbook",
+  "docs/tests",
+  "docs/workflow"
+];
+var docLayout = {
+  id: "lint:doc-layout",
+  pillars: ["all"],
+  defaultSeverity: "error",
+  run(repoRoot) {
+    const issues = [];
+    for (const dir of REQUIRED_DIRS) {
+      if (!dirExists(repoRoot, dir)) {
+        issues.push({
+          linter: this.id,
+          severity: "error",
+          file: dir,
+          message: `missing required directory: ${dir}/`
+        });
+      }
+    }
+    return issues;
+  }
+};
+
+// src/linters/frontmatter-tracks.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import fg3 from "fast-glob";
+var TRACKED_DIRS = ["docs/handbook", "docs/tests", "docs/workflow"];
+function trackedPathExists(repoRoot, pattern) {
+  if (pattern.includes("*")) {
+    return fg3.sync(pattern, { cwd: repoRoot, absolute: false }).length > 0;
+  }
+  return existsSync3(join3(repoRoot, pattern));
+}
+var frontmatterTracks = {
+  id: "lint:frontmatter-tracks",
+  pillars: ["handbook", "tests", "workflow"],
+  defaultSeverity: "error",
+  suggestedSkills: ["/handbook", "/test-plan", "/workflow"],
+  run(repoRoot) {
+    const issues = [];
+    for (const dir of TRACKED_DIRS) {
+      const files = listMarkdown(repoRoot, dir);
+      for (const f of files) {
+        const text = readText(repoRoot, f);
+        const { data } = parseFrontmatter(text);
+        if (!Array.isArray(data.tracks)) {
+          issues.push({
+            linter: this.id,
+            severity: "error",
+            file: f,
+            message: "missing frontmatter `tracks:` array"
+          });
+          continue;
+        }
+        for (const tracked of data.tracks) {
+          if (typeof tracked !== "string") {
+            issues.push({
+              linter: this.id,
+              severity: "error",
+              file: f,
+              message: "`tracks` entries must be strings"
+            });
+            continue;
+          }
+          if (!trackedPathExists(repoRoot, tracked)) {
+            issues.push({
+              linter: this.id,
+              severity: "error",
+              file: f,
+              message: `tracked path does not exist: ${tracked}`
+            });
+          }
+        }
+      }
+    }
+    return issues;
+  }
+};
+
+// src/linters/gitignore-harness.ts
+var REQUIRED_ENTRIES = [
+  ".harness-overrides/",
+  ".harness-manifest.json",
+  ".claude/",
+  ".codex/",
+  ".opencode/",
+  ".agents/",
+  ".vaubaan/",
+  "AGENTS.md",
+  "CLAUDE.md",
+  ".mcp.json"
+];
+var gitignoreHarness = {
+  id: "lint:gitignore-harness",
+  pillars: ["repo-root"],
+  defaultSeverity: "error",
+  run(repoRoot) {
+    const issues = [];
+    if (!fileExists(repoRoot, ".gitignore")) {
+      issues.push({
+        linter: this.id,
+        severity: "error",
+        file: ".gitignore",
+        message: ".gitignore is missing at repo root"
+      });
+      return issues;
+    }
+    const text = readText(repoRoot, ".gitignore");
+    const lines = new Set(
+      text.split("\n").map((l) => l.trim()).filter(Boolean)
+    );
+    for (const entry of REQUIRED_ENTRIES) {
+      const variants = [entry, entry.replace(/\/$/, "")];
+      if (!variants.some((v) => lines.has(v))) {
+        issues.push({
+          linter: this.id,
+          severity: "error",
+          file: ".gitignore",
+          message: `.gitignore must contain "${entry}"`
+        });
+      }
+    }
+    return issues;
+  }
+};
+
+// src/linters/orphan-decisions.ts
+import { basename } from "path";
+import fg4 from "fast-glob";
+var orphanDecisions = {
+  id: "lint:orphan-decisions",
+  pillars: ["decisions"],
+  defaultSeverity: "warning",
+  suggestedSkills: ["/handbook"],
+  run(repoRoot, ctx) {
+    const extra = ctx?.config.ignore ?? [];
+    const issues = [];
+    const adrs = listMarkdown(repoRoot, "docs/decisions");
+    if (adrs.length === 0) return issues;
+    const otherDocs = fg4.sync("**/*.md", {
+      cwd: repoRoot,
+      absolute: false,
+      ignore: [
+        "**/node_modules/**",
+        "**/dist/**",
+        ".harness-overrides/**",
+        "docs/decisions/**",
+        "skills/**",
+        "agents/**",
+        "commands/**",
+        "templates/**",
+        ...extra
+      ]
+    });
+    const referenceCorpus = otherDocs.map((f) => readText(repoRoot, f)).join("\n");
+    for (const adr of adrs) {
+      const filename = basename(adr);
+      const stem = filename.replace(/\.md$/, "");
+      const referenced = referenceCorpus.includes(filename) || referenceCorpus.includes(stem);
+      if (!referenced) {
+        issues.push({
+          linter: this.id,
+          severity: "warning",
+          file: adr,
+          message: "ADR is not referenced by any other doc file (orphan)"
+        });
+      }
+    }
+    return issues;
+  }
+};
+
+// src/linters/quality-schema.ts
+var QUALITY_DIR = "docs/quality";
+var CARDINAL_FILE = `${QUALITY_DIR}/code-quality.md`;
+var REQUIRED_SECTIONS2 = [
+  {
+    label: "Mechanical checks",
+    pattern: /^##\s+(Mechanical\s+checks|V[ée]rifications\s+m[ée]caniques)\s*$/im
+  },
+  { label: "Project rules", pattern: /^##\s+(Project\s+rules|R[èe]gles\s+du\s+projet)\s*$/im },
+  {
+    label: "Accepted deviations",
+    pattern: /^##\s+(Accepted\s+deviations|[ÉE]carts\s+assum[ée]s)\s*$/im
+  }
+];
+var qualitySchema = {
+  id: "lint:quality-schema",
+  pillars: ["quality"],
+  defaultSeverity: "error",
+  run(repoRoot) {
+    if (!dirExists(repoRoot, QUALITY_DIR)) return [];
+    if (!fileExists(repoRoot, CARDINAL_FILE)) {
+      return [
+        {
+          linter: this.id,
+          severity: "error",
+          file: CARDINAL_FILE,
+          message: `missing required cardinal file: ${CARDINAL_FILE}`
+        }
+      ];
+    }
+    const text = readText(repoRoot, CARDINAL_FILE);
+    return REQUIRED_SECTIONS2.filter(({ pattern }) => !pattern.test(text)).map(({ label }) => ({
+      linter: this.id,
+      severity: "error",
+      file: CARDINAL_FILE,
+      message: `missing required section: "${label}"`
+    }));
+  }
+};
+
+// src/linters/readme-presence.ts
+var readmePresence = {
+  id: "lint:readme-presence",
+  pillars: ["readme"],
+  defaultSeverity: "error",
+  suggestedSkills: ["/readme"],
+  run(repoRoot) {
+    if (fileExists(repoRoot, "README.md")) return [];
+    return [
+      {
+        linter: this.id,
+        severity: "error",
+        file: "README.md",
+        message: "README.md is missing at repo root"
+      }
+    ];
+  }
+};
+
+// src/linters/readme-sections.ts
+var REQUIRED_SECTIONS3 = [
+  /^#\s+\S/m,
+  /^##?\s+(What is this|Quick start)/im,
+  /^##?\s+(Quick start|Install|Getting started)/im
+];
+var REQUIRED_LABELS = ["title (# H1)", "What is this / intro", "Quick start / Install"];
+var readmeSections = {
+  id: "lint:readme-sections",
+  pillars: ["readme"],
+  defaultSeverity: "error",
+  suggestedSkills: ["/readme"],
+  run(repoRoot) {
+    if (!fileExists(repoRoot, "README.md")) return [];
+    const text = readText(repoRoot, "README.md");
+    const issues = [];
+    for (let i = 0; i < REQUIRED_SECTIONS3.length; i++) {
+      const pattern = REQUIRED_SECTIONS3[i];
+      const label = REQUIRED_LABELS[i];
+      if (pattern && !pattern.test(text)) {
+        issues.push({
+          linter: this.id,
+          severity: "error",
+          file: "README.md",
+          message: `missing required section: ${label}`
+        });
+      }
+    }
+    return issues;
+  }
+};
+
+// src/linters/spec-has-content.ts
+var specHasContent = {
+  id: "lint:spec-has-content",
+  pillars: ["spec"],
+  defaultSeverity: "warning",
+  suggestedSkills: ["/spec"],
+  run(repoRoot) {
+    if (!dirExists(repoRoot, "docs/spec")) return [];
+    const files = listMarkdown(repoRoot, "docs/spec");
+    if (files.length > 0) return [];
+    return [
+      {
+        linter: this.id,
+        severity: "warning",
+        file: "docs/spec",
+        message: "docs/spec/ has no markdown files \u2014 write at least one spec document"
+      }
+    ];
+  }
+};
+
+// src/linters/spec-tech-agnostic.ts
+function maskFencedBlocks(text) {
+  return text.replace(/```[\s\S]*?```/g, (m) => m.replace(/[^\n]/g, " "));
+}
+var TECH_BLOCKLIST = [
+  { pattern: /\bNext\.?js\b/i, keyword: "Next.js" },
+  { pattern: /\bSupabase\b/i, keyword: "Supabase" },
+  { pattern: /\bVercel\b/i, keyword: "Vercel" },
+  { pattern: /\bReact\b/, keyword: "React" },
+  { pattern: /\bTypeScript\b/, keyword: "TypeScript" },
+  { pattern: /\bDocker\b/, keyword: "Docker" },
+  { pattern: /\bKubernetes\b/i, keyword: "Kubernetes" },
+  { pattern: /\bPostgres(QL)?\b/i, keyword: "Postgres" },
+  { pattern: /\bMySQL\b/i, keyword: "MySQL" },
+  { pattern: /\bRedis\b/i, keyword: "Redis" },
+  { pattern: /\bnpm\b/, keyword: "npm" },
+  { pattern: /\bpnpm\b/, keyword: "pnpm" },
+  { pattern: /\byarn\b/, keyword: "yarn" }
+];
+var specTechAgnostic = {
+  id: "lint:spec-tech-agnostic",
+  pillars: ["spec"],
+  defaultSeverity: "error",
+  suggestedSkills: ["/spec"],
+  run(repoRoot) {
+    const issues = [];
+    const files = listMarkdown(repoRoot, "docs/spec");
+    for (const f of files) {
+      const text = maskFencedBlocks(readText(repoRoot, f));
+      for (const { pattern, keyword } of TECH_BLOCKLIST) {
+        if (pattern.test(text)) {
+          const issue = {
+            linter: this.id,
+            severity: "error",
+            file: f,
+            message: `forbidden tech keyword "${keyword}" \u2014 should be in handbook/ or decisions/`
+          };
+          const line = findLineNumber(text, pattern);
+          if (line !== void 0) issue.line = line;
+          issues.push(issue);
+        }
+      }
+    }
+    return issues;
+  }
+};
+
+// src/linters/tracks-drift.ts
+import fg5 from "fast-glob";
+var TRACKED_DIRS2 = ["docs/handbook", "docs/tests", "docs/workflow"];
+var DEFAULT_DRIFT_THRESHOLD = 10;
+function expandGlob(repoRoot, pattern) {
+  if (pattern.includes("*")) {
+    return fg5.sync(pattern, { cwd: repoRoot, absolute: false });
+  }
+  return [pattern];
+}
+var tracksDrift = {
+  id: "lint:tracks-drift",
+  pillars: ["handbook", "tests", "workflow"],
+  defaultSeverity: "warning",
+  suggestedSkills: ["/drift", "/handbook"],
+  run(repoRoot) {
+    const issues = [];
+    for (const dir of TRACKED_DIRS2) {
+      const files = listMarkdown(repoRoot, dir);
+      for (const f of files) {
+        const text = readText(repoRoot, f);
+        const { data } = parseFrontmatter(text);
+        if (!Array.isArray(data.tracks)) continue;
+        const docCommit = gitLastCommitForPath(repoRoot, f);
+        if (!docCommit) continue;
+        const threshold = typeof data.driftThreshold === "number" && data.driftThreshold > 0 ? data.driftThreshold : DEFAULT_DRIFT_THRESHOLD;
+        let driftCount = 0;
+        for (const tracked of data.tracks) {
+          if (typeof tracked !== "string") continue;
+          const targets = expandGlob(repoRoot, tracked);
+          for (const t of targets.length > 0 ? targets : [tracked]) {
+            driftCount += gitCommitsSince(repoRoot, t, docCommit.hash);
+          }
+        }
+        if (driftCount > threshold) {
+          issues.push({
+            linter: this.id,
+            severity: "warning",
+            file: f,
+            message: `tracked files changed in ${driftCount} commits since doc last edit (threshold ${threshold})`
+          });
+        }
+      }
+    }
+    return issues;
+  }
+};
+
+// src/linters/index.ts
+var ALL_LINTERS = [
+  readmePresence,
+  readmeSections,
+  docLayout,
+  cardinalFiles,
+  decisionSchema,
+  adrNoTracks,
+  frontmatterTracks,
+  tracksDrift,
+  specTechAgnostic,
+  specHasContent,
+  crossLinks,
+  orphanDecisions,
+  gitignoreHarness,
+  qualitySchema
+];
+function runLinters(repoRoot, opts = {}) {
+  const config = loadLintConfig(repoRoot);
+  const ctx = { repoRoot, config };
+  const filtered = ALL_LINTERS.filter((l) => {
+    if (opts.only && !opts.only.includes(l.id)) return false;
+    if (opts.pillar && !l.pillars.includes(opts.pillar) && !l.pillars.includes("all")) return false;
+    return true;
+  });
+  const issues = [];
+  for (const linter of filtered) {
+    try {
+      issues.push(...linter.run(repoRoot, ctx));
+    } catch (err) {
+      issues.push({
+        linter: linter.id,
+        severity: "error",
+        file: "<internal>",
+        message: `linter crashed: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  const errors = issues.filter((i) => i.severity === "error").length;
+  const warnings = issues.filter((i) => i.severity === "warning").length;
+  return {
+    version: 1,
+    summary: { errors, warnings, pass: errors === 0 },
+    issues
+  };
+}
+function suggestedSkillsFor(linterId) {
+  const linter = ALL_LINTERS.find((l) => l.id === linterId);
+  return linter?.suggestedSkills ?? [];
+}
+function formatReportText(report) {
+  const lines = [];
+  for (const issue of report.issues) {
+    const location = issue.line !== void 0 ? `:${issue.line}` : "";
+    lines.push(`${issue.file}${location}: ${issue.severity}[${issue.linter}]
+  ${issue.message}`);
+    const hints = suggestedSkillsFor(issue.linter);
+    if (hints.length > 0) {
+      lines.push(`  \u2192 Try: ${hints.join(", ")}`);
+    }
+  }
+  const { errors, warnings, pass } = report.summary;
+  lines.push("");
+  lines.push(
+    `${errors} ${errors === 1 ? "error" : "errors"}, ${warnings} ${warnings === 1 ? "warning" : "warnings"}. ${pass ? "\u2714 CI passes." : "\u2718 CI fails."}`
+  );
+  return lines.join("\n");
+}
+export {
+  ALL_LINTERS,
+  formatReportText,
+  loadLintConfig,
+  runLinters
+};
+//# sourceMappingURL=index.js.map