contextwise 0.1.0

package/dist/cli.js

@@ -0,0 +1,1116 @@
+import {
+  ConfigLoader,
+  ContextWiseConfigSchema,
+  ContextWiseProxy,
+  KnownServerRegistry,
+  LLM_PRICING,
+  ServerManager,
+  SmitheryClient,
+  UnifiedRegistryClient,
+  UpstreamMultiplexer,
+  VaultAuditor,
+  cloudClient,
+  logger,
+  metricsCollector,
+  secretVault,
+  syncManager
+} from "./chunk-P7JW7EPW.js";
+
+// src/cli/index.ts
+import { resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+
+// src/cli/commands/add.ts
+import chalk from "chalk";
+async function addCommand(serverName, extraArg, options) {
+  const rawName = serverName.trim();
+  const name = rawName.replace(/^@/, "").replace(/[^a-zA-Z0-9_-]/g, "_");
+  console.log(chalk.bold.cyan(`
+\u26A1 ContextWise Server Configuration: "${name}"
+`));
+  let serverConfig;
+  const envMap = {};
+  if (options.env) {
+    for (const item of options.env) {
+      const idx = item.indexOf("=");
+      if (idx > 0) {
+        const k = item.slice(0, idx).trim();
+        let v = item.slice(idx + 1).trim();
+        if (v.startsWith('"') && v.endsWith('"') || v.startsWith("'") && v.endsWith("'")) {
+          v = v.slice(1, -1);
+        }
+        envMap[k] = v;
+      }
+    }
+  }
+  if (options.url) {
+    serverConfig = {
+      url: options.url,
+      headers: {},
+      transport: "auto",
+      autoReconnect: true
+    };
+  } else if (options.smithery || name.startsWith("smithery:") || name.startsWith("ai.smithery/")) {
+    const pkg = typeof options.smithery === "string" ? options.smithery : name.replace(/^smithery:/, "").replace(/^ai\.smithery\//, "");
+    console.log(chalk.magenta(`\u2713 Configuring Smithery package: ${chalk.bold(pkg)}`));
+    serverConfig = SmitheryClient.buildServerConfig(pkg, { env: envMap });
+  } else {
+    const knownPreset = KnownServerRegistry.find(name);
+    if (knownPreset) {
+      console.log(
+        chalk.green(`\u2713 Recognized preset for ${chalk.bold(knownPreset.displayName)}`)
+      );
+      const passedArgs = options.args ?? [];
+      if (extraArg && !passedArgs.includes(extraArg)) {
+        passedArgs.push(extraArg);
+      }
+      for (const param of knownPreset.requiredParams) {
+        if (param.type === "env" && !envMap[param.name] && !process.env[param.name]) {
+          console.log(
+            chalk.yellow(
+              `\u26A0 Note: ${param.name} not set. Specify with --env ${param.name}=<value>`
+            )
+          );
+        }
+      }
+      serverConfig = KnownServerRegistry.buildConfig(knownPreset, {
+        args: passedArgs,
+        env: envMap
+      });
+    } else if (options.command) {
+      serverConfig = {
+        command: options.command,
+        args: options.args ?? (extraArg ? [extraArg] : []),
+        env: envMap,
+        autoRestart: true
+      };
+    } else {
+      console.log(
+        chalk.red(`Error: "${name}" is not a recognized preset.`)
+      );
+      console.log(
+        `Please specify --command <cmd>, use --smithery, or check available presets with ${chalk.cyan("contextwise browse")}.
+`
+      );
+      process.exit(1);
+    }
+  }
+  if (options.test !== false) {
+    console.log(chalk.gray(`Testing connection to "${name}"...`));
+    const multiplexer = new UpstreamMultiplexer();
+    try {
+      await multiplexer.connectServer(name, serverConfig);
+      const status = multiplexer.getStatus().find((s) => s.name === name);
+      if (status && status.status === "connected") {
+        const tools = multiplexer.getAllTools();
+        console.log(
+          chalk.green(
+            `\u2713 Connected successfully! Discovered ${tools.length} tools.`
+          )
+        );
+        for (const t of tools.slice(0, 5)) {
+          console.log(`  \u2022 ${chalk.gray(t.namespacedName)}`);
+        }
+        if (tools.length > 5) {
+          console.log(`  ... and ${tools.length - 5} more`);
+        }
+      } else {
+        console.log(
+          chalk.yellow(
+            `\u26A0 Warning: Server could not connect (${status?.error || "unknown error"}). Saving configuration anyway.`
+          )
+        );
+      }
+    } catch (testErr) {
+      console.log(
+        chalk.yellow(
+          `\u26A0 Warning: Connection test encountered error: ${testErr}. Saving configuration anyway.`
+        )
+      );
+    } finally {
+      await multiplexer.closeAll();
+    }
+  }
+  const savedPath = ServerManager.saveUpstream(name, serverConfig, options.config);
+  console.log(chalk.green(`
+\u2713 Server "${name}" successfully saved to ${savedPath}!`));
+  console.log(
+    chalk.gray(
+      `ContextWise will now automatically index "${name}" on startup and make its tools available.
+`
+    )
+  );
+}
+
+// src/cli/commands/browse.ts
+import chalk3 from "chalk";
+
+// src/cli/ui/navigator.ts
+import readline from "readline";
+import chalk2 from "chalk";
+async function launchNavigator(options = {}) {
+  if (!process.stdin.isTTY) {
+    console.log(chalk2.yellow("Interactive navigator requires an interactive TTY terminal."));
+    return;
+  }
+  let searchQuery = options.query || options.category || "";
+  let selectedIndex = 0;
+  let allServers = [];
+  let isFetching = true;
+  allServers = await UnifiedRegistryClient.search({
+    query: searchQuery || void 0,
+    category: options.category,
+    source: options.source || "all",
+    limit: 40
+  });
+  isFetching = false;
+  readline.emitKeypressEvents(process.stdin);
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdout.write("\x1B[?25l");
+  const cleanup = () => {
+    process.stdout.write("\x1B[?25h");
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+    }
+    process.stdin.pause();
+    console.clear();
+  };
+  const getSourceBadge = (src) => {
+    switch (src) {
+      case "curated":
+        return chalk2.bgGreen.black(" CURATED ");
+      case "official":
+        return chalk2.bgCyan.black(" OFFICIAL ");
+      case "smithery":
+        return chalk2.bgMagenta.black(" SMITHERY ");
+    }
+  };
+  const render = () => {
+    const q = searchQuery.toLowerCase().trim();
+    const filtered = allServers.filter(
+      (s) => !q || s.displayName.toLowerCase().includes(q) || s.id.toLowerCase().includes(q) || s.description.toLowerCase().includes(q) || s.tags && s.tags.some((t) => t.toLowerCase().includes(q))
+    );
+    if (selectedIndex >= filtered.length) {
+      selectedIndex = Math.max(0, filtered.length - 1);
+    }
+    const termHeight = process.stdout.rows || 25;
+    const termWidth = process.stdout.columns || 80;
+    const pageSize = Math.max(5, Math.min(10, termHeight - 14));
+    const startIdx = Math.max(
+      0,
+      Math.min(
+        selectedIndex - Math.floor(pageSize / 2),
+        Math.max(0, filtered.length - pageSize)
+      )
+    );
+    const visibleServers = filtered.slice(startIdx, startIdx + pageSize);
+    console.clear();
+    console.log(
+      chalk2.bold.cyan("\u{1F310} ContextWise Interactive MCP Navigator") + chalk2.gray(" | ") + chalk2.white("Search, browse, and hot-load MCP servers")
+    );
+    console.log(
+      chalk2.gray("Controls: ") + chalk2.yellow("\u2191/\u2193") + chalk2.gray(" Navigate  ") + chalk2.yellow("[a] / [Enter]") + chalk2.gray(" Add Server  ") + chalk2.yellow("[Esc] / [q]") + chalk2.gray(" Exit  ") + chalk2.yellow("Type") + chalk2.gray(" to filter\n")
+    );
+    console.log(
+      chalk2.bold("Filter: ") + chalk2.cyan(searchQuery ? searchQuery : chalk2.gray("(Type to filter...)")) + chalk2.gray(` [${filtered.length} matching / ${allServers.length} total]`)
+    );
+    console.log(chalk2.gray("\u2500".repeat(Math.min(termWidth, 76))));
+    if (isFetching) {
+      console.log(chalk2.yellow("\n  Loading servers from registries...\n"));
+    } else if (filtered.length === 0) {
+      console.log(chalk2.yellow(`
+  No servers matching "${searchQuery}".`));
+      console.log(chalk2.gray("  Press Backspace to broaden search or Esc to exit.\n"));
+    } else {
+      for (let i = 0; i < visibleServers.length; i++) {
+        const item = visibleServers[i];
+        const actualIndex = startIdx + i;
+        const isSelected = actualIndex === selectedIndex;
+        const cursor = isSelected ? chalk2.bold.green("\u25B8 ") : "  ";
+        const badge = getSourceBadge(item.source);
+        const nameStr = isSelected ? chalk2.bold.underline.white(item.displayName) : chalk2.white(item.displayName);
+        const idStr = chalk2.gray(`(${item.id})`);
+        console.log(`${cursor}${badge} ${nameStr} ${idStr}`);
+      }
+    }
+    console.log(chalk2.gray("\u2500".repeat(Math.min(termWidth, 76))));
+    const selectedItem = filtered[selectedIndex];
+    if (selectedItem) {
+      console.log(
+        chalk2.bold("Selected: ") + chalk2.green(selectedItem.displayName) + chalk2.gray(` [${selectedItem.sourceLabel}]`)
+      );
+      console.log(chalk2.white(`Description: ${selectedItem.description}`));
+      if (selectedItem.requiredParams && selectedItem.requiredParams.length > 0) {
+        const params = selectedItem.requiredParams.map((p) => `${p.name} (${p.type}: ${p.description})`).join(", ");
+        console.log(chalk2.yellow(`Required Params: ${params}`));
+      }
+      const docsUrl = selectedItem.homepage || (selectedItem.source === "smithery" ? `https://smithery.ai/servers/${selectedItem.id}` : selectedItem.source === "curated" ? `https://github.com/modelcontextprotocol/servers/tree/main/src/${selectedItem.id}` : `https://registry.modelcontextprotocol.io`);
+      console.log(chalk2.cyan("Docs: ") + chalk2.underline.white(docsUrl));
+      console.log(
+        chalk2.cyan(`Quick Action: `) + chalk2.white(`Press `) + chalk2.bold.yellow(`[a]`) + chalk2.white(` or `) + chalk2.bold.yellow(`[Enter]`) + chalk2.white(` to install `) + chalk2.bold(selectedItem.id)
+      );
+    } else {
+      console.log(chalk2.gray("Select a server above to view configuration and details."));
+    }
+  };
+  render();
+  return new Promise((resolve3) => {
+    process.stdin.on("keypress", async (str, key) => {
+      if (!key) {
+        if (str && str.length === 1 && str >= " ") {
+          searchQuery += str;
+          selectedIndex = 0;
+          render();
+        }
+        return;
+      }
+      if (key.name === "escape" || key.ctrl && key.name === "c" || key.name === "q" && searchQuery === "") {
+        cleanup();
+        console.log(chalk2.gray("Exited ContextWise Navigator.\n"));
+        resolve3();
+        return;
+      }
+      if (key.name === "up") {
+        selectedIndex = Math.max(0, selectedIndex - 1);
+        render();
+        return;
+      }
+      if (key.name === "down") {
+        const q = searchQuery.toLowerCase().trim();
+        const filteredCount = allServers.filter(
+          (s) => !q || s.displayName.toLowerCase().includes(q) || s.id.toLowerCase().includes(q) || s.description.toLowerCase().includes(q)
+        ).length;
+        selectedIndex = Math.min(Math.max(0, filteredCount - 1), selectedIndex + 1);
+        render();
+        return;
+      }
+      if (key.name === "backspace") {
+        if (searchQuery.length > 0) {
+          searchQuery = searchQuery.slice(0, -1);
+          selectedIndex = 0;
+          render();
+        }
+        return;
+      }
+      if (key.name === "return" || key.name === "a") {
+        const q = searchQuery.toLowerCase().trim();
+        const filtered = allServers.filter(
+          (s) => !q || s.displayName.toLowerCase().includes(q) || s.id.toLowerCase().includes(q) || s.description.toLowerCase().includes(q)
+        );
+        const target = filtered[selectedIndex];
+        if (target) {
+          cleanup();
+          console.log(chalk2.bold.green(`
+\u2713 Selected MCP Server: "${target.displayName}" (${target.id})
+`));
+          try {
+            let config = target.suggestedConfig;
+            if (!config) {
+              if (target.source === "smithery") {
+                config = SmitheryClient.buildServerConfig(target.id);
+              } else {
+                const preset = KnownServerRegistry.find(target.id);
+                if (preset) {
+                  config = KnownServerRegistry.buildConfig(preset);
+                } else {
+                  config = {
+                    command: "npx",
+                    args: ["-y", target.id],
+                    env: {},
+                    autoRestart: true
+                  };
+                }
+              }
+            }
+            const savedPath = ServerManager.saveUpstream(target.id, config);
+            console.log(
+              chalk2.green(
+                `\u2713 Successfully added "${target.id}" into ${chalk2.bold(savedPath)}!`
+              )
+            );
+            console.log(
+              chalk2.cyan(
+                `The server is now configured and will be loaded automatically on next session or when ContextWise starts.
+`
+              )
+            );
+          } catch (err) {
+            console.log(chalk2.red(`Failed to add server: ${err}
+`));
+          }
+          resolve3();
+          return;
+        }
+      }
+      if (str && str.length === 1 && !key.ctrl && !key.meta && str >= " ") {
+        searchQuery += str;
+        selectedIndex = 0;
+        render();
+      }
+    });
+  });
+}
+
+// src/cli/commands/browse.ts
+async function browseCommand(options) {
+  if (options.interactive) {
+    await launchNavigator({
+      query: options.query,
+      category: options.category,
+      source: options.source
+    });
+    return;
+  }
+  const source = (options.offline ? "curated" : options.source) || "all";
+  console.log(chalk3.bold.cyan("\n\u{1F310} ContextWise Multi-Registry MCP Browser"));
+  console.log(
+    chalk3.gray(
+      `Searching sources: ${source === "all" ? "Official MCP Registry + Smithery + Curated Presets" : source}
+`
+    )
+  );
+  const servers = await UnifiedRegistryClient.search({
+    query: options.query,
+    category: options.category,
+    source,
+    limit: 20
+  });
+  if (servers.length === 0) {
+    console.log(chalk3.yellow("No matching MCP servers found across registries."));
+    console.log(
+      chalk3.gray(
+        'Try broadening your query, or install any custom server using "contextwise add <name> --command <cmd>"\n'
+      )
+    );
+    return;
+  }
+  const getSourceBadge = (src) => {
+    switch (src) {
+      case "curated":
+        return chalk3.bgGreen.black(" CURATED / VERIFIED ");
+      case "official":
+        return chalk3.bgCyan.black(" OFFICIAL MCP REGISTRY ");
+      case "smithery":
+        return chalk3.bgMagenta.black(" SMITHERY ");
+    }
+  };
+  console.log(chalk3.bold(`Found ${servers.length} MCP Servers:
+`));
+  for (const s of servers) {
+    const verifiedIcon = s.verified ? chalk3.green(" \u2713") : "";
+    console.log(
+      `${getSourceBadge(s.source)} ${chalk3.bold.white(s.displayName)} (${chalk3.gray(s.id)})${verifiedIcon}`
+    );
+    console.log(`  ${chalk3.white(s.description)}`);
+    if (s.requiredParams && s.requiredParams.length > 0) {
+      const paramStr = s.requiredParams.map((p) => `${p.name} (${p.type})`).join(", ");
+      console.log(`  ${chalk3.yellow("Required parameters:")} ${chalk3.gray(paramStr)}`);
+    }
+    const docsUrl = s.homepage || (s.source === "smithery" ? `https://smithery.ai/servers/${s.id}` : s.source === "curated" ? `https://github.com/modelcontextprotocol/servers/tree/main/src/${s.id}` : `https://registry.modelcontextprotocol.io`);
+    console.log(`  ${chalk3.cyan("Docs:")} ${chalk3.underline.white(docsUrl)}`);
+    let installCmd = `contextwise add ${s.id}`;
+    if (s.source === "smithery") {
+      installCmd = `contextwise add ${s.id} --smithery`;
+    }
+    console.log(`  ${chalk3.cyan("Install:")} ${chalk3.bold(installCmd)}
+`);
+  }
+  console.log(
+    chalk3.gray(
+      "To install any server: " + chalk3.white("contextwise add <id>") + " or hot-load in chat with " + chalk3.white("contextwise_add_server\n")
+    )
+  );
+}
+
+// src/cli/commands/init.ts
+import { existsSync, writeFileSync } from "fs";
+import { resolve } from "path";
+import chalk4 from "chalk";
+async function initCommand(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const targetPath = resolve(cwd, "contextwise.json");
+  console.log(chalk4.bold.cyan("\n\u{1F680} ContextWise Setup Wizard\n"));
+  if (existsSync(targetPath) && !options.force) {
+    console.log(
+      chalk4.yellow(`Configuration file already exists at ${targetPath}.`)
+    );
+    console.log("Use --force to overwrite.\n");
+    return;
+  }
+  const imported = ConfigLoader.autoImportClientConfigs(cwd);
+  let initialConfig;
+  if (imported && Object.keys(imported.upstreams).length > 0) {
+    console.log(
+      chalk4.green(
+        `\u2713 Found existing MCP servers from AI client configuration:`
+      )
+    );
+    for (const name of Object.keys(imported.upstreams)) {
+      console.log(`  - ${chalk4.bold(name)}`);
+    }
+    initialConfig = imported;
+  } else {
+    console.log(chalk4.blue("\u2139 No existing MCP clients detected. Generating template configuration."));
+    initialConfig = ContextWiseConfigSchema.parse({
+      version: "1.0.0",
+      proxy: {
+        transport: "stdio",
+        port: 3456,
+        logLevel: "info"
+      },
+      routing: {
+        strategy: "hybrid",
+        topK: 5,
+        similarityThreshold: 0.45,
+        pinnedTools: []
+      },
+      guardrails: {
+        enableCache: true,
+        cacheTtlSeconds: 120,
+        maxCallsPerMinute: 60,
+        loopBreakerThreshold: 3
+      },
+      upstreams: {}
+    });
+  }
+  writeFileSync(targetPath, JSON.stringify(initialConfig, null, 2), "utf-8");
+  console.log(chalk4.green(`
+\u2713 Successfully created ${targetPath}`));
+  console.log(
+    chalk4.gray(
+      "\nNext step: Connect your AI client (Cursor, Claude Desktop, Windsurf) by adding ContextWise to its MCP configuration:\n"
+    )
+  );
+  console.log(chalk4.white('{\n  "mcpServers": {\n    "contextwise": {\n      "command": "npx",\n      "args": ["-y", "contextwise", "start"]\n    }\n  }\n}\n'));
+}
+
+// src/cli/commands/list.ts
+import chalk5 from "chalk";
+async function listCommand(options) {
+  const config = ConfigLoader.load({ configPath: options.config });
+  const upstreamCount = Object.keys(config.upstreams).length;
+  console.log(chalk5.bold.cyan("\n\u{1F50D} ContextWise Catalog Overview\n"));
+  console.log(`Configured Upstreams: ${chalk5.bold(upstreamCount)}`);
+  if (upstreamCount === 0) {
+    console.log(
+      chalk5.yellow('No upstream MCP servers defined. Run "contextwise init" to add servers.\n')
+    );
+    return;
+  }
+  const multiplexer = new UpstreamMultiplexer();
+  try {
+    await multiplexer.connectAll(config.upstreams);
+    const statuses = multiplexer.getStatus();
+    const tools = multiplexer.getAllTools();
+    console.log(chalk5.bold("\n--- Upstream Servers ---"));
+    for (const s of statuses) {
+      const statusColor = s.status === "connected" ? chalk5.green : chalk5.red;
+      console.log(
+        `\u2022 ${chalk5.bold(s.name)} [${s.transportType}] - ${statusColor(s.status.toUpperCase())} (${s.toolsCount} tools)`
+      );
+      if (s.error) {
+        console.log(`  ${chalk5.red("Error:")} ${s.error}`);
+      }
+    }
+    console.log(chalk5.bold(`
+--- Aggregated Tools (${tools.length} total) ---`));
+    for (const tool of tools) {
+      const hint = tool.readOnlyHint ? chalk5.gray(" [read-only]") : "";
+      console.log(`\u2022 ${chalk5.green(tool.namespacedName)}${hint}`);
+      if (tool.description) {
+        console.log(`  ${chalk5.gray(tool.description.slice(0, 100))}`);
+      }
+    }
+    console.log("");
+  } finally {
+    await multiplexer.closeAll();
+  }
+}
+
+// src/cli/commands/cloud.ts
+import { exec } from "child_process";
+import chalk6 from "chalk";
+function openBrowser(url) {
+  const startCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  exec(`${startCmd} "${url}"`, (err) => {
+    if (err) {
+      console.log(chalk6.gray(`Could not open browser automatically. Please visit:
+${url}`));
+    }
+  });
+}
+async function loginCommand(apiKey) {
+  const key = apiKey?.trim();
+  if (key) {
+    try {
+      const token = await cloudClient.loginWithKey(key);
+      console.log(chalk6.green(`
+\u2714 Logged in successfully as ${chalk6.bold(token.email)}
+`));
+      console.log(chalk6.gray(`User ID: ${token.userId}`));
+      console.log(chalk6.gray(`Session valid until: ${new Date(token.expiresAt).toLocaleDateString()}
+`));
+      return;
+    } catch (err) {
+      console.error(chalk6.red(`
+\u2716 Login failed: ${err instanceof Error ? err.message : err}
+`));
+      process.exit(1);
+    }
+  }
+  try {
+    console.log(chalk6.cyan("\nInitiating ContextWise Cloud authorization..."));
+    const flow = await cloudClient.startDeviceFlow();
+    console.log(chalk6.bold("\nTo authorize this device, follow these steps:"));
+    console.log(`1. Open this URL in your browser:`);
+    console.log(`   ${chalk6.bold.underline.blue(flow.verification_uri)}`);
+    console.log(`2. Verify the confirmation code:`);
+    console.log(`   ${chalk6.bold.yellow(flow.user_code)}
+`);
+    console.log(chalk6.gray("Waiting for browser approval... (press Ctrl+C to cancel)"));
+    const token = await cloudClient.pollDeviceToken(flow.device_code, flow.interval);
+    console.log(chalk6.green(`
+\u2714 Logged in successfully as ${chalk6.bold(token.email)}
+`));
+    console.log(chalk6.gray(`User ID: ${token.userId}`));
+    console.log(chalk6.gray(`Session valid until: ${new Date(token.expiresAt).toLocaleDateString()}
+`));
+  } catch (err) {
+    console.error(chalk6.red(`
+\u2716 Login failed: ${err instanceof Error ? err.message : err}
+`));
+    process.exit(1);
+  }
+}
+async function logoutCommand() {
+  cloudClient.clearToken();
+  console.log(chalk6.green("\n\u2714 Logged out of ContextWise Cloud.\n"));
+}
+async function whoamiCommand() {
+  try {
+    const info = await cloudClient.whoami();
+    console.log(chalk6.bold.cyan("\n\u{1F464} ContextWise Cloud Identity\n"));
+    console.log(`User Email:   ${chalk6.bold(info.email)}`);
+    console.log(`User ID:      ${chalk6.gray(info.userId)}`);
+    const planDisplay = info.plan === "pro" ? chalk6.bold.green("PRO") : info.plan === "team" ? chalk6.bold.blue("TEAM") : info.plan === "enterprise" ? chalk6.bold.magenta("ENTERPRISE") : chalk6.bold.gray("COMMUNITY (Free)");
+    const statusDisplay = info.subscriptionStatus === "active" ? chalk6.green("Active") : chalk6.yellow(info.subscriptionStatus || "Inactive");
+    console.log(`Plan:         ${planDisplay} (${statusDisplay})`);
+    if (info.currentPeriodEnd) {
+      console.log(
+        `Next Renewal: ${chalk6.gray(
+          new Date(info.currentPeriodEnd).toISOString().replace("T", " ").slice(0, 10)
+        )}`
+      );
+    }
+    console.log("");
+    if (info.workspaces && info.workspaces.length > 0) {
+      console.log(chalk6.bold("Workspaces:"));
+      for (const w of info.workspaces) {
+        console.log(`\u2022 ${chalk6.green(w.name)} (${w.id}) - Role: ${w.role}`);
+      }
+      console.log("");
+    }
+  } catch (err) {
+    console.error(chalk6.red(`
+\u2716 Failed to retrieve identity: ${err instanceof Error ? err.message : err}
+`));
+    process.exit(1);
+  }
+}
+async function upgradeCommand(options) {
+  if (!cloudClient.isAuthenticated()) {
+    console.log(chalk6.yellow("\nYou must be logged in to upgrade your subscription."));
+    console.log(
+      chalk6.cyan(
+        'Run "contextwise login" first, or visit https://contextwise.dev/#pricing in your browser.\n'
+      )
+    );
+    return;
+  }
+  const plan = options.team ? "team" : "pro";
+  const interval = options.annual ? "year" : "month";
+  console.log(
+    chalk6.cyan(
+      `
+Initiating Stripe Checkout for ContextWise ${chalk6.bold(plan.toUpperCase())} (${interval}ly)...`
+    )
+  );
+  try {
+    const session = await cloudClient.createCheckoutSession(plan, interval);
+    console.log(chalk6.green("\n\u2714 Checkout session created."));
+    console.log(`Opening your browser to complete payment via Stripe:
+`);
+    console.log(`  ${chalk6.bold.underline.blue(session.checkoutUrl)}
+`);
+    openBrowser(session.checkoutUrl);
+    console.log(chalk6.gray("Once payment is confirmed, your subscription will be instantly unlocked."));
+    console.log(chalk6.gray('Run "contextwise whoami" to confirm your subscription status.\n'));
+  } catch (err) {
+    console.error(
+      chalk6.red(`
+\u2716 Unable to initiate checkout: ${err instanceof Error ? err.message : err}
+`)
+    );
+  }
+}
+async function billingCommand() {
+  if (!cloudClient.isAuthenticated()) {
+    console.log(chalk6.yellow("\nYou must be logged in to access the billing portal."));
+    console.log(chalk6.cyan('Run "contextwise login" first.\n'));
+    return;
+  }
+  console.log(chalk6.cyan("\nOpening Stripe Customer Billing Portal..."));
+  try {
+    const session = await cloudClient.createPortalSession();
+    console.log(`Opening your browser to manage payment methods, invoices, and subscriptions:
+`);
+    console.log(`  ${chalk6.bold.underline.blue(session.portalUrl)}
+`);
+    openBrowser(session.portalUrl);
+  } catch (err) {
+    console.error(
+      chalk6.red(`
+\u2716 Unable to open billing portal: ${err instanceof Error ? err.message : err}
+`)
+    );
+  }
+}
+async function pushCommand(workspaceId) {
+  if (!cloudClient.isAuthenticated()) {
+    console.log(chalk6.yellow("\nNot logged in to ContextWise Cloud."));
+    console.log(chalk6.cyan('Run "contextwise login" first.\n'));
+    return;
+  }
+  console.log(chalk6.cyan("\n\u2601  Pushing local workspace to ContextWise Cloud..."));
+  try {
+    const res = await syncManager.push(workspaceId);
+    if (res.status === "committed") {
+      console.log(chalk6.green(`\u2714 Successfully pushed revision #${chalk6.bold(res.revision)} to Cloud.
+`));
+    } else {
+      console.log(chalk6.yellow(`\u26A0 Push conflict: Server has revision #${res.serverRevision}. Pull changes first.
+`));
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("requires an upgraded subscription") || msg.includes("Cloud Sync requires")) {
+      console.log(
+        chalk6.yellow("\n\u26A0 Multi-device Cloud Sync requires a ContextWise Pro or Team subscription.")
+      );
+      console.log(
+        chalk6.cyan(
+          'Run "contextwise upgrade" to subscribe via Stripe, or visit https://contextwise.dev/#pricing\n'
+        )
+      );
+    } else {
+      console.error(chalk6.red(`
+\u2716 Cloud push failed: ${msg}
+`));
+    }
+  }
+}
+async function pullCommand(workspaceId) {
+  if (!cloudClient.isAuthenticated()) {
+    console.log(chalk6.yellow("\nNot logged in to ContextWise Cloud."));
+    console.log(chalk6.cyan('Run "contextwise login" first.\n'));
+    return;
+  }
+  console.log(chalk6.cyan("\n\u2601  Pulling latest workspace snapshot from ContextWise Cloud..."));
+  try {
+    const res = await syncManager.pull(workspaceId);
+    if (res) {
+      console.log(chalk6.green(`\u2714 Applied cloud revision #${chalk6.bold(res.revision)} to local workspace.
+`));
+    } else {
+      console.log(chalk6.gray("\u2714 Local workspace is already up to date.\n"));
+    }
+  } catch (err) {
+    console.error(chalk6.red(`
+\u2716 Cloud pull failed: ${err instanceof Error ? err.message : err}
+`));
+  }
+}
+async function syncStatusCommand() {
+  const status = syncManager.getStatus();
+  console.log(chalk6.bold.cyan("\n\u{1F504} ContextWise Cloud Sync Status\n"));
+  console.log(`Logged In:      ${status.isLoggedIn ? chalk6.green("YES") : chalk6.gray("NO")}`);
+  if (status.userEmail) {
+    console.log(`Account:        ${chalk6.bold(status.userEmail)}`);
+  }
+  console.log(`Device ID:      ${chalk6.gray(status.deviceId)}`);
+  console.log(`Workspace ID:   ${status.workspaceId}`);
+  console.log(`Local Revision: ${chalk6.bold(status.revision)}`);
+  console.log(
+    `Last Synced:    ${status.lastSyncedAt > 0 ? new Date(status.lastSyncedAt).toISOString().replace("T", " ").slice(0, 19) : chalk6.gray("Never")}
+`
+  );
+}
+
+// src/cli/commands/secret.ts
+import { createInterface } from "readline/promises";
+import chalk7 from "chalk";
+async function secretSetCommand(key, value, options = {}) {
+  if (!key || typeof key !== "string") {
+    console.error(chalk7.red("Error: Secret key must be specified."));
+    process.exit(1);
+  }
+  let secretValue = value;
+  if (!secretValue) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+      secretValue = await rl.question(chalk7.cyan(`Enter secret value for "${key}": `));
+    } finally {
+      rl.close();
+    }
+  }
+  secretValue = secretValue?.trim();
+  if (!secretValue) {
+    console.error(chalk7.red("Error: Secret value cannot be empty."));
+    process.exit(1);
+  }
+  const scope = options.scope || "personal";
+  await secretVault.set(key, secretValue, scope);
+  console.log(
+    chalk7.green(
+      `
+\u2714 Secret "${chalk7.bold(key)}" stored successfully in vault [${secretVault.getActiveDriverName()}] (scope: ${scope})
+`
+    )
+  );
+  console.log(
+    chalk7.gray(
+      `Tip: Reference this secret in contextwise.json with: "vault://${key}"
+`
+    )
+  );
+}
+async function secretGetCommand(key, options = {}) {
+  if (!key) {
+    console.error(chalk7.red("Error: Secret key must be specified."));
+    process.exit(1);
+  }
+  const value = await secretVault.get(key);
+  if (value === null || value === void 0) {
+    console.log(chalk7.red(`
+\u2716 Secret "${key}" not found in ContextWise vault.
+`));
+    process.exit(1);
+  }
+  if (options.reveal) {
+    console.log(`
+${chalk7.bold(key)}: ${chalk7.yellow(value)}
+`);
+  } else {
+    const masked = value.length > 8 ? `${value.slice(0, 4)}\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022${value.slice(-4)}` : "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022";
+    console.log(
+      `
+${chalk7.bold(key)}: ${chalk7.yellow(masked)} ${chalk7.gray(
+        `(${value.length} chars, pass --reveal to view plaintext)`
+      )}
+`
+    );
+  }
+}
+async function secretListCommand() {
+  const secrets = await secretVault.list();
+  console.log(chalk7.bold.cyan("\n\u{1F510} ContextWise Secret Vault\n"));
+  console.log(`Active Storage Driver: ${chalk7.bold(secretVault.getActiveDriverName())}`);
+  console.log(`Total Stored Secrets:  ${chalk7.bold(secrets.length)}
+`);
+  if (secrets.length === 0) {
+    console.log(chalk7.yellow("No secrets currently stored in vault."));
+    console.log(
+      chalk7.gray("Store a secret with: contextwise secret set <key> <value>\n")
+    );
+    return;
+  }
+  console.log(
+    chalk7.bold(
+      `${"KEY".padEnd(30)} ${"SCOPE".padEnd(14)} ${"BACKEND".padEnd(18)} ${"UPDATED"}`
+    )
+  );
+  console.log(chalk7.gray("\u2500".repeat(75)));
+  for (const s of secrets) {
+    const dateStr = new Date(s.updatedAt).toISOString().replace("T", " ").slice(0, 19);
+    console.log(
+      `${chalk7.cyan(s.key.padEnd(30))} ${s.scope.padEnd(14)} ${s.backend.padEnd(18)} ${chalk7.gray(dateStr)}`
+    );
+  }
+  console.log("");
+}
+async function secretDeleteCommand(key) {
+  if (!key) {
+    console.error(chalk7.red("Error: Secret key must be specified."));
+    process.exit(1);
+  }
+  const deleted = await secretVault.delete(key);
+  if (deleted) {
+    console.log(chalk7.green(`
+\u2714 Secret "${chalk7.bold(key)}" was successfully deleted from vault.
+`));
+  } else {
+    console.log(chalk7.yellow(`
+\u2716 Secret "${key}" was not found in vault.
+`));
+  }
+}
+async function secretAuditCommand() {
+  const config = ConfigLoader.load();
+  const report = await VaultAuditor.audit(config);
+  console.log(chalk7.bold.cyan("\n\u{1F6E1}\uFE0F  ContextWise Secret Security Audit\n"));
+  console.log(`Upstream Servers Inspected: ${chalk7.bold(report.totalUpstreams)}`);
+  console.log(`Vault References in Config: ${chalk7.bold(report.vaultReferencedCount)}`);
+  console.log(`Active Vault Driver:        ${chalk7.bold(report.activeDriver)}`);
+  console.log(`Redacted Secrets in Memory: ${chalk7.bold(report.registeredSecretCount)}
+`);
+  if (report.plaintextWarnings.length === 0) {
+    console.log(
+      chalk7.green(
+        "\u2714 Vault Audit Passed: No exposed plaintext credentials detected in configuration.\n"
+      )
+    );
+    return;
+  }
+  console.log(
+    chalk7.red(
+      `\u26A0 Found ${report.plaintextWarnings.length} potential credential risk(s) in configuration:
+`
+    )
+  );
+  for (const warning of report.plaintextWarnings) {
+    const badge = warning.severity === "critical" ? chalk7.bgRed.bold(" CRITICAL ") : chalk7.bgYellow.black.bold(" WARNING ");
+    console.log(`${badge} [${warning.serverName}] ${chalk7.bold(warning.envVar)}`);
+    console.log(`  ${chalk7.gray("Issue:")}       ${warning.reason}`);
+    console.log(`  ${chalk7.cyan("Action:")}      ${warning.suggestion}
+`);
+  }
+}
+
+// src/cli/commands/start.ts
+async function startCommand(options) {
+  try {
+    const config = ConfigLoader.load({
+      configPath: options.config
+    });
+    if (options.logLevel) {
+      config.proxy.logLevel = options.logLevel;
+    }
+    if (options.passthrough) {
+      config.routing.strategy = "passthrough";
+    }
+    const proxy = new ContextWiseProxy();
+    let isShuttingDown = false;
+    const cleanup = async () => {
+      if (isShuttingDown) return;
+      isShuttingDown = true;
+      setTimeout(() => process.exit(0), 3e3).unref();
+      try {
+        await proxy.stop();
+      } catch (err) {
+        logger.error(`Error stopping ContextWise proxy: ${err}`);
+      } finally {
+        process.exit(0);
+      }
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    await proxy.start(config);
+    process.stdin.resume();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.error(`ContextWise proxy failed to start: ${msg}`);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/stats.ts
+import chalk8 from "chalk";
+function col(text, width, colorFn) {
+  const truncated = text.length > width ? text.slice(0, width) : text;
+  const padded = truncated.padEnd(width);
+  return colorFn ? colorFn(padded) : padded;
+}
+function makeSeparator(cLeft, cMid, cRight, widths) {
+  const parts = widths.map((w) => "\u2500".repeat(w + 2));
+  return `  ${cLeft}${parts.join(cMid)}${cRight}`;
+}
+function makeHeader(title, widths) {
+  const totalWidth = widths.reduce((acc, w) => acc + w + 2, 0) + widths.length - 1;
+  const banner = `  \u250C\u2500\u2500 ${title} `;
+  const remaining = Math.max(0, totalWidth + 3 - banner.length);
+  return `${banner}${"\u2500".repeat(remaining)}\u2510`;
+}
+async function statsCommand(options = {}) {
+  if (options.reset) {
+    metricsCollector.reset();
+    console.log(
+      chalk8.green.bold("\n\u2714 All ContextWise lifetime metrics and token analytics have been reset to zero.\n")
+    );
+    return;
+  }
+  metricsCollector.reload();
+  const summary = metricsCollector.getSummary();
+  if (options.json) {
+    console.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+  const doubleDivider = chalk8.bold.cyan("\u2550".repeat(74));
+  console.log(`
+${doubleDivider}`);
+  console.log(
+    chalk8.bold.cyan("         \u{1F4B0} ContextWise Performance, Token & Cost Analytics")
+  );
+  console.log(`${doubleDivider}
+`);
+  const baselineSavings = summary.dollarSavings.claudeSonnet.toFixed(2);
+  const totalTokens = summary.estimatedTotalTokensSaved.toLocaleString();
+  if (summary.estimatedTotalTokensSaved > 0) {
+    console.log(
+      chalk8.bgGreen.black.bold(`  SAVINGS  `) + chalk8.green.bold(
+        ` ContextWise has saved you ~$${baselineSavings} in LLM API costs!`
+      )
+    );
+    console.log(
+      chalk8.dim(`            ${totalTokens} total tokens avoided across all sessions
+`)
+    );
+  } else {
+    console.log(
+      chalk8.bgBlue.black.bold(`  STANDBY  `) + chalk8.cyan.bold(
+        ` Ready to route! Connect Claude Code, Cursor, or Antigravity to track savings.`
+      )
+    );
+    console.log(
+      chalk8.dim(`            0 tokens saved so far (start a session to begin tracking)
+`)
+    );
+  }
+  const modelCols = [30, 18, 16];
+  console.log(chalk8.bold.yellow(makeHeader("\u{1F4A1} ESTIMATED SAVINGS BY MODEL", modelCols)));
+  console.log(
+    `  \u2502 ${col("Model Family", 30, chalk8.bold)} \u2502 ${col("Benchmark Rate", 18, chalk8.bold)} \u2502 ${col("Dollar Saved", 16, chalk8.bold)} \u2502`
+  );
+  console.log(makeSeparator("\u251C", "\u253C", "\u2524", modelCols));
+  console.log(
+    `  \u2502 ${col("Claude 3.5 / 3.7 Sonnet (def)", 30, chalk8.cyan)} \u2502 ${col(`$${LLM_PRICING.CLAUDE_SONNET.toFixed(2)} / 1M`, 18)} \u2502 ${col(`$${summary.dollarSavings.claudeSonnet.toFixed(2)}`, 16, chalk8.green.bold)} \u2502`
+  );
+  console.log(
+    `  \u2502 ${col("OpenAI GPT-4o", 30)} \u2502 ${col(`$${LLM_PRICING.GPT_4O.toFixed(2)} / 1M`, 18)} \u2502 ${col(`$${summary.dollarSavings.gpt4o.toFixed(2)}`, 16, chalk8.green)} \u2502`
+  );
+  console.log(
+    `  \u2502 ${col("Claude 3 Opus", 30)} \u2502 ${col(`$${LLM_PRICING.CLAUDE_OPUS.toFixed(2)} / 1M`, 18)} \u2502 ${col(`$${summary.dollarSavings.claudeOpus.toFixed(2)}`, 16, chalk8.green)} \u2502`
+  );
+  console.log(
+    `  \u2502 ${col("Haiku / GPT-4o mini", 30)} \u2502 ${col(`$${LLM_PRICING.HAIKU_OR_MINI.toFixed(2)} / 1M`, 18)} \u2502 ${col(`$${summary.dollarSavings.haikuOrMini.toFixed(2)}`, 16, chalk8.green)} \u2502`
+  );
+  console.log(makeSeparator("\u2514", "\u2534", "\u2518", modelCols) + "\n");
+  const tokenCols = [24, 18, 24];
+  console.log(chalk8.bold.yellow(makeHeader("\u{1F4CA} TOKEN REDUCTION BREAKDOWN", tokenCols)));
+  console.log(
+    `  \u2502 ${col("Source", 24, chalk8.bold)} \u2502 ${col("Tokens Saved", 18, chalk8.bold)} \u2502 ${col("Details", 24, chalk8.bold)} \u2502`
+  );
+  console.log(makeSeparator("\u251C", "\u253C", "\u2524", tokenCols));
+  console.log(
+    `  \u2502 ${col("Schema Pruning", 24)} \u2502 ${col(summary.schemaPruningTokensSaved.toLocaleString(), 18, chalk8.green)} \u2502 ${col(`${Math.max(0, summary.totalCatalogToolsCount - summary.exposedToolsCount)} tools hidden/turn`, 24, chalk8.dim)} \u2502`
+  );
+  console.log(
+    `  \u2502 ${col("Response Cache", 24)} \u2502 ${col(summary.cacheTokensSaved.toLocaleString(), 18, chalk8.green)} \u2502 ${col(`${summary.cachedCalls} read calls cached`, 24, chalk8.dim)} \u2502`
+  );
+  console.log(
+    `  \u2502 ${col("Loop Prevention", 24)} \u2502 ${col(summary.loopPreventionTokensSaved.toLocaleString(), 18, chalk8.green)} \u2502 ${col(`${summary.loopsPrevented} runaway loops stopped`, 24, chalk8.dim)} \u2502`
+  );
+  console.log(makeSeparator("\u2514", "\u2534", "\u2518", tokenCols) + "\n");
+  const trackingSince = summary.firstRecordedAt > 0 ? new Date(summary.firstRecordedAt).toLocaleDateString(void 0, {
+    month: "short",
+    day: "numeric",
+    year: "numeric"
+  }) : "Session start";
+  const perfCols = [26, 43];
+  console.log(chalk8.bold.yellow(makeHeader("\u26A1 PROXY PERFORMANCE & RELIABILITY", perfCols)));
+  console.log(`  \u2502 ${col("Total Proxied Calls:", 26)} \u2502 ${col(String(summary.totalCalls), 43, chalk8.bold)} \u2502`);
+  console.log(
+    `  \u2502 ${col("Cache Hit Efficiency:", 26)} \u2502 ${col(`${summary.cacheHitRatePct}% (${summary.cachedCalls} cached / ${summary.totalCalls} calls)`, 43, chalk8.bold)} \u2502`
+  );
+  console.log(`  \u2502 ${col("Avg Execution Latency:", 26)} \u2502 ${col(`${summary.averageLatencyMs} ms`, 43, chalk8.bold)} \u2502`);
+  console.log(
+    `  \u2502 ${col("Tripped Loops / Errors:", 26)} \u2502 ${col(
+      summary.loopsPrevented > 0 || summary.errorCalls > 0 ? `${summary.loopsPrevented} loops / ${summary.errorCalls} errors` : "0 loops / 0 errors",
+      43,
+      summary.loopsPrevented > 0 || summary.errorCalls > 0 ? chalk8.red : chalk8.green
+    )} \u2502`
+  );
+  console.log(`  \u2502 ${col("Metrics Tracking Since:", 26)} \u2502 ${col(trackingSince, 43, chalk8.dim)} \u2502`);
+  console.log(makeSeparator("\u2514", "\u2534", "\u2518", perfCols) + "\n");
+  console.log(
+    chalk8.dim(
+      '  Tip: Run "contextwise stats --reset" to clear counters or "--json" for raw exports.\n'
+    )
+  );
+}
+
+// src/cli/index.ts
+function createCli() {
+  const program = new Command();
+  program.name("contextwise").description(
+    "ContextWise: Dynamic MCP Tool Routing, Schema Compression & Execution Gateway"
+  ).version("0.1.0");
+  program.command("start").description("Start the ContextWise MCP proxy gateway").option("-c, --config <path>", "Path to contextwise.json config file").option(
+    "-l, --log-level <level>",
+    "Logging level (debug, info, warn, error, silent)",
+    "info"
+  ).option(
+    "--passthrough",
+    "Run in raw passthrough mode without dynamic tool routing"
+  ).action(startCommand);
+  program.command("init").description("Initialize contextwise.json by scanning existing MCP configurations").option("-f, --force", "Overwrite existing configuration file").action(initCommand);
+  program.command("browse [category]").description("Browse MCP servers across Official Registry, Smithery, and Curated Presets").option("-q, --query <query>", "Filter by search keyword").option("-s, --source <source>", "Filter by registry source (all, official, smithery, curated)", "all").option("--offline", "Only show local curated presets without querying remote registries").option("-i, --interactive", "Launch interactive keyboard-navigable terminal UI").action(
+    (category, opts) => browseCommand({
+      category,
+      query: opts.query,
+      source: opts.source,
+      offline: opts.offline,
+      interactive: opts.interactive
+    })
+  );
+  program.command("add <name> [extraArg]").description(
+    "Add and configure an upstream MCP server in contextwise.json (e.g. contextwise add postgres postgresql://...)"
+  ).option("-s, --smithery [package]", "Install and run via Smithery CLI (@smithery/cli)").option("-c, --command <cmd>", "Executable command for local stdio server").option("-a, --args <args...>", "Command-line arguments").option("-e, --env <env...>", "Environment variables in KEY=VALUE format").option("-u, --url <url>", "Remote SSE endpoint URL").option("--no-test", "Skip testing connection before saving").action(addCommand);
+  program.command("list").description("Inspect configured upstreams and list all aggregated tools").option("-c, --config <path>", "Path to contextwise.json config file").action(listCommand);
+  const secret = program.command("secret").description("Manage encrypted secrets, credentials, and run security audits");
+  secret.command("set <key> [value]").description("Store an encrypted secret in the vault (prompts securely if value omitted)").option("-s, --scope <scope>", "Secret scope (personal, workspace, team)", "personal").action((key, value, opts) => secretSetCommand(key, value, { scope: opts.scope }));
+  secret.command("get <key>").description("Retrieve secret metadata and preview value").option("--reveal", "Print full unmasked secret value in plaintext").action((key, opts) => secretGetCommand(key, { reveal: opts.reveal }));
+  secret.command("list").description("List all secrets stored in the ContextWise vault").action(secretListCommand);
+  secret.command("delete <key>").alias("rm").description("Delete a secret from the vault").action(secretDeleteCommand);
+  secret.command("audit").description("Scan configuration for exposed plaintext API keys and credentials").action(secretAuditCommand);
+  program.command("login [apiKey]").description("Log in to ContextWise Cloud for end-to-end encrypted synchronization").action(loginCommand);
+  program.command("logout").description("Log out of ContextWise Cloud on this device").action(logoutCommand);
+  program.command("whoami").description("Display currently authenticated ContextWise Cloud account and workspaces").action(whoamiCommand);
+  program.command("push [workspaceId]").description("Push local workspace configuration and encrypted secrets to ContextWise Cloud").action(pushCommand);
+  program.command("pull [workspaceId]").description("Pull latest workspace configuration and secrets from ContextWise Cloud").action(pullCommand);
+  program.command("sync").description("Display status of ContextWise Cloud synchronization").action(syncStatusCommand);
+  program.command("upgrade").description("Upgrade your subscription to ContextWise Pro or Team via Stripe").option("--team", "Upgrade to Team subscription").option("--annual", "Select annual billing cycle for discounted pricing").action((opts) => upgradeCommand({ team: opts.team, annual: opts.annual }));
+  program.command("billing").description("Manage your Stripe subscription, invoices, and payment methods in Customer Portal").action(billingCommand);
+  program.command("stats").description("Display metrics on token savings, cost ROI, and cache efficiency").option("--reset", "Reset all recorded lifetime metrics").option("--json", "Output stats in raw JSON format").action((opts) => statsCommand({ reset: opts.reset, json: opts.json }));
+  return program;
+}
+async function runCli() {
+  const program = createCli();
+  await program.parseAsync(process.argv);
+}
+if (process.argv[1]) {
+  try {
+    const executed = resolve2(process.argv[1]);
+    const current = fileURLToPath(import.meta.url);
+    if (executed === current) {
+      runCli();
+    }
+  } catch {
+  }
+}
+export {
+  createCli,
+  runCli
+};
+//# sourceMappingURL=cli.js.map