abelworkflow 0.9.2 → 1.0.0

package/lib/cli/main.mjs

@@ -0,0 +1,385 @@
+import { resolve } from "node:path";
+import { stdin as input, stdout as output } from "node:process";
+import * as p from "@clack/prompts";
+import c from "picocolors";
+import { assertInteractiveMenuSupported, parseArgs } from "./args.mjs";
+import * as promptApi from "./prompts.mjs";
+import {
+  ensurePiResourcesLinked,
+  ensureSkillPresent,
+  installManagedWorkflow,
+  packageVersionFor
+} from "../installer/install.mjs";
+import {
+  finalizeProviderInstallMetadata,
+  getPreviousManagedCodexAgentFiles,
+  getPreviousManagedCodexAuthKeys,
+  readInstallMetadata,
+  writeInstallMetadata
+} from "../installer/state.mjs";
+import { configureClaudeApi } from "../providers/claude.mjs";
+import { configureCodexApi } from "../providers/codex.mjs";
+import { configurePiApi } from "../providers/pi.mjs";
+import {
+  configureContext7Env,
+  configureGrokSearchEnv
+} from "../providers/skills.mjs";
+import { commandExists, installCliTool } from "../tools/cli-installer.mjs";
+import { createPaths, defaultPaths, pathToLabel } from "../paths.mjs";
+
+const {
+  buildCliToolMenuDescriptors,
+  CancelledError,
+  confirmOrCancel,
+  interactiveMenuDefaultValue,
+  interactiveMenuDescriptors
+} = promptApi;
+
+const installReportSummaryFields = [
+  ["新增", "created"],
+  ["更新", "updated"],
+  ["未变", "unchanged"],
+  ["删除", "removed"],
+  ["链接", "linked"],
+  ["保留", "preserved"],
+  ["冲突", "conflicts"]
+];
+
+function uniqueReportPaths(paths = []) {
+  return [...new Set(paths)];
+}
+
+function presentInstallReport(report, reportOutput) {
+  const pathsByField = Object.fromEntries(installReportSummaryFields.map(([, field]) => [
+    field,
+    uniqueReportPaths(report[field])
+  ]));
+  reportOutput.message(`安装摘要：${installReportSummaryFields
+    .map(([label, field]) => `${label} ${pathsByField[field].length}`)
+    .join("，")}`);
+
+  for (const [message, field] of [
+    ["已更新", "updated"],
+    ["已跳过", "unchanged"]
+  ]) {
+    const paths = pathsByField[field];
+    if (paths.length > 0) {
+      reportOutput.message([
+        `${message} ${paths.length} 个${field === "unchanged" ? "未变化" : ""}文件：`,
+        ...paths.map((path) => `- ${path}`)
+      ].join("\n"));
+    }
+  }
+
+  const conflictPaths = pathsByField.conflicts;
+  const conflictSet = new Set(conflictPaths);
+  const preservedPaths = pathsByField.preserved.filter((path) => !conflictSet.has(path));
+  if (conflictPaths.length > 0) {
+    reportOutput.warn([
+      `检测到 ${conflictPaths.length} 个冲突，相关路径已保留：`,
+      ...conflictPaths.map((path) => `- ${path}`),
+      "确认可覆盖后，请在原安装命令中加入 `--force` 后重试。"
+    ].join("\n"));
+  }
+  if (preservedPaths.length > 0) {
+    reportOutput.message([
+      `另有 ${preservedPaths.length} 个非冲突路径已保留：`,
+      ...preservedPaths.map((path) => `- ${path}`)
+    ].join("\n"));
+  }
+}
+
+async function runManagedInstall(options) {
+  const report = await installManagedWorkflow(options);
+  presentInstallReport(report, p.log);
+  return report;
+}
+
+async function ensureSkillPresentWithReport(paths, skillName) {
+  const report = await ensureSkillPresent(paths, skillName);
+  presentInstallReport(report, p.log);
+  return report;
+}
+
+async function ensurePiResourcesLinkedWithReport(paths) {
+  const report = await ensurePiResourcesLinked(paths);
+  presentInstallReport(report, p.log);
+  return report;
+}
+
+function printHelp() {
+  console.log(`${c.bold("AbelWorkflow")} ${c.cyan("installer")}
+
+${c.bold("Usage:")}
+  ${c.cyan("npx abelworkflow")}
+  ${c.cyan("npx abelworkflow init")}
+  ${c.cyan("npx abelworkflow install")}
+  ${c.cyan("npx abelworkflow install --force")}
+  ${c.cyan("npx abelworkflow install --link-only")}
+  ${c.cyan("npx abelworkflow install --agents-dir /custom/path")}
+  ${c.cyan("npx abelworkflow --non-interactive")}
+
+${c.bold("Default behavior:")}
+  - npx abelworkflow: open the interactive setup menu.
+  - npx abelworkflow install: sync managed files and links explicitly.
+  - --non-interactive: auto-execute install (skip interactive menu); auto-enabled in CI.
+`);
+}
+
+async function configureCodexForPaths(paths) {
+  const metadata = await readInstallMetadata(paths);
+  const packageVersion = await packageVersionFor(paths, metadata);
+  const result = await configureCodexApi(paths, promptApi, {
+    managedAuthKeys: getPreviousManagedCodexAuthKeys(metadata),
+    managedCodexAgentFiles: getPreviousManagedCodexAgentFiles(metadata)
+  });
+  await writeInstallMetadata(paths, finalizeProviderInstallMetadata({
+    previousMetadata: metadata,
+    packageVersion,
+    overrides: {
+      managedCodexAuthKeys: result.managedAuthKeys,
+      managedCodexAgentFiles: result.managedCodexAgentFiles
+    }
+  }));
+}
+
+async function configureClaudeForPaths(paths) {
+  const metadata = await readInstallMetadata(paths);
+  const packageVersion = await packageVersionFor(paths, metadata);
+  await configureClaudeApi(paths, promptApi);
+  await writeInstallMetadata(paths, finalizeProviderInstallMetadata({
+    previousMetadata: metadata,
+    packageVersion
+  }));
+}
+
+async function runFullInit(options) {
+  const installReport = await runManagedInstall({
+    paths: options.paths,
+    force: options.force,
+    relinkOnly: false
+  });
+
+  if (await confirmOrCancel({ message: "是否安装或更新 Claude Code CLI？", initialValue: false })) {
+    await installCliTool("claude", promptApi);
+  }
+  if (await confirmOrCancel({ message: "是否配置 Claude Code 第三方 API？", initialValue: commandExists("claude") })) {
+    await configureClaudeForPaths(options.paths);
+  }
+  if (await confirmOrCancel({ message: "是否安装或更新 Codex CLI？", initialValue: false })) {
+    await installCliTool("codex", promptApi);
+  }
+  if (await confirmOrCancel({ message: "是否配置 Codex 第三方 API？", initialValue: commandExists("codex") })) {
+    await configureCodexForPaths(options.paths);
+  }
+  if (await confirmOrCancel({ message: "是否安装或更新 Pi CLI？", initialValue: false })) {
+    await installCliTool("pi", promptApi);
+  }
+  if (await confirmOrCancel({ message: "是否配置 Pi 当前有效 Provider API？", initialValue: commandExists("pi") })) {
+    await configurePiApi(options.paths, ensurePiResourcesLinked, promptApi);
+  }
+  if (await confirmOrCancel({ message: "是否填写 grok-search 环境变量？", initialValue: false })) {
+    await configureGrokSearchEnv(options.paths, (paths) => ensureSkillPresent(paths, "grok-search"), promptApi);
+  }
+  if (await confirmOrCancel({ message: "是否填写 context7-auto-research 环境变量？", initialValue: false })) {
+    await configureContext7Env(options.paths, (paths) => ensureSkillPresent(paths, "context7-auto-research"), promptApi);
+  }
+
+  const conflictCount = uniqueReportPaths(installReport.conflicts).length;
+  if (conflictCount > 0) {
+    p.log.warn(c.yellow(`AbelWorkflow 初始化流程结束；已保留 ${conflictCount} 个工作流冲突`));
+  } else {
+    p.log.success(c.green("AbelWorkflow 完整初始化完成"));
+  }
+}
+
+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", promptApi),
+        "pi-api": async () => configurePiApi(options.paths, ensurePiResourcesLinkedWithReport, promptApi)
+      }
+    },
+    "codex-cli": {
+      tool: "codex",
+      title: "Codex",
+      actions: {
+        "codex-install": async () => installCliTool("codex", promptApi),
+        "codex-api": async () => configureCodexForPaths(options.paths)
+      }
+    },
+    "claude-cli": {
+      tool: "claude",
+      title: "Claude Code",
+      actions: {
+        "claude-install": async () => installCliTool("claude", promptApi),
+        "claude-api": async () => configureClaudeForPaths(options.paths)
+      }
+    }
+  };
+  const runCliToolMenu = async ({ tool, title, actions }) => {
+    while (true) {
+      const choice = await p.select({
+        message: `请选择 ${title} 操作`,
+        options: buildCliToolMenuDescriptors(tool).map(buildOption),
+        initialValue: `${tool}-api`
+      });
+
+      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 () => runManagedInstall({
+      paths: options.paths,
+      force: options.force,
+      relinkOnly: options.relinkOnly
+    }),
+    "grok-search": async () => configureGrokSearchEnv(options.paths, (paths) => ensureSkillPresentWithReport(paths, "grok-search"), promptApi),
+    context7: async () => configureContext7Env(options.paths, (paths) => ensureSkillPresentWithReport(paths, "context7-auto-research"), promptApi),
+    "pi-cli": async () => runCliToolMenu(cliToolMenus["pi-cli"]),
+    "codex-cli": async () => runCliToolMenu(cliToolMenus["codex-cli"]),
+    "claude-cli": async () => runCliToolMenu(cliToolMenus["claude-cli"])
+  };
+
+  while (true) {
+    const selectOptions = [
+      ...interactiveMenuDescriptors
+        .filter((d) => d.group === "main")
+        .map(buildOption),
+      { value: "__sep_skills__", label: "─── 技能配置 ───", disabled: true },
+      ...interactiveMenuDescriptors
+        .filter((d) => d.group === "skill")
+        .map(buildOption),
+      { value: "__sep_cli__", label: "─── CLI 工具 ───", disabled: true },
+      ...interactiveMenuDescriptors
+        .filter((d) => d.group === "cli")
+        .map(buildOption),
+      { value: "__sep_exit__", label: "────────────────", disabled: true },
+      ...interactiveMenuDescriptors
+        .filter((d) => d.group === "exit")
+        .map(buildOption)
+    ];
+
+    const choice = await p.select({
+      message: "请选择操作",
+      options: selectOptions,
+      initialValue: interactiveMenuDefaultValue
+    });
+
+    if (p.isCancel(choice)) {
+      p.outro(c.gray("已退出"));
+      return;
+    }
+    if (choice === "exit") {
+      p.outro(c.gray("已退出"));
+      return;
+    }
+
+    const action = menuActions[choice];
+    if (!action) {
+      p.log.warn(`未知菜单选项: ${choice}`);
+      continue;
+    }
+
+    try {
+      await action();
+    } catch (error) {
+      if (error instanceof CancelledError) {
+        p.log.warn("操作已取消，返回菜单");
+        continue;
+      }
+      throw error;
+    }
+  }
+}
+
+async function main(argv, runtime = {}) {
+  const options = parseArgs(argv, {
+    defaultAgentsDir: runtime.defaultAgentsDir || defaultPaths.agentsDir,
+    resolvePath: runtime.resolvePath || resolve
+  });
+
+  if (options.command === "help") {
+    printHelp();
+    return 0;
+  }
+
+  if (options.command === "menu" && options.nonInteractive) {
+    console.log("检测到非交互模式，自动执行工作流安装...");
+    options.command = "install";
+  }
+
+  if (options.command === "install") {
+    try {
+      await runManagedInstall({
+        ...options,
+        paths: createPaths({
+          homeDir: runtime.homeDir ?? defaultPaths.homeDir,
+          packageRoot: runtime.packageRoot ?? defaultPaths.packageRoot,
+          agentsDir: options.agentsDir
+        })
+      });
+    } catch (error) {
+      const message = `操作失败: ${error.message || String(error)}`;
+      if (options.nonInteractive) console.error(message);
+      else p.outro(c.red(message));
+      return 1;
+    }
+    return 0;
+  }
+
+  assertInteractiveMenuSupported({
+    command: options.command,
+    inputIsTTY: runtime.inputIsTTY ?? input.isTTY,
+    outputIsTTY: runtime.outputIsTTY ?? output.isTTY,
+    nonInteractive: options.nonInteractive
+  });
+
+  try {
+    await runInteractiveMenu({
+      ...options,
+      paths: createPaths({
+        homeDir: runtime.homeDir ?? defaultPaths.homeDir,
+        packageRoot: runtime.packageRoot ?? defaultPaths.packageRoot,
+        agentsDir: options.agentsDir
+      })
+    });
+    return 0;
+  } catch (error) {
+    const message = `操作失败: ${error.message || String(error)}`;
+    if (options.nonInteractive) console.error(message);
+    else p.outro(c.red(message));
+    return 1;
+  }
+}
+
+export {
+  main,
+  presentInstallReport,
+  printHelp,
+  runFullInit,
+  runInteractiveMenu
+};

package/lib/cli/prompts.mjs

@@ -0,0 +1,106 @@
+import * as p from "@clack/prompts";
+
+const interactiveMenuDescriptors = [
+  { value: "full-init", label: "完整初始化", hint: "同步 + 安装 + 配置", group: "main" },
+  { value: "install", label: "仅同步工作流", group: "main" },
+  { value: "grok-search", label: "配置 grok-search", hint: "技能", group: "skill" },
+  { value: "context7", label: "配置 context7-auto-research", hint: "技能", group: "skill" },
+  { 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-api", label: "配置 Pi API" },
+    { value: "pi-install", label: "安装/更新 Pi" },
+    { value: "back", label: "返回上一级" }
+  ],
+  codex: [
+    { value: "codex-api", label: "配置 Codex API" },
+    { value: "codex-install", label: "安装/更新 Codex" },
+    { value: "back", label: "返回上一级" }
+  ],
+  claude: [
+    { value: "claude-api", label: "配置 Claude Code API" },
+    { value: "claude-install", label: "安装/更新 Claude Code" },
+    { value: "back", label: "返回上一级" }
+  ]
+};
+class CancelledError extends Error {
+  constructor(message = "用户取消") {
+    super(message);
+    this.name = "CancelledError";
+  }
+}
+
+function buildCliToolMenuDescriptors(tool) {
+  const descriptors = cliToolMenuDescriptorMap[tool];
+  if (!descriptors) throw new Error(`Unknown CLI tool: ${tool}`);
+  return descriptors.map((descriptor) => ({ ...descriptor }));
+}
+
+function required(message = "此项不能为空") {
+  return (value) => {
+    if (value === undefined || value === null || (typeof value === "string" && value.trim() === "")) return message;
+  };
+}
+
+function requiredUnlessExisting(existingValue, message = "此项不能为空") {
+  return (value) => {
+    if ((value === undefined || value === null || (typeof value === "string" && value.trim() === "")) && !existingValue) return message;
+  };
+}
+
+function resolvePasswordValue(userInput, existingValue) {
+  if (typeof userInput === "string") {
+    const trimmed = userInput.trim();
+    if (trimmed === "") {
+      if (typeof existingValue === "string" && existingValue.trim() === "") return undefined;
+      return existingValue || undefined;
+    }
+    return trimmed === "-" ? undefined : trimmed;
+  }
+  if (typeof existingValue === "string" && existingValue.trim() === "") return undefined;
+  return existingValue || undefined;
+}
+
+function passwordPromptOptions(message, existingValue, validate) {
+  const configured = typeof existingValue === "string" && existingValue.trim() !== "";
+  return {
+    message: `${message}${configured ? "（已配置，直接回车保留；输入 - 清除）" : "（输入 - 清除）"}`,
+    mask: "*",
+    ...(validate ? { validate } : {})
+  };
+}
+
+function assertNotCancelled(value) {
+  if (p.isCancel(value)) throw new CancelledError();
+}
+
+async function confirmOrCancel({ message, initialValue = false }) {
+  const value = await p.confirm({ message, initialValue, active: "是", inactive: "否" });
+  assertNotCancelled(value);
+  return value;
+}
+
+async function selectOrCancel(options) {
+  const value = await p.select(options);
+  assertNotCancelled(value);
+  return value;
+}
+
+export {
+  assertNotCancelled,
+  buildCliToolMenuDescriptors,
+  CancelledError,
+  confirmOrCancel,
+  interactiveMenuDefaultValue,
+  interactiveMenuDescriptors,
+  passwordPromptOptions,
+  required,
+  requiredUnlessExisting,
+  resolvePasswordValue,
+  selectOrCancel
+};

package/lib/config/dotenv.mjs

@@ -0,0 +1,102 @@
+function parseDotenvAssignment(line) {
+  const match = line.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=/u);
+  if (!match) return null;
+  let value = line.slice(match[0].length).trim();
+  if ((value.startsWith("\"") && value.endsWith("\"")) || (value.startsWith("'") && value.endsWith("'"))) {
+    value = value.slice(1, -1);
+  }
+  return { key: match[1], value };
+}
+
+function parseDotenv(content) {
+  const values = {};
+  for (const rawLine of content.split(/\r?\n/u)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const assignment = parseDotenvAssignment(line);
+    if (assignment && !Object.hasOwn(values, assignment.key)) {
+      values[assignment.key] = assignment.value;
+    }
+  }
+  return values;
+}
+
+function quoteEnvValue(value) {
+  const text = String(value);
+  if (/[\r\n]/u.test(text)) throw new Error("Environment values cannot contain newlines");
+  if (/^[A-Za-z0-9_./:@-]+$/u.test(text)) return text;
+  if (!text.includes("'")) return `'${text}'`;
+  if (!text.includes("\"")) return `"${text}"`;
+  if (text.trim() === text && !(
+    (text.startsWith("'") && text.endsWith("'"))
+    || (text.startsWith("\"") && text.endsWith("\""))
+  )) return text;
+  throw new Error("Environment value cannot be represented without changing its meaning");
+}
+
+function renderDotenv(values) {
+  const lines = Object.entries(values)
+    .filter(([, value]) => value !== undefined && value !== null && value !== "")
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([key, value]) => `${key}=${quoteEnvValue(String(value))}`);
+  return lines.length ? `${lines.join("\n")}\n` : "";
+}
+
+function getDotenvLines(content) {
+  const lines = [];
+  for (let start = 0; start < content.length;) {
+    const newline = content.indexOf("\n", start);
+    const end = newline === -1 ? content.length : newline + 1;
+    const raw = content.slice(start, end);
+    const lineEnding = raw.endsWith("\r\n") ? "\r\n" : raw.endsWith("\n") ? "\n" : "";
+    lines.push({
+      assignment: parseDotenvAssignment(lineEnding ? raw.slice(0, -lineEnding.length) : raw),
+      lineEnding,
+      raw
+    });
+    start = end;
+  }
+  return lines;
+}
+
+function updateDotenvContent(content, updates) {
+  const updateMap = new Map(Object.entries(updates));
+  const lines = getDotenvLines(content);
+  const counts = new Map();
+  for (const { assignment } of lines) {
+    if (assignment && updateMap.has(assignment.key)) {
+      counts.set(assignment.key, (counts.get(assignment.key) ?? 0) + 1);
+    }
+  }
+
+  const seen = new Set();
+  let next = "";
+  for (const line of lines) {
+    const key = line.assignment?.key;
+    if (!key || !updateMap.has(key)) {
+      next += line.raw;
+      continue;
+    }
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const value = updateMap.get(key);
+    if (value === null || value === undefined || value === "") continue;
+    const desired = String(value);
+    if (counts.get(key) === 1 && line.assignment.value === desired) {
+      next += line.raw;
+    } else {
+      next += `${key}=${quoteEnvValue(desired)}${line.lineEnding}`;
+    }
+  }
+
+  const missing = [...updateMap].filter(([key, value]) => (
+    !seen.has(key) && value !== null && value !== undefined && value !== ""
+  ));
+  if (!missing.length) return next;
+  const lineEnding = content.includes("\r\n") ? "\r\n" : "\n";
+  if (next && !next.endsWith("\n")) next += lineEnding;
+  next += `${missing.map(([key, value]) => `${key}=${quoteEnvValue(String(value))}`).join(lineEnding)}${lineEnding}`;
+  return next;
+}
+
+export { parseDotenv, quoteEnvValue, renderDotenv, updateDotenvContent };

package/lib/config/jsonc.mjs

@@ -0,0 +1,80 @@
+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;
+      }
+      if (i >= content.length) {
+        throw new SyntaxError("Unterminated block comment");
+      }
+      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;
+}
+
+export { stripJsonComments, stripJsonTrailingCommas };