abelworkflow 0.8.1 → 0.9.0

package/README.md

@@ -1,6 +1,6 @@
 # AbelWorkflow
 
-Codex、OpenCode、Claude Code 的 Skills 和 Commands 配置仓库。
+Codex、OpenCode、Claude Code、Pi 的 Skills、Commands/Prompts 和扩展配置仓库。
 
 ## 目录结构
 
@@ -17,6 +17,7 @@ Codex、OpenCode、Claude Code 的 Skills 和 Commands 配置仓库。
 │   └── prompt-enhancer/     # 提示词优化器
 ├── commands/           # 命令目录
 │   └── oc/                # 工作流命令
+├── extensions/         # Pi 扩展
 ├── AGENTS.md         # Agent 全局系统 prompts
 └── README.md
 ```
@@ -76,11 +77,12 @@ npx abelworkflow@latest
 > 说明：
 > - npm 发布包名必须使用小写，所以实际可执行命令是 `npx abelworkflow`。
 > - 交互式模式下，默认会打开初始化菜单，支持：
->   - 同步 `~/.agents` 并自动重建 `~/.claude` / `~/.codex` 链接
+>   - 同步 `~/.agents` 并自动重建 `~/.claude` / `~/.codex` / `~/.pi/agent` 链接
 >   - 交互式填写 `grok-search`、`context7-auto-research`、`prompt-enhancer` 的 `.env`
->   - 一键安装或更新 `Claude Code`、`Codex`
+>   - 一键安装或更新 `Claude Code`、`Codex`、`Pi`
 >   - 配置 `Claude Code` 的第三方 API 到 `~/.claude/settings.json`
 >   - 配置 `Codex` 的第三方 API 到 `~/.codex/config.toml` 和 `~/.codex/auth.json`
+>   - 配置 `Pi` 的自定义 API 到 `~/.pi/agent/models.json` 中的 `gpt` provider，并设置 `~/.pi/agent/settings.json` 默认模型，同时携带 Pi 扩展
 > - 非交互场景请显式使用 `npx abelworkflow install`，不再保留旧的默认自动同步逻辑。
 
 ### 交互式初始化能力
@@ -97,12 +99,14 @@ npx abelworkflow --help
 其中完整初始化会按需引导你完成：
 
 1. 安装 AbelWorkflow 到 `~/.agents`
-2. 自动链接到 `~/.claude/` 和 `~/.codex/`
+2. 自动链接到 `~/.claude/`、`~/.codex/` 和 `~/.pi/agent/`
 3. 可选安装 `Claude Code` CLI
 4. 可选配置 `Claude Code` 第三方 API
 5. 可选安装 `Codex` CLI
 6. 可选配置 `Codex` 第三方 API
-7. 可选填写三个技能的环境变量
+7. 可选安装 `Pi` CLI
+8. 可选配置 Pi `gpt` provider 自定义 API，并链接 Pi 扩展
+9. 可选填写三个技能的环境变量
 
 ### 技能环境写入位置
 
@@ -174,11 +178,12 @@ node .\bin\abelworkflow.mjs install
 
 ### 映射关系（本仓库 → 配置目录）
 
-| 本仓库 | Claude Code | Codex | 说明 |
-|---|---|---|---|
-| `AGENTS.md` | `~/.claude/CLAUDE.md` | `~/.codex/AGENTS.md` | 全局系统提示词/规则 |
-| `skills/<skill>/` | `~/.claude/skills/<skill>/` | `~/.codex/skills/<skill>/` | Skills（每个目录一个技能） |
-| `commands/abel-*.md` | `~/.claude/commands/abel-*.md` | `~/.codex/prompts/abel-*.md` | 扁平化部署，避免命名冲突 |
+| 本仓库 | Claude Code | Codex | Pi | 说明 |
+|---|---|---|---|---|
+| `AGENTS.md` | `~/.claude/CLAUDE.md` | `~/.codex/AGENTS.md` | `~/.pi/agent/AGENTS.md` | 全局系统提示词/规则 |
+| `skills/<skill>/` | `~/.claude/skills/<skill>/` | `~/.codex/skills/<skill>/` | `~/.pi/agent/skills/<skill>/` | Skills（每个目录一个技能） |
+| `commands/abel-*.md` | `~/.claude/commands/abel-*.md` | `~/.codex/prompts/abel-*.md` | `~/.pi/agent/prompts/abel-*.md` | 扁平化部署，避免命名冲突 |
+| `extensions/*.ts` | - | - | `~/.pi/agent/extensions/*.ts` | Pi 扩展 |
 
 ### 验证（可选）
 

package/extensions/pi-gpt-responses-compat.ts

@@ -0,0 +1,25 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+export default function (pi: ExtensionAPI) {
+  pi.on("before_provider_request", (event, ctx) => {
+    const payload = event.payload as any;
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) return;
+    if (ctx.model?.provider !== "gpt") return;
+    if (!("input" in payload)) return;
+
+    const input = Array.isArray(payload.input) ? payload.input : [];
+    const first = input[0];
+    const isPrompt = first?.role === "system" || first?.role === "developer";
+    const instructions =
+      (typeof payload.instructions === "string" && payload.instructions.trim()) ||
+      (isPrompt && typeof first.content === "string" && first.content.trim()) ||
+      ctx.getSystemPrompt().trim();
+
+    const nextPayload = { ...payload };
+    delete nextPayload.prompt_cache_key;
+    delete nextPayload.prompt_cache_retention;
+    delete nextPayload.max_output_tokens;
+
+    return { ...nextPayload, instructions, input: isPrompt ? input.slice(1) : input };
+  });
+}

package/lib/cli/logic.mjs

@@ -6,14 +6,38 @@ const interactiveMenuDescriptors = [
   { value: "grok-search", label: "配置 grok-search", hint: "技能", group: "skill" },
   { value: "context7", label: "配置 context7-auto-research", hint: "技能", group: "skill" },
   { value: "prompt-enhancer", label: "配置 prompt-enhancer", hint: "技能", group: "skill" },
-  { value: "claude-install", label: "安装/更新 Claude Code", hint: "CLI", group: "cli" },
-  { value: "claude-api", label: "配置 Claude API", hint: "CLI", group: "cli" },
-  { value: "codex-install", label: "安装/更新 Codex", hint: "CLI", group: "cli" },
-  { value: "codex-api", label: "配置 Codex API", hint: "CLI", group: "cli" },
+  { value: "pi-cli", label: "安装/配置 Pi", hint: "CLI", group: "cli" },
+  { value: "codex-cli", label: "安装/配置 Codex", hint: "CLI", group: "cli" },
+  { value: "claude-cli", label: "安装/配置 Claude Code", hint: "CLI", group: "cli" },
   { value: "exit", label: "退出", group: "exit" }
 ];
 
 const interactiveMenuDefaultValue = "full-init";
+const cliToolMenuDescriptorMap = {
+  pi: [
+    { value: "pi-install", label: "安装/更新 Pi" },
+    { value: "pi-api", label: "配置 Pi API" },
+    { value: "back", label: "返回上一级" }
+  ],
+  codex: [
+    { value: "codex-install", label: "安装/更新 Codex" },
+    { value: "codex-api", label: "配置 Codex API" },
+    { value: "back", label: "返回上一级" }
+  ],
+  claude: [
+    { value: "claude-install", label: "安装/更新 Claude Code" },
+    { value: "claude-api", label: "配置 Claude Code API" },
+    { value: "back", label: "返回上一级" }
+  ]
+};
+
+function buildCliToolMenuDescriptors(tool) {
+  const descriptors = cliToolMenuDescriptorMap[tool];
+  if (!descriptors) {
+    throw new Error(`Unknown CLI tool: ${tool}`);
+  }
+  return descriptors.map((descriptor) => ({ ...descriptor }));
+}
 
 class CancelledError extends Error {
   constructor(message = "用户取消") {
@@ -175,6 +199,7 @@ function getRunCommandSpawnOptions(platform = process.env.ABELWORKFLOW_TEST_PLAT
 export {
   assertInteractiveMenuSupported,
   assertNotCancelled,
+  buildCliToolMenuDescriptors,
   CancelledError,
   confirmOrCancel,
   getRunCommandSpawnOptions,

package/lib/cli.mjs

@@ -9,6 +9,7 @@ import c from "picocolors";
 import {
   assertInteractiveMenuSupported,
   assertNotCancelled,
+  buildCliToolMenuDescriptors,
   CancelledError,
   confirmOrCancel,
   getRunCommandSpawnOptions,
@@ -33,6 +34,13 @@ const codexAuthPath = join(home, ".codex", "auth.json");
 const codexTemplateRoot = join(packageRoot, "lib", "templates", "codex");
 const codexTemplateConfigPath = join(codexTemplateRoot, "config-base.toml");
 const codexTemplateAgentsPath = join(codexTemplateRoot, "agents");
+const piAgentDir = join(home, ".pi", "agent");
+const piModelsPath = join(piAgentDir, "models.json");
+const piSettingsPath = join(piAgentDir, "settings.json");
+const piProviderId = "gpt";
+const piDefaultApi = "openai-responses";
+const piDefaultBaseUrl = "https://api.openai.com/v1";
+const piDefaultModel = "gpt-5.5";
 const installBackupStamp = Date.now();
 const createdBackupPaths = new Set();
 const augmentContextEnginePermission = "mcp__augment-context-engine";
@@ -95,6 +103,7 @@ const managedEntries = [
   { target: "README.md" },
   { target: "commands", preserveExisting: true },
   { target: "skills", preserveExisting: true, filter: shouldCopySkillPath },
+  { target: "extensions", preserveExisting: true },
   { target: ".skill-lock.json" },
   { target: ".gitignore", sourceCandidates: [".gitignore", ".npmignore"] }
 ];
@@ -390,6 +399,39 @@ async function writeInstallMetadata(agentsDir, metadata) {
   await writeFile(join(agentsDir, installMetadataName), `${JSON.stringify(metadata, null, 2)}\n`, "utf8");
 }
 
+function linkedTargetsFromResults(results) {
+  return Object.fromEntries(
+    results
+      .filter((result) => result.sourcePath)
+      .map((result) => [
+        result.targetPath,
+        {
+          sourcePath: result.sourcePath,
+          kind: result.kind,
+          mode: result.mode
+        }
+      ])
+  );
+}
+
+function mergeLinkedTargets(previousLinkedTargets = {}, results = []) {
+  const nextLinkedTargets = { ...previousLinkedTargets };
+  for (const result of results) {
+    if (result.sourcePath) {
+      nextLinkedTargets[result.targetPath] = {
+        sourcePath: result.sourcePath,
+        kind: result.kind,
+        mode: result.mode
+      };
+      continue;
+    }
+    if (result.status === "removed") {
+      delete nextLinkedTargets[result.targetPath];
+    }
+  }
+  return nextLinkedTargets;
+}
+
 async function renderManagedWorkflowFile(path, augmentContextEngine) {
   if (!(await pathIsFile(path))) {
     return;
@@ -666,6 +708,18 @@ async function getCommandNames(commandsDir) {
   return names.filter(Boolean);
 }
 
+async function getPiExtensionNames(extensionsDir) {
+  if (!(await pathIsDirectory(extensionsDir))) {
+    return [];
+  }
+
+  const entries = await readdir(extensionsDir, { withFileTypes: true });
+  const names = await Promise.all(
+    entries.map(async (entry) => ((await isPiExtensionEntry(extensionsDir, entry)) ? entry.name : null))
+  );
+  return names.filter(Boolean);
+}
+
 async function pathIsDirectory(path) {
   try {
     return (await stat(path)).isDirectory();
@@ -710,6 +764,23 @@ async function isMarkdownFileEntry(root, entry) {
   return pathIsFile(join(root, entry.name));
 }
 
+async function isPiExtensionEntry(root, entry) {
+  const entryPath = join(root, entry.name);
+  if (entry.isDirectory()) {
+    return pathIsFile(join(entryPath, "index.ts"));
+  }
+  if (entry.isFile()) {
+    return entry.name.endsWith(".ts");
+  }
+  if (!entry.isSymbolicLink()) {
+    return false;
+  }
+  if (entry.name.endsWith(".ts") && await pathIsFile(entryPath)) {
+    return true;
+  }
+  return pathIsFile(join(entryPath, "index.ts"));
+}
+
 async function pruneManagedTargets(targetDir, managedSourceRoot, expectedNames, previousLinkedTargets) {
   if (!(await pathExists(targetDir))) {
     return [];
@@ -844,6 +915,71 @@ async function linkCodex(agentsDir, previousLinkedTargets) {
   return results;
 }
 
+async function linkPi(agentsDir, previousLinkedTargets) {
+  const results = [];
+  await mkdir(piAgentDir, { recursive: true });
+  await removeIfNotDirectory(join(piAgentDir, "skills"));
+  await removeIfNotDirectory(join(piAgentDir, "prompts"));
+  await removeIfNotDirectory(join(piAgentDir, "extensions"));
+  await mkdir(join(piAgentDir, "skills"), { recursive: true });
+  await mkdir(join(piAgentDir, "prompts"), { recursive: true });
+  await mkdir(join(piAgentDir, "extensions"), { recursive: true });
+
+  results.push(
+    await ensureManagedLink(
+      join(piAgentDir, "AGENTS.md"),
+      join(agentsDir, "AGENTS.md"),
+      "file",
+      previousLinkedTargets
+    )
+  );
+  results.push(...(await linkSkillDirectories(piAgentDir, agentsDir, previousLinkedTargets)));
+
+  const commandFiles = await getCommandNames(join(agentsDir, "commands"));
+  results.push(
+    ...(await pruneManagedTargets(
+      join(piAgentDir, "prompts"),
+      join(agentsDir, "commands"),
+      commandFiles,
+      previousLinkedTargets
+    ))
+  );
+  for (const fileName of commandFiles) {
+    results.push(
+      await ensureManagedLink(
+        join(piAgentDir, "prompts", fileName),
+        join(agentsDir, "commands", fileName),
+        "file",
+        previousLinkedTargets
+      )
+    );
+  }
+
+  const extensionNames = await getPiExtensionNames(join(agentsDir, "extensions"));
+  results.push(
+    ...(await pruneManagedTargets(
+      join(piAgentDir, "extensions"),
+      join(agentsDir, "extensions"),
+      extensionNames,
+      previousLinkedTargets
+    ))
+  );
+  for (const entryName of extensionNames) {
+    const sourcePath = join(agentsDir, "extensions", entryName);
+    const kind = await pathIsDirectory(sourcePath) ? "dir" : "file";
+    results.push(
+      await ensureManagedLink(
+        join(piAgentDir, "extensions", entryName),
+        sourcePath,
+        kind,
+        previousLinkedTargets
+      )
+    );
+  }
+
+  return results;
+}
+
 async function installManagedWorkflow(options) {
   let previousMetadata = {};
   let managedChildren = {};
@@ -870,30 +1006,21 @@ async function installManagedWorkflow(options) {
   }
 
   const previousLinkedTargets = previousMetadata.linkedTargets ?? {};
-  s.start("正在链接 Claude / Codex...");
+  s.start("正在链接 Claude / Codex / Pi...");
   let claudeResults;
   let codexResults;
+  let piResults;
   try {
     claudeResults = await linkClaude(options.agentsDir, previousLinkedTargets);
     codexResults = await linkCodex(options.agentsDir, previousLinkedTargets);
+    piResults = await linkPi(options.agentsDir, previousLinkedTargets);
   } catch (e) {
     s.cancel(c.red(`链接失败: ${e.message}`));
     throw e;
   }
   s.stop("链接完成");
 
-  const linkedTargets = Object.fromEntries(
-    [...claudeResults, ...codexResults]
-      .filter((result) => result.sourcePath)
-      .map((result) => [
-        result.targetPath,
-        {
-          sourcePath: result.sourcePath,
-          kind: result.kind,
-          mode: result.mode
-        }
-      ])
-  );
+  const linkedTargets = linkedTargetsFromResults([...claudeResults, ...codexResults, ...piResults]);
 
   const managedClaudePermissions = await ensureClaudeSettingsForFeature(augmentContextEngine, previousMetadata);
 
@@ -909,7 +1036,7 @@ async function installManagedWorkflow(options) {
     linkedTargets
   });
 
-  const resultLines = [...claudeResults, ...codexResults].map((result) => {
+  const resultLines = [...claudeResults, ...codexResults, ...piResults].map((result) => {
     const icon = result.status === "unchanged" ? c.gray("=")
       : result.status === "removed" ? c.yellow("−")
         : c.green("+");
@@ -943,6 +1070,188 @@ async function writeJsonFileWithBackup(path, data) {
   await writeJsonFileSafe(path, data);
 }
 
+function stripJsonComments(content) {
+  let output = "";
+  let inString = false;
+  let quote = "";
+  let escaped = false;
+  for (let i = 0; i < content.length; i += 1) {
+    const char = content[i];
+    const next = content[i + 1];
+
+    if (inString) {
+      output += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        inString = false;
+        quote = "";
+      }
+      continue;
+    }
+
+    if (char === "\"" || char === "'") {
+      inString = true;
+      quote = char;
+      output += char;
+      continue;
+    }
+
+    if (char === "/" && next === "/") {
+      while (i < content.length && content[i] !== "\n") {
+        i += 1;
+      }
+      if (i < content.length) {
+        output += content[i];
+      }
+      continue;
+    }
+
+    if (char === "/" && next === "*") {
+      i += 2;
+      while (i < content.length && !(content[i] === "*" && content[i + 1] === "/")) {
+        output += content[i] === "\n" ? "\n" : "";
+        i += 1;
+      }
+      i += 1;
+      continue;
+    }
+
+    output += char;
+  }
+  return stripJsonTrailingCommas(output);
+}
+
+function stripJsonTrailingCommas(content) {
+  let output = "";
+  let inString = false;
+  let quote = "";
+  let escaped = false;
+  for (let i = 0; i < content.length; i += 1) {
+    const char = content[i];
+
+    if (inString) {
+      output += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        inString = false;
+        quote = "";
+      }
+      continue;
+    }
+
+    if (char === "\"" || char === "'") {
+      inString = true;
+      quote = char;
+      output += char;
+      continue;
+    }
+
+    if (char === ",") {
+      let nextIndex = i + 1;
+      while (nextIndex < content.length && /\s/u.test(content[nextIndex])) {
+        nextIndex += 1;
+      }
+      if (content[nextIndex] === "}" || content[nextIndex] === "]") {
+        continue;
+      }
+    }
+
+    output += char;
+  }
+  return output;
+}
+
+async function readJsoncFileSafe(path, fallback = {}) {
+  if (!(await pathExists(path))) {
+    return fallback;
+  }
+
+  try {
+    return JSON.parse(stripJsonComments(await readFile(path, "utf8")));
+  } catch {
+    return fallback;
+  }
+}
+
+function parsePiModelIds(value) {
+  return [...new Set(String(value || "")
+    .split(/[\n,]+/u)
+    .map((item) => item.trim())
+    .filter(Boolean))];
+}
+
+function resolveExistingPiApiConfig(modelsConfig = {}, settings = {}) {
+  const provider = modelsConfig.providers?.[piProviderId] && typeof modelsConfig.providers[piProviderId] === "object"
+    ? modelsConfig.providers[piProviderId]
+    : {};
+  const models = Array.isArray(provider.models) ? provider.models.filter((model) => model?.id) : [];
+  return {
+    baseUrl: provider.baseUrl || piDefaultBaseUrl,
+    api: provider.api || piDefaultApi,
+    apiKey: provider.apiKey || "",
+    modelIds: models.map((model) => model.id),
+    defaultModel: settings.defaultProvider === piProviderId && settings.defaultModel
+      ? settings.defaultModel
+      : models[0]?.id || piDefaultModel
+  };
+}
+
+function buildPiModelConfig(modelId, existingModel = {}) {
+  return {
+    ...existingModel,
+    id: modelId,
+    name: existingModel.name || modelId,
+    reasoning: existingModel.reasoning ?? true,
+    input: Array.isArray(existingModel.input) ? existingModel.input : ["text", "image"],
+    contextWindow: existingModel.contextWindow ?? 262144,
+    maxTokens: existingModel.maxTokens ?? 64000
+  };
+}
+
+function buildPiModelsConfig(modelsConfig = {}, { baseUrl, api, apiKey, modelIds }) {
+  const providers = modelsConfig.providers && typeof modelsConfig.providers === "object" ? modelsConfig.providers : {};
+  const currentProvider = providers[piProviderId] && typeof providers[piProviderId] === "object" ? providers[piProviderId] : {};
+  const existingModels = new Map(
+    (Array.isArray(currentProvider.models) ? currentProvider.models : [])
+      .filter((model) => model?.id)
+      .map((model) => [model.id, model])
+  );
+
+  return {
+    ...modelsConfig,
+    providers: {
+      ...providers,
+      [piProviderId]: {
+        ...currentProvider,
+        baseUrl,
+        api,
+        apiKey,
+        compat: {
+          ...(currentProvider.compat && typeof currentProvider.compat === "object" ? currentProvider.compat : {}),
+          supportsDeveloperRole: false
+        },
+        models: modelIds.map((modelId) => buildPiModelConfig(modelId, existingModels.get(modelId)))
+      }
+    }
+  };
+}
+
+function buildPiSettingsConfig(settings = {}, defaultModel) {
+  return {
+    ...settings,
+    defaultProvider: piProviderId,
+    defaultModel,
+    defaultThinkingLevel: settings.defaultThinkingLevel || "high",
+    enableSkillCommands: settings.enableSkillCommands ?? true
+  };
+}
+
 function parseDotenv(content) {
   const values = {};
   for (const rawLine of content.split(/\r?\n/u)) {
@@ -1010,10 +1319,33 @@ async function updateDotenvFile(path, updates) {
   await writeFile(path, renderDotenv(current), "utf8");
 }
 
-function commandExists(command) {
+function getCommandPath(command) {
   const checker = isWindows() ? "where" : "which";
-  const result = spawnSync(checker, [command], { stdio: "ignore" });
-  return result.status === 0;
+  const result = spawnSync(checker, [command], { encoding: "utf8" });
+  if (result.status !== 0) {
+    return undefined;
+  }
+  return result.stdout
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .find(Boolean);
+}
+
+function commandExists(command) {
+  return Boolean(getCommandPath(command));
+}
+
+function readCommandOutput(command, args) {
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    shell: isWindows(),
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  if (result.status !== 0) {
+    return undefined;
+  }
+  const outputValue = result.stdout.trim();
+  return outputValue || undefined;
 }
 
 async function runCommand(command, args) {
@@ -1856,6 +2188,89 @@ async function getExistingCodexApiConfig() {
   return resolveExistingCodexApiConfig(content, auth);
 }
 
+async function ensurePiResourcesLinked(agentsDir) {
+  const { previousMetadata, managedChildren } = await syncManagedFiles(agentsDir);
+  const augmentContextEngine = resolveAugmentContextEngineFeature({}, previousMetadata);
+  await renderManagedWorkflowFiles(agentsDir, augmentContextEngine);
+
+  const previousLinkedTargets = previousMetadata.linkedTargets ?? {};
+  const piResults = await linkPi(agentsDir, previousLinkedTargets);
+  await writeInstallMetadata(agentsDir, {
+    ...previousMetadata,
+    package: previousMetadata.package || "abelworkflow",
+    installedAt: previousMetadata.installedAt || new Date().toISOString(),
+    features: {
+      ...(previousMetadata.features && typeof previousMetadata.features === "object" ? previousMetadata.features : {}),
+      augmentContextEngine
+    },
+    managedChildren,
+    managedClaudePermissions: getPreviousManagedClaudePermissions(previousMetadata),
+    linkedTargets: mergeLinkedTargets(previousLinkedTargets, piResults)
+  });
+  return piResults;
+}
+
+async function configurePiApi(agentsDir) {
+  const modelsConfig = await readJsoncFileSafe(piModelsPath, {});
+  const settings = await readJsonFileSafe(piSettingsPath, {});
+  const existing = resolveExistingPiApiConfig(modelsConfig, settings);
+
+  const baseUrl = await p.text({
+    message: "Pi gpt Base URL",
+    defaultValue: existing.baseUrl,
+    validate: required()
+  });
+  assertNotCancelled(baseUrl);
+
+  const piApiOptions = ["openai-responses", "openai-completions"];
+  const api = await selectOrCancel({
+    message: "Pi gpt API 类型",
+    options: [
+      { value: "openai-responses", label: "OpenAI Responses API" },
+      { value: "openai-completions", label: "OpenAI Chat Completions" }
+    ],
+    initialValue: piApiOptions.includes(existing.api) ? existing.api : piDefaultApi
+  });
+
+  const apiKey = await p.password({
+    message: "Pi gpt API Key（输入 - 清除）",
+    mask: "*",
+    defaultValue: existing.apiKey || undefined,
+    validate: requiredUnlessExisting(existing.apiKey, "API Key 不能为空")
+  });
+  assertNotCancelled(apiKey);
+  const finalApiKey = resolvePasswordValue(apiKey, existing.apiKey);
+
+  const modelIdsText = await p.text({
+    message: "Pi gpt 模型 ID（多个用逗号分隔）",
+    defaultValue: (existing.modelIds.length ? existing.modelIds : [existing.defaultModel]).join(","),
+    validate: (value) => parsePiModelIds(value).length ? undefined : "至少需要一个模型 ID"
+  });
+  assertNotCancelled(modelIdsText);
+  const modelIds = parsePiModelIds(modelIdsText);
+
+  const defaultModel = await p.text({
+    message: "Pi 默认模型",
+    defaultValue: modelIds.includes(existing.defaultModel) ? existing.defaultModel : modelIds[0],
+    validate: (value) => modelIds.includes(String(value || "").trim()) ? undefined : "默认模型必须在模型 ID 列表中"
+  });
+  assertNotCancelled(defaultModel);
+
+  const finalDefaultModel = String(defaultModel).trim();
+  await ensurePiResourcesLinked(agentsDir);
+  await writeJsonFileWithBackup(piModelsPath, buildPiModelsConfig(modelsConfig, {
+    baseUrl,
+    api,
+    apiKey: finalApiKey,
+    modelIds
+  }));
+  await writeJsonFileWithBackup(piSettingsPath, buildPiSettingsConfig(settings, finalDefaultModel));
+
+  p.log.step(`已更新 ${pathToLabel(piModelsPath)} (${piProviderId}, ${baseUrl})`);
+  p.log.step(`已更新 ${pathToLabel(piSettingsPath)} (默认模型: ${finalDefaultModel})`);
+  p.log.step(`已链接 Pi 扩展到 ${pathToLabel(join(piAgentDir, "extensions"))}`);
+}
+
 async function configureCodexApi() {
   const existing = await getExistingCodexApiConfig();
   const providerId = existing.providerId || "abelworkflow";
@@ -1945,14 +2360,140 @@ function buildCodexConfigContent(currentContent, {
 }
 
 function mergeCodexAuthData(auth, envKey, apiKey, legacyEnvKeys = []) {
-  const nextAuth = auth && typeof auth === "object" ? { ...auth } : {};
-  for (const key of legacyEnvKeys) {
-    if (key && key !== envKey) {
-      delete nextAuth[key];
+  return { [envKey]: apiKey };
+}
+
+function normalizeInstallPath(value) {
+  if (!value) {
+    return "";
+  }
+  return value.replace(/\\/gu, "/").replace(/\/+$/u, "").toLowerCase();
+}
+
+function installPathIsWithin(path, parentPath) {
+  const normalizedPath = normalizeInstallPath(path);
+  const normalizedParent = normalizeInstallPath(parentPath);
+  return Boolean(normalizedPath && normalizedParent)
+    && (normalizedPath === normalizedParent || normalizedPath.startsWith(`${normalizedParent}/`));
+}
+
+function getNpmGlobalBinDirs(npmGlobalPrefix, platform = getPlatform()) {
+  if (!npmGlobalPrefix) {
+    return [];
+  }
+  return platform === "win32" ? [npmGlobalPrefix] : [join(npmGlobalPrefix, "bin")];
+}
+
+function inferPackageManagerFromCommandPath(commandPath, {
+  bunGlobalBinDir,
+  npmGlobalPrefix,
+  platform = getPlatform()
+} = {}) {
+  if (installPathIsWithin(commandPath, bunGlobalBinDir)) {
+    return "bun";
+  }
+  if (getNpmGlobalBinDirs(npmGlobalPrefix, platform)
+    .some((binDir) => installPathIsWithin(commandPath, binDir))) {
+    return "npm";
+  }
+  return null;
+}
+
+function chooseCliInstallPackageManager({
+  commandPath,
+  availablePackageManagers = [],
+  bunGlobalBinDir,
+  npmGlobalPrefix,
+  platform = getPlatform(),
+  nodeAvailable = true,
+  supportedPackageManagers = ["bun", "npm"]
+} = {}) {
+  const supported = new Set(supportedPackageManagers);
+  const available = new Set(availablePackageManagers.filter((packageManager) => {
+    if (!supported.has(packageManager)) {
+      return false;
     }
+    return packageManager !== "bun" || nodeAvailable;
+  }));
+  const bunBlockedByMissingNode = !nodeAvailable
+    && supported.has("bun")
+    && availablePackageManagers.includes("bun");
+  const existingPackageManager = inferPackageManagerFromCommandPath(commandPath, {
+    bunGlobalBinDir,
+    npmGlobalPrefix,
+    platform
+  });
+
+  if (existingPackageManager && available.has(existingPackageManager)) {
+    return { packageManager: existingPackageManager, source: "existing" };
   }
-  nextAuth[envKey] = apiKey;
-  return nextAuth;
+  for (const packageManager of ["bun", "npm"]) {
+    if (available.has(packageManager)) {
+      return { packageManager, source: "available" };
+    }
+  }
+  return {
+    packageManager: null,
+    source: bunBlockedByMissingNode ? "missing-node" : (availablePackageManagers.length > 0 ? "unsupported" : "missing")
+  };
+}
+
+function buildCliToolInstallCommand(packageManager, { packageName, skipScripts = false }) {
+  if (packageManager === "npm") {
+    return {
+      command: "npm",
+      args: [
+        "install",
+        "-g",
+        ...(skipScripts ? ["--ignore-scripts"] : []),
+        packageName,
+        "--force"
+      ]
+    };
+  }
+  if (packageManager === "bun") {
+    return {
+      command: "bun",
+      args: [
+        "install",
+        "-g",
+        ...(skipScripts ? ["--ignore-scripts"] : []),
+        packageName
+      ]
+    };
+  }
+  throw new Error(`Unsupported package manager: ${packageManager}`);
+}
+
+function getPackageManagerInstallHelp(platform = getPlatform()) {
+  const platformLabel = {
+    darwin: "macOS",
+    win32: "Windows",
+    linux: "Linux"
+  }[platform] || platform;
+  return {
+    platformLabel,
+    mainlandUrl: "https://npmmirror.com/mirrors/node/",
+    officialUrl: "https://nodejs.org/en/download/"
+  };
+}
+
+function getAvailablePackageManagers() {
+  return ["bun", "npm"].filter((packageManager) => commandExists(packageManager));
+}
+
+function getBunGlobalBinDir(availablePackageManagers = getAvailablePackageManagers()) {
+  if (!availablePackageManagers.includes("bun")) {
+    return undefined;
+  }
+  return readCommandOutput("bun", ["pm", "bin", "-g"]) || join(home, ".bun", "bin");
+}
+
+function getNpmGlobalPrefix(availablePackageManagers = getAvailablePackageManagers()) {
+  if (!availablePackageManagers.includes("npm")) {
+    return undefined;
+  }
+  return readCommandOutput("npm", ["prefix", "-g"]);
 }
 
 async function installCliTool(tool) {
@@ -1960,12 +2501,20 @@ async function installCliTool(tool) {
     claude: {
       label: "Claude Code",
       command: "claude",
-      packageName: "@anthropic-ai/claude-code"
+      packageName: "@anthropic-ai/claude-code",
+      supportedPackageManagers: ["npm"],
+      installRequirement: "Claude Code 安装需要执行 postinstall；Bun 默认会阻止该脚本，因此需使用 npm。"
     },
     codex: {
       label: "Codex",
       command: "codex",
       packageName: "@openai/codex"
+    },
+    pi: {
+      label: "Pi",
+      command: "pi",
+      packageName: "@earendil-works/pi-coding-agent",
+      skipScripts: true
     }
   }[tool];
 
@@ -1973,10 +2522,40 @@ async function installCliTool(tool) {
     throw new Error(`Unsupported tool: ${tool}`);
   }
 
-  const installed = commandExists(toolConfig.command);
+  const commandPath = getCommandPath(toolConfig.command);
+  const installed = Boolean(commandPath);
+  const availablePackageManagers = getAvailablePackageManagers();
+  const packageManagerChoice = chooseCliInstallPackageManager({
+    commandPath,
+    availablePackageManagers,
+    bunGlobalBinDir: getBunGlobalBinDir(availablePackageManagers),
+    npmGlobalPrefix: getNpmGlobalPrefix(availablePackageManagers),
+    platform: getPlatform(),
+    nodeAvailable: commandExists("node"),
+    supportedPackageManagers: toolConfig.supportedPackageManagers
+  });
+
+  if (!packageManagerChoice.packageManager) {
+    const help = getPackageManagerInstallHelp();
+    p.log.warn(`未检测到可用于安装 ${toolConfig.label} 的包管理器。`);
+    if (packageManagerChoice.source === "missing-node") {
+      p.log.message(`${toolConfig.label} 是 Node CLI；使用 Bun 安装前也需要先安装 Node.js。`);
+    }
+    if (toolConfig.installRequirement) {
+      p.log.message(toolConfig.installRequirement);
+    }
+    p.log.message(`${help.platformLabel} 可先安装 Node.js/npm，再重新运行安装。`);
+    p.log.message(`中国大陆镜像: ${help.mainlandUrl}`);
+    p.log.message(`官方下载页: ${help.officialUrl}`);
+    return;
+  }
+
   if (installed) {
+    const managerMessage = packageManagerChoice.source === "existing"
+      ? `检测到原安装方式为 ${packageManagerChoice.packageManager}`
+      : `未识别原安装方式，将使用 ${packageManagerChoice.packageManager}`;
     const shouldUpdate = await confirmOrCancel({
-      message: `${toolConfig.label} 已检测到，是否继续执行 npm 强制安装/更新？`,
+      message: `${toolConfig.label} 已检测到（${managerMessage}），是否继续安装/更新？`,
       initialValue: false
     });
     if (!shouldUpdate) {
@@ -1985,10 +2564,11 @@ async function installCliTool(tool) {
     }
   }
 
+  const installCommand = buildCliToolInstallCommand(packageManagerChoice.packageManager, toolConfig);
   const s = p.spinner();
-  s.start(`正在安装 ${toolConfig.label}...`);
+  s.start(`正在使用 ${packageManagerChoice.packageManager} 安装 ${toolConfig.label}...`);
   try {
-    await runCommand("npm", ["install", "-g", toolConfig.packageName, "--force"]);
+    await runCommand(installCommand.command, installCommand.args);
     s.stop(`${toolConfig.label} 安装完成`);
   } catch (e) {
     s.cancel(c.red(`${toolConfig.label} 安装失败: ${e.message}`));
@@ -2020,6 +2600,12 @@ async function runFullInit(options) {
   if (await confirmOrCancel({ message: "是否配置 Codex 第三方 API？", initialValue: commandExists("codex") })) {
     await configureCodexApi();
   }
+  if (await confirmOrCancel({ message: "是否安装或更新 Pi CLI？", initialValue: false })) {
+    await installCliTool("pi");
+  }
+  if (await confirmOrCancel({ message: "是否配置 Pi gpt 自定义 API？", initialValue: commandExists("pi") })) {
+    await configurePiApi(options.agentsDir);
+  }
   if (await confirmOrCancel({ message: "是否填写 grok-search 环境变量？", initialValue: false })) {
     await configureGrokSearchEnv(options.agentsDir);
   }
@@ -2037,6 +2623,59 @@ async function runInteractiveMenu(options) {
   p.intro(c.bold(c.bgCyan(c.black(" AbelWorkflow Setup "))));
   p.log.message(`工作流目录: ${c.cyan(pathToLabel(options.agentsDir))}`);
 
+  const buildOption = (d) => {
+    const opt = { value: d.value, label: d.label };
+    if (d.hint) {
+      opt.hint = d.hint;
+    }
+    return opt;
+  };
+  const cliToolMenus = {
+    "pi-cli": {
+      tool: "pi",
+      title: "Pi",
+      actions: {
+        "pi-install": async () => installCliTool("pi"),
+        "pi-api": async () => configurePiApi(options.agentsDir)
+      }
+    },
+    "codex-cli": {
+      tool: "codex",
+      title: "Codex",
+      actions: {
+        "codex-install": async () => installCliTool("codex"),
+        "codex-api": async () => configureCodexApi()
+      }
+    },
+    "claude-cli": {
+      tool: "claude",
+      title: "Claude Code",
+      actions: {
+        "claude-install": async () => installCliTool("claude"),
+        "claude-api": async () => configureClaudeApi()
+      }
+    }
+  };
+  const runCliToolMenu = async ({ tool, title, actions }) => {
+    while (true) {
+      const choice = await p.select({
+        message: `请选择 ${title} 操作`,
+        options: buildCliToolMenuDescriptors(tool).map(buildOption),
+        initialValue: `${tool}-install`
+      });
+
+      if (p.isCancel(choice) || choice === "back") {
+        return;
+      }
+
+      const action = actions[choice];
+      if (!action) {
+        p.log.warn(`未知 CLI 工具菜单选项: ${choice}`);
+        continue;
+      }
+      await action();
+    }
+  };
   const menuActions = {
     "full-init": async () => runFullInit(options),
     install: async () => installManagedWorkflow({
@@ -2047,18 +2686,9 @@ async function runInteractiveMenu(options) {
     "grok-search": async () => configureGrokSearchEnv(options.agentsDir),
     context7: async () => configureContext7Env(options.agentsDir),
     "prompt-enhancer": async () => configurePromptEnhancerEnv(options.agentsDir),
-    "claude-install": async () => installCliTool("claude"),
-    "claude-api": async () => configureClaudeApi(),
-    "codex-install": async () => installCliTool("codex"),
-    "codex-api": async () => configureCodexApi()
-  };
-
-  const buildOption = (d) => {
-    const opt = { value: d.value, label: d.label };
-    if (d.hint) {
-      opt.hint = d.hint;
-    }
-    return opt;
+    "pi-cli": async () => runCliToolMenu(cliToolMenus["pi-cli"]),
+    "codex-cli": async () => runCliToolMenu(cliToolMenus["codex-cli"]),
+    "claude-cli": async () => runCliToolMenu(cliToolMenus["claude-cli"])
   };
 
   while (true) {
@@ -2169,11 +2799,17 @@ async function main() {
 
 export {
   applyClaudePermissionFeature,
+  buildCliToolInstallCommand,
   buildDefaultClaudeSettings,
   buildCodexConfigContent,
+  buildPiModelsConfig,
+  buildPiSettingsConfig,
+  chooseCliInstallPackageManager,
+  getPackageManagerInstallHelp,
   getAugmentContextEnginePromptOptions,
   getRunCommandSpawnOptions,
   hasPromptEnhancerApiConfig,
+  inferPackageManagerFromCommandPath,
   main,
   mergeCodexAuthData,
   mergeClaudeSettingsWithDefaults,
@@ -2181,5 +2817,8 @@ export {
   resolveAugmentContextEngineFeature,
   resolvePromptEnhancerMode,
   resolveExistingCodexApiConfig,
+  parsePiModelIds,
+  resolveExistingPiApiConfig,
+  stripJsonComments,
   updateTomlSectionFields
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abelworkflow",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "Install AbelWorkflow into ~/.agents and create Claude/Codex symlinks.",
   "type": "module",
   "scripts": {
@@ -17,6 +17,7 @@
     "README.md",
     "commands",
     "skills",
+    "extensions",
     ".skill-lock.json",
     ".gitignore"
   ],