vexp-cli 1.3.8 → 2.0.3

package/dist/cli.js

@@ -2,14 +2,14 @@
 import { Command } from "commander";
 import chalk from "chalk";
 import ora from "ora";
-import { spawn, spawnSync } from "child_process";
+import { spawn, spawnSync, execFileSync } from "child_process";
 import * as path from "path";
 import * as fs from "fs";
 import { checkbox } from "@inquirer/prompts";
 import { getBinaryPath, getInstalledVersion, getMcpServerPath } from "./binary.js";
 import { detectAgents, getAgentList, configureSelectedAgents } from "./agent-config.js";
 import { CLI_VERSION } from "./version.js";
-import { activateLicense, deactivateLicense, readLicenseLimits, } from "./license.js";
+import { activateLicense, deactivateLicense, readLicenseLimits, readDeviceBlocked, } from "./license.js";
 import { checkForUpdate } from "./update-check.js";
 const program = new Command();
 program
@@ -163,14 +163,57 @@ program
     .command("savings")
     .description("Show token savings statistics")
     .option("--days <n>", "Number of days to analyze", "30")
+    .option("--today", "Show savings for today only (since local midnight)")
     .option("--export", "Export report to .vexp/token-savings-report.md")
     .action(async (opts) => {
     const binaryPath = ensureBinary();
-    const args = ["savings", "--days", opts.days];
+    const args = ["savings"];
+    if (opts.today) {
+        // Compute local midnight in unix seconds so the Rust core aggregates
+        // only events from today in the caller's timezone.
+        const midnight = new Date();
+        midnight.setHours(0, 0, 0, 0);
+        const sinceTs = Math.floor(midnight.getTime() / 1000);
+        args.push("--since-ts", String(sinceTs), "--label", "today");
+    }
+    else {
+        args.push("--days", opts.days);
+    }
     if (opts.export)
         args.push("--export");
     runBinary(binaryPath, args);
 });
+program
+    .command("compress <file>")
+    .description("Compress a markdown/text file using caveman-style prose compression (backup to <name>.original.md)")
+    .option("--level <lvl>", "Compression level: off | lite | full | ultra", "full")
+    .action(async (file, opts) => {
+    const binaryPath = ensureBinary();
+    runBinary(binaryPath, ["compress", file, "--level", opts.level]);
+});
+program
+    .command("setup-llm")
+    .description("Configure optional local LLM compression (vexp-devmind). Runs interactive wizard by default.")
+    .option("--status", "Print current LLM config and readiness")
+    .option("--disable", "Disable LLM compression without removing model files")
+    .option("--install", "Non-interactive install (for CI / first-run)")
+    .option("--check-updates", "Check for model updates without downloading")
+    .option("--enable", "Enable a previously-installed LLM without re-downloading anything")
+    .action(async (opts) => {
+    const binaryPath = ensureBinary();
+    const args = ["setup-llm"];
+    if (opts.status)
+        args.push("--status");
+    if (opts.disable)
+        args.push("--disable");
+    if (opts.install)
+        args.push("--install");
+    if (opts.checkUpdates)
+        args.push("--check-updates");
+    if (opts.enable)
+        args.push("--enable");
+    runBinary(binaryPath, args);
+});
 program
     .command("hooks <action>")
     .description("Manage git hooks (install, check, remove)")
@@ -273,6 +316,46 @@ program
     catch {
         spinnerDaemon.warn("Daemon already running or failed to start (non-fatal)");
     }
+    // Step 2.6: Start MCP HTTP server (needed for Codex and HTTP-based agents)
+    const mcpPath = getMcpServerPath();
+    if (mcpPath) {
+        const spinnerMcp = ora("Starting MCP HTTP server...").start();
+        try {
+            const { randomUUID } = await import("crypto");
+            const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+            let mcpToken = "";
+            const tokenPath = home ? path.join(home, ".vexp", "mcp.token") : "";
+            if (tokenPath) {
+                try {
+                    mcpToken = fs.readFileSync(tokenPath, "utf-8").trim();
+                }
+                catch { }
+            }
+            if (!mcpToken) {
+                mcpToken = randomUUID();
+                if (tokenPath) {
+                    fs.mkdirSync(path.dirname(tokenPath), { recursive: true });
+                    fs.writeFileSync(tokenPath, mcpToken, { mode: 0o600 });
+                }
+            }
+            const mcpChild = spawn("node", [mcpPath, "--http", "--port=7821"], {
+                detached: true,
+                stdio: "ignore",
+                env: {
+                    ...process.env,
+                    VEXP_WORKSPACE: workspaceRoot,
+                    VEXP_HTTP: "1",
+                    VEXP_PORT: "7821",
+                    VEXP_MCP_TOKEN: mcpToken,
+                },
+            });
+            mcpChild.unref();
+            spinnerMcp.succeed("MCP HTTP server started (port 7821)");
+        }
+        catch {
+            spinnerMcp.warn("MCP HTTP server failed to start (non-fatal)");
+        }
+    }
     // In personal mode, make .vexp/ fully gitignored
     if (isPersonal) {
         const vexpGitignore = path.join(workspaceRoot, ".vexp", ".gitignore");
@@ -541,6 +624,12 @@ program
     console.log(`  All tools: ${limits.allTools ? "yes" : "no (7/10)"}`);
     if (limits.renewsAt)
         console.log(`  Renews:    ${limits.renewsAt.toLocaleDateString()}`);
+    const blocked = readDeviceBlocked();
+    if (blocked) {
+        console.log("");
+        console.log(chalk.yellow(`  ⚠ This machine is not registered (${blocked.maxDevices}/${blocked.maxDevices} slots used).`));
+        console.log(chalk.dim(`    Free a slot at ${blocked.manageUrl} and run a vexp command\n    to re-register this device.`));
+    }
     console.log("");
 });
 // ────────────────────────────────────────────────────
@@ -562,6 +651,7 @@ const MENU_CONFIG = [
     { key: "3", label: "setup", hint: "Full setup (index + agents + hooks)", description: "One-command bootstrap: indexes the codebase, detects AI agents,\n    writes MCP configs, installs git hooks." },
     { key: "4", label: "setup-agents", hint: "Choose which AI agents to configure", description: "Select agents (Claude, Cursor, Windsurf, Copilot, …) to configure.\n    Creates config directories and writes MCP settings for each." },
     { key: "5", label: "daemon-cmd", hint: "Manage daemon (start/stop/status/logs)", description: "Controls the background daemon:\n    start  → launches the daemon (indexes + watches for changes)\n    stop   → stops the running daemon\n    status → shows node/edge/file counts\n    logs   → prints .vexp/vexp.log" },
+    { key: "6", label: "setup-llm", hint: "Configure local LLM compression (vexp-devmind)", description: "Install, update, or disable the optional local LLM (vexp-devmind).\n    Runs entirely on your machine (~3.5 GB download).\n    Enables smart prompt preprocessing and higher-quality memory compression." },
 ];
 // ── Sub-menu: Explore & Analyze ──
 const MENU_EXPLORE = [
@@ -592,10 +682,30 @@ function printBanner() {
     console.log(chalk.dim("    ╚═══╝  ╚══════╝╚═╝  ╚═╝╚═╝") + chalk.dim(`  v${version}`));
     console.log("");
     console.log(chalk.dim("  Context Engine for AI Coding Agents"));
+    // One-liner LLM status
+    try {
+        const llmBin = ensureBinary();
+        const stdout = execFileSync(llmBin, ["setup-llm", "--status"], {
+            timeout: 5000,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const operational = /Operational:\s*true/.test(stdout);
+        const model = stdout.match(/Model:\s*(.+)/)?.[1]?.trim() ?? "";
+        if (operational) {
+            console.log(chalk.green(`  ● LLM: ${model} (active)`));
+        }
+        else {
+            console.log(chalk.dim("  ○ LLM: not configured — type 'setup-llm' or press 1 > 6"));
+        }
+    }
+    catch {
+        // Binary not available or no local_llm feature — skip silently
+    }
 }
 function printMainMenu() {
     console.log("");
-    console.log(`   ${chalk.cyan.bold("1")}  ${chalk.green("Setup & Config".padEnd(20))} ${chalk.dim("Initialize, index, and configure agents")}`);
+    console.log(`   ${chalk.cyan.bold("1")}  ${chalk.green("Setup & Config".padEnd(20))} ${chalk.dim("Initialize, index, configure agents & LLM")}`);
     console.log(`   ${chalk.cyan.bold("2")}  ${chalk.green("Explore & Analyze".padEnd(20))} ${chalk.dim("Query context, skeletons, impact, flow")}`);
     console.log(`   ${chalk.cyan.bold("3")}  ${chalk.green("Token Savings".padEnd(20))} ${chalk.dim("View savings stats, export report")}`);
     console.log(`   ${chalk.cyan.bold("4")}  ${chalk.green("License".padEnd(20))} ${chalk.dim("View or activate your license")}`);
@@ -732,6 +842,41 @@ async function executeCommand(label, rl) {
                 }
                 break;
             }
+            case "setup-llm": {
+                console.log("");
+                console.log(chalk.cyan("    Local LLM compression (vexp-devmind)"));
+                console.log(chalk.dim("    All processing runs locally — no data leaves your machine.\n"));
+                console.log(`    ${chalk.bold("1")}  Install / Reinstall (~3.5 GB download)`);
+                console.log(`    ${chalk.bold("2")}  Start               (enable without re-downloading)`);
+                console.log(`    ${chalk.bold("3")}  Check for updates   (no download if up to date)`);
+                console.log(`    ${chalk.bold("4")}  Status              (show current config + hardware)`);
+                console.log(`    ${chalk.bold("5")}  Disable             (keep files, stop using LLM)`);
+                console.log(`    ${chalk.dim("b")}  ${chalk.dim("Cancel")}`);
+                console.log("");
+                const llmChoice = await ask(rl, chalk.cyan("    Choose: "));
+                const llmBinary = ensureBinary();
+                switch (llmChoice.trim()) {
+                    case "1":
+                        console.log(chalk.dim("    Starting LLM setup (this may take several minutes)…\n"));
+                        runBinary(llmBinary, ["setup-llm", "--install"]);
+                        break;
+                    case "2":
+                        runBinary(llmBinary, ["setup-llm", "--enable"]);
+                        break;
+                    case "3":
+                        runBinary(llmBinary, ["setup-llm", "--check-updates"]);
+                        break;
+                    case "4":
+                        runBinary(llmBinary, ["setup-llm", "--status"]);
+                        break;
+                    case "5":
+                        runBinary(llmBinary, ["setup-llm", "--disable"]);
+                        break;
+                    default:
+                        console.log(chalk.dim("    Cancelled."));
+                }
+                break;
+            }
             // ── Explore commands ──
             case "capsule": {
                 const query = await ask(rl, chalk.cyan("    Describe your task: "));
@@ -772,17 +917,33 @@ async function executeCommand(label, rl) {
             }
             case "savings": // fallthrough from direct command
             case "summary": {
-                const daysInput = await ask(rl, chalk.cyan("    Period in days (7/14/30/60/90): "));
-                const days = parseInt(daysInput.trim(), 10) || 30;
+                const input = await ask(rl, chalk.cyan("    Period (today / 7 / 14 / 30 / 60 / 90): "));
                 const binaryPath = ensureBinary();
-                runBinary(binaryPath, ["savings", "--days", String(days)]);
+                const trimmed = input.trim().toLowerCase();
+                if (trimmed === "today") {
+                    const midnight = new Date();
+                    midnight.setHours(0, 0, 0, 0);
+                    runBinary(binaryPath, ["savings", "--since-ts", String(Math.floor(midnight.getTime() / 1000)), "--label", "today"]);
+                }
+                else {
+                    const days = parseInt(trimmed, 10) || 30;
+                    runBinary(binaryPath, ["savings", "--days", String(days)]);
+                }
                 break;
             }
             case "export": {
-                const daysInput = await ask(rl, chalk.cyan("    Period in days (7/14/30/60/90): "));
-                const days = parseInt(daysInput.trim(), 10) || 30;
+                const input = await ask(rl, chalk.cyan("    Period (today / 7 / 14 / 30 / 60 / 90): "));
                 const binaryPath = ensureBinary();
-                runBinary(binaryPath, ["savings", "--days", String(days), "--export"]);
+                const trimmed = input.trim().toLowerCase();
+                if (trimmed === "today") {
+                    const midnight = new Date();
+                    midnight.setHours(0, 0, 0, 0);
+                    runBinary(binaryPath, ["savings", "--since-ts", String(Math.floor(midnight.getTime() / 1000)), "--label", "today", "--export"]);
+                }
+                else {
+                    const days = parseInt(trimmed, 10) || 30;
+                    runBinary(binaryPath, ["savings", "--days", String(days), "--export"]);
+                }
                 break;
             }
             // ── License commands ──
@@ -838,4 +999,3 @@ if (process.argv.length <= 2) {
 else {
     program.parse();
 }
-//# sourceMappingURL=cli.js.map

package/dist/hook-template.js

@@ -18,4 +18,3 @@ else
 fi
 exit 0
 `;
-//# sourceMappingURL=hook-template.js.map

package/dist/license.js

@@ -2,12 +2,215 @@ import * as crypto from "crypto";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
+import { CLI_VERSION } from "./version.js";
 // Ed25519 PUBLIC key (DER, base64) — same key as vexp-vscode/src/license.ts.
 // Only the server (vexp.dev) holds the matching private key.
 const VEXP_LICENSE_PUBLIC_KEY = "MCowBQYDK2VwAyEApwiWYGCyhCaGHAHWn/RTBSGo/1MNmGyZUgSNBQ5YE4g=";
+const VEXP_WEB_ORIGIN = process.env.VEXP_WEB_ORIGIN || "https://vexp.dev";
+// 14-day grace window after the last successful online refresh before we
+// stop trusting the cached freshToken and fall back to the long JWT only.
+const GRACE_MS = 14 * 24 * 60 * 60 * 1000;
+// Opportunistic refresh cadence: don't hit the network more than once per 24h.
+const REFRESH_BACKOFF_MS = 24 * 60 * 60 * 1000;
+// 3 second timeout on validate calls — any slower falls back silently.
+const VALIDATE_TIMEOUT_MS = 3000;
 function getLicensePath() {
     return path.join(os.homedir(), ".vexp", "license.jwt");
 }
+function getFreshTokenPath() {
+    return path.join(os.homedir(), ".vexp", "fresh.jwt");
+}
+function getLastCheckPath() {
+    return path.join(os.homedir(), ".vexp", "last_online_check");
+}
+function getDeviceIdPath() {
+    return path.join(os.homedir(), ".vexp", "device.id");
+}
+/**
+ * Stable anonymous device identifier. First call creates and persists it.
+ * Uses OS hostname + a random salt — no PII, no hardware fingerprinting.
+ */
+function getDeviceId() {
+    const p = getDeviceIdPath();
+    try {
+        const existing = fs.readFileSync(p, "utf-8").trim();
+        if (existing)
+            return existing;
+    }
+    catch {
+        // first run
+    }
+    const raw = `${os.hostname()}::${crypto.randomBytes(16).toString("hex")}`;
+    const id = crypto.createHash("sha256").update(raw).digest("hex").slice(0, 32);
+    try {
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.writeFileSync(p, id, "utf-8");
+    }
+    catch {
+        // read-only FS: return the ephemeral id, refresh will still work
+    }
+    return id;
+}
+function readLastCheck() {
+    try {
+        const s = fs.readFileSync(getLastCheckPath(), "utf-8").trim();
+        const n = Number(s);
+        return Number.isFinite(n) ? n : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+function writeLastCheck(ts) {
+    try {
+        fs.mkdirSync(path.dirname(getLastCheckPath()), { recursive: true });
+        fs.writeFileSync(getLastCheckPath(), String(ts), "utf-8");
+    }
+    catch {
+        // ignore
+    }
+}
+function loadFreshToken() {
+    try {
+        const jwt = fs.readFileSync(getFreshTokenPath(), "utf-8").trim();
+        if (!jwt)
+            return null;
+        return verifyAndDecode(jwt);
+    }
+    catch {
+        return null;
+    }
+}
+function saveFreshToken(jwt) {
+    try {
+        fs.mkdirSync(path.dirname(getFreshTokenPath()), { recursive: true });
+        fs.writeFileSync(getFreshTokenPath(), jwt, "utf-8");
+    }
+    catch {
+        // ignore
+    }
+}
+function removeFreshToken() {
+    try {
+        fs.unlinkSync(getFreshTokenPath());
+    }
+    catch {
+        // ignore
+    }
+}
+function getDeviceBlockedPath() {
+    return path.join(os.homedir(), ".vexp", "device_blocked.json");
+}
+/** Returns the active device-blocked marker, if any. */
+export function readDeviceBlocked() {
+    try {
+        const raw = fs.readFileSync(getDeviceBlockedPath(), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed &&
+            typeof parsed.at === "number" &&
+            typeof parsed.maxDevices === "number" &&
+            typeof parsed.manageUrl === "string") {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeDeviceBlocked(info) {
+    try {
+        fs.mkdirSync(path.dirname(getDeviceBlockedPath()), { recursive: true });
+        fs.writeFileSync(getDeviceBlockedPath(), JSON.stringify(info), "utf-8");
+    }
+    catch {
+        // ignore
+    }
+}
+function clearDeviceBlocked() {
+    try {
+        fs.unlinkSync(getDeviceBlockedPath());
+    }
+    catch {
+        // ignore
+    }
+}
+/**
+ * Opportunistic online license refresh.
+ *
+ * Additive-only: any failure (network, 404, 5xx, timeout, server disabled)
+ * results in a silent no-op. The caller keeps using the local long JWT
+ * exactly as before. This MUST never throw.
+ */
+export async function tryOnlineRefresh(longJwt) {
+    // Rate limit: at most one network call per REFRESH_BACKOFF_MS
+    const last = readLastCheck();
+    if (Date.now() - last < REFRESH_BACKOFF_MS)
+        return;
+    // Global kill switch for users who want to stay fully offline
+    if (process.env.VEXP_OFFLINE === "1")
+        return;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), VALIDATE_TIMEOUT_MS);
+    try {
+        const res = await fetch(`${VEXP_WEB_ORIGIN}/api/license/validate`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                jwt: longJwt,
+                deviceId: getDeviceId(),
+                clientVersion: CLI_VERSION,
+            }),
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        // 404 = endpoint not deployed yet (old server), 503 = kill switch
+        if (res.status === 404 || res.status === 503) {
+            return;
+        }
+        if (!res.ok)
+            return;
+        const data = (await res.json());
+        if (data && data.valid && data.freshToken) {
+            // Only save if the freshToken itself verifies locally
+            if (verifyAndDecode(data.freshToken)) {
+                saveFreshToken(data.freshToken);
+                writeLastCheck(Date.now());
+                // Any previous device-blocked state is stale once the server issues
+                // a freshToken for us — we are back in a good state.
+                clearDeviceBlocked();
+            }
+        }
+        else if (data && data.reason === "device_limit_exceeded") {
+            // This machine is over the subscription's device cap. We do NOT touch
+            // the long JWT on disk: the user still owns a valid subscription, they
+            // just need to free a slot on vexp.dev/account/devices. We persist a
+            // marker so the CLI can surface the error next time a command runs.
+            writeDeviceBlocked({
+                at: Date.now(),
+                maxDevices: data.maxDevices ?? 4,
+                manageUrl: data.manageUrl ?? "https://vexp.dev/account/devices",
+            });
+            // Drop any stale freshToken so readLicenseLimits downgrades to FREE
+            // until the user frees a slot and retries.
+            removeFreshToken();
+            writeLastCheck(Date.now());
+        }
+        else if (data && data.revoked) {
+            // Server confirmed revocation. Drop the cached freshToken but keep
+            // the long JWT on disk — the user will fall back to whatever the
+            // long JWT allows until it expires naturally.
+            removeFreshToken();
+            writeLastCheck(Date.now());
+        }
+    }
+    catch {
+        // network error, timeout, abort — silent no-op
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
 function verifyAndDecode(jwt) {
     try {
         const parts = jwt.split(".");
@@ -48,7 +251,7 @@ export function activateLicense(jwt) {
     fs.writeFileSync(licensePath, jwt, "utf-8");
     return claims;
 }
-/** Remove the current license file */
+/** Remove the current license file (and any cached freshToken) */
 export function deactivateLicense() {
     const licensePath = getLicensePath();
     try {
@@ -58,24 +261,17 @@ export function deactivateLicense() {
     catch {
         // ignore
     }
-}
-/** Read license from ~/.vexp/license.jwt, verify, and return tier limits */
-export function readLicenseLimits() {
-    const licensePath = getLicensePath();
-    let jwt;
+    removeFreshToken();
+    clearDeviceBlocked();
     try {
-        jwt = fs.readFileSync(licensePath, "utf-8").trim();
+        if (fs.existsSync(getLastCheckPath()))
+            fs.unlinkSync(getLastCheckPath());
     }
     catch {
-        return FREE_LIMITS;
-    }
-    if (!jwt)
-        return FREE_LIMITS;
-    const claims = verifyAndDecode(jwt);
-    if (!claims || claims.exp * 1000 < Date.now()) {
-        return FREE_LIMITS;
+        // ignore
     }
-    // pe = Stripe period_end (renewal date), fallback to exp (JWT expiry)
+}
+function claimsToLimits(claims) {
     const renewsAt = new Date((claims.pe ?? claims.exp) * 1000);
     switch (claims.plan) {
         case "team":
@@ -86,4 +282,55 @@ export function readLicenseLimits() {
             return FREE_LIMITS;
     }
 }
-//# sourceMappingURL=license.js.map
+/**
+ * Read license from ~/.vexp/license.jwt, verify, and return tier limits.
+ *
+ * Phase 3 online validation is additive:
+ * 1. If a freshToken exists in ~/.vexp/fresh.jwt and is still valid, trust it
+ *    (it was signed by the server during the last successful refresh).
+ * 2. Otherwise, fall back to the long JWT in ~/.vexp/license.jwt exactly as
+ *    before (this is the zero-change path for users who never hit the server).
+ * 3. Fire a background refresh attempt. Any failure is silent — the caller
+ *    never sees a network error.
+ *
+ * The long JWT is NEVER deleted based on server response. The worst a
+ * successful server revoke does is remove the cached freshToken, after
+ * which the long JWT expires naturally at its own `exp`.
+ */
+export function readLicenseLimits() {
+    const licensePath = getLicensePath();
+    let longJwt;
+    try {
+        longJwt = fs.readFileSync(licensePath, "utf-8").trim();
+    }
+    catch {
+        return FREE_LIMITS;
+    }
+    if (!longJwt)
+        return FREE_LIMITS;
+    const longClaims = verifyAndDecode(longJwt);
+    if (!longClaims || longClaims.exp * 1000 < Date.now()) {
+        return FREE_LIMITS;
+    }
+    // Device cap enforcement: if this machine is over-cap, the server told
+    // us to downgrade here until a slot is freed. The long JWT stays on disk
+    // so that once the slot is freed, the next refresh lifts the block.
+    if (readDeviceBlocked()) {
+        return FREE_LIMITS;
+    }
+    // Fire-and-forget opportunistic refresh. Never awaited — we do not block
+    // CLI startup on the network.
+    void tryOnlineRefresh(longJwt);
+    // Prefer a still-valid freshToken within the grace window
+    const fresh = loadFreshToken();
+    if (fresh && fresh.exp * 1000 > Date.now()) {
+        const lastCheck = readLastCheck();
+        if (lastCheck === 0 || Date.now() - lastCheck < GRACE_MS) {
+            return claimsToLimits(fresh);
+        }
+        // freshToken is valid but the last successful refresh is older than the
+        // grace window → server is unreachable for too long. Fall back to the
+        // long JWT (keeps working as today, no downgrade to free).
+    }
+    return claimsToLimits(longClaims);
+}

package/dist/update-check.js

@@ -87,4 +87,3 @@ export async function checkForUpdate() {
         process.exit(1);
     }
 }
-//# sourceMappingURL=update-check.js.map

package/dist/version.js

@@ -2,4 +2,3 @@ import { createRequire } from "module";
 const require = createRequire(import.meta.url);
 const pkg = require("../package.json");
 export const CLI_VERSION = pkg.version || "0.0.0";
-//# sourceMappingURL=version.js.map