monk-pi 0.10.0 → 0.10.2

package/dist/chunk-GGAUER4O.js

@@ -0,0 +1,1005 @@
+// src/constants.ts
+import os from "os";
+import path from "path";
+var MONK_BASE_URL = "https://monk.party/v1";
+var MONK_WEBSITE = "https://monk.party";
+var MONK_ACCOUNT_URL = "https://monk.party/account/";
+var MONK_MODELS = [
+  {
+    id: "monk-coding",
+    name: "Monk Coding (\u4EE3\u7801\u4E3B\u529B - \u63A8\u8350)",
+    description: "\u4E13\u4E3A Agent \u6DF1\u5EA6\u4F18\u5316\uFF0C\u517C\u5907\u9AD8\u541E\u5410\u903B\u8F91\u63A8\u6F14\u4E0E\u5DE5\u5177\u8C03\u7528\u80FD\u529B",
+    reasoning: true,
+    contextWindow: 1e6,
+    maxTokens: 64e3
+  },
+  {
+    id: "monk-fast",
+    name: "Monk Fast (\u6781\u901F\u63A8\u7406)",
+    description: "\u6781\u901F\u54CD\u5E94\uFF0C\u9002\u5408\u65E5\u5E38\u95EE\u7B54\u3001\u5FEB\u901F\u4EE3\u7801\u63A2\u7D22\u4E0E\u5355\u6587\u4EF6\u9605\u8BFB",
+    reasoning: true,
+    contextWindow: 1e6,
+    maxTokens: 64e3
+  },
+  {
+    id: "monk",
+    name: "Monk (\u878D\u5408\u6A21\u578B)",
+    description: "\u96C6\u4E09\u5927 Flash \u4E4B\u6240\u957F\uFF0C\u7EFC\u5408\u8D28\u91CF\u4E0E\u601D\u8003\u80FD\u529B\u4F18\u5148",
+    reasoning: true,
+    contextWindow: 1e6,
+    maxTokens: 64e3
+  }
+];
+var DEFAULT_MONK_MODEL = "monk-coding";
+function getMonkHomeDir() {
+  return path.join(os.homedir(), ".monk-pi");
+}
+function getMonkConfigFile() {
+  return path.join(getMonkHomeDir(), "config.json");
+}
+function getPiHomeDir() {
+  return process.env.PI_CODING_AGENT_DIR || path.join(os.homedir(), ".pi", "agent");
+}
+function getPiModelsFile() {
+  return path.join(getPiHomeDir(), "models.json");
+}
+function getPiSettingsFile() {
+  return path.join(getPiHomeDir(), "settings.json");
+}
+function getPiExtensionsDir() {
+  return path.join(getPiHomeDir(), "extensions");
+}
+function getPiMonkExtensionFile() {
+  return path.join(getPiExtensionsDir(), "monk.ts");
+}
+
+// src/config.ts
+import fs from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+function loadMonkConfig() {
+  const configFile = getMonkConfigFile();
+  try {
+    if (fs.existsSync(configFile)) {
+      const content = fs.readFileSync(configFile, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {
+  }
+  return {};
+}
+function saveMonkConfig(config) {
+  const homeDir = getMonkHomeDir();
+  if (!fs.existsSync(homeDir)) {
+    fs.mkdirSync(homeDir, { recursive: true });
+  }
+  const configFile = getMonkConfigFile();
+  const existing = loadMonkConfig();
+  const merged = { ...existing, ...config };
+  fs.writeFileSync(configFile, JSON.stringify(merged, null, 2), "utf-8");
+}
+function resolveApiKey() {
+  const envKey = process.env.MONK_API_KEY?.trim();
+  if (envKey) {
+    return { key: envKey, source: "env" };
+  }
+  const localConfig = loadMonkConfig();
+  if (localConfig.apiKey?.trim()) {
+    return { key: localConfig.apiKey.trim(), source: "local" };
+  }
+  const piModelsFile = getPiModelsFile();
+  try {
+    if (fs.existsSync(piModelsFile)) {
+      const data = JSON.parse(fs.readFileSync(piModelsFile, "utf-8"));
+      const key = data?.providers?.monk?.apiKey;
+      if (typeof key === "string" && key.trim() && !key.startsWith("$")) {
+        return { key: key.trim(), source: "pi" };
+      }
+    }
+  } catch {
+  }
+  return { key: "", source: "none" };
+}
+function syncPiModelsJson(apiKey) {
+  const piDir = getPiHomeDir();
+  const piModelsFile = getPiModelsFile();
+  try {
+    if (!fs.existsSync(piDir)) {
+      fs.mkdirSync(piDir, { recursive: true });
+    }
+    let modelsData = { providers: {} };
+    if (fs.existsSync(piModelsFile)) {
+      const raw = fs.readFileSync(piModelsFile, "utf-8");
+      try {
+        modelsData = JSON.parse(raw);
+        if (!modelsData.providers) {
+          modelsData.providers = {};
+        }
+      } catch {
+        modelsData = { providers: {} };
+      }
+    }
+    const monkProviderConfig = {
+      name: "Monk",
+      baseUrl: MONK_BASE_URL,
+      api: "openai-completions",
+      apiKey: apiKey && !apiKey.startsWith("$") ? apiKey : "$MONK_API_KEY",
+      compat: {
+        supportsDeveloperRole: false,
+        maxTokensField: "max_tokens",
+        requiresToolResultName: true
+      },
+      models: MONK_MODELS.map((m) => ({
+        id: m.id,
+        name: m.name,
+        reasoning: m.reasoning,
+        input: ["text"],
+        contextWindow: m.contextWindow,
+        maxTokens: m.maxTokens,
+        cost: {
+          input: 0,
+          output: 0,
+          cacheRead: 0,
+          cacheWrite: 0
+        }
+      }))
+    };
+    modelsData.providers.monk = monkProviderConfig;
+    fs.writeFileSync(piModelsFile, JSON.stringify(modelsData, null, 2), "utf-8");
+    return { success: true, path: piModelsFile };
+  } catch (err) {
+    return {
+      success: false,
+      path: piModelsFile,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function getMonkExtensionRaw() {
+  try {
+    const distPath = path2.resolve(
+      path2.dirname(fileURLToPath(import.meta.url)),
+      "monk-extension.ts"
+    );
+    if (fs.existsSync(distPath)) {
+      return fs.readFileSync(distPath, "utf-8");
+    }
+    const srcPath = path2.resolve(
+      path2.dirname(fileURLToPath(import.meta.url)),
+      "../src/extension/monk-extension.ts"
+    );
+    if (fs.existsSync(srcPath)) {
+      return fs.readFileSync(srcPath, "utf-8");
+    }
+    const cwdPath = path2.resolve(process.cwd(), "src/extension/monk-extension.ts");
+    if (fs.existsSync(cwdPath)) {
+      return fs.readFileSync(cwdPath, "utf-8");
+    }
+  } catch {
+  }
+  return "";
+}
+function syncPiExtension(force = false) {
+  const extDir = getPiExtensionsDir();
+  const extFile = getPiMonkExtensionFile();
+  try {
+    if (!fs.existsSync(extDir)) {
+      fs.mkdirSync(extDir, { recursive: true });
+    }
+    const targetContent = getMonkExtensionRaw().trim() + "\n";
+    if (!targetContent.trim()) {
+      return {
+        success: false,
+        path: extFile,
+        updated: false,
+        error: "\u672A\u627E\u5230\u6269\u5C55\u6E90\u6587\u4EF6 monk-extension.ts"
+      };
+    }
+    if (fs.existsSync(extFile)) {
+      const existing = fs.readFileSync(extFile, "utf-8");
+      if (existing === targetContent && !force) {
+        return { success: true, path: extFile, updated: false };
+      }
+    }
+    fs.writeFileSync(extFile, targetContent, "utf-8");
+    return { success: true, path: extFile, updated: true };
+  } catch (err) {
+    return {
+      success: false,
+      path: extFile,
+      updated: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function getDefaultModel() {
+  const config = loadMonkConfig();
+  if (config.defaultModel && MONK_MODELS.some((m) => m.id === config.defaultModel)) {
+    return config.defaultModel;
+  }
+  return DEFAULT_MONK_MODEL;
+}
+
+// src/monk-api.ts
+async function validateApiKey(apiKey, baseUrl = MONK_BASE_URL) {
+  const trimmedKey = apiKey.trim();
+  if (!trimmedKey) {
+    return {
+      valid: false,
+      latencyMs: 0,
+      models: [],
+      error: "API Key \u4E0D\u80FD\u4E3A\u7A7A"
+    };
+  }
+  const endpoint = `${baseUrl.replace(/\/+$/, "")}/models`;
+  const startTime = Date.now();
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 8e3);
+    const response = await fetch(endpoint, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${trimmedKey}`,
+        Accept: "application/json"
+      },
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    const latencyMs = Date.now() - startTime;
+    if (response.status === 401 || response.status === 403) {
+      const body = await response.json().catch(() => ({}));
+      return {
+        valid: false,
+        latencyMs,
+        models: [],
+        statusCode: response.status,
+        error: body.error?.message || "API Key \u65E0\u6548\u6216\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u68C0\u67E5 monk.party \u7684\u8BA2\u9605\u51ED\u8BC1"
+      };
+    }
+    if (!response.ok) {
+      return {
+        valid: false,
+        latencyMs,
+        models: [],
+        statusCode: response.status,
+        error: `Monk API \u54CD\u5E94\u5F02\u5E38 (HTTP ${response.status})`
+      };
+    }
+    const data = await response.json().catch(() => ({}));
+    const models = Array.isArray(data.data) ? data.data.map((m) => m.id) : [];
+    return {
+      valid: true,
+      latencyMs,
+      models,
+      statusCode: response.status
+    };
+  } catch (err) {
+    const latencyMs = Date.now() - startTime;
+    const isAbort = err instanceof Error && err.name === "AbortError";
+    return {
+      valid: false,
+      latencyMs,
+      models: [],
+      error: isAbort ? "\u8FDE\u63A5 Monk \u670D\u52A1\u8D85\u65F6\uFF08\u8D85\u8FC7 8 \u79D2\uFF09\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5" : `\u7F51\u7EDC\u8FDE\u63A5\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+function extractFirstJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    const cleaned = text.replace(/^data:\s*/gm, "");
+    const start = cleaned.indexOf("{");
+    const end = cleaned.lastIndexOf("}");
+    if (start === -1 || end <= start) return {};
+    try {
+      return JSON.parse(cleaned.slice(start, end + 1));
+    } catch {
+      return {};
+    }
+  }
+}
+async function testChatCompletion(apiKey, model = "monk-fast", baseUrl = MONK_BASE_URL) {
+  const endpoint = `${baseUrl.replace(/\/+$/, "")}/chat/completions`;
+  const startTime = Date.now();
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3e4);
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey.trim()}`
+      },
+      body: JSON.stringify({
+        model,
+        messages: [{ role: "user", content: "pong" }],
+        max_tokens: 10,
+        temperature: 0.1
+      }),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    const latencyMs = Date.now() - startTime;
+    const payload = extractFirstJson(await response.text());
+    if (!response.ok) {
+      return {
+        success: false,
+        latencyMs,
+        error: payload.error?.message || `HTTP ${response.status}`
+      };
+    }
+    const reply = (payload.choices?.[0]?.message?.content ?? "").trim();
+    return {
+      success: true,
+      latencyMs,
+      reply
+    };
+  } catch (err) {
+    const latencyMs = Date.now() - startTime;
+    return {
+      success: false,
+      latencyMs,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+
+// src/ui.ts
+import spawn from "cross-spawn";
+import pc from "picocolors";
+import { password, select, confirm } from "@inquirer/prompts";
+function openBrowser(url) {
+  try {
+    if (process.platform === "darwin") {
+      spawn("open", [url], { stdio: "ignore", detached: true });
+      return true;
+    }
+    if (process.platform === "win32") {
+      spawn("cmd", ["/c", "start", "", url], { stdio: "ignore", detached: true });
+      return true;
+    }
+    spawn("xdg-open", [url], { stdio: "ignore", detached: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function printBanner() {
+  const line = pc.dim("\u2500".repeat(54));
+  console.log();
+  console.log(pc.bold(pc.yellow("  \u2588\u2580\u2584\u2580\u2588 \u2588\u2580\u2588 \u2588\u2584\u2591\u2588 \u2588\u2584\u2580") + "   \u2715   " + pc.cyan("\u2588\u2580\u2588 \u2588")));
+  console.log(pc.bold(pc.yellow("  \u2588\u2591\u2580\u2591\u2588 \u2588\u2584\u2588 \u2588\u2591\u2580\u2588 \u2588\u2591\u2588") + "       " + pc.cyan("\u2588\u2580\u2580 \u2588")));
+  console.log(line);
+  console.log(
+    `  ${pc.bold("Monk \xD7 Pi Harness")} ${pc.dim("\xB7")} ${pc.green("OpenAI-Compatible Fusion Agent")}`
+  );
+  console.log(
+    `  ${pc.dim("\u6A21\u578B:")} ${pc.yellow("monk-coding")} ${pc.dim("|")} ${pc.cyan("monk-fast")} ${pc.dim("|")} ${pc.magenta("monk")}`
+  );
+  console.log(line);
+  console.log();
+}
+function logSuccess(msg) {
+  console.log(`  ${pc.green("\u2714")} ${msg}`);
+}
+function logInfo(msg) {
+  console.log(`  ${pc.cyan("\u2139")} ${msg}`);
+}
+function logWarn(msg) {
+  console.log(`  ${pc.yellow("\u25B2")} ${msg}`);
+}
+function logError(msg) {
+  console.log(`  ${pc.red("\u2716")} ${msg}`);
+}
+function logStep(step, total, msg) {
+  console.log(`  ${pc.dim(`[${step}/${total}]`)} ${pc.bold(msg)}`);
+}
+async function promptForApiKey(currentKey) {
+  console.log();
+  console.log(`  ${pc.bold("\u6B22\u8FCE\u4F7F\u7528 Monk \xD7 Pi \u7F16\u7801\u4F34\u4FA3\uFF01")}`);
+  console.log(
+    `  ${pc.dim("Monk \u4E13\u4E3A Agent \u63D0\u4F9B\u6781\u901F\u9AD8\u541E\u5410\u878D\u5408\u6A21\u578B (\u6708\u5361 \xA530 / 100\u4E07 Token \u4E0A\u4E0B\u6587)")}`
+  );
+  console.log();
+  if (!currentKey) {
+    const action = await select({
+      message: "\u8BF7\u9009\u62E9\u914D\u7F6E\u6216\u83B7\u53D6 Monk API Key \u7684\u65B9\u5F0F:",
+      choices: [
+        {
+          name: `1. \u6211\u5DF2\u6709 API Key\uFF0C\u76F4\u63A5\u7C98\u8D34\u8F93\u5165 ${pc.dim("(sk-monk-...)")}`,
+          value: "input"
+        },
+        {
+          name: `2. \u6211\u8FD8\u6CA1\u6709 Key\uFF0C\u7ACB\u5373\u6253\u5F00 monk.party \u8BA2\u9605 ${pc.green("(\u63A8\u8350 \xB7 \u56DE\u8F66\u6D4F\u89C8\u5668\u626B\u7801)")}`,
+          value: "open_browser"
+        }
+      ]
+    });
+    if (action === "open_browser") {
+      logInfo(`\u6B63\u5728\u4E3A\u60A8\u5728\u9ED8\u8BA4\u6D4F\u89C8\u5668\u6253\u5F00\u5B98\u7F51: ${pc.cyan(MONK_WEBSITE)} ...`);
+      openBrowser(MONK_WEBSITE);
+      console.log();
+      logSuccess("\u5DF2\u5524\u8D77\u6D4F\u89C8\u5668\uFF01\u8BF7\u5728\u7F51\u9875\u5B8C\u6210\u8BA2\u9605\u540E\uFF0C\u5C06\u751F\u6210\u7684 sk-monk-... Key \u590D\u5236\u5E76\u7C98\u8D34\u5230\u4E0B\u65B9\uFF1A");
+      console.log();
+    }
+  } else {
+    const action = await select({
+      message: `\u68C0\u6D4B\u5230\u5DF2\u914D\u7F6E Key (${maskKey(currentKey)})\uFF0C\u8BF7\u9009\u62E9\u64CD\u4F5C:`,
+      choices: [
+        {
+          name: "1. \u4FDD\u6301\u5E76\u6D4B\u8BD5\u5F53\u524D Key",
+          value: "keep"
+        },
+        {
+          name: "2. \u66F4\u6362\u4E3A\u65B0\u7684 API Key",
+          value: "replace"
+        },
+        {
+          name: `3. \u5728\u6D4F\u89C8\u5668\u6253\u5F00 monk.party \u5B98\u7F51 (\u67E5\u8BE2/\u7EED\u8D39)`,
+          value: "open_browser"
+        }
+      ]
+    });
+    if (action === "keep") {
+      return currentKey;
+    }
+    if (action === "open_browser") {
+      logInfo(`\u6B63\u5728\u4E3A\u60A8\u5728\u6D4F\u89C8\u5668\u6253\u5F00\u5B98\u7F51: ${pc.cyan(MONK_ACCOUNT_URL)} ...`);
+      openBrowser(MONK_ACCOUNT_URL);
+      console.log();
+      logInfo("\u5DF2\u6253\u5F00\u67E5\u8BE2\u9875\u9762\u3002\u5982\u9700\u66F4\u6362 Key \u8BF7\u5728\u4E0B\u65B9\u7C98\u8D34\uFF0C\u76F4\u63A5\u56DE\u8F66\u4FDD\u6301\u5F53\u524D Key\uFF1A");
+      console.log();
+    }
+  }
+  const key = await password({
+    message: currentKey ? `\u8BF7\u8F93\u5165 Monk API Key (\u76F4\u63A5\u56DE\u8F66\u4FDD\u6301\u5F53\u524D: ${maskKey(currentKey)}):` : "\u8BF7\u7C98\u8D34\u60A8\u7684 Monk API Key (sk-monk-...):",
+    mask: "*",
+    validate: (val) => {
+      const trimmed = val.trim();
+      if (!trimmed && currentKey) return true;
+      if (!trimmed) return "API Key \u4E0D\u80FD\u4E3A\u7A7A";
+      if (!trimmed.startsWith("sk-")) {
+        return "Key \u683C\u5F0F\u901A\u5E38\u4EE5 sk- \u5F00\u5934\uFF0C\u8BF7\u786E\u8BA4\u590D\u5236\u5B8C\u6574";
+      }
+      return true;
+    }
+  });
+  const finalKey = key.trim() || currentKey || "";
+  return finalKey;
+}
+async function promptSelectModel(currentModel) {
+  const choices = MONK_MODELS.map((m) => ({
+    name: `${m.name.padEnd(28)} ${pc.dim(m.description)}`,
+    value: m.id,
+    description: m.description
+  }));
+  const selected = await select({
+    message: "\u8BF7\u9009\u62E9\u9ED8\u8BA4\u4E3B\u529B\u6A21\u578B:",
+    choices,
+    default: currentModel || "monk-coding"
+  });
+  return selected;
+}
+async function promptInstallPi() {
+  logWarn("\u672A\u68C0\u6D4B\u5230\u5168\u5C40\u5B89\u88C5\u7684 pi \u7F16\u7801\u52A9\u624B (@earendil-works/pi-coding-agent)\u3002");
+  console.log(`  ${pc.dim("Monk Harness \u4F9D\u8D56 Pi \u4F5C\u4E3A\u5E95\u5C42 TUI/Agent \u8FD0\u884C\u65F6\u3002")}`);
+  console.log();
+  return await confirm({
+    message: "\u662F\u5426\u7ACB\u5373\u4F7F\u7528 npm \u5168\u5C40\u5B89\u88C5 @earendil-works/pi-coding-agent\uFF1F",
+    default: true
+  });
+}
+function maskKey(key) {
+  if (!key || key.length < 10) return "******";
+  return `${key.slice(0, 7)}...${key.slice(-4)}`;
+}
+
+// src/pi-runner.ts
+import fs2 from "fs";
+import path3 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import spawn2 from "cross-spawn";
+import pc2 from "picocolors";
+function resolvePiBinary() {
+  try {
+    const globalCheck = spawn2.sync("pi", ["--version"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    if (globalCheck.status === 0 && globalCheck.stdout) {
+      return {
+        type: "global",
+        command: "pi",
+        argsPrefix: [],
+        version: globalCheck.stdout.trim(),
+        sourceDescription: "\u7CFB\u7EDF\u5168\u5C40\u547D\u4EE4 (PATH)"
+      };
+    }
+  } catch {
+  }
+  const candidateBinDirs = [
+    path3.resolve(path3.dirname(fileURLToPath2(import.meta.url)), "../node_modules/.bin/pi"),
+    path3.resolve(process.cwd(), "node_modules/.bin/pi")
+  ];
+  for (const binPath of candidateBinDirs) {
+    if (fs2.existsSync(binPath)) {
+      try {
+        const localCheck = spawn2.sync(binPath, ["--version"], {
+          encoding: "utf-8",
+          stdio: ["ignore", "pipe", "ignore"]
+        });
+        if (localCheck.status === 0 && localCheck.stdout) {
+          return {
+            type: "local",
+            command: binPath,
+            argsPrefix: [],
+            version: localCheck.stdout.trim(),
+            sourceDescription: `\u672C\u5730\u4F9D\u8D56 (${path3.basename(path3.dirname(binPath))})`
+          };
+        }
+      } catch {
+      }
+    }
+  }
+  try {
+    const mainEntry = fileURLToPath2(import.meta.resolve("@earendil-works/pi-coding-agent"));
+    const cliEntry = path3.join(path3.dirname(mainEntry), "bundle", "cli.js");
+    if (fs2.existsSync(cliEntry)) {
+      const moduleCheck = spawn2.sync(process.execPath, [cliEntry, "--version"], {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      if (moduleCheck.status === 0 && moduleCheck.stdout) {
+        return {
+          type: "bundled",
+          command: process.execPath,
+          argsPrefix: [cliEntry],
+          version: moduleCheck.stdout.trim(),
+          sourceDescription: "Monk-Pi \u5185\u5D4C\u6838\u5FC3 (\u514D\u5B89\u88C5\u8FD0\u884C)"
+        };
+      }
+    }
+  } catch {
+  }
+  return {
+    type: "missing",
+    command: "",
+    argsPrefix: [],
+    sourceDescription: "\u672A\u68C0\u6D4B\u5230\u53EF\u7528\u7684 Pi \u6838\u5FC3"
+  };
+}
+function detectPi() {
+  const resolved = resolvePiBinary();
+  return {
+    installed: resolved.type !== "missing",
+    version: resolved.version,
+    type: resolved.type,
+    description: resolved.sourceDescription
+  };
+}
+function detectPackageManager() {
+  try {
+    const bunCheck = spawn2.sync("bun", ["--version"], { stdio: "ignore" });
+    if (bunCheck.status === 0) return "bun";
+  } catch {
+  }
+  try {
+    const pnpmCheck = spawn2.sync("pnpm", ["--version"], { stdio: "ignore" });
+    if (pnpmCheck.status === 0) return "pnpm";
+  } catch {
+  }
+  return "npm";
+}
+async function installPi() {
+  const pm = detectPackageManager();
+  let cmd = "npm";
+  let args = ["install", "-g", "@earendil-works/pi-coding-agent"];
+  if (pm === "bun") {
+    cmd = "bun";
+    args = ["add", "-g", "@earendil-works/pi-coding-agent"];
+  } else if (pm === "pnpm") {
+    cmd = "pnpm";
+    args = ["add", "-g", "@earendil-works/pi-coding-agent"];
+  }
+  logInfo(`\u68C0\u6D4B\u5230\u5305\u7BA1\u7406\u5668: ${pc2.bold(pm)}\uFF0C\u6B63\u5728\u6267\u884C: ${pc2.yellow(`${cmd} ${args.join(" ")}`)} ...`);
+  try {
+    const child = spawn2.sync(cmd, args, {
+      stdio: "inherit"
+    });
+    if (child.status === 0) {
+      logSuccess("Pi \u6838\u5FC3\u5957\u4EF6\u5B89\u88C5\u6210\u529F\uFF01");
+      return true;
+    }
+    logError(`\u5B89\u88C5\u5931\u8D25\uFF0C\u9000\u51FA\u7801: ${child.status}`);
+    logWarn(`\u82E5\u56E0\u6743\u9650\u95EE\u9898 (EACCES) \u5931\u8D25\uFF0C\u8BF7\u5C1D\u8BD5:`);
+    console.log(`    ${pc2.cyan(`sudo ${cmd} ${args.join(" ")}`)}`);
+    console.log(`    \u6216\u76F4\u63A5\u4F7F\u7528\u514D\u5B89\u88C5\u65B9\u6848: ${pc2.cyan("npx monk-pi")}`);
+    return false;
+  } catch (err) {
+    logError(`\u6267\u884C\u5B89\u88C5\u5F02\u5E38: ${err instanceof Error ? err.message : String(err)}`);
+    return false;
+  }
+}
+function launchPi(options) {
+  const resolved = resolvePiBinary();
+  if (resolved.type === "missing") {
+    logError("\u672A\u627E\u5230\u53EF\u7528\u7684 Pi \u6838\u5FC3\u8FD0\u884C\u73AF\u5883\u3002");
+    return 1;
+  }
+  const { apiKey, defaultModel, passthroughArgs } = options;
+  const extraArgs = [];
+  const hasProvider = passthroughArgs.includes("--provider");
+  const hasModel = passthroughArgs.some((arg, idx) => {
+    return arg === "--model" || arg === "-m" || passthroughArgs[idx - 1] === "--model";
+  });
+  if (!hasProvider && !hasModel) {
+    extraArgs.push("--provider", "monk", "--model", defaultModel);
+  } else if (!hasProvider && hasModel) {
+    extraArgs.push("--provider", "monk");
+  }
+  const fullArgs = [...resolved.argsPrefix, ...extraArgs, ...passthroughArgs];
+  const env = {
+    ...process.env,
+    MONK_API_KEY: apiKey
+  };
+  const child = spawn2(resolved.command, fullArgs, {
+    stdio: "inherit",
+    env
+  });
+  const forwardSignal = (signal) => {
+    try {
+      child.kill(signal);
+    } catch {
+    }
+  };
+  process.on("SIGINT", () => forwardSignal("SIGINT"));
+  process.on("SIGTERM", () => forwardSignal("SIGTERM"));
+  return new Promise((resolve) => {
+    child.on("close", (code) => {
+      resolve(code ?? 0);
+    });
+    child.on("error", (err) => {
+      logError(`\u542F\u52A8 Pi \u53D1\u751F\u9519\u8BEF: ${err.message}`);
+      resolve(1);
+    });
+  });
+}
+
+// src/commands/doctor.ts
+import fs3 from "fs";
+import os2 from "os";
+import pc3 from "picocolors";
+async function doctorCommand() {
+  printBanner();
+  console.log(`  ${pc3.bold("\u3010Monk \xD7 Pi \u73AF\u5883\u8BCA\u65AD (Doctor)\u3011")}`);
+  console.log();
+  let hasIssue = false;
+  const nodeVersion = process.version;
+  const major = parseInt(nodeVersion.slice(1).split(".")[0], 10);
+  if (major >= 18) {
+    logSuccess(`Node.js \u7248\u672C: ${pc3.bold(nodeVersion)} (\u6EE1\u8DB3 >= 18 \u8981\u6C42)`);
+  } else {
+    hasIssue = true;
+    logError(`Node.js \u7248\u672C: ${pc3.bold(nodeVersion)} (\u8FC7\u4F4E\uFF0C\u8BF7\u5347\u7EA7\u5230 Node 18+)`);
+  }
+  logInfo(`\u64CD\u4F5C\u7CFB\u7EDF: ${os2.type()} ${os2.release()} (${os2.arch()})`);
+  const pi = detectPi();
+  if (pi.installed) {
+    logSuccess(
+      `Pi \u6838\u5FC3\u5957\u4EF6: ${pc3.bold(`\u5DF2\u5C31\u7EEA (v${pi.version})`)} \xB7 ${pc3.dim(`[\u6765\u6E90: ${pi.description}]`)}`
+    );
+  } else {
+    hasIssue = true;
+    logError(`Pi \u6838\u5FC3\u5957\u4EF6: ${pc3.bold("\u672A\u627E\u5230\u53EF\u7528\u8FD0\u884C\u65F6")}`);
+    console.log(`    ${pc3.dim("\u89E3\u51B3\u529E\u6CD5: \u8FD0\u884C npm install -g @earendil-works/pi-coding-agent")}`);
+  }
+  const { key, source } = resolveApiKey();
+  if (key) {
+    logSuccess(`Monk API Key: ${pc3.bold(maskKey(key))} (\u6765\u6E90: ${source})`);
+  } else {
+    hasIssue = true;
+    logError(`Monk API Key: \u672A\u914D\u7F6E`);
+    console.log(`    ${pc3.dim("\u89E3\u51B3\u529E\u6CD5: \u8FD0\u884C monk-pi login")}`);
+  }
+  const modelsFile = getPiModelsFile();
+  if (fs3.existsSync(modelsFile)) {
+    try {
+      const data = JSON.parse(fs3.readFileSync(modelsFile, "utf-8"));
+      const monk = data?.providers?.monk;
+      if (monk) {
+        const hasCompat = monk.compat?.supportsDeveloperRole === false && monk.compat?.maxTokensField === "max_tokens";
+        if (hasCompat) {
+          logSuccess(`Pi \u914D\u7F6E\u6587\u4EF6: ${pc3.bold("\u5DF2\u914D\u7F6E Monk \u4E13\u5C5E\u4F18\u5316\u517C\u5BB9\u53C2\u6570")}`);
+        } else {
+          logWarn(`Pi \u914D\u7F6E\u6587\u4EF6: \u5B58\u5728 Monk \u914D\u7F6E\uFF0C\u4F46\u7F3A\u5C11\u6700\u4F73 compat \u53C2\u6570`);
+          console.log(`    ${pc3.dim("\u6B63\u5728\u4E3A\u60A8\u81EA\u52A8\u7EA0\u6B63...")}`);
+          syncPiModelsJson(key);
+          logSuccess(`Pi \u914D\u7F6E\u6587\u4EF6: \u5DF2\u81EA\u52A8\u4FEE\u590D\u4F18\u5316`);
+        }
+      } else {
+        logWarn(`Pi \u914D\u7F6E\u6587\u4EF6: \u5C1A\u672A\u6CE8\u5165 Monk \u4F9B\u5E94\u5546`);
+        syncPiModelsJson(key);
+        logSuccess(`Pi \u914D\u7F6E\u6587\u4EF6: \u5DF2\u6210\u529F\u81EA\u52A8\u6CE8\u5165`);
+      }
+    } catch {
+      logError(`Pi \u914D\u7F6E\u6587\u4EF6: ${modelsFile} \u5B58\u5728\u8BED\u6CD5\u9519\u8BEF`);
+    }
+  } else {
+    logWarn(`Pi \u914D\u7F6E\u6587\u4EF6: \u5C1A\u672A\u521B\u5EFA\uFF0C\u6B63\u5728\u4E3A\u60A8\u81EA\u52A8\u521B\u5EFA...`);
+    syncPiModelsJson(key);
+    logSuccess(`Pi \u914D\u7F6E\u6587\u4EF6: \u521B\u5EFA\u5B8C\u6210`);
+  }
+  const extRes = syncPiExtension();
+  if (extRes.success) {
+    if (extRes.updated) {
+      logSuccess(
+        `Pi \u539F\u751F\u6269\u5C55: ${pc3.bold("\u5DF2\u81EA\u52A8\u66F4\u65B0\u81F3\u6700\u65B0\u7248")} (\u4E2D\u6587\u5DE5\u7A0B\u63D0\u793A\u8BCD\u3001/monk \u6307\u4EE4\u4E0E\u81EA\u52A8\u91CD\u8BD5\u5C31\u7EEA)`
+      );
+    } else {
+      logSuccess(
+        `Pi \u539F\u751F\u6269\u5C55: ${pc3.bold("\u5DF2\u5C31\u7EEA")} (\u4E2D\u6587\u5DE5\u7A0B\u63D0\u793A\u8BCD\u3001/monk \u6307\u4EE4\u4E0E\u81EA\u52A8\u91CD\u8BD5\u5C31\u7EEA)`
+      );
+    }
+  } else {
+    logError(`Pi \u539F\u751F\u6269\u5C55\u90E8\u7F72\u5931\u8D25: ${extRes.error}`);
+  }
+  if (key) {
+    process.stdout.write(`  ${pc3.dim("\u23F3 \u6B63\u5728\u63A2\u6D4B\u4E0E monk.party \u63A5\u53E3\u7684\u8FDE\u901A\u6027...")} `);
+    const val = await validateApiKey(key);
+    process.stdout.write("\r" + " ".repeat(50) + "\r");
+    if (val.valid) {
+      logSuccess(`Monk \u8FDE\u901A\u6027: ${pc3.green("\u4F18\u79C0")} \xB7 \u5EF6\u8FDF ${val.latencyMs}ms`);
+    } else {
+      hasIssue = true;
+      logError(`Monk \u8FDE\u901A\u6027\u5F02\u5E38: ${val.error}`);
+    }
+  }
+  console.log();
+  console.log(pc3.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  if (hasIssue) {
+    logWarn("\u68C0\u6D4B\u5230\u73AF\u5883\u5B58\u5728\u90E8\u5206\u95EE\u9898\uFF0C\u8BF7\u53C2\u8003\u4E0A\u65B9\u63D0\u793A\u5904\u7406\u3002");
+  } else {
+    logSuccess(pc3.bold("\u592A\u68D2\u4E86\uFF01\u6240\u6709\u68C0\u67E5\u9879\u5168\u90E8\u901A\u8FC7\uFF0C\u73AF\u5883\u5904\u4E8E\u6700\u4F73\u72B6\u6001\u3002"));
+  }
+  console.log();
+}
+
+// src/commands/login.ts
+import pc4 from "picocolors";
+async function loginCommand() {
+  printBanner();
+  const current = resolveApiKey();
+  const apiKey = await promptForApiKey(current.key || void 0);
+  if (!apiKey) {
+    logWarn("\u672A\u8F93\u5165 API Key\uFF0C\u64CD\u4F5C\u5DF2\u53D6\u6D88\u3002");
+    return false;
+  }
+  logInfo("\u6B63\u5728\u8FDE\u63A5 Monk API \u9A8C\u8BC1\u5BC6\u94A5...");
+  const result = await validateApiKey(apiKey);
+  if (!result.valid) {
+    logError(`\u9A8C\u8BC1\u5931\u8D25: ${result.error || "\u672A\u77E5\u9519\u8BEF"}`);
+    logWarn("\u8BF7\u6838\u5BF9\u540E\u91CD\u65B0\u8FD0\u884C `monk-pi login`\u3002");
+    return false;
+  }
+  logSuccess(`\u9A8C\u8BC1\u901A\u8FC7\uFF01\u7F51\u7EDC\u5EF6\u8FDF: ${pc4.green(`${result.latencyMs}ms`)}`);
+  if (result.models.length > 0) {
+    logInfo(`\u53EF\u7528\u6A21\u578B: ${pc4.yellow(result.models.join(", "))}`);
+  }
+  saveMonkConfig({
+    apiKey,
+    lastVerified: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  logSuccess(`\u51ED\u8BC1\u5DF2\u4FDD\u5B58\u81F3\u672C\u5730\u914D\u7F6E`);
+  const syncResult = syncPiModelsJson(apiKey);
+  const extResult = syncPiExtension();
+  if (syncResult.success) {
+    logSuccess(`\u5DF2\u6210\u529F\u540C\u6B65\u5E76\u4F18\u5316 Pi \u914D\u7F6E\u6587\u4EF6: ${pc4.dim(syncResult.path)}`);
+  } else {
+    logWarn(`\u540C\u6B65 Pi \u914D\u7F6E\u6587\u4EF6\u5931\u8D25: ${syncResult.error}`);
+  }
+  if (extResult.success) {
+    logSuccess(`\u5DF2\u5B89\u88C5 Monk \u539F\u751F TUI \u6269\u5C55: ${pc4.dim(extResult.path)}`);
+  }
+  console.log();
+  logSuccess(`Monk \xD7 Pi \u5C31\u7EEA\uFF01\u73B0\u5728\u60A8\u53EF\u4EE5\u76F4\u63A5\u8F93\u5165 ${pc4.bold(pc4.yellow("monk-pi"))} \u5F00\u59CB\u7F16\u7801\u3002`);
+  console.log();
+  return true;
+}
+
+// src/commands/model.ts
+import pc5 from "picocolors";
+async function modelCommand(targetModel) {
+  printBanner();
+  const currentModel = getDefaultModel();
+  if (targetModel) {
+    const matched2 = MONK_MODELS.find(
+      (m) => m.id === targetModel || m.id.endsWith(targetModel)
+    );
+    if (!matched2) {
+      logWarn(`\u672A\u77E5\u6A21\u578B: "${targetModel}"`);
+      logInfo(`\u652F\u6301\u7684\u6A21\u578B\u5217\u8868: ${MONK_MODELS.map((m) => m.id).join(", ")}`);
+      return;
+    }
+    saveMonkConfig({ defaultModel: matched2.id });
+    logSuccess(`\u9ED8\u8BA4\u4E3B\u529B\u6A21\u578B\u5DF2\u5207\u6362\u4E3A: ${pc5.bold(pc5.yellow(matched2.name))}`);
+    return;
+  }
+  const selected = await promptSelectModel(currentModel);
+  saveMonkConfig({ defaultModel: selected });
+  const matched = MONK_MODELS.find((m) => m.id === selected);
+  console.log();
+  logSuccess(`\u9ED8\u8BA4\u4E3B\u529B\u6A21\u578B\u5DF2\u6210\u529F\u8BBE\u5B9A\u4E3A: ${pc5.bold(pc5.yellow(matched?.name || selected))}`);
+  console.log();
+}
+
+// src/commands/run.ts
+import pc6 from "picocolors";
+
+// src/extension/monk-extension.ts
+import fs4 from "fs";
+import path4 from "path";
+var PRO_TIPS = [
+  "\u5728\u8F93\u5165\u6846\u8F93\u5165 @diff \u5373\u53EF\u79D2\u7EA7\u628A\u5F53\u524D\u672A\u63D0\u4EA4\u6539\u52A8\u5E26\u5165\u5206\u6790",
+  "\u8F93\u5165 /commit \u53EF\u6309 Conventional Commits \u89C4\u8303\u81EA\u52A8\u751F\u6210\u4E2D\u6587\u63D0\u4EA4",
+  "AI \u6539\u4E71\u4E86\u4EE3\u7801\u4E0D\u7528\u614C\uFF0C\u968F\u65F6\u8F93\u5165 /undo \u6216 /\u56DE\u9000 \u77AC\u95F4\u4E00\u952E\u590D\u539F",
+  "\u8F93\u5165 /review \u53EF\u4ECE\u7F3A\u9677\u3001\u6027\u80FD\u3001\u67B6\u6784\u56DB\u4E2A\u7EF4\u5EA6\u5BF9\u4EE3\u7801\u8FDB\u884C\u6DF1\u5EA6\u5BA1\u67E5",
+  "\u8F93\u5165 /monk \u53EF\u547C\u51FA\u56FE\u5F62\u5316\u63A7\u5236\u53F0\uFF0C\u79D2\u7EA7\u514D\u91CD\u542F\u5207\u6362\u4E3B\u529B\u6A21\u578B",
+  "\u8F93\u5165 @recent \u5FEB\u901F\u63D0\u53D6\u6700\u8FD1\u53D8\u52A8\u7684\u9879\u76EE\u6838\u5FC3\u6E90\u6587\u4EF6\u5217\u8868",
+  "\u8F93\u5165 /monk cn \u968F\u65F6\u5207\u6362\u4E2D\u6587\u5DE5\u7A0B\u7CBE\u70BC\u6A21\u5F0F\uFF08\u96F6\u5BA2\u5957\xB7\u884C\u52A8\u4F18\u5148\uFF09",
+  "\u7EC8\u7AEF\u8F93\u5165 monk-pi -r \u53EF\u89C6\u5316\u6062\u590D\u4EE5\u5F80\u4EFB\u610F\u5386\u53F2\u4EFB\u52A1\u65AD\u70B9\u7EED\u5199"
+];
+
+// src/commands/run.ts
+async function runCommand(passthroughArgs) {
+  const piCheck = detectPi();
+  if (!piCheck.installed) {
+    const shouldInstall = await promptInstallPi();
+    if (shouldInstall) {
+      const installed = await installPi();
+      if (!installed) {
+        logError("\u65E0\u6CD5\u81EA\u52A8\u5B89\u88C5 Pi\uFF0C\u8BF7\u624B\u52A8\u8FD0\u884C `npm install -g @earendil-works/pi-coding-agent` \u540E\u91CD\u8BD5\u3002");
+        return 1;
+      }
+    } else {
+      logWarn("\u5DF2\u53D6\u6D88\u8FD0\u884C\u3002Monk Harness \u9700\u8981 Pi \u4F5C\u4E3A\u8FD0\u884C\u5E95\u5EA7\u3002");
+      return 1;
+    }
+  }
+  let { key } = resolveApiKey();
+  if (!key) {
+    logWarn("\u672A\u68C0\u6D4B\u5230 Monk API Key\uFF0C\u6B63\u5728\u4E3A\u60A8\u542F\u52A8\u9996\u6B21\u914D\u7F6E\u5F15\u5BFC...");
+    const ok = await loginCommand();
+    if (!ok) {
+      return 1;
+    }
+    const resolved = resolveApiKey();
+    key = resolved.key;
+  }
+  if (!key) {
+    logError("\u672A\u627E\u5230\u6709\u6548\u7684 Monk API Key\uFF0C\u9000\u51FA\u8FD0\u884C\u3002");
+    return 1;
+  }
+  syncPiModelsJson(key);
+  syncPiExtension();
+  const defaultModel = getDefaultModel();
+  if (!passthroughArgs.includes("-p") && !passthroughArgs.includes("--print")) {
+    const tip = PRO_TIPS[Math.floor(Math.random() * PRO_TIPS.length)];
+    console.log(`  ${pc6.yellow("\u{1F4A1} \u6781\u5BA2\u5C0F\u8D34\u58EB:")} ${pc6.dim(tip)}`);
+    console.log();
+  }
+  return launchPi({
+    apiKey: key,
+    defaultModel,
+    passthroughArgs
+  });
+}
+
+// src/commands/status.ts
+import pc7 from "picocolors";
+async function statusCommand() {
+  printBanner();
+  console.log(`  ${pc7.bold("\u3010\u670D\u52A1\u4E0E\u73AF\u5883\u72B6\u6001\u68C0\u6D4B\u3011")}`);
+  console.log();
+  const piDetect = detectPi();
+  if (piDetect.installed) {
+    logSuccess(
+      `Pi \u8FD0\u884C\u73AF\u5883: ${pc7.bold("\u5DF2\u5C31\u7EEA")} (v${piDetect.version}) \xB7 ${pc7.dim(`[\u6765\u6E90: ${piDetect.description}]`)}`
+    );
+  } else {
+    logWarn(`Pi \u8FD0\u884C\u73AF\u5883: ${pc7.red("\u672A\u68C0\u6D4B\u5230\u53EF\u7528\u8FD0\u884C\u65F6")}`);
+    console.log(`    ${pc7.dim("\u8BF7\u8FD0\u884C npm install -g @earendil-works/pi-coding-agent")}`);
+  }
+  const { key, source } = resolveApiKey();
+  const defaultModel = getDefaultModel();
+  if (!key) {
+    logError(`Monk API Key: ${pc7.red("\u672A\u914D\u7F6E")}`);
+    console.log(`    ${pc7.dim("\u8BF7\u8FD0\u884C `monk-pi login` \u8F93\u5165\u60A8\u7684 Key")}`);
+    return;
+  }
+  const sourceLabels = {
+    env: "\u73AF\u5883\u53D8\u91CF ($MONK_API_KEY)",
+    local: `\u672C\u5730\u914D\u7F6E (${getMonkConfigFile()})`,
+    pi: `Pi \u914D\u7F6E\u6587\u4EF6 (${getPiModelsFile()})`,
+    none: "\u65E0"
+  };
+  logSuccess(`Monk API Key: ${pc7.bold(maskKey(key))} ${pc7.dim(`[\u6765\u6E90: ${sourceLabels[source]}]`)}`);
+  logInfo(`\u5F53\u524D\u9ED8\u8BA4\u4E3B\u529B\u6A21\u578B: ${pc7.yellow(defaultModel)}`);
+  logInfo(`Monk \u57FA\u7840\u5730\u5740: ${pc7.dim(MONK_BASE_URL)}`);
+  process.stdout.write(`  ${pc7.dim("\u23F3 \u6B63\u5728\u6D4B\u8BD5 Monk API \u8FDE\u63A5\u4E0E\u8BA4\u8BC1...")} `);
+  const valResult = await validateApiKey(key);
+  if (valResult.valid) {
+    process.stdout.write("\r" + " ".repeat(50) + "\r");
+    logSuccess(
+      `Monk API \u8FDE\u63A5\u6B63\u5E38 ${pc7.dim("\xB7")} \u8BA4\u8BC1\u6709\u6548 ${pc7.dim("\xB7")} \u5EF6\u8FDF: ${pc7.green(`${valResult.latencyMs}ms`)}`
+    );
+    if (valResult.models.length > 0) {
+      logInfo(`\u652F\u6301\u7684\u6A21\u578B\u7AEF\u70B9: ${pc7.dim(valResult.models.join(" \xB7 "))}`);
+    }
+  } else {
+    process.stdout.write("\r" + " ".repeat(50) + "\r");
+    logError(`Monk API \u9A8C\u8BC1\u5F02\u5E38: ${valResult.error}`);
+    return;
+  }
+  process.stdout.write(`  ${pc7.dim(`\u23F3 \u6B63\u5728\u5BF9 ${defaultModel} \u53D1\u8D77\u6781\u7B80\u63E1\u624B\u63A8\u6F14...`)} `);
+  const testRes = await testChatCompletion(key, defaultModel);
+  if (testRes.success) {
+    process.stdout.write("\r" + " ".repeat(50) + "\r");
+    logSuccess(
+      `\u63A8\u7406\u901A\u9053\u63E1\u624B\u6210\u529F ${pc7.dim("\xB7")} \u54CD\u5E94\u5EF6\u8FDF: ${pc7.green(`${testRes.latencyMs}ms`)}`
+    );
+  } else {
+    process.stdout.write("\r" + " ".repeat(50) + "\r");
+    logWarn(`\u63A8\u7406\u901A\u9053\u63E1\u624B\u8F7B\u5FAE\u544A\u8B66: ${testRes.error || "\u672A\u8FD4\u56DE\u5E38\u89C4\u5185\u5BB9"}`);
+  }
+  console.log();
+  console.log(pc7.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(`  ${pc7.dim("\u5B98\u65B9\u7F51\u7AD9:")} ${pc7.cyan(MONK_WEBSITE)}`);
+  console.log(`  ${pc7.dim("\u7528\u91CF\u4E0E\u5230\u671F\u67E5\u8BE2:")} ${pc7.cyan(MONK_ACCOUNT_URL)}`);
+  console.log();
+}
+
+export {
+  MONK_BASE_URL,
+  MONK_WEBSITE,
+  MONK_ACCOUNT_URL,
+  MONK_MODELS,
+  DEFAULT_MONK_MODEL,
+  getMonkHomeDir,
+  getMonkConfigFile,
+  getPiHomeDir,
+  getPiModelsFile,
+  getPiSettingsFile,
+  getPiExtensionsDir,
+  getPiMonkExtensionFile,
+  loadMonkConfig,
+  saveMonkConfig,
+  resolveApiKey,
+  syncPiModelsJson,
+  getMonkExtensionRaw,
+  syncPiExtension,
+  getDefaultModel,
+  validateApiKey,
+  testChatCompletion,
+  openBrowser,
+  printBanner,
+  logSuccess,
+  logInfo,
+  logWarn,
+  logError,
+  logStep,
+  promptForApiKey,
+  promptSelectModel,
+  promptInstallPi,
+  maskKey,
+  resolvePiBinary,
+  detectPi,
+  detectPackageManager,
+  installPi,
+  launchPi,
+  doctorCommand,
+  loginCommand,
+  modelCommand,
+  runCommand,
+  statusCommand
+};