@genrtl/grtl 0.1.0

package/dist/index.js

@@ -0,0 +1,1217 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command2 } from "commander";
+import pc6 from "picocolors";
+import figlet from "figlet";
+
+// src/commands/setup.ts
+import pc3 from "picocolors";
+import ora from "ora";
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, join as join2 } from "path";
+
+// src/utils/logger.ts
+import pc from "picocolors";
+var ANSI_PATTERN = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+function visibleLength(text) {
+  return text.replace(ANSI_PATTERN, "").length;
+}
+function padVisible(text, width) {
+  const padding = Math.max(0, width - visibleLength(text));
+  return text + " ".repeat(padding);
+}
+function box(lines, color = pc.green) {
+  const contentWidth = Math.max(...lines.map((line) => visibleLength(line)), 0);
+  const top = color(`\u250C${"\u2500".repeat(contentWidth + 2)}\u2510`);
+  const bottom = color(`\u2514${"\u2500".repeat(contentWidth + 2)}\u2518`);
+  console.log(top);
+  for (const line of lines) {
+    console.log(color("\u2502 ") + padVisible(line, contentWidth) + color(" \u2502"));
+  }
+  console.log(bottom);
+}
+var log = {
+  info: (message) => console.log(pc.cyan(message)),
+  success: (message) => console.log(pc.green(`\u2714 ${message}`)),
+  warn: (message) => console.log(pc.yellow(`\u26A0 ${message}`)),
+  error: (message) => console.log(pc.red(`\u2716 ${message}`)),
+  dim: (message) => console.log(pc.dim(message)),
+  item: (message) => console.log(pc.green(`  ${message}`)),
+  itemAdd: (message) => console.log(`  ${pc.green("+")} ${message}`),
+  plain: (message) => console.log(message),
+  blank: () => console.log(""),
+  box
+};
+
+// src/utils/prompts.ts
+import pc2 from "picocolors";
+import { checkbox } from "@inquirer/prompts";
+import readline from "readline";
+async function checkboxWithHover(config, options) {
+  const choices = config.choices.filter(
+    (c) => typeof c === "object" && c !== null && !("type" in c && c.type === "separator")
+  );
+  const values = choices.map((c) => c.value);
+  const totalItems = values.length;
+  let cursorPosition = choices.findIndex((c) => !c.disabled);
+  if (cursorPosition < 0) cursorPosition = 0;
+  const getName = options?.getName ?? ((v) => v.name);
+  const keypressHandler = (_str, key) => {
+    if (key.name === "up") {
+      let next = cursorPosition - 1;
+      while (next >= 0 && choices[next].disabled) next--;
+      if (next >= 0) cursorPosition = next;
+    } else if (key.name === "down") {
+      let next = cursorPosition + 1;
+      while (next < totalItems && choices[next].disabled) next++;
+      if (next < totalItems) cursorPosition = next;
+    }
+  };
+  readline.emitKeypressEvents(process.stdin);
+  process.stdin.on("keypress", keypressHandler);
+  const customConfig = {
+    ...config,
+    theme: {
+      ...config.theme,
+      style: {
+        answer: (text) => pc2.green(text),
+        ...config.theme?.style,
+        highlight: (text) => pc2.green(text),
+        renderSelectedChoices: (selected, _allChoices) => {
+          if (selected.length === 0) {
+            return pc2.dim(getName(values[cursorPosition]));
+          }
+          return selected.map((c) => getName(c.value)).join(", ");
+        }
+      }
+    }
+  };
+  try {
+    const selected = await checkbox(customConfig);
+    if (selected.length === 0) {
+      return [values[cursorPosition]];
+    }
+    return selected;
+  } finally {
+    process.stdin.removeListener("keypress", keypressHandler);
+  }
+}
+
+// src/utils/tracking.ts
+function trackEvent(_event, _data) {
+}
+
+// src/setup/http-agents.ts
+import { access } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+var SETUP_AGENT_NAMES = {
+  claude: "Claude Code",
+  cursor: "Cursor",
+  opencode: "OpenCode",
+  codex: "Codex",
+  antigravity: "Antigravity",
+  gemini: "Gemini CLI"
+};
+var mcpBaseUrl = "https://www.genrtl.com/api/mcp";
+function setMcpBaseUrl(url) {
+  const normalized = url.replace(/\/+$/, "");
+  mcpBaseUrl = normalized.endsWith("/api/mcp") ? normalized : `${normalized}/api/mcp`;
+}
+function headers(auth) {
+  return { Authorization: `Bearer ${auth.apiKey}` };
+}
+function claudeConfigDir() {
+  return process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+}
+function claudeGlobalMcpPath() {
+  return process.env.CLAUDE_CONFIG_DIR ? join(claudeConfigDir(), ".claude.json") : join(homedir(), ".claude.json");
+}
+var agents = {
+  claude: {
+    name: "claude",
+    displayName: "Claude Code",
+    mcp: {
+      projectPaths: [".mcp.json"],
+      get globalPaths() {
+        return [claudeGlobalMcpPath()];
+      },
+      configKey: "mcpServers",
+      buildEntry: (auth) => ({
+        type: "http",
+        url: mcpBaseUrl,
+        headers: headers(auth)
+      })
+    },
+    rule: {
+      kind: "file",
+      dir: (scope) => scope === "global" ? join(claudeConfigDir(), "rules") : join(".claude", "rules"),
+      filename: "genrtl.md"
+    },
+    detect: {
+      projectPaths: [".mcp.json", ".claude"],
+      get globalPaths() {
+        return [claudeConfigDir()];
+      }
+    }
+  },
+  cursor: {
+    name: "cursor",
+    displayName: "Cursor",
+    mcp: {
+      projectPaths: [join(".cursor", "mcp.json")],
+      globalPaths: [join(homedir(), ".cursor", "mcp.json")],
+      configKey: "mcpServers",
+      buildEntry: (auth) => ({ url: mcpBaseUrl, headers: headers(auth) })
+    },
+    rule: {
+      kind: "file",
+      dir: (scope) => scope === "global" ? join(homedir(), ".cursor", "rules") : join(".cursor", "rules"),
+      filename: "genrtl.mdc"
+    },
+    detect: {
+      projectPaths: [".cursor"],
+      globalPaths: [join(homedir(), ".cursor")]
+    }
+  },
+  opencode: {
+    name: "opencode",
+    displayName: "OpenCode",
+    mcp: {
+      projectPaths: ["opencode.json", "opencode.jsonc", ".opencode.json", ".opencode.jsonc"],
+      globalPaths: [
+        join(homedir(), ".config", "opencode", "opencode.json"),
+        join(homedir(), ".config", "opencode", "opencode.jsonc"),
+        join(homedir(), ".config", "opencode", ".opencode.json"),
+        join(homedir(), ".config", "opencode", ".opencode.jsonc")
+      ],
+      configKey: "mcp",
+      buildEntry: (auth) => ({
+        type: "remote",
+        url: mcpBaseUrl,
+        enabled: true,
+        headers: headers(auth)
+      })
+    },
+    rule: {
+      kind: "append",
+      file: (scope) => scope === "global" ? join(homedir(), ".config", "opencode", "AGENTS.md") : "AGENTS.md",
+      sectionMarker: "<!-- genrtl -->"
+    },
+    detect: {
+      projectPaths: ["opencode.json", "opencode.jsonc", ".opencode.json", ".opencode.jsonc"],
+      globalPaths: [join(homedir(), ".config", "opencode")]
+    }
+  },
+  codex: {
+    name: "codex",
+    displayName: "Codex",
+    mcp: {
+      projectPaths: [join(".codex", "config.toml")],
+      globalPaths: [join(homedir(), ".codex", "config.toml")],
+      configKey: "mcp_servers",
+      buildEntry: (auth) => auth.apiKeyEnvVar ? {
+        type: "http",
+        url: mcpBaseUrl,
+        bearer_token_env_var: auth.apiKeyEnvVar
+      } : {
+        type: "http",
+        url: mcpBaseUrl,
+        headers: headers(auth)
+      }
+    },
+    rule: {
+      kind: "append",
+      file: (scope) => scope === "global" ? join(homedir(), ".codex", "AGENTS.md") : "AGENTS.md",
+      sectionMarker: "<!-- genrtl -->"
+    },
+    detect: {
+      projectPaths: [".codex"],
+      globalPaths: [join(homedir(), ".codex")]
+    }
+  },
+  antigravity: {
+    name: "antigravity",
+    displayName: "Antigravity",
+    mcp: {
+      projectPaths: [],
+      globalPaths: [join(homedir(), ".gemini", "antigravity", "mcp_config.json")],
+      configKey: "mcpServers",
+      buildEntry: (auth) => ({ serverUrl: mcpBaseUrl, headers: headers(auth) })
+    },
+    rule: {
+      kind: "append",
+      file: (scope) => scope === "global" ? join(homedir(), ".gemini", "GEMINI.md") : "GEMINI.md",
+      sectionMarker: "<!-- genrtl -->"
+    },
+    detect: {
+      projectPaths: [".agent"],
+      globalPaths: [join(homedir(), ".gemini", "antigravity"), join(homedir(), ".agent")]
+    }
+  },
+  gemini: {
+    name: "gemini",
+    displayName: "Gemini CLI",
+    mcp: {
+      projectPaths: [join(".gemini", "settings.json")],
+      globalPaths: [join(homedir(), ".gemini", "settings.json")],
+      configKey: "mcpServers",
+      buildEntry: (auth) => ({ httpUrl: mcpBaseUrl, headers: headers(auth) })
+    },
+    rule: {
+      kind: "append",
+      file: (scope) => scope === "global" ? join(homedir(), ".gemini", "GEMINI.md") : "GEMINI.md",
+      sectionMarker: "<!-- genrtl -->"
+    },
+    detect: {
+      projectPaths: [".gemini"],
+      globalPaths: [join(homedir(), ".gemini")]
+    }
+  }
+};
+function getAgent(name) {
+  return agents[name];
+}
+var ALL_AGENT_NAMES = Object.keys(agents);
+async function pathExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectAgents(scope) {
+  const detected = [];
+  for (const agent of Object.values(agents)) {
+    const paths = scope === "global" ? agent.detect.globalPaths : agent.detect.projectPaths;
+    for (const path of paths) {
+      const fullPath = scope === "global" ? path : join(process.cwd(), path);
+      if (await pathExists(fullPath)) {
+        detected.push(agent.name);
+        break;
+      }
+    }
+  }
+  return detected;
+}
+
+// src/setup/templates.ts
+var GITHUB_RAW_URLS = ["https://raw.githubusercontent.com/xroting/grtl/main/rules"];
+var FALLBACK_MCP = `Use GenRTL MCP tools for grounded RTL engineering knowledge.
+
+Choose one tool:
+- \`genrtl_knowledge_search\` for cross-domain RTL questions
+- \`genrtl_spec2rtl_search\` for requirements and RTL design
+- \`genrtl_verification_search\` for testbenches and verification
+- \`genrtl_debug_search\` for lint, CDC, compile, synthesis, and RTL bugs
+
+Pass the complete engineering question in \`query\`. Add filters only when useful.`;
+var FALLBACK_CLI = `Use the \`grtl\` CLI for grounded RTL engineering knowledge.
+
+Choose one command:
+- \`npx @genrtl/grtl@latest knowledge-search "<query>"\`
+- \`npx @genrtl/grtl@latest spec2rtl-search "<query>"\`
+- \`npx @genrtl/grtl@latest verification-search "<query>"\`
+- \`npx @genrtl/grtl@latest debug-search "<query>"\`
+
+Pass the complete engineering question. Add filters such as \`--tool\`,
+\`--tool-version\`, \`--target\`, \`--interface\`, or \`--tag\` when known.
+If authentication fails, set \`GRTL_API_KEY\`.`;
+var CURSOR_FRONTMATTER = `---
+alwaysApply: true
+---
+
+`;
+var CODEX_CLI_SANDBOX_GUIDANCE = `Run GenRTL CLI requests outside Codex's default sandbox. If a GenRTL CLI command fails with DNS or network errors such as ENOTFOUND, host resolution failures, or fetch failed, rerun it outside the sandbox instead of retrying inside the sandbox.`;
+async function fetchRule(filename, fallback) {
+  for (const base of GITHUB_RAW_URLS) {
+    try {
+      const res = await fetch(`${base}/${filename}`);
+      if (res.ok) return await res.text();
+    } catch {
+      continue;
+    }
+  }
+  return fallback;
+}
+async function getRuleContent(mode, agent) {
+  const [filename, fallback] = mode === "mcp" ? ["genrtl-mcp.md", FALLBACK_MCP] : ["genrtl-cli.md", FALLBACK_CLI];
+  let body = await fetchRule(filename, fallback);
+  if (mode === "cli" && agent === "codex" && !body.includes(CODEX_CLI_SANDBOX_GUIDANCE)) {
+    body = `${body.trimEnd()}
+${CODEX_CLI_SANDBOX_GUIDANCE}
+`;
+  }
+  return agent === "cursor" ? `${CURSOR_FRONTMATTER}${body}` : body;
+}
+
+// src/setup/mcp-writer.ts
+import { access as access2, readFile, writeFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+function stripJsonComments(text) {
+  let result = "";
+  let i = 0;
+  while (i < text.length) {
+    if (text[i] === '"') {
+      const start = i++;
+      while (i < text.length && text[i] !== '"') {
+        if (text[i] === "\\") i++;
+        i++;
+      }
+      result += text.slice(start, ++i);
+    } else if (text[i] === "/" && text[i + 1] === "/") {
+      i += 2;
+      while (i < text.length && text[i] !== "\n") i++;
+    } else if (text[i] === "/" && text[i + 1] === "*") {
+      i += 2;
+      while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) i++;
+      i += 2;
+    } else {
+      result += text[i++];
+    }
+  }
+  return result;
+}
+async function readJsonConfig(filePath) {
+  let raw;
+  try {
+    raw = await readFile(filePath, "utf-8");
+  } catch {
+    return {};
+  }
+  raw = raw.trim();
+  if (!raw) return {};
+  return JSON.parse(stripJsonComments(raw));
+}
+function mergeServerEntry(existing, configKey, serverName, entry) {
+  const section = existing[configKey] ?? {};
+  const alreadyExists = serverName in section;
+  return {
+    config: {
+      ...existing,
+      [configKey]: {
+        ...section,
+        [serverName]: entry
+      }
+    },
+    alreadyExists
+  };
+}
+async function resolveMcpPath(candidates) {
+  for (const candidate of candidates) {
+    try {
+      await access2(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  return candidates[0];
+}
+async function writeJsonConfig(filePath, config) {
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function buildTomlServerBlock(serverName, entry) {
+  const lines = [`[mcp_servers.${serverName}]`];
+  const headers2 = entry.headers;
+  for (const [key, value] of Object.entries(entry)) {
+    if (key === "headers") continue;
+    lines.push(`${key} = ${JSON.stringify(value)}`);
+  }
+  if (headers2 && Object.keys(headers2).length > 0) {
+    lines.push("");
+    lines.push(`[mcp_servers.${serverName}.http_headers]`);
+    for (const [key, value] of Object.entries(headers2)) {
+      lines.push(`${key} = ${JSON.stringify(value)}`);
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+async function appendTomlServer(filePath, serverName, entry) {
+  const block = buildTomlServerBlock(serverName, entry);
+  let existing = "";
+  try {
+    existing = await readFile(filePath, "utf-8");
+  } catch {
+  }
+  const sectionHeader = `[mcp_servers.${serverName}]`;
+  const alreadyExists = existing.includes(sectionHeader);
+  if (alreadyExists) {
+    const subPrefix = `[mcp_servers.${serverName}.`;
+    const startIdx = existing.indexOf(sectionHeader);
+    const rest = existing.slice(startIdx + sectionHeader.length);
+    let endOffset = rest.length;
+    const re = /^\[/gm;
+    let m;
+    while ((m = re.exec(rest)) !== null) {
+      const lineEnd = rest.indexOf("\n", m.index);
+      const line = rest.slice(m.index, lineEnd === -1 ? void 0 : lineEnd);
+      if (!line.startsWith(subPrefix)) {
+        endOffset = m.index;
+        break;
+      }
+    }
+    const rawBefore = existing.slice(0, startIdx).replace(/\n+$/, "");
+    const rawAfter = existing.slice(startIdx + sectionHeader.length + endOffset).replace(/^\n+/, "");
+    const before = rawBefore.length > 0 ? rawBefore + "\n\n" : "";
+    const after = rawAfter.length > 0 ? "\n" + rawAfter : "";
+    const content = before + block + after;
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, content, "utf-8");
+  } else {
+    const separator = existing.length > 0 && !existing.endsWith("\n") ? "\n\n" : existing.length > 0 ? "\n" : "";
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, existing + separator + block, "utf-8");
+  }
+  return { alreadyExists };
+}
+
+// src/commands/setup.ts
+var CHECKBOX_THEME = {
+  style: {
+    highlight: (text) => pc3.green(text),
+    disabledChoice: (text) => ` ${pc3.dim("-")} ${pc3.dim(text)}`
+  }
+};
+function getSelectedAgents(options) {
+  const agents2 = [];
+  if (options.claude) agents2.push("claude");
+  if (options.cursor) agents2.push("cursor");
+  if (options.opencode) agents2.push("opencode");
+  if (options.codex) agents2.push("codex");
+  if (options.antigravity) agents2.push("antigravity");
+  if (options.gemini) agents2.push("gemini");
+  return agents2;
+}
+function resolveSetupAuth(options) {
+  if (options.apiKey) return { apiKey: options.apiKey };
+  if (process.env.GRTL_API_KEY) {
+    return { apiKey: process.env.GRTL_API_KEY, apiKeyEnvVar: "GRTL_API_KEY" };
+  }
+  if (process.env.GENRTL_API_KEY) {
+    return { apiKey: process.env.GENRTL_API_KEY, apiKeyEnvVar: "GENRTL_API_KEY" };
+  }
+  return void 0;
+}
+function registerSetupCommand(program2) {
+  program2.command("setup").description("Configure the hosted GenRTL HTTP MCP server for a coding agent").option("--claude", "Set up Claude Code").option("--cursor", "Set up Cursor").option("--antigravity", "Set up Antigravity").option("--opencode", "Set up OpenCode").option("--codex", "Set up Codex").option("--gemini", "Set up Gemini CLI").option("-p, --project", "Configure the current project instead of the user profile").option("-y, --yes", "Use all detected agents without prompting").option("--api-key <key>", "GenRTL API key (prefer the GRTL_API_KEY environment variable)").action(async (options) => {
+    await setupCommand(options);
+  });
+}
+async function promptAgents() {
+  try {
+    return await checkboxWithHover(
+      {
+        message: "Which agents do you want to set up?",
+        choices: ALL_AGENT_NAMES.map((name) => ({
+          name: SETUP_AGENT_NAMES[name],
+          value: name
+        })),
+        loop: false,
+        theme: CHECKBOX_THEME
+      },
+      { getName: (agent) => SETUP_AGENT_NAMES[agent] }
+    );
+  } catch {
+    return null;
+  }
+}
+async function resolveAgents(options, scope) {
+  const explicit = getSelectedAgents(options);
+  if (explicit.length > 0) return explicit;
+  const detected = await detectAgents(scope);
+  if (detected.length > 0 && options.yes) return detected;
+  if (options.yes) {
+    log.error("No supported coding agents were detected. Pass an agent flag such as --cursor.");
+    return [];
+  }
+  log.blank();
+  const selected = await promptAgents();
+  if (!selected) log.warn("Setup cancelled");
+  return selected ?? [];
+}
+async function installRule(agentName, scope) {
+  const rule = getAgent(agentName).rule;
+  const content = await getRuleContent("mcp", agentName);
+  if (rule.kind === "file") {
+    const ruleDir = scope === "global" ? rule.dir("global") : join2(process.cwd(), rule.dir("project"));
+    const rulePath = join2(ruleDir, rule.filename);
+    await mkdir2(dirname2(rulePath), { recursive: true });
+    await writeFile2(rulePath, content, "utf-8");
+    return { status: "installed", path: rulePath };
+  }
+  const filePath = scope === "global" ? rule.file("global") : join2(process.cwd(), rule.file("project"));
+  const escapedMarker = rule.sectionMarker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const section = `${rule.sectionMarker}
+${content.trimEnd()}
+${rule.sectionMarker}`;
+  let existing = "";
+  try {
+    existing = await readFile2(filePath, "utf-8");
+  } catch {
+  }
+  if (existing.includes(rule.sectionMarker)) {
+    const regex = new RegExp(`${escapedMarker}\\n[\\s\\S]*?${escapedMarker}`);
+    await writeFile2(filePath, existing.replace(regex, section), "utf-8");
+    return { status: "updated", path: filePath };
+  }
+  const separator = existing.length > 0 && !existing.endsWith("\n") ? "\n\n" : existing.length > 0 ? "\n" : "";
+  await mkdir2(dirname2(filePath), { recursive: true });
+  await writeFile2(filePath, `${existing}${separator}${section}
+`, "utf-8");
+  return { status: "installed", path: filePath };
+}
+async function setupAgent(agentName, auth, scope) {
+  const agent = getAgent(agentName);
+  const candidates = scope === "global" || agent.mcp.projectPaths.length === 0 ? agent.mcp.globalPaths : agent.mcp.projectPaths.map((path) => join2(process.cwd(), path));
+  const mcpPath = await resolveMcpPath(candidates);
+  const entry = agent.mcp.buildEntry(auth);
+  let mcpStatus;
+  try {
+    if (mcpPath.endsWith(".toml")) {
+      const { alreadyExists } = await appendTomlServer(mcpPath, "genrtl", entry);
+      mcpStatus = alreadyExists ? "reconfigured" : "configured";
+    } else {
+      const existing = await readJsonConfig(mcpPath);
+      const { config, alreadyExists } = mergeServerEntry(
+        existing,
+        agent.mcp.configKey,
+        "genrtl",
+        entry
+      );
+      await writeJsonConfig(mcpPath, config);
+      mcpStatus = alreadyExists ? "reconfigured" : "configured";
+    }
+  } catch (error) {
+    mcpStatus = `failed: ${error instanceof Error ? error.message : String(error)}`;
+  }
+  let ruleStatus;
+  let rulePath = "";
+  try {
+    const result = await installRule(agentName, scope);
+    ruleStatus = result.status;
+    rulePath = result.path;
+  } catch (error) {
+    ruleStatus = `failed: ${error instanceof Error ? error.message : String(error)}`;
+  }
+  return { agent: agent.displayName, mcpStatus, mcpPath, ruleStatus, rulePath };
+}
+async function setupCommand(options) {
+  trackEvent("command", { name: "setup" });
+  const auth = resolveSetupAuth(options);
+  if (!auth) {
+    log.error("Set GRTL_API_KEY or pass --api-key before running setup.");
+    process.exitCode = 1;
+    return;
+  }
+  const scope = options.project ? "project" : "global";
+  const agents2 = await resolveAgents(options, scope);
+  if (agents2.length === 0) return;
+  const spinner = ora("Configuring GenRTL MCP...").start();
+  const results = [];
+  for (const agentName of agents2) {
+    spinner.text = `Configuring ${getAgent(agentName).displayName}...`;
+    results.push(await setupAgent(agentName, auth, scope));
+  }
+  const failed = results.some(
+    (result) => result.mcpStatus.startsWith("failed") || result.ruleStatus.startsWith("failed")
+  );
+  if (failed) {
+    spinner.warn("GenRTL setup completed with errors");
+    process.exitCode = 1;
+  } else {
+    spinner.succeed("GenRTL setup complete");
+  }
+  log.blank();
+  for (const result of results) {
+    log.plain(`  ${pc3.bold(result.agent)}`);
+    log.plain(`    ${pc3.green("+")} MCP server ${result.mcpStatus}`);
+    log.plain(`      ${pc3.dim(result.mcpPath)}`);
+    log.plain(`    ${pc3.green("+")} Rule ${result.ruleStatus}`);
+    log.plain(`      ${pc3.dim(result.rulePath)}`);
+  }
+  log.blank();
+  trackEvent("setup", { agents: agents2, scope, authMode: "api-key" });
+}
+
+// src/commands/knowledge.ts
+import { InvalidArgumentError } from "commander";
+import pc4 from "picocolors";
+import ora2 from "ora";
+
+// src/constants.ts
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname as dirname3, join as join3 } from "path";
+var __dirname = dirname3(fileURLToPath(import.meta.url));
+var pkg = JSON.parse(readFileSync(join3(__dirname, "../package.json"), "utf-8"));
+var VERSION = pkg.version;
+var NAME = pkg.name;
+
+// src/utils/knowledge-api.ts
+var baseUrl = "https://www.genrtl.com";
+function setBaseUrl(url) {
+  baseUrl = url.replace(/\/+$/, "");
+}
+function getMcpEndpoint() {
+  return baseUrl.endsWith("/api/mcp") ? baseUrl : `${baseUrl}/api/mcp`;
+}
+function getApiKey() {
+  return process.env.GRTL_API_KEY || process.env.GENRTL_API_KEY;
+}
+function getMcpErrorMessage(content) {
+  if (!Array.isArray(content)) return void 0;
+  const item = content.find(
+    (entry) => entry && typeof entry === "object" && "type" in entry && entry.type === "text" && "text" in entry && typeof entry.text === "string"
+  );
+  return item?.text;
+}
+async function callGenrtlKnowledgeTool(toolName, input) {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    throw new Error("Authentication required. Set GRTL_API_KEY or GENRTL_API_KEY.");
+  }
+  const response = await fetch(getMcpEndpoint(), {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`,
+      "MCP-Protocol-Version": "2025-06-18",
+      "X-GenRTL-Source": "cli",
+      "X-GenRTL-Client-Version": VERSION
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "tools/call",
+      params: { name: toolName, arguments: input }
+    })
+  });
+  const payload = await response.json().catch(() => null);
+  if (!response.ok || payload?.error) {
+    const message = payload?.error?.message || `GenRTL MCP request failed with HTTP ${response.status}`;
+    const code = payload?.error?.data?.code;
+    throw new Error(code ? `${message} (${code})` : message);
+  }
+  const result = payload?.result;
+  if (!result) throw new Error("GenRTL MCP returned an empty result.");
+  if (result.isError) {
+    throw new Error(getMcpErrorMessage(result.content) || "GenRTL knowledge search failed.");
+  }
+  if (!result.structuredContent) {
+    throw new Error("GenRTL MCP response did not include structured knowledge results.");
+  }
+  return result.structuredContent;
+}
+
+// src/commands/knowledge.ts
+var isTTY = process.stdout.isTTY;
+var TOOL_COMMANDS = [
+  {
+    name: "genrtl_knowledge_search",
+    alias: "knowledge-search",
+    description: "Search all approved GenRTL knowledge cards"
+  },
+  {
+    name: "genrtl_spec2rtl_search",
+    alias: "spec2rtl-search",
+    description: "Search Spec2RTL knowledge cards"
+  },
+  {
+    name: "genrtl_verification_search",
+    alias: "verification-search",
+    description: "Search verification and testbench knowledge cards"
+  },
+  {
+    name: "genrtl_debug_search",
+    alias: "debug-search",
+    description: "Search lint, CDC, compile, synthesis, and RTL debug knowledge cards"
+  }
+];
+function parseInteger(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed)) {
+    throw new InvalidArgumentError("Expected an integer.");
+  }
+  return parsed;
+}
+function parseNumber(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    throw new InvalidArgumentError("Expected a number.");
+  }
+  return parsed;
+}
+function buildKnowledgeSearchInput(query, options) {
+  if (options.topK !== void 0 && (options.topK < 1 || options.topK > 20)) {
+    throw new InvalidArgumentError("--top-k must be between 1 and 20.");
+  }
+  if (options.minScore !== void 0 && (options.minScore < 0 || options.minScore > 1)) {
+    throw new InvalidArgumentError("--min-score must be between 0 and 1.");
+  }
+  if (options.target && !["fpga", "asic", "both"].includes(options.target)) {
+    throw new InvalidArgumentError("--target must be fpga, asic, or both.");
+  }
+  const filters = {};
+  if (options.type?.length) {
+    const allowed = /* @__PURE__ */ new Set(["spec2rtl", "verification", "debug"]);
+    const invalid = options.type.find((type) => !allowed.has(type));
+    if (invalid) {
+      throw new InvalidArgumentError(`Invalid knowledge type: ${invalid}`);
+    }
+    filters.types = options.type;
+  }
+  if (options.domain) filters.domain = options.domain;
+  if (options.tool) filters.tool = options.tool;
+  if (options.toolVersion) filters.tool_version = options.toolVersion;
+  if (options.errorType) filters.error_type = options.errorType;
+  if (options.severity) filters.severity = options.severity;
+  if (options.interface) filters.interface = options.interface;
+  if (options.target) filters.target = options.target;
+  if (options.tag?.length) filters.tags = options.tag;
+  return {
+    query,
+    ...Object.keys(filters).length > 0 ? { filters } : {},
+    ...options.topK !== void 0 ? { top_k: options.topK } : {},
+    ...options.minScore !== void 0 ? { min_score: options.minScore } : {},
+    ...options.workspaceId ? { workspace_id: options.workspaceId } : {}
+  };
+}
+function formatMatch(match, index) {
+  const lines = [
+    `${pc4.dim(`${index + 1}.`)} ${pc4.bold(match.title)} ${pc4.cyan(`[${match.type}]`)}`,
+    `   ${pc4.dim(`Confidence: ${Math.round(match.confidence * 100)}%`)}`,
+    `   ${match.summary}`
+  ];
+  if (match.root_cause) lines.push(`   ${pc4.bold("Root cause:")} ${match.root_cause}`);
+  if (match.fix_strategy?.length) {
+    lines.push(`   ${pc4.bold("Fix strategy:")} ${match.fix_strategy.join("; ")}`);
+  }
+  if (match.code_example) {
+    lines.push("", "```systemverilog", match.code_example, "```");
+  }
+  if (match.recommended_next_action) {
+    lines.push(`   ${pc4.bold("Next:")} ${match.recommended_next_action}`);
+  }
+  return lines.join("\n");
+}
+async function searchCommand(toolName, query, options) {
+  trackEvent("command", { name: toolName });
+  const spinner = isTTY ? ora2("Searching GenRTL knowledge...").start() : null;
+  try {
+    const input = buildKnowledgeSearchInput(query, options);
+    const result = await callGenrtlKnowledgeTool(toolName, input);
+    spinner?.stop();
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    printKnowledgeResult(result);
+  } catch (err) {
+    spinner?.fail(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    if (!spinner) log.error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+  }
+}
+function printKnowledgeResult(result) {
+  log.blank();
+  log.plain(pc4.bold(result.summary));
+  log.blank();
+  if (result.matched_cards.length === 0) {
+    log.warn("No matching GenRTL knowledge cards were found.");
+  } else {
+    result.matched_cards.forEach((match, index) => {
+      log.plain(formatMatch(match, index));
+      log.blank();
+    });
+  }
+  if (result.recommended_next_action) {
+    log.plain(`${pc4.bold("Recommended next action:")} ${result.recommended_next_action}`);
+    log.blank();
+  }
+}
+function addSearchOptions(command) {
+  return command.argument("<query>", "Natural-language RTL engineering question or diagnostic").option("--type <type...>", "Knowledge types: spec2rtl, verification, debug").option("--domain <domain>", "Filter by engineering domain").option("--tool <tool>", "Filter by EDA tool").option("--tool-version <version>", "Filter by EDA tool version").option("--error-type <type>", "Filter by error type").option("--severity <severity>", "Filter by severity").option("--interface <interface>", "Filter by hardware interface").option("--target <target>", "Filter by target: fpga, asic, or both").option("--tag <tag...>", "Filter by one or more tags").option("--top-k <count>", "Maximum results (1-20)", parseInteger).option("--min-score <score>", "Minimum similarity score (0-1)", parseNumber).option("--workspace-id <id>", "GenRTL workspace ID").option("--json", "Output the structured MCP result as JSON");
+}
+function registerKnowledgeCommands(program2) {
+  for (const tool of TOOL_COMMANDS) {
+    const command = program2.command(tool.name).alias(tool.alias).description(tool.description);
+    addSearchOptions(command).action(async (query, options) => {
+      await searchCommand(tool.name, query, options);
+    });
+  }
+}
+
+// src/commands/upgrade.ts
+import { confirm } from "@inquirer/prompts";
+import { spawn } from "child_process";
+import pc5 from "picocolors";
+
+// src/utils/update-check.ts
+import { homedir as homedir2 } from "os";
+import { dirname as dirname4, join as join4 } from "path";
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+var DEFAULT_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var UPDATE_STATE_FILE = join4(homedir2(), ".genrtl", "cli-state.json");
+function getStateFilePath(stateFile) {
+  return stateFile ?? UPDATE_STATE_FILE;
+}
+async function readUpdateState(stateFile) {
+  try {
+    const raw = await readFile3(getStateFilePath(stateFile), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function writeUpdateState(state, stateFile) {
+  const path = getStateFilePath(stateFile);
+  await mkdir3(dirname4(path), { recursive: true });
+  await writeFile3(path, JSON.stringify(state, null, 2) + "\n", "utf-8");
+}
+function compareVersions(a, b) {
+  const normalize = (version) => version.split("-", 1)[0].split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const left = normalize(a);
+  const right = normalize(b);
+  const max = Math.max(left.length, right.length);
+  for (let i = 0; i < max; i++) {
+    const diff = (left[i] ?? 0) - (right[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+function detectInstallMethod(env = process.env) {
+  const execPath = env.npm_execpath?.toLowerCase() ?? "";
+  const npmCommand = env.npm_command?.toLowerCase() ?? "";
+  const userAgent = env.npm_config_user_agent?.toLowerCase() ?? "";
+  if (execPath.includes("pnpm") && npmCommand === "dlx") return "pnpm-dlx";
+  if (execPath.includes("pnpm")) return "pnpm-global";
+  if (execPath.includes("bun") && npmCommand === "x") return "bunx";
+  if (execPath.includes("bun")) return "bun-global";
+  if (execPath.includes("npm") && npmCommand === "exec") return "npx";
+  if (execPath.includes("npm")) return "npm-global";
+  if (userAgent.startsWith("pnpm/")) return "pnpm-global";
+  if (userAgent.startsWith("bun/")) return "bun-global";
+  if (userAgent.startsWith("npm/")) return "npm-global";
+  return "unknown";
+}
+function getUpgradePlan(installMethod = detectInstallMethod(), packageName = NAME) {
+  switch (installMethod) {
+    case "pnpm-global":
+      return {
+        installMethod,
+        command: "pnpm",
+        args: ["add", "-g", `${packageName}@latest`],
+        displayCommand: `pnpm add -g ${packageName}@latest`,
+        canRun: true,
+        needsExplicitVersion: false
+      };
+    case "bun-global":
+      return {
+        installMethod,
+        command: "bun",
+        args: ["add", "-g", `${packageName}@latest`],
+        displayCommand: `bun add -g ${packageName}@latest`,
+        canRun: true,
+        needsExplicitVersion: false
+      };
+    case "npx":
+      return {
+        installMethod,
+        command: "npx",
+        args: [`${packageName}@latest`],
+        displayCommand: `npx ${packageName}@latest <command>`,
+        canRun: false,
+        needsExplicitVersion: true
+      };
+    case "pnpm-dlx":
+      return {
+        installMethod,
+        command: "pnpm",
+        args: ["dlx", `${packageName}@latest`],
+        displayCommand: `pnpm dlx ${packageName}@latest <command>`,
+        canRun: false,
+        needsExplicitVersion: true
+      };
+    case "bunx":
+      return {
+        installMethod,
+        command: "bunx",
+        args: [`${packageName}@latest`],
+        displayCommand: `bunx ${packageName}@latest <command>`,
+        canRun: false,
+        needsExplicitVersion: true
+      };
+    case "unknown":
+      return {
+        installMethod,
+        command: "npm",
+        args: ["install", "-g", `${packageName}@latest`],
+        displayCommand: `npm install -g ${packageName}@latest`,
+        canRun: false,
+        needsExplicitVersion: false
+      };
+    case "npm-global":
+    default:
+      return {
+        installMethod: "npm-global",
+        command: "npm",
+        args: ["install", "-g", `${packageName}@latest`],
+        displayCommand: `npm install -g ${packageName}@latest`,
+        canRun: true,
+        needsExplicitVersion: false
+      };
+  }
+}
+async function fetchLatestVersion(packageName = NAME) {
+  try {
+    const response = await fetch(
+      `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`,
+      {
+        headers: { Accept: "application/json" },
+        signal: AbortSignal.timeout(1500)
+      }
+    );
+    if (!response.ok) return null;
+    const data = await response.json();
+    return typeof data.version === "string" ? data.version : null;
+  } catch {
+    return null;
+  }
+}
+async function checkForUpdates(options = {}) {
+  const now = options.now ?? Date.now();
+  const cacheTtlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
+  const stateFile = options.stateFile;
+  const state = await readUpdateState(stateFile);
+  const isStale = options.force || !state.lastCheckedAt || now - state.lastCheckedAt >= cacheTtlMs || !state.latestVersion;
+  let latestVersion = state.latestVersion ?? null;
+  if (isStale) {
+    const fetchedVersion = await fetchLatestVersion();
+    if (fetchedVersion) {
+      latestVersion = fetchedVersion;
+      await writeUpdateState(
+        {
+          ...state,
+          latestVersion: fetchedVersion,
+          lastCheckedAt: now
+        },
+        stateFile
+      );
+    }
+  }
+  if (!latestVersion) return null;
+  const installMethod = detectInstallMethod();
+  return {
+    currentVersion: VERSION,
+    latestVersion,
+    updateAvailable: compareVersions(latestVersion, VERSION) > 0,
+    installMethod,
+    upgradePlan: getUpgradePlan(installMethod)
+  };
+}
+async function shouldShowUpdateNotification(info, options = {}) {
+  if (!info.updateAvailable) return false;
+  const now = options.now ?? Date.now();
+  const cooldownMs = options.cooldownMs ?? DEFAULT_CACHE_TTL_MS;
+  const state = await readUpdateState(options.stateFile);
+  if (state.notifiedVersion === info.latestVersion && state.lastNotifiedAt && now - state.lastNotifiedAt < cooldownMs) {
+    return false;
+  }
+  return true;
+}
+async function markUpdateNotificationShown(latestVersion, options = {}) {
+  const now = options.now ?? Date.now();
+  const state = await readUpdateState(options.stateFile);
+  await writeUpdateState(
+    {
+      ...state,
+      notifiedVersion: latestVersion,
+      lastNotifiedAt: now
+    },
+    options.stateFile
+  );
+}
+function shouldSkipUpdateNotifier(argv = process.argv) {
+  return argv.includes("--json") || argv.includes("-v") || argv.includes("--version");
+}
+
+// src/commands/upgrade.ts
+function registerUpgradeCommand(program2) {
+  program2.command("upgrade").description("Check for a newer grtl version and upgrade when possible").option("-y, --yes", "Run the suggested upgrade command without prompting").option("--check", "Only check for updates without running the upgrade command").action(async (options) => {
+    await upgradeCommand(options);
+  });
+}
+function runCommand(command, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve(code));
+  });
+}
+async function runUpgradePlan(plan) {
+  return runCommand(plan.command, plan.args);
+}
+function showUpgradeFailureHelp(plan) {
+  log.info(`Try rerunning: ${pc5.cyan(plan.displayCommand)}`);
+  const isGlobalNpmInstall = (plan.installMethod === "npm-global" || plan.installMethod === "unknown") && plan.command === "npm" && plan.args.includes("-g");
+  const isGlobalAltInstall = (plan.installMethod === "pnpm-global" || plan.installMethod === "bun-global") && plan.args.includes("-g");
+  if (isGlobalNpmInstall) {
+    log.dim(
+      "If this failed due to permissions, your global npm directory may require elevated privileges on this machine."
+    );
+  } else if (isGlobalAltInstall) {
+    log.dim(
+      "If this failed due to permissions, your global package manager install location may require additional privileges on this machine."
+    );
+  }
+}
+async function maybeShowUpgradeNotice(options = {}) {
+  const actionName = options.actionName ?? "";
+  const argv = options.argv ?? process.argv;
+  const isInteractive = options.isInteractive ?? Boolean(process.stdout.isTTY && process.stdin.isTTY);
+  if (!isInteractive || shouldSkipUpdateNotifier(argv) || actionName === "upgrade") {
+    return;
+  }
+  const info = await checkForUpdates();
+  if (!info || !info.updateAvailable || !await shouldShowUpdateNotification(info)) {
+    return;
+  }
+  log.blank();
+  if (info.upgradePlan.needsExplicitVersion) {
+    log.box([
+      `${pc5.white(pc5.bold("Update available:"))} ${pc5.green(pc5.bold(`v${info.currentVersion}`))} ${pc5.dim("->")} ${pc5.green(pc5.bold(`v${info.latestVersion}`))}`,
+      `${pc5.white("Use")} ${pc5.yellow(pc5.bold(info.upgradePlan.displayCommand))} ${pc5.white("to run the latest version")}`
+    ]);
+    await markUpdateNotificationShown(info.latestVersion);
+    log.blank();
+    return;
+  }
+  if (!info.upgradePlan.canRun) {
+    log.box([
+      `${pc5.white(pc5.bold("Update available:"))} ${pc5.green(pc5.bold(`v${info.currentVersion}`))} ${pc5.dim("->")} ${pc5.green(pc5.bold(`v${info.latestVersion}`))}`,
+      `${pc5.white("Run")} ${pc5.yellow(pc5.bold("grtl upgrade"))} ${pc5.white("for update steps")}`,
+      `${pc5.white("Or run")} ${pc5.yellow(info.upgradePlan.displayCommand)}`
+    ]);
+    await markUpdateNotificationShown(info.latestVersion);
+    log.blank();
+    return;
+  }
+  log.box([
+    `${pc5.white(pc5.bold("Update available:"))} ${pc5.green(pc5.bold(`v${info.currentVersion}`))} ${pc5.dim("->")} ${pc5.green(pc5.bold(`v${info.latestVersion}`))}`,
+    `${pc5.white("Run")} ${pc5.yellow(pc5.bold("grtl upgrade"))} ${pc5.white("to update now")}`,
+    `${pc5.white("Or run")} ${pc5.yellow(info.upgradePlan.displayCommand)}`
+  ]);
+  await markUpdateNotificationShown(info.latestVersion);
+  log.blank();
+}
+async function upgradeCommand(options) {
+  trackEvent("command", { name: "upgrade" });
+  const info = await checkForUpdates({ force: true });
+  const plan = info?.upgradePlan ?? getUpgradePlan();
+  if (!info) {
+    log.warn("Couldn't check for updates right now.");
+    log.info(`Try again later or run ${pc5.cyan(plan.displayCommand)} manually.`);
+    return;
+  }
+  if (!info.updateAvailable) {
+    log.success(`grtl is up to date (${pc5.bold(`v${VERSION}`)})`);
+    return;
+  }
+  log.blank();
+  log.info(
+    `Update available: ${pc5.bold(`v${info.currentVersion}`)} ${pc5.dim("->")} ${pc5.bold(`v${info.latestVersion}`)}`
+  );
+  if (plan.needsExplicitVersion) {
+    log.info(`You're using an ephemeral runner (${plan.installMethod}).`);
+    log.info(`Use ${pc5.cyan(plan.displayCommand)} to run the latest version immediately.`);
+    log.info(`Or install globally with ${pc5.cyan("npm install -g @genrtl/grtl@latest")}.`);
+    return;
+  }
+  if (!plan.canRun) {
+    log.info(`Run ${pc5.cyan(plan.displayCommand)} to update your installed version.`);
+    return;
+  }
+  log.info(`Upgrade command: ${pc5.cyan(plan.displayCommand)}`);
+  if (options.check) {
+    return;
+  }
+  let shouldRun = options.yes ?? false;
+  if (!shouldRun && process.stdout.isTTY) {
+    shouldRun = await confirm({
+      message: `Run ${plan.displayCommand} now?`,
+      default: true
+    });
+  }
+  if (!shouldRun) {
+    log.dim("Upgrade skipped.");
+    return;
+  }
+  log.blank();
+  const exitCode = await runUpgradePlan(plan);
+  if (exitCode === 0) {
+    log.blank();
+    log.success("Upgrade complete.");
+    log.info(`Run ${pc5.cyan("grtl --version")} to verify the installed version.`);
+    return;
+  }
+  log.blank();
+  log.error(`Upgrade command exited with code ${exitCode ?? "unknown"}.`);
+  showUpgradeFailureHelp(plan);
+  process.exitCode = 1;
+}
+
+// src/index.ts
+var brand = {
+  primary: pc6.green,
+  dim: pc6.dim
+};
+var program = new Command2();
+program.name("grtl").description("GenRTL CLI - Search RTL engineering knowledge and configure GenRTL").version(VERSION).option("--base-url <url>").hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  if (opts.baseUrl) {
+    setBaseUrl(opts.baseUrl);
+    setMcpBaseUrl(opts.baseUrl);
+  }
+}).hook("preAction", async (_thisCommand, actionCommand) => {
+  await maybeShowUpgradeNotice({
+    actionName: actionCommand.name(),
+    argv: process.argv
+  });
+}).addHelpText(
+  "after",
+  `
+Examples:
+  ${brand.dim("# Configure GenRTL for your coding agent")}
+  ${brand.primary("GRTL_API_KEY=your_key npx @genrtl/grtl setup --cursor")}
+  ${brand.primary("GRTL_API_KEY=your_key npx @genrtl/grtl setup --codex --project")}
+
+  ${brand.dim("# Search the same four tools exposed by the GenRTL MCP server")}
+  ${brand.primary('npx @genrtl/grtl knowledge-search "AXI stream backpressure design"')}
+  ${brand.primary('npx @genrtl/grtl spec2rtl-search "Generate an APB register block"')}
+  ${brand.primary('npx @genrtl/grtl verification-search "Verify an async FIFO"')}
+  ${brand.primary('npx @genrtl/grtl debug-search "Explain this Vivado CDC warning"')}
+`
+);
+registerSetupCommand(program);
+registerKnowledgeCommands(program);
+registerUpgradeCommand(program);
+program.action(() => {
+  console.log("");
+  const banner = figlet.textSync("GenRTL", { font: "ANSI Shadow" });
+  console.log(brand.primary(banner));
+  console.log(brand.dim("  RTL engineering knowledge for AI coding agents"));
+  console.log("");
+  console.log("  Quick start:");
+  console.log(`    ${brand.primary("npx @genrtl/grtl setup")}`);
+  console.log(`    ${brand.primary('npx @genrtl/grtl knowledge-search "your RTL question"')}`);
+  console.log("");
+  console.log(`  Run ${brand.primary("npx @genrtl/grtl --help")} for all commands and options`);
+  console.log("");
+});
+await program.parseAsync();