pbip-killer 0.5.0

package/README.md

@@ -0,0 +1,172 @@
+# pbip-killer
+
+Audit Power BI **PBIP / PBIR** reports from the command line or CI/CD — and fail
+the build when a report breaks your team's standards.
+
+This is the report-side sibling of [`dataflow-killer`](../cli). Where the
+dataflow CLI gates your data layer, this gates your **reports**: visuals,
+accessibility, governance and consistency. It is **audit-only** — it never
+modifies your `.pbip`.
+
+> **Status: v1 foundation.** Report (PBIR) analysis with a fully declarative,
+> customizable rule layer. The semantic-model (TMDL) side is intentionally out
+> of scope for now.
+
+## Why PBIR
+
+When you save a Power BI Desktop project as **PBIP** with the **enhanced report
+format (PBIR)** enabled, the report is stored as small per-page / per-visual JSON
+files. That makes it git-versionable *and* lintable at the visual level — which
+is exactly what this tool needs. Mandate "PBIP + PBIR on" for your team and you
+unlock CI gating without needing workspace Git integration.
+
+## Usage
+
+```bash
+# From the terminal
+npx pbip-killer audit ./MyProject.pbip
+npx pbip-killer audit ./MyProject.Report --format=md
+npx pbip-killer audit ./repo --config=pbipkiller.config.json --fail-on=warning
+```
+
+Exit code is **1** when any finding meets the `failOn` gate — that is what
+reddens a pipeline.
+
+### Use in GitHub Actions
+
+The [`action/`](action) wrapper installs the CLI and runs the audit. Drop this in
+`.github/workflows/report-audit.yml`:
+
+```yaml
+name: Report audit
+on:
+  pull_request:
+    paths: ['**/*.Report/**']
+jobs:
+  audit:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: Jesusveiga/DataflowKiller/pbip/action@v0.5.0
+        with:
+          path: .                 # a .pbip, a *.Report folder, or a repo root
+          # config: pbipkiller.config.json   # optional; auto-detected if omitted
+          # fail-on: warning                 # optional; overrides config's failOn
+          format: md
+```
+
+| Input     | Default | Notes |
+|-----------|---------|-------|
+| `path`    | `.`     | `.pbip` file, `*.Report` folder, or a repo folder containing one |
+| `config`  | —       | Path to `pbipkiller.config.json` (auto-detected in cwd if omitted) |
+| `fail-on` | —       | Override the gate; if omitted, the config's `failOn` wins |
+| `format`  | `human` | `human` · `json` · `md` |
+
+## The model rules see
+
+Rules never touch raw PBIR JSON. The parser normalizes it into clean, stable
+fields, and **those field names are the contract** for both filtering and
+message templating:
+
+| Scope     | Fields available |
+|-----------|------------------|
+| `report`  | `name`, `theme`, `exportDataMode`, `pageCount`, `visualCount`, `bookmarkCount` |
+| `page`    | `name`, `displayName`, `hidden`, `type`, `width`, `height`, `visualCount` |
+| `visual`  | `page`, `name`, `type`, `isCustomVisual`, `title`, `hasTitle`, `altText`, `hasAltText`, `hidden`, `width`, `height`, `x`, `y`, `tabOrder`, `fieldCount`, `measureCount`, `filterCount` |
+
+## Configuration — `pbipkiller.config.json`
+
+Three levels of customization, all in one file:
+
+### 1. Tune the built-in rules
+
+```jsonc
+{
+  "failOn": "critical",
+  "rules": {
+    "PERF001": { "severity": "warning", "max": 12 },  // override a threshold
+    "A11Y001": { "severity": "critical" },            // raise severity
+    "CONS001": "off"                                   // disable
+  }
+}
+```
+
+Built-in rules:
+
+| Id        | Category      | What it flags | Config keys | Default |
+|-----------|---------------|---------------|-------------|---------|
+| `PERF001` | Performance   | More than `max` data visuals on a page | `max` (15) | on |
+| `PERF002` | Performance   | More than `max` visuals report-wide | `max` (60) | on |
+| `PERF003` | Performance   | More than `max` slicers on a page | `max` (4) | on |
+| `PERF004` | Performance   | A visual binding more than `max` fields | `max` (10) | on |
+| `PERF005` | Performance   | Page total field load above `max` | `max` (60) | on |
+| `PERF006` | Performance   | A table/matrix with no visual-level filter (Top N) | — | on |
+| `PERF009` | Performance   | More than `max` pages | `max` (20) | off |
+| `DATA001` | Data          | A visual with no fields bound (renders blank) | — | on |
+| `GOV001`  | Governance    | An uncertified / custom (third-party) visual | — | on |
+| `GOV002`  | Governance    | A visual whose type is in your block-list | `types` ([]) | off |
+| `GOV003`  | Governance    | A page still named "Page N" | — | on |
+| `GOV005`  | Governance    | A visual reading from a restricted table | `entities` ([]) | off |
+| `GOV006`  | Governance    | End-user data export is enabled | — | on |
+| `GOV008`  | Governance    | Theme not in your approved list | `allowed` ([]) | off |
+| `CONS001` | Consistency   | A hidden page that still carries visuals | — | off |
+| `CONS002` | Consistency   | An empty page (0 visuals) | — | on |
+| `CONS003` | Consistency   | Mixed canvas sizes across the report | — | on |
+| `CONS004` | Consistency   | Data visuals that overlap or sit off-canvas | `minOverlapPct` (25) | on |
+| `CONS005` | Consistency   | Slicers placed inconsistently across pages | `tolerancePx` (10) | on |
+| `CONS010` | Consistency   | A bookmark group nothing navigates to | — | on |
+| `A11Y001` | Accessibility | A data visual with no alt text | — | on |
+| `A11Y002` | Accessibility | A visual with no explicit tab order | — | off |
+| `A11Y003` | Accessibility | A decorative shape/image left in the tab order | — | on |
+| `A11Y005` | Accessibility | A title containing banned jargon/acronyms | `terms` ([]) | off |
+
+Rules marked "off" need configuration (a list/threshold) to do anything; enable
+them by adding their config entry. Rules `PERF004/005/006`, `A11Y003/005`,
+`GOV006` and `CONS005` implement official Microsoft Learn guidance (optimization
+and accessibility checklists).
+
+### 2. The gate
+
+`"failOn"` ∈ `critical` (default) · `warning` · `optimization` · `none`.
+
+### 3. Write your own rules — no code
+
+Declare rules as data. They run in CI exactly like a built-in:
+
+```jsonc
+{
+  "customRules": [
+    {
+      "id": "team/no-image-visuals",
+      "title": "No static images as visuals",
+      "category": "Governance",
+      "severity": "warning",
+      "scope": "visual",
+      "when": { "field": "type", "op": "eq", "value": "image" },
+      "message": "Visual '{{name}}' on page '{{page}}' is a static image."
+    },
+    {
+      "id": "team/dense-pages",
+      "category": "Performance",
+      "severity": "critical",
+      "scope": "page",
+      "when": [
+        { "field": "visualCount", "op": "gt", "value": 20 },
+        { "field": "hidden", "op": "eq", "value": false }
+      ],
+      "message": "Page '{{displayName}}' has {{visualCount}} visuals — split it."
+    }
+  ]
+}
+```
+
+- `when` is one predicate or an array (AND-ed).
+- Operators: `eq` `ne` `gt` `gte` `lt` `lte` `in` `exists` `missing` `matches` (regex).
+- `message` supports `{{field}}` placeholders from the table above.
+
+## Roadmap
+
+- ~~Vitest suite pinning fixture findings.~~ ✅ [`tests/report.test.ts`](tests/report.test.ts)
+- ~~A GitHub Action wrapper.~~ ✅ [`action/`](action)
+- Phase 2: extract a shared `core` engine so dataflow + pbip share one dispatcher.
+- Phase 3: TMDL semantic-model rules (reuses the M folding engine).

package/dist/index.js

@@ -0,0 +1,1102 @@
+#!/usr/bin/env node
+
+// pbip/src/main.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { resolve } from "path";
+
+// pbip/src/parser.ts
+import { readFileSync, readdirSync, existsSync, statSync } from "fs";
+import { join, basename } from "path";
+var CORE_VISUALS = /* @__PURE__ */ new Set([
+  "barChart",
+  "columnChart",
+  "clusteredBarChart",
+  "clusteredColumnChart",
+  "hundredPercentStackedBarChart",
+  "hundredPercentStackedColumnChart",
+  "lineChart",
+  "areaChart",
+  "stackedAreaChart",
+  "lineStackedColumnComboChart",
+  "lineClusteredColumnComboChart",
+  "pieChart",
+  "donutChart",
+  "treemap",
+  "map",
+  "filledMap",
+  "shapeMap",
+  "azureMap",
+  "scatterChart",
+  "waterfallChart",
+  "funnel",
+  "gauge",
+  "card",
+  "cardVisual",
+  "multiRowCard",
+  "kpi",
+  "slicer",
+  "advancedSlicerVisual",
+  "tableEx",
+  "pivotTable",
+  "matrix",
+  "ribbonChart",
+  "decompositionTreeVisual",
+  "keyDriversVisual",
+  "qnaVisual",
+  "scriptVisual",
+  "pythonVisual",
+  "esriVisual",
+  "image",
+  "textbox",
+  "shape",
+  "actionButton",
+  "basicShape",
+  "filterVisual",
+  "pageNavigator",
+  "bookmarkNavigator",
+  "aggregatedSparkline"
+]);
+var DECORATION = /* @__PURE__ */ new Set([
+  "actionButton",
+  "shape",
+  "basicShape",
+  "textbox",
+  "image",
+  "pageNavigator",
+  "bookmarkNavigator"
+]);
+function isDecoration(type) {
+  return DECORATION.has(type);
+}
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function deepFindStrings(obj, key, out = []) {
+  if (!obj || typeof obj !== "object") return out;
+  for (const [k, v] of Object.entries(obj)) {
+    if (k === key && typeof v === "string" && v.trim()) out.push(v.trim());
+    else if (v && typeof v === "object") deepFindStrings(v, key, out);
+  }
+  return out;
+}
+function resolveDefinitionDir(input) {
+  let root = input;
+  if (statSync(input).isFile()) {
+    root = join(input, "..");
+  }
+  if (existsSync(join(root, "definition", "report.json"))) {
+    return join(root, "definition");
+  }
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    if (entry.isDirectory() && entry.name.endsWith(".Report")) {
+      const def = join(root, entry.name, "definition");
+      if (existsSync(join(def, "report.json"))) return def;
+    }
+  }
+  return null;
+}
+function firstLiteral(obj) {
+  const vals = deepFindStrings(obj, "Value");
+  for (const raw of vals) {
+    const s = raw.replace(/^'(.*)'$/s, "$1").trim();
+    if (s) return s;
+  }
+  return "";
+}
+function extractBinding(v) {
+  const state = v?.query?.queryState ?? {};
+  let fieldCount = 0;
+  let measureCount = 0;
+  const entities = /* @__PURE__ */ new Set();
+  for (const role of Object.values(state)) {
+    for (const proj of role?.projections ?? []) {
+      const f = proj?.field ?? {};
+      const node = f.Measure ?? f.Column;
+      if (!node) continue;
+      fieldCount++;
+      if (f.Measure) measureCount++;
+      const entity = node.Expression?.SourceRef?.Entity;
+      if (typeof entity === "string") entities.add(entity);
+    }
+  }
+  return { fieldCount, measureCount, entities: [...entities] };
+}
+function parseVisual(visualDir, customVisualIds, refTokens) {
+  const raw = readJson(join(visualDir, "visual.json"));
+  if (!raw) return null;
+  const v = raw.visual;
+  if (!v || typeof v.visualType !== "string") return null;
+  const type = v.visualType;
+  const pos = raw.position ?? {};
+  for (const lit of deepFindStrings(v, "Value")) {
+    refTokens.add(lit.replace(/^'(.*)'$/s, "$1").trim());
+  }
+  const altCandidates = deepFindStrings(v, "altText");
+  const title = firstLiteral(v.visualContainerObjects?.title);
+  const { fieldCount, measureCount, entities } = extractBinding(v);
+  const fcFilters = raw.filterConfig?.filters;
+  const filterCount = Array.isArray(fcFilters) ? fcFilters.length : 0;
+  return {
+    name: raw.name ?? basename(visualDir),
+    type,
+    isCustomVisual: !CORE_VISUALS.has(type) || customVisualIds.has(type),
+    title,
+    hasTitle: title.length > 0,
+    altText: altCandidates[0] ?? "",
+    hasAltText: altCandidates.length > 0,
+    hidden: raw.isHidden === true,
+    width: Number(pos.width ?? 0),
+    height: Number(pos.height ?? 0),
+    x: Number(pos.x ?? 0),
+    y: Number(pos.y ?? 0),
+    tabOrder: typeof pos.tabOrder === "number" ? pos.tabOrder : -1,
+    fieldCount,
+    measureCount,
+    entities,
+    filterCount
+  };
+}
+function parsePage(pageDir, customVisualIds, refTokens) {
+  const raw = readJson(join(pageDir, "page.json")) ?? {};
+  const visuals = [];
+  const visualsDir = join(pageDir, "visuals");
+  if (existsSync(visualsDir)) {
+    for (const entry of readdirSync(visualsDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const vis = parseVisual(join(visualsDir, entry.name), customVisualIds, refTokens);
+      if (vis) visuals.push(vis);
+    }
+  }
+  return {
+    name: raw.name ?? basename(pageDir),
+    displayName: raw.displayName ?? raw.name ?? basename(pageDir),
+    hidden: raw.visibility === "HiddenInViewMode" || raw.visibility === 1,
+    type: typeof raw.type === "string" ? raw.type : "",
+    width: Number(raw.width ?? 0),
+    height: Number(raw.height ?? 0),
+    visuals,
+    visualCount: visuals.length
+  };
+}
+function parseReport(input) {
+  const def = resolveDefinitionDir(input);
+  if (!def) {
+    throw new Error(`No PBIR report found at "${input}" (expected a definition/report.json).`);
+  }
+  const report = readJson(join(def, "report.json")) ?? {};
+  const customVisualIds = new Set(
+    report.publicCustomVisuals ?? []
+  );
+  const theme = report.themeCollection?.customTheme?.name ?? report.themeCollection?.baseTheme?.name ?? "";
+  const exportDataMode = report.settings?.exportDataMode ?? "";
+  const refTokens = /* @__PURE__ */ new Set();
+  const pages = [];
+  const pagesDir = join(def, "pages");
+  if (existsSync(pagesDir)) {
+    for (const entry of readdirSync(pagesDir, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        pages.push(parsePage(join(pagesDir, entry.name), customVisualIds, refTokens));
+      }
+    }
+  }
+  const { bookmarkCount, orphanBookmarkGroups } = analyzeBookmarks(def, refTokens);
+  const reportFolder = basename(join(def, "..")).replace(/\.Report$/, "");
+  return {
+    name: reportFolder || "report",
+    theme,
+    exportDataMode,
+    pages,
+    pageCount: pages.length,
+    visualCount: pages.reduce((n, p) => n + p.visualCount, 0),
+    bookmarkCount,
+    orphanBookmarkGroups
+  };
+}
+function analyzeBookmarks(def, refTokens) {
+  const meta = readJson(join(def, "bookmarks", "bookmarks.json"));
+  const items = meta?.items ?? [];
+  let bookmarkCount = 0;
+  const orphans = [];
+  for (const group of items) {
+    const children = Array.isArray(group.children) ? group.children : [];
+    bookmarkCount += children.length || 1;
+    const reachable = refTokens.has(group.name) || children.some((c) => refTokens.has(c));
+    if (!reachable) orphans.push(group.displayName ?? group.name);
+  }
+  return { bookmarkCount, orphanBookmarkGroups: orphans };
+}
+
+// pbip/src/config.ts
+var DEFAULT_CONFIG = {
+  failOn: "critical",
+  rules: {},
+  customRules: []
+};
+function fieldsOf(node, scope) {
+  switch (scope) {
+    case "report": {
+      const m = node;
+      return {
+        name: m.name,
+        theme: m.theme,
+        exportDataMode: m.exportDataMode,
+        pageCount: m.pageCount,
+        visualCount: m.visualCount,
+        bookmarkCount: m.bookmarkCount
+      };
+    }
+    case "page": {
+      const p = node;
+      return {
+        name: p.name,
+        displayName: p.displayName,
+        hidden: p.hidden,
+        type: p.type,
+        width: p.width,
+        height: p.height,
+        visualCount: p.visualCount
+      };
+    }
+    case "visual": {
+      const { page, visual } = node;
+      return {
+        page: page.displayName,
+        name: visual.name,
+        type: visual.type,
+        isCustomVisual: visual.isCustomVisual,
+        title: visual.title,
+        hasTitle: visual.hasTitle,
+        altText: visual.altText,
+        hasAltText: visual.hasAltText,
+        hidden: visual.hidden,
+        width: visual.width,
+        height: visual.height,
+        x: visual.x,
+        y: visual.y,
+        tabOrder: visual.tabOrder,
+        fieldCount: visual.fieldCount,
+        measureCount: visual.measureCount,
+        filterCount: visual.filterCount
+      };
+    }
+  }
+}
+function testPredicate(fields, p) {
+  const actual = fields[p.field];
+  switch (p.op) {
+    case "exists":
+      return actual !== void 0 && actual !== "" && actual !== false;
+    case "missing":
+      return actual === void 0 || actual === "" || actual === false;
+    case "eq":
+      return actual === p.value;
+    case "ne":
+      return actual !== p.value;
+    case "gt":
+      return Number(actual) > Number(p.value);
+    case "gte":
+      return Number(actual) >= Number(p.value);
+    case "lt":
+      return Number(actual) < Number(p.value);
+    case "lte":
+      return Number(actual) <= Number(p.value);
+    case "in":
+      return Array.isArray(p.value) && p.value.includes(actual);
+    case "matches":
+      return typeof actual === "string" && new RegExp(String(p.value)).test(actual);
+    default:
+      return false;
+  }
+}
+function evalWhen(fields, when) {
+  const preds = Array.isArray(when) ? when : [when];
+  return preds.every((p) => testPredicate(fields, p));
+}
+function renderMessage(template, fields) {
+  return template.replace(
+    /\{\{\s*(\w+)\s*\}\}/g,
+    (_, key) => key in fields ? String(fields[key]) : `{{${key}}}`
+  );
+}
+function normalizeConfig(raw) {
+  const obj = raw && typeof raw === "object" ? raw : {};
+  return {
+    failOn: obj.failOn ?? DEFAULT_CONFIG.failOn,
+    rules: obj.rules ?? {},
+    customRules: Array.isArray(obj.customRules) ? obj.customRules : []
+  };
+}
+function normalizeSeverity(s, fallback) {
+  switch ((s ?? "").toLowerCase()) {
+    case "critical":
+      return "Critical";
+    case "warning":
+      return "Warning";
+    case "optimization":
+      return "Optimization";
+    default:
+      return fallback;
+  }
+}
+var SEVERITY_RANK = {
+  critical: 3,
+  warning: 2,
+  optimization: 1,
+  none: 0
+};
+function meetsThreshold(severity, failOn) {
+  const gate = SEVERITY_RANK[failOn] ?? 3;
+  if (gate === 0) return false;
+  return (SEVERITY_RANK[severity.toLowerCase()] ?? 0) >= gate;
+}
+
+// pbip/src/customRules.ts
+function compile(spec) {
+  return {
+    id: spec.id,
+    title: spec.title ?? spec.id,
+    category: spec.category,
+    scope: spec.scope,
+    defaultSeverity: normalizeSeverity(spec.severity, "Warning"),
+    custom: true,
+    rationale: spec.rationale ?? "User-defined rule.",
+    evaluate(node) {
+      const fields = fieldsOf(node, spec.scope);
+      if (!evalWhen(fields, spec.when)) return [];
+      const hit = { message: renderMessage(spec.message, fields) };
+      if (spec.recommendation) hit.recommendation = spec.recommendation;
+      if (spec.scope === "visual") {
+        const { page, visual } = node;
+        hit.page = page.displayName;
+        hit.visual = visual.name;
+      } else if (spec.scope === "page") {
+        hit.page = node.displayName;
+      }
+      return [hit];
+    }
+  };
+}
+function compileCustomRules(specs) {
+  const out = [];
+  for (const spec of specs) {
+    if (!spec.id || !spec.when || !spec.message || !spec.scope) {
+      console.error(
+        `Skipping custom rule (needs id, scope, when, message): ${JSON.stringify(spec.id ?? spec)}`
+      );
+      continue;
+    }
+    out.push(compile(spec));
+  }
+  return out;
+}
+
+// pbip/src/rules.ts
+var isUtilityPage = (p) => p.type === "Tooltip" || p.type === "Drillthrough";
+var dataVisuals = (p) => p.visuals.filter((v) => !isDecoration(v.type));
+function num(ctx, key, def) {
+  const v = ctx.override?.[key];
+  return typeof v === "number" ? v : def;
+}
+function list(ctx, key, def = []) {
+  const v = ctx.override?.[key];
+  return Array.isArray(v) ? v.map(String) : def;
+}
+var SLICER_TYPES = /* @__PURE__ */ new Set(["slicer", "advancedSlicerVisual", "filterVisual"]);
+var TABLE_TYPES = /* @__PURE__ */ new Set(["tableEx", "pivotTable", "matrix"]);
+var DECORATIVE_ONLY = /* @__PURE__ */ new Set(["shape", "basicShape", "image"]);
+var PERF001_VisualsPerPage = {
+  id: "PERF001",
+  title: "Too many visuals on a page",
+  category: "Performance",
+  scope: "page",
+  defaultSeverity: "Warning",
+  rationale: "Each data visual is a separate query against the model. Pages with many of them slow first render and multiply query load. Decoration (buttons/shapes/text) is excluded.",
+  evaluate(page, ctx) {
+    const max = num(ctx, "max", 15);
+    const count = dataVisuals(page).length;
+    if (count <= max) return [];
+    return [
+      {
+        message: `Page "${page.displayName}" has ${count} data visuals (max ${max}).`,
+        recommendation: "Split the page, or replace several cards with a single multi-row visual.",
+        page: page.displayName
+      }
+    ];
+  }
+};
+var PERF002_VisualsPerReport = {
+  id: "PERF002",
+  title: "Report has too many visuals overall",
+  category: "Performance",
+  scope: "report",
+  defaultSeverity: "Optimization",
+  rationale: "A very large report inflates publish size and open time. A high total often signals pages that should be split into separate reports.",
+  evaluate(model, ctx) {
+    const max = num(ctx, "max", 60);
+    if (model.visualCount <= max) return [];
+    return [
+      {
+        message: `Report has ${model.visualCount} visuals across ${model.pageCount} pages (max ${max}).`,
+        recommendation: "Consider splitting into focused reports or trimming redundant visuals."
+      }
+    ];
+  }
+};
+var PERF003_SlicersPerPage = {
+  id: "PERF003",
+  title: "Too many slicers on a page",
+  category: "Performance",
+  scope: "page",
+  defaultSeverity: "Warning",
+  rationale: "Every slicer issues its own query and re-queries on each interaction. A wall of slicers is a common refresh/interaction bottleneck.",
+  evaluate(page, ctx) {
+    const max = num(ctx, "max", 4);
+    const slicers = page.visuals.filter((v) => SLICER_TYPES.has(v.type));
+    if (slicers.length <= max) return [];
+    return [
+      {
+        message: `Page "${page.displayName}" has ${slicers.length} slicers (max ${max}).`,
+        recommendation: "Consolidate filters into the filter pane or a single multi-field slicer.",
+        page: page.displayName
+      }
+    ];
+  }
+};
+var PERF009_PageCount = {
+  id: "PERF009",
+  title: "Report has too many pages",
+  category: "Performance",
+  scope: "report",
+  defaultSeverity: "Optimization",
+  defaultEnabled: false,
+  // varies a lot by team; opt-in
+  rationale: "Beyond a point, page count hurts navigation and load. Often a sign a report is doing several jobs.",
+  evaluate(model, ctx) {
+    const max = num(ctx, "max", 20);
+    if (model.pageCount <= max) return [];
+    return [
+      {
+        message: `Report has ${model.pageCount} pages (max ${max}).`,
+        recommendation: "Split into multiple reports or use a navigation/drill-through pattern."
+      }
+    ];
+  }
+};
+var GOV001_UncertifiedCustomVisual = {
+  id: "GOV001",
+  title: "Uncertified custom visual in use",
+  category: "Governance",
+  scope: "visual",
+  defaultSeverity: "Warning",
+  rationale: "Custom visuals run third-party code and can exfiltrate data unless certified. Many tenants forbid them \u2014 catch them before they ship.",
+  evaluate({ page, visual }) {
+    if (!visual.isCustomVisual) return [];
+    return [
+      {
+        message: `Visual "${visual.name}" on "${page.displayName}" is a custom visual ("${visual.type}").`,
+        recommendation: "Replace with a core visual, or confirm the custom visual is org-certified.",
+        page: page.displayName,
+        visual: visual.name
+      }
+    ];
+  }
+};
+var GOV002_BlockedVisualType = {
+  id: "GOV002",
+  title: "Blocked visual type in use",
+  category: "Governance",
+  scope: "visual",
+  defaultSeverity: "Warning",
+  defaultEnabled: false,
+  // needs a configured block-list to do anything
+  rationale: "Lets a team ban specific visual types outright (e.g. static images, Python/R visuals) via config.",
+  evaluate({ page, visual }, ctx) {
+    const blocked = list(ctx, "types");
+    if (!blocked.includes(visual.type)) return [];
+    return [
+      {
+        message: `Visual "${visual.name}" on "${page.displayName}" uses blocked type "${visual.type}".`,
+        recommendation: "Use an approved visual type per the team standard.",
+        page: page.displayName,
+        visual: visual.name
+      }
+    ];
+  }
+};
+var GOV003_DefaultPageName = {
+  id: "GOV003",
+  title: "Page still has a default name",
+  category: "Governance",
+  scope: "page",
+  defaultSeverity: "Optimization",
+  rationale: 'Pages left as "Page 1" signal unfinished work and read poorly in navigation and bookmarks.',
+  evaluate(page) {
+    if (!/^Page\s*\d+$/i.test(page.displayName.trim())) return [];
+    return [
+      {
+        message: `Page is still named "${page.displayName}".`,
+        recommendation: "Give every page a meaningful, user-facing name.",
+        page: page.displayName
+      }
+    ];
+  }
+};
+var GOV008_ThemeNotApproved = {
+  id: "GOV008",
+  title: "Report theme is not on the approved list",
+  category: "Governance",
+  scope: "report",
+  defaultSeverity: "Warning",
+  defaultEnabled: false,
+  // needs an approved-theme allowlist in config
+  rationale: "Enforces corporate theming: flags reports whose theme is not one your org sanctioned.",
+  evaluate(model, ctx) {
+    const allowed = list(ctx, "allowed");
+    if (allowed.length === 0) return [];
+    if (model.theme && allowed.includes(model.theme)) return [];
+    return [
+      {
+        message: `Report theme "${model.theme || "(none)"}" is not in the approved list [${allowed.join(", ")}].`,
+        recommendation: "Apply an approved corporate theme."
+      }
+    ];
+  }
+};
+var CONS001_HiddenPageWithVisuals = {
+  id: "CONS001",
+  title: "Hidden page still loads visuals",
+  category: "Consistency",
+  scope: "page",
+  defaultSeverity: "Optimization",
+  defaultEnabled: false,
+  // stylistic — off by default
+  rationale: "A hidden page that is never a drill-through target still costs refresh/model load. Often a dev leftover.",
+  evaluate(page) {
+    if (!page.hidden || page.visualCount === 0) return [];
+    return [
+      {
+        message: `Hidden page "${page.displayName}" still contains ${page.visualCount} visuals.`,
+        recommendation: "Delete the page if it is dead, or document it as a drill-through target.",
+        page: page.displayName
+      }
+    ];
+  }
+};
+var CONS002_EmptyPage = {
+  id: "CONS002",
+  title: "Page has no visuals",
+  category: "Consistency",
+  scope: "page",
+  defaultSeverity: "Optimization",
+  rationale: "An empty page is almost always a leftover; it confuses users in navigation.",
+  evaluate(page) {
+    if (page.visualCount > 0 || isUtilityPage(page)) return [];
+    return [
+      {
+        message: `Page "${page.displayName}" is empty (0 visuals).`,
+        recommendation: "Remove the page, or add its intended content.",
+        page: page.displayName
+      }
+    ];
+  }
+};
+var CONS003_InconsistentPageSize = {
+  id: "CONS003",
+  title: "Pages use inconsistent canvas sizes",
+  category: "Consistency",
+  scope: "report",
+  defaultSeverity: "Optimization",
+  rationale: "Mixed canvas sizes make a report feel disjointed and break shared backgrounds/layouts. Usually unintentional.",
+  evaluate(model) {
+    const sizes = new Set(
+      model.pages.filter((p) => p.width > 0 && p.height > 0 && !isUtilityPage(p)).map((p) => `${p.width}x${p.height}`)
+    );
+    if (sizes.size <= 1) return [];
+    return [
+      {
+        message: `Report mixes ${sizes.size} canvas sizes: ${[...sizes].join(", ")}.`,
+        recommendation: "Standardize on one canvas size (e.g. 1280x720) unless a page is a tooltip/drill page."
+      }
+    ];
+  }
+};
+var A11Y001_MissingAltText = {
+  id: "A11Y001",
+  title: "Visual is missing alt text",
+  category: "Accessibility",
+  scope: "visual",
+  defaultSeverity: "Optimization",
+  rationale: "Screen readers announce alt text. Charts without it are invisible to users relying on assistive tech.",
+  evaluate({ page, visual }) {
+    if (visual.hidden || isUtilityPage(page)) return [];
+    if (isDecoration(visual.type)) return [];
+    if (visual.hasAltText) return [];
+    return [
+      {
+        message: `Visual "${visual.name}" (${visual.type}) on "${page.displayName}" has no alt text.`,
+        recommendation: "Set alt text in the visual's General > Alt text formatting pane.",
+        page: page.displayName,
+        visual: visual.name
+      }
+    ];
+  }
+};
+var GOV006_ExportDataEnabled = {
+  id: "GOV006",
+  title: "End-user data export is enabled",
+  category: "Governance",
+  scope: "report",
+  defaultSeverity: "Optimization",
+  rationale: "Reports that allow exporting summarized or underlying data can leak governed data outside Power BI. Many orgs restrict this.",
+  evaluate(model) {
+    const mode = model.exportDataMode;
+    if (!mode || mode === "None") return [];
+    return [
+      {
+        message: `Report allows data export (exportDataMode = "${mode}").`,
+        recommendation: 'Set export to "None" unless the audience explicitly needs to export data.'
+      }
+    ];
+  }
+};
+var A11Y002_MissingTabOrder = {
+  id: "A11Y002",
+  title: "Visual has no explicit tab order",
+  category: "Accessibility",
+  scope: "visual",
+  defaultSeverity: "Optimization",
+  defaultEnabled: false,
+  // can be noisy; opt-in
+  rationale: "Keyboard users navigate by tab order. Visuals left at the default order often read in a confusing sequence for screen-reader users.",
+  evaluate({ page, visual }) {
+    if (visual.hidden || isUtilityPage(page) || isDecoration(visual.type)) return [];
+    if (visual.tabOrder >= 0) return [];
+    return [
+      {
+        message: `Visual "${visual.name}" (${visual.type}) on "${page.displayName}" has no explicit tab order.`,
+        recommendation: "Set tab order in the Selection pane to control keyboard navigation.",
+        page: page.displayName,
+        visual: visual.name
+      }
+    ];
+  }
+};
+var DATA001_EmptyVisual = {
+  id: "DATA001",
+  title: "Visual has no fields bound",
+  category: "Data",
+  scope: "visual",
+  defaultSeverity: "Warning",
+  rationale: "A data visual with zero fields renders blank or broken in the report \u2014 a defect that ships silently. Decoration (buttons/shapes/navigators) is excluded.",
+  evaluate({ page, visual }) {
+    if (isDecoration(visual.type)) return [];
+    if (visual.fieldCount > 0) return [];
+    return [
+      {
+        message: `Visual "${visual.name}" (${visual.type}) on "${page.displayName}" has no fields bound \u2014 it will render blank.`,
+        recommendation: "Bind a field/measure, or delete the visual.",
+        page: page.displayName,
+        visual: visual.name
+      }
+    ];
+  }
+};
+var PERF004_VisualTooManyFields = {
+  id: "PERF004",
+  title: "Visual binds too many fields",
+  category: "Performance",
+  scope: "visual",
+  defaultSeverity: "Warning",
+  rationale: "Each bound field widens the query the visual sends to the model. Tables/charts with many fields are slow to render and hard to read.",
+  evaluate({ page, visual }, ctx) {
+    const max = num(ctx, "max", 10);
+    if (isDecoration(visual.type) || visual.fieldCount <= max) return [];
+    return [
+      {
+        message: `Visual "${visual.name}" (${visual.type}) on "${page.displayName}" binds ${visual.fieldCount} fields (max ${max}).`,
+        recommendation: "Trim columns/series, or split into focused visuals.",
+        page: page.displayName,
+        visual: visual.name
+      }
+    ];
+  }
+};
+var PERF005_PageQueryLoad = {
+  id: "PERF005",
+  title: "Page issues a heavy total query load",
+  category: "Performance",
+  scope: "page",
+  defaultSeverity: "Optimization",
+  rationale: "Sum of fields across all data visuals approximates how much the page asks of the model on load. A very high total is a refresh/interactivity bottleneck.",
+  evaluate(page, ctx) {
+    const max = num(ctx, "max", 60);
+    const load = dataVisuals(page).reduce((n, v) => n + v.fieldCount, 0);
+    if (load <= max) return [];
+    return [
+      {
+        message: `Page "${page.displayName}" binds ${load} fields across its data visuals (max ${max}).`,
+        recommendation: "Reduce visuals/fields, or move detail to a drill-through page.",
+        page: page.displayName
+      }
+    ];
+  }
+};
+var GOV005_RestrictedEntity = {
+  id: "GOV005",
+  title: "Visual reads from a restricted table",
+  category: "Governance",
+  scope: "visual",
+  defaultSeverity: "Critical",
+  defaultEnabled: false,
+  // needs a configured list of restricted entities
+  rationale: "Lets a team forbid specific source tables (e.g. salary, PII) from appearing in reports. Flags any visual bound to one.",
+  evaluate({ page, visual }, ctx) {
+    const restricted = list(ctx, "entities");
+    const hit = visual.entities.filter((e) => restricted.includes(e));
+    if (hit.length === 0) return [];
+    return [
+      {
+        message: `Visual "${visual.name}" on "${page.displayName}" reads from restricted table(s): ${hit.join(", ")}.`,
+        recommendation: "Remove the field, or get the table cleared for reporting.",
+        page: page.displayName,
+        visual: visual.name
+      }
+    ];
+  }
+};
+var CONS004_OverlappingVisuals = {
+  id: "CONS004",
+  title: "Data visuals overlap or sit off-canvas",
+  category: "Consistency",
+  scope: "page",
+  defaultSeverity: "Warning",
+  rationale: "Overlapping data visuals hide each other (data the user never sees); off-canvas visuals are invisible yet still query the model. Both are real defects, not cosmetics.",
+  evaluate(page, ctx) {
+    if (isUtilityPage(page)) return [];
+    const minOverlap = num(ctx, "minOverlapPct", 25) / 100;
+    const vs = dataVisuals(page).filter((v) => !v.hidden && v.width > 0 && v.height > 0);
+    let overlaps = 0;
+    for (let i = 0; i < vs.length; i++) {
+      for (let j = i + 1; j < vs.length; j++) {
+        const a = vs[i], b = vs[j];
+        const ix = Math.max(0, Math.min(a.x + a.width, b.x + b.width) - Math.max(a.x, b.x));
+        const iy = Math.max(0, Math.min(a.y + a.height, b.y + b.height) - Math.max(a.y, b.y));
+        const inter = ix * iy;
+        const smaller = Math.min(a.width * a.height, b.width * b.height);
+        if (smaller > 0 && inter / smaller >= minOverlap) overlaps++;
+      }
+    }
+    const offCanvas = page.width > 0 && page.height > 0 ? vs.filter((v) => v.x < -1 || v.y < -1 || v.x + v.width > page.width + 1 || v.y + v.height > page.height + 1).length : 0;
+    if (overlaps === 0 && offCanvas === 0) return [];
+    const parts = [
+      overlaps ? `${overlaps} overlapping pair(s)` : "",
+      offCanvas ? `${offCanvas} off-canvas` : ""
+    ].filter(Boolean);
+    return [
+      {
+        message: `Page "${page.displayName}" has ${parts.join(" and ")} among its data visuals.`,
+        recommendation: "Use the Selection pane to align visuals and bring off-canvas ones back into view.",
+        page: page.displayName
+      }
+    ];
+  }
+};
+var CONS010_OrphanBookmark = {
+  id: "CONS010",
+  title: "Orphaned bookmark group",
+  category: "Consistency",
+  scope: "report",
+  defaultSeverity: "Optimization",
+  rationale: "Bookmarks no navigator or button points to are dead weight: they bloat the file, confuse maintainers, and may hold stale filter state. Common after redesigns.",
+  evaluate(model) {
+    if (model.orphanBookmarkGroups.length === 0) return [];
+    return model.orphanBookmarkGroups.map((name) => ({
+      message: `Bookmark group "${name}" is not referenced by any navigator or button.`,
+      recommendation: "Delete it, or wire a navigator/button to it."
+    }));
+  }
+};
+var PERF006_UnfilteredTable = {
+  id: "PERF006",
+  title: "Table/matrix has no visual-level filter",
+  category: "Performance",
+  scope: "visual",
+  defaultSeverity: "Optimization",
+  rationale: "Microsoft: tables are expensive and an unfiltered table loads every row into memory. Apply a Top N (or other) filter to cap rows.",
+  evaluate({ page, visual }) {
+    if (!TABLE_TYPES.has(visual.type) || visual.filterCount > 0) return [];
+    return [
+      {
+        message: `Table "${visual.name}" on "${page.displayName}" has no visual-level filter (risk of loading all rows).`,
+        recommendation: "Add a Top N filter to cap the rows the table materializes.",
+        page: page.displayName,
+        visual: visual.name
+      }
+    ];
+  }
+};
+var A11Y003_DecorativeInTabOrder = {
+  id: "A11Y003",
+  title: "Decorative shape/image is in the tab order",
+  category: "Accessibility",
+  scope: "visual",
+  defaultSeverity: "Optimization",
+  rationale: "Microsoft: decorative shapes and images should be hidden from the tab order so screen readers don't announce them. Interactive items (buttons) are exempt.",
+  evaluate({ page, visual }) {
+    if (isUtilityPage(page) || !DECORATIVE_ONLY.has(visual.type)) return [];
+    if (visual.tabOrder < 0) return [];
+    return [
+      {
+        message: `Decorative ${visual.type} "${visual.name}" on "${page.displayName}" is still in the tab order.`,
+        recommendation: "Hide it from tab order in the Selection pane so screen readers skip it.",
+        page: page.displayName,
+        visual: visual.name
+      }
+    ];
+  }
+};
+var A11Y005_JargonInTitle = {
+  id: "A11Y005",
+  title: "Visual title contains banned jargon/acronym",
+  category: "Accessibility",
+  scope: "visual",
+  defaultSeverity: "Optimization",
+  defaultEnabled: false,
+  // needs a configured term list
+  rationale: "Microsoft: avoid acronyms/jargon in titles \u2014 external or new users may not understand them. Supply your org's banned terms.",
+  evaluate({ page, visual }, ctx) {
+    if (!visual.hasTitle) return [];
+    const banned = list(ctx, "terms");
+    const hit = banned.find((t) => new RegExp(`\\b${t}\\b`, "i").test(visual.title));
+    if (!hit) return [];
+    return [
+      {
+        message: `Title "${visual.title}" on "${page.displayName}" uses banned term "${hit}".`,
+        recommendation: "Spell out the term or use plain language.",
+        page: page.displayName,
+        visual: visual.name
+      }
+    ];
+  }
+};
+var CONS005_SlicerPlacement = {
+  id: "CONS005",
+  title: "Slicers are placed inconsistently across pages",
+  category: "Consistency",
+  scope: "report",
+  defaultSeverity: "Optimization",
+  rationale: "Microsoft: keep slicers in the same spatial position on every page. Jumping slicer positions disorient users and keyboard navigation.",
+  evaluate(model, ctx) {
+    const tol = num(ctx, "tolerancePx", 10);
+    const origins = [];
+    for (const p of model.pages) {
+      if (isUtilityPage(p)) continue;
+      const slicers = p.visuals.filter((v) => SLICER_TYPES.has(v.type) && !v.hidden);
+      if (slicers.length === 0) continue;
+      const ox = Math.round(Math.min(...slicers.map((s) => s.x)) / tol) * tol;
+      const oy = Math.round(Math.min(...slicers.map((s) => s.y)) / tol) * tol;
+      origins.push({ page: p.displayName, key: `${ox},${oy}` });
+    }
+    if (origins.length < 2) return [];
+    const counts = /* @__PURE__ */ new Map();
+    for (const o of origins) counts.set(o.key, (counts.get(o.key) ?? 0) + 1);
+    const modal = [...counts.entries()].sort((a, b) => b[1] - a[1])[0][0];
+    const deviating = origins.filter((o) => o.key !== modal);
+    if (deviating.length === 0) return [];
+    return deviating.map((o) => ({
+      message: `Slicers on "${o.page}" sit at a different position (${o.key}) than the rest of the report (${modal}).`,
+      recommendation: "Align the slicer block to the same location used on other pages.",
+      page: o.page
+    }));
+  }
+};
+var BUILTIN_RULES = [
+  // Performance
+  PERF001_VisualsPerPage,
+  PERF002_VisualsPerReport,
+  PERF003_SlicersPerPage,
+  PERF004_VisualTooManyFields,
+  PERF005_PageQueryLoad,
+  PERF006_UnfilteredTable,
+  PERF009_PageCount,
+  // Data integrity
+  DATA001_EmptyVisual,
+  // Governance
+  GOV001_UncertifiedCustomVisual,
+  GOV002_BlockedVisualType,
+  GOV003_DefaultPageName,
+  GOV005_RestrictedEntity,
+  GOV006_ExportDataEnabled,
+  GOV008_ThemeNotApproved,
+  // Consistency
+  CONS001_HiddenPageWithVisuals,
+  CONS002_EmptyPage,
+  CONS003_InconsistentPageSize,
+  CONS004_OverlappingVisuals,
+  CONS005_SlicerPlacement,
+  CONS010_OrphanBookmark,
+  // Accessibility
+  A11Y001_MissingAltText,
+  A11Y002_MissingTabOrder,
+  A11Y003_DecorativeInTabOrder,
+  A11Y005_JargonInTitle
+];
+
+// pbip/src/engine.ts
+function nodesForScope(scope, model) {
+  switch (scope) {
+    case "report":
+      return [model];
+    case "page":
+      return model.pages;
+    case "visual": {
+      const out = [];
+      for (const page of model.pages) {
+        for (const visual of page.visuals) out.push({ page, visual });
+      }
+      return out;
+    }
+  }
+}
+function resolveOverride(cfg2, rule) {
+  const raw = cfg2.rules[rule.id];
+  if (raw === "off") return { enabled: false, severity: rule.defaultSeverity, bag: {} };
+  if (raw && typeof raw === "object") {
+    return {
+      enabled: raw.enabled ?? true,
+      severity: normalizeSeverity(raw.severity, rule.defaultSeverity),
+      bag: raw
+    };
+  }
+  return {
+    enabled: rule.defaultEnabled !== false,
+    severity: rule.defaultSeverity,
+    bag: {}
+  };
+}
+function runReportAudit(model, rawConfig2 = {}) {
+  const cfg2 = normalizeConfig(rawConfig2);
+  const rules = [...BUILTIN_RULES, ...compileCustomRules(cfg2.customRules)];
+  const findings = [];
+  for (const rule of rules) {
+    const { enabled, severity, bag } = resolveOverride(cfg2, rule);
+    if (!enabled) continue;
+    const ctx = { model, override: bag };
+    for (const node of nodesForScope(rule.scope, model)) {
+      let hits;
+      try {
+        hits = rule.evaluate(node, ctx);
+      } catch (err) {
+        console.error(`Rule "${rule.id}" threw and was skipped: ${err.message}`);
+        continue;
+      }
+      for (const hit of hits) {
+        findings.push({
+          ...hit,
+          ruleId: rule.id,
+          ruleTitle: rule.title,
+          category: rule.category,
+          severity,
+          custom: rule.custom === true
+        });
+      }
+    }
+  }
+  const blocking = findings.filter((f) => meetsThreshold(f.severity, cfg2.failOn));
+  const countsBySeverity = {
+    Critical: findings.filter((f) => f.severity === "Critical").length,
+    Warning: findings.filter((f) => f.severity === "Warning").length,
+    Optimization: findings.filter((f) => f.severity === "Optimization").length
+  };
+  return { model, findings, blocking, countsBySeverity, passed: blocking.length === 0 };
+}
+
+// pbip/src/main.ts
+var args = process.argv.slice(2);
+var flag = (name, def = "") => {
+  const hit = args.find((a) => a.startsWith(`--${name}=`));
+  return hit ? hit.slice(name.length + 3) : def;
+};
+var sub = args[0];
+if (!sub || sub === "--help" || sub === "-h") {
+  console.log(`
+  pbip-killer \u2014 audit Power BI PBIP/PBIR reports
+
+  Usage:
+    pbip-killer audit <path> [options]
+
+  Options:
+    --config=<file>   Config file (default: pbipkiller.config.json if present).
+    --fail-on=<lvl>   Override the gate: critical | warning | optimization | none.
+    --format=<fmt>    human (default) | json | md.
+    --help            Show this help.
+`);
+  process.exit(0);
+}
+if (sub !== "audit") {
+  console.error(`Unknown command: ${sub}. Run with --help.`);
+  process.exit(2);
+}
+var target = args.slice(1).find((a) => !a.startsWith("--"));
+if (!target) {
+  console.error("No path specified. Run with --help.");
+  process.exit(2);
+}
+var configPath = flag("config") || "pbipkiller.config.json";
+var rawConfig = {};
+if (existsSync2(resolve(configPath))) {
+  try {
+    rawConfig = JSON.parse(readFileSync2(resolve(configPath), "utf8"));
+  } catch (err) {
+    console.error(`Failed to read config ${configPath}: ${err.message}`);
+    process.exit(2);
+  }
+}
+var cfg = normalizeConfig(rawConfig);
+var failOnOverride = flag("fail-on");
+if (failOnOverride) cfg.failOn = failOnOverride;
+var format = flag("format", "human");
+var audit;
+try {
+  const model = parseReport(resolve(target));
+  audit = runReportAudit(model, cfg);
+} catch (err) {
+  console.error(err.message);
+  process.exit(2);
+}
+if (format === "json") {
+  console.log(JSON.stringify(audit, null, 2));
+} else if (format === "md") {
+  const icon = audit.passed ? "\u2705" : "\u274C";
+  console.log(`## ${icon} ${audit.model.name}
+`);
+  console.log(`| Pages | Visuals | Findings | Blocking |`);
+  console.log(`|-------|---------|----------|----------|`);
+  console.log(`| ${audit.model.pageCount} | ${audit.model.visualCount} | ${audit.findings.length} | ${audit.blocking.length} |`);
+  if (audit.findings.length) {
+    console.log(`
+| Rule | Severity | Where | Message |`);
+    console.log(`|------|----------|-------|---------|`);
+    for (const f of audit.findings) {
+      const where = [f.page, f.visual].filter(Boolean).join(" \u203A ") || "-";
+      console.log(`| ${f.ruleId}${f.custom ? " (custom)" : ""} | ${f.severity} | ${where} | ${f.message.replace(/\|/g, "\\|")} |`);
+    }
+  }
+} else {
+  console.log(`
+  ${audit.model.name} \u2014 ${audit.model.pageCount} pages, ${audit.model.visualCount} visuals`);
+  console.log(`  ${"\u2500".repeat(56)}`);
+  for (const f of audit.findings) {
+    const where = [f.page, f.visual].filter(Boolean).join(" \u203A ");
+    console.log(`  [${f.severity[0]}] ${f.ruleId}${f.custom ? "*" : ""}  ${f.message}${where ? `  (${where})` : ""}`);
+  }
+  const verdict = audit.passed ? "PASS" : "FAIL";
+  console.log(`  ${"\u2500".repeat(56)}`);
+  console.log(`  ${verdict} \u2014 ${audit.findings.length} findings, ${audit.blocking.length} blocking (fail-on=${cfg.failOn})
+`);
+}
+process.exit(audit.passed ? 0 : 1);

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "pbip-killer",
+  "version": "0.5.0",
+  "description": "Audit Power BI PBIP / PBIR reports from the command line or CI/CD, with fully customizable rules.",
+  "author": "Jesús Veiga",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "pbip-killer": "dist/index.js"
+  },
+  "files": ["dist"],
+  "scripts": {
+    "prepublishOnly": "cd .. && npm run build:pbip"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "power-bi",
+    "pbip",
+    "pbir",
+    "report",
+    "audit",
+    "governance",
+    "quality-gate",
+    "ci-cd",
+    "fabric",
+    "accessibility"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Jesusveiga/DataflowKiller.git",
+    "directory": "pbip"
+  },
+  "homepage": "https://dataflowkiller.com"
+}