@wrongstack/plugins 0.281.3 → 0.282.1

package/dist/knowledge-graph.js

@@ -0,0 +1,325 @@
+import { readFileSync, mkdirSync, writeFileSync } from 'fs';
+import { resolve, isAbsolute, relative, dirname } from 'path';
+
+// src/knowledge-graph/index.ts
+var API_VERSION = "^0.1.10";
+var state = {
+  facts: [],
+  nextId: 1,
+  adds: 0,
+  removals: 0,
+  queries: 0,
+  persistErrors: 0,
+  contributorUnregister: null
+};
+var DEFAULTS = {
+  enabled: true,
+  filePath: ".wrongstack/knowledge-graph.json",
+  maxFacts: 200,
+  maxFactChars: 300,
+  contributeToSystemPrompt: true,
+  contributeMaxChars: 1500
+};
+function resolveProjectPath(rawPath, cwd = process.cwd()) {
+  if (typeof rawPath !== "string" || rawPath.length === 0) return null;
+  const root = resolve(cwd);
+  const resolved = isAbsolute(rawPath) ? resolve(rawPath) : resolve(root, rawPath);
+  const rel = relative(root, resolved);
+  if (rel === "" || !rel.startsWith("..") && !isAbsolute(rel)) return resolved;
+  return null;
+}
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  return {
+    enabled: r["enabled"] !== false,
+    filePath: typeof r["filePath"] === "string" ? r["filePath"] : DEFAULTS.filePath,
+    maxFacts: typeof r["maxFacts"] === "number" && r["maxFacts"] >= 1 && r["maxFacts"] <= 2e3 ? r["maxFacts"] : DEFAULTS.maxFacts,
+    maxFactChars: typeof r["maxFactChars"] === "number" && r["maxFactChars"] >= 20 ? r["maxFactChars"] : DEFAULTS.maxFactChars,
+    contributeToSystemPrompt: r["contributeToSystemPrompt"] !== false,
+    contributeMaxChars: typeof r["contributeMaxChars"] === "number" && r["contributeMaxChars"] >= 100 ? r["contributeMaxChars"] : DEFAULTS.contributeMaxChars
+  };
+}
+function loadFacts(filePath) {
+  if (!filePath) return { facts: [], nextId: 1 };
+  try {
+    const raw = JSON.parse(readFileSync(filePath, "utf-8"));
+    const facts = Array.isArray(raw.facts) ? raw.facts.filter(
+      (f) => !!f && typeof f === "object" && typeof f.id === "string" && typeof f.subject === "string" && typeof f.relation === "string" && typeof f.object === "string"
+    ) : [];
+    const nextId = typeof raw.nextId === "number" && raw.nextId >= 1 ? raw.nextId : facts.length + 1;
+    return { facts, nextId };
+  } catch {
+    return { facts: [], nextId: 1 };
+  }
+}
+function persistFacts(filePath) {
+  if (!filePath) return true;
+  try {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(
+      filePath,
+      JSON.stringify({ facts: state.facts, nextId: state.nextId }, null, 2)
+    );
+    return true;
+  } catch {
+    state.persistErrors += 1;
+    return false;
+  }
+}
+var plugin = {
+  name: "knowledge-graph",
+  version: "0.1.0",
+  description: "Accumulates structured (subject, relation, object) facts about the project and queries them across sessions",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: { type: "boolean", default: true, description: "Master switch." },
+      filePath: {
+        type: "string",
+        default: ".wrongstack/knowledge-graph.json",
+        description: "Project-local JSON file where facts persist."
+      },
+      maxFacts: {
+        type: "number",
+        minimum: 1,
+        maximum: 2e3,
+        default: 200,
+        description: "Maximum number of facts stored."
+      },
+      maxFactChars: {
+        type: "number",
+        minimum: 20,
+        default: 300,
+        description: "Per-field length cap (subject, relation, object)."
+      },
+      contributeToSystemPrompt: {
+        type: "boolean",
+        default: true,
+        description: "Inject a compact fact summary into the system prompt."
+      },
+      contributeMaxChars: {
+        type: "number",
+        minimum: 100,
+        default: 1500,
+        description: "Maximum chars contributed to the system prompt."
+      }
+    }
+  },
+  setup(api) {
+    state.adds = 0;
+    state.removals = 0;
+    state.queries = 0;
+    state.persistErrors = 0;
+    if (state.contributorUnregister) {
+      try {
+        state.contributorUnregister();
+      } catch {
+      }
+      state.contributorUnregister = null;
+    }
+    const cfg = readConfig(api.config.extensions?.["knowledge-graph"]);
+    const resolved = resolveProjectPath(cfg.filePath) ?? "";
+    const loaded = resolved ? loadFacts(resolved) : { facts: [], nextId: 1 };
+    state.facts = loaded.facts.slice(0, cfg.maxFacts);
+    state.nextId = loaded.nextId;
+    if (cfg.enabled && cfg.contributeToSystemPrompt) {
+      state.contributorUnregister = api.registerSystemPromptContributor(async () => {
+        if (state.facts.length === 0) return [];
+        const recent = [...state.facts].filter((f) => f.confidence !== "low").sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt)).slice(0, 20);
+        if (recent.length === 0) return [];
+        const lines = recent.map((f) => `- ${f.subject} ${f.relation} ${f.object}`);
+        const text = "[project_knowledge]\nRecorded facts about this project (most recent, medium/high confidence):\n" + lines.join("\n");
+        const truncated = text.length > cfg.contributeMaxChars ? text.slice(0, cfg.contributeMaxChars) + "\n[truncated]" : text;
+        return [{ type: "text", text: truncated }];
+      });
+    }
+    api.tools.register({
+      name: "kg_add_fact",
+      description: "Add a structured fact to the project knowledge graph. Facts persist across sessions.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          subject: { type: "string", description: "The entity the fact is about." },
+          relation: { type: "string", description: 'Relationship, e.g. "depends_on", "owned_by".' },
+          object: { type: "string", description: "The related entity or value." },
+          source: {
+            type: "string",
+            description: "Where this fact came from (file path, conversation, tool result)."
+          },
+          confidence: {
+            type: "string",
+            enum: ["low", "medium", "high"],
+            description: "How sure the agent is about this fact."
+          }
+        },
+        required: ["subject", "relation", "object"]
+      },
+      permission: "auto",
+      category: "Memory",
+      mutating: true,
+      async execute(input) {
+        if (!cfg.enabled) return { ok: false, error: "knowledge-graph is disabled" };
+        if (state.facts.length >= cfg.maxFacts) {
+          return {
+            ok: false,
+            error: `fact limit reached (${cfg.maxFacts}). Remove old facts first.`
+          };
+        }
+        const trim = (s) => String(s ?? "").trim().slice(0, cfg.maxFactChars);
+        const subject = trim(input.subject);
+        const relation = trim(input.relation);
+        const object = trim(input.object);
+        if (!subject || !relation || !object) {
+          return { ok: false, error: "subject, relation, and object are required" };
+        }
+        const fact = {
+          id: `kg-${state.nextId++}`,
+          subject,
+          relation,
+          object,
+          source: input.source ? String(input.source).slice(0, cfg.maxFactChars) : null,
+          confidence: input.confidence ?? "medium",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        state.facts.push(fact);
+        state.adds += 1;
+        api.metrics.counter("adds");
+        const persisted = persistFacts(resolved);
+        return { ok: true, fact, persisted, totalFacts: state.facts.length };
+      }
+    });
+    api.tools.register({
+      name: "kg_query",
+      description: "Query the knowledge graph by subject, relation, object, or confidence. Returns matching facts.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          subject: { type: "string" },
+          relation: { type: "string" },
+          object: { type: "string" },
+          confidence: { type: "string", enum: ["low", "medium", "high"] },
+          limit: { type: "number", description: "Max results (default 20)." }
+        }
+      },
+      permission: "auto",
+      category: "Memory",
+      mutating: false,
+      async execute(input) {
+        if (!cfg.enabled) return { ok: false, error: "knowledge-graph is disabled" };
+        state.queries += 1;
+        const limit = typeof input.limit === "number" && input.limit >= 1 ? Math.floor(input.limit) : 20;
+        const matches = state.facts.filter((f) => {
+          if (input.subject && !f.subject.toLowerCase().includes(input.subject.toLowerCase())) return false;
+          if (input.relation && !f.relation.toLowerCase().includes(input.relation.toLowerCase())) return false;
+          if (input.object && !f.object.toLowerCase().includes(input.object.toLowerCase())) return false;
+          if (input.confidence && f.confidence !== input.confidence) return false;
+          return true;
+        });
+        return {
+          ok: true,
+          totalFacts: state.facts.length,
+          returned: Math.min(matches.length, limit),
+          facts: matches.slice(-limit)
+        };
+      }
+    });
+    api.tools.register({
+      name: "kg_remove_fact",
+      description: "Remove a fact from the knowledge graph by its id (kg-N).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Fact id to remove." }
+        },
+        required: ["id"]
+      },
+      permission: "auto",
+      category: "Memory",
+      mutating: true,
+      async execute(input) {
+        if (!cfg.enabled) return { ok: false, error: "knowledge-graph is disabled" };
+        const before = state.facts.length;
+        state.facts = state.facts.filter((f) => f.id !== input.id);
+        const removed = before - state.facts.length;
+        if (removed === 0) return { ok: false, error: `no fact matches "${input.id}"` };
+        state.removals += removed;
+        api.metrics.counter("removals", removed);
+        const persisted = persistFacts(resolved);
+        return { ok: true, removed, persisted, totalFacts: state.facts.length };
+      }
+    });
+    api.tools.register({
+      name: "kg_status",
+      description: "Reports knowledge-graph state: fact count, persisted path, and counters.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Memory",
+      mutating: false,
+      async execute() {
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          totalFacts: state.facts.length,
+          maxFacts: cfg.maxFacts,
+          filePath: cfg.filePath,
+          resolvedPath: resolved || null,
+          contributeToSystemPrompt: cfg.contributeToSystemPrompt,
+          counters: {
+            adds: state.adds,
+            removals: state.removals,
+            queries: state.queries,
+            persistErrors: state.persistErrors
+          }
+        };
+      }
+    });
+    api.log.info("knowledge-graph plugin loaded", {
+      version: "0.1.0",
+      factsLoaded: state.facts.length,
+      filePath: cfg.filePath
+    });
+  },
+  teardown(api) {
+    if (state.contributorUnregister) {
+      try {
+        state.contributorUnregister();
+      } catch {
+      }
+      state.contributorUnregister = null;
+    }
+    const final = {
+      facts: state.facts.length,
+      adds: state.adds,
+      removals: state.removals,
+      queries: state.queries,
+      persistErrors: state.persistErrors
+    };
+    state.facts = [];
+    state.nextId = 1;
+    state.adds = 0;
+    state.removals = 0;
+    state.queries = 0;
+    state.persistErrors = 0;
+    api.log.info("knowledge-graph: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: state.persistErrors === 0,
+      message: `knowledge-graph: ${state.facts.length} fact(s), ${state.adds} add(s), ${state.queries} query(ies), ${state.persistErrors} persist error(s)`,
+      counters: {
+        facts: state.facts.length,
+        adds: state.adds,
+        removals: state.removals,
+        queries: state.queries,
+        persistErrors: state.persistErrors
+      }
+    };
+  }
+};
+var knowledge_graph_default = plugin;
+
+export { knowledge_graph_default as default };

package/dist/license-audit-gate.d.ts

@@ -0,0 +1,34 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * license-audit-gate plugin — audits dependency licenses at install time.
+ *
+ * After every `bash` or `exec` tool call that looks like a package-manager
+ * install/add command (`npm i`, `pnpm add`, `yarn add`, `bun add`), the
+ * plugin reads `node_modules/<package>/package.json` for each newly added
+ * dependency, extracts its license field(s), and checks them against an
+ * allowlist. If any package's license is not on the allowlist, the hook
+ * either blocks the install (default) or injects a warning note.
+ *
+ * Tools registered:
+ * - license_audit_status : Show config + per-session counters.
+ *
+ * Hooks registered:
+ * - PostToolUse with matcher `bash|exec`.
+ *
+ * Config (`config.extensions['license-audit-gate']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "allowedLicenses": ["MIT", "Apache-2.0", "BSD-2-Clause", "BSD-3-Clause", "ISC", "0BSD", "Unlicense"],
+ *   "block": true
+ * }
+ * ```
+ *
+ * @public
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };

package/dist/license-audit-gate.js

@@ -0,0 +1,260 @@
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+
+// src/license-audit-gate/index.ts
+var API_VERSION = "^0.1.10";
+var state = {
+  invocations: 0,
+  installsSeen: 0,
+  packagesAudited: 0,
+  allowedCount: 0,
+  deniedCount: 0,
+  blockedCount: 0,
+  errorCount: 0,
+  lastResult: null,
+  hookUnregister: null
+};
+var DEFAULTS = {
+  enabled: true,
+  allowedLicenses: ["MIT", "Apache-2.0", "BSD-2-Clause", "BSD-3-Clause", "ISC", "0BSD", "Unlicense"],
+  block: true
+};
+function normalizeStrings(v) {
+  if (!Array.isArray(v)) return [];
+  return v.filter((s) => typeof s === "string" && s.length > 0).map((s) => s.trim());
+}
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  const allowed = normalizeStrings(r["allowedLicenses"]);
+  return {
+    enabled: r["enabled"] !== false,
+    allowedLicenses: allowed.length > 0 ? allowed : [...DEFAULTS.allowedLicenses],
+    block: r["block"] !== false
+  };
+}
+function extractLicenseStrings(pkg) {
+  if (!pkg || typeof pkg !== "object") return [];
+  const p = pkg;
+  const out = [];
+  const push = (v) => {
+    if (typeof v === "string" && v.trim()) {
+      out.push(v.trim());
+    } else if (v && typeof v === "object" && typeof v.type === "string") {
+      const t = v.type;
+      if (t.trim()) out.push(t.trim());
+    }
+  };
+  push(p["license"]);
+  if (Array.isArray(p["licenses"])) {
+    for (const entry of p["licenses"]) push(entry);
+  }
+  return [...new Set(out)];
+}
+var INSTALL_RE = /(?:^|[;&|]\s*)(npm|pnpm|yarn|bun)\s+(?:install|i|add)\s+([^;&|]+)/gi;
+function parsePackageNames(command) {
+  const names = [];
+  INSTALL_RE.lastIndex = 0;
+  let m;
+  while ((m = INSTALL_RE.exec(command)) !== null) {
+    const argString = m[2] ?? "";
+    for (const token of argString.split(/\s+/)) {
+      if (!token || token.startsWith("-")) continue;
+      if (/^(\.|\/|file:|git\+|https?:)/i.test(token) || token.endsWith(".tgz")) continue;
+      const cleaned = token.replace(/^['"]|['"]$/g, "");
+      if (!cleaned) continue;
+      let name = cleaned;
+      const at = cleaned.lastIndexOf("@");
+      if (at > 0) name = cleaned.slice(0, at);
+      if (name) names.push(name);
+    }
+  }
+  return [...new Set(names)];
+}
+function auditPackages(names, allowedLicenses) {
+  const results = [];
+  const errors = [];
+  const normalizedAllowed = new Set(allowedLicenses.map((l) => l.toLowerCase()));
+  for (const name of names) {
+    let licenses = [];
+    try {
+      const pkgPath = resolve("node_modules", name, "package.json");
+      const raw = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      licenses = extractLicenseStrings(raw);
+    } catch {
+      errors.push(name);
+    }
+    const allowed = licenses.length > 0 && licenses.every((l) => normalizedAllowed.has(l.toLowerCase()));
+    results.push({ name, licenses, allowed });
+  }
+  const ok = errors.length === 0 && results.every((r) => r.allowed);
+  return { ok, results, errors };
+}
+var plugin = {
+  name: "license-audit-gate",
+  version: "0.1.0",
+  description: "PostToolUse hook that audits dependency licenses after package-manager install/add commands and blocks disallowed licenses",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true, hooks: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: {
+        type: "boolean",
+        default: true,
+        description: "Master switch."
+      },
+      allowedLicenses: {
+        type: "array",
+        items: { type: "string" },
+        default: DEFAULTS.allowedLicenses,
+        description: "List of allowed SPDX/license identifiers."
+      },
+      block: {
+        type: "boolean",
+        default: true,
+        description: "true = block the install when a disallowed license is found; false = inject a warning note."
+      }
+    }
+  },
+  setup(api) {
+    state.invocations = 0;
+    state.installsSeen = 0;
+    state.packagesAudited = 0;
+    state.allowedCount = 0;
+    state.deniedCount = 0;
+    state.blockedCount = 0;
+    state.errorCount = 0;
+    state.lastResult = null;
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const cfg = readConfig(api.config.extensions?.["license-audit-gate"]);
+    const hook = (input) => {
+      if (!cfg.enabled) return;
+      if (input.toolResult?.isError) return;
+      const ti = input.toolInput ?? {};
+      const command = typeof ti["command"] === "string" ? ti["command"] : "";
+      if (!command) return;
+      state.invocations += 1;
+      const names = parsePackageNames(command);
+      if (names.length === 0) return;
+      state.installsSeen += 1;
+      const audit = auditPackages(names, cfg.allowedLicenses);
+      state.packagesAudited += names.length;
+      const denied = audit.results.filter((r) => !r.allowed).map((r) => r.name);
+      state.allowedCount += audit.results.filter((r) => r.allowed).length;
+      state.deniedCount += denied.length;
+      state.errorCount += audit.errors.length;
+      state.lastResult = {
+        passed: audit.ok,
+        denied,
+        when: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (audit.ok) return;
+      const lines = audit.results.map((r) => {
+        const licenseText = r.licenses.length > 0 ? r.licenses.join(", ") : "no license found";
+        if (r.allowed) return `  \u2705 ${r.name}: ${licenseText}`;
+        return `  \u274C ${r.name}: ${licenseText} (not in allowlist)`;
+      });
+      if (audit.errors.length > 0) {
+        lines.push(`  \u26A0\uFE0F could not read package.json for: ${audit.errors.join(", ")}`);
+      }
+      const message = `license-audit-gate: dependency license check failed for newly added packages.
+Allowed licenses: ${cfg.allowedLicenses.join(", ")}
+` + lines.join("\n");
+      if (cfg.block) {
+        state.blockedCount += 1;
+        return {
+          decision: "block",
+          reason: message,
+          additionalContext: message
+        };
+      }
+      return { additionalContext: message };
+    };
+    state.hookUnregister = api.registerHook("PostToolUse", "bash|exec", hook);
+    api.tools.register({
+      name: "license_audit_status",
+      description: "Reports license-audit-gate state: allowlist, block mode, and per-session audit counters.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute() {
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          allowedLicenses: cfg.allowedLicenses,
+          block: cfg.block,
+          counters: {
+            invocations: state.invocations,
+            installsSeen: state.installsSeen,
+            packagesAudited: state.packagesAudited,
+            allowed: state.allowedCount,
+            denied: state.deniedCount,
+            blocked: state.blockedCount,
+            errors: state.errorCount
+          },
+          lastResult: state.lastResult
+        };
+      }
+    });
+    api.log.info("license-audit-gate plugin loaded", {
+      version: "0.1.0",
+      allowedLicensesCount: cfg.allowedLicenses.length,
+      block: cfg.block
+    });
+  },
+  teardown(api) {
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const final = {
+      invocations: state.invocations,
+      installsSeen: state.installsSeen,
+      packagesAudited: state.packagesAudited,
+      allowed: state.allowedCount,
+      denied: state.deniedCount,
+      blocked: state.blockedCount,
+      errors: state.errorCount
+    };
+    state.invocations = 0;
+    state.installsSeen = 0;
+    state.packagesAudited = 0;
+    state.allowedCount = 0;
+    state.deniedCount = 0;
+    state.blockedCount = 0;
+    state.errorCount = 0;
+    state.lastResult = null;
+    api.log.info("license-audit-gate: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: true,
+      message: state.lastResult ? `license-audit-gate: ${state.installsSeen} install command(s) seen, ${state.deniedCount} denied, ${state.blockedCount} blocked` : `license-audit-gate: ${state.invocations} invocation(s), ${state.packagesAudited} package(s) audited`,
+      counters: {
+        invocations: state.invocations,
+        installsSeen: state.installsSeen,
+        packagesAudited: state.packagesAudited,
+        allowed: state.allowedCount,
+        denied: state.deniedCount,
+        blocked: state.blockedCount,
+        errors: state.errorCount
+      },
+      lastResult: state.lastResult
+    };
+  }
+};
+var license_audit_gate_default = plugin;
+
+export { license_audit_gate_default as default };

package/dist/llm-cache.js

@@ -125,6 +125,11 @@ var plugin = {
     }
     const cfg = readConfig(api.config.extensions?.["llm-cache"]);
     if (cfg.enabled) {
+      api.emitCustom?.("provider.wrap:loaded", {
+        plugin: "llm-cache",
+        kind: "cache",
+        wraps: ["request"]
+      });
       state.extensionUnregister = api.extensions.register({
         name: "llm-cache",
         owner: "llm-cache",

package/dist/loop-breaker.d.ts

@@ -1,43 +1,5 @@
 import { Plugin } from '@wrongstack/core';
 
-/**
- * loop-breaker plugin — detects runaway tool-call loops and breaks them.
- *
- * Agents occasionally get stuck re-issuing the same tool call with the
- * same input (a failing bash command retried forever, re-reading the
- * same file, re-writing identical content). Each repeat burns tokens
- * and wall-clock without making progress. This plugin fingerprints
- * every tool call (`toolName` + canonicalized input JSON) via a
- * `PreToolUse '*'` hook and tracks consecutive repeats:
- *
- *  - at `warnAfter` repeats  → inject `additionalContext` telling the
- *    model it is looping and should change approach
- *  - at `blockAfter` repeats → block the call outright with a clear
- *    reason (unless `mode: 'warn'`)
- *
- * Any *different* call resets the streak, so normal workflows (many
- * distinct reads/edits) are never touched. A small LRU of recent
- * fingerprints also catches A-B-A-B oscillation loops.
- *
- * Config (`config.extensions['loop-breaker']`):
- *
- * ```jsonc
- * {
- *   "enabled": true,
- *   "mode": "block",        // "block" | "warn"
- *   "warnAfter": 3,          // consecutive identical calls before warning
- *   "blockAfter": 5,         // consecutive identical calls before blocking
- *   "oscillationWindow": 8,  // recent-call window for A-B-A-B detection
- *   "ignoreTools": []        // tool names exempt from loop detection
- * }
- * ```
- *
- * Toggle off entirely with `{ "name": "loop-breaker", "enabled": false }`
- * in `config.plugins`, or `"enabled": false` in the options above.
- *
- * @public
- */
-
 declare const plugin: Plugin;
 
 export { plugin as default };