lurqrun 0.1.6 → 0.1.7

package/dist/chunk-UDVNA7EA.js

@@ -0,0 +1,483 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  packageRoot
+} from "./chunk-LUAKDHLZ.js";
+import {
+  logger
+} from "./chunk-MYGSLK44.js";
+import {
+  lurqHome,
+  resolveApiKey
+} from "./chunk-Y5GI7RL3.js";
+import {
+  DEFAULT_ENDPOINT,
+  PACKAGE_NAME
+} from "./chunk-GPTKSNR6.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/cli/installSkill.ts
+init_esm_shims();
+import {
+  accessSync,
+  chmodSync,
+  constants,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { copyFileSync } from "fs";
+import { homedir } from "os";
+import { delimiter, dirname, join } from "path";
+var ENV_KEYS = [
+  "DATABASE_URL",
+  "GITHUB_TOKEN",
+  "EMBEDDING_PROVIDER",
+  "EMBEDDING_API_KEY",
+  "EMBEDDING_MODEL",
+  "SUMMARY_PROVIDER",
+  "SUMMARY_API_KEY",
+  "SUMMARY_MODEL"
+];
+function home(...p) {
+  return join(homedir(), ...p);
+}
+function vscodeUserDir() {
+  if (process.platform === "darwin") return home("Library", "Application Support", "Code", "User");
+  if (process.platform === "win32") {
+    return join(process.env.APPDATA ?? home("AppData", "Roaming"), "Code", "User");
+  }
+  return join(process.env.XDG_CONFIG_HOME || home(".config"), "Code", "User");
+}
+function agentSpecs() {
+  return [
+    {
+      id: "claude-code",
+      label: "Claude Code",
+      format: "mcpServers",
+      path: home(".claude.json"),
+      detected: existsSync(home(".claude.json")) || existsSync(home(".claude")),
+      // Personal skills are read from ~/.claude/skills/<name>/SKILL.md and apply
+      // across every project, which is exactly the scope a global install wants.
+      instructions: { kind: "skill", path: home(".claude", "skills", "lurq", "SKILL.md") }
+    },
+    {
+      // No instructions target: Cursor's user-level rules live in its settings
+      // UI, not a file on disk, and its `.cursor/rules/*.mdc` files are
+      // per-project, so there is nothing a machine-wide install can write once.
+      // The MCP tool descriptions carry the guidance here.
+      id: "cursor",
+      label: "Cursor",
+      format: "mcpServers",
+      path: home(".cursor", "mcp.json"),
+      detected: existsSync(home(".cursor"))
+    },
+    {
+      id: "windsurf",
+      label: "Windsurf",
+      format: "mcpServers",
+      path: home(".codeium", "windsurf", "mcp_config.json"),
+      detected: existsSync(home(".codeium")),
+      instructions: {
+        kind: "shared",
+        path: home(".codeium", "windsurf", "memories", "global_rules.md")
+      }
+    },
+    {
+      // No instructions target, for two reasons that compound. A
+      // `.instructions.md` file is only applied automatically when its
+      // frontmatter carries an `applyTo` glob; without one, VS Code requires the
+      // user to attach it to a request by hand. And the user-profile directory
+      // that gets scanned is not a documented default at all: the workspace
+      // default is `.github/instructions`, and profile-level folders come from
+      // the `chat.instructionsFilesLocations` setting. Guessing the path would
+      // write a file nobody reads while reporting success, which is the same
+      // mistake the hardcoded macOS config path made above.
+      id: "copilot",
+      label: "VS Code / GitHub Copilot",
+      format: "servers",
+      path: join(vscodeUserDir(), "mcp.json"),
+      detected: existsSync(vscodeUserDir())
+    },
+    {
+      id: "codex",
+      label: "OpenAI Codex CLI",
+      format: "toml",
+      path: home(".codex", "config.toml"),
+      detected: existsSync(home(".codex")),
+      instructions: { kind: "shared", path: home(".codex", "AGENTS.md") }
+    },
+    {
+      id: "gemini-cli",
+      label: "Gemini CLI",
+      format: "mcpServers",
+      path: home(".gemini", "settings.json"),
+      detected: existsSync(home(".gemini", "settings.json")),
+      // ~/.gemini/GEMINI.md is the global tier of the context hierarchy, loaded
+      // ahead of any workspace file.
+      instructions: { kind: "shared", path: home(".gemini", "GEMINI.md") }
+    },
+    {
+      // Shares the ~/.gemini root with the Gemini CLI but keeps its own file, so
+      // detection has to look at the file rather than at the directory. It reads
+      // the same global GEMINI.md; upserting the block twice is a no-op, so
+      // having both selected is harmless.
+      id: "antigravity",
+      label: "Google Antigravity",
+      format: "mcpServers",
+      path: home(".gemini", "config", "mcp_config.json"),
+      detected: existsSync(home(".gemini", "config")),
+      instructions: { kind: "shared", path: home(".gemini", "GEMINI.md") }
+    },
+    {
+      id: "kiro",
+      label: "Kiro",
+      format: "mcpServers",
+      path: home(".kiro", "settings", "mcp.json"),
+      detected: existsSync(home(".kiro")),
+      // Steering files in ~/.kiro/steering apply to every workspace and are
+      // always included.
+      instructions: { kind: "file", path: home(".kiro", "steering", "lurq.md") }
+    }
+  ];
+}
+var SUPPORTED_AGENTS = [
+  "claude-code",
+  "cursor",
+  "windsurf",
+  "copilot",
+  "codex",
+  "gemini-cli",
+  "antigravity",
+  "kiro"
+];
+function collectEnv() {
+  const env = {};
+  for (const key of ENV_KEYS) {
+    const value = process.env[key];
+    if (value) env[key] = value;
+  }
+  return env;
+}
+function readJsonObject(path) {
+  if (!existsSync(path)) return {};
+  const text = readFileSync(path, "utf8").trim();
+  if (!text) return {};
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    throw new Error(
+      `${path} is not plain JSON (${err instanceof Error ? err.message : String(err)}). If it has comments or trailing commas, lurq will not rewrite it and lose them: remove them and re-run, or edit the "lurq" server entry by hand.`
+    );
+  }
+}
+var KEY_FILE_MODE = 384;
+function writeFileAtomic(path, contents, newFileMode = KEY_FILE_MODE) {
+  let target = path;
+  let mode = newFileMode;
+  try {
+    target = realpathSync(path);
+    mode = statSync(target).mode & 511;
+  } catch {
+  }
+  mkdirSync(dirname(target), { recursive: true });
+  const tmp = `${target}.lurq-${process.pid}.tmp`;
+  try {
+    writeFileSync(tmp, contents, { encoding: "utf8", mode });
+    chmodSync(tmp, mode);
+    renameSync(tmp, target);
+  } catch (err) {
+    try {
+      rmSync(tmp, { force: true });
+    } catch {
+    }
+    throw err;
+  }
+}
+function writeJson(path, obj) {
+  writeFileAtomic(path, JSON.stringify(obj, null, 2) + "\n");
+}
+function buildServerEntry(env, withType) {
+  const entry = { command: "npx", args: ["-y", PACKAGE_NAME, "serve"] };
+  if (withType) entry.type = "stdio";
+  if (Object.keys(env).length) entry.env = env;
+  return entry;
+}
+function buildRemoteServerEntry(agentId, opts) {
+  const headers = { Authorization: `Bearer ${opts.apiKey}` };
+  switch (agentId) {
+    case "cursor":
+    case "kiro":
+      return { url: opts.url, headers };
+    case "windsurf":
+    case "antigravity":
+      return { serverUrl: opts.url, headers };
+    case "gemini-cli":
+      return { httpUrl: opts.url, headers };
+    case "claude-code":
+    case "copilot":
+    default:
+      return { type: "http", url: opts.url, headers };
+  }
+}
+function buildTomlBlock(env) {
+  const lines = ["[mcp_servers.lurq]", 'command = "npx"', `args = ["-y", "${PACKAGE_NAME}", "serve"]`];
+  if (Object.keys(env).length) {
+    lines.push("", "[mcp_servers.lurq.env]");
+    for (const [k, v] of Object.entries(env)) lines.push(`${k} = ${JSON.stringify(v)}`);
+  }
+  return lines.join("\n") + "\n";
+}
+function buildRemoteTomlBlock(opts) {
+  return [
+    "[mcp_servers.lurq]",
+    `url = ${JSON.stringify(opts.url)}`,
+    `http_headers = { Authorization = ${JSON.stringify(`Bearer ${opts.apiKey}`)} }`
+  ].join("\n") + "\n";
+}
+function installJsonEntry(spec, entry) {
+  const key = spec.format === "servers" ? "servers" : "mcpServers";
+  const config = readJsonObject(spec.path);
+  if (typeof config[key] !== "object" || config[key] === null) config[key] = {};
+  config[key].lurq = entry;
+  writeJson(spec.path, config);
+  return { agent: spec.id, path: spec.path, status: "installed" };
+}
+function stripTomlBlock(text, header = "[mcp_servers.lurq]") {
+  const lines = text.split("\n");
+  const start = lines.findIndex((l) => l.trim() === header);
+  if (start === -1) return text;
+  let end = start + 1;
+  while (end < lines.length) {
+    const t = lines[end].trim();
+    if (t.startsWith("[") && !t.startsWith(`${header.slice(0, -1)}.`)) break;
+    end++;
+  }
+  return [...lines.slice(0, start), ...lines.slice(end)].join("\n").replace(/\n{3,}/g, "\n\n");
+}
+function installTomlBlock(spec, block) {
+  const current = existsSync(spec.path) ? readFileSync(spec.path, "utf8") : "";
+  const existing = stripTomlBlock(current).replace(/\s+$/, "");
+  const sep = existing ? "\n\n" : "";
+  writeFileAtomic(spec.path, existing + sep + block);
+  return {
+    agent: spec.id,
+    path: spec.path,
+    status: "installed",
+    message: current.includes("[mcp_servers.lurq]") ? "replaced the existing lurq entry" : void 0
+  };
+}
+var BLOCK_START = "<!-- lurq:start -->";
+var BLOCK_END = "<!-- lurq:end -->";
+var SKILL_DESCRIPTION = "Get current, evidence-scored facts about npm packages instead of recalling them. Use before adding, choosing, comparing, or upgrading any JS/TS dependency, before hand-rolling something a package may already do, and before writing code against a package API that may have moved since training. Covers hallucinated and typosquatted package names, advisories, version-exact export surfaces, and stack compatibility.";
+function template(name) {
+  const src = join(packageRoot(), "templates", name);
+  return existsSync(src) ? readFileSync(src, "utf8") : null;
+}
+function upsertMarkedBlock(text, block) {
+  const wrapped = `${BLOCK_START}
+${block.trim()}
+${BLOCK_END}`;
+  const start = text.indexOf(BLOCK_START);
+  if (start === -1) {
+    const existing = text.replace(/\s+$/, "");
+    return existing ? `${existing}
+
+${wrapped}
+` : `${wrapped}
+`;
+  }
+  const endAt = text.indexOf(BLOCK_END, start);
+  const after = endAt === -1 ? "" : text.slice(endAt + BLOCK_END.length);
+  return `${text.slice(0, start)}${wrapped}${after.replace(/^\n*/, "\n")}`;
+}
+function removeMarkedBlock(text) {
+  const start = text.indexOf(BLOCK_START);
+  if (start === -1) return text;
+  const endAt = text.indexOf(BLOCK_END, start);
+  const before = text.slice(0, start).replace(/\s+$/, "");
+  const after = endAt === -1 ? "" : text.slice(endAt + BLOCK_END.length).replace(/^\s+/, "");
+  const joined = [before, after].filter(Boolean).join("\n\n");
+  return joined ? joined.replace(/\s*$/, "\n") : "";
+}
+function buildSkillFile(guide) {
+  return [
+    "---",
+    "name: lurq",
+    `description: ${SKILL_DESCRIPTION}`,
+    "---",
+    "",
+    guide.trim(),
+    ""
+  ].join("\n");
+}
+function installInstructions(spec) {
+  const target = spec.instructions;
+  if (!target) return null;
+  if (target.kind === "shared") {
+    const brief = template("agent-rules.md");
+    if (!brief) return null;
+    const current = existsSync(target.path) ? readFileSync(target.path, "utf8") : "";
+    writeFileAtomic(target.path, upsertMarkedBlock(current, brief), 420);
+    return target.path;
+  }
+  const guide = template("skill-instructions.md");
+  if (!guide) return null;
+  writeFileAtomic(target.path, target.kind === "skill" ? buildSkillFile(guide) : guide, 420);
+  return target.path;
+}
+function installAgent(spec, mode) {
+  try {
+    const result = spec.format === "toml" ? installTomlBlock(
+      spec,
+      mode.kind === "remote" ? buildRemoteTomlBlock(mode) : buildTomlBlock(mode.env)
+    ) : installJsonEntry(
+      spec,
+      mode.kind === "remote" ? buildRemoteServerEntry(spec.id, mode) : buildServerEntry(mode.env, spec.format === "servers")
+    );
+    try {
+      result.instructionsPath = installInstructions(spec) ?? void 0;
+    } catch (err) {
+      result.message = `MCP entry written; instructions file failed: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    return result;
+  } catch (err) {
+    return {
+      agent: spec.id,
+      path: spec.path,
+      status: "error",
+      message: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function installInstructionsFile() {
+  const src = join(packageRoot(), "templates", "skill-instructions.md");
+  if (!existsSync(src)) return null;
+  const destDir = lurqHome();
+  const dest = join(destDir, "skill-instructions.md");
+  mkdirSync(destDir, { recursive: true });
+  copyFileSync(src, dest);
+  return dest;
+}
+function resolveAgents(target) {
+  const specs = agentSpecs();
+  if (target === "all") return specs.filter((s) => s.detected);
+  const spec = specs.find((s) => s.id === target);
+  if (!spec) {
+    throw new Error(`Unknown agent "${target}". Supported: ${SUPPORTED_AGENTS.join(", ")}, all.`);
+  }
+  return [spec];
+}
+function lurqInvocation() {
+  const candidates = process.platform === "win32" ? [".cmd", ".exe", ""] : [""];
+  for (const dir of (process.env.PATH ?? "").split(delimiter)) {
+    if (!dir) continue;
+    for (const ext of candidates) {
+      try {
+        accessSync(join(dir, `lurq${ext}`), constants.X_OK);
+        return { command: "lurq", onPath: true };
+      } catch {
+      }
+    }
+  }
+  return { command: `npx ${PACKAGE_NAME}`, onPath: false };
+}
+function printInstallReport(results, instructionsPath, mode) {
+  const specs = agentSpecs();
+  const short = (p) => p.startsWith(homedir()) ? `~${p.slice(homedir().length)}` : p;
+  console.log("lurq MCP server registration:");
+  for (const r of results) {
+    const spec = specs.find((s) => s.id === r.agent);
+    const mark = r.status === "installed" ? "\u2713" : r.status === "skipped" ? "\u2022" : "\u2717";
+    console.log(
+      `  ${mark} ${spec.label.padEnd(26)} ${short(r.path)}${r.message ? `  (${r.message})` : ""}`
+    );
+  }
+  const withSkills = results.filter((r) => r.instructionsPath);
+  if (withSkills.length) {
+    console.log("\nAgent instructions (so it reaches for lurq on its own):");
+    for (const r of withSkills) {
+      const spec = specs.find((s) => s.id === r.agent);
+      console.log(`  \u2713 ${spec.label.padEnd(26)} ${short(r.instructionsPath)}`);
+    }
+  }
+  if (instructionsPath) console.log(`
+Full guide: ${short(instructionsPath)}`);
+  console.log("\nNext steps:");
+  if (mode.kind === "local") {
+    console.log("  1. Ensure DATABASE_URL (and any API keys) are set in the config env above.");
+    console.log("  2. Restart the agent so it picks up the new MCP server.");
+  } else {
+    console.log("  1. Restart the agent so it picks up the new MCP server.");
+  }
+  console.log("  \u2022 Ask it to add a package. It should check the package with lurq first.");
+  const { command, onPath } = lurqInvocation();
+  console.log(`  \u2022 Or use the terminal directly: \`${command} verify zod\`.`);
+  if (!onPath) {
+    console.log(`
+  There is no \`lurq\` command on this machine yet. Everything above`);
+    console.log("  worked and your agents are wired up; only the terminal shortcut is");
+    console.log(`  missing, so use \`npx ${PACKAGE_NAME} <command>\`. To get \`lurq\` itself:`);
+    console.log(`      npm install -g ${PACKAGE_NAME}`);
+  }
+}
+async function runInstallSkill(opts) {
+  const selected = resolveAgents(opts.agent ?? "claude-code");
+  if (selected.length === 0) {
+    console.log("No supported agents detected on this machine.");
+    return;
+  }
+  const remote = !opts.local;
+  let mode;
+  if (remote) {
+    const apiKey = resolveApiKey(opts.apiKey);
+    if (!apiKey) {
+      throw new Error(
+        "An API key is required for a hosted install. Pass --api-key <key> (or set LURQ_API_KEY), or run `lurq setup` for the guided setup, or --local to self-host."
+      );
+    }
+    const url = opts.url ?? process.env.LURQ_ENDPOINT ?? DEFAULT_ENDPOINT;
+    mode = { kind: "remote", url, apiKey };
+  } else {
+    const env = collectEnv();
+    if (!env.DATABASE_URL) {
+      logger.warn(
+        "DATABASE_URL is not set, the local server entry will have no DATABASE_URL. Set it (in .env) and re-run, or edit the config."
+      );
+    }
+    mode = { kind: "local", env };
+  }
+  const results = selected.map((spec) => installAgent(spec, mode));
+  const instructionsPath = installInstructionsFile();
+  printInstallReport(results, instructionsPath, mode);
+}
+
+export {
+  agentSpecs,
+  SUPPORTED_AGENTS,
+  readJsonObject,
+  writeFileAtomic,
+  writeJson,
+  buildServerEntry,
+  buildRemoteServerEntry,
+  buildTomlBlock,
+  buildRemoteTomlBlock,
+  stripTomlBlock,
+  BLOCK_START,
+  upsertMarkedBlock,
+  removeMarkedBlock,
+  buildSkillFile,
+  installInstructions,
+  installAgent,
+  installInstructionsFile,
+  resolveAgents,
+  lurqInvocation,
+  printInstallReport,
+  runInstallSkill
+};

package/dist/chunk-VL2E5T2A.js

@@ -0,0 +1,109 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  MCP_TIER,
+  contractOf,
+  resolveAnnotations
+} from "./chunk-6EQ3ARXA.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/compat/mcpStack.ts
+init_esm_shims();
+var TOKENS_PER_TOOL = 250;
+var CROWDED_TOOL_COUNT = 60;
+var NPM_NAME = /^(?:@[a-z0-9-][a-z0-9-._]*\/)?[a-z0-9-][a-z0-9-._]*$/;
+async function loadStackMembers(db, servers, tenantId = 0) {
+  const out = [];
+  for (const s of servers) {
+    if (s.tools) {
+      out.push({
+        server: s.server,
+        version: s.version,
+        tools: s.tools.map((t) => ({ name: t.name, annotations: resolveAnnotations(t.annotations) }))
+      });
+      continue;
+    }
+    const [{ enqueueSurface }, { loadStored, rowsToSurface }] = await Promise.all([
+      import("./surface-YL6O67W3.js"),
+      import("./surfaceHandlers-X2IZKA3E.js")
+    ]);
+    const stored = await loadStored(db, s.server, s.version, tenantId, "mcp_server");
+    if (!stored || stored.rows.length === 0 || stored.verdict === "verified_false") {
+      if (stored?.verdict !== "verified_false" && NPM_NAME.test(s.server)) {
+        await enqueueSurface(db, s.server, s.version, "mcp_server").catch(() => {
+        });
+      }
+      out.push({ server: s.server, version: s.version, tools: null });
+      continue;
+    }
+    const surface = rowsToSurface(s.server, s.version, stored.rows, MCP_TIER);
+    out.push({
+      server: s.server,
+      version: s.version,
+      // A symbol written by an older extractor has no contract; the spec
+      // defaults (writes, destroys) are the honest reading of "we don't know".
+      tools: surface.symbols.map((sym) => ({
+        name: sym.path,
+        annotations: contractOf(sym)?.annotations ?? resolveAnnotations(null)
+      }))
+    });
+  }
+  return out;
+}
+function analyzeStack(inputs) {
+  const members = [];
+  const unread = [];
+  const byTool = /* @__PURE__ */ new Map();
+  for (const m of inputs) {
+    if (!m.tools) {
+      unread.push(m.server);
+      members.push({ server: m.server, version: m.version, tools: null, writes: 0, destroys: 0 });
+      continue;
+    }
+    let writes = 0;
+    let destroys = 0;
+    for (const t of m.tools) {
+      const canWrite = !t.annotations.readOnlyHint;
+      if (canWrite) writes++;
+      if (t.annotations.destructiveHint) destroys++;
+      const seen = byTool.get(t.name);
+      if (seen) {
+        if (!seen.servers.includes(m.server)) seen.servers.push(m.server);
+        seen.writes ||= canWrite;
+      } else {
+        byTool.set(t.name, { servers: [m.server], writes: canWrite });
+      }
+    }
+    members.push({ server: m.server, version: m.version, tools: m.tools.length, writes, destroys });
+  }
+  const collisions = [...byTool.entries()].filter(([, v]) => v.servers.length > 1).map(([tool, v]) => ({ tool, servers: v.servers, writes: v.writes })).sort((a, b) => a.tool < b.tool ? -1 : 1);
+  const readMembers = members.filter((m) => m.tools !== null);
+  const totalTools = unread.length ? null : readMembers.reduce((n, m) => n + (m.tools ?? 0), 0);
+  const overall = collisions.length > 0 ? "conflict" : unread.length > 0 ? "unknown" : "compatible";
+  const note = collisions.length > 0 ? `${collisions.length} tool name(s) are exposed by more than one server; the agent has no way to say which one it means` : unread.length > 0 ? `${unread.length} server(s) have not been probed, so the namespace was only partly assembled \u2014 this is NOT a clean bill` : `${totalTools} tool(s) across ${readMembers.length} server(s), no name collisions`;
+  return {
+    overall,
+    members,
+    collisions,
+    totalTools,
+    estimatedContextTokens: totalTools === null ? null : totalTools * TOKENS_PER_TOOL,
+    unread,
+    note
+  };
+}
+async function checkMcpStack(db, servers, tenantId = 0) {
+  return analyzeStack(await loadStackMembers(db, servers, tenantId));
+}
+function isCrowded(report) {
+  return (report.totalTools ?? 0) >= CROWDED_TOOL_COUNT;
+}
+
+export {
+  TOKENS_PER_TOOL,
+  CROWDED_TOOL_COUNT,
+  loadStackMembers,
+  analyzeStack,
+  checkMcpStack,
+  isCrowded
+};

package/dist/chunk-VLRHFMGJ.js

@@ -0,0 +1,58 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/core/types.ts
+init_esm_shims();
+var DEFAULT_ECOSYSTEM = "npm";
+var CATEGORIES = [
+  "framework",
+  "meta-framework",
+  "state-management",
+  "routing",
+  "orm",
+  "database-client",
+  "ui-component-library",
+  "styling",
+  "forms",
+  "validation",
+  "data-fetching",
+  "http-client",
+  "auth",
+  "testing",
+  "build-tool",
+  "bundler",
+  "linting",
+  "date-time",
+  "animation",
+  "charts",
+  "i18n",
+  "utility",
+  "other"
+];
+function isCategory(value) {
+  return CATEGORIES.includes(value);
+}
+var FRONTEND_CATEGORIES = [
+  "ui-component-library",
+  "styling",
+  "state-management",
+  "forms",
+  "validation",
+  "data-fetching",
+  "charts",
+  "animation",
+  "date-time",
+  "utility"
+];
+function isFrontendCategory(category) {
+  return category != null && FRONTEND_CATEGORIES.includes(category);
+}
+
+export {
+  DEFAULT_ECOSYSTEM,
+  CATEGORIES,
+  isCategory,
+  isFrontendCategory
+};