npm - moon-iq - Versions diffs - 0.1.0 - Mend

moon-iq 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/index.js ADDED Viewed

@@ -0,0 +1,1005 @@
+#!/usr/bin/env node
+// src/index.ts
+import { Command, Option } from "commander";
+// src/auth.ts
+import { execSync } from "child_process";
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as http from "http";
+import * as os from "os";
+import * as path from "path";
+function generateCodeVerifier() {
+  return crypto.randomBytes(32).toString("base64url");
+}
+function generateCodeChallenge(verifier) {
+  return crypto.createHash("sha256").update(verifier).digest("base64url");
+}
+var CONFIG_DIR = path.join(os.homedir(), ".mooniq");
+var CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+var CREDENTIALS_PATH = path.join(CONFIG_DIR, "credentials.json");
+var CALLBACK_PORT = 3847;
+var CALLBACK_URL = `http://localhost:${CALLBACK_PORT}/callback`;
+var DEFAULT_CONFIG = {
+  baseUrl: "https://moon-iq.com",
+  clientId: "mooniq_zin3s5jz3olzkdfxpmbeaogv"
+};
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function getConfig() {
+  if (!fs.existsSync(CONFIG_PATH)) {
+    return null;
+  }
+  try {
+    const data = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+    if (!data.baseUrl || !data.clientId) {
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+function getConfigOrDefault(baseUrl) {
+  const fromFile = getConfig();
+  if (fromFile) return fromFile;
+  const config = {
+    ...DEFAULT_CONFIG,
+    baseUrl: baseUrl ?? DEFAULT_CONFIG.baseUrl
+  };
+  saveConfig(config);
+  return config;
+}
+function getCredentials() {
+  if (!fs.existsSync(CREDENTIALS_PATH)) {
+    return null;
+  }
+  try {
+    const data = JSON.parse(fs.readFileSync(CREDENTIALS_PATH, "utf-8"));
+    if (!data.accessToken || !data.baseUrl) {
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+function saveCredentials(creds) {
+  ensureConfigDir();
+  fs.writeFileSync(CREDENTIALS_PATH, JSON.stringify(creds, null, 2), "utf-8");
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+}
+function clearCredentials() {
+  if (fs.existsSync(CREDENTIALS_PATH)) {
+    fs.unlinkSync(CREDENTIALS_PATH);
+  }
+}
+function openBrowser(url) {
+  const platform = process.platform;
+  const command = platform === "darwin" ? `open "${url}"` : platform === "win32" ? `start "" "${url}"` : `xdg-open "${url}"`;
+  execSync(command);
+}
+async function login(config) {
+  const state = crypto.randomUUID();
+  const usePkce = !config.clientSecret;
+  let codeVerifier;
+  if (usePkce) {
+    codeVerifier = generateCodeVerifier();
+  }
+  let resolveCallback;
+  const codePromise = new Promise((resolve) => {
+    resolveCallback = resolve;
+  });
+  let callbackSocket = null;
+  const server = http.createServer((req, res) => {
+    const url = new URL(req.url ?? "/", `http://localhost:${CALLBACK_PORT}`);
+    if (url.pathname === "/callback") {
+      const code2 = url.searchParams.get("code");
+      const error = url.searchParams.get("error");
+      const errorDesc = url.searchParams.get("error_description");
+      if (error) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          `<!DOCTYPE html><html><head><meta charset="utf-8"><title>OAuth Error</title></head><body style="font-family:system-ui,sans-serif;display:flex;flex-direction:column;align-items:center;justify-content:center;min-height:100vh;margin:0;padding:2rem;text-align:center;background:#fef2f2"><h1 style="color:#b91c1c;margin:0 0 1rem">OAuth Error</h1><p style="color:#991b1b;margin:0">${error}: ${errorDesc ?? "Unknown error"}</p></body></html>`
+        );
+        resolveCallback("");
+        setTimeout(() => server.close(), 2e3);
+      } else if (code2) {
+        callbackSocket = res.socket ?? req.socket;
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          `<!DOCTYPE html><html><head><meta charset="utf-8"><title>Success</title></head><body style="font-family:system-ui,sans-serif;display:flex;flex-direction:column;align-items:center;justify-content:center;min-height:100vh;margin:0;padding:2rem;text-align:center;background:#f0fdf4"><h1 style="color:#166534;margin:0 0 1rem;font-size:1.5rem">\u2713 Success!</h1><p style="color:#15803d;margin:0;font-size:1.1rem">You can close this page and return to the terminal.</p></body></html>`
+        );
+        resolveCallback(code2);
+      } else {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          `<!DOCTYPE html><html><head><meta charset="utf-8"><title>Error</title></head><body style="font-family:system-ui,sans-serif;display:flex;flex-direction:column;align-items:center;justify-content:center;min-height:100vh;margin:0;padding:2rem;text-align:center;background:#fef2f2"><h1 style="color:#b91c1c;margin:0 0 1rem">Error</h1><p style="color:#991b1b;margin:0">No authorization code received.</p></body></html>`
+        );
+        resolveCallback("");
+        setTimeout(() => server.close(), 2e3);
+      }
+    } else {
+      res.writeHead(204);
+      res.end();
+    }
+  });
+  await new Promise((resolve, reject) => {
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        reject(
+          new Error(
+            `Port ${CALLBACK_PORT} is in use. Close the other process or run: lsof -i :${CALLBACK_PORT}`
+          )
+        );
+      } else {
+        reject(err);
+      }
+    });
+    server.listen(CALLBACK_PORT, "0.0.0.0", () => resolve());
+  });
+  console.log(
+    `Waiting for callback at http://localhost:${CALLBACK_PORT}/callback`
+  );
+  const authorizeParams = new URLSearchParams({
+    client_id: config.clientId,
+    redirect_uri: CALLBACK_URL,
+    response_type: "code",
+    scope: "profile email",
+    state
+  });
+  if (usePkce && codeVerifier) {
+    authorizeParams.set("code_challenge", generateCodeChallenge(codeVerifier));
+    authorizeParams.set("code_challenge_method", "S256");
+  }
+  const authorizeUrl = `${config.baseUrl}/api/oauth/authorize?${authorizeParams.toString()}`;
+  console.log("Opening browser for authorization...");
+  console.log("(Make sure you're logged in to Moon IQ in your browser)\n");
+  openBrowser(authorizeUrl);
+  const code = await codePromise;
+  if (!code) {
+    throw new Error("No authorization code received");
+  }
+  const tokenParams = {
+    grant_type: "authorization_code",
+    code,
+    client_id: config.clientId,
+    redirect_uri: CALLBACK_URL
+  };
+  if (config.clientSecret) {
+    tokenParams.client_secret = config.clientSecret;
+  }
+  if (usePkce && codeVerifier) {
+    tokenParams.code_verifier = codeVerifier;
+  }
+  const tokenResponse = await fetch(`${config.baseUrl}/api/oauth/token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams(tokenParams)
+  });
+  if (!tokenResponse.ok) {
+    const err = await tokenResponse.json().catch(() => ({}));
+    const msg = err.error_description ?? err.error ?? tokenResponse.statusText;
+    throw new Error(`Token exchange failed: ${msg}`);
+  }
+  const tokens = await tokenResponse.json();
+  const expiresAt = Date.now() + (tokens.expires_in ?? 3600) * 1e3;
+  const creds = {
+    accessToken: tokens.access_token,
+    refreshToken: tokens.refresh_token ?? null,
+    expiresAt,
+    baseUrl: config.baseUrl
+  };
+  saveCredentials(creds);
+  server.close();
+  if (callbackSocket && "destroy" in callbackSocket) {
+    callbackSocket.destroy();
+  }
+  return creds;
+}
+async function refreshCredentials(creds, config) {
+  if (!creds.refreshToken) {
+    throw new Error("No refresh token available");
+  }
+  const refreshParams = {
+    grant_type: "refresh_token",
+    refresh_token: creds.refreshToken,
+    client_id: config.clientId
+  };
+  if (config.clientSecret) {
+    refreshParams.client_secret = config.clientSecret;
+  }
+  const tokenResponse = await fetch(`${config.baseUrl}/api/oauth/token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams(refreshParams)
+  });
+  if (!tokenResponse.ok) {
+    throw new Error("Token refresh failed");
+  }
+  const tokens = await tokenResponse.json();
+  const expiresAt = Date.now() + (tokens.expires_in ?? 3600) * 1e3;
+  const newCreds = {
+    accessToken: tokens.access_token,
+    refreshToken: tokens.refresh_token ?? creds.refreshToken,
+    expiresAt,
+    baseUrl: config.baseUrl
+  };
+  saveCredentials(newCreds);
+  return newCreds;
+}
+var TOKEN_EXPIRY_BUFFER_MS = 5 * 60 * 1e3;
+async function getValidToken() {
+  const creds = getCredentials();
+  if (!creds) return null;
+  const config = getConfig();
+  if (!config || config.baseUrl !== creds.baseUrl) return null;
+  if (Date.now() >= creds.expiresAt - TOKEN_EXPIRY_BUFFER_MS) {
+    if (creds.refreshToken) {
+      try {
+        const newCreds = await refreshCredentials(creds, config);
+        return newCreds.accessToken;
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  return creds.accessToken;
+}
+// src/generated/client.ts
+var TOOL_NAMES = [
+  "iron_account_create",
+  "iron_account_retrieve",
+  "iron_offramp_create",
+  "iron_offramp_initiate",
+  "iron_offramp_list",
+  "iron_offramp_retrieve",
+  "iron_onramp_create",
+  "iron_onramp_list",
+  "iron_onramp_retrieve",
+  "lending_account_retrieve",
+  "lending_deposit",
+  "lending_rate_retrieve",
+  "lending_recommend",
+  "lending_withdraw",
+  "moonit_buy",
+  "moonit_buy_recommend",
+  "moonit_sell",
+  "moonit_sell_recommend",
+  "moonit_token_list",
+  "moonpay_buy",
+  "rhythm_token_list",
+  "rhythm_token_trending_list",
+  "rhythm_trade_list",
+  "token_balance_list",
+  "token_balance_retrieve",
+  "token_buy",
+  "token_digest_retrieve",
+  "token_limit_buy",
+  "token_limit_buy_recommend",
+  "token_limit_order_list",
+  "token_limit_recommend",
+  "token_limit_sell",
+  "token_limit_sell_recommend",
+  "token_recurring_buy",
+  "token_recurring_order_list",
+  "token_recurring_recommend",
+  "token_recurring_sell",
+  "token_retrieve",
+  "token_search",
+  "token_sell",
+  "token_swap",
+  "token_swap_recommend",
+  "token_trending_list",
+  "user_retrieve",
+  "user_update"
+];
+var TOOL_DEFINITIONS = [
+  {
+    "name": "iron_account_create",
+    "description": "Create a new Iron account for the user.",
+    "options": []
+  },
+  {
+    "name": "iron_account_retrieve",
+    "description": "Get the user's Iron account information.",
+    "options": []
+  },
+  {
+    "name": "iron_offramp_create",
+    "description": "Create a new offramp for the user to convert crypto to fiat",
+    "options": [
+      {
+        "name": "name",
+        "type": "string",
+        "description": "The name of the offramp",
+        "required": true
+      },
+      {
+        "name": "fiat",
+        "type": "string",
+        "description": "The fiat currency to convert to",
+        "required": true
+      },
+      {
+        "name": "stablecoin",
+        "type": "string",
+        "description": "The stablecoin token to convert from",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "iron_offramp_initiate",
+    "description": "Initiate an offramp by sending stablecoin to the offramp's deposit account. The stablecoin will be converted to fiat and deposited into your registered bank account. This process is asynchronous and may take some time for funds to appear in your bank account.",
+    "options": []
+  },
+  {
+    "name": "iron_offramp_list",
+    "description": "Get all offramps for the user",
+    "options": []
+  },
+  {
+    "name": "iron_offramp_retrieve",
+    "description": "Get an offramp for the user",
+    "options": [
+      {
+        "name": "offrampId",
+        "type": "string",
+        "description": "The ID of the offramp to retrieve",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "iron_onramp_create",
+    "description": "Create an onramp to convert fiat currency to a stablecoin",
+    "options": [
+      {
+        "name": "name",
+        "type": "string",
+        "description": "The name of the onramp",
+        "required": true
+      },
+      {
+        "name": "fiat",
+        "type": "string",
+        "description": "The fiat currency to convert from",
+        "required": true
+      },
+      {
+        "name": "stablecoin",
+        "type": "string",
+        "description": "The stablecoin token to convert to",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "iron_onramp_list",
+    "description": "Get all onramps for the user",
+    "options": [
+      {
+        "name": "status",
+        "type": "string",
+        "description": "Status of the onramps to get",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "iron_onramp_retrieve",
+    "description": "Get an onramp for the user",
+    "options": [
+      {
+        "name": "onrampId",
+        "type": "string",
+        "description": "The ID of the onramp to retrieve",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "lending_account_retrieve",
+    "description": "Get account details for a lending account by wallet address, including balances, interest earned, and withdrawal limits",
+    "options": []
+  },
+  {
+    "name": "lending_deposit",
+    "description": "Deposit USDC into your lending account to earn interest.",
+    "options": []
+  },
+  {
+    "name": "lending_rate_retrieve",
+    "description": "Get current and historical interest rates for lending USDC",
+    "options": []
+  },
+  {
+    "name": "lending_recommend",
+    "description": "Analyze user's lending account and wallet balances to recommend either a deposit or withdraw action with appropriate parameters. Understands queries like 'should I deposit more?', 'recommend a withdrawal', or 'what should I do with my lending account?'.",
+    "options": [
+      {
+        "name": "query",
+        "type": "string",
+        "description": "Natural language query about lending recommendations. Examples: 'should I deposit more?', 'recommend a withdrawal', 'what should I do with my lending account?'.",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "lending_withdraw",
+    "description": "Withdraw USDC from your lending account.",
+    "options": []
+  },
+  {
+    "name": "moonit_buy",
+    "description": "Buy tokens on Moonit platform using bonding curve. This tool converts USDC to SOL, then uses the SOL as collateral to buy Moonit tokens. It builds, signs, and executes the transaction. Note: This tool requires SOL for transaction fees.",
+    "options": []
+  },
+  {
+    "name": "moonit_buy_recommend",
+    "description": "Parse natural language queries into structured buy parameters for Moonit on Solana. Understands queries like 'buy 100 USDC worth of Moonit token', 'buy $50 worth of token ABC', or 'buy all my USDC worth of Moonit token XYZ'. Returns the recommended buy parameters ready to use with moonit_buy.",
+    "options": [
+      {
+        "name": "query",
+        "type": "string",
+        "description": "Natural language description of the desired buy transaction on Moonit. Examples: 'buy 100 USDC worth of Moonit token', 'buy $50 worth of token ABC', 'buy all my USDC worth of Moonit token XYZ'. The agent will parse token and amount from this query.",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "moonit_sell",
+    "description": "Sell tokens on Moonit platform using bonding curve. This tool sells Moonit tokens to get SOL, then converts SOL to USDC. It builds, signs, and executes the transaction. Note: This tool requires SOL for transaction fees.",
+    "options": []
+  },
+  {
+    "name": "moonit_sell_recommend",
+    "description": "Parse natural language queries into structured sell parameters for Moonit on Solana. Understands queries like 'sell 100 SANTAMOON tokens', 'sell all my Moonit tokens', or 'sell 50% of my token ABC'. Returns the recommended sell parameters ready to use with moonit_sell.",
+    "options": [
+      {
+        "name": "query",
+        "type": "string",
+        "description": "Natural language description of the desired sell transaction on Moonit. Examples: 'sell 100 SANTAMOON tokens', 'sell all my Moonit tokens', 'sell 50% of my token ABC'. The agent will parse token and amount from this query.",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "moonit_token_list",
+    "description": "Get the most popular Moonit tokens sorted by market capitalization. Moonit is a token launch platform by DEX Screener x Helio offering bonding curve mechanics, daily LP rewards, and graduation to Raydium/Meteora DEXs.",
+    "options": []
+  },
+  {
+    "name": "moonpay_buy",
+    "description": "Buy a token using Moonpay. Specify either from.amount (USD to spend) or to.amount (tokens to buy), not both.",
+    "options": [
+      {
+        "name": "from",
+        "type": "string",
+        "description": "Payment currency and amount to spend",
+        "required": true
+      },
+      {
+        "name": "to",
+        "type": "string",
+        "description": "Destination chain, currency, and token amount",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "rhythm_token_list",
+    "description": "List tokens from Rhythm",
+    "options": []
+  },
+  {
+    "name": "rhythm_token_trending_list",
+    "description": "Get trending tokens from Rhythm",
+    "options": [
+      {
+        "name": "type",
+        "type": "string",
+        "description": "Type of trending tokens to get",
+        "required": true,
+        "choices": [
+          "holding_strong",
+          "survivor",
+          "legacies"
+        ]
+      }
+    ]
+  },
+  {
+    "name": "rhythm_trade_list",
+    "description": "Get whale trades from Rhythm discover",
+    "options": []
+  },
+  {
+    "name": "token_balance_list",
+    "description": "List all token balances held in a wallet, including amount owned, current value in USD, and token details. Shows the complete token portfolio.",
+    "options": [
+      {
+        "name": "wallet",
+        "type": "string",
+        "description": "Wallet address to check token balances for",
+        "required": true
+      },
+      {
+        "name": "chain",
+        "type": "string",
+        "description": "Blockchain to check balances on (e.g. 'solana', 'ethereum', 'base')",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_balance_retrieve",
+    "description": "Get the balance of a specific token in a wallet, including the amount owned, current USD value, and token price. Returns zero balance if token is not held.",
+    "options": [
+      {
+        "name": "wallet",
+        "type": "string",
+        "description": "Wallet address to check the balance for",
+        "required": true
+      },
+      {
+        "name": "token",
+        "type": "string",
+        "description": "Token address to check the balance of",
+        "required": true
+      },
+      {
+        "name": "chain",
+        "type": "string",
+        "description": "Blockchain where the token and wallet exist",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_buy",
+    "description": "Swap the specified amount of USDC for a token.",
+    "options": []
+  },
+  {
+    "name": "token_digest_retrieve",
+    "description": "Retrieve a token digest by token and chain.",
+    "options": [
+      {
+        "name": "token",
+        "type": "string",
+        "description": "Token address",
+        "required": true
+      },
+      {
+        "name": "chain",
+        "type": "string",
+        "description": "Blockchain network where the token exists",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_limit_buy",
+    "description": "Create a limit buy order to swap USDC for a token at a specific price.",
+    "options": []
+  },
+  {
+    "name": "token_limit_buy_recommend",
+    "description": "Parse natural language queries into structured limit buy parameters. Understands queries like 'buy BONK at $0.00001', 'limit buy 100 USDC worth of SOL when price reaches $150', or 'buy BONK at $0.00001 with 50 USDC'. Returns the recommended limit buy parameters ready to use with token_limit_buy.",
+    "options": [
+      {
+        "name": "query",
+        "type": "string",
+        "description": "Natural language description of the desired limit buy order. Examples: 'buy BONK at $0.00001', 'limit buy 100 USDC worth of SOL when price reaches $150', 'buy BONK at $0.00001 with 50 USDC'. The agent will parse token, amount, and price from this query.",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_limit_order_list",
+    "description": "Get limit orders for the authenticated user.",
+    "options": []
+  },
+  {
+    "name": "token_limit_recommend",
+    "description": "Parse natural language queries into structured limit order parameters (buy or sell). Understands queries like 'buy BONK at $0.00001', 'sell BONK at $0.00002', 'limit buy 100 USDC worth of SOL when price reaches $150', or 'sell all my BONK at $0.00002'. Automatically determines if the request is a buy or sell order and returns the appropriate parameters ready to use with token_limit_buy or token_limit_sell.",
+    "options": [
+      {
+        "name": "query",
+        "type": "string",
+        "description": "Natural language description of the desired limit order (buy or sell). Examples: 'buy BONK at $0.00001', 'sell BONK at $0.00002', 'limit buy 100 USDC worth of SOL when price reaches $150', 'sell all my BONK at $0.00002'. The agent will parse the order type (buy/sell), token, amount, and price from this query.",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_limit_sell",
+    "description": "Create a limit sell order to swap a token for USDC at a specific price.",
+    "options": []
+  },
+  {
+    "name": "token_limit_sell_recommend",
+    "description": "Parse natural language queries into structured limit sell parameters. Understands queries like 'sell BONK at $0.00002', 'limit sell 100 SOL when price reaches $200', or 'sell all my BONK at $0.00002'. Returns the recommended limit sell parameters ready to use with token_limit_sell.",
+    "options": [
+      {
+        "name": "query",
+        "type": "string",
+        "description": "Natural language description of the desired limit sell order. Examples: 'sell BONK at $0.00002', 'limit sell 100 SOL when price reaches $200', 'sell all my BONK at $0.00002'. The agent will parse token, amount, and price from this query.",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_recurring_buy",
+    "description": "Create a recurring buy order (DCA) to swap USDC for a token at regular intervals.",
+    "options": []
+  },
+  {
+    "name": "token_recurring_order_list",
+    "description": "Get recurring orders.",
+    "options": []
+  },
+  {
+    "name": "token_recurring_recommend",
+    "description": "Parse natural language queries into structured recurring order (DCA) parameters (buy or sell). Understands queries like 'buy BONK daily with 50 USDC for 10 days', 'sell BONK daily, 100 tokens per order for 10 days', 'DCA 100 USDC into SOL weekly for a month', or 'recurring sell SOL every day, 0.5 SOL, 20 orders'. Automatically determines if the request is a buy or sell order and returns the appropriate parameters ready to use with token_recurring_buy or token_recurring_sell.",
+    "options": [
+      {
+        "name": "query",
+        "type": "string",
+        "description": "Natural language description of the desired recurring order (buy or sell). Examples: 'buy BONK daily with 50 USDC for 10 days', 'sell BONK daily, 100 tokens per order for 10 days', 'DCA 100 USDC into SOL weekly for a month', 'recurring sell SOL every day, 0.5 SOL, 20 orders'. The agent will parse the order type (buy/sell), token, amount, interval, and numberOfOrders from this query.",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_recurring_sell",
+    "description": "Create a recurring sell order (DCA) to swap a token for USDC at regular intervals.",
+    "options": []
+  },
+  {
+    "name": "token_retrieve",
+    "description": "Get detailed token information including market data, price changes, volume, trades, and holder statistics by token address",
+    "options": [
+      {
+        "name": "token",
+        "type": "string",
+        "description": "Address of the token to retrieve",
+        "required": true
+      },
+      {
+        "name": "chain",
+        "type": "string",
+        "description": "Blockchain network where the token exists",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_search",
+    "description": "Search for tokens by name, symbol, or address. Returns matching tokens with their market data including price, volume, and liquidity.",
+    "options": [
+      {
+        "name": "query",
+        "type": "string",
+        "description": "Search term - can be token name (e.g. 'Bitcoin'), symbol (e.g. 'BTC'), or partial match",
+        "required": true
+      },
+      {
+        "name": "chain",
+        "type": "string",
+        "description": "Blockchain to search on (e.g. 'solana', 'ethereum', 'base')",
+        "required": true
+      },
+      {
+        "name": "limit",
+        "type": "number",
+        "description": "Maximum number of results to return (optional, defaults to 5)",
+        "required": false
+      }
+    ]
+  },
+  {
+    "name": "token_sell",
+    "description": "Swap the specified amount of tokens for USDC.",
+    "options": []
+  },
+  {
+    "name": "token_swap",
+    "description": "Swap the specified amount of input token for output token.",
+    "options": []
+  },
+  {
+    "name": "token_swap_recommend",
+    "description": "Parse natural language queries into structured swap parameters for swapping tokens on Solana. Understands queries like 'swap 100 USDC for SOL', 'swap all my USDC for BONK', or '50 SOL to USDC'. Returns the recommended swap parameters ready to use with token_swap.",
+    "options": [
+      {
+        "name": "query",
+        "type": "string",
+        "description": "Natural language description of the desired swap on Solana. Examples: 'swap 100 USDC for SOL', 'swap all my USDC for BONK', '50 SOL to USDC', 'convert my SOL to USDC'. The agent will parse tokens and amounts from this query.",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_trending_list",
+    "description": "Get currently trending tokens on a blockchain, sorted by popularity rank, trading volume, or liquidity. Perfect for discovering what's hot right now.",
+    "options": []
+  },
+  {
+    "name": "user_retrieve",
+    "description": "Retrieve the currently authenticated user from the session context.",
+    "options": []
+  },
+  {
+    "name": "user_update",
+    "description": "Update user fields in the database. This is a PUT-style update requiring all updatable fields (developer, firstName, lastName, username) to be sent. You must first call user_retrieve to get the current user state, then update with all four fields.",
+    "options": [
+      {
+        "name": "developer",
+        "type": "boolean",
+        "description": "Whether the user is a developer",
+        "required": true
+      },
+      {
+        "name": "firstName",
+        "type": "string",
+        "description": "The user's first name, or null to clear it",
+        "required": false
+      },
+      {
+        "name": "lastName",
+        "type": "string",
+        "description": "The user's last name, or null to clear it",
+        "required": false
+      },
+      {
+        "name": "username",
+        "type": "string",
+        "description": "The user's username (3-20 lowercase letters, numbers, and underscores, must start with a letter), or null to clear it",
+        "required": false
+      }
+    ]
+  }
+];
+// src/client.ts
+async function callToolWithToken(baseUrl, token, toolName, params) {
+  const res = await fetch(`${baseUrl}/api/tools/${toolName}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify(params)
+  });
+  const data = await res.json();
+  return { data, status: res.status };
+}
+async function callToolWithAuth(baseUrl, toolName, params) {
+  let token = await getValidToken();
+  if (!token) {
+    throw new Error(
+      "Not logged in. Run `mooniq login` first and ensure ~/.mooniq/config.json has baseUrl and clientId."
+    );
+  }
+  let result = await callToolWithToken(baseUrl, token, toolName, params);
+  if (result.status === 401) {
+    const creds = getCredentials();
+    const config = getConfig();
+    if (creds?.refreshToken && config && config.baseUrl === creds.baseUrl) {
+      try {
+        const newCreds = await refreshCredentials(creds, config);
+        result = await callToolWithToken(
+          baseUrl,
+          newCreds.accessToken,
+          toolName,
+          params
+        );
+      } catch {
+      }
+    }
+  }
+  if (result.status < 200 || result.status >= 300) {
+    const err = result.data;
+    throw new Error(err?.error ?? "Tool call failed");
+  }
+  return result.data;
+}
+// src/index.ts
+var DEFAULT_BASE_URL = "https://moon-iq.com";
+var program = new Command();
+program.name("mooniq").description("Moon IQ CLI").version("0.1.0");
+program.command("login").description("Log in to Moon IQ via OAuth").option(
+  "-b, --base-url <url>",
+  "Base URL (default: https://moon-iq.com or from ~/.mooniq/config.json)"
+).action(async (options) => {
+  const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+  const config = getConfigOrDefault(baseUrl);
+  try {
+    await login({ ...config, baseUrl });
+    console.log("Logged in successfully.");
+  } catch (error) {
+    console.error("Login failed:", error.message);
+    process.exit(1);
+  }
+});
+program.command("logout").description("Log out and clear stored credentials").action(() => {
+  clearCredentials();
+  console.log("Logged out.");
+});
+program.command("whoami").description("Show current user info").action(async () => {
+  let token = await getValidToken();
+  if (!token) {
+    console.error("Not logged in. Run `mooniq login` first.");
+    process.exit(1);
+  }
+  const creds = getCredentials();
+  const config = getConfig();
+  const baseUrl = config?.baseUrl ?? creds?.baseUrl ?? DEFAULT_BASE_URL;
+  let res = await fetch(`${baseUrl}/api/oauth/userinfo`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (res.status === 401 && creds?.refreshToken && config && config.baseUrl === creds.baseUrl) {
+    try {
+      const newCreds = await refreshCredentials(creds, config);
+      res = await fetch(`${baseUrl}/api/oauth/userinfo`, {
+        headers: { Authorization: `Bearer ${newCreds.accessToken}` }
+      });
+    } catch {
+    }
+  }
+  if (!res.ok) {
+    console.error("Failed to fetch user info:", res.status);
+    process.exit(1);
+  }
+  const userinfo = await res.json();
+  console.log(JSON.stringify(userinfo, null, 2));
+});
+program.command("run <tool_name>").description("Run a tool by name. Use --input for JSON params.").option(
+  "-i, --input <json>",
+  "Input parameters as JSON (omit for empty params)"
+).option(
+  "-b, --base-url <url>",
+  "Base URL (default: from credentials or https://moon-iq.com)"
+).addHelpText(
+  "after",
+  `
+Examples:
+  mooniq run user_retrieve                    # no params
+  mooniq run token_search --input '{"query":"SOL","chain":"solana"}'   # with params
+`
+).action(async (toolName, options) => {
+  const toolNames = TOOL_NAMES;
+  if (!toolNames.includes(toolName)) {
+    console.error(`Unknown tool: ${toolName}`);
+    console.error(`Available tools: ${toolNames.slice(0, 10).join(", ")}...`);
+    process.exit(1);
+  }
+  let params = {};
+  if (options.input) {
+    try {
+      params = JSON.parse(options.input);
+    } catch {
+      console.error("Invalid JSON in --input");
+      process.exit(1);
+    }
+  }
+  const creds = getCredentials();
+  const config = getConfig();
+  const baseUrl = options.baseUrl ?? config?.baseUrl ?? creds?.baseUrl ?? DEFAULT_BASE_URL;
+  try {
+    const result = await callToolWithAuth(baseUrl, toolName, params);
+    console.log(JSON.stringify(result, null, 2));
+  } catch (error) {
+    console.error("Tool call failed:", error.message);
+    process.exit(1);
+  }
+});
+program.command("tools").description("List available tools").action(() => {
+  TOOL_NAMES.forEach((name) => console.log(name));
+});
+function buildToolCommands(program2) {
+  const root = { children: /* @__PURE__ */ new Map() };
+  for (const tool of TOOL_DEFINITIONS) {
+    const parts = tool.name.split("_");
+    let current = root;
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      if (!current.children.has(part)) {
+        current.children.set(part, { children: /* @__PURE__ */ new Map() });
+      }
+      current = current.children.get(part);
+      if (i === parts.length - 1) {
+        current.tool = tool;
+      }
+    }
+  }
+  function createCommands(node, parent, path2) {
+    for (const [name, child] of node.children) {
+      const currentPath = [...path2, name];
+      if (child.tool) {
+        const cmd = parent.command(name).description(child.tool.description || `Run ${child.tool.name}`);
+        for (const opt of child.tool.options) {
+          const optionFlag = createOptionFlag(opt);
+          const option = new Option(optionFlag, opt.description);
+          if (opt.choices) {
+            option.choices(opt.choices);
+          }
+          if (opt.required) {
+            cmd.addOption(option);
+          } else {
+            cmd.addOption(option);
+          }
+        }
+        cmd.option(
+          "-b, --base-url <url>",
+          "Base URL (default: from credentials or https://moon-iq.com)"
+        );
+        const toolName = child.tool.name;
+        cmd.action(async (options) => {
+          const params = buildParams(child.tool.options, options);
+          const creds = getCredentials();
+          const config = getConfig();
+          const baseUrl = options.baseUrl ?? config?.baseUrl ?? creds?.baseUrl ?? DEFAULT_BASE_URL;
+          try {
+            const result = await callToolWithAuth(baseUrl, toolName, params);
+            console.log(JSON.stringify(result, null, 2));
+          } catch (error) {
+            console.error("Tool call failed:", error.message);
+            process.exit(1);
+          }
+        });
+        if (child.children.size > 0) {
+          createCommands(child, cmd, currentPath);
+        }
+      } else if (child.children.size > 0) {
+        const cmd = parent.command(name).description(`${name} commands`);
+        createCommands(child, cmd, currentPath);
+      }
+    }
+  }
+  createCommands(root, program2, []);
+}
+function createOptionFlag(opt) {
+  const kebabName = opt.name.replace(/([A-Z])/g, "-$1").toLowerCase();
+  if (opt.type === "boolean") {
+    return `--${kebabName}`;
+  }
+  const valuePlaceholder = `<${opt.name}>`;
+  return `--${kebabName} ${valuePlaceholder}`;
+}
+function buildParams(toolOptions, cmdOptions) {
+  const params = {};
+  for (const opt of toolOptions) {
+    const kebabName = opt.name.replace(/([A-Z])/g, "-$1").toLowerCase();
+    const camelName = kebabName.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+    const value = cmdOptions[camelName] ?? cmdOptions[opt.name];
+    if (value !== void 0) {
+      if (opt.type === "number" && typeof value === "string") {
+        params[opt.name] = parseFloat(value);
+      } else if (opt.type === "boolean") {
+        params[opt.name] = value === true || value === "true";
+      } else {
+        params[opt.name] = value;
+      }
+    } else if (!opt.required) {
+      params[opt.name] = null;
+    }
+  }
+  return params;
+}
+buildToolCommands(program);
+program.parse();
+//# sourceMappingURL=index.js.map