monk-pi 0.1.0

package/README.md

@@ -0,0 +1,151 @@
+# Monk × Pi Harness (`monk-pi`)
+
+> **开箱即用 · 零配置 · 极速高性价比终端 Coding Agent**  
+> 将 [Monk](https://monk.party/) 的 OpenAI 兼容融合模型（月卡 ¥30 / 1M 上下文 / Agent 原生适配）与 [Pi](https://github.com/earendil-works/pi) 的极速灵活终端 Agent 架构深度结合。
+
+---
+
+## 💡 为什么需要 Monk-Pi？
+
+- **极低门槛**：官方 Claude 3.7 / Opus / GPT-4o 价格高昂且易受网络限制。Monk 融合顶尖 Flash 模型，提供 100 万 Token 上下文与 Agent 原生工具调用能力。
+- **零配置接入**：彻底告别繁琐的手写 `models.json` 和 `compat` 参数配置。首次启动自动完成密钥检验与环境注入。
+- **专为编码调优**：预置代码主力模型（`monk-coding`）、极速推理模型（`monk-fast`）与融合旗舰（`monk`），并自动应用最佳 `max_tokens` 与角色兼容补丁。
+- **完全兼容原生 Pi**：保留 Pi 原生的所有命令行参数、会话管理、TUI 快捷键和插件生态。
+
+---
+
+## 🚀 快速开始
+
+### 1. 一键运行 (推荐)
+
+无需全局安装，直接通过 `npx` 启动：
+
+```bash
+npx monk-pi
+```
+
+或者全局安装命令：
+
+```bash
+npm install -g monk-pi
+monk-pi
+```
+
+首次运行会自动弹出向导，提示输入您的 Monk API Key（可在 [monk.party](https://monk.party) 订阅获取），随后即刻进入极速编码终端。
+
+---
+
+## 🛠️ 常用使用场景
+
+### 1. 日常交互式编程
+
+```bash
+# 直接进入交互式编码 Agent (默认使用 monk-coding)
+monk-pi
+
+# 带着初始任务进入
+monk-pi "重构当前目录下的鉴权模块，补充单元测试"
+
+# 恢复上一轮历史会话
+monk-pi --continue
+```
+
+### 2. 命令行单次执行 (Print Mode)
+
+```bash
+# 检查依赖并直接输出结果后退出
+monk-pi -p "解释当前 package.json 的依赖版本"
+
+# 审查 Git 改动
+monk-pi -p "检查 git diff，给出简洁的 commit message"
+```
+
+### 3. 指定临时模型
+
+```bash
+# 使用极速模型进行轻量提问
+monk-pi --model monk-fast "这行正则是什么意思？"
+
+# 使用综合质量优先模型
+monk-pi --model monk "帮我设计一套分布式系统的架构方案"
+```
+
+---
+
+## 🧰 专属管理命令
+
+| 命令 | 说明 |
+| :--- | :--- |
+| `monk-pi login` (或 `auth`) | 交互式配置或更新 Monk API Key，并自动同步至 Pi |
+| `monk-pi status` (或 `check`) | 检测 API 网络延迟、认证有效性及推演通道 |
+| `monk-pi model [name]` | 查看或切换默认主力模型 (`monk-coding` / `monk-fast` / `monk`) |
+| `monk-pi doctor` | 一键诊断 Node、Pi 运行时、配置文件健康度与网络状况 |
+
+---
+
+## ⚙️ 自动注入的 Pi 最佳配置
+
+`monk-pi` 会在 `~/.pi/agent/models.json` 中安全注入以下经深度调优的配置，不会覆盖您原有的其他自定义 Provider：
+
+```json
+{
+  "providers": {
+    "monk": {
+      "name": "Monk",
+      "baseUrl": "https://monk.party/v1",
+      "api": "openai-completions",
+      "apiKey": "$MONK_API_KEY",
+      "compat": {
+        "supportsDeveloperRole": false,
+        "maxTokensField": "max_tokens",
+        "requiresToolResultName": true
+      },
+      "models": [
+        {
+          "id": "monk-coding",
+          "name": "Monk Coding (代码主力 - 推荐)",
+          "reasoning": true,
+          "contextWindow": 1000000,
+          "maxTokens": 64000
+        },
+        {
+          "id": "monk-fast",
+          "name": "Monk Fast (极速推理)",
+          "reasoning": true,
+          "contextWindow": 1000000,
+          "maxTokens": 64000
+        },
+        {
+          "id": "monk",
+          "name": "Monk (融合模型)",
+          "reasoning": true,
+          "contextWindow": 1000000,
+          "maxTokens": 64000
+        }
+      ]
+    }
+  }
+}
+```
+
+---
+
+## 🗺️ 后续迭代规划 (Roadmap)
+
+- [x] **Phase 1: 轻量脚手架与启动器**
+  - [x] 交互式 Key 引导与实时有效性校验
+  - [x] Pi 运行时环境检测与自动注入
+  - [x] `status` / `doctor` / `model` 诊断指令
+  - [x] 完整参数透传与 TTY 会话继承
+- [ ] **Phase 2: Monk 原生 Pi Extension**
+  - [ ] TUI 底部状态栏展示 Monk 订阅剩余天数与今日用量
+  - [ ] 针对 Monk 代理的上游报错拦截与自动 Context Compaction 重试机制
+  - [ ] `/monk` 专属 Slash 快捷指令
+- [ ] **Phase 3: 生态共建**
+  - [ ] 提交收录至 monk.party 帮助中心客户端推荐列表
+
+---
+
+## 📄 开源许可
+
+MIT License

package/dist/chunk-DHF5QVTM.js

@@ -0,0 +1,812 @@
+// 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");
+}
+
+// src/config.ts
+import fs from "fs";
+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 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)}`
+    };
+  }
+}
+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(), 12e3);
+    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;
+    if (!response.ok) {
+      const errJson = await response.json().catch(() => ({}));
+      return {
+        success: false,
+        latencyMs,
+        error: errJson.error?.message || `HTTP ${response.status}`
+      };
+    }
+    const json = await response.json().catch(() => ({}));
+    const reply = json.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 pc from "picocolors";
+import { password, select, confirm } from "@inquirer/prompts";
+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\u9AD8\u5E76\u53D1\u6781\u901F\u878D\u5408\u6A21\u578B\u3002\u8BF7\u914D\u7F6E\u60A8\u7684 API Key\u3002")}`);
+  console.log(`  ${pc.dim("\u8FD8\u6CA1\u6709 Key\uFF1F\u53EF\u4EE5\u5728")} ${pc.underline(pc.yellow(MONK_WEBSITE))} ${pc.dim("\u8BA2\u9605\u6708\u5361 (\xA530/\u6708)")}`);
+  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\u8F93\u5165 Monk API Key (\u683C\u5F0F 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 path2 from "path";
+import { fileURLToPath } from "url";
+import spawn from "cross-spawn";
+import pc2 from "picocolors";
+function resolvePiBinary() {
+  try {
+    const globalCheck = spawn.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 = [
+    path2.resolve(path2.dirname(fileURLToPath(import.meta.url)), "../node_modules/.bin/pi"),
+    path2.resolve(process.cwd(), "node_modules/.bin/pi")
+  ];
+  for (const binPath of candidateBinDirs) {
+    if (fs2.existsSync(binPath)) {
+      try {
+        const localCheck = spawn.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 (${path2.basename(path2.dirname(binPath))})`
+          };
+        }
+      } catch {
+      }
+    }
+  }
+  try {
+    const mainEntry = fileURLToPath(import.meta.resolve("@earendil-works/pi-coding-agent"));
+    const cliEntry = path2.join(path2.dirname(mainEntry), "bundle", "cli.js");
+    if (fs2.existsSync(cliEntry)) {
+      const moduleCheck = spawn.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 = spawn.sync("bun", ["--version"], { stdio: "ignore" });
+    if (bunCheck.status === 0) return "bun";
+  } catch {
+  }
+  try {
+    const pnpmCheck = spawn.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 = spawn.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 = spawn(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`);
+  }
+  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);
+  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}`);
+  }
+  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
+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);
+  const defaultModel = getDefaultModel();
+  return launchPi({
+    apiKey: key,
+    defaultModel,
+    passthroughArgs
+  });
+}
+
+// src/commands/status.ts
+import pc6 from "picocolors";
+async function statusCommand() {
+  printBanner();
+  console.log(`  ${pc6.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: ${pc6.bold("\u5DF2\u5C31\u7EEA")} (v${piDetect.version}) \xB7 ${pc6.dim(`[\u6765\u6E90: ${piDetect.description}]`)}`
+    );
+  } else {
+    logWarn(`Pi \u8FD0\u884C\u73AF\u5883: ${pc6.red("\u672A\u68C0\u6D4B\u5230\u53EF\u7528\u8FD0\u884C\u65F6")}`);
+    console.log(`    ${pc6.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: ${pc6.red("\u672A\u914D\u7F6E")}`);
+    console.log(`    ${pc6.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: ${pc6.bold(maskKey(key))} ${pc6.dim(`[\u6765\u6E90: ${sourceLabels[source]}]`)}`);
+  logInfo(`\u5F53\u524D\u9ED8\u8BA4\u4E3B\u529B\u6A21\u578B: ${pc6.yellow(defaultModel)}`);
+  logInfo(`Monk \u57FA\u7840\u5730\u5740: ${pc6.dim(MONK_BASE_URL)}`);
+  process.stdout.write(`  ${pc6.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 ${pc6.dim("\xB7")} \u8BA4\u8BC1\u6709\u6548 ${pc6.dim("\xB7")} \u5EF6\u8FDF: ${pc6.green(`${valResult.latencyMs}ms`)}`
+    );
+    if (valResult.models.length > 0) {
+      logInfo(`\u652F\u6301\u7684\u6A21\u578B\u7AEF\u70B9: ${pc6.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(`  ${pc6.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 ${pc6.dim("\xB7")} \u54CD\u5E94\u5EF6\u8FDF: ${pc6.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(pc6.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(`  ${pc6.dim("\u5B98\u65B9\u7F51\u7AD9:")} ${pc6.cyan(MONK_WEBSITE)}`);
+  console.log(`  ${pc6.dim("\u7528\u91CF\u4E0E\u5230\u671F\u67E5\u8BE2:")} ${pc6.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,
+  loadMonkConfig,
+  saveMonkConfig,
+  resolveApiKey,
+  syncPiModelsJson,
+  getDefaultModel,
+  validateApiKey,
+  testChatCompletion,
+  printBanner,
+  logSuccess,
+  logInfo,
+  logWarn,
+  logError,
+  logStep,
+  promptForApiKey,
+  promptSelectModel,
+  promptInstallPi,
+  maskKey,
+  resolvePiBinary,
+  detectPi,
+  detectPackageManager,
+  installPi,
+  launchPi,
+  doctorCommand,
+  loginCommand,
+  modelCommand,
+  runCommand,
+  statusCommand
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+import {
+  MONK_ACCOUNT_URL,
+  MONK_WEBSITE,
+  doctorCommand,
+  loginCommand,
+  modelCommand,
+  printBanner,
+  runCommand,
+  statusCommand
+} from "./chunk-DHF5QVTM.js";
+
+// src/cli.ts
+import { Command } from "commander";
+import pc from "picocolors";
+var rawArgs = process.argv.slice(2);
+var firstArg = rawArgs[0];
+var SUBCOMMANDS = /* @__PURE__ */ new Set(["login", "auth", "status", "check", "model", "doctor"]);
+async function main() {
+  if (firstArg && SUBCOMMANDS.has(firstArg)) {
+    const program = new Command();
+    program.name("monk-pi").description("Monk \xD7 Pi: \u6781\u901F\u9AD8\u6027\u4EF7\u6BD4 Coding Agent Harness").version("0.1.0");
+    program.command("login").alias("auth").description("\u914D\u7F6E\u6216\u66F4\u65B0 Monk API Key\uFF0C\u5E76\u81EA\u52A8\u540C\u6B65\u5230 Pi \u914D\u7F6E\u6587\u4EF6").action(async () => {
+      await loginCommand();
+    });
+    program.command("status").alias("check").description("\u6D4B\u8BD5 Monk API \u5EF6\u8FDF\u3001Key \u72B6\u6001\u53CA\u6A21\u578B\u8FDE\u901A\u6027").action(async () => {
+      await statusCommand();
+    });
+    program.command("model [name]").description("\u5207\u6362\u9ED8\u8BA4\u4E3B\u529B\u6A21\u578B (monk-coding / monk-fast / monk)").action(async (name) => {
+      await modelCommand(name);
+    });
+    program.command("doctor").description("\u5168\u9762\u8BCA\u65AD\u73AF\u5883\u3001Node \u7248\u672C\u3001Pi \u6838\u5FC3\u53CA\u7F51\u7EDC\u517C\u5BB9\u6027").action(async () => {
+      await doctorCommand();
+    });
+    await program.parseAsync(process.argv);
+    return;
+  }
+  if (firstArg === "--help" || firstArg === "-h") {
+    printBanner();
+    console.log(`  ${pc.bold("\u7528\u6CD5:")}`);
+    console.log(`    ${pc.yellow("monk-pi")}                       \u8FDB\u5165\u4EA4\u4E92\u5F0F\u7F16\u7801\u6A21\u5F0F (\u9ED8\u8BA4\u4F7F\u7528 monk-coding)`);
+    console.log(`    ${pc.yellow("monk-pi")} [\u9009\u9879/\u63D0\u793A\u8BCD...]        \u4F20\u9012\u6307\u4EE4\u6216\u6587\u4EF6\u7ED9 Pi`);
+    console.log();
+    console.log(`  ${pc.bold("\u793A\u4F8B:")}`);
+    console.log(`    ${pc.dim("# \u542F\u52A8\u4EA4\u4E92\u5F0F Agent")}`);
+    console.log(`    ${pc.cyan("monk-pi")}`);
+    console.log();
+    console.log(`    ${pc.dim("# \u5E26\u521D\u59CB\u9700\u6C42\u8FDB\u5165\u4EA4\u4E92\u5F0F\u7EC8\u7AEF")}`);
+    console.log(`    ${pc.cyan('monk-pi "\u91CD\u6784\u8FD9\u4E2A\u76EE\u5F55\u4E0B\u7684\u4EE3\u7801"')}`);
+    console.log();
+    console.log(`    ${pc.dim("# \u975E\u4EA4\u4E92\u5F0F\u547D\u4EE4\u884C\u6A21\u5F0F (\u6253\u5370\u7ED3\u679C\u5E76\u9000\u51FA)")}`);
+    console.log(`    ${pc.cyan('monk-pi -p "\u89E3\u91CA\u5F53\u524D package.json \u7684\u4F9D\u8D56"')}`);
+    console.log();
+    console.log(`    ${pc.dim("# \u6307\u5B9A\u4F7F\u7528\u6781\u901F\u63A8\u7406\u6A21\u578B")}`);
+    console.log(`    ${pc.cyan('monk-pi --model monk-fast "\u5FEB\u901F\u5BA1\u67E5\u8FD9\u4E2A\u63D0\u4EA4"')}`);
+    console.log();
+    console.log(`    ${pc.dim("# \u6062\u590D\u4E0A\u4E00\u8F6E\u5386\u53F2\u4F1A\u8BDD")}`);
+    console.log(`    ${pc.cyan("monk-pi --continue")}`);
+    console.log();
+    console.log(`  ${pc.bold("\u4E13\u5C5E\u7BA1\u7406\u6307\u4EE4:")}`);
+    console.log(`    ${pc.yellow("monk-pi login")}                 \u914D\u7F6E / \u66F4\u65B0 Monk API Key`);
+    console.log(`    ${pc.yellow("monk-pi status")}                \u68C0\u6D4B API \u5EF6\u8FDF\u3001Key \u72B6\u6001\u4E0E\u8FDE\u901A\u6027`);
+    console.log(`    ${pc.yellow("monk-pi model [name]")}          \u67E5\u770B\u6216\u5207\u6362\u9ED8\u8BA4\u4E3B\u529B\u6A21\u578B`);
+    console.log(`    ${pc.yellow("monk-pi doctor")}                \u4E00\u952E\u8BCA\u65AD\u73AF\u5883\u4F9D\u8D56\u4E0E\u517C\u5BB9\u914D\u7F6E`);
+    console.log();
+    console.log(`  ${pc.bold("\u76F8\u5173\u94FE\u63A5:")}`);
+    console.log(`    Monk \u5B98\u7F51: ${pc.underline(pc.cyan(MONK_WEBSITE))}`);
+    console.log(`    \u7528\u91CF\u67E5\u8BE2: ${pc.underline(pc.cyan(MONK_ACCOUNT_URL))}`);
+    console.log();
+    return;
+  }
+  if (firstArg === "--version" || firstArg === "-v") {
+    console.log("monk-pi v0.1.0");
+    return;
+  }
+  const exitCode = await runCommand(rawArgs);
+  process.exit(exitCode);
+}
+main().catch((err) => {
+  console.error(pc.red(`
+[monk-pi \u5F02\u5E38]: ${err.message || err}
+`));
+  process.exit(1);
+});

package/dist/index.d.ts

@@ -0,0 +1,152 @@
+declare const MONK_BASE_URL = "https://monk.party/v1";
+declare const MONK_WEBSITE = "https://monk.party";
+declare const MONK_ACCOUNT_URL = "https://monk.party/account/";
+declare const MONK_MODELS: readonly [{
+    readonly id: "monk-coding";
+    readonly name: "Monk Coding (代码主力 - 推荐)";
+    readonly description: "专为 Agent 深度优化，兼备高吞吐逻辑推演与工具调用能力";
+    readonly reasoning: true;
+    readonly contextWindow: 1000000;
+    readonly maxTokens: 64000;
+}, {
+    readonly id: "monk-fast";
+    readonly name: "Monk Fast (极速推理)";
+    readonly description: "极速响应，适合日常问答、快速代码探索与单文件阅读";
+    readonly reasoning: true;
+    readonly contextWindow: 1000000;
+    readonly maxTokens: 64000;
+}, {
+    readonly id: "monk";
+    readonly name: "Monk (融合模型)";
+    readonly description: "集三大 Flash 之所长，综合质量与思考能力优先";
+    readonly reasoning: true;
+    readonly contextWindow: 1000000;
+    readonly maxTokens: 64000;
+}];
+type MonkModelId = (typeof MONK_MODELS)[number]["id"];
+declare const DEFAULT_MONK_MODEL: MonkModelId;
+declare function getMonkHomeDir(): string;
+declare function getMonkConfigFile(): string;
+declare function getPiHomeDir(): string;
+declare function getPiModelsFile(): string;
+declare function getPiSettingsFile(): string;
+
+interface MonkLocalConfig {
+    apiKey?: string;
+    defaultModel?: MonkModelId;
+    baseUrl?: string;
+    lastVerified?: string;
+    email?: string;
+    tradeNo?: string;
+}
+declare function loadMonkConfig(): MonkLocalConfig;
+declare function saveMonkConfig(config: MonkLocalConfig): void;
+/**
+ * Resolves the Monk API Key by checking env -> local config -> pi models.json
+ */
+declare function resolveApiKey(): {
+    key: string;
+    source: "env" | "local" | "pi" | "none";
+};
+/**
+ * Safely updates or injects the Monk provider config into Pi's models.json
+ */
+declare function syncPiModelsJson(apiKey?: string): {
+    success: boolean;
+    path: string;
+    error?: string;
+};
+/**
+ * Gets the current default model
+ */
+declare function getDefaultModel(): MonkModelId;
+
+interface ValidateResult {
+    valid: boolean;
+    latencyMs: number;
+    models: string[];
+    error?: string;
+    statusCode?: number;
+}
+interface CompletionTestResult {
+    success: boolean;
+    latencyMs: number;
+    reply?: string;
+    error?: string;
+}
+/**
+ * Validates the Monk API Key by checking GET /v1/models
+ */
+declare function validateApiKey(apiKey: string, baseUrl?: string): Promise<ValidateResult>;
+/**
+ * Tests an actual chat completion to ensure the model responds properly
+ */
+declare function testChatCompletion(apiKey: string, model?: string, baseUrl?: string): Promise<CompletionTestResult>;
+
+type PiBinaryType = "global" | "local" | "bundled" | "missing";
+interface ResolvedPi {
+    type: PiBinaryType;
+    command: string;
+    argsPrefix: string[];
+    version?: string;
+    sourceDescription: string;
+}
+/**
+ * Resolves Pi executable across global PATH, local project, and bundled dependencies
+ */
+declare function resolvePiBinary(): ResolvedPi;
+declare function detectPi(): {
+    installed: boolean;
+    version?: string;
+    type?: PiBinaryType;
+    description?: string;
+};
+/**
+ * Detects the available package manager on the host machine
+ */
+declare function detectPackageManager(): "bun" | "pnpm" | "npm";
+/**
+ * Installs Pi globally using the best detected package manager
+ */
+declare function installPi(): Promise<boolean>;
+interface LaunchPiOptions {
+    apiKey: string;
+    defaultModel: string;
+    passthroughArgs: string[];
+}
+/**
+ * Launches Pi with Monk provider & model flags, passing through all user arguments
+ */
+declare function launchPi(options: LaunchPiOptions): number;
+
+declare function printBanner(): void;
+declare function logSuccess(msg: string): void;
+declare function logInfo(msg: string): void;
+declare function logWarn(msg: string): void;
+declare function logError(msg: string): void;
+declare function logStep(step: number, total: number, msg: string): void;
+/**
+ * Interactive prompt for API Key
+ */
+declare function promptForApiKey(currentKey?: string): Promise<string>;
+/**
+ * Interactive prompt for selecting default model
+ */
+declare function promptSelectModel(currentModel?: MonkModelId): Promise<MonkModelId>;
+/**
+ * Prompt to install pi if missing
+ */
+declare function promptInstallPi(): Promise<boolean>;
+declare function maskKey(key: string): string;
+
+declare function loginCommand(): Promise<boolean>;
+
+declare function statusCommand(): Promise<void>;
+
+declare function modelCommand(targetModel?: string): Promise<void>;
+
+declare function doctorCommand(): Promise<void>;
+
+declare function runCommand(passthroughArgs: string[]): Promise<number>;
+
+export { type CompletionTestResult, DEFAULT_MONK_MODEL, type LaunchPiOptions, MONK_ACCOUNT_URL, MONK_BASE_URL, MONK_MODELS, MONK_WEBSITE, type MonkLocalConfig, type MonkModelId, type PiBinaryType, type ResolvedPi, type ValidateResult, detectPackageManager, detectPi, doctorCommand, getDefaultModel, getMonkConfigFile, getMonkHomeDir, getPiHomeDir, getPiModelsFile, getPiSettingsFile, installPi, launchPi, loadMonkConfig, logError, logInfo, logStep, logSuccess, logWarn, loginCommand, maskKey, modelCommand, printBanner, promptForApiKey, promptInstallPi, promptSelectModel, resolveApiKey, resolvePiBinary, runCommand, saveMonkConfig, statusCommand, syncPiModelsJson, testChatCompletion, validateApiKey };

package/dist/index.js

@@ -0,0 +1,78 @@
+import {
+  DEFAULT_MONK_MODEL,
+  MONK_ACCOUNT_URL,
+  MONK_BASE_URL,
+  MONK_MODELS,
+  MONK_WEBSITE,
+  detectPackageManager,
+  detectPi,
+  doctorCommand,
+  getDefaultModel,
+  getMonkConfigFile,
+  getMonkHomeDir,
+  getPiHomeDir,
+  getPiModelsFile,
+  getPiSettingsFile,
+  installPi,
+  launchPi,
+  loadMonkConfig,
+  logError,
+  logInfo,
+  logStep,
+  logSuccess,
+  logWarn,
+  loginCommand,
+  maskKey,
+  modelCommand,
+  printBanner,
+  promptForApiKey,
+  promptInstallPi,
+  promptSelectModel,
+  resolveApiKey,
+  resolvePiBinary,
+  runCommand,
+  saveMonkConfig,
+  statusCommand,
+  syncPiModelsJson,
+  testChatCompletion,
+  validateApiKey
+} from "./chunk-DHF5QVTM.js";
+export {
+  DEFAULT_MONK_MODEL,
+  MONK_ACCOUNT_URL,
+  MONK_BASE_URL,
+  MONK_MODELS,
+  MONK_WEBSITE,
+  detectPackageManager,
+  detectPi,
+  doctorCommand,
+  getDefaultModel,
+  getMonkConfigFile,
+  getMonkHomeDir,
+  getPiHomeDir,
+  getPiModelsFile,
+  getPiSettingsFile,
+  installPi,
+  launchPi,
+  loadMonkConfig,
+  logError,
+  logInfo,
+  logStep,
+  logSuccess,
+  logWarn,
+  loginCommand,
+  maskKey,
+  modelCommand,
+  printBanner,
+  promptForApiKey,
+  promptInstallPi,
+  promptSelectModel,
+  resolveApiKey,
+  resolvePiBinary,
+  runCommand,
+  saveMonkConfig,
+  statusCommand,
+  syncPiModelsJson,
+  testChatCompletion,
+  validateApiKey
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "monk-pi",
+  "version": "0.1.0",
+  "description": "Zero-config harness for running Pi Coding Agent with Monk API (monk.party)",
+  "type": "module",
+  "bin": "./dist/cli.js",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "start": "node ./dist/cli.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "monk",
+    "pi",
+    "coding-agent",
+    "llm",
+    "ai",
+    "harness",
+    "cli"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@earendil-works/pi-coding-agent": "^0.85.1",
+    "@inquirer/prompts": "^8.7.2",
+    "commander": "^15.0.0",
+    "cross-spawn": "^7.0.6",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/cross-spawn": "^6.0.6",
+    "@types/node": "^26.5.1",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  }
+}